diff --git a/.github/workflows/continuous-integration-workflow-32bit.yml b/.github/workflows/continuous-integration-workflow-32bit.yml
new file mode 100644
index 0000000000..7fab3b0e62
--- /dev/null
+++ b/.github/workflows/continuous-integration-workflow-32bit.yml
@@ -0,0 +1,37 @@
+name: github-Linux-32bit
+on: [push, pull_request]
+
+concurrency:
+  group: ${ {github.event_name }}-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{github.event_name == 'pull_request'}}
+
+jobs:
+  CI-32bit:
+    name: Linux-32bit
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/kokkos/ci-containers/ubuntu:latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: install_multilib
+        run: sudo apt-get update && sudo apt-get install -y gcc-multilib g++-multilib gfortran-multilib
+      - name: Configure Kokkos
+        run: |
+          cmake -B builddir \
+            -DKokkos_ENABLE_OPENMP=ON \
+            -DKokkos_ENABLE_TESTS=ON \
+            -DKokkos_ENABLE_BENCHMARKS=ON \
+            -DKokkos_ENABLE_EXAMPLES=ON \
+            -DKokkos_ENABLE_DEPRECATED_CODE_4=ON \
+            -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF \
+            -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
+            -DCMAKE_CXX_FLAGS="-Werror -m32 -DKOKKOS_IMPL_32BIT" \
+            -DCMAKE_CXX_COMPILER=g++ \
+            -DCMAKE_BUILD_TYPE=RelWithDebInfo
+      - name: Build
+        run: |
+          cmake --build builddir --parallel 2
+      - name: Tests
+        working-directory: builddir
+        run: ctest --output-on-failure
diff --git a/.github/workflows/continuous-integration-workflow-hpx.yml b/.github/workflows/continuous-integration-workflow-hpx.yml
index 35bb5bb2cb..0c7abd2fc1 100644
--- a/.github/workflows/continuous-integration-workflow-hpx.yml
+++ b/.github/workflows/continuous-integration-workflow-hpx.yml
@@ -13,7 +13,7 @@ jobs:
 
     steps:
       - name: checkout code
-        uses: actions/checkout@v2.2.0
+        uses: actions/checkout@v3
         with:
           path: kokkos
       - name: setup hpx dependencies
@@ -26,12 +26,12 @@ jobs:
             libboost-all-dev \
             ninja-build
       - name: checkout hpx
-        uses: actions/checkout@v2.2.0
+        uses: actions/checkout@v3
         with:
           repository: STELLAR-GROUP/hpx
-          ref: 1.7.1
+          ref: 1.8.0
           path: hpx
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
         id:   cache-hpx
         with:
           path:         ./hpx/install
@@ -69,12 +69,10 @@ jobs:
             -DCMAKE_CXX_COMPILER=clang++ \
             -DCMAKE_CXX_FLAGS="-Werror" \
             -DHPX_ROOT=$PWD/../../hpx/install \
-            -DKokkos_ARCH_NATIVE=ON \
             -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
             -DKokkos_ENABLE_DEPRECATED_CODE_4=OFF \
             -DKokkos_ENABLE_EXAMPLES=ON \
             -DKokkos_ENABLE_HPX=ON \
-            -DKokkos_ENABLE_HPX_ASYNC_DISPATCH=ON \
             -DKokkos_ENABLE_SERIAL=OFF \
             -DKokkos_ENABLE_TESTS=ON \
             ..
diff --git a/.github/workflows/continuous-integration-workflow.yml b/.github/workflows/continuous-integration-workflow.yml
index 55b8817948..741f6b2746 100644
--- a/.github/workflows/continuous-integration-workflow.yml
+++ b/.github/workflows/continuous-integration-workflow.yml
@@ -12,30 +12,31 @@ jobs:
       matrix:
         distro: ['fedora:latest', 'fedora:rawhide', 'ubuntu:latest']
         cxx: ['g++', 'clang++']
+        cxx_extra_flags: ['']
         cmake_build_type: ['Release', 'Debug']
         backend: ['OPENMP']
         clang-tidy: ['']
         include:
           - distro: 'fedora:intel'
             cxx: 'icpc'
+            cxx_extra_flags: '-diag-disable=177,10441'
             cmake_build_type: 'Release'
             backend: 'OPENMP'
-            clang-tidy: ''
           - distro: 'fedora:intel'
             cxx: 'icpc'
+            cxx_extra_flags: '-diag-disable=177,10441'
             cmake_build_type: 'Debug'
             backend: 'OPENMP'
-            clang-tidy: ''
           - distro: 'fedora:intel'
             cxx: 'icpx'
+            cxx_extra_flags: '-fp-model=precise -Wno-pass-failed'
             cmake_build_type: 'Release'
             backend: 'OPENMP'
-            clang-tidy: ''
           - distro: 'fedora:intel'
             cxx: 'icpx'
+            cxx_extra_flags: '-fp-model=precise -Wno-pass-failed'
             cmake_build_type: 'Debug'
             backend: 'OPENMP'
-            clang-tidy: ''
           - distro: 'ubuntu:latest'
             cxx: 'clang++'
             cmake_build_type: 'RelWithDebInfo'
@@ -48,11 +49,9 @@ jobs:
     runs-on: ubuntu-latest
     container:
       image: ghcr.io/kokkos/ci-containers/${{ matrix.distro }}
-      # see https://github.com/actions/virtual-environments/issues/3812
-      options: --security-opt seccomp=unconfined
     steps:
       - name: Checkout desul
-        uses: actions/checkout@v2.2.0
+        uses: actions/checkout@v3
         with:
           repository: desul/desul
           ref: 477da9c8f40f8db369c28dd3f93a67e376d8511b
@@ -67,21 +66,17 @@ jobs:
           cmake -DDESUL_ENABLE_TESTS=OFF -DCMAKE_INSTALL_PREFIX=/usr/desul-install ..
           sudo cmake --build . --target install --parallel 2
       - name: Checkout code
-        uses: actions/checkout@v2.2.0
-      - uses: actions/cache@v2
+        uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
-          path: ~/.ccache
-          key: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.cmake_build_type }}-${{ matrix.openmp }}-${github.ref}-${{ github.sha }}
-          restore-keys: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.cmake_build_type }}-${{ matrix.openmp }}-${{github.ref}}
+          path: ~/.cache/ccache
+          key: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.cmake_build_type }}-${{ matrix.openmp }}-${{ github.ref }}-${{ github.sha }}
+          restore-keys: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.cmake_build_type }}-${{ matrix.openmp }}-${{ github.ref }}
       - name: maybe_disable_death_tests
         if: ${{ matrix.distro == 'fedora:rawhide' }}
         run: echo "GTEST_FILTER=-*DeathTest*" >> $GITHUB_ENV
-# Re-enable when latest is F37+
-#      - name: maybe_use_flang
-#        if: ${{ matrix.cxx == 'clang++' && startsWith(matrix.distro,'fedora:') }}
-#        run: echo "FC=flang" >> $GITHUB_ENV
       - name: maybe_use_flang_new
-        if: ${{ matrix.cxx == 'clang++' && startsWith(matrix.distro,'fedora:rawhide') }}
+        if: ${{ matrix.cxx == 'clang++' && startsWith(matrix.distro,'fedora:') }}
         run: echo "FC=flang-new" >> $GITHUB_ENV
       - name: maybe_use_external_gtest
         if: ${{ matrix.distro == 'ubuntu:latest' }}
@@ -95,7 +90,6 @@ jobs:
             -DCMAKE_INSTALL_PREFIX=/usr \
             ${{ matrix.clang-tidy }} \
             -Ddesul_ROOT=/usr/desul-install/ \
-            -DKokkos_ARCH_NATIVE=ON \
             -DKokkos_ENABLE_DESUL_ATOMICS_EXTERNAL=ON \
             -DKokkos_ENABLE_HWLOC=ON \
             -DKokkos_ENABLE_${{ matrix.backend }}=ON \
@@ -104,7 +98,10 @@ jobs:
             -DKokkos_ENABLE_EXAMPLES=ON \
             -DKokkos_ENABLE_DEPRECATED_CODE_4=ON \
             -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF \
+            -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
+            -DCMAKE_CXX_FLAGS="-Werror ${{ matrix.cxx_extra_flags }}" \
             -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -DCMAKE_BUILD_TYPE=${{ matrix.cmake_build_type }}
       - name: Build
         run: |
@@ -114,6 +111,12 @@ jobs:
       - name: Tests
         working-directory: builddir
         run: ctest --output-on-failure
+      - name: Test linking against build dir
+        working-directory: example/build_cmake_installed
+        run: |
+          cmake -B builddir_buildtree -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} -DKokkos_ROOT=../../builddir
+          cmake --build builddir_buildtree
+          cmake --build builddir_buildtree --target test
       - name: Test DESTDIR Install
         run: DESTDIR=${PWD}/install cmake --build builddir --target install && rm -rf ${PWD}/install/usr && rmdir ${PWD}/install
       - name: Install
diff --git a/.github/workflows/osx.yml b/.github/workflows/osx.yml
index dae8343f20..0ff3266848 100644
--- a/.github/workflows/osx.yml
+++ b/.github/workflows/osx.yml
@@ -24,14 +24,13 @@ jobs:
             cmake_build_type: "Release"
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: configure
         run:
           cmake -B build .
             -DKokkos_ENABLE_${{ matrix.backend }}=On
             -DCMAKE_CXX_FLAGS="-Werror"
             -DCMAKE_CXX_STANDARD=17
-            -DKokkos_ARCH_NATIVE=ON
             -DKokkos_ENABLE_COMPILER_WARNINGS=ON
             -DKokkos_ENABLE_DEPRECATED_CODE_4=OFF
             -DKokkos_ENABLE_TESTS=On
diff --git a/.github/workflows/performance-benchmark.yml b/.github/workflows/performance-benchmark.yml
new file mode 100644
index 0000000000..205239e043
--- /dev/null
+++ b/.github/workflows/performance-benchmark.yml
@@ -0,0 +1,61 @@
+name: github-benchmarks
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+
+jobs:
+  CI:
+    continue-on-error: true
+    strategy:
+      matrix:
+        distro: ['ubuntu:latest']
+        cxx: ['g++', 'clang++']
+        backend: ['OPENMP']
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/kokkos/ci-containers/${{ matrix.distro }}
+    env:
+      BUILD_ID: ${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.backend }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - uses: actions/cache@v3
+        with:
+          path: ~/.cache/ccache
+          key: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.backend }}-${{ github.ref }}-${{ github.sha }}
+          restore-keys: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.backend }}-${{ github.ref }}
+      - name: Configure Kokkos
+        run: |
+          cmake -B builddir \
+            -DKokkos_ENABLE_HWLOC=ON \
+            -DKokkos_ENABLE_${{ matrix.backend }}=ON \
+            -DKokkos_ENABLE_BENCHMARKS=ON \
+            -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DCMAKE_BUILD_TYPE=Release
+      - name: Build
+        run: |
+          ccache -z
+          NUM_CPU=$(grep -c processor /proc/cpuinfo)
+          cmake --build builddir --parallel ${NUM_CPU}
+          ccache -s
+      - name: Tests
+        working-directory: builddir
+        run: ctest --output-on-failure
+      - name: Gather benchmark results
+        run: |
+          mkdir ${{ env.BUILD_ID }}
+          find builddir/core/perf_test/ -name "*.json" -exec mv {} ${{ env.BUILD_ID }}/  \;
+      - name: Push benchmark results
+        if: ${{ github.ref == 'refs/heads/develop' }}
+        uses: dmnemec/copy_file_to_another_repo_action@main
+        env:
+          API_TOKEN_GITHUB: ${{ secrets.DALG24_PUSH_BENCHMARK_RESULTS }}
+        with:
+          source_file: ${{ env.BUILD_ID }}
+          destination_repo: 'kokkos/kokkos-benchmark-results'
+          destination_branch: 'main'
+          user_email: 'kokkos@users.noreply.github.com'
+          user_name: 'Kokkos Developers'
diff --git a/.jenkins b/.jenkins
index 1775a57d3b..c7d8ce533d 100644
--- a/.jenkins
+++ b/.jenkins
@@ -17,7 +17,7 @@ pipeline {
                 dockerfile {
                     filename 'Dockerfile.clang'
                     dir 'scripts/docker'
-                    label 'nvidia-docker || docker'
+                    label 'nvidia-docker || rocm-docker || docker'
                     args '-v /tmp/ccache.kokkos:/tmp/ccache'
                 }
             }
@@ -101,12 +101,14 @@ pipeline {
                     }
                     steps {
                         sh 'ccache --zero-stats'
-                        sh '''rm -rf build && mkdir -p build && cd build && \
+                        sh '''. /opt/intel/oneapi/setvars.sh --include-intel-llvm && \
+                              rm -rf build && mkdir -p build && cd build && \
                               cmake \
                                 -DCMAKE_BUILD_TYPE=Release \
                                 -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-                                -DCMAKE_CXX_COMPILER=clang++ \
-                                -DCMAKE_CXX_FLAGS="-fsycl-device-code-split=per_kernel -Werror -Wno-gnu-zero-variadic-macro-arguments -Wno-linker-warnings" \
+                                -DCMAKE_CXX_COMPILER=/opt/intel/oneapi/compiler/2023.0.0/linux/bin-llvm/clang++ \
+                                -DCMAKE_CXX_FLAGS="-fsycl-device-code-split=per_kernel -Wno-deprecated-declarations -Werror -Wno-gnu-zero-variadic-macro-arguments -Wno-unknown-cuda-version -Wno-sycl-target" \
+                                -DKOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED=0 \
                                 -DKokkos_ARCH_NATIVE=ON \
                                 -DKokkos_ARCH_VOLTA70=ON \
                                 -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
@@ -343,7 +345,7 @@ pipeline {
                                 --with-cuda \
                                 --with-cuda-options=enable_lambda \
                                 --arch=Volta70 \
-                              .. && \
+                              && \
                               make test -j8'''
                     }
                     post {
@@ -487,6 +489,7 @@ pipeline {
                                 -DCMAKE_CXX_FLAGS=-Werror \
                                 -DKokkos_ARCH_NATIVE=ON \
                                 -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
+                                -DKokkos_ENABLE_DEPRECATED_CODE_3=ON \
                                 -DKokkos_ENABLE_DEPRECATED_CODE_4=ON \
                                 -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF \
                                 -DKokkos_ENABLE_TESTS=ON \
diff --git a/.jenkins_nightly b/.jenkins_nightly
new file mode 100644
index 0000000000..8bcdb75a2a
--- /dev/null
+++ b/.jenkins_nightly
@@ -0,0 +1,76 @@
+pipeline {
+    agent none
+
+    options {
+        timeout(time: 6, unit: 'HOURS')
+    }
+
+    stages {
+        stage('Build') {
+            parallel {
+                stage('spack-serial') {
+                    agent {
+                        docker {
+                          image 'ubuntu:22.04'
+                          label 'docker'
+                        }
+                    }
+                    steps {
+                        sh '''
+                          DEBIAN_FRONTEND=noninteractive && \
+                          apt-get update && apt-get upgrade -y && apt-get install -y \
+                          build-essential \
+                          wget \
+                          git \
+                          bc \
+                          python3-dev \
+                          && \
+                          apt-get clean && rm -rf /var/lib/apt/lists/*
+
+                          rm -rf spack && \
+                          git clone https://github.com/spack/spack.git && \
+                          . ./spack/share/spack/setup-env.sh && \
+                          spack install kokkos@develop+tests && \
+                          spack load cmake && \
+                          spack test run kokkos && \
+                          spack test results -l
+                          '''
+                    }      
+                }   
+                stage('spack-cuda') {
+                    agent {
+                        docker {
+                          image 'nvidia/cuda:12.1.0-devel-ubuntu22.04'
+                          label 'nvidia-docker && ampere'
+                        }
+                    }
+                    steps {
+                        sh '''
+                          DEBIAN_FRONTEND=noninteractive && \
+                          apt-get update && apt-get upgrade -y && apt-get install -y \
+                          build-essential \
+                          wget \
+                          git \
+                          bc \
+                          python3-dev \
+                          gfortran \
+                          && \
+                          apt-get clean && rm -rf /var/lib/apt/lists/*
+
+                          rm -rf spack && \
+                          git clone https://github.com/spack/spack.git && \
+                          . ./spack/share/spack/setup-env.sh && \
+                          spack install kokkos@develop+cuda+wrapper+tests cuda_arch=80 ^cuda@12.1.0 && \
+                          spack load cmake  && \
+                          spack load kokkos-nvcc-wrapper && \
+                          spack load cuda && \
+                          spack load kokkos && \
+                          spack test run kokkos && \
+                          spack test results -l
+                          '''
+                    }      
+                }   
+            }
+        }
+    }
+}
diff --git a/BUILD.md b/BUILD.md
index b0d603e6db..f80320e78b 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -111,247 +111,4 @@ For dev-build details, consult the kokkos-spack repository [README](https://gith
 
 # Kokkos Keyword Listing
 
-## Device Backends
-Device backends can be enabled by specifying `-DKokkos_ENABLE_X`.
-
-* Kokkos_ENABLE_CUDA
-    * Whether to build CUDA backend
-    * BOOL Default: OFF
-* Kokkos_ENABLE_HPX
-    * Whether to build HPX backend (experimental)
-    * BOOL Default: OFF
-* Kokkos_ENABLE_OPENMP
-    * Whether to build OpenMP backend
-    * BOOL Default: OFF
-* Kokkos_ENABLE_THREADS
-    * Whether to build C++ thread backend
-    * BOOL Default: OFF
-* Kokkos_ENABLE_SERIAL
-    * Whether to build serial backend
-    * BOOL Default: ON
-* Kokkos_ENABLE_HIP (Experimental)
-    * Whether to build HIP backend
-    * BOOL Default: OFF
-* Kokkos_ENABLE_OPENMPTARGET (Experimental)
-    * Whether to build the OpenMP target backend
-    * BOOL Default: OFF
-
-## Enable Options
-Options can be enabled by specifying `-DKokkos_ENABLE_X`.
-
-* Kokkos_ENABLE_AGGRESSIVE_VECTORIZATION
-    * Whether to aggressively vectorize loops
-    * BOOL Default: OFF
-* Kokkos_ENABLE_COMPILER_WARNINGS
-    * Whether to print all compiler warnings
-    * BOOL Default: OFF
-* Kokkos_ENABLE_CUDA_CONSTEXPR
-    * Whether to activate experimental relaxed constexpr functions
-    * BOOL Default: OFF
-* Kokkos_ENABLE_CUDA_LAMBDA
-    * Whether to activate experimental lambda features
-    * BOOL Default: OFF
-* Kokkos_ENABLE_CUDA_LDG_INTRINSIC
-    * Deprecated since 4.0, LDG intrinsics are always enabled.
-    * Whether to use CUDA LDG intrinsics
-    * BOOL Default: OFF
-* Kokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-    * Whether to enable relocatable device code (RDC) for CUDA
-    * BOOL Default: OFF
-* Kokkos_ENABLE_CUDA_UVM
-    * Deprecated since 4.0
-    * Whether to use unified memory (UM) by default for CUDA
-    * BOOL Default: OFF
-* Kokkos_ENABLE_DEBUG
-    * Whether to activate extra debug features - may increase compile times
-    * BOOL Default: OFF
-* Kokkos_ENABLE_DEBUG_BOUNDS_CHECK
-    * Whether to use bounds checking - will increase runtime
-    * BOOL Default: OFF
-* Kokkos_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
-    * Debug check on dual views
-    * BOOL Default: OFF
-* Kokkos_ENABLE_EXAMPLES
-    * Whether to enable building examples
-    * BOOL Default: OFF
-* Kokkos_ENABLE_HPX_ASYNC_DISPATCH
-    * Whether HPX supports asynchronous dispatch
-    * BOOL Default: OFF
-* Kokkos_ENABLE_IMPL_CUDA_MALLOC_ASYNC
-    * Whether to enable CudaMallocAsync (requires CUDA Toolkit 11.2). This is an experimental performance feature and currently has issue when using with UCX. See https://github.com/kokkos/kokkos/issues/4228 for more details.
-    * BOOL Default: OFF
-* Kokkos_ENABLE_LARGE_MEM_TESTS
-    * Whether to perform extra large memory tests
-    * BOOL_Default: OFF
-* Kokkos_ENABLE_PROFILING_LOAD_PRINT
-    * Whether to print information about which profiling tools gotloaded
-    * BOOL Default: OFF
-* Kokkos_ENABLE_TESTS
-    * Whether to enable test suite
-    * BOOL Default: OFF
-
-
-## Third-party Libraries (TPLs)
-The following options control enabling TPLs:
-* Kokkos_ENABLE_HPX
-    * Whether to enable the HPX library
-    * BOOL Default: OFF
-* Kokkos_ENABLE_HWLOC
-    * Whether to enable the HWLOC library
-    * BOOL Default: Off
-* Kokkos_ENABLE_LIBNUMA
-    * Whether to enable the LIBNUMA library
-    * BOOL Default: Off
-* Kokkos_ENABLE_MEMKIND
-    * Whether to enable the MEMKIND library
-    * BOOL Default: Off
-* Kokkos_ENABLE_LIBDL
-    * Whether to enable the LIBDL library
-    * BOOL Default: On
-* Kokkos_ENABLE_LIBRT
-    * Whether to enable the LIBRT library
-    * BOOL Default: Off
-
-The following options control finding and configuring non-CMake TPLs:
-* Kokkos_CUDA_DIR or CUDA_ROOT
-    * Location of CUDA install prefix for libraries
-    * PATH Default:
-* Kokkos_HWLOC_DIR or HWLOC_ROOT
-    * Location of HWLOC install prefix
-    * PATH Default:
-* Kokkos_LIBNUMA_DIR or LIBNUMA_ROOT
-    * Location of LIBNUMA install prefix
-    * PATH Default:
-* Kokkos_MEMKIND_DIR or MEMKIND_ROOT
-    * Location of MEMKIND install prefix
-    * PATH Default:
-* Kokkos_LIBDL_DIR or LIBDL_ROOT
-    * Location of LIBDL install prefix
-    * PATH Default:
-* Kokkos_LIBRT_DIR or LIBRT_ROOT
-    * Location of LIBRT install prefix
-    * PATH Default:
-
-The following options control `find_package` paths for CMake-based TPLs:
-* HPX_DIR or HPX_ROOT
-    * Location of HPX prefix (ROOT) or CMake config file (DIR)
-    * PATH Default:
-
-## Architecture Keywords
-Architecture-specific optimizations can be enabled by specifying `-DKokkos_ARCH_X`.
-
-* Kokkos_ARCH_NATIVE
-    * Whether to optimize for the the local CPU architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_AMDAVX
-    * Whether to optimize for the AMDAVX architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ARMV80
-    * Whether to optimize for the ARMV80 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ARMV81
-    * Whether to optimize for the ARMV81 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ARMV8_THUNDERX
-    * Whether to optimize for the ARMV8_THUNDERX architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ARMV8_TX2
-    * Whether to optimize for the ARMV8_TX2 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_BDW
-    * Whether to optimize for the BDW architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_BGQ
-    * Whether to optimize for the BGQ architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ZEN
-    * Whether to optimize for the Zen architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ZEN2
-    * Whether to optimize for the Zen2 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ZEN3
-    * Whether to optimize for the Zen3 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_HSW
-    * Whether to optimize for the HSW architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_KEPLER30
-    * Whether to optimize for the KEPLER30 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_KEPLER32
-    * Whether to optimize for the KEPLER32 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_KEPLER35
-    * Whether to optimize for the KEPLER35 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_KEPLER37
-    * Whether to optimize for the KEPLER37 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_KNC
-    * Whether to optimize for the KNC architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_KNL
-    * Whether to optimize for the KNL architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_MAXWELL50
-    * Whether to optimize for the MAXWELL50 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_MAXWELL52
-    * Whether to optimize for the MAXWELL52 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_MAXWELL53
-    * Whether to optimize for the MAXWELL53 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_PASCAL60
-    * Whether to optimize for the PASCAL60 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_PASCAL61
-    * Whether to optimize for the PASCAL61 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_POWER7
-    * Whether to optimize for the POWER7 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_POWER8
-    * Whether to optimize for the POWER8 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_POWER9
-    * Whether to optimize for the POWER9 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ICL
-    * Whether to optimize for the ICL architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_ICX
-    * Whether to optimize for the ICX architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_SKL
-    * Whether to optimize for the SKL architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_SKX
-    * Whether to optimize for the SKX architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_SNB
-    * Whether to optimize for the SNB architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_SPR
-    * Whether to optimize for the SPR architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_TURING75
-    * Whether to optimize for the TURING75 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_VOLTA70
-    * Whether to optimize for the VOLTA70 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_VOLTA72
-    * Whether to optimize for the VOLTA72 architecture
-    * BOOL Default: OFF
-* Kokkos_ARCH_WSM
-    * Whether to optimize for the WSM architecture
-    * BOOL Default: OFF
-
-##### [LICENSE](https://github.com/kokkos/kokkos/blob/devel/LICENSE)
-
-[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-
-Under the terms of Contract DE-NA0003525 with NTESS,
-the U.S. Government retains certain rights in this software.
+Please refer to our [wiki](https://kokkos.github.io/kokkos-core-wiki/keywords.html#cmake-keywords).
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c3409a9058..4c145c44b3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,129 @@
-# Change Log
+# CHANGELOG
 
-## [4.0.0](https://github.com/kokkos/kokkos/tree/4.0.0) (2023-02-21)
-[Full Changelog](https://github.com/kokkos/kokkos/compare/3.7.01...4.0.0)
+## [4.1.00](https://github.com/kokkos/kokkos/tree/4.0.01) (2023-06-16)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.0.01...4.1.00)
+
+### Features:
+* Add `<Kokkos_BitManipulation.hpp>` header [\#4577](https://github.com/kokkos/kokkos/pull/4577) [\#5907](https://github.com/kokkos/kokkos/pull/5907) [\#5967](https://github.com/kokkos/kokkos/pull/5967) [\#6101](https://github.com/kokkos/kokkos/pull/6101)
+* Add `UnorderedMapInsertOpTypes` [\#5877](https://github.com/kokkos/kokkos/pull/5877) and documentation [\#350](https://github.com/kokkos/kokkos-core-wiki/pull/350)
+* Add multiple reducers support for team-level parallel reduce [\#5727](https://github.com/kokkos/kokkos/pull/5727)
+
+### Backend and Architecture Enhancements:
+
+#### CUDA:
+
+* Allow NVCC 12 to compile using C++20 flag [\#5977](https://github.com/kokkos/kokkos/pull/5977)
+* Remove ability to disable CMake option `Kokkos_ENABLE_CUDA_LAMBDA` and unconditionally enable CUDA extended lambda support. [\#5964](https://github.com/kokkos/kokkos/pull/5964)
+* Drop unnecessary fences around the memory allocation when using `CudaUVMSpace` in views [\#6008](https://github.com/kokkos/kokkos/pull/6008)
+
+#### HIP:
+* Improve performance for `parallel_reduce`. Use different parameters for `LightWeight` kernels [\#6029](https://github.com/kokkos/kokkos/pull/6029) and [\#6160](https://github.com/kokkos/kokkos/pull/6160)
+
+#### SYCL:
+* Only pass one wrapper object in SYCL reductions [\#6047](https://github.com/kokkos/kokkos/pull/6047)
+* Improve and simplify parallel_scan implementation [\#6064](https://github.com/kokkos/kokkos/pull/6064)
+* Remove workaround for submit_barrier not being enqueued properly [\#5504](https://github.com/kokkos/kokkos/pull/5504)
+* Fix guards for using scratch space with SYCL [\#6003](https://github.com/kokkos/kokkos/pull/6003)
+* Fix compiling SYCL with KOKKOS_IMPL_DO_NOT_USE_PRINTF_USAGE [\#6219](https://github.com/kokkos/kokkos/pull/6219)
+
+#### OpenMPTarget:
+* Improve hierarchical parallelism for Intel architectures [\#6043](https://github.com/kokkos/kokkos/pull/6043)
+* Enable Cray compiler for the OpenMPTarget backend. [\#5889](https://github.com/kokkos/kokkos/pull/5889)
+
+#### HPX:
+* Update HPX backend to use HPX's sender/receiver functionality [\#5628](https://github.com/kokkos/kokkos/pull/5628)
+* Increase minimum required HPX version to 1.8.0 [\#6132](https://github.com/kokkos/kokkos/pull/6132)
+* Implement HPX::in_parallel [\#6143](https://github.com/kokkos/kokkos/pull/6143)
+
+### General Enhancements
+* Export CMake `Kokkos_{CUDA,HIP}_ARCHITECTURES` variables [\#5919](https://github.com/kokkos/kokkos/pull/5919) [\#5925](https://github.com/kokkos/kokkos/pull/5925)
+* Add `Kokkos::Profiling::ScopedRegion` [\#5959](https://github.com/kokkos/kokkos/pull/5959) [\#5972](https://github.com/kokkos/kokkos/pull/5972)
+* Add support for `View::rank[_dynamic]()`[\#5870](https://github.com/kokkos/kokkos/pull/5870)
+* Detect incompatible relocatable device code mode to prevent ODR violations [\#5991](https://github.com/kokkos/kokkos/pull/5991)
+* Add (experimental) support for 32-bit Darwin and PPC [\#5916](https://github.com/kokkos/kokkos/pull/5916)
+* Add missing half and bhalf specialization of the infinity numeric trait [\#6055](https://github.com/kokkos/kokkos/pull/6055)
+* Add `is_dual_view` trait and align further with regular view [\#6120](https://github.com/kokkos/kokkos/pull/6120)
+* Allow templated functors in parallel_for, parallel_reduce and parallel_scan [\#5976](https://github.com/kokkos/kokkos/pull/5976)
+* Define KOKKOS_COMPILER_INTEL_LLVM and only define at most one KOKKOS_COMPILER* macro [\#5906](https://github.com/kokkos/kokkos/pull/5906)
+* Allow linking against build tree [\#6078](https://github.com/kokkos/kokkos/pull/6078)
+* Allow passing a temporary std::vector to partition_space [\#6167](https://github.com/kokkos/kokkos/pull/6167)
+* `Kokkos` can be used as an external dependency in `Trilinos` [\#6142](https://github.com/kokkos/kokkos/pull/6142), [\#6157](https://github.com/kokkos/kokkos/pull/6157) [\#6163](https://github.com/kokkos/kokkos/pull/6163)
+* Left align demangled stacktrace output [\#6191](https://github.com/kokkos/kokkos/pull/6191)
+* Improve OpenMP affinity warning to include MPI concerns [\#6185](https://github.com/kokkos/kokkos/pull/6185)
+
+### Build System Changes
+* Drop `Kokkos_ENABLE_LAUNCH_COMPILER` option which had no effect [\#6148](https://github.com/kokkos/kokkos/pull/6148)
+* Export variables for relevant Kokkos options with cmake[\#6142](https://github.com/kokkos/kokkos/pull/6142)
+
+### Incompatibilities (i.e. breaking changes)
+* Desul atomics always enabled [\#5801](https://github.com/kokkos/kokkos/pull/5801)
+* Drop `KOKKOS_ENABLE_CUDA_ASM*` and `KOKKOS_ENABLE_*_ATOMICS` macros [\#5940](https://github.com/kokkos/kokkos/pull/5940)
+* Drop `KOKKOS_ENABLE_RFO_PREFETCH` macro [\#5944](https://github.com/kokkos/kokkos/pull/5944)
+* Deprecate `Kokkos_ENABLE_CUDA_LAMBDA` configuration option and force it to `ON` [\#5964](https://github.com/kokkos/kokkos/pull/5964)
+* Remove TriBITS Kokkos subpackages [\#6104](https://github.com/kokkos/kokkos/pull/6104)
+* Cuda: Remove unused attach_texture_object [\#6129](https://github.com/kokkos/kokkos/pull/6129)
+* Drop Kokkos_ENABLE_PROFILING_LOAD_PRINT configuration option [\#6150](https://github.com/kokkos/kokkos/pull/6150)
+* Drop pointless Kokkos{Algorithms,Containers}_config.h files [\#6108](https://github.com/kokkos/kokkos/pull/6108)
+
+### Deprecations
+* Deprecate `BinSort`, `BinOp1D`, and `BinOp3D` default constructors [\#6131](https://github.com/kokkos/kokkos/pull/6131)
+
+### Bug Fixes
+* Fix `SYCLTeamMember` to take arguments for scratch sizes as `std::size_t` [\#5981](https://github.com/kokkos/kokkos/pull/5981)
+* Fix Kokkos_SIMD with AVX2 on 64-bit architectures [\#6075](https://github.com/kokkos/kokkos/pull/6075)
+* Fix an incorrectly returning size for SIMD uint64_t in AVX2 [\#6004](https://github.com/kokkos/kokkos/pull/6004)
+* Fix missing avx512 header file with gcc versions before 10 [\#6183](https://github.com/kokkos/kokkos/pull/6183)
+* Fix incorrect results of `parallel_reduce` of types smaller than `int` on CUDA and HIP: [\#5745](https://github.com/kokkos/kokkos/pull/5745)
+* CMake: update package compatibility mode when building within Trilinos [\#6012](https://github.com/kokkos/kokkos/pull/6012)
+* Fix warnings generated from internal uses of `ALL_t` rather than `Kokkos::ALL_t` [\#6028](https://github.com/kokkos/kokkos/pull/6028)
+* Fix bug in `hpcbind` script: check for correct Slurm variable [\#6116](https://github.com/kokkos/kokkos/pull/6116)
+* KokkosTools: Don't call callbacks before backends are initialized [\#6114](https://github.com/kokkos/kokkos/pull/6114)
+* Fix global fence in Kokkos::resize(DynRankView) [\#6184](https://github.com/kokkos/kokkos/pull/6184)
+* Fix `BinSort` support for strided views [\#6081](https://github.com/kokkos/kokkos/pull/6184)
+* Fix missing `is_*_view` traits in containers [\#6195](https://github.com/kokkos/kokkos/pull/6195)
+* Fix broken OpenMP target on NVHPC [\#6171](https://github.com/kokkos/kokkos/pull/6171)
+* Sorting an empty view should exit early and not fail [\#6130](https://github.com/kokkos/kokkos/pull/6130)
+
+## [4.0.01](https://github.com/kokkos/kokkos/tree/4.0.01) (2023-04-14)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.0.00...4.0.01)
+
+### Backend and Architecture Enhancements:
+
+#### CUDA:
+
+- Allow NVCC 12 to compile using C++20 flag [\#6020](https://github.com/kokkos/kokkos/pull/6020)
+- Add CUDA Ada architecture support [\#6022](https://github.com/kokkos/kokkos/pull/6022)
+
+#### HIP:
+
+- Add support for AMDGPU target NAVI31 / RX 7900 XT(X): gfx1100 [\#6021](https://github.com/kokkos/kokkos/pull/6021)
+- HIP: Fix warning from `std::memcpy` [\#6019](https://github.com/kokkos/kokkos/pull/6019)
+
+#### SYCL:
+- Fix `SYCLTeamMember` to take arguments for scratch sizes as `std::size_t` [\#5986](https://github.com/kokkos/kokkos/pull/5986)
+
+### General Enhancements
+- Fixup 4.0 change log [\#6023](https://github.com/kokkos/kokkos/pull/6023)
+
+### Build System Changes
+- Cherry-pick TriBITS update from Trilinos [\#6037](https://github.com/kokkos/kokkos/pull/6037)
+- CMake: update package compatibility mode when building within Trilinos [\#6013](https://github.com/kokkos/kokkos/pull/6013)
+
+### Bug Fixes
+- Fix an incorrectly returning size for SIMD uint64_t in AVX2 [\#6011](https://github.com/kokkos/kokkos/pull/6011)
+- Desul atomics: wrong value for `desul::Impl::numeric_limits_max<uint64_t>` [\#6018](https://github.com/kokkos/kokkos/pull/6018)
+- Fix warning in some user code when using std::memcpy [\#6000](https://github.com/kokkos/kokkos/pull/6000)
+- Fix excessive build times using Makefile.kokkos [\#6068](https://github.com/kokkos/kokkos/pull/6068)
+
+## [4.0.0](https://github.com/kokkos/kokkos/tree/4.0.00) (2023-02-21)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/3.7.01...4.0.00)
 
 ### Features:
 - Allow value types without default constructor in `Kokkos::View` with `Kokkos::WithoutInitializing` [\#5307](https://github.com/kokkos/kokkos/pull/5307)
 - `parallel_scan` with `View` as result type. [\#5146](https://github.com/kokkos/kokkos/pull/5146)
 - Introduced `SharedSpace`, an alias for a `MemorySpace` that is accessible by every `ExecutionSpace`. The memory is moved and then accessed locally. [\#5289](https://github.com/kokkos/kokkos/pull/5289)
 - Introduced `SharedHostPinnedSpace`, an alias for a `MemorySpace` that is accessible by every `ExecutionSpace`. The memory is pinned to the host and accessed via zero-copy access. [\#5405](https://github.com/kokkos/kokkos/pull/5405)
+- Add team- and thread-level `sort`, `sort_by_key` algorithms. [\#5317](https://github.com/kokkos/kokkos/pull/5317)
 - Groundwork for `MDSpan` integration. [\#4973](https://github.com/kokkos/kokkos/pull/4973) and [\#5304](https://github.com/kokkos/kokkos/pull/5304)
 - Introduced MD version of hierarchical parallelism: `TeamThreadMDRange`, `ThreadVectorMDRange` and `TeamVectorMDRange`. [\#5238](https://github.com/kokkos/kokkos/pull/5238)
 
@@ -72,23 +188,12 @@
 - Remove Kokkos_ENABLE_CUDA_LDG_INTRINSIC option [\#5623](https://github.com/kokkos/kokkos/pull/5623)
 - Don't rely on synchronization behavior of default stream in CUDA and HIP - this potentially will break unintended implicit synchronization with other libraries such as MPI [\#5391](https://github.com/kokkos/kokkos/pull/5391)
 - Make ExecutionSpace::concurrency() a non-static member function [\#5655](https://github.com/kokkos/kokkos/pull/5655) and related PRs
+- Remove code guarded by `KOKKOS_ENABLE_DEPRECATED_CODE_3`
 
 ### Deprecations
-- Guard against non-public header inclusion [\#5178](https://github.com/kokkos/kokkos/pull/5178)
-- Raise deprecation warnings if non empty WorkTag class is used [\#5230](https://github.com/kokkos/kokkos/pull/5230)
-- Deprecate `parallel_*` overloads taking the label as trailing argument [\#5141](https://github.com/kokkos/kokkos/pull/5141)
-- Deprecate nested types in functional [\#5185](https://github.com/kokkos/kokkos/pull/5185)
-- Deprecate `InitArguments` struct and replace it with `InitializationSettings` [\#5135](https://github.com/kokkos/kokkos/pull/5135)
-- Deprecate `finalize_all()` [\#5134](https://github.com/kokkos/kokkos/pull/5134)
-- Deprecate command line arguments (other than `--help`) that are not prefixed with `kokkos-*` [\#5120](https://github.com/kokkos/kokkos/pull/5120)
-- Deprecate `--[kokkos-]numa` cmdline arg and `KOKKOS_NUMA` env var [\#5117](https://github.com/kokkos/kokkos/pull/5117)
-- Deprecate `--[kokkos-]threads` command line argument in favor of `--[kokkos-]num-threads` [\#5111](https://github.com/kokkos/kokkos/pull/5111)
-- Deprecate `Kokkos::is_reducer_type` [\#4957](https://github.com/kokkos/kokkos/pull/4957)
-- Deprecate `OffsetView` constructors taking `index_list_type` [\#4810](https://github.com/kokkos/kokkos/pull/4810)
-- Deprecate overloads of `Kokkos::sort` taking a parameter `bool always_use_kokkos_sort` [\#5382](https://github.com/kokkos/kokkos/issues/5382)
 - Deprecate `CudaUVMSpace::available()` which always returned `true` [\#5614](https://github.com/kokkos/kokkos/pull/5614)
 - Deprecate `volatile`-qualified members from `Kokkos::pair` and `Kokkos::complex` [\#5412](https://github.com/kokkos/kokkos/pull/5412)
-- Deprecate `KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_*` macros [\#5824](https://github.com/kokkos/kokkos/pull/5824) (oversight in 3.2)
+- Deprecate `KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_*` macros [\#5824](https://github.com/kokkos/kokkos/pull/5824) (oversight in 3.6)
 
 ### Bug Fixes
 - Avoid allocating memory for `UniqueToken` [\#5300](https://github.com/kokkos/kokkos/pull/5300)
@@ -103,6 +208,27 @@
 - Don't install standard algorithms headers multiple times [\#5670](https://github.com/kokkos/kokkos/pull/5670)
 - Fix max scratch size calculation for level 0 scratch in CUDA and HIP [\#5718](https://github.com/kokkos/kokkos/pull/5718)
 
+## [3.7.02](https://github.com/kokkos/kokkos/tree/3.7.02) (2023-05-17)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/3.7.01...3.7.02)
+
+### Backends and Archs Enhancements:
+#### CUDA
+- Add Hopper support and update nvcc_wrapper to work with CUDA-12 [\#5693](https://github.com/kokkos/kokkos/pull/5693)
+### General Enhancements:
+- sprintf -> snprintf [\#5787](https://github.com/kokkos/kokkos/pull/5787)
+### Build System:
+- Add error message when not using `hipcc` and when `CMAKE_CXX_STANDARD` is not set [\#5945](https://github.com/kokkos/kokkos/pull/5945)
+### Bug Fixes:
+- Fix Scratch allocation alignment issues [\#5692](https://github.com/kokkos/kokkos/pull/5692)
+- Fix Intel Classic Compiler ICE [\#5710](https://github.com/kokkos/kokkos/pull/5710)
+- Don't install std algorithm headers multiple times [\#5711](https://github.com/kokkos/kokkos/pull/5711)
+- Fix static init order issue in InitalizationSettings [\#5721](https://github.com/kokkos/kokkos/pull/5721)
+- Fix src/dst Properties in deep_copy(DynamicView,View) [\#5732](https://github.com/kokkos/kokkos/pull/5732)
+- Fix build on Fedora Rawhide [\#5782](https://github.com/kokkos/kokkos/pull/5782)
+- Finalize HIP lock arrays [\#5694](https://github.com/kokkos/kokkos/pull/5694)
+- Fix CUDA lock arrays for current Desul [\#5812](https://github.com/kokkos/kokkos/pull/5812)
+- Set the correct device/context in InterOp tests [\#5701](https://github.com/kokkos/kokkos/pull/5701)
+
 ## [3.7.01](https://github.com/kokkos/kokkos/tree/3.7.01) (2022-12-01)
 [Full Changelog](https://github.com/kokkos/kokkos/compare/3.7.00...3.7.01)
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 02ebcf9e24..895cee6a08 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,13 +5,16 @@ if( "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}" )
   message( FATAL_ERROR "FATAL: In-source builds are not allowed. You should create a separate directory for build files and delete CMakeCache.txt." )
 endif()
 
+if (COMMAND TRIBITS_PACKAGE)
+  TRIBITS_PACKAGE(Kokkos)
+endif()
+
 # We want to determine if options are given with the wrong case
 # In order to detect which arguments are given to compare against
 # the list of valid arguments, at the beginning here we need to
 # form a list of all the given variables. If it begins with any
 # case of KoKkOS, we add it to the list.
 
-
 GET_CMAKE_PROPERTY(_variableNames VARIABLES)
 SET(KOKKOS_GIVEN_VARIABLES)
 FOREACH (var ${_variableNames})
@@ -34,6 +37,8 @@ IF(COMMAND TRIBITS_PACKAGE_DECL)
   SET(KOKKOS_HAS_TRILINOS ON)
 ELSE()
   SET(KOKKOS_HAS_TRILINOS OFF)
+  SET(PACKAGE_NAME Kokkos)
+  SET(PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
 ENDIF()
 # Is this build a subdirectory of another project
 GET_DIRECTORY_PROPERTY(HAS_PARENT PARENT_DIRECTORY)
@@ -123,6 +128,8 @@ IF(NOT KOKKOS_HAS_TRILINOS)
           FORCE)
     ENDIF()
   ENDIF()
+ELSE()
+  SET(KOKKOS_COMPILE_LANGUAGE CXX)
 ENDIF()
 
 IF (NOT CMAKE_SIZEOF_VOID_P)
@@ -133,14 +140,20 @@ IF (NOT CMAKE_SIZEOF_VOID_P)
     MESSAGE(FATAL_ERROR "Kokkos did not configure correctly and failed to validate compiler. The most likely cause is linkage errors during CMake compiler validation. Please consult the CMake error log shown below for the exact error during compiler validation")
   ENDIF()
 ELSEIF (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-  MESSAGE(FATAL_ERROR "Kokkos assumes a 64-bit build; i.e., 8-byte pointers, but found ${CMAKE_SIZEOF_VOID_P}-byte pointers instead")
+  IF(CMAKE_SIZEOF_VOID_P EQUAL 4)
+    MESSAGE(WARNING "32-bit builds are experimental and not officially supported.")
+    SET(KOKKOS_IMPL_32BIT ON)
+  ELSE()
+    MESSAGE(FATAL_ERROR "Kokkos assumes a 64-bit build, i.e., 8-byte pointers, but found ${CMAKE_SIZEOF_VOID_P}-byte pointers instead;")
+  ENDIF()
 ENDIF()
 
 
 set(Kokkos_VERSION_MAJOR 4)
-set(Kokkos_VERSION_MINOR 0)
-set(Kokkos_VERSION_PATCH 0)
+set(Kokkos_VERSION_MINOR 1)
+set(Kokkos_VERSION_PATCH 00)
 set(Kokkos_VERSION "${Kokkos_VERSION_MAJOR}.${Kokkos_VERSION_MINOR}.${Kokkos_VERSION_PATCH}")
+message(STATUS "Kokkos version: ${Kokkos_VERSION}")
 math(EXPR KOKKOS_VERSION "${Kokkos_VERSION_MAJOR} * 10000 + ${Kokkos_VERSION_MINOR} * 100 + ${Kokkos_VERSION_PATCH}")
 # mathematical expressions below are not stricly necessary but they eliminate
 # the rather aggravating leading 0 in the releases patch version number, and,
@@ -288,8 +301,6 @@ IF (KOKKOS_HAS_TRILINOS)
     $<$<COMPILE_LANGUAGE:CXX>:${KOKKOS_ALL_COMPILE_OPTIONS}>)
 ENDIF()
 
-KOKKOS_PACKAGE_DECL()
-
 
 #------------------------------------------------------------------------------
 #
@@ -303,7 +314,6 @@ KOKKOS_PROCESS_SUBPACKAGES()
 # E) If Kokkos itself is enabled, process the Kokkos package
 #
 
-KOKKOS_PACKAGE_DEF()
 KOKKOS_EXCLUDE_AUTOTOOLS_FILES()
 KOKKOS_PACKAGE_POSTPROCESS()
 KOKKOS_CONFIGURE_CORE()
@@ -313,6 +323,8 @@ IF (NOT KOKKOS_HAS_TRILINOS AND NOT Kokkos_INSTALL_TESTING)
   #Make sure in-tree projects can reference this as Kokkos::
   #to match the installed target names
   ADD_LIBRARY(Kokkos::kokkos ALIAS kokkos)
+  # all_libs target is required for TriBITS-compliance
+  ADD_LIBRARY(Kokkos::all_libs ALIAS kokkos)
   TARGET_LINK_LIBRARIES(kokkos INTERFACE ${KOKKOS_COMPONENT_LIBRARIES})
   KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL(kokkos)
 ENDIF()
diff --git a/Makefile.kokkos b/Makefile.kokkos
index a55e3428cf..9436b75b9e 100644
--- a/Makefile.kokkos
+++ b/Makefile.kokkos
@@ -1,8 +1,8 @@
 # Default settings common options.
 
 KOKKOS_VERSION_MAJOR = 4
-KOKKOS_VERSION_MINOR = 0
-KOKKOS_VERSION_PATCH = 0
+KOKKOS_VERSION_MINOR = 1
+KOKKOS_VERSION_PATCH = 00
 KOKKOS_VERSION = $(shell echo $(KOKKOS_VERSION_MAJOR)*10000+$(KOKKOS_VERSION_MINOR)*100+$(KOKKOS_VERSION_PATCH) | bc)
 
 # Options: Cuda,HIP,SYCL,OpenMPTarget,OpenMP,Threads,Serial
@@ -10,7 +10,7 @@ KOKKOS_VERSION = $(shell echo $(KOKKOS_VERSION_MAJOR)*10000+$(KOKKOS_VERSION_MIN
 KOKKOS_DEVICES ?= "Threads"
 # Options:
 # Intel:    KNC,KNL,SNB,HSW,BDW,SKL,SKX,ICL,ICX,SPR
-# NVIDIA:   Kepler,Kepler30,Kepler32,Kepler35,Kepler37,Maxwell,Maxwell50,Maxwell52,Maxwell53,Pascal60,Pascal61,Volta70,Volta72,Turing75,Ampere80,Ampere86,Hopper90
+# NVIDIA:   Kepler,Kepler30,Kepler32,Kepler35,Kepler37,Maxwell,Maxwell50,Maxwell52,Maxwell53,Pascal60,Pascal61,Volta70,Volta72,Turing75,Ampere80,Ampere86,Ada89,Hopper90
 # ARM:      ARMv80,ARMv81,ARMv8-ThunderX,ARMv8-TX2,A64FX
 # IBM:      BGQ,Power7,Power8,Power9
 # AMD-GPUS: Vega906,Vega908,Vega90A,Navi1030
@@ -23,7 +23,7 @@ KOKKOS_DEBUG ?= "no"
 KOKKOS_USE_TPLS ?= ""
 # Options: c++17,c++1z,c++20,c++2a,c++23,c++2b
 KOKKOS_CXX_STANDARD ?= "c++17"
-# Options: aggressive_vectorization,disable_profiling,enable_large_mem_tests,disable_complex_align,disable_deprecated_code,enable_deprecation_warnings,disable_desul_atomics
+# Options: aggressive_vectorization,disable_profiling,enable_large_mem_tests,disable_complex_align,disable_deprecated_code,enable_deprecation_warnings
 KOKKOS_OPTIONS ?= ""
 KOKKOS_CMAKE ?= "no"
 KOKKOS_TRIBITS ?= "no"
@@ -75,7 +75,6 @@ KOKKOS_INTERNAL_AGGRESSIVE_VECTORIZATION := $(call kokkos_has_string,$(KOKKOS_OP
 KOKKOS_INTERNAL_ENABLE_TUNING := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_tuning)
 KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_complex_align)
 KOKKOS_INTERNAL_DISABLE_DUALVIEW_MODIFY_CHECK := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_dualview_modify_check)
-KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_profile_load_print)
 KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_large_mem_tests)
 # deprecated
 KOKKOS_INTERNAL_CUDA_USE_LDG := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),use_ldg)
@@ -86,6 +85,7 @@ KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR := $(call kokkos_has_string,$(KOKKOS_CUDA_OPT
 KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH := $(call kokkos_has_string,$(KOKKOS_HPX_OPTIONS),enable_async_dispatch)
 # deprecated
 KOKKOS_INTERNAL_ENABLE_DESUL_ATOMICS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),enable_desul_atomics)
+# deprecated
 KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_desul_atomics)
 KOKKOS_INTERNAL_DISABLE_BUNDLED_MDSPAN := $(call kokkos_has_string,$(KOKKOS_OPTIONS),impl_disable_bundled_mdspan)
 KOKKOS_INTERNAL_DISABLE_DEPRECATED_CODE := $(call kokkos_has_string,$(KOKKOS_OPTIONS),disable_deprecated_code)
@@ -265,15 +265,16 @@ else
     KOKKOS_INTERNAL_OPENMP_FLAG := -fopenmp
   endif
 endif
-ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
-  #KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_BUG_WORKAROUND_IBM_CLANG_OMP45_VIEW_INIT -fopenmp-implicit-declare-target -fopenmp-targets=nvptx64-nvidia-cuda -fopenmp -fopenmp=libomp
-  KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -DKOKKOS_WORKAROUND_OPENMPTARGET_CLANG -fopenmp -fopenmp=libomp -Wno-openmp-mapping
-  KOKKOS_INTERNAL_OPENMPTARGET_LIB := -lomptarget
-else ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL_CLANG), 1)
-  KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -fiopenmp -Wno-openmp-mapping
-else
-  #Assume GCC
-  KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -fopenmp -foffload=nvptx-none
+
+ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL_CLANG), 1)
+    KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -fiopenmp -Wno-openmp-mapping
+  else ifeq ($(KOKKOS_INTERNAL_COMPILER_NVHPC), 1)
+    KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -mp=gpu 
+  else ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 0)
+    #Assume GCC
+    KOKKOS_INTERNAL_OPENMPTARGET_FLAG := -fopenmp -foffload=nvptx-none
+  endif
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_OPENACC), 1)
@@ -341,6 +342,7 @@ KOKKOS_INTERNAL_USE_ARCH_VOLTA72 := $(call kokkos_has_string,$(KOKKOS_ARCH),Volt
 KOKKOS_INTERNAL_USE_ARCH_TURING75 := $(call kokkos_has_string,$(KOKKOS_ARCH),Turing75)
 KOKKOS_INTERNAL_USE_ARCH_AMPERE80 := $(call kokkos_has_string,$(KOKKOS_ARCH),Ampere80)
 KOKKOS_INTERNAL_USE_ARCH_AMPERE86 := $(call kokkos_has_string,$(KOKKOS_ARCH),Ampere86)
+KOKKOS_INTERNAL_USE_ARCH_ADA89 := $(call kokkos_has_string,$(KOKKOS_ARCH),Ada89)
 KOKKOS_INTERNAL_USE_ARCH_HOPPER90 := $(call kokkos_has_string,$(KOKKOS_ARCH),Hopper90)
 KOKKOS_INTERNAL_USE_ARCH_NVIDIA := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KEPLER30)  \
                                               + $(KOKKOS_INTERNAL_USE_ARCH_KEPLER32)  \
@@ -356,6 +358,7 @@ KOKKOS_INTERNAL_USE_ARCH_NVIDIA := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KEPLE
                                               + $(KOKKOS_INTERNAL_USE_ARCH_TURING75)  \
                                               + $(KOKKOS_INTERNAL_USE_ARCH_AMPERE80)  \
                                               + $(KOKKOS_INTERNAL_USE_ARCH_AMPERE86)  \
+                                              + $(KOKKOS_INTERNAL_USE_ARCH_ADA89)     \
                                               + $(KOKKOS_INTERNAL_USE_ARCH_HOPPER90))
 
 #SEK: This seems like a bug to me
@@ -574,10 +577,6 @@ ifeq ($(KOKKOS_INTERNAL_DISABLE_COMPLEX_ALIGN), 0)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_COMPLEX_ALIGN")
 endif
 
-ifeq ($(KOKKOS_INTERNAL_ENABLE_PROFILING_LOAD_PRINT), 1)
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_PROFILING_LOAD_PRINT")
-endif
-
 ifeq ($(KOKKOS_INTERNAL_ENABLE_TUNING), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_TUNING")
 endif
@@ -666,15 +665,13 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     endif
   endif
 
-  ifeq ($(KOKKOS_INTERNAL_CUDA_USE_LAMBDA), 1)
-    ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
-      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LAMBDA")
-      KOKKOS_CXXFLAGS += -expt-extended-lambda
-    endif
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
+    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LAMBDA")
+    KOKKOS_CXXFLAGS += -extended-lambda
+  endif
 
-    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
-      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LAMBDA")
-    endif
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
+    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CUDA_LAMBDA")
   endif
 
   ifeq ($(KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR), 1)
@@ -695,7 +692,7 @@ endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
   ifeq ($(KOKKOS_INTERNAL_HPX_ENABLE_ASYNC_DISPATCH), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HPX_ASYNC_DISPATCH")
+    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH")
   endif
 endif
 
@@ -971,134 +968,144 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA_ARCH), 1)
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
-  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-fopenmp-targets=nvptx64 -Xopenmp-target -march
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY_CLANG), 1)
+    KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-fopenmp
+    else ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG=-fopenmp --offload-arch
   endif
-  KOKKOS_INTERNAL_USE_CUDA_ARCH = 1
 endif
 
-ifeq ($(KOKKOS_INTERNAL_USE_CUDA_ARCH), 1)
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER30), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER30")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_30
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER32), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER32")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_32
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER35), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER35")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_35
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER37), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER37")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_37
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL50")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_50
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL52")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_52
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL53")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_53
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL60), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL60")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_60
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL61), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL61")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_61
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA70), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA70")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_70
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA72), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA72")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_72
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_TURING75), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_TURING")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_TURING75")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_75
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMPERE80), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE80")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_80
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMPERE86), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE86")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_86
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_HOPPER90), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HOPPER")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HOPPER90")
-    KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_90
+# Do not add this flag if its the cray compiler or the nvhpc compiler.
+ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY_CLANG), 0)
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVHPC), 0)
+    # Lets start with adding architecture defines
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER30), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER30")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_30
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER32), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER32")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_32
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER35), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER35")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_35
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_KEPLER37), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_KEPLER37")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_37
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL50), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL50")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_50
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL52), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL52")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_52
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MAXWELL53), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_MAXWELL53")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_53
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL60), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL60")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_60
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_PASCAL61), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_PASCAL61")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_61
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA70), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA70")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_70
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VOLTA72), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VOLTA72")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_72
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_TURING75), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_TURING75")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_75
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMPERE80), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE80")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_80
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMPERE86), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMPERE86")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_86
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ADA89), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ADA89")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_89
+    endif
+    ifeq ($(KOKKOS_INTERNAL_USE_ARCH_HOPPER90), 1)
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HOPPER")
+      tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_HOPPER90")
+      KOKKOS_INTERNAL_CUDA_ARCH_FLAG := $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)=sm_90
+    endif
   endif
+endif
 
-  ifneq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 0)
-    KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
+ifneq ($(KOKKOS_INTERNAL_USE_ARCH_NVIDIA), 0)
+  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
 
-    ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
+    KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
+  endif
+  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
+    ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
       KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
     endif
-    ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
-      ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
-        KOKKOS_LDFLAGS += $(KOKKOS_INTERNAL_CUDA_ARCH_FLAG)
-      endif
-    endif
   endif
 endif
 
 
 # Figure out the architecture flag for ROCm.
-ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
-  # Lets start with adding architecture defines
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA906), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA906")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA")
-    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx906
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA908), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA908")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA")
-    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx908
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA90A), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA90A")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA")
-    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx90a
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NAVI1030), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_NAVI1030")
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_NAVI")
-    KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx1030
-  endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA906), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA906")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx906
+endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA908), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA908")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx908
+endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_VEGA90A), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA90A")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_VEGA")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx90a
+endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NAVI1030), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_NAVI1030")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_NAVI")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx1030
+endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_NAVI1100), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_NAVI1100")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_NAVI")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx1100
+endif
 
 
+ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
   KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/HIP/*.cpp)
+  KOKKOS_SRC += $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_HIP.cpp
   KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/HIP/*.hpp)
-  ifeq ($(KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS), 0)
-    KOKKOS_SRC += $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_HIP.cpp
-  endif
 
   KOKKOS_CXXFLAGS+=$(KOKKOS_INTERNAL_HIP_ARCH_FLAG)
   KOKKOS_LDFLAGS+=$(KOKKOS_INTERNAL_HIP_ARCH_FLAG)
@@ -1171,12 +1178,14 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
   KOKKOS_LDFLAGS+=$(KOKKOS_INTERNAL_INTEL_ARCH_FLAG)
 endif
 
-ifeq ($(KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS), 0)
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_IMPL_DESUL_ATOMICS")
-  KOKKOS_CPPFLAGS+=-I$(KOKKOS_PATH)/tpls/desul/include
-else ifeq ($(KOKKOS_INTERNAL_ENABLE_DESUL_ATOMICS), 1)
-  $(error Contradictory Desul atomics options: KOKKOS_OPTIONS=$(KOKKOS_OPTIONS) )
+ifeq ($(KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS), 1)
+  $(warning disable_desul_atomics option has been removed. Desul atomics cannot be disabled.)
+  KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS := 0
+endif
+ifeq ($(KOKKOS_INTERNAL_ENABLE_DESUL_ATOMICS), 1)
+  $(warning enable_desul_atomics option has been removed. Desul atomics are always enabled.)
 endif
+KOKKOS_CPPFLAGS+=-I$(KOKKOS_PATH)/tpls/desul/include
 
 ifeq ($(KOKKOS_INTERNAL_DISABLE_BUNDLED_MDSPAN), 0)
   KOKKOS_CPPFLAGS+=-I$(KOKKOS_PATH)/tpls/mdspan/include
@@ -1218,6 +1227,7 @@ ifneq ($(KOKKOS_INTERNAL_NEW_CONFIG), 0)
   ifeq ($(KOKKOS_INTERNAL_USE_SYCL), 1)
     tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_SYCL.hpp>","KokkosCore_Config_FwdBackend.hpp")
     tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_SYCL.hpp>","KokkosCore_Config_DeclareBackend.hpp")
+    tmp := $(call kokkos_append_config_header,"$H""include <setup/Kokkos_Setup_SYCL.hpp>","KokkosCore_Config_SetupBackend.hpp")
   endif
   ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
     tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HIP.hpp>","KokkosCore_Config_FwdBackend.hpp")
@@ -1229,8 +1239,8 @@ ifneq ($(KOKKOS_INTERNAL_NEW_CONFIG), 0)
     tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_OPENMP.hpp>","KokkosCore_Config_DeclareBackend.hpp")
   endif
   ifeq ($(KOKKOS_INTERNAL_USE_OPENACC), 1)
-    tmp := $(call kokkos_append_config_header,"\#include <fwd/Kokkos_Fwd_OPENACC.hpp>","KokkosCore_Config_FwdBackend.hpp")
-    tmp := $(call kokkos_append_config_header,"\#include <decl/Kokkos_Declare_OPENACC.hpp>","KokkosCore_Config_DeclareBackend.hpp")
+    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_OPENACC.hpp>","KokkosCore_Config_FwdBackend.hpp")
+    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_OPENACC.hpp>","KokkosCore_Config_DeclareBackend.hpp")
   endif
   ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
     tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_THREADS.hpp>","KokkosCore_Config_FwdBackend.hpp")
@@ -1261,9 +1271,7 @@ KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/containers/src/impl/*.cpp)
 
 ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
   KOKKOS_SRC += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.cpp)
-  ifeq ($(KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS), 0)
-    KOKKOS_SRC += $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_CUDA.cpp
-  endif
+  KOKKOS_SRC += $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_CUDA.cpp
   KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/Cuda/*.hpp)
   ifneq ($(CUDA_PATH),)
     KOKKOS_CPPLAGS += -I$(CUDA_PATH)/include
@@ -1379,11 +1387,7 @@ KOKKOS_LIBS := -lkokkos ${KOKKOS_LIBS}
 
 # Generating the <desul/atomics/Config.hpp> header
 DESUL_INTERNAL_CONFIG_TMP=Desul_Config.tmp
-ifeq ($(KOKKOS_INTERNAL_DISABLE_DESUL_ATOMICS), 0)
-  DESUL_CONFIG_HEADER=desul/atomics/Config.hpp
-else
-  DESUL_CONFIG_HEADER=NothingToSeeHereMoveAlong
-endif
+DESUL_CONFIG_HEADER=desul/atomics/Config.hpp
 desul_append_header = $(shell echo $1 >> $(DESUL_INTERNAL_CONFIG_TMP))
 tmp := $(call desul_append_header, "// generated by on-demand build system by crtrott" > $(DESUL_INTERNAL_CONFIG_TMP))
 tmp := $(call desul_append_header, "$H""ifndef DESUL_ATOMICS_CONFIG_HPP_")
@@ -1394,12 +1398,22 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
 else
   tmp := $(call desul_append_header,"/* $H""undef DESUL_ATOMICS_ENABLE_CUDA */")
 endif
+ifeq ($(KOKKOS_INTERNAL_CUDA_USE_RELOC), 1)
+  tmp := $(call desul_append_header,"$H""define DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION")
+else
+  tmp := $(call desul_append_header,"/* $H""undef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION */")
+endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
   tmp := $(call desul_append_header,"$H""define DESUL_ATOMICS_ENABLE_HIP")
 else
   tmp := $(call desul_append_header,"/* $H""undef DESUL_ATOMICS_ENABLE_HIP */")
 endif
+ifeq ($(KOKKOS_INTERNAL_HIP_USE_RELOC), 1)
+  tmp := $(call desul_append_header,"$H""define DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION")
+else
+  tmp := $(call desul_append_header,"/* $H""undef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION */")
+endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_SYCL), 1)
   tmp := $(call desul_append_header,"$H""define DESUL_ATOMICS_ENABLE_SYCL")
@@ -1418,7 +1432,7 @@ tmp := $(call desul_append_header, "$H""endif")
 DESUL_INTERNAL_LS_CONFIG := $(shell ls $(DESUL_CONFIG_HEADER) 2>&1)
 
 ifeq ($(DESUL_INTERNAL_LS_CONFIG), $(DESUL_CONFIG_HEADER))
-  KOKKOS_INTERNAL_NEW_CONFIG := $(strip $(shell diff $(DESUL_CONFIG_HEADER) $(DESUL_INTERNAL_CONFIG_TMP) | grep -c define))
+  DESUL_INTERNAL_NEW_CONFIG := $(strip $(shell diff $(DESUL_CONFIG_HEADER) $(DESUL_INTERNAL_CONFIG_TMP) | grep -c define))
 else
   DESUL_INTERNAL_NEW_CONFIG := 1
 endif
diff --git a/Makefile.targets b/Makefile.targets
index 32b1fab261..4e08a46c69 100644
--- a/Makefile.targets
+++ b/Makefile.targets
@@ -51,8 +51,6 @@ Kokkos_CudaSpace.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Cuda/Kokkos_Cu
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/Cuda/Kokkos_CudaSpace.cpp
 Kokkos_Cuda_Task.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Cuda/Kokkos_Cuda_Task.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/Cuda/Kokkos_Cuda_Task.cpp
-Kokkos_Cuda_Locks.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Cuda/Kokkos_Cuda_Locks.cpp
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/Cuda/Kokkos_Cuda_Locks.cpp
 Lock_Array_CUDA.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_CUDA.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_CUDA.cpp
 endif
@@ -77,8 +75,6 @@ Kokkos_HIP_Space.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/HIP/Kokkos_HIP
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/HIP/Kokkos_HIP_Space.cpp
 Kokkos_HIP_Instance.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/HIP/Kokkos_HIP_Instance.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/HIP/Kokkos_HIP_Instance.cpp
-Kokkos_HIP_Locks.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/HIP/Kokkos_HIP_Locks.cpp
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/HIP/Kokkos_HIP_Locks.cpp
 Lock_Array_HIP.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_HIP.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/tpls/desul/src/Lock_Array_HIP.cpp
 endif
@@ -89,6 +85,8 @@ Kokkos_ThreadsExec.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Threads/Kokk
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
+Kokkos_OpenMP.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/OpenMP/Kokkos_OpenMP.cpp
+	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/OpenMP/Kokkos_OpenMP.cpp
 Kokkos_OpenMP_Instance.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
 Kokkos_OpenMP_Task.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
diff --git a/algorithms/CMakeLists.txt b/algorithms/CMakeLists.txt
index f32363dc9a..ab557ab66a 100644
--- a/algorithms/CMakeLists.txt
+++ b/algorithms/CMakeLists.txt
@@ -1,7 +1,3 @@
-
-
-KOKKOS_SUBPACKAGE(Algorithms)
-
 IF (NOT Kokkos_INSTALL_TESTING)
   ADD_SUBDIRECTORY(src)
 ENDIF()
@@ -9,7 +5,3 @@ ENDIF()
 IF(NOT ((KOKKOS_ENABLE_OPENMPTARGET OR KOKKOS_ENABLE_OPENACC) AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC))
   KOKKOS_ADD_TEST_DIRECTORIES(unit_tests)
 ENDIF()
-
-KOKKOS_SUBPACKAGE_POSTPROCESS()
-
-
diff --git a/algorithms/cmake/Dependencies.cmake b/algorithms/cmake/Dependencies.cmake
deleted file mode 100644
index c36b62523f..0000000000
--- a/algorithms/cmake/Dependencies.cmake
+++ /dev/null
@@ -1,5 +0,0 @@
-TRIBITS_PACKAGE_DEFINE_DEPENDENCIES(
-  LIB_REQUIRED_PACKAGES KokkosCore KokkosContainers
-  LIB_OPTIONAL_TPLS Pthread CUDA HWLOC
-  TEST_OPTIONAL_TPLS CUSPARSE
-  )
diff --git a/algorithms/cmake/KokkosAlgorithms_config.h.in b/algorithms/cmake/KokkosAlgorithms_config.h.in
deleted file mode 100644
index 67334b70f3..0000000000
--- a/algorithms/cmake/KokkosAlgorithms_config.h.in
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef KOKKOS_ALGORITHMS_CONFIG_H
-#define KOKKOS_ALGORITHMS_CONFIG_H
-
-#endif
diff --git a/algorithms/src/CMakeLists.txt b/algorithms/src/CMakeLists.txt
index 606d83d18b..1695778947 100644
--- a/algorithms/src/CMakeLists.txt
+++ b/algorithms/src/CMakeLists.txt
@@ -1,6 +1,3 @@
-
-KOKKOS_CONFIGURE_FILE(${PACKAGE_NAME}_config.h)
-
 #I have to leave these here for tribits
 KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
@@ -9,7 +6,6 @@ KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 FILE(GLOB ALGO_HEADERS *.hpp)
 FILE(GLOB ALGO_SOURCES *.cpp)
-LIST(APPEND ALGO_HEADERS ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME}_config.h)
 APPEND_GLOB(ALGO_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/std_algorithms/*.hpp)
 APPEND_GLOB(ALGO_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/std_algorithms/impl/*.hpp)
 
diff --git a/algorithms/src/Kokkos_Random.hpp b/algorithms/src/Kokkos_Random.hpp
index 91e9ce6fc8..abb028d28e 100644
--- a/algorithms/src/Kokkos_Random.hpp
+++ b/algorithms/src/Kokkos_Random.hpp
@@ -1514,7 +1514,7 @@ void fill_random(const ExecutionSpace& exec, ViewType a, RandomPool g,
         "Kokkos::fill_random",
         Kokkos::RangePolicy<ExecutionSpace>(exec, 0, (LDA + 127) / 128),
         Impl::fill_random_functor_begin_end<ViewType, RandomPool, 128,
-                                            ViewType::Rank, IndexType>(
+                                            ViewType::rank, IndexType>(
             a, g, begin, end));
 }
 
diff --git a/algorithms/src/Kokkos_Sort.hpp b/algorithms/src/Kokkos_Sort.hpp
index 033de22164..10f9ad6462 100644
--- a/algorithms/src/Kokkos_Sort.hpp
+++ b/algorithms/src/Kokkos_Sort.hpp
@@ -66,11 +66,16 @@
 
 #endif
 
+#if defined(KOKKOS_ENABLE_ONEDPL)
+#include <oneapi/dpl/execution>
+#include <oneapi/dpl/algorithm>
+#endif
+
 namespace Kokkos {
 
 namespace Impl {
 
-template <class DstViewType, class SrcViewType, int Rank = DstViewType::Rank>
+template <class DstViewType, class SrcViewType, int Rank = DstViewType::rank>
 struct CopyOp;
 
 template <class DstViewType, class SrcViewType>
@@ -141,8 +146,12 @@ class BinSort {
         Kokkos::is_view<SrcViewType>::value,
         Kokkos::View<typename SrcViewType::const_data_type,
                      typename SrcViewType::array_layout,
-                     typename SrcViewType::device_type,
-                     Kokkos::MemoryTraits<Kokkos::RandomAccess> >,
+                     typename SrcViewType::device_type
+#if !defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
+                     ,
+                     Kokkos::MemoryTraits<Kokkos::RandomAccess>
+#endif
+                     >,
         typename SrcViewType::const_type>;
 
     using perm_view_type = typename PermuteViewType::const_type;
@@ -221,7 +230,11 @@ class BinSort {
   bool sort_within_bins;
 
  public:
-  BinSort() = default;
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED BinSort() = default;
+#else
+  BinSort() = delete;
+#endif
 
   //----------------------------------------
   // Constructor: takes the keys, the binning_operator and optionally whether to
@@ -324,6 +337,10 @@ class BinSort {
   template <class ExecutionSpace, class ValuesViewType>
   void sort(const ExecutionSpace& exec, ValuesViewType const& values,
             int values_range_begin, int values_range_end) const {
+    if (values.extent(0) == 0) {
+      return;
+    }
+
     static_assert(
         Kokkos::SpaceAccessibility<ExecutionSpace,
                                    typename Space::memory_space>::accessible,
@@ -335,11 +352,6 @@ class BinSort {
         "The provided execution space must be able to access the memory space "
         "of the View argument!");
 
-    using scratch_view_type =
-        Kokkos::View<typename ValuesViewType::data_type,
-                     typename ValuesViewType::array_layout,
-                     typename ValuesViewType::device_type>;
-
     const size_t len        = range_end - range_begin;
     const size_t values_len = values_range_end - values_range_begin;
     if (len != values_len) {
@@ -347,6 +359,9 @@ class BinSort {
           "BinSort::sort: values range length != permutation vector length");
     }
 
+    using scratch_view_type =
+        Kokkos::View<typename ValuesViewType::data_type,
+                     typename ValuesViewType::device_type>;
     scratch_view_type sorted_values(
         view_alloc(exec, WithoutInitializing,
                    "Kokkos::SortImpl::BinSortFunctor::sorted_values"),
@@ -451,24 +466,29 @@ class BinSort {
   void operator()(const bin_sort_bins_tag& /*tag*/, const int i) const {
     auto bin_size = bin_count_const(i);
     if (bin_size <= 1) return;
-    int upper_bound = bin_offsets(i) + bin_size;
-    bool sorted     = false;
-    while (!sorted) {
-      sorted      = true;
-      int old_idx = sort_order(bin_offsets(i));
-      int new_idx = 0;
-      for (int k = bin_offsets(i) + 1; k < upper_bound; k++) {
-        new_idx = sort_order(k);
-
-        if (!bin_op(keys_rnd, old_idx, new_idx)) {
-          sort_order(k - 1) = new_idx;
-          sort_order(k)     = old_idx;
-          sorted            = false;
-        } else {
-          old_idx = new_idx;
+    constexpr bool use_std_sort =
+        std::is_same_v<typename exec_space::memory_space, HostSpace>;
+    int lower_bound = bin_offsets(i);
+    int upper_bound = lower_bound + bin_size;
+    // Switching to std::sort for more than 10 elements has been found
+    // reasonable experimentally.
+    if (use_std_sort && bin_size > 10) {
+      if constexpr (use_std_sort) {
+        std::sort(&sort_order(lower_bound), &sort_order(upper_bound),
+                  [this](int p, int q) { return bin_op(keys_rnd, p, q); });
+      }
+    } else {
+      for (int k = lower_bound + 1; k < upper_bound; ++k) {
+        int old_idx = sort_order(k);
+        int j       = k - 1;
+        while (j >= lower_bound) {
+          int new_idx = sort_order(j);
+          if (!bin_op(keys_rnd, old_idx, new_idx)) break;
+          sort_order(j + 1) = new_idx;
+          --j;
         }
+        sort_order(j + 1) = old_idx;
       }
-      upper_bound--;
     }
   }
 };
@@ -481,7 +501,11 @@ struct BinOp1D {
   double mul_   = {};
   double min_   = {};
 
-  BinOp1D() = default;
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED BinOp1D() = default;
+#else
+  BinOp1D() = delete;
+#endif
 
   // Construct BinOp with number of bins, minimum value and maximum value
   BinOp1D(int max_bins__, typename KeyViewType::const_value_type min,
@@ -525,7 +549,11 @@ struct BinOp3D {
   double mul_[3]   = {};
   double min_[3]   = {};
 
-  BinOp3D() = default;
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED BinOp3D() = default;
+#else
+  BinOp3D() = delete;
+#endif
 
   BinOp3D(int max_bins__[], typename KeyViewType::const_value_type min[],
           typename KeyViewType::const_value_type max[]) {
@@ -596,6 +624,10 @@ std::enable_if_t<(Kokkos::is_execution_space<ExecutionSpace>::value) &&
                                     memory_space>::accessible)>
 sort(const ExecutionSpace& exec,
      const Kokkos::View<DataType, Properties...>& view) {
+  if (view.extent(0) == 0) {
+    return;
+  }
+
   using ViewType = Kokkos::View<DataType, Properties...>;
   using CompType = BinOp1D<ViewType>;
 
@@ -634,12 +666,44 @@ sort(const ExecutionSpace& exec,
   bin_sort.sort(exec, view);
 }
 
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class DataType, class... Properties>
+void sort(const Experimental::SYCL& space,
+          const Kokkos::View<DataType, Properties...>& view) {
+  if (view.extent(0) == 0) {
+    return;
+  }
+
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(SpaceAccessibility<Experimental::SYCL,
+                                   typename ViewType::memory_space>::accessible,
+                "SYCL execution space is not able to access the memory space "
+                "of the View argument!");
+
+  auto queue  = space.sycl_queue();
+  auto policy = oneapi::dpl::execution::make_device_policy(queue);
+
+  // Can't use Experimental::begin/end here since the oneDPL then assumes that
+  // the data is on the host.
+  static_assert(
+      ViewType::rank == 1 &&
+          (std::is_same<typename ViewType::array_layout, LayoutRight>::value ||
+           std::is_same<typename ViewType::array_layout, LayoutLeft>::value),
+      "SYCL sort only supports contiguous 1D Views.");
+  const int n = view.extent(0);
+  oneapi::dpl::sort(policy, view.data(), view.data() + n);
+}
+#endif
+
 template <class ExecutionSpace, class DataType, class... Properties>
 std::enable_if_t<(Kokkos::is_execution_space<ExecutionSpace>::value) &&
                  (SpaceAccessibility<
                      HostSpace, typename Kokkos::View<DataType, Properties...>::
                                     memory_space>::accessible)>
 sort(const ExecutionSpace&, const Kokkos::View<DataType, Properties...>& view) {
+  if (view.extent(0) == 0) {
+    return;
+  }
   auto first = Experimental::begin(view);
   auto last  = Experimental::end(view);
   std::sort(first, last);
@@ -649,6 +713,9 @@ sort(const ExecutionSpace&, const Kokkos::View<DataType, Properties...>& view) {
 template <class DataType, class... Properties>
 void sort(const Cuda& space,
           const Kokkos::View<DataType, Properties...>& view) {
+  if (view.extent(0) == 0) {
+    return;
+  }
   const auto exec = thrust::cuda::par.on(space.cuda_stream());
   auto first      = Experimental::begin(view);
   auto last       = Experimental::end(view);
@@ -659,6 +726,11 @@ void sort(const Cuda& space,
 template <class ViewType>
 void sort(ViewType const& view) {
   Kokkos::fence("Kokkos::sort: before");
+
+  if (view.extent(0) == 0) {
+    return;
+  }
+
   typename ViewType::execution_space exec;
   sort(exec, view);
   exec.fence("Kokkos::sort: fence after sorting");
@@ -668,6 +740,10 @@ template <class ExecutionSpace, class ViewType>
 std::enable_if_t<Kokkos::is_execution_space<ExecutionSpace>::value> sort(
     const ExecutionSpace& exec, ViewType view, size_t const begin,
     size_t const end) {
+  if (view.extent(0) == 0) {
+    return;
+  }
+
   using range_policy = Kokkos::RangePolicy<typename ViewType::execution_space>;
   using CompType     = BinOp1D<ViewType>;
 
@@ -690,6 +766,11 @@ std::enable_if_t<Kokkos::is_execution_space<ExecutionSpace>::value> sort(
 template <class ViewType>
 void sort(ViewType view, size_t const begin, size_t const end) {
   Kokkos::fence("Kokkos::sort: before");
+
+  if (view.extent(0) == 0) {
+    return;
+  }
+
   typename ViewType::execution_space exec;
   sort(exec, view, begin, end);
   exec.fence("Kokkos::Sort: fence after sorting");
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
index cc6b63f028..dd785e603b 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
@@ -42,12 +42,13 @@ struct StdAdjacentFindFunctor {
     const auto& next_value = m_first[i + 1];
     const bool are_equal   = m_p(my_value, next_value);
 
-    auto rv =
-        are_equal
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type value = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (are_equal) {
+      value.min_loc_true = i;
+    }
 
-    m_reducer.join(red_value, rv);
+    m_reducer.join(red_value, value);
   }
 
   KOKKOS_FUNCTION
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp
index 52e7625e4d..0376100410 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp
@@ -29,7 +29,7 @@ struct is_admissible_to_kokkos_std_algorithms : std::false_type {};
 
 template <typename T>
 struct is_admissible_to_kokkos_std_algorithms<
-    T, std::enable_if_t< ::Kokkos::is_view<T>::value && T::rank == 1 &&
+    T, std::enable_if_t< ::Kokkos::is_view<T>::value && T::rank() == 1 &&
                          (std::is_same<typename T::traits::array_layout,
                                        Kokkos::LayoutLeft>::value ||
                           std::is_same<typename T::traits::array_layout,
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp
index f2bfa23ccd..71f13e490a 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp
@@ -96,6 +96,8 @@ struct ExclusiveScanDefaultFunctor {
 
   KOKKOS_FUNCTION
   void join(value_type& update, const value_type& input) const {
+    if (input.is_initial) return;
+
     if (update.is_initial) {
       update.val        = input.val;
       update.is_initial = false;
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
index 3fa41af8ea..3ec64fa43d 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
@@ -59,9 +59,11 @@ struct StdFindEndFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::max()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::max()};
+    if (found) {
+      rv.max_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
index df10da2fd5..5f22d2ad13 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
@@ -52,10 +52,11 @@ struct StdFindFirstOfFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
-
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found) {
+      rv.min_loc_true = i;
+    }
     m_reducer.join(red_value, rv);
   }
 
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
index f7ec4b1110..9c0b0c0ccd 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
@@ -44,10 +44,11 @@ struct StdFindIfOrNotFunctor {
     // if doing find_if_not, look for when predicate is false
     const bool found_condition = is_find_if ? m_p(my_value) : !m_p(my_value);
 
-    auto rv =
-        found_condition
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found_condition) {
+      rv.min_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp
index 55e1a78695..ecd6ff39cd 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp
@@ -90,6 +90,8 @@ struct InclusiveScanDefaultFunctor {
 
   KOKKOS_FUNCTION
   void join(value_type& update, const value_type& input) const {
+    if (input.is_initial) return;
+
     if (update.is_initial) {
       update.val = input.val;
     } else {
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp b/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
index 92a22f3c3a..0fe2d246ff 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
@@ -43,8 +43,12 @@ struct StdIsPartitionedFunctor {
         ::Kokkos::reduction_identity<index_type>::min();
     constexpr index_type m_red_id_max =
         ::Kokkos::reduction_identity<index_type>::max();
-    auto rv = predicate_value ? red_value_type{i, m_red_id_min}
-                              : red_value_type{m_red_id_max, i};
+
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {m_red_id_max, i};
+    if (predicate_value) {
+      rv = {i, m_red_id_min};
+    }
 
     m_reducer.join(redValue, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp b/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp
index fe52e18a33..2a0c112bf5 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp
@@ -28,33 +28,30 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IteratorType, class IndicatorViewType, class ComparatorType>
+template <class IteratorType, class ComparatorType, class ReducerType>
 struct StdIsSortedUntilFunctor {
   using index_type = typename IteratorType::difference_type;
+  using value_type = typename ReducerType::value_type;
+
   IteratorType m_first;
-  IndicatorViewType m_indicator;
   ComparatorType m_comparator;
+  ReducerType m_reducer;
 
   KOKKOS_FUNCTION
-  void operator()(const index_type i, int& update, const bool final) const {
+  void operator()(const index_type i, value_type& reduction_result) const {
     const auto& val_i   = m_first[i];
     const auto& val_ip1 = m_first[i + 1];
-
     if (m_comparator(val_ip1, val_i)) {
-      ++update;
-    }
-
-    if (final) {
-      m_indicator(i) = update;
+      m_reducer.join(reduction_result, i);
     }
   }
 
   KOKKOS_FUNCTION
-  StdIsSortedUntilFunctor(IteratorType _first1, IndicatorViewType indicator,
-                          ComparatorType comparator)
-      : m_first(std::move(_first1)),
-        m_indicator(std::move(indicator)),
-        m_comparator(std::move(comparator)) {}
+  StdIsSortedUntilFunctor(IteratorType first, ComparatorType comparator,
+                          ReducerType reducer)
+      : m_first(std::move(first)),
+        m_comparator(std::move(comparator)),
+        m_reducer(std::move(reducer)) {}
 };
 
 template <class ExecutionSpace, class IteratorType, class ComparatorType>
@@ -73,40 +70,31 @@ IteratorType is_sorted_until_impl(const std::string& label,
   }
 
   /*
-    use scan and a helper "indicator" view
-    such that we scan the data and fill the indicator with
-    partial sum that is always 0 unless we find a pair that
-    breaks the sorting, so in that case the indicator will
-    have a 1 starting at the location where the sorting breaks.
-    So finding that 1 means finding the location we want.
-   */
-
-  // aliases
-  using indicator_value_type = std::size_t;
-  using indicator_view_type =
-      ::Kokkos::View<indicator_value_type*, ExecutionSpace>;
-  using functor_type =
-      StdIsSortedUntilFunctor<IteratorType, indicator_view_type,
-                              ComparatorType>;
-
-  // do scan
-  // use num_elements-1 because each index handles i and i+1
-  const auto num_elements_minus_one = num_elements - 1;
-  indicator_view_type indicator("is_sorted_until_indicator_helper",
-                                num_elements_minus_one);
-  ::Kokkos::parallel_scan(
-      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements_minus_one),
-      functor_type(first, indicator, std::move(comp)));
-
-  // try to find the first sentinel value, which indicates
-  // where the sorting condition breaks
-  namespace KE                                  = ::Kokkos::Experimental;
-  constexpr indicator_value_type sentinel_value = 1;
-  auto r =
-      KE::find(ex, KE::cbegin(indicator), KE::cend(indicator), sentinel_value);
-  const auto shift = r - ::Kokkos::Experimental::cbegin(indicator);
-
-  return first + (shift + 1);
+    Do a par_reduce computing the *min* index that breaks the sorting.
+    If such an index is found, then the range is sorted until that element.
+    If no such index is found, then the range is sorted until the end.
+  */
+  using index_type = typename IteratorType::difference_type;
+  index_type reduction_result;
+  ::Kokkos::Min<index_type> reducer(reduction_result);
+  ::Kokkos::parallel_reduce(
+      label,
+      // use num_elements-1 because each index handles i and i+1
+      RangePolicy<ExecutionSpace>(ex, 0, num_elements - 1),
+      // use CTAD
+      StdIsSortedUntilFunctor(first, comp, reducer), reducer);
+
+  /* If the reduction result is equal to the initial value,
+     it means the range is sorted until the end */
+  index_type reduction_result_init;
+  reducer.init(reduction_result_init);
+  if (reduction_result == reduction_result_init) {
+    return last;
+  } else {
+    /* If such an index is found, then the range is sorted until there and
+       we need to return an iterator past the element found so do +1 */
+    return first + (reduction_result + 1);
+  }
 }
 
 template <class ExecutionSpace, class IteratorType>
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp b/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
index 170ec9f291..ad7f59232e 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
@@ -63,12 +63,14 @@ struct StdLexicographicalCompareFunctor {
     const auto& my_value1 = m_first1[i];
     const auto& my_value2 = m_first2[i];
 
-    bool different = m_comparator(my_value1, my_value2) ||
-                     m_comparator(my_value2, my_value1);
-    auto rv =
-        different
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    const bool different = m_comparator(my_value1, my_value2) ||
+                           m_comparator(my_value2, my_value1);
+
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (different) {
+      rv.min_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
index 9d2e31f63f..b742684467 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
@@ -42,10 +42,11 @@ struct StdMismatchRedFunctor {
     const auto& my_value1 = m_first1[i];
     const auto& my_value2 = m_first2[i];
 
-    auto rv =
-        !m_predicate(my_value1, my_value2)
-            ? red_value_type{i}
-            : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {i};
+    if (m_predicate(my_value1, my_value2)) {
+      rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    }
 
     m_reducer.join(red_value, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp b/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp
index 5457ae2508..54f7c5b612 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp
@@ -31,25 +31,6 @@ template <class ValueType>
 struct StdPartitionCopyScalar {
   ValueType true_count_;
   ValueType false_count_;
-
-  // Here we implement the copy assignment operators explicitly for consistency
-  // with how the Scalar structs are implemented inside
-  // Kokkos_Parallel_Reduce.hpp.
-  KOKKOS_FUNCTION
-  void operator=(const StdPartitionCopyScalar& other) {
-    true_count_  = other.true_count_;
-    false_count_ = other.false_count_;
-  }
-
-  // this is needed for
-  // OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp:699:21: error: no viable
-  // overloaded '=' m_returnvalue = 0;
-  //
-  KOKKOS_FUNCTION
-  void operator=(const ValueType value) {
-    true_count_  = value;
-    false_count_ = value;
-  }
 };
 
 template <class IndexType, class FirstFrom, class FirstDestTrue,
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp b/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
index 2d0ae2aac6..c9517f6977 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
@@ -39,10 +39,13 @@ struct StdPartitionPointFunctor {
   KOKKOS_FUNCTION
   void operator()(const index_type i, red_value_type& redValue) const {
     const auto predicate_value = m_p(m_first[i]);
-    auto rv =
-        predicate_value
-            ? red_value_type{::Kokkos::reduction_identity<index_type>::min()}
-            : red_value_type{i};
+
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {i};
+    if (predicate_value) {
+      rv = {::Kokkos::reduction_identity<index_type>::min()};
+    }
+
     m_reducer.join(redValue, rv);
   }
 
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp
index a4aaba26b9..7c75899cb8 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp
@@ -39,16 +39,7 @@ struct StdReverseFunctor {
 
   KOKKOS_FUNCTION
   void operator()(index_type i) const {
-    // the swap below is doing the same thing, but
-    // for Intel 18.0.5 does not work.
-    // But putting the impl directly here, it works.
-#ifdef KOKKOS_COMPILER_INTEL
-    typename InputIterator::value_type tmp = std::move(m_first[i]);
-    m_first[i]                             = std::move(m_last[-i - 1]);
-    m_last[-i - 1]                         = std::move(tmp);
-#else
     ::Kokkos::Experimental::swap(m_first[i], m_last[-i - 1]);
-#endif
   }
 
   StdReverseFunctor(InputIterator first, InputIterator last)
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
index a612a57231..2780151f29 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
@@ -60,9 +60,11 @@ struct StdSearchFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found) {
+      rv = {i};
+    }
 
     m_reducer.join(red_value, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
index 0d3b6bc706..98640136d4 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
@@ -59,9 +59,11 @@ struct StdSearchNFunctor {
       }
     }
 
-    const auto rv =
-        found ? red_value_type{i}
-              : red_value_type{::Kokkos::reduction_identity<IndexType>::min()};
+    // FIXME_NVHPC using a ternary operator causes problems
+    red_value_type rv = {::Kokkos::reduction_identity<IndexType>::min()};
+    if (found) {
+      rv.min_loc_true = i;
+    }
 
     m_reducer.join(red_value, rv);
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp b/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp
index 438acb989f..a5e4786d04 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp
@@ -35,16 +35,7 @@ struct StdSwapRangesFunctor {
 
   KOKKOS_FUNCTION
   void operator()(IndexType i) const {
-    // the swap below is doing the same thing, but
-    // for Intel 18.0.5 does not work.
-    // But putting the impl directly here, it works.
-#ifdef KOKKOS_COMPILER_INTEL
-    typename IteratorType1::value_type tmp = std::move(m_first1[i]);
-    m_first1[i]                            = std::move(m_first2[i]);
-    m_first2[i]                            = std::move(tmp);
-#else
     ::Kokkos::Experimental::swap(m_first1[i], m_first2[i]);
-#endif
   }
 
   KOKKOS_FUNCTION
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp
index 773e8c2f88..3bb337de36 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp
@@ -76,6 +76,8 @@ struct TransformExclusiveScanFunctor {
 
   KOKKOS_FUNCTION
   void join(value_type& update, const value_type& input) const {
+    if (input.is_initial) return;
+
     if (update.is_initial) {
       update.val = input.val;
     } else {
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp
index 9dde2b0fb1..05f8589086 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp
@@ -67,6 +67,8 @@ struct TransformInclusiveScanNoInitValueFunctor {
 
   KOKKOS_FUNCTION
   void join(value_type& update, const value_type& input) const {
+    if (input.is_initial) return;
+
     if (update.is_initial) {
       update.val = input.val;
     } else {
@@ -118,6 +120,8 @@ struct TransformInclusiveScanWithInitValueFunctor {
 
   KOKKOS_FUNCTION
   void join(value_type& update, const value_type& input) const {
+    if (input.is_initial) return;
+
     if (update.is_initial) {
       update.val = input.val;
     } else {
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ValueWrapperForNoNeutralElement.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ValueWrapperForNoNeutralElement.hpp
index 9b0d4d8244..8a73b8e0f1 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ValueWrapperForNoNeutralElement.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ValueWrapperForNoNeutralElement.hpp
@@ -29,12 +29,6 @@ template <class Scalar>
 struct ValueWrapperForNoNeutralElement {
   Scalar val;
   bool is_initial = true;
-
-  KOKKOS_FUNCTION
-  void operator=(const ValueWrapperForNoNeutralElement& rhs) {
-    val        = rhs.val;
-    is_initial = rhs.is_initial;
-  }
 };
 
 }  // namespace Impl
diff --git a/algorithms/unit_tests/CMakeLists.txt b/algorithms/unit_tests/CMakeLists.txt
index 0fe9c2006e..92d9f072c1 100644
--- a/algorithms/unit_tests/CMakeLists.txt
+++ b/algorithms/unit_tests/CMakeLists.txt
@@ -16,35 +16,45 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
     set(dir ${CMAKE_CURRENT_BINARY_DIR}/${dir})
     file(MAKE_DIRECTORY ${dir})
 
-    # -------------------------
-    # Sort1d,3d, Random
-    # -------------------------
-    set(SOURCES_A)
-    if(Tag STREQUAL "OpenMP")
-      LIST(APPEND SOURCES_A
-	TestOpenMP_Sort1D.cpp
-	TestOpenMP_Sort3D.cpp
-	TestOpenMP_SortDynamicView.cpp
-	)
-    endif()
-
+    # ------------------------------------------
+    # Sort
+    # ------------------------------------------
     # Each of these inputs is an .hpp file.
     # Generate a .cpp file for each one that runs it on the current backend (Tag),
     # and add this .cpp file to the sources for UnitTest_RandomAndSort.
-    foreach(SOURCES_A_Input
-        TestRandomCommon
-        TestSortCommon
-        TestNestedSort
-    )
-      set(file ${dir}/${SOURCES_A_Input}.cpp)
+    set(ALGO_SORT_SOURCES)
+    foreach(SOURCE_Input
+	TestSort
+	TestBinSortA
+	TestBinSortB
+	TestNestedSort
+      )
+      set(file ${dir}/${SOURCE_Input}.cpp)
       # Write to a temporary intermediate file and call configure_file to avoid
       # updating timestamps triggering unnecessary rebuilds on subsequent cmake runs.
       file(WRITE ${dir}/dummy.cpp
         "#include <Test${Tag}_Category.hpp>\n"
-        "#include <${SOURCES_A_Input}.hpp>\n"
+        "#include <${SOURCE_Input}.hpp>\n"
+        )
+      configure_file(${dir}/dummy.cpp ${file})
+      list(APPEND ALGO_SORT_SOURCES ${file})
+    endforeach()
+
+    # ------------------------------------------
+    # Random
+    # ------------------------------------------
+    # do as above
+    set(ALGO_RANDOM_SOURCES)
+    foreach(SOURCE_Input
+	TestRandom
+      )
+      set(file ${dir}/${SOURCE_Input}.cpp)
+      file(WRITE ${dir}/dummy.cpp
+        "#include <Test${Tag}_Category.hpp>\n"
+        "#include <${SOURCE_Input}.hpp>\n"
         )
       configure_file(${dir}/dummy.cpp ${file})
-      list(APPEND SOURCES_A ${file})
+      list(APPEND ALGO_RANDOM_SOURCES ${file})
     endforeach()
 
     # ------------------------------------------
@@ -145,6 +155,26 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
   endif()
 endforeach()
 
+# FIXME_OPENMPTARGET This test causes internal compiler errors as of 09/01/22
+# when compiling for Intel's Xe-HP GPUs.
+# FRIZZI: 04/26/2023: not sure if the compilation error is still applicable
+# but we conservatively leave this guard on
+if(NOT (KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM))
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_Sort
+    SOURCES
+    UnitTestMain.cpp
+    ${ALGO_SORT_SOURCES}
+  )
+
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_Random
+    SOURCES
+    UnitTestMain.cpp
+    ${ALGO_RANDOM_SOURCES}
+  )
+endif()
+
 # FIXME_OPENMPTARGET These tests cause internal compiler errors as of 09/01/22
 # when compiling for Intel's Xe-HP GPUs.
 if(KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM)
@@ -160,20 +190,9 @@ if(KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM)
   )
 endif()
 
-# FIXME_OPENMPTARGET This test causes internal compiler errors as of 09/01/22
-# when compiling for Intel's Xe-HP GPUs.
-if(NOT (KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM))
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_RandomAndSort
-    SOURCES
-      UnitTestMain.cpp
-      ${SOURCES_A}
-  )
-endif()
-
 foreach(ID A;B;C;D;E)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_StdSet_${ID}
+    AlgorithmsUnitTest_StdSet_${ID}
     SOURCES
     UnitTestMain.cpp
     ${STDALGO_SOURCES_${ID}}
@@ -184,7 +203,7 @@ endforeach()
 # when compiling for Intel's Xe-HP GPUs.
 if(NOT (KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM))
   KOKKOS_ADD_EXECUTABLE(
-    UnitTest_StdAlgoCompileOnly
+    AlgorithmsUnitTest_StdAlgoCompileOnly
     SOURCES TestStdAlgorithmsCompileOnly.cpp
   )
 endif()
diff --git a/algorithms/unit_tests/Makefile b/algorithms/unit_tests/Makefile
index e961e7ba2c..9e0f1d60a0 100644
--- a/algorithms/unit_tests/Makefile
+++ b/algorithms/unit_tests/Makefile
@@ -27,10 +27,8 @@ TARGETS =
 
 tmp := $(foreach device, $(KOKKOS_DEVICELIST), \
   $(if $(filter Test$(device).cpp, $(shell ls Test$(device).cpp 2>/dev/null)),,\
-    $(shell echo "\#include <Test"${device}"_Category.hpp>" > Test$(device).cpp); \
-    $(shell echo "\#include <TestRandomCommon.hpp>" >> Test$(device).cpp); \
-    $(shell echo "\#include <TestSortCommon.hpp>" >> Test$(device).cpp); \
-  ) \
+     $(shell echo "\#include <Test"${device}"_Category.hpp>" > Test$(device).cpp); \
+   ) \
 )
 
 ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
@@ -52,7 +50,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
-	OBJ_OPENMP = TestOpenMP.o TestOpenMP_Sort1D.o TestOpenMP_Sort3D.o TestOpenMP_SortDynamicView.o UnitTestMain.o gtest-all.o
+	OBJ_OPENMP = TestOpenMP.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_OpenMP
 	TEST_TARGETS += test-openmp
 endif
diff --git a/algorithms/unit_tests/TestBinSortA.hpp b/algorithms/unit_tests/TestBinSortA.hpp
new file mode 100644
index 0000000000..46f6486cdc
--- /dev/null
+++ b/algorithms/unit_tests/TestBinSortA.hpp
@@ -0,0 +1,280 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TEST_BINSORTA_HPP
+#define KOKKOS_ALGORITHMS_UNITTESTS_TEST_BINSORTA_HPP
+
+#include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
+#include <Kokkos_Random.hpp>
+#include <Kokkos_Sort.hpp>
+#include <random>
+
+namespace Test {
+namespace BinSortSetA {
+
+template <class ExecutionSpace, class Scalar>
+struct bin3d_is_sorted_struct {
+  using value_type      = unsigned int;
+  using execution_space = ExecutionSpace;
+
+  Kokkos::View<Scalar * [3], ExecutionSpace> keys;
+
+  int max_bins;
+  Scalar min;
+  Scalar max;
+
+  bin3d_is_sorted_struct(Kokkos::View<Scalar * [3], ExecutionSpace> keys_,
+                         int max_bins_, Scalar min_, Scalar max_)
+      : keys(keys_), max_bins(max_bins_), min(min_), max(max_) {}
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i, unsigned int& count) const {
+    int ix1 = int((keys(i, 0) - min) / max * max_bins);
+    int iy1 = int((keys(i, 1) - min) / max * max_bins);
+    int iz1 = int((keys(i, 2) - min) / max * max_bins);
+    int ix2 = int((keys(i + 1, 0) - min) / max * max_bins);
+    int iy2 = int((keys(i + 1, 1) - min) / max * max_bins);
+    int iz2 = int((keys(i + 1, 2) - min) / max * max_bins);
+
+    if (ix1 > ix2)
+      count++;
+    else if (ix1 == ix2) {
+      if (iy1 > iy2)
+        count++;
+      else if ((iy1 == iy2) && (iz1 > iz2))
+        count++;
+    }
+  }
+};
+
+template <class ExecutionSpace, class Scalar>
+struct sum3D {
+  using value_type      = double;
+  using execution_space = ExecutionSpace;
+
+  Kokkos::View<Scalar * [3], ExecutionSpace> keys;
+
+  sum3D(Kokkos::View<Scalar * [3], ExecutionSpace> keys_) : keys(keys_) {}
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i, double& count) const {
+    count += keys(i, 0);
+    count += keys(i, 1);
+    count += keys(i, 2);
+  }
+};
+
+template <class ExecutionSpace, typename KeyType>
+void test_3D_sort_impl(unsigned int n) {
+  using KeyViewType = Kokkos::View<KeyType * [3], ExecutionSpace>;
+
+  KeyViewType keys("Keys", n * n * n);
+
+  Kokkos::Random_XorShift64_Pool<ExecutionSpace> g(1931);
+  Kokkos::fill_random(keys, g, 100.0);
+
+  double sum_before       = 0.0;
+  double sum_after        = 0.0;
+  unsigned int sort_fails = 0;
+
+  ExecutionSpace exec;
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecutionSpace>(exec, 0, keys.extent(0)),
+      sum3D<ExecutionSpace, KeyType>(keys), sum_before);
+
+  int bin_1d = 1;
+  while (bin_1d * bin_1d * bin_1d * 4 < (int)keys.extent(0)) bin_1d *= 2;
+  int bin_max[3]                          = {bin_1d, bin_1d, bin_1d};
+  typename KeyViewType::value_type min[3] = {0, 0, 0};
+  typename KeyViewType::value_type max[3] = {100, 100, 100};
+
+  using BinOp = Kokkos::BinOp3D<KeyViewType>;
+  BinOp bin_op(bin_max, min, max);
+  Kokkos::BinSort<KeyViewType, BinOp> Sorter(keys, bin_op, false);
+  Sorter.create_permute_vector(exec);
+  Sorter.sort(exec, keys);
+
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecutionSpace>(exec, 0, keys.extent(0)),
+      sum3D<ExecutionSpace, KeyType>(keys), sum_after);
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecutionSpace>(exec, 0, keys.extent(0) - 1),
+      bin3d_is_sorted_struct<ExecutionSpace, KeyType>(keys, bin_1d, min[0],
+                                                      max[0]),
+      sort_fails);
+
+  double ratio   = sum_before / sum_after;
+  double epsilon = 1e-10;
+  unsigned int equal_sum =
+      (ratio > (1.0 - epsilon)) && (ratio < (1.0 + epsilon)) ? 1 : 0;
+
+  if (sort_fails)
+    printf("3D Sort Sum: %f %f Fails: %u\n", sum_before, sum_after, sort_fails);
+
+  ASSERT_EQ(sort_fails, 0u);
+  ASSERT_EQ(equal_sum, 1u);
+}
+
+template <class ExecutionSpace>
+void test_issue_1160_impl() {
+  Kokkos::View<int*, ExecutionSpace> element_("element", 10);
+  Kokkos::View<double*, ExecutionSpace> x_("x", 10);
+  Kokkos::View<double*, ExecutionSpace> v_("y", 10);
+
+  auto h_element = Kokkos::create_mirror_view(element_);
+  auto h_x       = Kokkos::create_mirror_view(x_);
+  auto h_v       = Kokkos::create_mirror_view(v_);
+
+  h_element(0) = 9;
+  h_element(1) = 8;
+  h_element(2) = 7;
+  h_element(3) = 6;
+  h_element(4) = 5;
+  h_element(5) = 4;
+  h_element(6) = 3;
+  h_element(7) = 2;
+  h_element(8) = 1;
+  h_element(9) = 0;
+
+  for (int i = 0; i < 10; ++i) {
+    h_v.access(i, 0) = h_x.access(i, 0) = double(h_element(i));
+  }
+  ExecutionSpace exec;
+  Kokkos::deep_copy(exec, element_, h_element);
+  Kokkos::deep_copy(exec, x_, h_x);
+  Kokkos::deep_copy(exec, v_, h_v);
+
+  using KeyViewType = decltype(element_);
+  using BinOp       = Kokkos::BinOp1D<KeyViewType>;
+
+  int begin = 3;
+  int end   = 8;
+  auto max  = h_element(begin);
+  auto min  = h_element(end - 1);
+  BinOp binner(end - begin, min, max);
+
+  Kokkos::BinSort<KeyViewType, BinOp> Sorter(element_, begin, end, binner,
+                                             false);
+  Sorter.create_permute_vector(exec);
+  Sorter.sort(exec, element_, begin, end);
+
+  Sorter.sort(exec, x_, begin, end);
+  Sorter.sort(exec, v_, begin, end);
+
+  Kokkos::deep_copy(exec, h_element, element_);
+  Kokkos::deep_copy(exec, h_x, x_);
+  Kokkos::deep_copy(exec, h_v, v_);
+  exec.fence();
+
+  ASSERT_EQ(h_element(0), 9);
+  ASSERT_EQ(h_element(1), 8);
+  ASSERT_EQ(h_element(2), 7);
+  ASSERT_EQ(h_element(3), 2);
+  ASSERT_EQ(h_element(4), 3);
+  ASSERT_EQ(h_element(5), 4);
+  ASSERT_EQ(h_element(6), 5);
+  ASSERT_EQ(h_element(7), 6);
+  ASSERT_EQ(h_element(8), 1);
+  ASSERT_EQ(h_element(9), 0);
+
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_EQ(h_element(i), int(h_x.access(i, 0)));
+    ASSERT_EQ(h_element(i), int(h_v.access(i, 0)));
+  }
+}
+
+template <class ExecutionSpace, class T>
+void test_sort_integer_overflow() {
+  // FIXME: this test is meant to test something for BinSort,
+  // but actually uses the kokkos::sort API with the assumption
+  // that underneath it calls binsort. I don't think this is correct,
+  // because if the kokkos::sort API chages impl, this test is not testing
+  // what it meants to test... so need to change this to actually use BinSort
+  // directly.
+
+  // array with two extrema in reverse order to expose integer overflow bug in
+  // bin calculation
+  T a[2]  = {Kokkos::Experimental::finite_max<T>::value,
+            Kokkos::Experimental::finite_min<T>::value};
+  auto vd = Kokkos::create_mirror_view_and_copy(
+      ExecutionSpace(), Kokkos::View<T[2], Kokkos::HostSpace>(a));
+  Kokkos::sort(vd);
+  auto vh = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), vd);
+  EXPECT_TRUE(std::is_sorted(vh.data(), vh.data() + 2))
+      << "view (" << vh[0] << ", " << vh[1] << ") is not sorted";
+}
+
+}  // namespace BinSortSetA
+
+TEST(TEST_CATEGORY, BinSortGenericTests) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using key_type       = unsigned;
+  constexpr int N      = 171;
+
+#if defined(KOKKOS_ENABLE_CUDA) && \
+    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
+  if (!std::is_same_v<ExecutionSpace, Kokkos::Cuda>)
+#endif
+    BinSortSetA::test_3D_sort_impl<ExecutionSpace, key_type>(N);
+
+#if defined(KOKKOS_ENABLE_CUDA) && \
+    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
+  if (!std::is_same_v<ExecutionSpace, Kokkos::Cuda>)
+#endif
+    BinSortSetA::test_issue_1160_impl<ExecutionSpace>();
+
+  BinSortSetA::test_sort_integer_overflow<ExecutionSpace, long long>();
+  BinSortSetA::test_sort_integer_overflow<ExecutionSpace, unsigned long long>();
+  BinSortSetA::test_sort_integer_overflow<ExecutionSpace, int>();
+}
+
+TEST(TEST_CATEGORY, BinSortEmptyView) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  // the bounds and extents used below are totally arbitrary
+  // and, in theory, should have no impact
+
+  using KeyViewType = Kokkos::View<int*, ExecutionSpace>;
+  KeyViewType kv("kv", 20);
+
+  using BinOp_t = Kokkos::BinOp1D<KeyViewType>;
+  BinOp_t binOp(5, 0, 10);
+  Kokkos::BinSort<KeyViewType, BinOp_t> Sorter(ExecutionSpace{}, kv, binOp);
+
+  // does not matter if we use int or something else
+  Kokkos::View<int*, ExecutionSpace> v("v", 0);
+
+  // test all exposed public sort methods
+  ASSERT_NO_THROW(Sorter.sort(ExecutionSpace(), v, 0, 0));
+  ASSERT_NO_THROW(Sorter.sort(v, 0, 0));
+  ASSERT_NO_THROW(Sorter.sort(ExecutionSpace(), v));
+  ASSERT_NO_THROW(Sorter.sort(v));
+}
+
+TEST(TEST_CATEGORY, BinSortEmptyKeysView) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  using KeyViewType = Kokkos::View<int*, ExecutionSpace>;
+  KeyViewType kv("kv", 0);
+
+  using BinOp_t = Kokkos::BinOp1D<KeyViewType>;
+  BinOp_t binOp(5, 0, 10);
+  Kokkos::BinSort<KeyViewType, BinOp_t> Sorter(ExecutionSpace{}, kv, binOp);
+
+  ASSERT_NO_THROW(Sorter.create_permute_vector(ExecutionSpace{}));
+}
+
+}  // namespace Test
+#endif
diff --git a/algorithms/unit_tests/TestBinSortB.hpp b/algorithms/unit_tests/TestBinSortB.hpp
new file mode 100644
index 0000000000..0707411f59
--- /dev/null
+++ b/algorithms/unit_tests/TestBinSortB.hpp
@@ -0,0 +1,262 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TEST_BINSORTB_HPP
+#define KOKKOS_ALGORITHMS_UNITTESTS_TEST_BINSORTB_HPP
+
+#include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
+#include <Kokkos_Random.hpp>
+#include <Kokkos_Sort.hpp>
+#include <Kokkos_StdAlgorithms.hpp>
+#include <TestStdAlgorithmsHelperFunctors.hpp>
+#include <random>
+#include <numeric>  //needed for iota
+
+namespace Test {
+namespace BinSortSetB {
+
+template <class ViewTypeFrom, class ViewTypeTo>
+struct CopyFunctorRank2 {
+  ViewTypeFrom m_view_from;
+  ViewTypeTo m_view_to;
+
+  CopyFunctorRank2() = delete;
+
+  CopyFunctorRank2(const ViewTypeFrom view_from, const ViewTypeTo view_to)
+      : m_view_from(view_from), m_view_to(view_to) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int k) const {
+    const auto i    = k / m_view_from.extent(1);
+    const auto j    = k % m_view_from.extent(1);
+    m_view_to(i, j) = m_view_from(i, j);
+  }
+};
+
+template <class ValueType, class... Props>
+auto create_deep_copyable_compatible_view_with_same_extent(
+    Kokkos::View<ValueType*, Props...> view) {
+  using view_type            = Kokkos::View<ValueType*, Props...>;
+  using view_value_type      = typename view_type::value_type;
+  using view_exespace        = typename view_type::execution_space;
+  const std::size_t ext0     = view.extent(0);
+  using view_deep_copyable_t = Kokkos::View<view_value_type*, view_exespace>;
+  return view_deep_copyable_t{"view_dc", ext0};
+}
+
+template <class ValueType, class... Props>
+auto create_deep_copyable_compatible_view_with_same_extent(
+    Kokkos::View<ValueType**, Props...> view) {
+  using view_type            = Kokkos::View<ValueType**, Props...>;
+  using view_value_type      = typename view_type::value_type;
+  using view_exespace        = typename view_type::execution_space;
+  using view_deep_copyable_t = Kokkos::View<view_value_type**, view_exespace>;
+  const std::size_t ext0     = view.extent(0);
+  const std::size_t ext1     = view.extent(1);
+  return view_deep_copyable_t{"view_dc", ext0, ext1};
+}
+
+template <class ViewType>
+auto create_deep_copyable_compatible_clone(ViewType view) {
+  static_assert(ViewType::rank <= 2);
+
+  auto view_dc    = create_deep_copyable_compatible_view_with_same_extent(view);
+  using view_dc_t = decltype(view_dc);
+  if constexpr (ViewType::rank == 1) {
+    Test::stdalgos::CopyFunctor<ViewType, view_dc_t> F1(view, view_dc);
+    Kokkos::parallel_for("copy", view.extent(0), F1);
+  } else {
+    static_assert(ViewType::rank == 2, "Only rank 1 or 2 supported.");
+    CopyFunctorRank2<ViewType, view_dc_t> F1(view, view_dc);
+    Kokkos::parallel_for("copy", view.extent(0) * view.extent(1), F1);
+  }
+  return view_dc;
+}
+
+template <class ViewType>
+auto create_host_space_copy(ViewType view) {
+  auto view_dc = create_deep_copyable_compatible_clone(view);
+  return create_mirror_view_and_copy(Kokkos::HostSpace(), view_dc);
+}
+
+template <class KeyType, class ExecutionSpace>
+auto create_rank1_dev_and_host_views_of_keys(const ExecutionSpace& exec,
+                                             int N) {
+  namespace KE = Kokkos::Experimental;
+  Kokkos::DefaultHostExecutionSpace defaultHostExeSpace;
+
+  using KeyViewType = Kokkos::View<KeyType*, ExecutionSpace>;
+  KeyViewType keys("keys", N);
+  auto keys_h = Kokkos::create_mirror_view(keys);
+  std::iota(KE::begin(keys_h), KE::end(keys_h), KeyType(0));
+  KE::reverse(defaultHostExeSpace, keys_h);
+  // keys now is = [N-1,N-2,...,2,1,0], shuffle it for avoid trivial case
+  std::random_device rd;
+  std::mt19937 g(rd());
+  std::shuffle(KE::begin(keys_h), KE::end(keys_h), g);
+  Kokkos::deep_copy(exec, keys, keys_h);
+
+  return std::make_pair(keys, keys_h);
+}
+
+template <class ExecutionSpace, class ValueType, int ValuesViewRank,
+          std::enable_if_t<ValuesViewRank == 1, int> = 0>
+auto create_strided_view(std::size_t numRows, std::size_t /*numCols*/) {
+  Kokkos::LayoutStride layout{numRows, 2};
+  using v_t = Kokkos::View<ValueType*, Kokkos::LayoutStride, ExecutionSpace>;
+  v_t v("v", layout);
+  return v;
+}
+
+template <class ExecutionSpace, class ValueType, int ValuesViewRank,
+          std::enable_if_t<ValuesViewRank == 2, int> = 0>
+auto create_strided_view(std::size_t numRows, std::size_t numCols) {
+  Kokkos::LayoutStride layout{numRows, 2, numCols, numRows * 2};
+  using v_t = Kokkos::View<ValueType**, Kokkos::LayoutStride, ExecutionSpace>;
+  v_t v("v", layout);
+  return v;
+}
+
+template <class ExecutionSpace, class KeyType, class ValueType,
+          int ValuesViewRank>
+void test_on_view_with_stride(std::size_t numRows, std::size_t indB,
+                              std::size_t indE, std::size_t numCols = 1) {
+  ExecutionSpace exec;
+  Kokkos::DefaultHostExecutionSpace defaultHostExeSpace;
+  namespace KE = Kokkos::Experimental;
+
+  // 1. generate 1D view of keys
+  auto [keys, keys_h] =
+      create_rank1_dev_and_host_views_of_keys<KeyType>(exec, numRows);
+  using KeyViewType = decltype(keys);
+
+  // need this map key->row to use later for checking
+  std::unordered_map<KeyType, std::size_t> keyToRowBeforeSort;
+  for (std::size_t i = 0; i < numRows; ++i) {
+    keyToRowBeforeSort[keys_h(i)] = i;
+  }
+
+  // 2. create binOp
+  using BinOp = Kokkos::BinOp1D<KeyViewType>;
+  auto itB    = KE::cbegin(keys_h) + indB;
+  auto itE    = itB + indE - indB;
+  auto it     = KE::minmax_element(defaultHostExeSpace, itB, itE);
+  // seems like the behavior is odd when we use # buckets = # keys
+  // so use +5 for using more buckets than keys.
+  // This is something to investigate.
+  BinOp binner(indE - indB + 5, *it.first, *it.second);
+
+  // 3. create sorter
+  Kokkos::BinSort<KeyViewType, BinOp> sorter(keys, indB, indE, binner, false);
+  sorter.create_permute_vector(exec);
+  sorter.sort(exec, keys, indB, indE);
+  Kokkos::deep_copy(exec, keys_h, keys);
+
+  auto v = create_strided_view<ExecutionSpace, ValueType, ValuesViewRank>(
+      numRows, numCols);
+
+  Kokkos::Random_XorShift64_Pool<ExecutionSpace> pool(73931);
+  Kokkos::fill_random(v, pool, ValueType(545));
+  auto v_before_sort_h = create_host_space_copy(v);
+  sorter.sort(exec, v, indB, indE);
+  auto v_after_sort_h = create_host_space_copy(v);
+
+  for (size_t i = 0; i < v.extent(0); ++i) {
+    // if i within [indB,indE), the sorting was done
+    // so we need to do proper checking since rows have changed
+    if (i >= size_t(indB) && i < size_t(indE)) {
+      const KeyType key = keys_h(i);
+      if constexpr (ValuesViewRank == 1) {
+        ASSERT_TRUE(v_before_sort_h(keyToRowBeforeSort.at(key)) ==
+                    v_after_sort_h(i));
+      } else {
+        for (size_t j = 0; j < v.extent(1); ++j) {
+          ASSERT_TRUE(v_before_sort_h(keyToRowBeforeSort.at(key), j) ==
+                      v_after_sort_h(i, j));
+        }
+      }
+    }
+    // outside the target bounds, then the i-th row remains unchanged
+    else {
+      if constexpr (ValuesViewRank == 1) {
+        ASSERT_TRUE(v_before_sort_h(i) == v_after_sort_h(i));
+      } else {
+        for (size_t j = 0; j < v.extent(1); ++j) {
+          ASSERT_TRUE(v_before_sort_h(i, j) == v_after_sort_h(i, j));
+        }
+      }
+    }
+  }
+}
+
+template <class ExecutionSpace, class KeyType, class ValueType>
+void run_for_rank1() {
+  constexpr int rank = 1;
+
+  // trivial case
+  test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(1, 0, 1);
+
+  // nontrivial cases
+  for (std::size_t N : {311, 710017}) {
+    // various cases for bounds
+    test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(N, 0, N);
+    test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(N, 3, N);
+    test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(N, 0,
+                                                                       N - 4);
+    test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(N, 4,
+                                                                       N - 3);
+  }
+}
+
+template <class ExecutionSpace, class KeyType, class ValueType>
+void run_for_rank2() {
+  constexpr int rank = 2;
+
+  // trivial case
+  test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(1, 0, 1,
+                                                                     1);
+
+  // nontrivial cases
+  for (std::size_t Nr : {11, 1157, 710017}) {
+    for (std::size_t Nc : {3, 51}) {
+      // various cases for bounds
+      test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(
+          Nr, 0, Nr, Nc);
+      test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(
+          Nr, 3, Nr, Nc);
+      test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(
+          Nr, 0, Nr - 4, Nc);
+      test_on_view_with_stride<ExecutionSpace, KeyType, ValueType, rank>(
+          Nr, 4, Nr - 3, Nc);
+    }
+  }
+}
+
+}  // namespace BinSortSetB
+
+TEST(TEST_CATEGORY, BinSortUnsignedKeyLayoutStrideValues) {
+  using ExeSpace = TEST_EXECSPACE;
+  using key_type = unsigned;
+  BinSortSetB::run_for_rank1<ExeSpace, key_type, int>();
+  BinSortSetB::run_for_rank1<ExeSpace, key_type, double>();
+
+  BinSortSetB::run_for_rank2<ExeSpace, key_type, int>();
+  BinSortSetB::run_for_rank2<ExeSpace, key_type, double>();
+}
+
+}  // namespace Test
+#endif
diff --git a/algorithms/unit_tests/TestNestedSort.hpp b/algorithms/unit_tests/TestNestedSort.hpp
index 37ee211b42..1b7a3f48fc 100644
--- a/algorithms/unit_tests/TestNestedSort.hpp
+++ b/algorithms/unit_tests/TestNestedSort.hpp
@@ -17,14 +17,14 @@
 #ifndef KOKKOS_ALGORITHMS_UNITTESTS_TEST_NESTED_SORT_HPP
 #define KOKKOS_ALGORITHMS_UNITTESTS_TEST_NESTED_SORT_HPP
 
+#include <gtest/gtest.h>
 #include <unordered_set>
 #include <random>
 #include <Kokkos_Random.hpp>
 #include <Kokkos_NestedSort.hpp>
 
 namespace Test {
-
-namespace Impl {
+namespace NestedSortImpl {
 
 // Comparator for sorting in descending order
 template <typename Key>
@@ -383,24 +383,28 @@ void test_nested_sort_by_key(unsigned int N, KeyType minKey, KeyType maxKey,
   test_nested_sort_by_key_impl<ExecutionSpace, KeyType, ValueType>(
       N, N, false, true, minKey, maxKey, minVal, maxVal);
 }
-}  // namespace Impl
+}  // namespace NestedSortImpl
 
 TEST(TEST_CATEGORY, NestedSort) {
-  Impl::test_nested_sort<TEST_EXECSPACE, unsigned>(171, 0U, UINT_MAX);
-  Impl::test_nested_sort<TEST_EXECSPACE, float>(42, -1e6f, 1e6f);
-  Impl::test_nested_sort<TEST_EXECSPACE, char>(67, CHAR_MIN, CHAR_MAX);
+  using ExecutionSpace = TEST_EXECSPACE;
+  NestedSortImpl::test_nested_sort<ExecutionSpace, unsigned>(171, 0U, UINT_MAX);
+  NestedSortImpl::test_nested_sort<ExecutionSpace, float>(42, -1e6f, 1e6f);
+  NestedSortImpl::test_nested_sort<ExecutionSpace, char>(67, CHAR_MIN,
+                                                         CHAR_MAX);
 }
 
 TEST(TEST_CATEGORY, NestedSortByKey) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
   // Second/third template arguments are key and value respectively.
   // In sort_by_key_X functions, a key view and a value view are both permuted
   // to make the keys sorted. This means that the value type doesn't need to be
   // ordered, unlike key
-  Impl::test_nested_sort_by_key<TEST_EXECSPACE, unsigned, unsigned>(
+  NestedSortImpl::test_nested_sort_by_key<ExecutionSpace, unsigned, unsigned>(
       161, 0U, UINT_MAX, 0U, UINT_MAX);
-  Impl::test_nested_sort_by_key<TEST_EXECSPACE, float, char>(
+  NestedSortImpl::test_nested_sort_by_key<ExecutionSpace, float, char>(
       267, -1e6f, 1e6f, CHAR_MIN, CHAR_MAX);
-  Impl::test_nested_sort_by_key<TEST_EXECSPACE, char, double>(
+  NestedSortImpl::test_nested_sort_by_key<ExecutionSpace, char, double>(
       11, CHAR_MIN, CHAR_MAX, 2.718, 3.14);
 }
 
diff --git a/algorithms/unit_tests/TestOpenMP_Sort1D.cpp b/algorithms/unit_tests/TestOpenMP_Sort1D.cpp
deleted file mode 100644
index e06486618f..0000000000
--- a/algorithms/unit_tests/TestOpenMP_Sort1D.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_OPENMP
-
-#include <gtest/gtest.h>
-#include <Kokkos_Core.hpp>
-
-//----------------------------------------------------------------------------
-#include <TestRandom.hpp>
-#include <TestSort.hpp>
-#include <iomanip>
-
-namespace Test {
-
-TEST(openmp, SortUnsigned1D) {
-  Impl::test_1D_sort<Kokkos::OpenMP, unsigned>(171);
-}
-
-TEST(openmp, SortIssue1160) { Impl::test_issue_1160_sort<Kokkos::OpenMP>(); }
-
-}  // namespace Test
-#else
-void KOKKOS_ALGORITHMS_UNITTESTS_TESTOPENMP_PREVENT_LINK_ERROR() {}
-#endif
diff --git a/algorithms/unit_tests/TestOpenMP_SortDynamicView.cpp b/algorithms/unit_tests/TestOpenMP_SortDynamicView.cpp
deleted file mode 100644
index 549d09f1f2..0000000000
--- a/algorithms/unit_tests/TestOpenMP_SortDynamicView.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_OPENMP
-
-#include <gtest/gtest.h>
-#include <Kokkos_Core.hpp>
-
-//----------------------------------------------------------------------------
-#include <TestRandom.hpp>
-#include <TestSort.hpp>
-#include <iomanip>
-
-namespace Test {
-
-TEST(openmp, SortUnsignedDynamicView) {
-  Impl::test_dynamic_view_sort<Kokkos::OpenMP, unsigned>(171);
-}
-
-}  // namespace Test
-#else
-void KOKKOS_ALGORITHMS_UNITTESTS_TESTOPENMP_PREVENT_LINK_ERROR() {}
-#endif
diff --git a/algorithms/unit_tests/TestRandom.hpp b/algorithms/unit_tests/TestRandom.hpp
index 607e94c784..e9dc3327a6 100644
--- a/algorithms/unit_tests/TestRandom.hpp
+++ b/algorithms/unit_tests/TestRandom.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_TEST_DUALVIEW_HPP
-#define KOKKOS_TEST_DUALVIEW_HPP
+#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TEST_RANDOM_HPP
+#define KOKKOS_ALGORITHMS_UNITTESTS_TEST_RANDOM_HPP
 
 #include <gtest/gtest.h>
 #include <iostream>
@@ -29,8 +29,7 @@
 #include <chrono>
 
 namespace Test {
-
-namespace Impl {
+namespace AlgoRandomImpl {
 
 // This test runs the random number generators and uses some statistic tests to
 // check the 'goodness' of the random numbers:
@@ -469,42 +468,46 @@ struct TestDynRankView {
     ASSERT_LE(val.max_val, max);
   }
 };
-}  // namespace Impl
 
-template <typename ExecutionSpace>
-void test_random_xorshift64() {
+}  // namespace AlgoRandomImpl
+
+TEST(TEST_CATEGORY, Random_XorShift64) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
 #if defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_CUDA) || \
     defined(KOKKOS_ENABLE_HIP)
   const int num_draws = 132141141;
 #else  // SERIAL, HPX, OPENMP
   const int num_draws = 10240000;
 #endif
-  Impl::test_random<Kokkos::Random_XorShift64_Pool<ExecutionSpace>>(num_draws);
-  Impl::test_random<Kokkos::Random_XorShift64_Pool<
+  AlgoRandomImpl::test_random<Kokkos::Random_XorShift64_Pool<ExecutionSpace>>(
+      num_draws);
+  AlgoRandomImpl::test_random<Kokkos::Random_XorShift64_Pool<
       Kokkos::Device<ExecutionSpace, typename ExecutionSpace::memory_space>>>(
       num_draws);
-  Impl::TestDynRankView<ExecutionSpace,
-                        Kokkos::Random_XorShift64_Pool<ExecutionSpace>>(10000)
+  AlgoRandomImpl::TestDynRankView<
+      ExecutionSpace, Kokkos::Random_XorShift64_Pool<ExecutionSpace>>(10000)
       .run();
 }
 
-template <typename ExecutionSpace>
-void test_random_xorshift1024() {
+TEST(TEST_CATEGORY, Random_XorShift1024_0) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
 #if defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_CUDA) || \
     defined(KOKKOS_ENABLE_HIP)
   const int num_draws = 52428813;
 #else  // SERIAL, HPX, OPENMP
   const int num_draws = 10130144;
 #endif
-  Impl::test_random<Kokkos::Random_XorShift1024_Pool<ExecutionSpace>>(
+  AlgoRandomImpl::test_random<Kokkos::Random_XorShift1024_Pool<ExecutionSpace>>(
       num_draws);
-  Impl::test_random<Kokkos::Random_XorShift1024_Pool<
+  AlgoRandomImpl::test_random<Kokkos::Random_XorShift1024_Pool<
       Kokkos::Device<ExecutionSpace, typename ExecutionSpace::memory_space>>>(
       num_draws);
-  Impl::TestDynRankView<ExecutionSpace,
-                        Kokkos::Random_XorShift1024_Pool<ExecutionSpace>>(10000)
+  AlgoRandomImpl::TestDynRankView<
+      ExecutionSpace, Kokkos::Random_XorShift1024_Pool<ExecutionSpace>>(10000)
       .run();
 }
-}  // namespace Test
 
-#endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
+}  // namespace Test
+#endif
diff --git a/algorithms/unit_tests/TestRandomAccessIterator.cpp b/algorithms/unit_tests/TestRandomAccessIterator.cpp
index 439d171c8a..fd3a875b1e 100644
--- a/algorithms/unit_tests/TestRandomAccessIterator.cpp
+++ b/algorithms/unit_tests/TestRandomAccessIterator.cpp
@@ -54,7 +54,7 @@ void test_random_access_it_verify(IteratorType it, ValueType gold_value) {
   Kokkos::parallel_for("_std_algo_copy", 1, cf);
   auto v_h =
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), checkView);
-  EXPECT_EQ(v_h(), gold_value);
+  ASSERT_EQ(v_h(), gold_value);
 }
 
 TEST_F(random_access_iterator_test, dereference) {
@@ -96,9 +96,9 @@ void test_random_access_it_subscript_op_verify(IteratorType it) {
 
   auto v_h =
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), checkView);
-  EXPECT_EQ(v_h(0), (value_t)0);
-  EXPECT_EQ(v_h(1), (value_t)1);
-  EXPECT_EQ(v_h(2), (value_t)2);
+  ASSERT_EQ(v_h(0), (value_t)0);
+  ASSERT_EQ(v_h(1), (value_t)1);
+  ASSERT_EQ(v_h(2), (value_t)2);
 }
 
 TEST_F(random_access_iterator_test, subscript_operator) {
@@ -188,9 +188,9 @@ TEST_F(random_access_iterator_test, operatorsSet4) {
   auto it7 = KE::Impl::RandomAccessIterator<static_view_t>(m_static_view, 3);
   auto it8 = KE::Impl::RandomAccessIterator<dyn_view_t>(m_dynamic_view, 3);
   auto it9 = KE::Impl::RandomAccessIterator<strided_view_t>(m_strided_view, 3);
-  EXPECT_EQ(it1, it7);
-  EXPECT_EQ(it2, it8);
-  EXPECT_EQ(it3, it9);
+  ASSERT_EQ(it1, it7);
+  ASSERT_EQ(it2, it8);
+  ASSERT_EQ(it3, it9);
   EXPECT_GE(it1, it7);
   EXPECT_GE(it2, it8);
   EXPECT_GE(it3, it9);
@@ -205,16 +205,16 @@ TEST_F(random_access_iterator_test, assignment_operator) {
   EXPECT_NE(it1, it2);
 
   it2 = it1;
-  EXPECT_EQ(it1, it2);
+  ASSERT_EQ(it1, it2);
 }
 
 TEST_F(random_access_iterator_test, distance) {
   auto first = KE::begin(m_dynamic_view);
   auto last  = KE::end(m_dynamic_view);
 
-  EXPECT_EQ(0, KE::distance(first, first));
-  EXPECT_EQ(1, KE::distance(first, first + 1));
-  EXPECT_EQ(m_dynamic_view.extent(0), size_t(KE::distance(first, last)));
+  ASSERT_EQ(0, KE::distance(first, first));
+  ASSERT_EQ(1, KE::distance(first, first + 1));
+  ASSERT_EQ(m_dynamic_view.extent(0), size_t(KE::distance(first, last)));
 }
 
 }  // namespace stdalgos
diff --git a/algorithms/unit_tests/TestSort.hpp b/algorithms/unit_tests/TestSort.hpp
index d903888878..968fb8950b 100644
--- a/algorithms/unit_tests/TestSort.hpp
+++ b/algorithms/unit_tests/TestSort.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_HPP
-#define KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_HPP
+#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TEST_SORT_HPP
+#define KOKKOS_ALGORITHMS_UNITTESTS_TEST_SORT_HPP
 
 #include <gtest/gtest.h>
 #include <Kokkos_Core.hpp>
@@ -24,8 +24,7 @@
 #include <Kokkos_Sort.hpp>
 
 namespace Test {
-
-namespace Impl {
+namespace SortImpl {
 
 template <class ExecutionSpace, class Scalar>
 struct is_sorted_struct {
@@ -53,56 +52,6 @@ struct sum {
   void operator()(int i, double& count) const { count += keys(i); }
 };
 
-template <class ExecutionSpace, class Scalar>
-struct bin3d_is_sorted_struct {
-  using value_type      = unsigned int;
-  using execution_space = ExecutionSpace;
-
-  Kokkos::View<Scalar * [3], ExecutionSpace> keys;
-
-  int max_bins;
-  Scalar min;
-  Scalar max;
-
-  bin3d_is_sorted_struct(Kokkos::View<Scalar * [3], ExecutionSpace> keys_,
-                         int max_bins_, Scalar min_, Scalar max_)
-      : keys(keys_), max_bins(max_bins_), min(min_), max(max_) {}
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int i, unsigned int& count) const {
-    int ix1 = int((keys(i, 0) - min) / max * max_bins);
-    int iy1 = int((keys(i, 1) - min) / max * max_bins);
-    int iz1 = int((keys(i, 2) - min) / max * max_bins);
-    int ix2 = int((keys(i + 1, 0) - min) / max * max_bins);
-    int iy2 = int((keys(i + 1, 1) - min) / max * max_bins);
-    int iz2 = int((keys(i + 1, 2) - min) / max * max_bins);
-
-    if (ix1 > ix2)
-      count++;
-    else if (ix1 == ix2) {
-      if (iy1 > iy2)
-        count++;
-      else if ((iy1 == iy2) && (iz1 > iz2))
-        count++;
-    }
-  }
-};
-
-template <class ExecutionSpace, class Scalar>
-struct sum3D {
-  using value_type      = double;
-  using execution_space = ExecutionSpace;
-
-  Kokkos::View<Scalar * [3], ExecutionSpace> keys;
-
-  sum3D(Kokkos::View<Scalar * [3], ExecutionSpace> keys_) : keys(keys_) {}
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int i, double& count) const {
-    count += keys(i, 0);
-    count += keys(i, 1);
-    count += keys(i, 2);
-  }
-};
-
 template <class ExecutionSpace, typename KeyType>
 void test_1D_sort_impl(unsigned int n) {
   using KeyViewType = Kokkos::View<KeyType*, ExecutionSpace>;
@@ -142,57 +91,6 @@ void test_1D_sort_impl(unsigned int n) {
   ASSERT_EQ(equal_sum, 1u);
 }
 
-template <class ExecutionSpace, typename KeyType>
-void test_3D_sort_impl(unsigned int n) {
-  using KeyViewType = Kokkos::View<KeyType * [3], ExecutionSpace>;
-
-  KeyViewType keys("Keys", n * n * n);
-
-  Kokkos::Random_XorShift64_Pool<ExecutionSpace> g(1931);
-  Kokkos::fill_random(keys, g, 100.0);
-
-  double sum_before       = 0.0;
-  double sum_after        = 0.0;
-  unsigned int sort_fails = 0;
-
-  ExecutionSpace exec;
-  Kokkos::parallel_reduce(
-      Kokkos::RangePolicy<ExecutionSpace>(exec, 0, keys.extent(0)),
-      sum3D<ExecutionSpace, KeyType>(keys), sum_before);
-
-  int bin_1d = 1;
-  while (bin_1d * bin_1d * bin_1d * 4 < (int)keys.extent(0)) bin_1d *= 2;
-  int bin_max[3]                          = {bin_1d, bin_1d, bin_1d};
-  typename KeyViewType::value_type min[3] = {0, 0, 0};
-  typename KeyViewType::value_type max[3] = {100, 100, 100};
-
-  using BinOp = Kokkos::BinOp3D<KeyViewType>;
-  BinOp bin_op(bin_max, min, max);
-  Kokkos::BinSort<KeyViewType, BinOp> Sorter(keys, bin_op, false);
-  Sorter.create_permute_vector(exec);
-  Sorter.sort(exec, keys);
-
-  Kokkos::parallel_reduce(
-      Kokkos::RangePolicy<ExecutionSpace>(exec, 0, keys.extent(0)),
-      sum3D<ExecutionSpace, KeyType>(keys), sum_after);
-  Kokkos::parallel_reduce(
-      Kokkos::RangePolicy<ExecutionSpace>(exec, 0, keys.extent(0) - 1),
-      bin3d_is_sorted_struct<ExecutionSpace, KeyType>(keys, bin_1d, min[0],
-                                                      max[0]),
-      sort_fails);
-
-  double ratio   = sum_before / sum_after;
-  double epsilon = 1e-10;
-  unsigned int equal_sum =
-      (ratio > (1.0 - epsilon)) && (ratio < (1.0 + epsilon)) ? 1 : 0;
-
-  if (sort_fails)
-    printf("3D Sort Sum: %f %f Fails: %u\n", sum_before, sum_after, sort_fails);
-
-  ASSERT_EQ(sort_fails, 0u);
-  ASSERT_EQ(equal_sum, 1u);
-}
-
 //----------------------------------------------------------------------------
 
 template <class ExecutionSpace, typename KeyType>
@@ -259,74 +157,6 @@ void test_dynamic_view_sort_impl(unsigned int n) {
 
 //----------------------------------------------------------------------------
 
-template <class ExecutionSpace>
-void test_issue_1160_impl() {
-  Kokkos::View<int*, ExecutionSpace> element_("element", 10);
-  Kokkos::View<double*, ExecutionSpace> x_("x", 10);
-  Kokkos::View<double*, ExecutionSpace> v_("y", 10);
-
-  auto h_element = Kokkos::create_mirror_view(element_);
-  auto h_x       = Kokkos::create_mirror_view(x_);
-  auto h_v       = Kokkos::create_mirror_view(v_);
-
-  h_element(0) = 9;
-  h_element(1) = 8;
-  h_element(2) = 7;
-  h_element(3) = 6;
-  h_element(4) = 5;
-  h_element(5) = 4;
-  h_element(6) = 3;
-  h_element(7) = 2;
-  h_element(8) = 1;
-  h_element(9) = 0;
-
-  for (int i = 0; i < 10; ++i) {
-    h_v.access(i, 0) = h_x.access(i, 0) = double(h_element(i));
-  }
-  ExecutionSpace exec;
-  Kokkos::deep_copy(exec, element_, h_element);
-  Kokkos::deep_copy(exec, x_, h_x);
-  Kokkos::deep_copy(exec, v_, h_v);
-
-  using KeyViewType = decltype(element_);
-  using BinOp       = Kokkos::BinOp1D<KeyViewType>;
-
-  int begin = 3;
-  int end   = 8;
-  auto max  = h_element(begin);
-  auto min  = h_element(end - 1);
-  BinOp binner(end - begin, min, max);
-
-  Kokkos::BinSort<KeyViewType, BinOp> Sorter(element_, begin, end, binner,
-                                             false);
-  Sorter.create_permute_vector(exec);
-  Sorter.sort(exec, element_, begin, end);
-
-  Sorter.sort(exec, x_, begin, end);
-  Sorter.sort(exec, v_, begin, end);
-
-  Kokkos::deep_copy(exec, h_element, element_);
-  Kokkos::deep_copy(exec, h_x, x_);
-  Kokkos::deep_copy(exec, h_v, v_);
-  exec.fence();
-
-  ASSERT_EQ(h_element(0), 9);
-  ASSERT_EQ(h_element(1), 8);
-  ASSERT_EQ(h_element(2), 7);
-  ASSERT_EQ(h_element(3), 2);
-  ASSERT_EQ(h_element(4), 3);
-  ASSERT_EQ(h_element(5), 4);
-  ASSERT_EQ(h_element(6), 5);
-  ASSERT_EQ(h_element(7), 6);
-  ASSERT_EQ(h_element(8), 1);
-  ASSERT_EQ(h_element(9), 0);
-
-  for (int i = 0; i < 10; ++i) {
-    ASSERT_EQ(h_element(i), int(h_x.access(i, 0)));
-    ASSERT_EQ(h_element(i), int(h_v.access(i, 0)));
-  }
-}
-
 template <class ExecutionSpace>
 void test_issue_4978_impl() {
   Kokkos::View<long long*, ExecutionSpace> element_("element", 9);
@@ -376,55 +206,33 @@ void test_sort_integer_overflow() {
       << "view (" << vh[0] << ", " << vh[1] << ") is not sorted";
 }
 
-//----------------------------------------------------------------------------
+}  // namespace SortImpl
 
-template <class ExecutionSpace, typename KeyType>
-void test_1D_sort(unsigned int N) {
-  test_1D_sort_impl<ExecutionSpace, KeyType>(N * N * N);
-}
+TEST(TEST_CATEGORY, SortUnsignedValueType) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using key_type       = unsigned;
+  constexpr int N      = 171;
 
-template <class ExecutionSpace, typename KeyType>
-void test_3D_sort(unsigned int N) {
-  test_3D_sort_impl<ExecutionSpace, KeyType>(N);
-}
+  SortImpl::test_1D_sort_impl<ExecutionSpace, key_type>(N * N * N);
 
-template <class ExecutionSpace, typename KeyType>
-void test_dynamic_view_sort(unsigned int N) {
-  test_dynamic_view_sort_impl<ExecutionSpace, KeyType>(N * N);
-}
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+  // FIXME_OPENMPTARGET: OpenMPTarget doesn't support DynamicView yet.
+  SortImpl::test_dynamic_view_sort_impl<ExecutionSpace, key_type>(N * N);
+#endif
 
-template <class ExecutionSpace>
-void test_issue_1160_sort() {
-  test_issue_1160_impl<ExecutionSpace>();
+  SortImpl::test_issue_4978_impl<ExecutionSpace>();
 }
 
-template <class ExecutionSpace>
-void test_issue_4978_sort() {
-  test_issue_4978_impl<ExecutionSpace>();
-}
+TEST(TEST_CATEGORY, SortEmptyView) {
+  using ExecutionSpace = TEST_EXECSPACE;
 
-template <class ExecutionSpace, typename KeyType>
-void test_sort(unsigned int N) {
-  test_1D_sort<ExecutionSpace, KeyType>(N);
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if (!std::is_same_v<ExecutionSpace, Kokkos::Cuda>)
-#endif
-    test_3D_sort<ExecutionSpace, KeyType>(N);
-// FIXME_OPENMPTARGET: OpenMPTarget doesn't support DynamicView yet.
-#ifndef KOKKOS_ENABLE_OPENMPTARGET
-  test_dynamic_view_sort<ExecutionSpace, KeyType>(N);
-#endif
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if (!std::is_same_v<ExecutionSpace, Kokkos::Cuda>)
-#endif
-    test_issue_1160_sort<ExecutionSpace>();
-  test_issue_4978_sort<ExecutionSpace>();
-  test_sort_integer_overflow<ExecutionSpace, long long>();
-  test_sort_integer_overflow<ExecutionSpace, unsigned long long>();
-  test_sort_integer_overflow<ExecutionSpace, int>();
+  // does not matter if we use int or something else
+  Kokkos::View<int*, ExecutionSpace> v("v", 0);
+
+  // TODO check the synchronous behavior of the calls below
+  ASSERT_NO_THROW(Kokkos::sort(ExecutionSpace(), v));
+  ASSERT_NO_THROW(Kokkos::sort(v));
 }
-}  // namespace Impl
+
 }  // namespace Test
-#endif /* KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_HPP */
+#endif
diff --git a/algorithms/unit_tests/TestStdAlgorithmsAdjacentDifference.cpp b/algorithms/unit_tests/TestStdAlgorithmsAdjacentDifference.cpp
index d414d524b6..75ad533f6e 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsAdjacentDifference.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsAdjacentDifference.cpp
@@ -157,7 +157,7 @@ void verify_data(TestViewType test_view, GoldViewType gold) {
   const auto gold_h = create_mirror_view_and_copy(Kokkos::HostSpace(), gold);
 
   for (std::size_t i = 0; i < test_view.extent(0); ++i) {
-    EXPECT_EQ(gold_h(i), test_view_dc_h(i));
+    ASSERT_EQ(gold_h(i), test_view_dc_h(i));
   }
 }
 
@@ -197,7 +197,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto res1 = KE::adjacent_difference(exespace(), KE::cbegin(view_from),
                                         KE::cend(view_from),
                                         KE::begin(view_dest), args...);
-    EXPECT_EQ(res1, KE::end(view_dest));
+    ASSERT_EQ(res1, KE::end(view_dest));
     verify_data(view_dest, gold);
   }
 
@@ -207,7 +207,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto res2 = KE::adjacent_difference(
         "label", exespace(), KE::cbegin(view_from), KE::cend(view_from),
         KE::begin(view_dest), args...);
-    EXPECT_EQ(res2, KE::end(view_dest));
+    ASSERT_EQ(res2, KE::end(view_dest));
     verify_data(view_dest, gold);
   }
 
@@ -216,7 +216,7 @@ void run_single_scenario(const InfoType& scenario_info,
         create_view<ValueType>(Tag{}, view_ext, "adj_diff_dest_view");
     auto res3 =
         KE::adjacent_difference(exespace(), view_from, view_dest, args...);
-    EXPECT_EQ(res3, KE::end(view_dest));
+    ASSERT_EQ(res3, KE::end(view_dest));
     verify_data(view_dest, gold);
   }
 
@@ -225,7 +225,7 @@ void run_single_scenario(const InfoType& scenario_info,
         create_view<ValueType>(Tag{}, view_ext, "adj_diff_dest_view");
     auto res4 = KE::adjacent_difference("label", exespace(), view_from,
                                         view_dest, args...);
-    EXPECT_EQ(res4, KE::end(view_dest));
+    ASSERT_EQ(res4, KE::end(view_dest));
     verify_data(view_dest, gold);
   }
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsAdjacentFind.cpp b/algorithms/unit_tests/TestStdAlgorithmsAdjacentFind.cpp
index ee34761265..fa4ff48dbe 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsAdjacentFind.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsAdjacentFind.cpp
@@ -229,7 +229,7 @@ void verify(DiffType my_diff, ViewType view, Args... args) {
       my_std_adjacent_find(KE::cbegin(view_h), KE::cend(view_h), args...);
   const auto std_diff = std_r - KE::cbegin(view_h);
 
-  EXPECT_EQ(my_diff, std_diff);
+  ASSERT_EQ(my_diff, std_diff);
 }
 
 template <class Tag, class ValueType, class InfoType, class... Args>
@@ -287,12 +287,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_nonmod_seq_ops, adjacent_find) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedThreeTag, int>();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsAllAnyNoneOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsAllAnyNoneOf.cpp
index 1c39a4735e..cccc0f6c18 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsAllAnyNoneOf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsAllAnyNoneOf.cpp
@@ -147,12 +147,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_all_any_none_of_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedTwoTag, int>();
   run_all_scenarios<StridedThreeTag, unsigned>();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp b/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp
index 694676a878..5b30b9eda7 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp
@@ -110,7 +110,7 @@ verify_values(ValueType expected, const ViewType view) {
                 "Non-matching value types of view and reference value");
   auto view_h = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), view);
   for (std::size_t i = 0; i < view_h.extent(0); i++) {
-    EXPECT_EQ(expected, view_h(i));
+    ASSERT_EQ(expected, view_h(i));
   }
 }
 
@@ -130,7 +130,7 @@ verify_values(ValueType expected, const ViewType view) {
   auto view_h =
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), tmpView);
   for (std::size_t i = 0; i < view_h.extent(0); i++) {
-    EXPECT_EQ(expected, view_h(i));
+    ASSERT_EQ(expected, view_h(i));
   }
 }
 
@@ -147,7 +147,7 @@ compare_views(ViewType1 expected, const ViewType2 actual) {
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), actual);
 
   for (std::size_t i = 0; i < expected_h.extent(0); i++) {
-    EXPECT_EQ(expected_h(i), actual_h(i));
+    ASSERT_EQ(expected_h(i), actual_h(i));
   }
 }
 
@@ -171,7 +171,7 @@ compare_views(ViewType1 expected, const ViewType2 actual) {
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), expected);
 
   for (std::size_t i = 0; i < expected_h.extent(0); i++) {
-    EXPECT_EQ(expected_h(i), actual_h(i));
+    ASSERT_EQ(expected_h(i), actual_h(i));
   }
 }
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp b/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp
index 5d55199801..386d533f7a 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp
@@ -42,8 +42,8 @@ TEST(std_algorithms, is_admissible_to_std_algorithms) {
   using strided_view_1d_t = Kokkos::View<value_type*, Kokkos::LayoutStride>;
   Kokkos::LayoutStride layout1d{extent0, 2};
   strided_view_1d_t strided_view_1d{"std-algo-test-1d-strided-view", layout1d};
-  EXPECT_EQ(layout1d.dimension[0], 13u);
-  EXPECT_EQ(layout1d.stride[0], 2u);
+  ASSERT_EQ(layout1d.dimension[0], 13u);
+  ASSERT_EQ(layout1d.stride[0], 2u);
   // they are admissible
   KE::Impl::static_assert_is_admissible_to_kokkos_std_algorithms(
       static_view_1d);
diff --git a/algorithms/unit_tests/TestStdAlgorithmsCopyIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsCopyIf.cpp
index e21d50f69b..5778e37be0 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsCopyIf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsCopyIf.cpp
@@ -135,49 +135,49 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   }
 
   else if (name == "one-element-a") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(0));
   }
 
   else if (name == "one-element-b") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(2));
   }
 
   else if (name == "two-elements-a") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(2));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(0));
   }
 
   else if (name == "two-elements-b") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(2));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(0));
   }
 
   else if (name == "small-a") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(-4));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(-2));
-    EXPECT_EQ(view_test_h(2), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(3), static_cast<value_type>(2));
-    EXPECT_EQ(view_test_h(4), static_cast<value_type>(4));
-    EXPECT_EQ(view_test_h(5), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(6), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(7), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(8), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(-4));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(-2));
+    ASSERT_EQ(view_test_h(2), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(3), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(4), static_cast<value_type>(4));
+    ASSERT_EQ(view_test_h(5), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(6), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(7), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(8), static_cast<value_type>(0));
   }
 
   else if (name == "small-b") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(22));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(-12));
-    EXPECT_EQ(view_test_h(2), static_cast<value_type>(22));
-    EXPECT_EQ(view_test_h(3), static_cast<value_type>(-12));
-    EXPECT_EQ(view_test_h(4), static_cast<value_type>(22));
-    EXPECT_EQ(view_test_h(5), static_cast<value_type>(-12));
-    EXPECT_EQ(view_test_h(6), static_cast<value_type>(22));
-    EXPECT_EQ(view_test_h(7), static_cast<value_type>(-12));
-    EXPECT_EQ(view_test_h(8), static_cast<value_type>(22));
-    EXPECT_EQ(view_test_h(9), static_cast<value_type>(-12));
-    EXPECT_EQ(view_test_h(10), static_cast<value_type>(22));
-    EXPECT_EQ(view_test_h(11), static_cast<value_type>(-12));
-    EXPECT_EQ(view_test_h(12), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(-12));
+    ASSERT_EQ(view_test_h(2), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(3), static_cast<value_type>(-12));
+    ASSERT_EQ(view_test_h(4), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(5), static_cast<value_type>(-12));
+    ASSERT_EQ(view_test_h(6), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(7), static_cast<value_type>(-12));
+    ASSERT_EQ(view_test_h(8), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(9), static_cast<value_type>(-12));
+    ASSERT_EQ(view_test_h(10), static_cast<value_type>(22));
+    ASSERT_EQ(view_test_h(11), static_cast<value_type>(-12));
+    ASSERT_EQ(view_test_h(12), static_cast<value_type>(22));
   }
 
   else if (name == "medium" || name == "large") {
@@ -190,14 +190,14 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
     std::size_t count = 0;
     for (std::size_t i = 0; i < view_from_h.extent(0); ++i) {
       if (pred(view_from_h(i))) {
-        EXPECT_EQ(view_test_h(count), view_from_h(i));
+        ASSERT_EQ(view_test_h(count), view_from_h(i));
         count++;
       }
     }
     // all other entries of test view should be zero
     for (; count < view_test_h.extent(0); ++count) {
       // std::cout << count << '\n';
-      EXPECT_EQ(view_test_h(count), value_type(0));
+      ASSERT_EQ(view_test_h(count), value_type(0));
     }
   }
 
@@ -226,7 +226,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto rit       = KE::copy_if(exespace(), KE::cbegin(view_from),
                            KE::cend(view_from), KE::begin(view_dest), pred);
     verify_data(name, view_from, view_dest, pred);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   {
@@ -235,7 +235,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto rit       = KE::copy_if("label", exespace(), KE::cbegin(view_from),
                            KE::cend(view_from), KE::begin(view_dest), pred);
     verify_data(name, view_from, view_dest, pred);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   {
@@ -243,7 +243,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto view_dest = create_view<ValueType>(Tag{}, view_ext, "copy_if_dest");
     auto rit       = KE::copy_if(exespace(), view_from, view_dest, pred);
     verify_data(name, view_from, view_dest, pred);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   {
@@ -251,7 +251,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto view_dest = create_view<ValueType>(Tag{}, view_ext, "copy_if_dest");
     auto rit = KE::copy_if("label", exespace(), view_from, view_dest, pred);
     verify_data(name, view_from, view_dest, pred);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   Kokkos::fence();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsCount.cpp b/algorithms/unit_tests/TestStdAlgorithmsCount.cpp
index 9423d2e15a..32e9883709 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsCount.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsCount.cpp
@@ -35,13 +35,13 @@ void test_count(const ViewType view) {
     const value_t count_value = 0;
     const auto std_result =
         std::count(KE::cbegin(expected), KE::cend(expected), count_value);
-    EXPECT_EQ(view.extent(0), size_t(std_result));
+    ASSERT_EQ(view.extent(0), size_t(std_result));
 
     // pass const iterators
-    EXPECT_EQ(std_result, KE::count(exespace(), KE::cbegin(view),
+    ASSERT_EQ(std_result, KE::count(exespace(), KE::cbegin(view),
                                     KE::cend(view), count_value));
     // pass view
-    EXPECT_EQ(std_result, KE::count(exespace(), view, count_value));
+    ASSERT_EQ(std_result, KE::count(exespace(), view, count_value));
   }
 
   {
@@ -50,10 +50,10 @@ void test_count(const ViewType view) {
         std::count(KE::cbegin(expected), KE::cend(expected), count_value);
 
     // pass iterators
-    EXPECT_EQ(std_result, KE::count("label", exespace(), KE::begin(view),
+    ASSERT_EQ(std_result, KE::count("label", exespace(), KE::begin(view),
                                     KE::end(view), count_value));
     // pass view
-    EXPECT_EQ(std_result, KE::count("label", exespace(), view, count_value));
+    ASSERT_EQ(std_result, KE::count("label", exespace(), view, count_value));
   }
 }
 
@@ -67,24 +67,24 @@ void test_count_if(const ViewType view) {
 
   // no positive elements (all zeroes)
   const auto predicate = IsPositiveFunctor<value_type>();
-  EXPECT_EQ(0,
+  ASSERT_EQ(0,
             std::count_if(KE::begin(expected), KE::end(expected), predicate));
 
   // pass iterators
-  EXPECT_EQ(
+  ASSERT_EQ(
       0, KE::count_if(exespace(), KE::begin(view), KE::end(view), predicate));
   // pass view
-  EXPECT_EQ(0, KE::count_if(exespace(), view, predicate));
+  ASSERT_EQ(0, KE::count_if(exespace(), view, predicate));
 
   fill_views_inc(view, expected);
 
   const auto std_result =
       std::count_if(KE::begin(expected), KE::end(expected), predicate);
   // pass const iterators
-  EXPECT_EQ(std_result, KE::count_if("label", exespace(), KE::cbegin(view),
+  ASSERT_EQ(std_result, KE::count_if("label", exespace(), KE::cbegin(view),
                                      KE::cend(view), predicate));
   // pass view
-  EXPECT_EQ(std_result, KE::count_if("label", exespace(), view, predicate));
+  ASSERT_EQ(std_result, KE::count_if("label", exespace(), view, predicate));
 }
 
 template <class Tag, class ValueType>
diff --git a/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp
index 4969541a02..799de8b0c4 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp
@@ -157,7 +157,7 @@ void verify_data(ViewType1 data_view,  // contains data
       //           << gold_h(i) << " " << test_view_h(i) << " "
       //           << std::abs(gold_h(i) - test_view_h(i)) << std::endl;
       if (std::is_same<gold_view_value_type, int>::value) {
-        EXPECT_EQ(gold_h(i), test_view_h(i));
+        ASSERT_EQ(gold_h(i), test_view_h(i));
       } else {
         const auto error =
             std::abs(static_cast<double>(gold_h(i) - test_view_h(i)));
@@ -213,7 +213,7 @@ void run_single_scenario_default_op(const InfoType& scenario_info,
     auto r = KE::exclusive_scan(exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest),
                                 init_value);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, default_op());
   }
 
@@ -222,14 +222,14 @@ void run_single_scenario_default_op(const InfoType& scenario_info,
     auto r = KE::exclusive_scan("label", exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest),
                                 init_value);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, default_op());
   }
 
   {
     fill_zero(view_dest);
     auto r = KE::exclusive_scan(exespace(), view_from, view_dest, init_value);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, default_op());
   }
 
@@ -237,7 +237,7 @@ void run_single_scenario_default_op(const InfoType& scenario_info,
     fill_zero(view_dest);
     auto r = KE::exclusive_scan("label", exespace(), view_from, view_dest,
                                 init_value);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, default_op());
   }
 
@@ -263,7 +263,7 @@ void run_single_scenario_custom_op(const InfoType& scenario_info,
     auto r = KE::exclusive_scan(exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest),
                                 init_value, bop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop);
   }
 
@@ -272,7 +272,7 @@ void run_single_scenario_custom_op(const InfoType& scenario_info,
     auto r = KE::exclusive_scan("label", exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest),
                                 init_value, bop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop);
   }
 
@@ -280,7 +280,7 @@ void run_single_scenario_custom_op(const InfoType& scenario_info,
     fill_zero(view_dest);
     auto r =
         KE::exclusive_scan(exespace(), view_from, view_dest, init_value, bop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop);
   }
 
@@ -288,7 +288,7 @@ void run_single_scenario_custom_op(const InfoType& scenario_info,
     fill_zero(view_dest);
     auto r = KE::exclusive_scan("label", exespace(), view_from, view_dest,
                                 init_value, bop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop);
   }
 
@@ -344,6 +344,46 @@ TEST(std_algorithms_numeric_ops_test, exclusive_scan) {
   run_exclusive_scan_all_scenarios<StridedThreeTag, CustomValueType>();
 }
 
+TEST(std_algorithms_numeric_ops_test, exclusive_scan_functor) {
+  int dummy       = 0;
+  using view_type = Kokkos::View<int*, exespace>;
+  view_type dummy_view("dummy_view", 0);
+  using functor_type = Kokkos::Experimental::Impl::ExclusiveScanDefaultFunctor<
+      exespace, int, int, view_type, view_type>;
+  functor_type functor(dummy, dummy_view, dummy_view);
+  using value_type = functor_type::value_type;
+
+  value_type value1;
+  functor.init(value1);
+  ASSERT_EQ(value1.val, 0);
+  ASSERT_EQ(value1.is_initial, true);
+
+  value_type value2;
+  value2.val        = 1;
+  value2.is_initial = false;
+  functor.join(value1, value2);
+  ASSERT_EQ(value1.val, 1);
+  ASSERT_EQ(value1.is_initial, false);
+
+  functor.init(value1);
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 1);
+  ASSERT_EQ(value2.is_initial, false);
+
+  functor.init(value2);
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 0);
+  ASSERT_EQ(value2.is_initial, true);
+
+  value1.val        = 1;
+  value1.is_initial = false;
+  value2.val        = 2;
+  value2.is_initial = false;
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 3);
+  ASSERT_EQ(value2.is_initial, false);
+}
+
 }  // namespace EScan
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsFind.cpp b/algorithms/unit_tests/TestStdAlgorithmsFind.cpp
index 3b8b5e85af..2692df6982 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsFind.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsFind.cpp
@@ -34,14 +34,14 @@ void test_find(const ViewType view) {
   constexpr value_t find_value = 13;
 
   // value not found, return last
-  EXPECT_EQ(KE::end(expected),
+  ASSERT_EQ(KE::end(expected),
             std::find(KE::begin(expected), KE::end(expected), find_value));
 
   // pass const iterators, returns const iterator
-  EXPECT_EQ(KE::cend(view),
+  ASSERT_EQ(KE::cend(view),
             KE::find(exespace(), KE::cbegin(view), KE::cend(view), find_value));
   // pass view, returns iterator
-  EXPECT_EQ(KE::end(view), KE::find(exespace(), view, find_value));
+  ASSERT_EQ(KE::end(view), KE::find(exespace(), view, find_value));
 
   fill_views_inc(view, expected);
 
@@ -50,10 +50,10 @@ void test_find(const ViewType view) {
   auto distance = std::distance(KE::begin(expected), std_result);
 
   // pass iterators, returns iterator
-  EXPECT_EQ(KE::begin(view) + distance,
+  ASSERT_EQ(KE::begin(view) + distance,
             KE::find(exespace(), KE::begin(view), KE::end(view), find_value));
   // pass view, returns iterator
-  EXPECT_EQ(KE::begin(view) + distance, KE::find(exespace(), view, find_value));
+  ASSERT_EQ(KE::begin(view) + distance, KE::find(exespace(), view, find_value));
 }
 
 template <class ViewType>
@@ -67,15 +67,15 @@ void test_find_if(const ViewType view) {
   const auto not_equals_zero = NotEqualsZeroFunctor<value_type>();
 
   // value not found, return last
-  EXPECT_EQ(
+  ASSERT_EQ(
       KE::end(expected),
       std::find_if(KE::begin(expected), KE::end(expected), not_equals_zero));
 
   // pass iterators, returns iterator
-  EXPECT_EQ(KE::end(view), KE::find_if(exespace(), KE::begin(view),
+  ASSERT_EQ(KE::end(view), KE::find_if(exespace(), KE::begin(view),
                                        KE::end(view), not_equals_zero));
   // pass view, returns iterator
-  EXPECT_EQ(KE::end(view), KE::find_if(exespace(), view, not_equals_zero));
+  ASSERT_EQ(KE::end(view), KE::find_if(exespace(), view, not_equals_zero));
 
   fill_views_inc(view, expected);
 
@@ -86,11 +86,11 @@ void test_find_if(const ViewType view) {
   auto distance = std::distance(KE::begin(expected), std_result);
 
   // pass const iterators, returns const iterator
-  EXPECT_EQ(
+  ASSERT_EQ(
       KE::cbegin(view) + distance,
       KE::find_if(exespace(), KE::cbegin(view), KE::cend(view), equals_val));
   // pass view, returns iterator
-  EXPECT_EQ(KE::begin(view) + distance,
+  ASSERT_EQ(KE::begin(view) + distance,
             KE::find_if(exespace(), view, equals_val));
 }
 
@@ -105,15 +105,15 @@ void test_find_if_not(const ViewType view) {
   const auto not_equals_zero = NotEqualsZeroFunctor<value_type>();
 
   // first value matches
-  EXPECT_EQ(KE::begin(expected),
+  ASSERT_EQ(KE::begin(expected),
             std::find_if_not(KE::begin(expected), KE::end(expected),
                              not_equals_zero));
 
   // pass iterators, returns iterator
-  EXPECT_EQ(KE::begin(view), KE::find_if_not(exespace(), KE::begin(view),
+  ASSERT_EQ(KE::begin(view), KE::find_if_not(exespace(), KE::begin(view),
                                              KE::end(view), not_equals_zero));
   // pass view, returns iterator
-  EXPECT_EQ(KE::begin(view),
+  ASSERT_EQ(KE::begin(view),
             KE::find_if_not(exespace(), view, not_equals_zero));
 
   fill_views_inc(view, expected);
@@ -124,11 +124,11 @@ void test_find_if_not(const ViewType view) {
   auto distance = std::distance(KE::begin(expected), std_result);
 
   // pass const iterators, returns const iterator
-  EXPECT_EQ(KE::cbegin(view) + distance,
+  ASSERT_EQ(KE::cbegin(view) + distance,
             KE::find_if_not(exespace(), KE::cbegin(view), KE::cend(view),
                             equals_zero));
   // pass view, returns const iterator
-  EXPECT_EQ(KE::begin(view) + distance,
+  ASSERT_EQ(KE::begin(view) + distance,
             KE::find_if_not(exespace(), view, equals_zero));
 }
 
@@ -151,12 +151,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_find_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedTwoTag, int>();
   run_all_scenarios<StridedThreeTag, unsigned>();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsFindEnd.cpp b/algorithms/unit_tests/TestStdAlgorithmsFindEnd.cpp
index ddc4bc1ba6..5a5359b0b2 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsFindEnd.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsFindEnd.cpp
@@ -282,7 +282,7 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t seq_ext,
     const auto mydiff  = myrit - KE::cbegin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
     // std::cout << "result : " << mydiff << " " << stddiff << std::endl;
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
@@ -291,21 +291,21 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t seq_ext,
                      KE::cbegin(s_view), KE::cend(s_view), args...);
     const auto mydiff  = myrit - KE::cbegin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit         = KE::find_end(exespace(), view, s_view, args...);
     const auto mydiff  = myrit - KE::begin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit = KE::find_end("label", exespace(), view, s_view, args...);
     const auto mydiff  = myrit - KE::begin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   Kokkos::fence();
@@ -348,12 +348,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, find_end) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsFindFirstOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsFindFirstOf.cpp
index c2f7a2fdb8..d77edb5fed 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsFindFirstOf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsFindFirstOf.cpp
@@ -201,7 +201,7 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t seq_ext,
                           KE::cbegin(s_view), KE::cend(s_view), args...);
     const auto mydiff  = myrit - KE::cbegin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
@@ -210,21 +210,21 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t seq_ext,
                           KE::cbegin(s_view), KE::cend(s_view), args...);
     const auto mydiff  = myrit - KE::cbegin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit         = KE::find_first_of(exespace(), view, s_view, args...);
     const auto mydiff  = myrit - KE::begin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit = KE::find_first_of("label", exespace(), view, s_view, args...);
     const auto mydiff  = myrit - KE::begin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   Kokkos::fence();
@@ -264,12 +264,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, find_first_of) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsForEach.cpp b/algorithms/unit_tests/TestStdAlgorithmsForEach.cpp
index 83b44f01aa..793b98a67f 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsForEach.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsForEach.cpp
@@ -91,23 +91,23 @@ void test_for_each_n(const ViewType view) {
   const auto non_mod_functor = NoOpNonMutableFunctor<value_t>();
 
   // pass const iterators, functor takes const ref
-  EXPECT_EQ(KE::cbegin(view) + n,
+  ASSERT_EQ(KE::cbegin(view) + n,
             KE::for_each_n(exespace(), KE::cbegin(view), n, non_mod_functor));
   verify_values(value_t{0}, view);
 
   // pass view, functor takes const ref
-  EXPECT_EQ(KE::begin(view) + n,
+  ASSERT_EQ(KE::begin(view) + n,
             KE::for_each_n(exespace(), view, n, non_mod_functor));
   verify_values(value_t{0}, view);
 
   // pass iterators, functor takes non-const ref
   const auto mod_functor = IncrementElementWiseFunctor<value_t>();
-  EXPECT_EQ(KE::begin(view) + n,
+  ASSERT_EQ(KE::begin(view) + n,
             KE::for_each_n(exespace(), KE::begin(view), n, mod_functor));
   verify_values(value_t{1}, view);
 
   // pass view, functor takes non-const ref
-  EXPECT_EQ(KE::begin(view) + n,
+  ASSERT_EQ(KE::begin(view) + n,
             KE::for_each_n("label", exespace(), view, n, mod_functor));
   verify_values(value_t{2}, view);
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp
index 510f1d195a..8e60a43e5f 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp
@@ -171,7 +171,7 @@ void verify_data(ViewType1 data_view,  // contains data
       //           << std::abs(gold_h(i) - test_view_h(i)) << std::endl;
 
       if (std::is_same<gold_view_value_type, int>::value) {
-        EXPECT_EQ(gold_h(i), test_view_h(i));
+        ASSERT_EQ(gold_h(i), test_view_h(i));
       } else {
         const auto error =
             std::abs(static_cast<double>(gold_h(i) - test_view_h(i)));
@@ -224,7 +224,7 @@ void run_single_scenario_default_op(const InfoType& scenario_info) {
     fill_zero(view_dest);
     auto r = KE::inclusive_scan(exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest));
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, default_op());
   }
 
@@ -232,21 +232,21 @@ void run_single_scenario_default_op(const InfoType& scenario_info) {
     fill_zero(view_dest);
     auto r = KE::inclusive_scan("label", exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest));
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, default_op());
   }
 
   {
     fill_zero(view_dest);
     auto r = KE::inclusive_scan(exespace(), view_from, view_dest);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, default_op());
   }
 
   {
     fill_zero(view_dest);
     auto r = KE::inclusive_scan("label", exespace(), view_from, view_dest);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, default_op());
   }
 
@@ -279,7 +279,7 @@ void run_single_scenario_custom_op(const InfoType& scenario_info, BinaryOp bop,
     auto r = KE::inclusive_scan(exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest), bop,
                                 args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, bop, args...);
   }
 
@@ -288,14 +288,14 @@ void run_single_scenario_custom_op(const InfoType& scenario_info, BinaryOp bop,
     auto r = KE::inclusive_scan("label", exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest), bop,
                                 args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, bop, args...);
   }
 
   {
     fill_zero(view_dest);
     auto r = KE::inclusive_scan(exespace(), view_from, view_dest, bop, args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, bop, args...);
   }
 
@@ -303,7 +303,7 @@ void run_single_scenario_custom_op(const InfoType& scenario_info, BinaryOp bop,
     fill_zero(view_dest);
     auto r = KE::inclusive_scan("label", exespace(), view_from, view_dest, bop,
                                 args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, bop, args...);
   }
 
@@ -353,6 +353,45 @@ TEST(std_algorithms_numeric_ops_test, inclusive_scan) {
   run_inclusive_scan_all_scenarios<StridedThreeTag, CustomValueType>();
 }
 
+TEST(std_algorithms_numeric_ops_test, inclusive_scan_functor) {
+  using view_type = Kokkos::View<int*, exespace>;
+  view_type dummy_view("dummy_view", 0);
+  using functor_type = Kokkos::Experimental::Impl::InclusiveScanDefaultFunctor<
+      exespace, int, int, view_type, view_type>;
+  functor_type functor(dummy_view, dummy_view);
+  using value_type = functor_type::value_type;
+
+  value_type value1;
+  functor.init(value1);
+  ASSERT_EQ(value1.val, 0);
+  ASSERT_EQ(value1.is_initial, true);
+
+  value_type value2;
+  value2.val        = 1;
+  value2.is_initial = false;
+  functor.join(value1, value2);
+  ASSERT_EQ(value1.val, 1);
+  ASSERT_EQ(value1.is_initial, false);
+
+  functor.init(value1);
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 1);
+  ASSERT_EQ(value2.is_initial, false);
+
+  functor.init(value2);
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 0);
+  ASSERT_EQ(value2.is_initial, true);
+
+  value1.val        = 1;
+  value1.is_initial = false;
+  value2.val        = 2;
+  value2.is_initial = false;
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 3);
+  ASSERT_EQ(value2.is_initial, false);
+}
+
 }  // namespace IncScan
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp b/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp
index ce8669a84f..dcfe8ad67e 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp
@@ -145,10 +145,10 @@ void run_single_scenario(const InfoType& scenario_info) {
       KE::is_sorted_until("label", exespace(), KE::begin(view), KE::end(view));
   auto r3 = KE::is_sorted_until(exespace(), view);
   auto r4 = KE::is_sorted_until("label", exespace(), view);
-  EXPECT_EQ(r1, gold);
-  EXPECT_EQ(r2, gold);
-  EXPECT_EQ(r3, gold);
-  EXPECT_EQ(r4, gold);
+  ASSERT_EQ(r1, gold);
+  ASSERT_EQ(r2, gold);
+  ASSERT_EQ(r3, gold);
+  ASSERT_EQ(r4, gold);
 
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
   CustomLessThanComparator<ValueType, ValueType> comp;
@@ -160,10 +160,10 @@ void run_single_scenario(const InfoType& scenario_info) {
   auto r8 = KE::is_sorted_until("label", exespace(), view, comp);
 #endif
 
-  EXPECT_EQ(r1, gold);
-  EXPECT_EQ(r2, gold);
-  EXPECT_EQ(r3, gold);
-  EXPECT_EQ(r4, gold);
+  ASSERT_EQ(r1, gold);
+  ASSERT_EQ(r2, gold);
+  ASSERT_EQ(r3, gold);
+  ASSERT_EQ(r4, gold);
 
   Kokkos::fence();
 }
@@ -185,12 +185,6 @@ void run_is_sorted_until_all_scenarios() {
 }
 
 TEST(std_algorithms_sorting_ops_test, is_sorted_until) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_is_sorted_until_all_scenarios<DynamicTag, double>();
   run_is_sorted_until_all_scenarios<StridedTwoTag, double>();
   run_is_sorted_until_all_scenarios<StridedThreeTag, double>();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsLexicographicalCompare.cpp b/algorithms/unit_tests/TestStdAlgorithmsLexicographicalCompare.cpp
index 2acd4934ac..5d9e7db803 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsLexicographicalCompare.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsLexicographicalCompare.cpp
@@ -44,16 +44,16 @@ void test_lexicographical_compare(const ViewType1 view_1, ViewType2 view_2) {
         std::lexicographical_compare(h_first_1, h_last_1, h_first_2, h_last_2);
 
     // pass iterators
-    EXPECT_EQ(std_result, KE::lexicographical_compare(exespace(), first_1,
+    ASSERT_EQ(std_result, KE::lexicographical_compare(exespace(), first_1,
                                                       last_1, first_2, last_2));
-    EXPECT_EQ(std_result,
+    ASSERT_EQ(std_result,
               KE::lexicographical_compare("label", exespace(), first_1, last_1,
                                           first_2, last_2));
 
     // pass views
-    EXPECT_EQ(std_result,
+    ASSERT_EQ(std_result,
               KE::lexicographical_compare(exespace(), view_1, view_2));
-    EXPECT_EQ(std_result,
+    ASSERT_EQ(std_result,
               KE::lexicographical_compare("label", exespace(), view_1, view_2));
   }
 
@@ -67,17 +67,17 @@ void test_lexicographical_compare(const ViewType1 view_1, ViewType2 view_2) {
         h_first_1, h_last_1, h_first_2, h_last_2, custom_comparator);
 
     // pass iterators
-    EXPECT_EQ(std_result,
+    ASSERT_EQ(std_result,
               KE::lexicographical_compare(exespace(), first_1, last_1, first_2,
                                           last_2, custom_comparator));
-    EXPECT_EQ(std_result,
+    ASSERT_EQ(std_result,
               KE::lexicographical_compare("label", exespace(), first_1, last_1,
                                           first_2, last_2, custom_comparator));
 
     // pass views
-    EXPECT_EQ(std_result, KE::lexicographical_compare(
+    ASSERT_EQ(std_result, KE::lexicographical_compare(
                               exespace(), view_1, view_2, custom_comparator));
-    EXPECT_EQ(std_result,
+    ASSERT_EQ(std_result,
               KE::lexicographical_compare("label", exespace(), view_1, view_2,
                                           custom_comparator));
   }
@@ -86,7 +86,7 @@ void test_lexicographical_compare(const ViewType1 view_1, ViewType2 view_2) {
     // empty vs non-empty
     auto std_result =
         std::lexicographical_compare(h_first_1, h_first_1, h_first_2, h_last_2);
-    EXPECT_EQ(std_result, KE::lexicographical_compare(
+    ASSERT_EQ(std_result, KE::lexicographical_compare(
                               exespace(), first_1, first_1, first_2, last_2));
   }
 
@@ -95,7 +95,7 @@ void test_lexicographical_compare(const ViewType1 view_1, ViewType2 view_2) {
     if (view_1.extent(0) > 1) {
       auto std_result = std::lexicographical_compare(h_first_1, h_last_1 - 1,
                                                      h_first_2, h_last_2);
-      EXPECT_EQ(std_result,
+      ASSERT_EQ(std_result,
                 KE::lexicographical_compare(exespace(), first_1, last_1 - 1,
                                             first_2, last_2));
     }
@@ -140,12 +140,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_lexicographical_compare_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
 // FIXME: should this disable only custom comparator tests?
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
   run_all_scenarios<DynamicTag, double>();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsMinMaxElementOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsMinMaxElementOps.cpp
index f8634ffafe..bc43231784 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsMinMaxElementOps.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsMinMaxElementOps.cpp
@@ -173,7 +173,7 @@ void std_algo_min_max_test_verify(Kokkos::pair<IndexType, ValueType> goldPair,
                                   const ItType result,
                                   TestedViewType testedView) {
   // check that iterator is pointing to right element
-  EXPECT_EQ(result - KE::begin(testedView), goldPair.first);
+  ASSERT_EQ(result - KE::begin(testedView), goldPair.first);
 
   // create a view for the result to copy into it the iterator's value
   using result_view_t = Kokkos::View<int>;
@@ -184,7 +184,7 @@ void std_algo_min_max_test_verify(Kokkos::pair<IndexType, ValueType> goldPair,
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), resultView);
 
   // use the host mirror of the result view to check that the values match
-  EXPECT_EQ(result_v_h(), goldPair.second);
+  ASSERT_EQ(result_v_h(), goldPair.second);
 }
 
 template <class GoldSolutionType, class ItType, class TestedViewType>
@@ -199,39 +199,39 @@ template <class ViewType>
 void test_max_element_trivial_data(ViewType view) {
   /* if we pass empty range, should return last */
   auto result = KE::max_element(exespace(), KE::cbegin(view), KE::cbegin(view));
-  EXPECT_EQ(result, KE::cbegin(view));
+  ASSERT_EQ(result, KE::cbegin(view));
 
   /* if we pass empty range, should return last */
   auto it0     = KE::cbegin(view) + 3;
   auto it1     = it0;
   auto result2 = KE::max_element(exespace(), it0, it1);
-  EXPECT_EQ(result2, it1);
+  ASSERT_EQ(result2, it1);
 }
 
 template <class ViewType>
 void test_min_element_trivial_data(ViewType view) {
   /* if we pass empty range, should return last */
   auto result = KE::min_element(exespace(), KE::cbegin(view), KE::cbegin(view));
-  EXPECT_EQ(result, KE::cbegin(view));
+  ASSERT_EQ(result, KE::cbegin(view));
 
   /* if we pass empty range, should return last */
   auto it0     = KE::cbegin(view) + 3;
   auto it1     = it0;
   auto result2 = KE::min_element(exespace(), it0, it1);
-  EXPECT_EQ(result2, it1);
+  ASSERT_EQ(result2, it1);
 }
 
 template <class ViewType>
 void test_minmax_element_empty_range(ViewType view) {
   auto result =
       KE::minmax_element(exespace(), KE::cbegin(view), KE::cbegin(view));
-  EXPECT_EQ(result.first, KE::cbegin(view));
-  EXPECT_EQ(result.second, KE::cbegin(view));
+  ASSERT_EQ(result.first, KE::cbegin(view));
+  ASSERT_EQ(result.second, KE::cbegin(view));
   auto it0     = KE::cbegin(view) + 3;
   auto it1     = it0;
   auto result2 = KE::minmax_element(exespace(), it0, it1);
-  EXPECT_EQ(result2.first, it1);
-  EXPECT_EQ(result2.second, it1);
+  ASSERT_EQ(result2.first, it1);
+  ASSERT_EQ(result2.second, it1);
 }
 
 template <class ViewType>
diff --git a/algorithms/unit_tests/TestStdAlgorithmsMismatch.cpp b/algorithms/unit_tests/TestStdAlgorithmsMismatch.cpp
index bb4b6fb2a2..f3b3e269c4 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsMismatch.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsMismatch.cpp
@@ -120,10 +120,10 @@ void run_single_scenario(ViewType view1, ViewType view2,
     const auto my_diff12 = my_res1.second - f2;
     const auto my_diff21 = my_res2.first - f1;
     const auto my_diff22 = my_res2.second - f2;
-    EXPECT_EQ(my_diff11, std_diff1);
-    EXPECT_EQ(my_diff12, std_diff2);
-    EXPECT_EQ(my_diff21, std_diff1);
-    EXPECT_EQ(my_diff22, std_diff2);
+    ASSERT_EQ(my_diff11, std_diff1);
+    ASSERT_EQ(my_diff12, std_diff2);
+    ASSERT_EQ(my_diff21, std_diff1);
+    ASSERT_EQ(my_diff22, std_diff2);
   }
 
   {
@@ -134,10 +134,10 @@ void run_single_scenario(ViewType view1, ViewType view2,
     const auto my_diff12 = my_res1.second - KE::begin(view2);
     const auto my_diff21 = my_res2.first - KE::begin(view1);
     const auto my_diff22 = my_res2.second - KE::begin(view2);
-    EXPECT_EQ(my_diff11, std_diff1);
-    EXPECT_EQ(my_diff12, std_diff2);
-    EXPECT_EQ(my_diff21, std_diff1);
-    EXPECT_EQ(my_diff22, std_diff2);
+    ASSERT_EQ(my_diff11, std_diff1);
+    ASSERT_EQ(my_diff12, std_diff2);
+    ASSERT_EQ(my_diff21, std_diff1);
+    ASSERT_EQ(my_diff22, std_diff2);
   }
 }
 
@@ -189,12 +189,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_mismatch_test, test) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, double>();
   run_all_scenarios<StridedThreeTag, int>();
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp
index 4fce044bcf..4604764097 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp
@@ -52,14 +52,14 @@ TEST(std_algorithms_mod_ops_test, move) {
 
   // move constr
   MyMovableType b(std::move(a));
-  EXPECT_EQ(b.m_value, 11);
-  EXPECT_EQ(a.m_value, -2);
+  ASSERT_EQ(b.m_value, 11);
+  ASSERT_EQ(a.m_value, -2);
 
   // move assign
   MyMovableType c;
   c = std::move(b);
-  EXPECT_EQ(c.m_value, 11);
-  EXPECT_EQ(b.m_value, -4);
+  ASSERT_EQ(c.m_value, 11);
+  ASSERT_EQ(b.m_value, -4);
 }
 
 template <class ViewType>
@@ -97,8 +97,8 @@ TEST(std_algorithms_mod_ops_test, swap) {
     int a = 1;
     int b = 2;
     KE::swap(a, b);
-    EXPECT_EQ(a, 2);
-    EXPECT_EQ(b, 1);
+    ASSERT_EQ(a, 2);
+    ASSERT_EQ(b, 1);
   }
 
   {
@@ -151,17 +151,17 @@ void test_iter_swap(ViewType view) {
   using value_type = typename ViewType::value_type;
   auto a_dc        = create_deep_copyable_compatible_clone(view);
   auto a_h         = create_mirror_view_and_copy(Kokkos::HostSpace(), a_dc);
-  EXPECT_EQ(view.extent_int(0), 10);
-  EXPECT_EQ(a_h(0), value_type(3));
-  EXPECT_EQ(a_h(1), value_type(1));
-  EXPECT_EQ(a_h(2), value_type(2));
-  EXPECT_EQ(a_h(3), value_type(0));
-  EXPECT_EQ(a_h(4), value_type(6));
-  EXPECT_EQ(a_h(5), value_type(5));
-  EXPECT_EQ(a_h(6), value_type(4));
-  EXPECT_EQ(a_h(7), value_type(7));
-  EXPECT_EQ(a_h(8), value_type(8));
-  EXPECT_EQ(a_h(9), value_type(9));
+  ASSERT_EQ(view.extent_int(0), 10);
+  ASSERT_EQ(a_h(0), value_type(3));
+  ASSERT_EQ(a_h(1), value_type(1));
+  ASSERT_EQ(a_h(2), value_type(2));
+  ASSERT_EQ(a_h(3), value_type(0));
+  ASSERT_EQ(a_h(4), value_type(6));
+  ASSERT_EQ(a_h(5), value_type(5));
+  ASSERT_EQ(a_h(6), value_type(4));
+  ASSERT_EQ(a_h(7), value_type(7));
+  ASSERT_EQ(a_h(8), value_type(8));
+  ASSERT_EQ(a_h(9), value_type(9));
 }
 
 TEST(std_algorithms_mod_ops_test, iter_swap_static_view) {
diff --git a/algorithms/unit_tests/TestStdAlgorithmsModSeqOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsModSeqOps.cpp
index 6b806d7bc5..f80f30797e 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsModSeqOps.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsModSeqOps.cpp
@@ -34,21 +34,21 @@ struct std_algorithms_mod_seq_ops_test : std_algorithms_test {
 TEST_F(std_algorithms_mod_seq_ops_test, copy) {
   auto result = KE::copy(exespace(), KE::begin(m_static_view),
                          KE::end(m_static_view), KE::begin(m_strided_view));
-  EXPECT_EQ(KE::end(m_strided_view), result);
+  ASSERT_EQ(KE::end(m_strided_view), result);
   compare_views(m_static_view, m_strided_view);
 
   auto result2 = KE::copy(exespace(), KE::begin(m_strided_view),
                           KE::end(m_strided_view), KE::begin(m_dynamic_view));
-  EXPECT_EQ(KE::end(m_dynamic_view), result2);
+  ASSERT_EQ(KE::end(m_dynamic_view), result2);
   compare_views(m_dynamic_view, m_strided_view);
 }
 
 TEST_F(std_algorithms_mod_seq_ops_test, copy_view) {
-  EXPECT_EQ(KE::end(m_dynamic_view),
+  ASSERT_EQ(KE::end(m_dynamic_view),
             KE::copy(exespace(), m_static_view, m_dynamic_view));
   compare_views(m_static_view, m_dynamic_view);
 
-  EXPECT_EQ(KE::end(m_strided_view),
+  ASSERT_EQ(KE::end(m_strided_view),
             KE::copy(exespace(), m_dynamic_view, m_strided_view));
   compare_views(m_dynamic_view, m_strided_view);
 }
@@ -70,11 +70,11 @@ TEST_F(std_algorithms_mod_seq_ops_test, copy_n) {
   // pass iterators
   auto first = KE::begin(m_static_view);
   auto dest  = KE::begin(m_dynamic_view);
-  EXPECT_EQ(dest + n, KE::copy_n(exespace(), first, n, dest));
+  ASSERT_EQ(dest + n, KE::copy_n(exespace(), first, n, dest));
   compare_views(expected, m_dynamic_view);
 
   // pass views
-  EXPECT_EQ(KE::begin(m_strided_view) + n,
+  ASSERT_EQ(KE::begin(m_strided_view) + n,
             KE::copy_n(exespace(), m_static_view, n, m_strided_view));
   compare_views(expected, m_strided_view);
 }
@@ -85,12 +85,12 @@ TEST_F(std_algorithms_mod_seq_ops_test, copy_backward) {
   auto dest  = KE::end(m_dynamic_view);
 
   // pass iterators
-  EXPECT_EQ(KE::begin(m_dynamic_view),
+  ASSERT_EQ(KE::begin(m_dynamic_view),
             KE::copy_backward(exespace(), first, last, dest));
   compare_views(m_static_view, m_dynamic_view);
 
   // pass views
-  EXPECT_EQ(KE::begin(m_strided_view),
+  ASSERT_EQ(KE::begin(m_strided_view),
             KE::copy_backward(exespace(), m_static_view, m_strided_view));
   compare_views(m_static_view, m_strided_view);
 }
@@ -112,11 +112,11 @@ TEST_F(std_algorithms_mod_seq_ops_test, reverse_copy) {
   auto last  = KE::end(m_static_view);
   auto dest  = KE::begin(m_dynamic_view);
 
-  EXPECT_EQ(KE::end(m_dynamic_view),
+  ASSERT_EQ(KE::end(m_dynamic_view),
             KE::reverse_copy(exespace(), first, last, dest));
   compare_views(expected, m_dynamic_view);
 
-  EXPECT_EQ(KE::end(m_strided_view),
+  ASSERT_EQ(KE::end(m_strided_view),
             KE::reverse_copy(exespace(), m_static_view, m_strided_view));
   compare_views(expected, m_strided_view);
 }
@@ -151,25 +151,25 @@ TEST_F(std_algorithms_mod_seq_ops_test, fill_n) {
 
   // fill all elements
   // pass iterator
-  EXPECT_EQ(KE::end(m_static_view),
+  ASSERT_EQ(KE::end(m_static_view),
             KE::fill_n(exespace(), KE::begin(m_static_view),
                        m_static_view.extent(0), fill_n_value));
   verify_values(fill_n_value, m_static_view);
 
   // pass view
-  EXPECT_EQ(KE::end(m_strided_view),
+  ASSERT_EQ(KE::end(m_strided_view),
             KE::fill_n(exespace(), m_strided_view, m_strided_view.extent(0),
                        fill_n_value));
   verify_values(fill_n_value, m_strided_view);
 
   // fill zero elements
   // pass view
-  EXPECT_EQ(KE::begin(m_dynamic_view),
+  ASSERT_EQ(KE::begin(m_dynamic_view),
             KE::fill_n(exespace(), m_dynamic_view, 0, fill_n_new_value));
 
   // fill single element
   // pass iterator
-  EXPECT_EQ(
+  ASSERT_EQ(
       KE::begin(m_static_view) + 1,
       KE::fill_n(exespace(), KE::begin(m_static_view), 1, fill_n_new_value));
 
@@ -212,21 +212,21 @@ TEST_F(std_algorithms_mod_seq_ops_test, transform_from_fixture_unary_op) {
   auto r1 = KE::transform(exespace(), KE::begin(m_static_view),
                           KE::end(m_static_view), KE::begin(m_dynamic_view),
                           TransformFunctor());
-  EXPECT_EQ(r1, KE::end(m_dynamic_view));
+  ASSERT_EQ(r1, KE::end(m_dynamic_view));
   compare_views(gold_source, m_static_view);
   verify_values(-1., m_dynamic_view);
 
   // transform dynamic view, store results in strided view
   auto r2 = KE::transform(exespace(), m_dynamic_view, m_strided_view,
                           TransformFunctor());
-  EXPECT_EQ(r2, KE::end(m_strided_view));
+  ASSERT_EQ(r2, KE::end(m_strided_view));
   verify_values(-1., m_dynamic_view);
   verify_values(-1., m_strided_view);
 
   // transform strided view, store results in static view
   auto r3 = KE::transform(exespace(), m_strided_view, m_static_view,
                           TransformFunctor());
-  EXPECT_EQ(r3, KE::end(m_static_view));
+  ASSERT_EQ(r3, KE::end(m_static_view));
   verify_values(-1., m_static_view);
   verify_values(-1., m_strided_view);
 }
@@ -254,7 +254,7 @@ TEST_F(std_algorithms_mod_seq_ops_test, transform_from_fixture_binary_op) {
   auto r1 = KE::transform(exespace(), KE::begin(m_static_view),
                           KE::end(m_static_view), KE::begin(m_dynamic_view),
                           KE::begin(m_strided_view), TransformBinaryFunctor());
-  EXPECT_EQ(r1, KE::end(m_strided_view));
+  ASSERT_EQ(r1, KE::end(m_strided_view));
   compare_views(expected, m_strided_view);
 
   expected(0) = 0;
@@ -269,7 +269,7 @@ TEST_F(std_algorithms_mod_seq_ops_test, transform_from_fixture_binary_op) {
   expected(9) = 18;
   auto r2 = KE::transform("label", exespace(), m_static_view, m_strided_view,
                           m_dynamic_view, TransformBinaryFunctor());
-  EXPECT_EQ(r2, KE::end(m_dynamic_view));
+  ASSERT_EQ(r2, KE::end(m_dynamic_view));
   compare_views(expected, m_dynamic_view);
 }
 
@@ -296,19 +296,19 @@ TEST_F(std_algorithms_mod_seq_ops_test, generate) {
 
 TEST_F(std_algorithms_mod_seq_ops_test, generate_n) {
   // iterator + functor
-  EXPECT_EQ(KE::end(m_static_view),
+  ASSERT_EQ(KE::end(m_static_view),
             KE::generate_n(exespace(), KE::begin(m_static_view),
                            m_static_view.extent(0), GenerateFunctor()));
   verify_values(generated_value, m_static_view);
 
   // view + functor
-  EXPECT_EQ(KE::end(m_dynamic_view),
+  ASSERT_EQ(KE::end(m_dynamic_view),
             KE::generate_n(exespace(), m_dynamic_view, m_dynamic_view.extent(0),
                            GenerateFunctor()));
   verify_values(generated_value, m_dynamic_view);
 
   // view + functor, negative n
-  EXPECT_EQ(KE::begin(m_strided_view),
+  ASSERT_EQ(KE::begin(m_strided_view),
             KE::generate_n(exespace(), m_strided_view, -1, GenerateFunctor()));
 }
 
@@ -352,7 +352,7 @@ void test_swap_ranges(ViewType view) {
   auto last1  = first1 + 4;
   auto first2 = KE::begin(viewB) + 1;
   auto r      = KE::swap_ranges(exespace(), first1, last1, first2);
-  EXPECT_EQ(r, first2 + 4);
+  ASSERT_EQ(r, first2 + 4);
 
   /* check VIEW_A */
   static_view_type checkViewA("tmp");
@@ -360,16 +360,16 @@ void test_swap_ranges(ViewType view) {
   parallel_for(ext, cp_func_a_t(view, checkViewA));
   auto cvA_h =
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), checkViewA);
-  EXPECT_EQ(cvA_h(0), 0);
-  EXPECT_EQ(cvA_h(1), 1);
-  EXPECT_EQ(cvA_h(2), 99);
-  EXPECT_EQ(cvA_h(3), 98);
-  EXPECT_EQ(cvA_h(4), 97);
-  EXPECT_EQ(cvA_h(5), 96);
-  EXPECT_EQ(cvA_h(6), 6);
-  EXPECT_EQ(cvA_h(7), 7);
-  EXPECT_EQ(cvA_h(8), 8);
-  EXPECT_EQ(cvA_h(9), 9);
+  ASSERT_EQ(cvA_h(0), 0);
+  ASSERT_EQ(cvA_h(1), 1);
+  ASSERT_EQ(cvA_h(2), 99);
+  ASSERT_EQ(cvA_h(3), 98);
+  ASSERT_EQ(cvA_h(4), 97);
+  ASSERT_EQ(cvA_h(5), 96);
+  ASSERT_EQ(cvA_h(6), 6);
+  ASSERT_EQ(cvA_h(7), 7);
+  ASSERT_EQ(cvA_h(8), 8);
+  ASSERT_EQ(cvA_h(9), 9);
 
   /* check viewB */
   static_view_type checkViewB("tmpB");
@@ -377,16 +377,16 @@ void test_swap_ranges(ViewType view) {
   Kokkos::parallel_for(ext, cp_func_b_t(viewB, checkViewB));
   auto cvB_h =
       Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), checkViewB);
-  EXPECT_EQ(cvB_h(0), 100);
-  EXPECT_EQ(cvB_h(1), 2);
-  EXPECT_EQ(cvB_h(2), 3);
-  EXPECT_EQ(cvB_h(3), 4);
-  EXPECT_EQ(cvB_h(4), 5);
-  EXPECT_EQ(cvB_h(5), 95);
-  EXPECT_EQ(cvB_h(6), 94);
-  EXPECT_EQ(cvB_h(7), 93);
-  EXPECT_EQ(cvB_h(8), 92);
-  EXPECT_EQ(cvB_h(9), 91);
+  ASSERT_EQ(cvB_h(0), 100);
+  ASSERT_EQ(cvB_h(1), 2);
+  ASSERT_EQ(cvB_h(2), 3);
+  ASSERT_EQ(cvB_h(3), 4);
+  ASSERT_EQ(cvB_h(4), 5);
+  ASSERT_EQ(cvB_h(5), 95);
+  ASSERT_EQ(cvB_h(6), 94);
+  ASSERT_EQ(cvB_h(7), 93);
+  ASSERT_EQ(cvB_h(8), 92);
+  ASSERT_EQ(cvB_h(9), 91);
 }
 
 TEST_F(std_algorithms_mod_seq_ops_test, swap_ranges) {
diff --git a/algorithms/unit_tests/TestStdAlgorithmsMoveBackward.cpp b/algorithms/unit_tests/TestStdAlgorithmsMoveBackward.cpp
index 635714eb54..b201ab95c1 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsMoveBackward.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsMoveBackward.cpp
@@ -53,20 +53,20 @@ void run_single_scenario(const InfoType& scenario_info, int apiId) {
     auto rit =
         KE::move_backward(exespace(), KE::begin(v), KE::end(v), KE::end(v2));
     const int dist = KE::distance(KE::begin(v2), rit);
-    EXPECT_EQ(dist, 5);
+    ASSERT_EQ(dist, 5);
   } else if (apiId == 1) {
     auto rit       = KE::move_backward("mylabel", exespace(), KE::begin(v),
                                  KE::end(v), KE::end(v2));
     const int dist = KE::distance(KE::begin(v2), rit);
-    EXPECT_EQ(dist, 5);
+    ASSERT_EQ(dist, 5);
   } else if (apiId == 2) {
     auto rit       = KE::move_backward(exespace(), v, v2);
     const int dist = KE::distance(KE::begin(v2), rit);
-    EXPECT_EQ(dist, 5);
+    ASSERT_EQ(dist, 5);
   } else if (apiId == 3) {
     auto rit       = KE::move_backward("mylabel", exespace(), v, v2);
     const int dist = KE::distance(KE::begin(v2), rit);
-    EXPECT_EQ(dist, 5);
+    ASSERT_EQ(dist, 5);
   }
 
   // check
diff --git a/algorithms/unit_tests/TestStdAlgorithmsNumerics.cpp b/algorithms/unit_tests/TestStdAlgorithmsNumerics.cpp
index 288a67c369..0933c4e135 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsNumerics.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsNumerics.cpp
@@ -151,8 +151,8 @@ void run_and_check_transform_reduce_default(ViewType1 first_view,
   const auto r2 = KE::transform_reduce(
       "MYLABEL", ExecutionSpace(), KE::cbegin(first_view),
       KE::cbegin(first_view), KE::cbegin(second_view), init_value);
-  EXPECT_EQ(r1, init_value);
-  EXPECT_EQ(r2, init_value);
+  ASSERT_EQ(r1, init_value);
+  ASSERT_EQ(r2, init_value);
 
   // non-trivial cases
   const auto r3 = KE::transform_reduce(ExecutionSpace(), KE::cbegin(first_view),
@@ -168,10 +168,10 @@ void run_and_check_transform_reduce_default(ViewType1 first_view,
   const auto r6 = KE::transform_reduce("MYLABEL", ExecutionSpace(), first_view,
                                        second_view, init_value);
 
-  EXPECT_EQ(r3, result_value);
-  EXPECT_EQ(r4, result_value);
-  EXPECT_EQ(r5, result_value);
-  EXPECT_EQ(r6, result_value);
+  ASSERT_EQ(r3, result_value);
+  ASSERT_EQ(r4, result_value);
+  ASSERT_EQ(r5, result_value);
+  ASSERT_EQ(r6, result_value);
 }
 
 TEST_F(std_algorithms_numerics_test,
@@ -254,8 +254,8 @@ void run_and_check_transform_reduce_overloadA(ViewType1 first_view,
                            KE::cbegin(first_view), KE::cbegin(second_view),
                            init_value, std::forward<Args>(args)...);
 
-  EXPECT_EQ(r1, init_value);
-  EXPECT_EQ(r2, init_value);
+  ASSERT_EQ(r1, init_value);
+  ASSERT_EQ(r2, init_value);
 
   // non trivial cases
   const auto r3 = KE::transform_reduce(
@@ -273,10 +273,10 @@ void run_and_check_transform_reduce_overloadA(ViewType1 first_view,
       KE::transform_reduce("MYLABEL", ExecutionSpace(), first_view, second_view,
                            init_value, std::forward<Args>(args)...);
 
-  EXPECT_EQ(r3, result_value);
-  EXPECT_EQ(r4, result_value);
-  EXPECT_EQ(r5, result_value);
-  EXPECT_EQ(r6, result_value);
+  ASSERT_EQ(r3, result_value);
+  ASSERT_EQ(r4, result_value);
+  ASSERT_EQ(r5, result_value);
+  ASSERT_EQ(r6, result_value);
 }
 
 TEST_F(std_algorithms_numerics_test,
@@ -373,8 +373,8 @@ void run_and_check_transform_reduce_overloadB(ViewType view,
                                        KE::cbegin(view), KE::cbegin(view),
                                        init_value, std::forward<Args>(args)...);
 
-  EXPECT_EQ(r1, init_value);
-  EXPECT_EQ(r2, init_value);
+  ASSERT_EQ(r1, init_value);
+  ASSERT_EQ(r2, init_value);
 
   // non trivial
   const auto r3 =
@@ -390,10 +390,10 @@ void run_and_check_transform_reduce_overloadB(ViewType view,
   const auto r6 = KE::transform_reduce("MYLABEL", ExecutionSpace(), view,
                                        init_value, std::forward<Args>(args)...);
 
-  EXPECT_EQ(r3, result_value);
-  EXPECT_EQ(r4, result_value);
-  EXPECT_EQ(r5, result_value);
-  EXPECT_EQ(r6, result_value);
+  ASSERT_EQ(r3, result_value);
+  ASSERT_EQ(r4, result_value);
+  ASSERT_EQ(r5, result_value);
+  ASSERT_EQ(r6, result_value);
 }
 
 TEST_F(std_algorithms_numerics_test,
@@ -447,8 +447,8 @@ void run_and_check_reduce_overloadA(ViewType view, ValueType non_trivial_result,
       KE::reduce(ExecutionSpace(), KE::cbegin(view), KE::cbegin(view));
   const auto r2 = KE::reduce("MYLABEL", ExecutionSpace(), KE::cbegin(view),
                              KE::cbegin(view));
-  EXPECT_EQ(r1, trivial_result);
-  EXPECT_EQ(r2, trivial_result);
+  ASSERT_EQ(r1, trivial_result);
+  ASSERT_EQ(r2, trivial_result);
 
   // non trivial cases
   const auto r3 =
@@ -458,10 +458,10 @@ void run_and_check_reduce_overloadA(ViewType view, ValueType non_trivial_result,
   const auto r5 = KE::reduce(ExecutionSpace(), view);
   const auto r6 = KE::reduce("MYLABEL", ExecutionSpace(), view);
 
-  EXPECT_EQ(r3, non_trivial_result);
-  EXPECT_EQ(r4, non_trivial_result);
-  EXPECT_EQ(r5, non_trivial_result);
-  EXPECT_EQ(r6, non_trivial_result);
+  ASSERT_EQ(r3, non_trivial_result);
+  ASSERT_EQ(r4, non_trivial_result);
+  ASSERT_EQ(r5, non_trivial_result);
+  ASSERT_EQ(r6, non_trivial_result);
 }
 
 TEST_F(std_algorithms_numerics_test,
@@ -503,8 +503,8 @@ void run_and_check_reduce_overloadB(ViewType view, ValueType result_value,
                              KE::cbegin(view), init_value);
   const auto r2 = KE::reduce("MYLABEL", ExecutionSpace(), KE::cbegin(view),
                              KE::cbegin(view), init_value);
-  EXPECT_EQ(r1, init_value);
-  EXPECT_EQ(r2, init_value);
+  ASSERT_EQ(r1, init_value);
+  ASSERT_EQ(r2, init_value);
 
   // non trivial cases
   const auto r3 = KE::reduce(ExecutionSpace(), KE::cbegin(view), KE::cend(view),
@@ -514,10 +514,10 @@ void run_and_check_reduce_overloadB(ViewType view, ValueType result_value,
   const auto r5 = KE::reduce(ExecutionSpace(), view, init_value);
   const auto r6 = KE::reduce("MYLABEL", ExecutionSpace(), view, init_value);
 
-  EXPECT_EQ(r3, result_value);
-  EXPECT_EQ(r4, result_value);
-  EXPECT_EQ(r5, result_value);
-  EXPECT_EQ(r6, result_value);
+  ASSERT_EQ(r3, result_value);
+  ASSERT_EQ(r4, result_value);
+  ASSERT_EQ(r5, result_value);
+  ASSERT_EQ(r6, result_value);
 }
 
 TEST_F(std_algorithms_numerics_test,
@@ -553,8 +553,8 @@ void run_and_check_reduce_overloadC(ViewType view, ValueType result_value,
                              KE::cbegin(view), init_value, joiner);
   const auto r2 = KE::reduce("MYLABEL", ExecutionSpace(), KE::cbegin(view),
                              KE::cbegin(view), init_value, joiner);
-  EXPECT_EQ(r1, init_value);
-  EXPECT_EQ(r2, init_value);
+  ASSERT_EQ(r1, init_value);
+  ASSERT_EQ(r2, init_value);
 
   // non trivial cases
   const auto r3 = KE::reduce(ExecutionSpace(), KE::cbegin(view), KE::cend(view),
@@ -565,10 +565,10 @@ void run_and_check_reduce_overloadC(ViewType view, ValueType result_value,
   const auto r6 =
       KE::reduce("MYLABEL", ExecutionSpace(), view, init_value, joiner);
 
-  EXPECT_EQ(r3, result_value);
-  EXPECT_EQ(r4, result_value);
-  EXPECT_EQ(r5, result_value);
-  EXPECT_EQ(r6, result_value);
+  ASSERT_EQ(r3, result_value);
+  ASSERT_EQ(r4, result_value);
+  ASSERT_EQ(r5, result_value);
+  ASSERT_EQ(r6, result_value);
 }
 
 TEST_F(std_algorithms_numerics_test,
diff --git a/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp
index 0399e9eee4..f169fd9ce8 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp
@@ -130,12 +130,12 @@ void verify_data(const std::string& name, ResultType my_result,
   const std::size_t my_diff_true = my_result.first - KE::begin(view_dest_true);
   const std::size_t my_diff_false =
       my_result.second - KE::begin(view_dest_false);
-  EXPECT_EQ(std_diff_true, my_diff_true);
-  EXPECT_EQ(std_diff_false, my_diff_false);
+  ASSERT_EQ(std_diff_true, my_diff_true);
+  ASSERT_EQ(std_diff_false, my_diff_false);
 
   auto view_dest_true_h = create_host_space_copy(view_dest_true);
   for (std::size_t i = 0; i < std_diff_true; ++i) {
-    EXPECT_EQ(std_vec_true[i], view_dest_true_h(i));
+    ASSERT_EQ(std_vec_true[i], view_dest_true_h(i));
     // std::cout << "i= " << i << " "
     // 	      << " std_true = " << std_vec_true[i] << " "
     // 	      << " mine     = " << view_dest_true_h(i) << '\n';
@@ -143,45 +143,45 @@ void verify_data(const std::string& name, ResultType my_result,
 
   auto view_dest_false_h = create_host_space_copy(view_dest_false);
   for (std::size_t i = 0; i < std_diff_false; ++i) {
-    EXPECT_EQ(std_vec_false[i], view_dest_false_h(i));
+    ASSERT_EQ(std_vec_false[i], view_dest_false_h(i));
     // std::cout << "i= " << i << " "
     // 	      << " std_false = " << std_vec_false[i] << " "
     // 	      << " mine     = " << view_dest_false_h(i) << '\n';
   }
 
   if (name == "empty") {
-    EXPECT_EQ(my_diff_true, 0u);
-    EXPECT_EQ(my_diff_false, 0u);
+    ASSERT_EQ(my_diff_true, 0u);
+    ASSERT_EQ(my_diff_false, 0u);
   }
 
   else if (name == "one-element-a") {
-    EXPECT_EQ(my_diff_true, 0u);
-    EXPECT_EQ(my_diff_false, 1u);
+    ASSERT_EQ(my_diff_true, 0u);
+    ASSERT_EQ(my_diff_false, 1u);
   }
 
   else if (name == "one-element-b") {
-    EXPECT_EQ(my_diff_true, 1u);
-    EXPECT_EQ(my_diff_false, 0u);
+    ASSERT_EQ(my_diff_true, 1u);
+    ASSERT_EQ(my_diff_false, 0u);
   }
 
   else if (name == "two-elements-a") {
-    EXPECT_EQ(my_diff_true, 1u);
-    EXPECT_EQ(my_diff_false, 1u);
+    ASSERT_EQ(my_diff_true, 1u);
+    ASSERT_EQ(my_diff_false, 1u);
   }
 
   else if (name == "two-elements-b") {
-    EXPECT_EQ(my_diff_true, 1u);
-    EXPECT_EQ(my_diff_false, 1u);
+    ASSERT_EQ(my_diff_true, 1u);
+    ASSERT_EQ(my_diff_false, 1u);
   }
 
   else if (name == "small-b") {
-    EXPECT_EQ(my_diff_true, 13u);
-    EXPECT_EQ(my_diff_false, 0u);
+    ASSERT_EQ(my_diff_true, 13u);
+    ASSERT_EQ(my_diff_false, 0u);
   }
 
   else if (name == "small-c") {
-    EXPECT_EQ(my_diff_true, 0u);
-    EXPECT_EQ(my_diff_false, 15u);
+    ASSERT_EQ(my_diff_true, 0u);
+    ASSERT_EQ(my_diff_false, 15u);
   }
 }
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
index 1bfb536c2c..33a1326c47 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
@@ -148,12 +148,6 @@ struct std_algorithms_partitioning_test : public std_algorithms_test {
 };
 
 TEST_F(std_algorithms_partitioning_test, is_partitioned_trivial) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   IsNegativeFunctor<value_type> p;
   const auto result1 = KE::is_partitioned(exespace(), KE::cbegin(m_static_view),
                                           KE::cbegin(m_static_view), p);
@@ -169,12 +163,6 @@ TEST_F(std_algorithms_partitioning_test, is_partitioned_trivial) {
 }
 
 TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_iterators) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   const IsNegativeFunctor<value_type> p;
 
   for (int id = 0; id < FixtureViews::Count; ++id) {
@@ -183,25 +171,19 @@ TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_iterators) {
         goldSolutionIsPartitioned(static_cast<FixtureViews>(id));
     const auto result1 = KE::is_partitioned(
         exespace(), KE::cbegin(m_static_view), KE::cend(m_static_view), p);
-    EXPECT_EQ(goldBool, result1);
+    ASSERT_EQ(goldBool, result1);
 
     const auto result2 = KE::is_partitioned(
         exespace(), KE::cbegin(m_dynamic_view), KE::cend(m_dynamic_view), p);
-    EXPECT_EQ(goldBool, result2);
+    ASSERT_EQ(goldBool, result2);
 
     const auto result3 = KE::is_partitioned(
         exespace(), KE::cbegin(m_strided_view), KE::cend(m_strided_view), p);
-    EXPECT_EQ(goldBool, result3);
+    ASSERT_EQ(goldBool, result3);
   }
 }
 
 TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_view) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   const IsNegativeFunctor<value_type> p;
 
   for (int id = 0; id < FixtureViews::Count; ++id) {
@@ -209,23 +191,17 @@ TEST_F(std_algorithms_partitioning_test, is_partitioned_accepting_view) {
     const bool goldBool =
         goldSolutionIsPartitioned(static_cast<FixtureViews>(id));
     const auto result1 = KE::is_partitioned(exespace(), m_static_view, p);
-    EXPECT_EQ(goldBool, result1);
+    ASSERT_EQ(goldBool, result1);
 
     const auto result2 = KE::is_partitioned(exespace(), m_dynamic_view, p);
-    EXPECT_EQ(goldBool, result2);
+    ASSERT_EQ(goldBool, result2);
 
     const auto result3 = KE::is_partitioned(exespace(), m_strided_view, p);
-    EXPECT_EQ(goldBool, result3);
+    ASSERT_EQ(goldBool, result3);
   }
 }
 
 TEST_F(std_algorithms_partitioning_test, partition_point) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   const IsNegativeFunctor<value_type> p;
 
   for (int id = 0; id < FixtureViews::Count; ++id) {
@@ -235,17 +211,17 @@ TEST_F(std_algorithms_partitioning_test, partition_point) {
     auto first1        = KE::cbegin(m_static_view);
     auto last1         = KE::cend(m_static_view);
     const auto result1 = KE::partition_point(exespace(), first1, last1, p);
-    EXPECT_EQ(goldIndex, result1 - first1);
+    ASSERT_EQ(goldIndex, result1 - first1);
 
     auto first2        = KE::cbegin(m_dynamic_view);
     auto last2         = KE::cend(m_dynamic_view);
     const auto result2 = KE::partition_point(exespace(), first2, last2, p);
-    EXPECT_EQ(goldIndex, result2 - first2);
+    ASSERT_EQ(goldIndex, result2 - first2);
 
     auto first3        = KE::cbegin(m_strided_view);
     auto last3         = KE::cend(m_strided_view);
     const auto result3 = KE::partition_point(exespace(), first3, last3, p);
-    EXPECT_EQ(goldIndex, result3 - first3);
+    ASSERT_EQ(goldIndex, result3 - first3);
   }
 }
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsRemove.cpp b/algorithms/unit_tests/TestStdAlgorithmsRemove.cpp
index 8832d71f95..c35fc5c24b 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsRemove.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsRemove.cpp
@@ -117,12 +117,12 @@ void verify_data(ViewTypeData view_data_h, ViewTypeTest view_test,
   // check that returned iterators are correct
   const std::size_t std_diff = std_result - KE::begin(view_data_h);
   const std::size_t my_diff  = my_result - KE::begin(view_test);
-  EXPECT_EQ(std_diff, my_diff);
+  ASSERT_EQ(std_diff, my_diff);
 
   // check the actual data after algo has been applied
   auto view_test_h = create_host_space_copy(view_test);
   for (std::size_t i = 0; i < my_diff; ++i) {
-    EXPECT_EQ(view_test_h(i), view_data_h[i]);
+    ASSERT_EQ(view_test_h(i), view_data_h[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << view_test_h(i) << " "
     // 	      << "std: " << view_data_h(i)
diff --git a/algorithms/unit_tests/TestStdAlgorithmsRemoveCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsRemoveCopy.cpp
index 949f8f60c9..3d7c52108b 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsRemoveCopy.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsRemoveCopy.cpp
@@ -135,12 +135,12 @@ void verify_data(ViewFromType view_from, ViewDestType view_dest,
   // check that returned iterators are correct
   const std::size_t std_diff = std_result - gold_dest_std.begin();
   const std::size_t my_diff  = my_result - KE::begin(view_dest);
-  EXPECT_EQ(std_diff, my_diff);
+  ASSERT_EQ(std_diff, my_diff);
 
   // check the actual data after algo has been applied
   auto view_dest_h = create_host_space_copy(view_dest);
   for (std::size_t i = 0; i < my_diff; ++i) {
-    EXPECT_EQ(view_dest_h(i), gold_dest_std[i]);
+    ASSERT_EQ(view_dest_h(i), gold_dest_std[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << view_dest_h(i) << " "
     // 	      << "std: " << gold_dest_std[i]
diff --git a/algorithms/unit_tests/TestStdAlgorithmsRemoveCopyIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsRemoveCopyIf.cpp
index 9dc1e4a7e1..cb699aa923 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsRemoveCopyIf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsRemoveCopyIf.cpp
@@ -119,12 +119,12 @@ void verify_data(ViewTypeFrom view_from, ViewTypeDest view_dest,
   // check that returned iterators are correct
   const std::size_t std_diff = std_result - gold_dest_std.begin();
   const std::size_t my_diff  = my_result - KE::begin(view_dest);
-  EXPECT_EQ(std_diff, my_diff);
+  ASSERT_EQ(std_diff, my_diff);
 
   // check the actual data after algo has been applied
   auto view_dest_h = create_host_space_copy(view_dest);
   for (std::size_t i = 0; i < my_diff; ++i) {
-    EXPECT_EQ(view_dest_h(i), gold_dest_std[i]);
+    ASSERT_EQ(view_dest_h(i), gold_dest_std[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << view_dest_h(i) << " "
     // 	      << "std: " << gold_dest_std[i]
diff --git a/algorithms/unit_tests/TestStdAlgorithmsRemoveIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsRemoveIf.cpp
index e9d15f29d8..f06f2234ee 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsRemoveIf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsRemoveIf.cpp
@@ -112,12 +112,12 @@ void verify_data(ViewTypeData view_data_h, ViewTypeTest view_test,
   // check that returned iterators are correct
   const std::size_t std_diff = std_result - KE::begin(view_data_h);
   const std::size_t my_diff  = my_result - KE::begin(view_test);
-  EXPECT_EQ(std_diff, my_diff);
+  ASSERT_EQ(std_diff, my_diff);
 
   // check the actual data after algo has been applied
   auto view_test_h = create_host_space_copy(view_test);
   for (std::size_t i = 0; i < my_diff; ++i) {
-    EXPECT_EQ(view_test_h(i), view_data_h[i]);
+    ASSERT_EQ(view_test_h(i), view_data_h[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << view_test_h(i) << " "
     // 	      << "std: " << view_data_h(i)
diff --git a/algorithms/unit_tests/TestStdAlgorithmsReplace.cpp b/algorithms/unit_tests/TestStdAlgorithmsReplace.cpp
index b226de5535..a22ab32d76 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsReplace.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsReplace.cpp
@@ -104,30 +104,30 @@ void verify_data(const std::string& name, ViewType1 test_view,
   }
 
   else if (name == "one-element-a") {
-    EXPECT_EQ(view_h(0), ValueType{1});
+    ASSERT_EQ(view_h(0), ValueType{1});
   }
 
   else if (name == "one-element-b") {
-    EXPECT_EQ(view_h(0), new_value);
+    ASSERT_EQ(view_h(0), new_value);
   }
 
   else if (name == "two-elements-a") {
-    EXPECT_EQ(view_h(0), ValueType{1});
-    EXPECT_EQ(view_h(1), new_value);
+    ASSERT_EQ(view_h(0), ValueType{1});
+    ASSERT_EQ(view_h(1), new_value);
   }
 
   else if (name == "two-elements-b") {
-    EXPECT_EQ(view_h(0), new_value);
-    EXPECT_EQ(view_h(1), ValueType{-1});
+    ASSERT_EQ(view_h(0), new_value);
+    ASSERT_EQ(view_h(1), ValueType{-1});
   }
 
   else if (name == "small-a") {
     for (std::size_t i = 0; i < view_h.extent(0); ++i) {
       if (i == 0 || i == 3 || i == 5 || i == 6) {
-        EXPECT_EQ(view_h(i), new_value);
+        ASSERT_EQ(view_h(i), new_value);
       } else {
         const auto gold = ValueType{-5} + static_cast<ValueType>(i + 1);
-        EXPECT_EQ(view_h(i), gold);
+        ASSERT_EQ(view_h(i), gold);
       }
     }
   }
@@ -135,9 +135,9 @@ void verify_data(const std::string& name, ViewType1 test_view,
   else if (name == "small-b") {
     for (std::size_t i = 0; i < view_h.extent(0); ++i) {
       if (i < 4) {
-        EXPECT_EQ(view_h(i), ValueType{-1});
+        ASSERT_EQ(view_h(i), ValueType{-1});
       } else {
-        EXPECT_EQ(view_h(i), new_value);
+        ASSERT_EQ(view_h(i), new_value);
       }
     }
   }
@@ -145,9 +145,9 @@ void verify_data(const std::string& name, ViewType1 test_view,
   else if (name == "medium" || name == "large") {
     for (std::size_t i = 0; i < view_h.extent(0); ++i) {
       if (i % 2 == 0) {
-        EXPECT_EQ(view_h(i), ValueType{-1});
+        ASSERT_EQ(view_h(i), ValueType{-1});
       } else {
-        EXPECT_EQ(view_h(i), new_value);
+        ASSERT_EQ(view_h(i), new_value);
       }
     }
   }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsReplaceCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsReplaceCopy.cpp
index 16b181fdd2..a964ec8e17 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsReplaceCopy.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsReplaceCopy.cpp
@@ -112,40 +112,40 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   }
 
   else if (name == "one-element-a") {
-    EXPECT_EQ(view_from_h(0), ValueType{1});
-    EXPECT_EQ(view_test_h(0), view_from_h(0));
+    ASSERT_EQ(view_from_h(0), ValueType{1});
+    ASSERT_EQ(view_test_h(0), view_from_h(0));
   }
 
   else if (name == "one-element-b") {
-    EXPECT_EQ(view_from_h(0), ValueType{2});
-    EXPECT_EQ(view_test_h(0), new_value);
+    ASSERT_EQ(view_from_h(0), ValueType{2});
+    ASSERT_EQ(view_test_h(0), new_value);
   }
 
   else if (name == "two-elements-a") {
-    EXPECT_EQ(view_from_h(0), ValueType{1});
-    EXPECT_EQ(view_from_h(1), ValueType{2});
+    ASSERT_EQ(view_from_h(0), ValueType{1});
+    ASSERT_EQ(view_from_h(1), ValueType{2});
 
-    EXPECT_EQ(view_test_h(0), view_from_h(0));
-    EXPECT_EQ(view_test_h(1), new_value);
+    ASSERT_EQ(view_test_h(0), view_from_h(0));
+    ASSERT_EQ(view_test_h(1), new_value);
   }
 
   else if (name == "two-elements-b") {
-    EXPECT_EQ(view_from_h(0), ValueType{2});
-    EXPECT_EQ(view_from_h(1), ValueType{-1});
+    ASSERT_EQ(view_from_h(0), ValueType{2});
+    ASSERT_EQ(view_from_h(1), ValueType{-1});
 
-    EXPECT_EQ(view_test_h(0), new_value);
-    EXPECT_EQ(view_test_h(1), view_from_h(1));
+    ASSERT_EQ(view_test_h(0), new_value);
+    ASSERT_EQ(view_test_h(1), view_from_h(1));
   }
 
   else if (name == "small-a") {
     for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
       if (i == 0 || i == 3 || i == 5 || i == 6) {
-        EXPECT_EQ(view_from_h(i), ValueType{2});
-        EXPECT_EQ(view_test_h(i), new_value);
+        ASSERT_EQ(view_from_h(i), ValueType{2});
+        ASSERT_EQ(view_test_h(i), new_value);
       } else {
         const auto gold = ValueType{-5} + static_cast<ValueType>(i + 1);
-        EXPECT_EQ(view_from_h(i), gold);
-        EXPECT_EQ(view_test_h(i), gold);
+        ASSERT_EQ(view_from_h(i), gold);
+        ASSERT_EQ(view_test_h(i), gold);
       }
     }
   }
@@ -153,11 +153,11 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   else if (name == "small-b") {
     for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
       if (i < 4) {
-        EXPECT_EQ(view_from_h(i), ValueType{-1});
-        EXPECT_EQ(view_test_h(i), view_from_h(i));
+        ASSERT_EQ(view_from_h(i), ValueType{-1});
+        ASSERT_EQ(view_test_h(i), view_from_h(i));
       } else {
-        EXPECT_EQ(view_from_h(i), ValueType{2});
-        EXPECT_EQ(view_test_h(i), new_value);
+        ASSERT_EQ(view_from_h(i), ValueType{2});
+        ASSERT_EQ(view_test_h(i), new_value);
       }
     }
   }
@@ -165,11 +165,11 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   else if (name == "medium" || name == "large") {
     for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
       if (i % 2 == 0) {
-        EXPECT_EQ(view_from_h(i), ValueType{-1});
-        EXPECT_EQ(view_test_h(i), view_from_h(i));
+        ASSERT_EQ(view_from_h(i), ValueType{-1});
+        ASSERT_EQ(view_test_h(i), view_from_h(i));
       } else {
-        EXPECT_EQ(view_from_h(i), ValueType{2});
-        EXPECT_EQ(view_test_h(i), new_value);
+        ASSERT_EQ(view_from_h(i), ValueType{2});
+        ASSERT_EQ(view_test_h(i), new_value);
       }
     }
   }
@@ -202,7 +202,7 @@ void run_single_scenario(const InfoType& scenario_info) {
         KE::replace_copy(exespace(), KE::cbegin(view_from), KE::cend(view_from),
                          KE::begin(view_dest), old_value, new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -215,7 +215,7 @@ void run_single_scenario(const InfoType& scenario_info) {
                                 KE::cend(view_from), KE::begin(view_dest),
                                 old_value, new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -227,7 +227,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto rit = KE::replace_copy(exespace(), view_from, view_dest, old_value,
                                 new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -239,7 +239,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto rit = KE::replace_copy("label", exespace(), view_from, view_dest,
                                 old_value, new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   Kokkos::fence();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsReplaceCopyIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsReplaceCopyIf.cpp
index a402e30ad9..ceeba88971 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsReplaceCopyIf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsReplaceCopyIf.cpp
@@ -112,40 +112,40 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   }
 
   else if (name == "one-element-a") {
-    EXPECT_EQ(view_from_h(0), ValueType{1});
-    EXPECT_EQ(view_test_h(0), view_from_h(0));
+    ASSERT_EQ(view_from_h(0), ValueType{1});
+    ASSERT_EQ(view_test_h(0), view_from_h(0));
   }
 
   else if (name == "one-element-b") {
-    EXPECT_EQ(view_from_h(0), ValueType{2});
-    EXPECT_EQ(view_test_h(0), new_value);
+    ASSERT_EQ(view_from_h(0), ValueType{2});
+    ASSERT_EQ(view_test_h(0), new_value);
   }
 
   else if (name == "two-elements-a") {
-    EXPECT_EQ(view_from_h(0), ValueType{1});
-    EXPECT_EQ(view_from_h(1), ValueType{2});
+    ASSERT_EQ(view_from_h(0), ValueType{1});
+    ASSERT_EQ(view_from_h(1), ValueType{2});
 
-    EXPECT_EQ(view_test_h(0), view_from_h(0));
-    EXPECT_EQ(view_test_h(1), new_value);
+    ASSERT_EQ(view_test_h(0), view_from_h(0));
+    ASSERT_EQ(view_test_h(1), new_value);
   }
 
   else if (name == "two-elements-b") {
-    EXPECT_EQ(view_from_h(0), ValueType{2});
-    EXPECT_EQ(view_from_h(1), ValueType{-1});
+    ASSERT_EQ(view_from_h(0), ValueType{2});
+    ASSERT_EQ(view_from_h(1), ValueType{-1});
 
-    EXPECT_EQ(view_test_h(0), new_value);
-    EXPECT_EQ(view_test_h(1), view_from_h(1));
+    ASSERT_EQ(view_test_h(0), new_value);
+    ASSERT_EQ(view_test_h(1), view_from_h(1));
   }
 
   else if (name == "small-a") {
     for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
       if (i == 0 || i == 3 || i == 5 || i == 6) {
-        EXPECT_EQ(view_from_h(i), ValueType{2});
-        EXPECT_EQ(view_test_h(i), new_value);
+        ASSERT_EQ(view_from_h(i), ValueType{2});
+        ASSERT_EQ(view_test_h(i), new_value);
       } else {
         const auto gold = ValueType{-5} + static_cast<ValueType>(i + 1);
-        EXPECT_EQ(view_from_h(i), gold);
-        EXPECT_EQ(view_test_h(i), gold);
+        ASSERT_EQ(view_from_h(i), gold);
+        ASSERT_EQ(view_test_h(i), gold);
       }
     }
   }
@@ -153,11 +153,11 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   else if (name == "small-b") {
     for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
       if (i < 4) {
-        EXPECT_EQ(view_from_h(i), ValueType{-1});
-        EXPECT_EQ(view_test_h(i), view_from_h(i));
+        ASSERT_EQ(view_from_h(i), ValueType{-1});
+        ASSERT_EQ(view_test_h(i), view_from_h(i));
       } else {
-        EXPECT_EQ(view_from_h(i), ValueType{2});
-        EXPECT_EQ(view_test_h(i), new_value);
+        ASSERT_EQ(view_from_h(i), ValueType{2});
+        ASSERT_EQ(view_test_h(i), new_value);
       }
     }
   }
@@ -165,11 +165,11 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   else if (name == "medium" || name == "large") {
     for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
       if (i % 2 == 0) {
-        EXPECT_EQ(view_from_h(i), ValueType{-1});
-        EXPECT_EQ(view_test_h(i), view_from_h(i));
+        ASSERT_EQ(view_from_h(i), ValueType{-1});
+        ASSERT_EQ(view_test_h(i), view_from_h(i));
       } else {
-        EXPECT_EQ(view_from_h(i), ValueType{2});
-        EXPECT_EQ(view_test_h(i), new_value);
+        ASSERT_EQ(view_from_h(i), ValueType{2});
+        ASSERT_EQ(view_test_h(i), new_value);
       }
     }
   }
@@ -209,7 +209,7 @@ void run_single_scenario(const InfoType& scenario_info) {
                                    KE::cend(view_from), KE::begin(view_dest),
                                    pred_type(), new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -220,7 +220,7 @@ void run_single_scenario(const InfoType& scenario_info) {
                                    KE::cend(view_from), KE::begin(view_dest),
                                    pred_type(), new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -230,7 +230,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto rit = KE::replace_copy_if(exespace(), view_from, view_dest,
                                    pred_type(), new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -240,7 +240,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto rit = KE::replace_copy_if("label", exespace(), view_from, view_dest,
                                    pred_type(), new_value);
     verify_data(name, view_from, view_dest, new_value);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   Kokkos::fence();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsReplaceIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsReplaceIf.cpp
index f481144e1c..802c0093c5 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsReplaceIf.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsReplaceIf.cpp
@@ -138,7 +138,7 @@ void verify_data(ViewType1 data_view,  // contains data
       // 		<< data_view_dc(i) << " "
       // 		<< data_view_h(i) << " "
       // 		<< test_view_h(i) << std::endl;
-      EXPECT_EQ(data_view_h(i), test_view_h(i));
+      ASSERT_EQ(data_view_h(i), test_view_h(i));
     }
   }
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsReverse.cpp b/algorithms/unit_tests/TestStdAlgorithmsReverse.cpp
index 7d16e54029..6e6ca72783 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsReverse.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsReverse.cpp
@@ -77,7 +77,7 @@ void verify_data(ViewType1 test_view, ViewType2 orig_view) {
 
   const std::size_t ext = test_view.extent(0);
   for (std::size_t i = 0; i < ext; ++i) {
-    EXPECT_EQ(tv_h(i), ov_h(ext - i - 1));
+    ASSERT_EQ(tv_h(i), ov_h(ext - i - 1));
   }
 }
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsRotate.cpp b/algorithms/unit_tests/TestStdAlgorithmsRotate.cpp
index a5a6f99bac..5638cbee4a 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsRotate.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsRotate.cpp
@@ -136,13 +136,13 @@ void verify_data(ResultIt result_it, ViewType view, ViewHostType data_view_host,
   // make sure results match
   const auto my_diff  = result_it - KE::begin(view);
   const auto std_diff = std_rit - KE::begin(data_view_host);
-  EXPECT_EQ(my_diff, std_diff);
+  ASSERT_EQ(my_diff, std_diff);
 
   // check views match
   auto view_h           = create_host_space_copy(view);
   const std::size_t ext = view_h.extent(0);
   for (std::size_t i = 0; i < ext; ++i) {
-    EXPECT_EQ(view_h(i), data_view_host[i]);
+    ASSERT_EQ(view_h(i), data_view_host[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << view_h(i) << " "
     // 	      << "std: " << data_view_host(i)
diff --git a/algorithms/unit_tests/TestStdAlgorithmsRotateCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsRotateCopy.cpp
index 27451a1d04..d0caca7cea 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsRotateCopy.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsRotateCopy.cpp
@@ -139,7 +139,7 @@ void verify_data(ViewTypeFrom view_from, ViewTypeTest view_test,
                    std_gold_h.begin());
 
   for (std::size_t i = 0; i < ext; ++i) {
-    EXPECT_EQ(view_test_h(i), std_gold_h[i]);
+    ASSERT_EQ(view_test_h(i), std_gold_h[i]);
     // std::cout << "i= " << i << " "
     // 	      << "from: " << view_from_h(i) << " "
     // 	      << "mine: " << view_test_h(i) << " "
@@ -177,7 +177,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto rit  = KE::rotate_copy(exespace(), KE::cbegin(view_from), n_it,
                                KE::cend(view_from), KE::begin(view_dest));
     verify_data(view_from, view_dest, rotation_point);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -187,7 +187,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto rit = KE::rotate_copy("label", exespace(), KE::cbegin(view_from), n_it,
                                KE::cend(view_from), KE::begin(view_dest));
     verify_data(view_from, view_dest, rotation_point);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -196,7 +196,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto rit =
         KE::rotate_copy(exespace(), view_from, rotation_point, view_dest);
     verify_data(view_from, view_dest, rotation_point);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   {
@@ -205,7 +205,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto rit = KE::rotate_copy("label", exespace(), view_from, rotation_point,
                                view_dest);
     verify_data(view_from, view_dest, rotation_point);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + view_ext));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + view_ext));
   }
 
   Kokkos::fence();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsSearch.cpp b/algorithms/unit_tests/TestStdAlgorithmsSearch.cpp
index ab4bf50713..021609c444 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsSearch.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsSearch.cpp
@@ -259,7 +259,7 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t seq_ext,
                             KE::cbegin(s_view), KE::cend(s_view), args...);
     const auto mydiff = myrit - KE::cbegin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
@@ -268,21 +268,21 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t seq_ext,
                    KE::cbegin(s_view), KE::cend(s_view), args...);
     const auto mydiff  = myrit - KE::cbegin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit         = KE::search(exespace(), view, s_view, args...);
     const auto mydiff  = myrit - KE::begin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit         = KE::search("label", exespace(), view, s_view, args...);
     const auto mydiff  = myrit - KE::begin(view);
     const auto stddiff = stdrit - KE::cbegin(view_h);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   Kokkos::fence();
@@ -325,12 +325,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, search) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsSearch_n.cpp b/algorithms/unit_tests/TestStdAlgorithmsSearch_n.cpp
index a6fe9c1e89..53ad8daa2e 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsSearch_n.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsSearch_n.cpp
@@ -203,26 +203,26 @@ void run_single_scenario(const InfoType& scenario_info, std::size_t count,
     auto myrit = KE::search_n(exespace(), KE::cbegin(view), KE::cend(view),
                               count, value, args...);
     const auto mydiff = myrit - KE::cbegin(view);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit        = KE::search_n("label", exespace(), KE::cbegin(view),
                               KE::cend(view), count, value, args...);
     const auto mydiff = myrit - KE::cbegin(view);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit = KE::search_n("label", exespace(), view, count, value, args...);
     const auto mydiff = myrit - KE::begin(view);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   {
     auto myrit        = KE::search_n(exespace(), view, count, value, args...);
     const auto mydiff = myrit - KE::begin(view);
-    EXPECT_EQ(mydiff, stddiff);
+    ASSERT_EQ(mydiff, stddiff);
   }
 
   Kokkos::fence();
@@ -297,12 +297,6 @@ void run_all_scenarios() {
 }
 
 TEST(std_algorithms_non_mod_seq_ops, search_n) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<exespace, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   run_all_scenarios<DynamicTag, int>();
   run_all_scenarios<StridedThreeTag, int>();
 }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsShiftLeft.cpp b/algorithms/unit_tests/TestStdAlgorithmsShiftLeft.cpp
index 8e4ced9635..0b5fe9216e 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsShiftLeft.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsShiftLeft.cpp
@@ -103,12 +103,12 @@ void verify_data(ResultIt result_it, ViewType view, ViewHostType data_view_host,
   // make sure results match
   const auto my_diff  = result_it - KE::begin(view);
   const auto std_diff = std_rit - KE::begin(data_view_host);
-  EXPECT_EQ(my_diff, std_diff);
+  ASSERT_EQ(my_diff, std_diff);
 
   // check views match
   auto view_h = create_host_space_copy(view);
   for (std::size_t i = 0; i < (std::size_t)my_diff; ++i) {
-    EXPECT_EQ(view_h(i), data_view_host[i]);
+    ASSERT_EQ(view_h(i), data_view_host[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << view_h(i) << " "
     // 	      << "std: " << data_view_host(i)
diff --git a/algorithms/unit_tests/TestStdAlgorithmsShiftRight.cpp b/algorithms/unit_tests/TestStdAlgorithmsShiftRight.cpp
index a1614be027..8e4ae94375 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsShiftRight.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsShiftRight.cpp
@@ -101,14 +101,14 @@ void verify_data(ResultIt result_it, ViewType view, ViewHostType data_view_host,
   // make sure results match
   const auto my_diff  = KE::end(view) - result_it;
   const auto std_diff = KE::end(data_view_host) - std_rit;
-  EXPECT_EQ(my_diff, std_diff);
+  ASSERT_EQ(my_diff, std_diff);
 
   // check views match
   auto view_h = create_host_space_copy(view);
   auto it1    = KE::cbegin(view_h);
   auto it2    = KE::cbegin(data_view_host);
   for (std::size_t i = 0; i < (std::size_t)my_diff; ++i) {
-    EXPECT_EQ(it1[i], it2[i]);
+    ASSERT_EQ(it1[i], it2[i]);
     // std::cout << "i= " << i << " "
     // 	      << "mine: " << it1[i] << " "
     // 	      << "std:  " << it2[i]
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp
index 70c04dbafa..75525b3b0f 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp
@@ -165,7 +165,7 @@ void verify_data(ViewType1 data_view,  // contains data
       //           << std::abs(gold_h(i) - test_view_h(i)) << std::endl;
 
       if (std::is_same<gold_view_value_type, int>::value) {
-        EXPECT_EQ(gold_h(i), test_view_h(i));
+        ASSERT_EQ(gold_h(i), test_view_h(i));
       } else {
         const auto error = std::abs(gold_h(i) - test_view_h(i));
         if (error > 1e-10) {
@@ -221,7 +221,7 @@ void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
     auto r = KE::transform_exclusive_scan(
         exespace(), KE::cbegin(view_from), KE::cend(view_from),
         KE::begin(view_dest), init_value, bop, uop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop, uop);
   }
 
@@ -230,7 +230,7 @@ void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
     auto r = KE::transform_exclusive_scan(
         "label", exespace(), KE::cbegin(view_from), KE::cend(view_from),
         KE::begin(view_dest), init_value, bop, uop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop, uop);
   }
 
@@ -238,7 +238,7 @@ void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
     fill_zero(view_dest);
     auto r = KE::transform_exclusive_scan(exespace(), view_from, view_dest,
                                           init_value, bop, uop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop, uop);
   }
 
@@ -246,7 +246,7 @@ void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
     fill_zero(view_dest);
     auto r = KE::transform_exclusive_scan("label", exespace(), view_from,
                                           view_dest, init_value, bop, uop);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, init_value, bop, uop);
   }
 
@@ -279,6 +279,59 @@ TEST(std_algorithms_numeric_ops_test, transform_exclusive_scan) {
 }
 #endif
 
+template <class ValueType>
+struct MultiplyFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& a, const ValueType& b) const {
+    return (a * b);
+  }
+};
+
+TEST(std_algorithms_numeric_ops_test, transform_exclusive_scan_functor) {
+  int dummy       = 0;
+  using view_type = Kokkos::View<int*, exespace>;
+  view_type dummy_view("dummy_view", 0);
+  using unary_op_type =
+      Kokkos::Experimental::Impl::StdNumericScanIdentityReferenceUnaryFunctor<
+          int>;
+  using functor_type =
+      Kokkos::Experimental::Impl::TransformExclusiveScanFunctor<
+          exespace, int, int, view_type, view_type, MultiplyFunctor<int>,
+          unary_op_type>;
+  functor_type functor(dummy, dummy_view, dummy_view, {}, {});
+  using value_type = functor_type::value_type;
+
+  value_type value1;
+  functor.init(value1);
+  ASSERT_EQ(value1.val, 0);
+  ASSERT_EQ(value1.is_initial, true);
+
+  value_type value2;
+  value2.val        = 1;
+  value2.is_initial = false;
+  functor.join(value1, value2);
+  ASSERT_EQ(value1.val, 1);
+  ASSERT_EQ(value1.is_initial, false);
+
+  functor.init(value1);
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 1);
+  ASSERT_EQ(value2.is_initial, false);
+
+  functor.init(value2);
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 0);
+  ASSERT_EQ(value2.is_initial, true);
+
+  value1.val        = 3;
+  value1.is_initial = false;
+  value2.val        = 2;
+  value2.is_initial = false;
+  functor.join(value2, value1);
+  ASSERT_EQ(value2.val, 6);
+  ASSERT_EQ(value2.is_initial, false);
+}
+
 }  // namespace TransformEScan
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp
index 80ff813251..5d122ac5e8 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp
@@ -177,7 +177,7 @@ void verify_data(ViewType1 data_view,  // contains data
       //           << std::abs(gold_h(i) - test_view_h(i)) << std::endl;
 
       if (std::is_same<gold_view_value_type, int>::value) {
-        EXPECT_EQ(gold_h(i), test_view_h(i));
+        ASSERT_EQ(gold_h(i), test_view_h(i));
       } else {
         const auto error = std::abs(gold_h(i) - test_view_h(i));
         if (error > 1e-10) {
@@ -246,7 +246,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto r = KE::transform_inclusive_scan(exespace(), KE::cbegin(view_from),
                                           KE::cend(view_from),
                                           KE::begin(view_dest), args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, args...);
   }
 
@@ -255,7 +255,7 @@ void run_single_scenario(const InfoType& scenario_info,
     auto r = KE::transform_inclusive_scan(
         "label", exespace(), KE::cbegin(view_from), KE::cend(view_from),
         KE::begin(view_dest), args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, args...);
   }
 
@@ -263,7 +263,7 @@ void run_single_scenario(const InfoType& scenario_info,
     fill_zero(view_dest);
     auto r =
         KE::transform_inclusive_scan(exespace(), view_from, view_dest, args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, args...);
   }
 
@@ -271,7 +271,7 @@ void run_single_scenario(const InfoType& scenario_info,
     fill_zero(view_dest);
     auto r = KE::transform_inclusive_scan("label", exespace(), view_from,
                                           view_dest, args...);
-    EXPECT_EQ(r, KE::end(view_dest));
+    ASSERT_EQ(r, KE::end(view_dest));
     verify_data(view_from, view_dest, args...);
   }
 
@@ -306,6 +306,73 @@ TEST(std_algorithms_numeric_ops_test, transform_inclusive_scan) {
 }
 #endif
 
+template <class ValueType>
+struct MultiplyFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& a, const ValueType& b) const {
+    return (a * b);
+  }
+};
+
+TEST(std_algorithms_numeric_ops_test, transform_inclusive_scan_functor) {
+  using value_type = KE::Impl::ValueWrapperForNoNeutralElement<int>;
+
+  auto test_lambda = [&](auto& functor) {
+    value_type value1;
+    functor.init(value1);
+    ASSERT_EQ(value1.val, 0);
+    ASSERT_EQ(value1.is_initial, true);
+
+    value_type value2;
+    value2.val        = 1;
+    value2.is_initial = false;
+    functor.join(value1, value2);
+    ASSERT_EQ(value1.val, 1);
+    ASSERT_EQ(value1.is_initial, false);
+
+    functor.init(value1);
+    functor.join(value2, value1);
+    ASSERT_EQ(value2.val, 1);
+    ASSERT_EQ(value2.is_initial, false);
+
+    functor.init(value2);
+    functor.join(value2, value1);
+    ASSERT_EQ(value2.val, 0);
+    ASSERT_EQ(value2.is_initial, true);
+
+    value1.val        = 3;
+    value1.is_initial = false;
+    value2.val        = 2;
+    value2.is_initial = false;
+    functor.join(value2, value1);
+    ASSERT_EQ(value2.val, 6);
+    ASSERT_EQ(value2.is_initial, false);
+  };
+
+  int dummy       = 0;
+  using view_type = Kokkos::View<int*, exespace>;
+  view_type dummy_view("dummy_view", 0);
+  using unary_op_type =
+      KE::Impl::StdNumericScanIdentityReferenceUnaryFunctor<int>;
+  {
+    using functor_type = KE::Impl::TransformInclusiveScanNoInitValueFunctor<
+        exespace, int, int, view_type, view_type, MultiplyFunctor<int>,
+        unary_op_type>;
+    functor_type functor(dummy_view, dummy_view, {}, {});
+
+    test_lambda(functor);
+  }
+
+  {
+    using functor_type = KE::Impl::TransformInclusiveScanWithInitValueFunctor<
+        exespace, int, int, view_type, view_type, MultiplyFunctor<int>,
+        unary_op_type>;
+    functor_type functor(dummy_view, dummy_view, {}, {}, dummy);
+
+    test_lambda(functor);
+  }
+}
+
 }  // namespace TransformIncScan
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTransformUnaryOp.cpp b/algorithms/unit_tests/TestStdAlgorithmsTransformUnaryOp.cpp
index dab81b8f1e..6070c1a60d 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsTransformUnaryOp.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsTransformUnaryOp.cpp
@@ -58,7 +58,7 @@ void verify_data(ViewTypeFrom view_from, ViewTypeTest view_test) {
       create_mirror_view_and_copy(Kokkos::HostSpace(), view_from_dc);
 
   for (std::size_t i = 0; i < view_test_h.extent(0); ++i) {
-    EXPECT_EQ(view_test_h(i), view_from_h(i) + value_type(1));
+    ASSERT_EQ(view_test_h(i), view_from_h(i) + value_type(1));
   }
 }
 
@@ -89,7 +89,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto r1 = KE::transform(exespace(), KE::begin(view_from),
                             KE::end(view_from), KE::begin(view_dest), unOp);
     verify_data(view_from, view_dest);
-    EXPECT_EQ(r1, KE::end(view_dest));
+    ASSERT_EQ(r1, KE::end(view_dest));
   }
 
   {
@@ -98,7 +98,7 @@ void run_single_scenario(const InfoType& scenario_info) {
     auto r1 = KE::transform("label", exespace(), KE::begin(view_from),
                             KE::end(view_from), KE::begin(view_dest), unOp);
     verify_data(view_from, view_dest);
-    EXPECT_EQ(r1, KE::end(view_dest));
+    ASSERT_EQ(r1, KE::end(view_dest));
   }
 
   {
@@ -106,7 +106,7 @@ void run_single_scenario(const InfoType& scenario_info) {
         create_view<ValueType>(Tag{}, view_ext, "transform_uop_dest");
     auto r1 = KE::transform(exespace(), view_from, view_dest, unOp);
     verify_data(view_from, view_dest);
-    EXPECT_EQ(r1, KE::end(view_dest));
+    ASSERT_EQ(r1, KE::end(view_dest));
   }
 
   {
@@ -114,7 +114,7 @@ void run_single_scenario(const InfoType& scenario_info) {
         create_view<ValueType>(Tag{}, view_ext, "transform_uop_dest");
     auto r1 = KE::transform("label", exespace(), view_from, view_dest, unOp);
     verify_data(view_from, view_dest);
-    EXPECT_EQ(r1, KE::end(view_dest));
+    ASSERT_EQ(r1, KE::end(view_dest));
   }
 
   Kokkos::fence();
diff --git a/algorithms/unit_tests/TestStdAlgorithmsUnique.cpp b/algorithms/unit_tests/TestStdAlgorithmsUnique.cpp
index a810d31d82..9c5ae0cf8a 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsUnique.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsUnique.cpp
@@ -157,7 +157,7 @@ void verify_data(const std::string& name, ResultIt my_result_it,
   //
   const auto std_diff = (std::size_t)(std_r - KE::begin(data_v_h));
   const auto my_diff  = (std::size_t)(my_result_it - KE::begin(view_test));
-  EXPECT_EQ(my_diff, std_diff);
+  ASSERT_EQ(my_diff, std_diff);
 
   //
   // check the data in the view
@@ -170,14 +170,14 @@ void verify_data(const std::string& name, ResultIt my_result_it,
     // 		<< " my  = " << view_test_h(i) << " "
     // 		<< " std = " << data_v_h(i)
     // 		<< '\n';
-    EXPECT_EQ(view_test_h(i), data_v_h(i));
+    ASSERT_EQ(view_test_h(i), data_v_h(i));
   }
 
   if (name == "medium-b") {
     using value_type = typename ViewType1::value_type;
-    EXPECT_EQ(my_diff, (std::size_t)2);
-    EXPECT_EQ(view_test_h(0), (value_type)22);
-    EXPECT_EQ(view_test_h(1), (value_type)44);
+    ASSERT_EQ(my_diff, (std::size_t)2);
+    ASSERT_EQ(view_test_h(0), (value_type)22);
+    ASSERT_EQ(view_test_h(1), (value_type)44);
   }
 }
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsUniqueCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsUniqueCopy.cpp
index f609d8517e..3cf43ad4db 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsUniqueCopy.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsUniqueCopy.cpp
@@ -174,51 +174,51 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
   }
 
   else if (name == "one-element-a") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(1));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(1));
   }
 
   else if (name == "one-element-b") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(2));
   }
 
   else if (name == "two-elements-a") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(1));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(1));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(2));
   }
 
   else if (name == "two-elements-b") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(2));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(-1));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(-1));
   }
 
   else if (name == "small-a") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(1));
-    EXPECT_EQ(view_test_h(2), static_cast<value_type>(2));
-    EXPECT_EQ(view_test_h(3), static_cast<value_type>(3));
-    EXPECT_EQ(view_test_h(4), static_cast<value_type>(4));
-    EXPECT_EQ(view_test_h(5), static_cast<value_type>(5));
-    EXPECT_EQ(view_test_h(6), static_cast<value_type>(6));
-    EXPECT_EQ(view_test_h(7), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(8), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(9), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(10), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(1));
+    ASSERT_EQ(view_test_h(2), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(3), static_cast<value_type>(3));
+    ASSERT_EQ(view_test_h(4), static_cast<value_type>(4));
+    ASSERT_EQ(view_test_h(5), static_cast<value_type>(5));
+    ASSERT_EQ(view_test_h(6), static_cast<value_type>(6));
+    ASSERT_EQ(view_test_h(7), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(8), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(9), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(10), static_cast<value_type>(0));
   }
 
   else if (name == "small-b") {
-    EXPECT_EQ(view_test_h(0), static_cast<value_type>(1));
-    EXPECT_EQ(view_test_h(1), static_cast<value_type>(2));
-    EXPECT_EQ(view_test_h(2), static_cast<value_type>(3));
-    EXPECT_EQ(view_test_h(3), static_cast<value_type>(4));
-    EXPECT_EQ(view_test_h(4), static_cast<value_type>(5));
-    EXPECT_EQ(view_test_h(5), static_cast<value_type>(6));
-    EXPECT_EQ(view_test_h(6), static_cast<value_type>(8));
-    EXPECT_EQ(view_test_h(7), static_cast<value_type>(9));
-    EXPECT_EQ(view_test_h(8), static_cast<value_type>(8));
-    EXPECT_EQ(view_test_h(9), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(10), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(11), static_cast<value_type>(0));
-    EXPECT_EQ(view_test_h(12), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(0), static_cast<value_type>(1));
+    ASSERT_EQ(view_test_h(1), static_cast<value_type>(2));
+    ASSERT_EQ(view_test_h(2), static_cast<value_type>(3));
+    ASSERT_EQ(view_test_h(3), static_cast<value_type>(4));
+    ASSERT_EQ(view_test_h(4), static_cast<value_type>(5));
+    ASSERT_EQ(view_test_h(5), static_cast<value_type>(6));
+    ASSERT_EQ(view_test_h(6), static_cast<value_type>(8));
+    ASSERT_EQ(view_test_h(7), static_cast<value_type>(9));
+    ASSERT_EQ(view_test_h(8), static_cast<value_type>(8));
+    ASSERT_EQ(view_test_h(9), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(10), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(11), static_cast<value_type>(0));
+    ASSERT_EQ(view_test_h(12), static_cast<value_type>(0));
   }
 
   else if (name == "medium" || name == "large") {
@@ -230,7 +230,7 @@ void verify_data(const std::string& name, ViewTypeFrom view_from,
     (void)std_r;
 
     for (std::size_t i = 0; i < view_from_h.extent(0); ++i) {
-      EXPECT_EQ(view_test_h(i), tmp[i]);
+      ASSERT_EQ(view_test_h(i), tmp[i]);
     }
   }
 
@@ -273,7 +273,7 @@ void run_single_scenario(const InfoType& scenario_info, Args... args) {
         KE::unique_copy(exespace(), KE::cbegin(view_from), KE::cend(view_from),
                         KE::begin(view_dest), args...);
     verify_data(name, view_from, view_dest, args...);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   {
@@ -283,7 +283,7 @@ void run_single_scenario(const InfoType& scenario_info, Args... args) {
         KE::unique_copy("label", exespace(), KE::cbegin(view_from),
                         KE::cend(view_from), KE::begin(view_dest), args...);
     verify_data(name, view_from, view_dest, args...);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   {
@@ -291,7 +291,7 @@ void run_single_scenario(const InfoType& scenario_info, Args... args) {
         create_view<ValueType>(Tag{}, view_ext, "unique_copy_dest");
     auto rit = KE::unique_copy(exespace(), view_from, view_dest, args...);
     verify_data(name, view_from, view_dest, args...);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   {
@@ -300,7 +300,7 @@ void run_single_scenario(const InfoType& scenario_info, Args... args) {
     auto rit =
         KE::unique_copy("label", exespace(), view_from, view_dest, args...);
     verify_data(name, view_from, view_dest, args...);
-    EXPECT_EQ(rit, (KE::begin(view_dest) + n));
+    ASSERT_EQ(rit, (KE::begin(view_dest) + n));
   }
 
   Kokkos::fence();
diff --git a/bin/hpcbind b/bin/hpcbind
index cb2af2c4b5..b6db270128 100755
--- a/bin/hpcbind
+++ b/bin/hpcbind
@@ -36,8 +36,14 @@ fi
 ################################################################################
 declare -i HPCBIND_HAS_NVIDIA=0
 type nvidia-smi >/dev/null 2>&1
-HPCBIND_HAS_NVIDIA=$((!$?))
+HPCBIND_HAS_NVIDIA=$((! $?))
 
+################################################################################
+# Check if rocm-smi exist
+################################################################################
+declare -i HPCBIND_HAS_AMD=0
+type rocm-smi >/dev/null 2>&1
+HPCBIND_HAS_AMD=$((! $?))
 
 ################################################################################
 # Get visible gpu
@@ -45,11 +51,30 @@ HPCBIND_HAS_NVIDIA=$((!$?))
 declare -i NUM_GPUS=0
 HPCBIND_VISIBLE_GPUS=""
 if [[ ${HPCBIND_HAS_NVIDIA} -eq 1 ]]; then
-  NUM_GPUS=$(nvidia-smi -L | wc -l);
-  HPCBIND_HAS_NVIDIA=$((!$?))
+  nvidia-smi >/dev/null 2>&1
+  HPCBIND_HAS_NVIDIA=$((! $?))
   if [[ ${HPCBIND_HAS_NVIDIA} -eq 1 ]]; then
-    GPU_LIST="$( seq 0 $((NUM_GPUS-1)) )"
-    HPCBIND_VISIBLE_GPUS=${CUDA_VISIBLE_DEVICES:-${GPU_LIST}}
+    NUM_GPUS=$(nvidia-smi -L | wc -l);
+    HPCBIND_HAS_NVIDIA=$((! $?))
+    if [[ ${HPCBIND_HAS_NVIDIA} -eq 1 ]]; then
+      GPU_LIST="$( seq 0 $((NUM_GPUS-1)) )"
+      HPCBIND_VISIBLE_GPUS=${CUDA_VISIBLE_DEVICES:-${GPU_LIST}}
+    fi
+  fi
+fi
+
+if [[ ${HPCBIND_HAS_AMD} -eq 1 ]]; then
+  # rocm-smi doesn't have an error code if there is no hardware
+  # check for /sys/module/amdgpu/initstate instead
+  stat /sys/module/amdgpu/initstate >/dev/null 2>&1
+  HPCBIND_HAS_AMD=$((! $?))
+  if [[ ${HPCBIND_HAS_AMD} -eq 1 ]]; then
+    NUM_GPUS=$(rocm-smi -i --csv | sed '/^$/d' | tail -n +2 | wc -l);
+    HPCBIND_HAS_AMD=$((! $?))
+    if [[ ${HPCBIND_HAS_AMD} -eq 1 ]]; then
+      GPU_LIST="$( seq 0 $((NUM_GPUS-1)) )"
+      HPCBIND_VISIBLE_GPUS=${ROCR_VISIBLE_DEVICES:-${GPU_LIST}}
+    fi
   fi
 fi
 
@@ -80,7 +105,7 @@ elif [[ ! -z "${MV2_COMM_WORLD_RANK}" ]]; then
   HPCBIND_QUEUE_NAME="mvapich2"
   HPCBIND_QUEUE_RANK=${MV2_COMM_WORLD_RANK}
   HPCBIND_QUEUE_SIZE=${MV2_COMM_WORLD_SIZE}
-elif [[ ! -z "${SLURM_LOCAL_ID}" ]]; then
+elif [[ ! -z "${SLURM_LOCALID}" ]]; then
   HPCBIND_QUEUE_MAPPING=1
   HPCBIND_QUEUE_NAME="slurm"
   HPCBIND_QUEUE_RANK=${SLURM_PROCID}
@@ -101,8 +126,8 @@ fi
 function show_help {
   local cmd=$(basename "$0")
   echo "Usage: ${cmd} <options> -- command ..."
-  echo "  Set the process mask, OMP environment variables and CUDA environment"
-  echo "  variables to sane values if possible. Uses hwloc and nvidia-smi if"
+  echo "  Set the process mask, OMP environment variables and CUDA/ROCm environment"
+  echo "  variables to sane values if possible. Uses hwloc and nvidia-smi/rocm-smi if"
   echo "  available.  Will preserve the current process binding, so it is safe"
   echo "  to use with a queuing system or mpiexec."
   echo ""
@@ -116,10 +141,10 @@ function show_help {
   echo "  --distribute-partition=I"
   echo "                        Use the i'th partition (zero based)"
   echo "  --visible-gpus=<L>    Comma separated list of gpu ids"
-  echo "                        Default: CUDA_VISIBLE_DEVICES or all gpus in"
+  echo "                        Default: CUDA_VISIBLE_DEVICES/ROCR_VISIBLE_DEVICES or all gpus in"
   echo "                        sequential order"
   echo "  --ignore-queue        Ignore queue job id when choosing visible GPU and partition"
-  echo "  --no-gpu-mapping      Do not set CUDA_VISIBLE_DEVICES"
+  echo "  --no-gpu-mapping      Do not set CUDA_VISIBLE_DEVICES/ROCR_VISIBLE_DEVICES"
   echo "  --openmp=M.m          Set env variables for the given OpenMP version"
   echo "                        Default: 4.0"
   echo "  --openmp-ratio=N/D    Ratio of the cpuset to use for OpenMP"
@@ -525,13 +550,24 @@ fi
 ################################################################################
 
 if [[ ${HPCBIND_ENABLE_GPU_MAPPING} -eq 1 ]]; then
-  if [[ ${HPCBIND_QUEUE_MAPPING} -eq 0 ]]; then
-    declare -i GPU_ID=$((HPCBIND_PARTITION % NUM_GPUS))
-    export CUDA_VISIBLE_DEVICES="${HPCBIND_VISIBLE_GPUS[${GPU_ID}]}"
-  else
-    declare -i MY_TASK_ID=$((HPCBIND_QUEUE_RANK * HPCBIND_DISTRIBUTE + HPCBIND_PARTITION))
-    declare -i GPU_ID=$((MY_TASK_ID % NUM_GPUS))
-    export CUDA_VISIBLE_DEVICES="${HPCBIND_VISIBLE_GPUS[${GPU_ID}]}"
+  if [[ ${HPCBIND_HAS_NVIDIA} -eq 1 ]]; then
+    if [[ ${HPCBIND_QUEUE_MAPPING} -eq 0 ]]; then
+      declare -i GPU_ID=$((HPCBIND_PARTITION % NUM_GPUS))
+      export CUDA_VISIBLE_DEVICES="${HPCBIND_VISIBLE_GPUS[${GPU_ID}]}"
+    else
+      declare -i MY_TASK_ID=$((HPCBIND_QUEUE_RANK * HPCBIND_DISTRIBUTE + HPCBIND_PARTITION))
+      declare -i GPU_ID=$((MY_TASK_ID % NUM_GPUS))
+      export CUDA_VISIBLE_DEVICES="${HPCBIND_VISIBLE_GPUS[${GPU_ID}]}"
+    fi
+  elif [[ ${HPCBIND_HAS_AMD} -eq 1 ]]; then
+    if [[ ${HPCBIND_QUEUE_MAPPING} -eq 0 ]]; then
+      declare -i GPU_ID=$((HPCBIND_PARTITION % NUM_GPUS))
+      export ROCR_VISIBLE_DEVICES="${HPCBIND_VISIBLE_GPUS[${GPU_ID}]}"
+    else
+      declare -i MY_TASK_ID=$((HPCBIND_QUEUE_RANK * HPCBIND_DISTRIBUTE + HPCBIND_PARTITION))
+      declare -i GPU_ID=$((MY_TASK_ID % NUM_GPUS))
+      export ROCR_VISIBLE_DEVICES="${HPCBIND_VISIBLE_GPUS[${GPU_ID}]}"
+    fi
   fi
 fi
 
@@ -541,6 +577,7 @@ fi
 export HPCBIND_HWLOC_VERSION=${HPCBIND_HWLOC_VERSION}
 export HPCBIND_HAS_HWLOC=${HPCBIND_HAS_HWLOC}
 export HPCBIND_HAS_NVIDIA=${HPCBIND_HAS_NVIDIA}
+export HPCBIND_HAS_AMD=${HPCBIND_HAS_AMD}
 export HPCBIND_NUM_PUS=${HPCBIND_NUM_PUS}
 export HPCBIND_NUM_CORES=${HPCBIND_NUM_CORES}
 export HPCBIND_NUM_NUMAS=${HPCBIND_NUM_NUMAS}
@@ -555,8 +592,14 @@ else
   export HPCBIND_HWLOC_PARENT_CPUSET="${HPCBIND_HWLOC_PARENT_CPUSET}"
 fi
 export HPCBIND_HWLOC_PROC_BIND="${HPCBIND_PROC_BIND}"
-export HPCBIND_NVIDIA_ENABLE_GPU_MAPPING=${HPCBIND_ENABLE_GPU_MAPPING}
-export HPCBIND_NVIDIA_VISIBLE_GPUS=$(echo "${HPCBIND_VISIBLE_GPUS[*]}" | tr ' ' ',')
+if [[ ${HPCBIND_HAS_NVIDIA} -eq 1 ]]; then
+  export HPCBIND_NVIDIA_ENABLE_GPU_MAPPING=${HPCBIND_ENABLE_GPU_MAPPING}
+  export HPCBIND_NVIDIA_VISIBLE_GPUS=$(echo "${HPCBIND_VISIBLE_GPUS[*]}" | tr ' ' ',')
+fi
+if [[ ${HPCBIND_HAS_AMD} -eq 1 ]]; then
+  export HPCBIND_AMD_ENABLE_GPU_MAPPING=${HPCBIND_ENABLE_GPU_MAPPING}
+  export HPCBIND_AMD_VISIBLE_GPUS=$(echo "${HPCBIND_VISIBLE_GPUS[*]}" | tr ' ' ',')
+fi
 export HPCBIND_OPENMP_VERSION="${HPCBIND_OPENMP_VERSION}"
 if [[ "${HPCBIND_QUEUE_NAME}" != "" ]]; then
   export HPCBIND_QUEUE_RANK=${HPCBIND_QUEUE_RANK}
@@ -580,6 +623,9 @@ if [[ ${HPCBIND_TEE} -eq 0 || ${HPCBIND_VERBOSE} -eq 0 ]]; then
   echo "${TMP_ENV}" | grep -E "^HWLOC_" >> ${HPCBIND_LOG}
   echo "[CUDA]" >> ${HPCBIND_LOG}
   echo "${TMP_ENV}" | grep -E "^CUDA_" >> ${HPCBIND_LOG}
+  echo "[ROCM]" >> ${HPCBIND_LOG}
+  echo "${TMP_ENV}" | grep -E "^ROCM_" >> ${HPCBIND_LOG}
+  echo "${TMP_ENV}" | grep -E "^ROCR_" >> ${HPCBIND_LOG}
   echo "[OPENMP]" >> ${HPCBIND_LOG}
   echo "${TMP_ENV}" | grep -E "^OMP_" >> ${HPCBIND_LOG}
   echo "[GOMP] (gcc, g++, and gfortran)" >> ${HPCBIND_LOG}
@@ -602,6 +648,9 @@ else
   echo "${TMP_ENV}" | grep -E "^HWLOC_" > >(tee -a ${HPCBIND_LOG})
   echo "[CUDA]" > >(tee -a ${HPCBIND_LOG})
   echo "${TMP_ENV}" | grep -E "^CUDA_" > >(tee -a ${HPCBIND_LOG})
+  echo "[ROCM]" > >(tee -a ${HPCBIND_LOG})
+  echo "${TMP_ENV}" | grep -E "^ROCM_" > >(tee -a ${HPCBIND_LOG})
+  echo "${TMP_ENV}" | grep -E "^ROCR_" > >(tee -a ${HPCBIND_LOG})
   echo "[OPENMP]" > >(tee -a ${HPCBIND_LOG})
   echo "${TMP_ENV}" | grep -E "^OMP_" > >(tee -a ${HPCBIND_LOG})
   echo "[GOMP] (gcc, g++, and gfortran)" > >(tee -a ${HPCBIND_LOG})
diff --git a/bin/nvcc_wrapper b/bin/nvcc_wrapper
index 2204514d1b..1397148141 100755
--- a/bin/nvcc_wrapper
+++ b/bin/nvcc_wrapper
@@ -338,6 +338,24 @@ do
     std_flag=$corrected_std_flag
     shared_args="$shared_args $std_flag"
     ;;
+  --std=c++20|-std=c++20)
+    if [ -n "$std_flag" ]; then
+      warn_std_flag
+      shared_args=${shared_args/ $std_flag/}
+    fi
+    # NVCC only has C++20 from version 12 on
+    cuda_main_version=$([[ $(${nvcc_compiler} --version) =~ V([0-9]+) ]] && echo ${BASH_REMATCH[1]})
+    if [ ${cuda_main_version} -lt 12 ]; then
+      fallback_std_flag="-std=c++14"
+      # this is hopefully just occurring in a downstream project during CMake feature tests
+      # we really have no choice here but to accept the flag and change  to an accepted C++ standard
+      echo "nvcc_wrapper does not accept standard flags $1 since partial standard flags and standards after C++14 are not supported. nvcc_wrapper will use $fallback_std_flag instead. It is undefined behavior to use this flag. This should only be occurring during CMake configuration."
+      std_flag=$fallback_std_flag
+    else
+      std_flag=$1
+    fi
+    shared_args="$shared_args $std_flag"
+    ;;
   --std=c++17|-std=c++17)
     if [ -n "$std_flag" ]; then
       warn_std_flag
@@ -389,7 +407,7 @@ do
   -Woverloaded-virtual)
     ;;
   #strip -Xcompiler because we add it
-  -Xcompiler)
+  -Xcompiler|--compiler-options)
     if [[ $2 != "-o" ]]; then
       if [ $first_xcompiler_arg -eq 1 ]; then
         xcompiler_args="$2"
diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake
index 23b473ce24..611c089b2e 100644
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -1,10 +1,6 @@
 TRIBITS_PACKAGE_DEFINE_DEPENDENCIES(
-  SUBPACKAGES_DIRS_CLASSIFICATIONS_OPTREQS
-    #SubPackageName       Directory         Class    Req/Opt
-    #
-    # New Kokkos subpackages:
-    Core                  core              PS       REQUIRED
-    Containers            containers        PS       OPTIONAL
-    Algorithms            algorithms        PS       OPTIONAL
-    Simd                  simd              PT       OPTIONAL
+  LIB_OPTIONAL_TPLS Pthread CUDA HWLOC DLlib
+  TEST_OPTIONAL_TPLS CUSPARSE
   )
+
+TRIBITS_TPL_TENTATIVELY_ENABLE(DLlib)
diff --git a/cmake/KokkosConfigCommon.cmake.in b/cmake/KokkosConfigCommon.cmake.in
index bb5ce5ff81..446d12fa5f 100644
--- a/cmake/KokkosConfigCommon.cmake.in
+++ b/cmake/KokkosConfigCommon.cmake.in
@@ -6,10 +6,37 @@ SET(Kokkos_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
 SET(Kokkos_CXX_COMPILER_ID "@KOKKOS_CXX_COMPILER_ID@")
 SET(Kokkos_CXX_STANDARD @KOKKOS_CXX_STANDARD@)
 
-# These are needed by KokkosKernels
+# Required to be a TriBITS-compliant external package
+IF(NOT TARGET Kokkos::all_libs)
+  # CMake Error at <prefix>/lib/cmake/Kokkos/KokkosConfigCommon.cmake:10 (ADD_LIBRARY):
+  #   ADD_LIBRARY cannot create ALIAS target "Kokkos::all_libs" because target
+  #   "Kokkos::kokkos" is imported but not globally visible.
+  IF(CMAKE_VERSION VERSION_LESS "3.18")
+    SET_TARGET_PROPERTIES(Kokkos::kokkos PROPERTIES IMPORTED_GLOBAL ON)
+  ENDIF()
+  ADD_LIBRARY(Kokkos::all_libs ALIAS Kokkos::kokkos)
+ENDIF()
+
+# Export Kokkos_ENABLE_<BACKEND> for each backend that was enabled.
+# NOTE: "Devices" is a little bit of a misnomer here.  These are really
+# backends, e.g. Kokkos_ENABLE_OPENMP, Kokkos_ENABLE_CUDA, Kokkos_ENABLE_HIP,
+# or Kokkos_ENABLE_SYCL.
 FOREACH(DEV ${Kokkos_DEVICES})
   SET(Kokkos_ENABLE_${DEV} ON)
 ENDFOREACH()
+# Export relevant Kokkos_ENABLE<OPTION> variables, e.g.
+# Kokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE, Kokkos_ENABLE_DEBUG, etc.
+FOREACH(OPT ${Kokkos_OPTIONS})
+  SET(Kokkos_ENABLE_${OPT} ON)
+ENDFOREACH()
+
+IF(Kokkos_ENABLE_CUDA)
+  SET(Kokkos_CUDA_ARCHITECTURES @KOKKOS_CUDA_ARCHITECTURES@)
+ENDIF()
+
+IF(Kokkos_ENABLE_HIP)
+  SET(Kokkos_HIP_ARCHITECTURES @KOKKOS_HIP_ARCHITECTURES@)
+ENDIF()
 
 IF(NOT Kokkos_FIND_QUIETLY)
   MESSAGE(STATUS "Enabled Kokkos devices: ${Kokkos_DEVICES}")
diff --git a/cmake/KokkosCore_config.h.in b/cmake/KokkosCore_config.h.in
index 5b97e461b4..58fc8375bf 100644
--- a/cmake/KokkosCore_config.h.in
+++ b/cmake/KokkosCore_config.h.in
@@ -26,6 +26,7 @@
 #cmakedefine KOKKOS_ENABLE_MEMKIND
 #cmakedefine KOKKOS_ENABLE_LIBRT
 #cmakedefine KOKKOS_ENABLE_SYCL
+#cmakedefine KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED
 
 /* General Settings */
 #cmakedefine KOKKOS_ENABLE_CXX17
@@ -34,23 +35,21 @@
 
 #cmakedefine KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
 #cmakedefine KOKKOS_ENABLE_CUDA_UVM
-#cmakedefine KOKKOS_ENABLE_CUDA_LAMBDA
+#cmakedefine KOKKOS_ENABLE_CUDA_LAMBDA  // deprecated
 #cmakedefine KOKKOS_ENABLE_CUDA_CONSTEXPR
 #cmakedefine KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC
 #cmakedefine KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
 #cmakedefine KOKKOS_ENABLE_HIP_MULTIPLE_KERNEL_INSTANTIATIONS
-#cmakedefine KOKKOS_ENABLE_HPX_ASYNC_DISPATCH
+#cmakedefine KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH
 #cmakedefine KOKKOS_ENABLE_DEBUG
 #cmakedefine KOKKOS_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK
 #cmakedefine KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
-#cmakedefine KOKKOS_ENABLE_PROFILING_LOAD_PRINT
 #cmakedefine KOKKOS_ENABLE_TUNING
 #cmakedefine KOKKOS_ENABLE_DEPRECATED_CODE_3
 #cmakedefine KOKKOS_ENABLE_DEPRECATED_CODE_4
 #cmakedefine KOKKOS_ENABLE_DEPRECATION_WARNINGS
 #cmakedefine KOKKOS_ENABLE_LARGE_MEM_TESTS
 #cmakedefine KOKKOS_ENABLE_COMPLEX_ALIGN
-#cmakedefine KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 #cmakedefine KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION  // deprecated
 #cmakedefine KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
 #cmakedefine KOKKOS_ENABLE_IMPL_MDSPAN
@@ -62,6 +61,7 @@
 #cmakedefine KOKKOS_ENABLE_LIBDL
 #cmakedefine KOKKOS_ENABLE_LIBQUADMATH
 #cmakedefine KOKKOS_IMPL_CUDA_CLANG_WORKAROUND
+#cmakedefine KOKKOS_ENABLE_ONEDPL
 
 #cmakedefine KOKKOS_ARCH_SSE42
 #cmakedefine KOKKOS_ARCH_ARMV80
@@ -105,6 +105,7 @@
 #cmakedefine KOKKOS_ARCH_AMPERE
 #cmakedefine KOKKOS_ARCH_AMPERE80
 #cmakedefine KOKKOS_ARCH_AMPERE86
+#cmakedefine KOKKOS_ARCH_ADA89
 #cmakedefine KOKKOS_ARCH_HOPPER
 #cmakedefine KOKKOS_ARCH_HOPPER90
 #cmakedefine KOKKOS_ARCH_AMD_ZEN
@@ -116,3 +117,6 @@
 #cmakedefine KOKKOS_ARCH_VEGA90A
 #cmakedefine KOKKOS_ARCH_NAVI
 #cmakedefine KOKKOS_ARCH_NAVI1030
+#cmakedefine KOKKOS_ARCH_NAVI1100
+
+#cmakedefine KOKKOS_IMPL_32BIT
diff --git a/cmake/Kokkos_Version_Info.cpp.in b/cmake/Kokkos_Version_Info.cpp.in
index e9fabe8177..3665282e7b 100644
--- a/cmake/Kokkos_Version_Info.cpp.in
+++ b/cmake/Kokkos_Version_Info.cpp.in
@@ -19,11 +19,12 @@
 namespace Kokkos {
 namespace Impl {
 
-std::string GIT_BRANCH             = "@GIT_BRANCH@";
-std::string GIT_COMMIT_HASH        = "@GIT_COMMIT_HASH@";
-std::string GIT_CLEAN_STATUS       = "@GIT_CLEAN_STATUS@";
-std::string GIT_COMMIT_DESCRIPTION = "@GIT_COMMIT_DESCRIPTION@";
-std::string GIT_COMMIT_DATE        = "@GIT_COMMIT_DATE@";
+std::string GIT_BRANCH       = R"branch(@GIT_BRANCH@)branch";
+std::string GIT_COMMIT_HASH  = "@GIT_COMMIT_HASH@";
+std::string GIT_CLEAN_STATUS = "@GIT_CLEAN_STATUS@";
+std::string GIT_COMMIT_DESCRIPTION =
+    R"message(@GIT_COMMIT_DESCRIPTION@)message";
+std::string GIT_COMMIT_DATE = "@GIT_COMMIT_DATE@";
 
 }  // namespace Impl
 
diff --git a/cmake/Kokkos_Version_Info.hpp b/cmake/Kokkos_Version_Info.hpp
index ba605a301d..831247115e 100644
--- a/cmake/Kokkos_Version_Info.hpp
+++ b/cmake/Kokkos_Version_Info.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef GIT_VERSION_H
-#define GIT_VERSION_H
+#ifndef KOKKOS_GIT_VERSION_INFO_H
+#define KOKKOS_GIT_VERSION_INFO_H
 
 #include <string>
 
diff --git a/cmake/Modules/FindTPLHPX.cmake b/cmake/Modules/FindTPLHPX.cmake
index 5636a9bb66..d7b54fb9c9 100644
--- a/cmake/Modules/FindTPLHPX.cmake
+++ b/cmake/Modules/FindTPLHPX.cmake
@@ -1,5 +1,5 @@
 
-FIND_PACKAGE(HPX REQUIRED 1.7.0)
+FIND_PACKAGE(HPX REQUIRED 1.8.0)
 #as of right now, HPX doesn't export correctly
 #so let's convert it to an interface target
 KOKKOS_CREATE_IMPORTED_TPL(HPX INTERFACE
diff --git a/cmake/Modules/FindTPLLIBNUMA.cmake b/cmake/Modules/FindTPLLIBNUMA.cmake
deleted file mode 100644
index 811db5851b..0000000000
--- a/cmake/Modules/FindTPLLIBNUMA.cmake
+++ /dev/null
@@ -1 +0,0 @@
-KOKKOS_FIND_IMPORTED(LIBNUMA HEADER numa.h   LIBRARY numa)
diff --git a/cmake/Modules/FindTPLONEDPL.cmake b/cmake/Modules/FindTPLONEDPL.cmake
new file mode 100644
index 0000000000..01791cff44
--- /dev/null
+++ b/cmake/Modules/FindTPLONEDPL.cmake
@@ -0,0 +1,46 @@
+INCLUDE(CheckIncludeFileCXX)
+CHECK_INCLUDE_FILE_CXX(oneapi/dpl/execution KOKKOS_COMPILER_HAS_ONEDPL_EXECUTION_HEADER)
+CHECK_INCLUDE_FILE_CXX(oneapi/dpl/algorithm KOKKOS_COMPILER_HAS_ONEDPL_ALGORITHM_HEADER)
+
+INCLUDE(CheckCXXSourceCompiles)
+CHECK_CXX_SOURCE_COMPILES("
+  #include <iostream>
+
+  int main()
+  {
+    #if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE == 9 || _GLIBCXX_RELEASE == 10)
+      static_assert(false);
+    #endif
+    return 0;
+  }"
+  KOKKOS_NO_TBB_CONFLICT)
+
+IF (KOKKOS_COMPILER_HAS_ONEDPL_EXECUTION_HEADER AND KOKKOS_COMPILER_HAS_ONEDPL_ALGORITHM_HEADER)
+  IF(KOKKOS_NO_TBB_CONFLICT)
+    KOKKOS_CREATE_IMPORTED_TPL(
+      ONEDPL INTERFACE
+    )
+  ELSE()
+    KOKKOS_CREATE_IMPORTED_TPL(
+      ONEDPL INTERFACE
+      # https://stackoverflow.com/questions/67923287/how-to-resolve-no-member-named-task-in-namespace-tbb-error-when-using-oned/
+      COMPILE_DEFINITIONS PSTL_USE_PARALLEL_POLICIES=0 _GLIBCXX_USE_TBB_PAR_BACKEND=0
+    )
+  ENDIF()
+ELSE()
+  FIND_PACKAGE(oneDPL REQUIRED)
+
+  IF(KOKKOS_NO_TBB_CONFLICT)
+    KOKKOS_CREATE_IMPORTED_TPL(
+      ONEDPL INTERFACE
+      LINK_LIBRARIES oneDPL
+    )
+  ELSE()
+    KOKKOS_CREATE_IMPORTED_TPL(
+      ONEDPL INTERFACE
+      LINK_LIBRARIES oneDPL
+      # https://stackoverflow.com/questions/67923287/how-to-resolve-no-member-named-task-in-namespace-tbb-error-when-using-oned/
+      COMPILE_DEFINITIONS PSTL_USE_PARALLEL_POLICIES=0 _GLIBCXX_USE_TBB_PAR_BACKEND=0
+    )
+  ENDIF()
+ENDIF()
diff --git a/cmake/build_env_info.cmake b/cmake/build_env_info.cmake
index 2cd169cba4..0eeb637245 100644
--- a/cmake/build_env_info.cmake
+++ b/cmake/build_env_info.cmake
@@ -110,6 +110,7 @@ FUNCTION(check_git_setup)
 
   add_library(impl_git_version ${CMAKE_BINARY_DIR}/generated/Kokkos_Version_Info.cpp)
   target_include_directories(impl_git_version PUBLIC ${CMAKE_BINARY_DIR}/generated)
+  target_compile_features(impl_git_version PRIVATE cxx_raw_string_literals)
   add_dependencies(impl_git_version AlwaysCheckGit)
 
   check_git_version()
diff --git a/cmake/compile_tests/cuda_compute_capability.cc b/cmake/compile_tests/cuda_compute_capability.cc
index b0bc5d1520..b81c4218a9 100644
--- a/cmake/compile_tests/cuda_compute_capability.cc
+++ b/cmake/compile_tests/cuda_compute_capability.cc
@@ -46,6 +46,7 @@ int main() {
     case 75: std::cout << "Set -DKokkos_ARCH_TURING75=ON ." << std::endl; break;
     case 80: std::cout << "Set -DKokkos_ARCH_AMPERE80=ON ." << std::endl; break;
     case 86: std::cout << "Set -DKokkos_ARCH_AMPERE86=ON ." << std::endl; break;
+    case 89: std::cout << "Set -DKokkos_ARCH_ADA89=ON ." << std::endl; break;
     case 90: std::cout << "Set -DKokkos_ARCH_HOPPER90=ON ." << std::endl; break;
     default:
       std::cout << "Compute capability " << compute_capability
diff --git a/cmake/fake_tribits.cmake b/cmake/fake_tribits.cmake
index 71e85e915c..eedae14d45 100644
--- a/cmake/fake_tribits.cmake
+++ b/cmake/fake_tribits.cmake
@@ -11,22 +11,7 @@ FUNCTION(ASSERT_DEFINED VARS)
   ENDFOREACH()
 ENDFUNCTION()
 
-MACRO(KOKKOS_ADD_OPTION_AND_DEFINE USER_OPTION_NAME MACRO_DEFINE_NAME DOCSTRING DEFAULT_VALUE )
-SET( ${USER_OPTION_NAME} "${DEFAULT_VALUE}" CACHE BOOL "${DOCSTRING}" )
-IF(NOT ${MACRO_DEFINE_NAME} STREQUAL "")
-  IF(${USER_OPTION_NAME})
-    GLOBAL_SET(${MACRO_DEFINE_NAME} ON)
-  ELSE()
-    GLOBAL_SET(${MACRO_DEFINE_NAME} OFF)
-  ENDIF()
-ENDIF()
-ENDMACRO()
-
-MACRO(GLOBAL_OVERWRITE VARNAME VALUE TYPE)
-  SET(${VARNAME} ${VALUE} CACHE ${TYPE} "" FORCE)
-ENDMACRO()
-
-IF (NOT KOKKOS_HAS_TRILINOS)
+IF(NOT KOKKOS_HAS_TRILINOS)
 MACRO(APPEND_GLOB VAR)
   FILE(GLOB LOCAL_TMP_VAR ${ARGN})
   LIST(APPEND ${VAR} ${LOCAL_TMP_VAR})
@@ -40,35 +25,7 @@ MACRO(PREPEND_GLOBAL_SET VARNAME)
   ASSERT_DEFINED(${VARNAME})
   GLOBAL_SET(${VARNAME} ${ARGN} ${${VARNAME}})
 ENDMACRO()
-
-MACRO(PREPEND_TARGET_SET VARNAME TARGET_NAME TYPE)
-  IF(TYPE STREQUAL "REQUIRED")
-    SET(REQUIRED TRUE)
-  ELSE()
-    SET(REQUIRED FALSE)
-  ENDIF()
-  IF(TARGET ${TARGET_NAME})
-    PREPEND_GLOBAL_SET(${VARNAME} ${TARGET_NAME})
-  ELSE()
-    IF(REQUIRED)
-      MESSAGE(FATAL_ERROR "Missing dependency ${TARGET_NAME}")
-    ENDIF()
-  ENDIF()
-ENDMACRO()
-endif()
-
-
-FUNCTION(KOKKOS_CONFIGURE_FILE  PACKAGE_NAME_CONFIG_FILE)
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_CONFIGURE_FILE(${PACKAGE_NAME_CONFIG_FILE})
-  else()
-    # Configure the file
-    CONFIGURE_FILE(
-      ${PACKAGE_SOURCE_DIR}/cmake/${PACKAGE_NAME_CONFIG_FILE}.in
-      ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME_CONFIG_FILE}
-      )
-  endif()
-ENDFUNCTION()
+ENDIF()
 
 MACRO(ADD_INTERFACE_LIBRARY LIB_NAME)
   FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cpp "")
diff --git a/cmake/kokkos_arch.cmake b/cmake/kokkos_arch.cmake
index b051f8e3bd..d64726307b 100644
--- a/cmake/kokkos_arch.cmake
+++ b/cmake/kokkos_arch.cmake
@@ -86,6 +86,7 @@ KOKKOS_ARCH_OPTION(VOLTA72         GPU  "NVIDIA Volta generation CC 7.2"   "KOKK
 KOKKOS_ARCH_OPTION(TURING75        GPU  "NVIDIA Turing generation CC 7.5"  "KOKKOS_SHOW_CUDA_ARCHS")
 KOKKOS_ARCH_OPTION(AMPERE80        GPU  "NVIDIA Ampere generation CC 8.0"  "KOKKOS_SHOW_CUDA_ARCHS")
 KOKKOS_ARCH_OPTION(AMPERE86        GPU  "NVIDIA Ampere generation CC 8.6"  "KOKKOS_SHOW_CUDA_ARCHS")
+KOKKOS_ARCH_OPTION(ADA89           GPU  "NVIDIA Ada generation CC 8.9"     "KOKKOS_SHOW_CUDA_ARCHS")
 KOKKOS_ARCH_OPTION(HOPPER90        GPU  "NVIDIA Hopper generation CC 9.0"  "KOKKOS_SHOW_CUDA_ARCHS")
 
 IF(Kokkos_ENABLE_HIP OR Kokkos_ENABLE_OPENMPTARGET)
@@ -93,9 +94,9 @@ IF(Kokkos_ENABLE_HIP OR Kokkos_ENABLE_OPENMPTARGET)
 ENDIF()
 
 # AMD archs ordered in decreasing priority of autodetection
-LIST(APPEND SUPPORTED_AMD_GPUS       MI200    MI100    MI50/60  V620/W6800)
-LIST(APPEND SUPPORTED_AMD_ARCHS      VEGA90A  VEGA908  VEGA906  NAVI1030)
-LIST(APPEND CORRESPONDING_AMD_FLAGS  gfx90a   gfx908   gfx906   gfx1030)
+LIST(APPEND SUPPORTED_AMD_GPUS       MI200    MI100    MI50/60  RX7900XTX  V620/W6800)
+LIST(APPEND SUPPORTED_AMD_ARCHS      VEGA90A  VEGA908  VEGA906  NAVI1100   NAVI1030)
+LIST(APPEND CORRESPONDING_AMD_FLAGS  gfx90a   gfx908   gfx906   gfx1100    gfx1030)
 
 #FIXME CAN BE REPLACED WITH LIST_ZIP IN CMAKE 3.17
 FOREACH(ARCH IN LISTS SUPPORTED_AMD_ARCHS)
@@ -119,7 +120,7 @@ KOKKOS_ARCH_OPTION(INTEL_PVC       GPU  "Intel GPU Ponte Vecchio"
 
 IF(KOKKOS_ENABLE_COMPILER_WARNINGS)
   SET(COMMON_WARNINGS
-    "-Wall" "-Wunused-parameter" "-Wshadow" "-pedantic"
+    "-Wall" "-Wextra" "-Wunused-parameter" "-Wshadow" "-pedantic"
     "-Wsign-compare" "-Wtype-limits" "-Wuninitialized")
 
   # NOTE KOKKOS_ prefixed variable (all uppercase) is not set yet because TPLs are processed after ARCH
@@ -128,11 +129,6 @@ IF(KOKKOS_ENABLE_COMPILER_WARNINGS)
     LIST(REMOVE_ITEM COMMON_WARNINGS "-pedantic")
   ENDIF()
 
-  # OpenMPTarget compilers give erroneous warnings about sign comparison in loops
-  IF(KOKKOS_ENABLE_OPENMPTARGET)
-    LIST(REMOVE_ITEM COMMON_WARNINGS "-Wsign-compare")
-  ENDIF()
-
   # NVHPC compiler does not support -Wtype-limits.
   IF(KOKKOS_ENABLE_OPENACC)
     IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
@@ -166,11 +162,9 @@ ENDIF()
 #clear anything that might be in the cache
 GLOBAL_SET(KOKKOS_CUDA_OPTIONS)
 # Construct the Makefile options
-IF (KOKKOS_ENABLE_CUDA_LAMBDA)
-  IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
-    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "-expt-extended-lambda")
-    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "-Wext-lambda-captures-this")
-  ENDIF()
+IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+  GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "-extended-lambda")
+  GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "-Wext-lambda-captures-this")
 ENDIF()
 
 IF (KOKKOS_ENABLE_CUDA_CONSTEXPR)
@@ -216,7 +210,7 @@ GLOBAL_SET(KOKKOS_AMDGPU_OPTIONS)
 IF(KOKKOS_ENABLE_HIP)
   SET(AMDGPU_ARCH_FLAG "--offload-arch")
   IF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL HIPCC)
-    GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS -x hip)
+    GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS -xhip)
     IF(DEFINED ENV{ROCM_PATH})
       GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS --rocm-path=$ENV{ROCM_PATH})
     ENDIF()
@@ -229,9 +223,16 @@ IF(KOKKOS_ARCH_NATIVE)
     MESSAGE(FATAL_ERROR "MSVC doesn't support ARCH_NATIVE!")
   ENDIF()
 
+  STRING(TOUPPER "${CMAKE_SYSTEM_PROCESSOR}" KOKKOS_UC_SYSTEM_PROCESSOR)
+  IF(KOKKOS_UC_SYSTEM_PROCESSOR MATCHES "(X86)|(AMD64)")
+    SET(KOKKOS_NATIVE_FLAGS "-march=native;-mtune=native")
+  ELSE()
+    SET(KOKKOS_NATIVE_FLAGS "-mcpu=native")
+  ENDIF()
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
-    DEFAULT -march=native -mtune=native
+    NVHPC   -tp=native
+    DEFAULT ${KOKKOS_NATIVE_FLAGS}
   )
 ENDIF()
 
@@ -405,8 +406,10 @@ IF (KOKKOS_ARCH_SKL)
 ENDIF()
 
 IF (KOKKOS_ARCH_SKX)
-  #avx512-xeon
-  SET(KOKKOS_ARCH_AVX512XEON ON)
+  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
+  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
+    SET(KOKKOS_ARCH_AVX512XEON ON)
+  ENDIF()
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     Cray    NO-VALUE-SPECIFIED
@@ -418,7 +421,10 @@ IF (KOKKOS_ARCH_SKX)
 ENDIF()
 
 IF (KOKKOS_ARCH_ICL)
-  SET(KOKKOS_ARCH_AVX512XEON ON)
+  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
+  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
+    SET(KOKKOS_ARCH_AVX512XEON ON)
+  ENDIF()
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     MSVC    /arch:AVX512
@@ -427,7 +433,10 @@ IF (KOKKOS_ARCH_ICL)
 ENDIF()
 
 IF (KOKKOS_ARCH_ICX)
-  SET(KOKKOS_ARCH_AVX512XEON ON)
+  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
+  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
+    SET(KOKKOS_ARCH_AVX512XEON ON)
+  ENDIF()
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     MSVC    /arch:AVX512
@@ -436,7 +445,10 @@ IF (KOKKOS_ARCH_ICX)
 ENDIF()
 
 IF (KOKKOS_ARCH_SPR)
-  SET(KOKKOS_ARCH_AVX512XEON ON)
+  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
+  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
+    SET(KOKKOS_ARCH_AVX512XEON ON)
+  ENDIF()
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     MSVC    /arch:AVX512
@@ -505,7 +517,7 @@ ENDIF()
 IF (KOKKOS_ENABLE_HIP)
   IF (KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE)
     COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fgpu-rdc -DDESUL_HIP_RDC
+      DEFAULT -fgpu-rdc
     )
   ELSE()
     COMPILER_SPECIFIC_FLAGS(
@@ -523,6 +535,35 @@ IF (KOKKOS_ENABLE_SYCL)
   )
 ENDIF()
 
+# Check support for device_global variables
+# FIXME_SYCL Once the feature test macro SYCL_EXT_ONEAPI_DEVICE_GLOBAL is
+#            available, use that instead.
+IF(KOKKOS_ENABLE_SYCL AND NOT BUILD_SHARED_LIBS)
+  INCLUDE(CheckCXXSourceCompiles)
+  STRING(REPLACE ";" " " CMAKE_REQUIRED_FLAGS "${KOKKOS_COMPILE_OPTIONS}")
+  CHECK_CXX_SOURCE_COMPILES("
+    #include <sycl/sycl.hpp>
+    using namespace sycl::ext::oneapi::experimental;
+    using namespace sycl;
+
+    SYCL_EXTERNAL device_global<int, decltype(properties(device_image_scope))> Foo;
+
+    void bar(queue q) {
+      q.single_task([=] {
+      Foo = 42;
+    });
+    }
+
+    int main(){ return 0; }
+    "
+    KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED)
+
+  IF(KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED)
+    COMPILER_SPECIFIC_FLAGS(
+      DEFAULT -fsycl-device-code-split=off -DDESUL_SYCL_DEVICE_GLOBAL_SUPPORTED
+    )
+  ENDIF()
+ENDIF()
 
 SET(CUDA_ARCH_ALREADY_SPECIFIED "")
 FUNCTION(CHECK_CUDA_ARCH ARCH FLAG)
@@ -535,10 +576,14 @@ FUNCTION(CHECK_CUDA_ARCH ARCH FLAG)
       MESSAGE(WARNING "Given CUDA arch ${ARCH}, but Kokkos_ENABLE_CUDA, Kokkos_ENABLE_OPENACC, and Kokkos_ENABLE_OPENMPTARGET are OFF. Option will be ignored.")
       UNSET(KOKKOS_ARCH_${ARCH} PARENT_SCOPE)
     ELSE()
+      IF(KOKKOS_ENABLE_CUDA)
+        STRING(REPLACE "sm_" "" CMAKE_ARCH ${FLAG})
+        SET(KOKKOS_CUDA_ARCHITECTURES ${CMAKE_ARCH})
+        SET(KOKKOS_CUDA_ARCHITECTURES ${CMAKE_ARCH} PARENT_SCOPE)
+      ENDIF()
       SET(KOKKOS_CUDA_ARCH_FLAG ${FLAG} PARENT_SCOPE)
       IF(KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
-        string(REPLACE "sm_" "" CMAKE_ARCH ${FLAG})
-        SET(CMAKE_CUDA_ARCHITECTURES ${CMAKE_ARCH} PARENT_SCOPE)
+        SET(CMAKE_CUDA_ARCHITECTURES ${KOKKOS_CUDA_ARCHITECTURES} PARENT_SCOPE)
       ELSE()
         IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
           STRING(REPLACE "sm_" "cc" NVHPC_CUDA_ARCH ${FLAG})
@@ -576,6 +621,7 @@ CHECK_CUDA_ARCH(VOLTA72   sm_72)
 CHECK_CUDA_ARCH(TURING75  sm_75)
 CHECK_CUDA_ARCH(AMPERE80  sm_80)
 CHECK_CUDA_ARCH(AMPERE86  sm_86)
+CHECK_CUDA_ARCH(ADA89     sm_89)
 CHECK_CUDA_ARCH(HOPPER90  sm_90)
 
 SET(AMDGPU_ARCH_ALREADY_SPECIFIED "")
@@ -589,6 +635,9 @@ FUNCTION(CHECK_AMDGPU_ARCH ARCH FLAG)
       MESSAGE(WARNING "Given AMD GPU architecture ${ARCH}, but Kokkos_ENABLE_HIP and Kokkos_ENABLE_OPENMPTARGET are OFF. Option will be ignored.")
       UNSET(KOKKOS_ARCH_${ARCH} PARENT_SCOPE)
     ELSE()
+      IF(KOKKOS_ENABLE_HIP)
+        SET(KOKKOS_HIP_ARCHITECTURES ${FLAG} PARENT_SCOPE)
+      ENDIF()
       SET(KOKKOS_AMDGPU_ARCH_FLAG ${FLAG} PARENT_SCOPE)
       GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS "${AMDGPU_ARCH_FLAG}=${FLAG}")
       IF(KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE)
@@ -644,11 +693,17 @@ ENDIF()
 IF (KOKKOS_ENABLE_OPENMPTARGET)
   SET(CLANG_CUDA_ARCH ${KOKKOS_CUDA_ARCH_FLAG})
   IF (CLANG_CUDA_ARCH)
-    STRING(REPLACE "sm_" "cc" NVHPC_CUDA_ARCH ${CLANG_CUDA_ARCH})
-    COMPILER_SPECIFIC_FLAGS(
-      Clang -Xopenmp-target -march=${CLANG_CUDA_ARCH} -fopenmp-targets=nvptx64
-      NVHPC -gpu=${NVHPC_CUDA_ARCH}
-    )
+    IF(KOKKOS_CLANG_IS_CRAY)
+      COMPILER_SPECIFIC_FLAGS(
+        Cray -fopenmp
+      )
+    ELSE()
+      STRING(REPLACE "sm_" "cc" NVHPC_CUDA_ARCH ${CLANG_CUDA_ARCH})
+      COMPILER_SPECIFIC_FLAGS(
+        Clang -Xopenmp-target -march=${CLANG_CUDA_ARCH} -fopenmp-targets=nvptx64
+        NVHPC -gpu=${NVHPC_CUDA_ARCH}
+      )
+    ENDIF()
   ENDIF()
   SET(CLANG_AMDGPU_ARCH ${KOKKOS_AMDGPU_ARCH_FLAG})
   IF (CLANG_AMDGPU_ARCH)
@@ -704,7 +759,7 @@ IF (KOKKOS_ENABLE_SYCL)
   IF(CUDA_ARCH_ALREADY_SPECIFIED)
     IF(KOKKOS_ENABLE_UNSUPPORTED_ARCHS)
       COMPILER_SPECIFIC_FLAGS(
-        DEFAULT -fsycl-targets=nvptx64-nvidia-cuda -Xsycl-target-backend "${CUDA_ARCH_FLAG}=${KOKKOS_CUDA_ARCH_FLAG}"
+        DEFAULT -fsycl-targets=nvptx64-nvidia-cuda -Xsycl-target-backend=nvptx64-nvidia-cuda --cuda-gpu-arch=${KOKKOS_CUDA_ARCH_FLAG}
       )
     ELSE()
       MESSAGE(SEND_ERROR "Setting a CUDA architecture for SYCL is only allowed with Kokkos_ENABLE_UNSUPPORTED_ARCHS=ON!")
@@ -713,30 +768,35 @@ IF (KOKKOS_ENABLE_SYCL)
     COMPILER_SPECIFIC_FLAGS(
       DEFAULT -fsycl-targets=spir64
     )
-  ELSEIF(KOKKOS_ARCH_INTEL_GEN9)
-    COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device gen9"
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_GEN11)
-    COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device gen11"
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_GEN12LP)
-    COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device gen12lp"
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_DG1)
-    COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device dg1"
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_XEHP)
-    COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device 12.50.4"
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_PVC)
-    COMPILER_SPECIFIC_FLAGS(
-      DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device 12.60.7"
+  ELSE()
+    COMPILER_SPECIFIC_OPTIONS(
+      DEFAULT -fsycl-targets=spir64_gen
     )
+    IF(KOKKOS_ARCH_INTEL_GEN9)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device gen9"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_GEN11)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device gen11"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_GEN12LP)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device gen12lp"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_DG1)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device dg1"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_XEHP)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device 12.50.4"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_PVC)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT -fsycl-targets=spir64_gen -Xsycl-target-backend "-device 12.60.7"
+      )
+    ENDIF()
   ENDIF()
 ENDIF()
 
diff --git a/cmake/kokkos_compiler_id.cmake b/cmake/kokkos_compiler_id.cmake
index 27a3102a6b..fc4c06ce2b 100644
--- a/cmake/kokkos_compiler_id.cmake
+++ b/cmake/kokkos_compiler_id.cmake
@@ -152,7 +152,7 @@ SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang(CUDA)       10.0.0 or
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    GCC                8.2.0 or higher")
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Intel             19.0.5 or higher")
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    IntelLLVM(CPU)  2021.1.1 or higher")
-SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    IntelLLVM(SYCL) 2022.0.0 or higher") #FIXME
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    IntelLLVM(SYCL) 2023.0.0 or higher")
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    NVCC              11.0.0 or higher")
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    HIPCC              5.2.0 or higher")
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    NVHPC/PGI           22.3 or higher")
@@ -181,7 +181,7 @@ ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM AND NOT Kokkos_ENABLE_SYCL)
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM AND Kokkos_ENABLE_SYCL)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 2022.0.0) #FIXME 2022.2.0
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 2023.0.0)
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
diff --git a/cmake/kokkos_enable_options.cmake b/cmake/kokkos_enable_options.cmake
index f9f1bc5a8b..435fe47ab1 100644
--- a/cmake/kokkos_enable_options.cmake
+++ b/cmake/kokkos_enable_options.cmake
@@ -11,7 +11,7 @@
 FUNCTION(KOKKOS_ENABLE_OPTION SUFFIX DEFAULT DOCSTRING)
   KOKKOS_OPTION(ENABLE_${SUFFIX} ${DEFAULT} BOOL ${DOCSTRING})
   STRING(TOUPPER ${SUFFIX} UC_NAME)
-  IF (KOKKOS_ENABLE_${UC_NAME})
+  IF (KOKKOS_ENABLE_${UC_NAME} AND NOT "Kokkos_ENABLE_${UC_NAME}" IN_LIST Kokkos_OPTIONS_NOT_TO_EXPORT)
     LIST(APPEND KOKKOS_ENABLED_OPTIONS ${UC_NAME})
     #I hate that CMake makes me do this
     SET(KOKKOS_ENABLED_OPTIONS ${KOKKOS_ENABLED_OPTIONS} PARENT_SCOPE)
@@ -26,19 +26,29 @@ KOKKOS_CFG_DEPENDS(OPTIONS COMPILER_ID)
 # Put a check in just in case people are using this option
 KOKKOS_DEPRECATED_LIST(OPTIONS ENABLE)
 
-# Set the Default for Desul Atomics usage.
-set(_DESUL_ATOMICS_DEFAULT ON)
-
 KOKKOS_ENABLE_OPTION(CUDA_RELOCATABLE_DEVICE_CODE  OFF "Whether to enable relocatable device code (RDC) for CUDA")
 KOKKOS_ENABLE_OPTION(CUDA_UVM             OFF "Whether to use unified memory (UM) for CUDA by default")
 KOKKOS_ENABLE_OPTION(CUDA_LDG_INTRINSIC   OFF "Whether to use CUDA LDG intrinsics")
+# In contrast to other CUDA-dependent, options CUDA_LAMBDA is ON by default.
+# That is problematic when CUDA is not enabled because this not only yields a
+# bogus warning, but also exports the Kokkos_ENABLE_CUDA_LAMBDA variable and
+# sets it to ON. This if-clause is a crutch that delays the refactoring of the
+# way we declare all options until after we get rid of TriBITS.
+IF (Trilinos_ENABLE_Kokkos AND TPL_ENABLE_CUDA)
+   SET(CUDA_LAMBDA_DEFAULT ON)
+ELSEIF (KOKKOS_ENABLE_CUDA)
+   SET(CUDA_LAMBDA_DEFAULT ON)
+ELSE()
+   SET(CUDA_LAMBDA_DEFAULT OFF)
+ENDIF()
+KOKKOS_ENABLE_OPTION(CUDA_LAMBDA ${CUDA_LAMBDA_DEFAULT} "Whether to allow lambda expressions on the device with NVCC **DEPRECATED**")
+
 # As of 08/12/2021 CudaMallocAsync causes issues if UCX is used as MPI communication layer.
 KOKKOS_ENABLE_OPTION(IMPL_CUDA_MALLOC_ASYNC      OFF  "Whether to enable CudaMallocAsync (requires CUDA Toolkit 11.2)")
 KOKKOS_ENABLE_OPTION(DEPRECATED_CODE_3    OFF "Whether code deprecated in major release 3 is available" )
 KOKKOS_ENABLE_OPTION(DEPRECATED_CODE_4    ON "Whether code deprecated in major release 4 is available" )
 KOKKOS_ENABLE_OPTION(DEPRECATION_WARNINGS ON "Whether to emit deprecation warnings" )
 KOKKOS_ENABLE_OPTION(HIP_RELOCATABLE_DEVICE_CODE  OFF "Whether to enable relocatable device code (RDC) for HIP")
-KOKKOS_ENABLE_OPTION(HPX_ASYNC_DISPATCH   OFF "Whether HPX supports asynchronous dispatch")
 KOKKOS_ENABLE_OPTION(TESTS         OFF  "Whether to build the unit tests")
 KOKKOS_ENABLE_OPTION(BENCHMARKS    OFF  "Whether to build the benchmarks")
 KOKKOS_ENABLE_OPTION(EXAMPLES      OFF  "Whether to build the examples")
@@ -54,15 +64,12 @@ UNSET(_UPPERCASE_CMAKE_BUILD_TYPE)
 KOKKOS_ENABLE_OPTION(LARGE_MEM_TESTS      OFF "Whether to perform extra large memory tests")
 KOKKOS_ENABLE_OPTION(DEBUG_BOUNDS_CHECK   OFF "Whether to use bounds checking - will increase runtime")
 KOKKOS_ENABLE_OPTION(COMPILER_WARNINGS    OFF "Whether to print all compiler warnings")
-KOKKOS_ENABLE_OPTION(PROFILING_LOAD_PRINT OFF "Whether to print information about which profiling tools got loaded")
 KOKKOS_ENABLE_OPTION(TUNING               OFF "Whether to create bindings for tuning tools")
 KOKKOS_ENABLE_OPTION(AGGRESSIVE_VECTORIZATION OFF "Whether to aggressively vectorize loops")
-KOKKOS_ENABLE_OPTION(LAUNCH_COMPILER      ON  "Whether to potentially use the launch compiler")
 KOKKOS_ENABLE_OPTION(COMPILE_AS_CMAKE_LANGUAGE OFF "Whether to use native cmake language support")
 KOKKOS_ENABLE_OPTION(HIP_MULTIPLE_KERNEL_INSTANTIATIONS OFF "Whether multiple kernels are instantiated at compile time - improve performance but increase compile time")
 
 # This option will go away eventually, but allows fallback to old implementation when needed.
-KOKKOS_ENABLE_OPTION(IMPL_DESUL_ATOMICS   ON  "Whether to use desul based atomics - option only during beta")
 KOKKOS_ENABLE_OPTION(DESUL_ATOMICS_EXTERNAL OFF "Whether to use an external desul installation")
 
 KOKKOS_ENABLE_OPTION(IMPL_MDSPAN OFF "Whether to enable experimental mdspan support")
@@ -72,14 +79,6 @@ mark_as_advanced(Kokkos_ENABLE_IMPL_MDSPAN)
 mark_as_advanced(Kokkos_ENABLE_MDSPAN_EXTERNAL)
 mark_as_advanced(Kokkos_ENABLE_IMPL_SKIP_COMPILER_MDSPAN)
 
-IF (Trilinos_ENABLE_Kokkos AND TPL_ENABLE_CUDA)
-  SET(CUDA_LAMBDA_DEFAULT ON)
-ELSEIF (KOKKOS_ENABLE_CUDA)
-  SET(CUDA_LAMBDA_DEFAULT ON)
-ELSE()
-  SET(CUDA_LAMBDA_DEFAULT OFF)
-ENDIF()
-KOKKOS_ENABLE_OPTION(CUDA_LAMBDA ${CUDA_LAMBDA_DEFAULT} "Whether to activate experimental lambda features")
 IF (Trilinos_ENABLE_Kokkos)
   SET(COMPLEX_ALIGN_DEFAULT OFF)
 ELSE()
@@ -104,6 +103,13 @@ ELSE()
 ENDIF()
 KOKKOS_ENABLE_OPTION(CUDA_CONSTEXPR ${CUDA_CONSTEXPR_DEFAULT} "Whether to activate experimental relaxed constexpr functions")
 
+IF (KOKKOS_ENABLE_HPX)
+  SET(HPX_ASYNC_DISPATCH_DEFAULT ON)
+ELSE()
+  SET(HPX_ASYNC_DISPATCH_DEFAULT OFF)
+ENDIF()
+KOKKOS_ENABLE_OPTION(IMPL_HPX_ASYNC_DISPATCH ${HPX_ASYNC_DISPATCH_DEFAULT} "Whether HPX supports asynchronous dispatch")
+
 Kokkos_ENABLE_OPTION(UNSUPPORTED_ARCHS OFF "Whether to allow architectures in backends Kokkos doesn't optimize for")
 
 FUNCTION(check_device_specific_options)
@@ -123,7 +129,7 @@ ENDFUNCTION()
 
 CHECK_DEVICE_SPECIFIC_OPTIONS(DEVICE CUDA OPTIONS CUDA_UVM CUDA_RELOCATABLE_DEVICE_CODE CUDA_LAMBDA CUDA_CONSTEXPR CUDA_LDG_INTRINSIC)
 CHECK_DEVICE_SPECIFIC_OPTIONS(DEVICE HIP OPTIONS HIP_RELOCATABLE_DEVICE_CODE)
-CHECK_DEVICE_SPECIFIC_OPTIONS(DEVICE HPX OPTIONS HPX_ASYNC_DISPATCH)
+CHECK_DEVICE_SPECIFIC_OPTIONS(DEVICE HPX OPTIONS IMPL_HPX_ASYNC_DISPATCH)
 
 # Needed due to change from deprecated name to new header define name
 IF (KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION)
@@ -166,3 +172,17 @@ IF(Kokkos_ENABLE_CUDA_LDG_INTRINSIC)
     MESSAGE(FATAL_ERROR "Kokkos_ENABLE_CUDA_LDG_INTRINSIC has been removed. LDG intrinsics are always enabled.")
   ENDIF()
 ENDIF()
+IF(Kokkos_ENABLE_CUDA AND NOT Kokkos_ENABLE_CUDA_LAMBDA)
+  IF(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+    MESSAGE(DEPRECATION "Setting Kokkos_ENABLE_CUDA_LAMBDA is deprecated. Lambda expressions in device code are always enabled. Forcing -DKokkos_ENABLE_CUDA_LAMBDA=ON")
+    set(Kokkos_ENABLE_CUDA_LAMBDA ON CACHE BOOL "Kokkos turned Cuda lambda support ON!" FORCE)
+    set(KOKKOS_ENABLE_CUDA_LAMBDA ON)
+  ELSE()
+    MESSAGE(FATAL_ERROR "Kokkos_ENABLE_CUDA_LAMBDA has been removed. Lambda expressions in device code always enabled.")
+  ENDIF()
+ENDIF()
+
+
+IF(DEFINED Kokkos_ENABLE_IMPL_DESUL_ATOMICS)
+  MESSAGE(WARNING "Kokkos_ENABLE_IMPL_DESUL_ATOMICS option has been removed. Desul atomics cannot be disabled.")
+ENDIF()
diff --git a/cmake/kokkos_functions.cmake b/cmake/kokkos_functions.cmake
index 4c51bdeabf..9dab1ca00e 100644
--- a/cmake/kokkos_functions.cmake
+++ b/cmake/kokkos_functions.cmake
@@ -5,6 +5,14 @@
 # Validate options are given with correct case and define an internal
 # upper-case version for use within
 
+set(Kokkos_OPTIONS_NOT_TO_EXPORT
+  Kokkos_ENABLE_BENCHMARKS
+  Kokkos_ENABLE_EXAMPLES
+  Kokkos_ENABLE_TESTS
+  Kokkos_ENABLE_HEADER_SELF_CONTAINMENT_TESTS
+  Kokkos_ENABLE_COMPILER_WARNINGS
+)
+
 #
 #
 # @FUNCTION: kokkos_deprecated_list
@@ -57,6 +65,12 @@ FUNCTION(kokkos_option CAMEL_SUFFIX DEFAULT TYPE DOCSTRING)
   # Make sure this appears in the cache with the appropriate DOCSTRING
   SET(${CAMEL_NAME} ${DEFAULT} CACHE ${TYPE} ${DOCSTRING})
 
+  IF (KOKKOS_HAS_TRILINOS)
+    IF (NOT CAMEL_NAME IN_LIST Kokkos_OPTIONS_NOT_TO_EXPORT)
+      TRIBITS_PKG_EXPORT_CACHE_VAR(${CAMEL_NAME})
+    ENDIF()
+  ENDIF()
+
   #I don't love doing it this way because it's N^2 in number options, but c'est la vie
   FOREACH(opt ${KOKKOS_GIVEN_VARIABLES})
     STRING(TOUPPER ${opt} OPT_UC)
diff --git a/cmake/kokkos_install.cmake b/cmake/kokkos_install.cmake
index c65c2af52b..f818dfa244 100644
--- a/cmake/kokkos_install.cmake
+++ b/cmake/kokkos_install.cmake
@@ -28,6 +28,15 @@ IF (NOT KOKKOS_HAS_TRILINOS AND NOT Kokkos_INSTALL_TESTING)
     "${Kokkos_BINARY_DIR}/KokkosConfigVersion.cmake"
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Kokkos)
   install(EXPORT KokkosTargets NAMESPACE Kokkos:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Kokkos)
+  export(EXPORT KokkosTargets NAMESPACE Kokkos:: FILE ${Kokkos_BINARY_DIR}/KokkosTargets.cmake)
+
+  # Required to be a TriBITS-compliant external package
+  file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/cmake_packages/Kokkos)
+  file(COPY ${Kokkos_BINARY_DIR}/KokkosConfig.cmake
+            ${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake
+            ${Kokkos_BINARY_DIR}/KokkosConfigVersion.cmake
+            DESTINATION ${CMAKE_BINARY_DIR}/cmake_packages/Kokkos)
+  export(EXPORT KokkosTargets NAMESPACE Kokkos:: FILE ${CMAKE_BINARY_DIR}/cmake_packages/Kokkos/KokkosTargets.cmake)
 ELSE()
   CONFIGURE_FILE(cmake/KokkosConfigCommon.cmake.in ${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake @ONLY)
   file(READ ${Kokkos_BINARY_DIR}/KokkosConfigCommon.cmake KOKKOS_CONFIG_COMMON)
@@ -38,7 +47,7 @@ ELSE()
 
   WRITE_BASIC_PACKAGE_VERSION_FILE("${CMAKE_CURRENT_BINARY_DIR}/KokkosConfigVersion.cmake"
       VERSION "${Kokkos_VERSION}"
-      COMPATIBILITY SameMajorVersion)
+      COMPATIBILITY AnyNewerVersion)
 
   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KokkosConfigVersion.cmake
       DESTINATION "${${PROJECT_NAME}_INSTALL_LIB_DIR}/cmake/${PACKAGE_NAME}")
diff --git a/cmake/kokkos_test_cxx_std.cmake b/cmake/kokkos_test_cxx_std.cmake
index eda3124586..5f8e15cd67 100644
--- a/cmake/kokkos_test_cxx_std.cmake
+++ b/cmake/kokkos_test_cxx_std.cmake
@@ -29,7 +29,11 @@ FUNCTION(kokkos_set_cxx_standard_feature standard)
   ELSEIF(NOT KOKKOS_USE_CXX_EXTENSIONS AND ${STANDARD_NAME})
     MESSAGE(STATUS "Using ${${STANDARD_NAME}} for C++${standard} standard as feature")
     IF (KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA AND (KOKKOS_CXX_HOST_COMPILER_ID STREQUAL GNU OR KOKKOS_CXX_HOST_COMPILER_ID STREQUAL Clang))
-      SET(SUPPORTED_NVCC_FLAGS "-std=c++17")
+      IF(${KOKKOS_CXX_COMPILER_VERSION} VERSION_LESS 12.0.0)
+        SET(SUPPORTED_NVCC_FLAGS "-std=c++17")
+      ELSE()
+        SET(SUPPORTED_NVCC_FLAGS "-std=c++17" "-std=c++20")
+      ENDIF()
       IF (NOT ${${STANDARD_NAME}} IN_LIST SUPPORTED_NVCC_FLAGS)
         MESSAGE(FATAL_ERROR "CMake wants to use ${${STANDARD_NAME}} which is not supported by NVCC. Using a more recent host compiler or a more recent CMake version might help.")
       ENDIF()
diff --git a/cmake/kokkos_tpls.cmake b/cmake/kokkos_tpls.cmake
index ba66ee4d38..c902e9f0e5 100644
--- a/cmake/kokkos_tpls.cmake
+++ b/cmake/kokkos_tpls.cmake
@@ -31,8 +31,7 @@ FUNCTION(KOKKOS_TPL_OPTION PKG DEFAULT)
   ENDIF()
 ENDFUNCTION()
 
-KOKKOS_TPL_OPTION(HWLOC   Off)
-KOKKOS_TPL_OPTION(LIBNUMA Off)
+KOKKOS_TPL_OPTION(HWLOC   Off TRIBITS HWLOC)
 KOKKOS_TPL_OPTION(MEMKIND Off)
 IF(KOKKOS_ENABLE_MEMKIND)
   SET(KOKKOS_ENABLE_HBWSPACE ON)
@@ -46,6 +45,7 @@ ELSE()
   SET(ROCM_DEFAULT OFF)
 ENDIF()
 KOKKOS_TPL_OPTION(ROCM    ${ROCM_DEFAULT})
+KOKKOS_TPL_OPTION(ONEDPL  ${Kokkos_ENABLE_SYCL})
 
 IF (WIN32)
   SET(LIBDL_DEFAULT Off)
@@ -76,7 +76,6 @@ IF (NOT KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
   KOKKOS_IMPORT_TPL(CUDA INTERFACE)
 ENDIF()
 KOKKOS_IMPORT_TPL(HWLOC)
-KOKKOS_IMPORT_TPL(LIBNUMA)
 KOKKOS_IMPORT_TPL(LIBRT)
 KOKKOS_IMPORT_TPL(LIBDL)
 KOKKOS_IMPORT_TPL(MEMKIND)
@@ -85,10 +84,11 @@ IF (NOT WIN32)
 ENDIF()
 IF (NOT KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
   KOKKOS_IMPORT_TPL(ROCM INTERFACE)
+  KOKKOS_IMPORT_TPL(ONEDPL INTERFACE)
 ENDIF()
 KOKKOS_IMPORT_TPL(LIBQUADMATH)
 
-IF (Kokkos_ENABLE_IMPL_DESUL_ATOMICS AND Kokkos_ENABLE_DESUL_ATOMICS_EXTERNAL)
+IF (Kokkos_ENABLE_DESUL_ATOMICS_EXTERNAL)
   find_package(desul REQUIRED COMPONENTS atomics)
   KOKKOS_EXPORT_CMAKE_TPL(desul REQUIRED COMPONENTS atomics)
 ENDIF()
diff --git a/cmake/kokkos_tribits.cmake b/cmake/kokkos_tribits.cmake
index 0557db2098..01ea7efd8a 100644
--- a/cmake/kokkos_tribits.cmake
+++ b/cmake/kokkos_tribits.cmake
@@ -44,53 +44,12 @@ IF (KOKKOS_HAS_TRILINOS)
   ENDIF()
 ENDIF()
 
-MACRO(KOKKOS_SUBPACKAGE NAME)
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_SUBPACKAGE(${NAME})
-  else()
-    SET(PACKAGE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-    SET(PARENT_PACKAGE_NAME ${PACKAGE_NAME})
-    SET(PACKAGE_NAME ${PACKAGE_NAME}${NAME})
-    STRING(TOUPPER ${PACKAGE_NAME} PACKAGE_NAME_UC)
-    SET(${PACKAGE_NAME}_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-    #ADD_INTERFACE_LIBRARY(PACKAGE_${PACKAGE_NAME})
-    #GLOBAL_SET(${PACKAGE_NAME}_LIBS "")
-  endif()
-ENDMACRO()
-
-MACRO(KOKKOS_SUBPACKAGE_POSTPROCESS)
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_SUBPACKAGE_POSTPROCESS()
-  endif()
-ENDMACRO()
-
-MACRO(KOKKOS_PACKAGE_DECL)
-
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_PACKAGE_DECL(Kokkos)
-  else()
-    SET(PACKAGE_NAME Kokkos)
-    SET(${PACKAGE_NAME}_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-    STRING(TOUPPER ${PACKAGE_NAME} PACKAGE_NAME_UC)
-  endif()
-
-  #SET(TRIBITS_DEPS_DIR "${CMAKE_SOURCE_DIR}/cmake/deps")
-  #FILE(GLOB TPLS_FILES "${TRIBITS_DEPS_DIR}/*.cmake")
-  #FOREACH(TPL_FILE ${TPLS_FILES})
-  #  TRIBITS_PROCESS_TPL_DEP_FILE(${TPL_FILE})
-  #ENDFOREACH()
-
-ENDMACRO()
-
-
 MACRO(KOKKOS_PROCESS_SUBPACKAGES)
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_PROCESS_SUBPACKAGES()
-  else()
-    ADD_SUBDIRECTORY(core)
-    ADD_SUBDIRECTORY(containers)
-    ADD_SUBDIRECTORY(algorithms)
-    ADD_SUBDIRECTORY(simd)
+  ADD_SUBDIRECTORY(core)
+  ADD_SUBDIRECTORY(containers)
+  ADD_SUBDIRECTORY(algorithms)
+  ADD_SUBDIRECTORY(simd)
+  if (NOT KOKKOS_HAS_TRILINOS)
     ADD_SUBDIRECTORY(example)
   endif()
 ENDMACRO()
@@ -353,6 +312,7 @@ MACRO(KOKKOS_INSTALL_ADDITIONAL_FILES)
           DESTINATION ${KOKKOS_HEADER_DIR})
 ENDMACRO()
 
+
 FUNCTION(KOKKOS_SET_LIBRARY_PROPERTIES LIBRARY_NAME)
   CMAKE_PARSE_ARGUMENTS(PARSE
     "PLAIN_STYLE"
@@ -441,6 +401,7 @@ FUNCTION(KOKKOS_SET_LIBRARY_PROPERTIES LIBRARY_NAME)
   ENDIF()
 ENDFUNCTION()
 
+
 FUNCTION(KOKKOS_INTERNAL_ADD_LIBRARY LIBRARY_NAME)
   CMAKE_PARSE_ARGUMENTS(PARSE
     "STATIC;SHARED"
@@ -503,19 +464,11 @@ FUNCTION(KOKKOS_ADD_LIBRARY LIBRARY_NAME)
     # preserving the directory structure, e.g. impl
     # If headers got installed in both locations, it breaks some
     # downstream packages
-    TRIBITS_ADD_LIBRARY(${LIBRARY_NAME} ${PARSE_UNPARSED_ARGUMENTS})
-    #Stolen from Tribits - it can add prefixes
-    SET(TRIBITS_LIBRARY_NAME_PREFIX "${${PROJECT_NAME}_LIBRARY_NAME_PREFIX}")
-    SET(TRIBITS_LIBRARY_NAME ${TRIBITS_LIBRARY_NAME_PREFIX}${LIBRARY_NAME})
-    #Tribits has way too much techinical debt and baggage to even
-    #allow PUBLIC target_compile_options to be used. It forces C++ flags on projects
-    #as a giant blob of space-separated strings. We end up with duplicated
-    #flags between the flags implicitly forced on Kokkos-dependent and those Kokkos
-    #has in its public INTERFACE_COMPILE_OPTIONS.
-    #These do NOT get de-deduplicated because Tribits
-    #creates flags as a giant monolithic space-separated string
-    #Do not set any transitive properties and keep everything working as before
-    #KOKKOS_SET_LIBRARY_PROPERTIES(${TRIBITS_LIBRARY_NAME} PLAIN_STYLE)
+    TRIBITS_ADD_LIBRARY(${LIBRARY_NAME} ${PARSE_UNPARSED_ARGUMENTS}
+      ADDED_LIB_TARGET_NAME_OUT  ${LIBRARY_NAME}_TARGET_NAME )
+    IF (PARSE_ADD_BUILD_OPTIONS)
+      KOKKOS_SET_LIBRARY_PROPERTIES(${${LIBRARY_NAME}_TARGET_NAME})
+    ENDIF()
   ELSE()
     # Forward the headers, we want to know about all headers
     # to make sure they appear correctly in IDEs
@@ -527,15 +480,17 @@ FUNCTION(KOKKOS_ADD_LIBRARY LIBRARY_NAME)
   ENDIF()
 ENDFUNCTION()
 
+
 FUNCTION(KOKKOS_ADD_INTERFACE_LIBRARY NAME)
-IF (KOKKOS_HAS_TRILINOS)
-  TRIBITS_ADD_LIBRARY(${NAME} ${ARGN})
-ELSE()
-  ADD_LIBRARY(${NAME} INTERFACE)
-  KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL(${NAME})
-ENDIF()
+  IF (KOKKOS_HAS_TRILINOS)
+    TRIBITS_ADD_LIBRARY(${NAME} ${ARGN})
+  ELSE()
+    ADD_LIBRARY(${NAME} INTERFACE)
+    KOKKOS_INTERNAL_ADD_LIBRARY_INSTALL(${NAME})
+  ENDIF()
 ENDFUNCTION()
 
+
 FUNCTION(KOKKOS_LIB_INCLUDE_DIRECTORIES TARGET)
   IF(KOKKOS_HAS_TRILINOS)
     #ignore the target, tribits doesn't do anything directly with targets
@@ -549,13 +504,8 @@ FUNCTION(KOKKOS_LIB_INCLUDE_DIRECTORIES TARGET)
 ENDFUNCTION()
 
 FUNCTION(KOKKOS_LIB_COMPILE_OPTIONS TARGET)
-  IF(KOKKOS_HAS_TRILINOS)
-    #don't trust tribits to do this correctly
-    KOKKOS_TARGET_COMPILE_OPTIONS(${TARGET} ${ARGN})
-  ELSE()
-    KOKKOS_LIB_TYPE(${TARGET} INCTYPE)
-    KOKKOS_TARGET_COMPILE_OPTIONS(${${PROJECT_NAME}_LIBRARY_NAME_PREFIX}${TARGET} ${INCTYPE} ${ARGN})
-  ENDIF()
+  KOKKOS_LIB_TYPE(${TARGET} INCTYPE)
+  KOKKOS_TARGET_COMPILE_OPTIONS(${${PROJECT_NAME}_LIBRARY_NAME_PREFIX}${TARGET} ${INCTYPE} ${ARGN})
 ENDFUNCTION()
 
 MACRO(KOKKOS_ADD_TEST_DIRECTORIES)
diff --git a/containers/CMakeLists.txt b/containers/CMakeLists.txt
index b450c27209..0857d7007b 100644
--- a/containers/CMakeLists.txt
+++ b/containers/CMakeLists.txt
@@ -1,7 +1,3 @@
-
-
-KOKKOS_SUBPACKAGE(Containers)
-
 IF (NOT Kokkos_INSTALL_TESTING)
   ADD_SUBDIRECTORY(src)
 ENDIF()
@@ -11,5 +7,3 @@ IF(NOT KOKKOS_ENABLE_OPENACC)
 KOKKOS_ADD_TEST_DIRECTORIES(unit_tests)
 KOKKOS_ADD_TEST_DIRECTORIES(performance_tests)
 ENDIF()
-
-KOKKOS_SUBPACKAGE_POSTPROCESS()
diff --git a/containers/cmake/Dependencies.cmake b/containers/cmake/Dependencies.cmake
deleted file mode 100644
index 1d71d8af34..0000000000
--- a/containers/cmake/Dependencies.cmake
+++ /dev/null
@@ -1,5 +0,0 @@
-TRIBITS_PACKAGE_DEFINE_DEPENDENCIES(
-  LIB_REQUIRED_PACKAGES KokkosCore
-  LIB_OPTIONAL_TPLS Pthread CUDA HWLOC
-  TEST_OPTIONAL_TPLS CUSPARSE
-  )
diff --git a/containers/cmake/KokkosContainers_config.h.in b/containers/cmake/KokkosContainers_config.h.in
deleted file mode 100644
index d91fdda1e3..0000000000
--- a/containers/cmake/KokkosContainers_config.h.in
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef KOKKOS_CONTAINERS_CONFIG_H
-#define KOKKOS_CONTAINERS_CONFIG_H
-
-#endif
diff --git a/containers/performance_tests/CMakeLists.txt b/containers/performance_tests/CMakeLists.txt
index 4f1eeacdad..e325e45e85 100644
--- a/containers/performance_tests/CMakeLists.txt
+++ b/containers/performance_tests/CMakeLists.txt
@@ -16,7 +16,7 @@ foreach(Tag Threads;OpenMP;Cuda;HPX;HIP)
     )
 
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-      PerformanceTest_${Tag}
+      ContainersPerformanceTest_${Tag}
       SOURCES ${SOURCES}
     )
   endif()
diff --git a/containers/src/CMakeLists.txt b/containers/src/CMakeLists.txt
index cdbc6527fd..b7d85ebf11 100644
--- a/containers/src/CMakeLists.txt
+++ b/containers/src/CMakeLists.txt
@@ -1,6 +1,3 @@
-
-KOKKOS_CONFIGURE_FILE(${PACKAGE_NAME}_config.h)
-
 #need these here for now
 KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
 KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/containers/src/Kokkos_DualView.hpp b/containers/src/Kokkos_DualView.hpp
index 07256b4464..e821570a8d 100644
--- a/containers/src/Kokkos_DualView.hpp
+++ b/containers/src/Kokkos_DualView.hpp
@@ -86,22 +86,57 @@ inline const Kokkos::Cuda& get_cuda_space(const NonCudaExecSpace&) {
 #endif  // KOKKOS_ENABLE_CUDA
 
 }  // namespace Impl
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 template <class DataType, class Arg1Type = void, class Arg2Type = void,
           class Arg3Type = void>
+class DualView;
+#else
+template <class DataType, class... Properties>
+class DualView;
+#endif
+
+template <class>
+struct is_dual_view : public std::false_type {};
+
+template <class DT, class... DP>
+struct is_dual_view<DualView<DT, DP...>> : public std::true_type {};
+
+template <class DT, class... DP>
+struct is_dual_view<const DualView<DT, DP...>> : public std::true_type {};
+
+template <class T>
+inline constexpr bool is_dual_view_v = is_dual_view<T>::value;
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+template <class DataType, class Arg1Type, class Arg2Type, class Arg3Type>
 class DualView : public ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> {
   template <class, class, class, class>
+#else
+template <class DataType, class... Properties>
+class DualView : public ViewTraits<DataType, Properties...> {
+  template <class, class...>
+#endif
   friend class DualView;
 
  public:
   //! \name Typedefs for device types and various Kokkos::View specializations.
   //@{
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   using traits = ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type>;
+#else
+  using traits      = ViewTraits<DataType, Properties...>;
+#endif
 
   //! The Kokkos Host Device type;
   using host_mirror_space = typename traits::host_mirror_space;
 
   //! The type of a Kokkos::View on the device.
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   using t_dev = View<typename traits::data_type, Arg1Type, Arg2Type, Arg3Type>;
+#else
+  using t_dev       = View<typename traits::data_type, Properties...>;
+#endif
 
   /// \typedef t_host
   /// \brief The type of a Kokkos::View host mirror of \c t_dev.
@@ -109,8 +144,12 @@ class DualView : public ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> {
 
   //! The type of a const View on the device.
   //! The type of a Kokkos::View on the device.
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   using t_dev_const =
       View<typename traits::const_data_type, Arg1Type, Arg2Type, Arg3Type>;
+#else
+  using t_dev_const = View<typename traits::const_data_type, Properties...>;
+#endif
 
   /// \typedef t_host_const
   /// \brief The type of a const View host mirror of \c t_dev_const.
@@ -239,22 +278,23 @@ class DualView : public ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> {
       : modified_flags(t_modified_flags("DualView::modified_flags")),
         d_view(arg_prop, n0, n1, n2, n3, n4, n5, n6, n7) {
     // without UVM, host View mirrors
-    if (Kokkos::Impl::has_type<Impl::WithoutInitializing_t, P...>::value)
+    if constexpr (Kokkos::Impl::has_type<Impl::WithoutInitializing_t,
+                                         P...>::value)
       h_view = Kokkos::create_mirror_view(Kokkos::WithoutInitializing, d_view);
     else
       h_view = Kokkos::create_mirror_view(d_view);
   }
 
   //! Copy constructor (shallow copy)
-  template <class SS, class LS, class DS, class MS>
-  DualView(const DualView<SS, LS, DS, MS>& src)
+  template <typename DT, typename... DP>
+  DualView(const DualView<DT, DP...>& src)
       : modified_flags(src.modified_flags),
         d_view(src.d_view),
         h_view(src.h_view) {}
 
   //! Subview constructor
-  template <class SD, class S1, class S2, class S3, class Arg0, class... Args>
-  DualView(const DualView<SD, S1, S2, S3>& src, const Arg0& arg0, Args... args)
+  template <class DT, class... DP, class Arg0, class... Args>
+  DualView(const DualView<DT, DP...>& src, const Arg0& arg0, Args... args)
       : modified_flags(src.modified_flags),
         d_view(Kokkos::subview(src.d_view, arg0, args...)),
         h_view(Kokkos::subview(src.h_view, arg0, args...)) {}
@@ -576,8 +616,8 @@ class DualView : public ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> {
         impl_report_host_sync();
       }
     }
-    if (std::is_same<typename t_host::memory_space,
-                     typename t_dev::memory_space>::value) {
+    if constexpr (std::is_same<typename t_host::memory_space,
+                               typename t_dev::memory_space>::value) {
       typename t_dev::execution_space().fence(
           "Kokkos::DualView<>::sync: fence after syncing DualView");
       typename t_host::execution_space().fence(
@@ -1141,23 +1181,24 @@ class DualView : public ViewTraits<DataType, Arg1Type, Arg2Type, Arg3Type> {
 namespace Kokkos {
 namespace Impl {
 
-template <class D, class A1, class A2, class A3, class... Args>
-struct DualViewSubview {
-  using dst_traits = typename Kokkos::Impl::ViewMapping<
-      void, Kokkos::ViewTraits<D, A1, A2, A3>, Args...>::traits_type;
+template <class V>
+struct V2DV;
 
-  using type = Kokkos::DualView<
-      typename dst_traits::data_type, typename dst_traits::array_layout,
-      typename dst_traits::device_type, typename dst_traits::memory_traits>;
+template <class D, class... P>
+struct V2DV<View<D, P...>> {
+  using type = DualView<D, P...>;
 };
-
 } /* namespace Impl */
 
-template <class D, class A1, class A2, class A3, class... Args>
-typename Impl::DualViewSubview<D, A1, A2, A3, Args...>::type subview(
-    const DualView<D, A1, A2, A3>& src, Args... args) {
-  return typename Impl::DualViewSubview<D, A1, A2, A3, Args...>::type(src,
-                                                                      args...);
+template <class DataType, class... Properties, class... Args>
+auto subview(const DualView<DataType, Properties...>& src, Args&&... args) {
+  // leverage Kokkos::View facilities to deduce the properties of the subview
+  using deduce_subview_type =
+      decltype(subview(std::declval<View<DataType, Properties...>>(),
+                       std::forward<Args>(args)...));
+  // map it back to dual view
+  return typename Impl::V2DV<deduce_subview_type>::type(
+      src, std::forward<Args>(args)...);
 }
 
 } /* namespace Kokkos */
@@ -1171,11 +1212,8 @@ namespace Kokkos {
 // Partial specialization of Kokkos::deep_copy() for DualView objects.
 //
 
-template <class DT, class DL, class DD, class DM, class ST, class SL, class SD,
-          class SM>
-void deep_copy(
-    DualView<DT, DL, DD, DM> dst,  // trust me, this must not be a reference
-    const DualView<ST, SL, SD, SM>& src) {
+template <class DT, class... DP, class ST, class... SP>
+void deep_copy(DualView<DT, DP...>& dst, const DualView<ST, SP...>& src) {
   if (src.need_sync_device()) {
     deep_copy(dst.h_view, src.h_view);
     dst.modify_host();
@@ -1185,12 +1223,9 @@ void deep_copy(
   }
 }
 
-template <class ExecutionSpace, class DT, class DL, class DD, class DM,
-          class ST, class SL, class SD, class SM>
-void deep_copy(
-    const ExecutionSpace& exec,
-    DualView<DT, DL, DD, DM> dst,  // trust me, this must not be a reference
-    const DualView<ST, SL, SD, SM>& src) {
+template <class ExecutionSpace, class DT, class... DP, class ST, class... SP>
+void deep_copy(const ExecutionSpace& exec, DualView<DT, DP...>& dst,
+               const DualView<ST, SP...>& src) {
   if (src.need_sync_device()) {
     deep_copy(exec, dst.h_view, src.h_view);
     dst.modify_host();
diff --git a/containers/src/Kokkos_DynRankView.hpp b/containers/src/Kokkos_DynRankView.hpp
index ce433b0bfc..39d72fb37d 100644
--- a/containers/src/Kokkos_DynRankView.hpp
+++ b/containers/src/Kokkos_DynRankView.hpp
@@ -346,7 +346,7 @@ class ViewMapping<
     dst.m_map.m_impl_handle = Kokkos::Impl::ViewDataHandle<DstTraits>::assign(
         src.m_map.m_impl_handle, src.m_track.m_tracker);
     dst.m_track.assign(src.m_track.m_tracker, DstTraits::is_managed);
-    dst.m_rank = src.Rank;
+    dst.m_rank = Kokkos::View<ST, SP...>::rank();
   }
 };
 
@@ -375,6 +375,9 @@ template <class D, class... P>
 struct is_dyn_rank_view<Kokkos::DynRankView<D, P...>> : public std::true_type {
 };
 
+template <class T>
+inline constexpr bool is_dyn_rank_view_v = is_dyn_rank_view<T>::value;
+
 template <typename DataType, class... Properties>
 class DynRankView : public ViewTraits<DataType, Properties...> {
   static_assert(!std::is_array<DataType>::value &&
@@ -1025,7 +1028,7 @@ class DynRankView : public ViewTraits<DataType, Properties...> {
   // Copy/Assign View to DynRankView
   template <class RT, class... RP>
   KOKKOS_INLINE_FUNCTION DynRankView(const View<RT, RP...>& rhs)
-      : m_track(), m_map(), m_rank(rhs.Rank) {
+      : m_track(), m_map(), m_rank(View<RT, RP...>::rank()) {
     using SrcTraits = typename View<RT, RP...>::traits;
     using Mapping =
         Kokkos::Impl::ViewMapping<traits, SrcTraits,
@@ -1089,37 +1092,12 @@ class DynRankView : public ViewTraits<DataType, Properties...> {
           "execution space");
     }
 
-//------------------------------------------------------------
-#if defined(KOKKOS_ENABLE_CUDA)
-    // If allocating in CudaUVMSpace must fence before and after
-    // the allocation to protect against possible concurrent access
-    // on the CPU and the GPU.
-    // Fence using the trait's executon space (which will be Kokkos::Cuda)
-    // to avoid incomplete type errors from usng Kokkos::Cuda directly.
-    if (std::is_same<Kokkos::CudaUVMSpace,
-                     typename traits::device_type::memory_space>::value) {
-      typename traits::device_type::memory_space::execution_space().fence(
-          "Kokkos::DynRankView<>::DynRankView: fence before UVM allocation");
-    }
-#endif
-    //------------------------------------------------------------
-
     Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
         prop_copy,
         Impl::DynRankDimTraits<typename traits::specialize>::
             template createLayout<traits, P...>(arg_prop, arg_layout),
         Impl::ViewCtorProp<P...>::has_execution_space);
 
-//------------------------------------------------------------
-#if defined(KOKKOS_ENABLE_CUDA)
-    if (std::is_same<Kokkos::CudaUVMSpace,
-                     typename traits::device_type::memory_space>::value) {
-      typename traits::device_type::memory_space::execution_space().fence(
-          "Kokkos::DynRankView<>::DynRankView: fence after UVM allocation");
-    }
-#endif
-    //------------------------------------------------------------
-
     // Setup and initialization complete, start tracking
     m_track.assign_allocated_record_to_uninitialized(record);
   }
@@ -1573,7 +1551,7 @@ struct DynRankViewFill {
 };
 
 template <class OutputView>
-struct DynRankViewFill<OutputView, std::enable_if_t<OutputView::Rank == 0>> {
+struct DynRankViewFill<OutputView, std::enable_if_t<OutputView::rank == 0>> {
   DynRankViewFill(const OutputView& dst,
                   const typename OutputView::const_value_type& src) {
     Kokkos::Impl::DeepCopy<typename OutputView::memory_space,
@@ -2324,9 +2302,10 @@ inline void impl_resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
   if constexpr (alloc_prop_input::has_execution_space)
     Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(
         Impl::get_property<Impl::ExecutionSpaceTag>(prop_copy), v_resized, v);
-  else
+  else {
     Kokkos::Impl::DynRankViewRemap<drview_type, drview_type>(v_resized, v);
-
+    Kokkos::fence("Kokkos::resize(DynRankView)");
+  }
   v = v_resized;
 }
 
diff --git a/containers/src/Kokkos_DynamicView.hpp b/containers/src/Kokkos_DynamicView.hpp
index f8636b6212..12885edbae 100644
--- a/containers/src/Kokkos_DynamicView.hpp
+++ b/containers/src/Kokkos_DynamicView.hpp
@@ -553,6 +553,9 @@ template <class D, class... P>
 struct is_dynamic_view<Kokkos::Experimental::DynamicView<D, P...>>
     : public std::true_type {};
 
+template <class T>
+inline constexpr bool is_dynamic_view_v = is_dynamic_view<T>::value;
+
 }  // namespace Kokkos
 
 namespace Kokkos {
diff --git a/containers/src/Kokkos_OffsetView.hpp b/containers/src/Kokkos_OffsetView.hpp
index 35b28999c1..92aead2878 100644
--- a/containers/src/Kokkos_OffsetView.hpp
+++ b/containers/src/Kokkos_OffsetView.hpp
@@ -43,6 +43,9 @@ struct is_offset_view<OffsetView<D, P...>> : public std::true_type {};
 template <class D, class... P>
 struct is_offset_view<const OffsetView<D, P...>> : public std::true_type {};
 
+template <class T>
+inline constexpr bool is_offset_view_v = is_offset_view<T>::value;
+
 #define KOKKOS_INVALID_OFFSET int64_t(0x7FFFFFFFFFFFFFFFLL)
 #define KOKKOS_INVALID_INDEX_RANGE \
   { KOKKOS_INVALID_OFFSET, KOKKOS_INVALID_OFFSET }
@@ -827,7 +830,7 @@ class OffsetView : public ViewTraits<DataType, Properties...> {
                   "Incompatible OffsetView copy construction");
     Mapping::assign(m_map, aview.impl_map(), m_track);
 
-    for (int i = 0; i < aview.Rank; ++i) {
+    for (size_t i = 0; i < View<RT, RP...>::rank(); ++i) {
       m_begins[i] = 0;
     }
   }
@@ -938,10 +941,10 @@ class OffsetView : public ViewTraits<DataType, Properties...> {
           ")"
           "\n";
 
-    // If there are no errors so far, then rank == Rank
+    // If there are no errors so far, then arg_rank == Rank
     // Otherwise, check as much as possible
-    size_t rank = begins.size() < ends.size() ? begins.size() : ends.size();
-    for (size_t i = 0; i != rank; ++i) {
+    size_t arg_rank = begins.size() < ends.size() ? begins.size() : ends.size();
+    for (size_t i = 0; i != arg_rank; ++i) {
       subtraction_failure sf = check_subtraction(at(ends, i), at(begins, i));
       if (sf != subtraction_failure::none) {
         message +=
@@ -1191,35 +1194,10 @@ class OffsetView : public ViewTraits<DataType, Properties...> {
           "execution space");
     }
 
-    //------------------------------------------------------------
-#if defined(KOKKOS_ENABLE_CUDA)
-    // If allocating in CudaUVMSpace must fence before and after
-    // the allocation to protect against possible concurrent access
-    // on the CPU and the GPU.
-    // Fence using the trait's executon space (which will be Kokkos::Cuda)
-    // to avoid incomplete type errors from usng Kokkos::Cuda directly.
-    if (std::is_same<Kokkos::CudaUVMSpace,
-                     typename traits::device_type::memory_space>::value) {
-      typename traits::device_type::memory_space::execution_space().fence(
-          "Kokkos::OffsetView::OffsetView(): fence before UVM allocation");
-    }
-#endif
-    //------------------------------------------------------------
-
     Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
         prop_copy, arg_layout,
         Kokkos::Impl::ViewCtorProp<P...>::has_execution_space);
 
-    //------------------------------------------------------------
-#if defined(KOKKOS_ENABLE_CUDA)
-    if (std::is_same<Kokkos::CudaUVMSpace,
-                     typename traits::device_type::memory_space>::value) {
-      typename traits::device_type::memory_space::execution_space().fence(
-          "Kokkos::OffsetView::OffsetView(): fence after UVM allocation");
-    }
-#endif
-    //------------------------------------------------------------
-
     // Setup and initialization complete, start tracking
     m_track.assign_allocated_record_to_uninitialized(record);
 
@@ -1251,8 +1229,7 @@ shift_input(const T arg, const int64_t offset) {
 }
 
 KOKKOS_INLINE_FUNCTION
-Kokkos::Impl::ALL_t shift_input(const Kokkos::Impl::ALL_t arg,
-                                const int64_t /*offset*/) {
+Kokkos::ALL_t shift_input(const Kokkos::ALL_t arg, const int64_t /*offset*/) {
   return arg;
 }
 
@@ -1302,7 +1279,7 @@ KOKKOS_INLINE_FUNCTION
       Kokkos::Impl::ViewMapping<void /* deduce subview type from source view
                                         traits */
                                 ,
-                                ViewTraits<D, P...>, T>::type::Rank;
+                                ViewTraits<D, P...>, T>::type::rank;
 
   auto theSubview = Kokkos::subview(theView, shiftedArg);
 
@@ -1341,7 +1318,7 @@ KOKKOS_INLINE_FUNCTION
       Kokkos::Impl::ViewMapping<void /* deduce subview type from source view
                                         traits */
                                 ,
-                                ViewTraits<D, P...>, T0, T1>::type::Rank;
+                                ViewTraits<D, P...>, T0, T1>::type::rank;
 
   Kokkos::Array<int64_t, rank> subviewBegins;
   size_t counter = 0;
@@ -1382,7 +1359,7 @@ KOKKOS_INLINE_FUNCTION
       Kokkos::Impl::ViewMapping<void /* deduce subview type from source view
                                         traits */
                                 ,
-                                ViewTraits<D, P...>, T0, T1, T2>::type::Rank;
+                                ViewTraits<D, P...>, T0, T1, T2>::type::rank;
 
   Kokkos::Array<int64_t, rank> subviewBegins;
 
@@ -1427,7 +1404,7 @@ KOKKOS_INLINE_FUNCTION
   constexpr size_t rank = Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>, T0, T1, T2, T3>::type::Rank;
+      ViewTraits<D, P...>, T0, T1, T2, T3>::type::rank;
   Kokkos::Array<int64_t, rank> subviewBegins;
 
   size_t counter = 0;
@@ -1474,7 +1451,7 @@ KOKKOS_INLINE_FUNCTION
   constexpr size_t rank = Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type::Rank;
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4>::type::rank;
   Kokkos::Array<int64_t, rank> subviewBegins;
 
   size_t counter = 0;
@@ -1526,7 +1503,7 @@ KOKKOS_INLINE_FUNCTION
   constexpr size_t rank = Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type::Rank;
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5>::type::rank;
 
   Kokkos::Array<int64_t, rank> subviewBegins;
 
@@ -1581,7 +1558,7 @@ KOKKOS_INLINE_FUNCTION
   constexpr size_t rank = Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type::Rank;
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6>::type::rank;
 
   Kokkos::Array<int64_t, rank> subviewBegins;
 
@@ -1640,7 +1617,7 @@ KOKKOS_INLINE_FUNCTION
   constexpr size_t rank = Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type::Rank;
+      ViewTraits<D, P...>, T0, T1, T2, T3, T4, T5, T6, T7>::type::rank;
 
   Kokkos::Array<int64_t, rank> subviewBegins;
 
diff --git a/containers/src/Kokkos_ScatterView.hpp b/containers/src/Kokkos_ScatterView.hpp
index 3b30996ad6..9d04cf6acd 100644
--- a/containers/src/Kokkos_ScatterView.hpp
+++ b/containers/src/Kokkos_ScatterView.hpp
@@ -532,7 +532,7 @@ void args_to_array(size_t* array, int pos, T dim0, Dims... dims) {
    subview where the index specified is the largest-stride one. */
 template <typename Layout, int rank, typename V, typename... Args>
 struct Slice {
-  using next       = Slice<Layout, rank - 1, V, Kokkos::Impl::ALL_t, Args...>;
+  using next       = Slice<Layout, rank - 1, V, Kokkos::ALL_t, Args...>;
   using value_type = typename next::value_type;
 
   static value_type get(V const& src, const size_t i, Args... args) {
@@ -663,6 +663,18 @@ template <typename DataType,
                   typename DeviceType::execution_space, Duplication>::type>
 class ScatterView;
 
+template <class>
+struct is_scatter_view : public std::false_type {};
+
+template <class D, class... P>
+struct is_scatter_view<ScatterView<D, P...>> : public std::true_type {};
+
+template <class D, class... P>
+struct is_scatter_view<const ScatterView<D, P...>> : public std::true_type {};
+
+template <class T>
+inline constexpr bool is_scatter_view_v = is_scatter_view<T>::value;
+
 template <typename DataType, typename Op, typename DeviceType, typename Layout,
           typename Duplication, typename Contribution,
           typename OverrideContribution>
@@ -721,10 +733,11 @@ class ScatterView<DataType, Layout, DeviceType, Op, ScatterNonDuplicated,
       : internal_view(other_view.internal_view) {}
 
   template <typename OtherDataType, typename OtherDeviceType>
-  KOKKOS_FUNCTION void operator=(
+  KOKKOS_FUNCTION ScatterView& operator=(
       const ScatterView<OtherDataType, Layout, OtherDeviceType, Op,
                         ScatterNonDuplicated, Contribution>& other_view) {
     internal_view = other_view.internal_view;
+    return *this;
   }
 
   template <typename OverrideContribution = Contribution>
@@ -942,11 +955,12 @@ class ScatterView<DataType, Kokkos::LayoutRight, DeviceType, Op,
         internal_view(other_view.internal_view) {}
 
   template <typename OtherDataType, typename OtherDeviceType>
-  KOKKOS_FUNCTION void operator=(
+  KOKKOS_FUNCTION ScatterView& operator=(
       const ScatterView<OtherDataType, Kokkos::LayoutRight, OtherDeviceType, Op,
                         ScatterDuplicated, Contribution>& other_view) {
     unique_token  = other_view.unique_token;
     internal_view = other_view.internal_view;
+    return *this;
   }
 
   template <typename RT, typename... RP>
@@ -1019,7 +1033,7 @@ class ScatterView<DataType, Kokkos::LayoutRight, DeviceType, Op,
                                              internal_view_type>::value_type
   subview() const {
     return Kokkos::Impl::Experimental::Slice<
-        Kokkos::LayoutRight, internal_view_type::Rank,
+        Kokkos::LayoutRight, internal_view_type::rank,
         internal_view_type>::get(internal_view, 0);
   }
 
@@ -1278,11 +1292,12 @@ class ScatterView<DataType, Kokkos::LayoutLeft, DeviceType, Op,
         internal_view(other_view.internal_view) {}
 
   template <typename OtherDataType, typename OtherDeviceType>
-  KOKKOS_FUNCTION void operator=(
+  KOKKOS_FUNCTION ScatterView& operator=(
       const ScatterView<OtherDataType, Kokkos::LayoutLeft, OtherDeviceType, Op,
                         ScatterDuplicated, Contribution>& other_view) {
     unique_token  = other_view.unique_token;
     internal_view = other_view.internal_view;
+    return *this;
   }
 
   template <typename OverrideContribution = Contribution>
diff --git a/containers/src/Kokkos_UnorderedMap.hpp b/containers/src/Kokkos_UnorderedMap.hpp
index 058b6626c4..aa62d32557 100644
--- a/containers/src/Kokkos_UnorderedMap.hpp
+++ b/containers/src/Kokkos_UnorderedMap.hpp
@@ -119,6 +119,36 @@ class UnorderedMapInsertResult {
   uint32_t m_status;
 };
 
+/// \class UnorderedMapInsertOpTypes
+///
+/// \brief Operations applied to the values array upon subsequent insertions.
+///
+/// The default behavior when a k,v pair already exists in the UnorderedMap is
+/// to perform no operation. Alternatively, the caller may select to
+/// instantiate the UnorderedMap with the AtomicAdd insert operator such that
+/// duplicate keys accumulate values into the given values array entry.
+/// \tparam ValueTypeView The UnorderedMap value array type.
+/// \tparam ValuesIdxType The index type for lookups in the value array.
+///
+/// Supported operations:
+///   NoOp:      the first key inserted stores the associated value.
+///   AtomicAdd: duplicate key insertions sum values together.
+template <class ValueTypeView, class ValuesIdxType>
+struct UnorderedMapInsertOpTypes {
+  using value_type = typename ValueTypeView::non_const_value_type;
+  struct NoOp {
+    KOKKOS_FUNCTION
+    void op(ValueTypeView, ValuesIdxType, const value_type) const {}
+  };
+  struct AtomicAdd {
+    KOKKOS_FUNCTION
+    void op(ValueTypeView values, ValuesIdxType values_idx,
+            const value_type v) const {
+      Kokkos::atomic_add(values.data() + values_idx, v);
+    }
+  };
+};
+
 /// \class UnorderedMap
 /// \brief Thread-safe, performance-portable lookup table.
 ///
@@ -186,7 +216,6 @@ class UnorderedMap {
  public:
   //! \name Public types and constants
   //@{
-
   // key_types
   using declared_key_type = Key;
   using key_type          = std::remove_const_t<declared_key_type>;
@@ -232,7 +261,6 @@ class UnorderedMap {
       UnorderedMap<Key, Value, host_mirror_space, Hasher, EqualTo>;
 
   using histogram_type = Impl::UnorderedMapHistogram<const_map_type>;
-
   //@}
 
  private:
@@ -263,19 +291,23 @@ class UnorderedMap {
  public:
   //! \name Public member functions
   //@{
+  using default_op_type =
+      typename UnorderedMapInsertOpTypes<value_type_view, uint32_t>::NoOp;
 
   /// \brief Constructor
   ///
   /// \param capacity_hint [in] Initial guess of how many unique keys will be
-  /// inserted into the map \param hash [in] Hasher function for \c Key
-  /// instances.  The
-  ///   default value usually suffices.
+  ///                           inserted into the map.
+  /// \param hash          [in] Hasher function for \c Key instances.  The
+  ///                           default value usually suffices.
+  /// \param equal_to      [in] The operator used for determining if two
+  ///                           keys are equal.
   UnorderedMap(size_type capacity_hint = 0, hasher_type hasher = hasher_type(),
                equal_to_type equal_to = equal_to_type())
       : m_bounded_insert(true),
         m_hasher(hasher),
         m_equal_to(equal_to),
-        m_size(),
+        m_size("UnorderedMap size"),
         m_available_indexes(calculate_capacity(capacity_hint)),
         m_hash_lists(view_alloc(WithoutInitializing, "UnorderedMap hash list"),
                      Impl::find_hash_size(capacity())),
@@ -315,7 +347,7 @@ class UnorderedMap {
       Kokkos::deep_copy(m_keys, tmp);
     }
     Kokkos::deep_copy(m_scalars, 0);
-    m_size = 0;
+    m_size() = 0;
   }
 
   KOKKOS_INLINE_FUNCTION constexpr bool is_allocated() const {
@@ -369,10 +401,10 @@ class UnorderedMap {
   size_type size() const {
     if (capacity() == 0u) return 0u;
     if (modified()) {
-      m_size = m_available_indexes.count();
+      m_size() = m_available_indexes.count();
       reset_flag(modified_idx);
     }
-    return m_size;
+    return m_size();
   }
 
   /// \brief The current number of failed insert() calls.
@@ -442,9 +474,18 @@ class UnorderedMap {
   /// \param v [in] The corresponding value to attempt to insert.  If
   ///   using this class as a set (with Value = void), then you need not
   ///   provide this value.
-  KOKKOS_INLINE_FUNCTION
-  insert_result insert(key_type const &k,
-                       impl_value_type const &v = impl_value_type()) const {
+  /// \param insert_op [in] The operator used for combining values if a
+  ///                       key already exists. See
+  ///                       Kokkos::UnorderedMapInsertOpTypes for more ops.
+  template <typename InsertOpType = default_op_type>
+  KOKKOS_INLINE_FUNCTION insert_result
+  insert(key_type const &k, impl_value_type const &v = impl_value_type(),
+         [[maybe_unused]] InsertOpType arg_insert_op = InsertOpType()) const {
+    if constexpr (is_set) {
+      static_assert(std::is_same_v<InsertOpType, default_op_type>,
+                    "Insert Operations are not supported on sets.");
+    }
+
     insert_result result;
 
     if (!is_insertable_map || capacity() == 0u ||
@@ -532,6 +573,9 @@ class UnorderedMap {
         }
 
         result.set_existing(curr, free_existing);
+        if constexpr (!is_set) {
+          arg_insert_op.op(m_values, curr, v);
+        }
         not_done = false;
       }
       //------------------------------------------------------------
@@ -725,7 +769,7 @@ class UnorderedMap {
       tmp.m_bounded_insert    = src.m_bounded_insert;
       tmp.m_hasher            = src.m_hasher;
       tmp.m_equal_to          = src.m_equal_to;
-      tmp.m_size              = src.size();
+      tmp.m_size()            = src.m_size();
       tmp.m_available_indexes = bitset_type(src.capacity());
       tmp.m_hash_lists        = size_type_view(
           view_alloc(WithoutInitializing, "UnorderedMap hash list"),
@@ -818,7 +862,7 @@ class UnorderedMap {
   bool m_bounded_insert;
   hasher_type m_hasher;
   equal_to_type m_equal_to;
-  mutable size_type m_size;
+  View<size_type, HostSpace> m_size;
   bitset_type m_available_indexes;
   size_type_view m_hash_lists;
   size_type_view m_next_index;
diff --git a/containers/src/Kokkos_Vector.hpp b/containers/src/Kokkos_Vector.hpp
index 29bb15f5ea..9c9cde3a55 100644
--- a/containers/src/Kokkos_Vector.hpp
+++ b/containers/src/Kokkos_Vector.hpp
@@ -196,10 +196,16 @@ class vector : public DualView<Scalar*, LayoutLeft, Arg1Type> {
 
   iterator begin() const { return DV::h_view.data(); }
 
+  const_iterator cbegin() const { return DV::h_view.data(); }
+
   iterator end() const {
     return _size > 0 ? DV::h_view.data() + _size : DV::h_view.data();
   }
 
+  const_iterator cend() const {
+    return _size > 0 ? DV::h_view.data() + _size : DV::h_view.data();
+  }
+
   reference front() { return DV::h_view(0); }
 
   reference back() { return DV::h_view(_size - 1); }
diff --git a/containers/unit_tests/CMakeLists.txt b/containers/unit_tests/CMakeLists.txt
index 261d9dcd42..161f7be93e 100644
--- a/containers/unit_tests/CMakeLists.txt
+++ b/containers/unit_tests/CMakeLists.txt
@@ -43,15 +43,17 @@ foreach(Tag Threads;Serial;OpenMP;HPX;Cuda;HIP;SYCL)
      LIST(REMOVE_ITEM UnitTestSources ${dir}/TestCuda_DynViewAPI_generic.cpp)
     endif()
 
-    KOKKOS_ADD_EXECUTABLE_AND_TEST(UnitTest_${Tag} SOURCES ${UnitTestSources})
+    KOKKOS_ADD_EXECUTABLE_AND_TEST(ContainersUnitTest_${Tag} SOURCES ${UnitTestSources})
   endif()
 endforeach()
 
 SET(COMPILE_ONLY_SOURCES
   TestCreateMirror.cpp
+  TestDualViewParameterPack.cpp
+  TestIsViewTrait.cpp
 )
 KOKKOS_ADD_EXECUTABLE(
-  TestCompileOnly
+  ContainersTestCompileOnly
   SOURCES
   TestCompileMain.cpp
   ${COMPILE_ONLY_SOURCES}
diff --git a/containers/unit_tests/TestDualViewParameterPack.cpp b/containers/unit_tests/TestDualViewParameterPack.cpp
new file mode 100644
index 0000000000..861eba2b3e
--- /dev/null
+++ b/containers/unit_tests/TestDualViewParameterPack.cpp
@@ -0,0 +1,43 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_DualView.hpp>
+
+namespace {
+
+template <class DataType, class Arg1Type = void, class Arg2Type = void,
+          class Arg3Type = void>
+void not_supported_anymore(
+    Kokkos::DualView<DataType, Arg1Type, Arg2Type, Arg2Type> x) {
+  static_assert(Kokkos::is_dual_view_v<decltype(x)>);
+}
+
+template <class DataType, class... Properties>
+void prefer_instead(Kokkos::DualView<DataType, Properties...> x) {
+  static_assert(Kokkos::is_dual_view_v<decltype(x)>);
+}
+
+using KDV = Kokkos::DualView<int*>;
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+static_assert(
+    std::is_void_v<decltype(not_supported_anymore(std::declval<KDV>()))>);
+#endif
+
+static_assert(std::is_void_v<decltype(prefer_instead(std::declval<KDV>()))>);
+
+}  // namespace
diff --git a/containers/unit_tests/TestDynViewAPI.hpp b/containers/unit_tests/TestDynViewAPI.hpp
index c7a5b13dbb..4ecb6cf25c 100644
--- a/containers/unit_tests/TestDynViewAPI.hpp
+++ b/containers/unit_tests/TestDynViewAPI.hpp
@@ -1200,19 +1200,19 @@ class TestDynViewAPI {
 
     View7 vtest1("vtest1", 2, 2, 2, 2, 2, 2, 2);
     dView0 dfromv1(vtest1);
-    ASSERT_EQ(dfromv1.rank(), vtest1.Rank);
+    ASSERT_EQ(dfromv1.rank(), vtest1.rank);
     ASSERT_EQ(dfromv1.extent(0), vtest1.extent(0));
     ASSERT_EQ(dfromv1.extent(1), vtest1.extent(1));
     ASSERT_EQ(dfromv1.use_count(), vtest1.use_count());
 
     dView0 dfromv2(vcast);
-    ASSERT_EQ(dfromv2.rank(), vcast.Rank);
+    ASSERT_EQ(dfromv2.rank(), vcast.rank);
     ASSERT_EQ(dfromv2.extent(0), vcast.extent(0));
     ASSERT_EQ(dfromv2.extent(1), vcast.extent(1));
     ASSERT_EQ(dfromv2.use_count(), vcast.use_count());
 
     dView0 dfromv3 = vcast1;
-    ASSERT_EQ(dfromv3.rank(), vcast1.Rank);
+    ASSERT_EQ(dfromv3.rank(), vcast1.rank);
     ASSERT_EQ(dfromv3.extent(0), vcast1.extent(0));
     ASSERT_EQ(dfromv3.extent(1), vcast1.extent(1));
     ASSERT_EQ(dfromv3.use_count(), vcast1.use_count());
diff --git a/containers/unit_tests/TestDynViewAPI_rank12345.hpp b/containers/unit_tests/TestDynViewAPI_rank12345.hpp
index d6019e8239..9cefad190a 100644
--- a/containers/unit_tests/TestDynViewAPI_rank12345.hpp
+++ b/containers/unit_tests/TestDynViewAPI_rank12345.hpp
@@ -20,4 +20,56 @@ namespace Test {
 TEST(TEST_CATEGORY, dyn_rank_view_api_operator_rank12345) {
   TestDynViewAPI<double, TEST_EXECSPACE>::run_operator_test_rank12345();
 }
+
+template <typename SharedMemorySpace>
+void test_dyn_rank_view_resize() {
+  int n = 1000;
+  Kokkos::DynRankView<double, SharedMemorySpace> device_view("device view", n);
+  // Make sure we don't deallocate memory in Kokkos::resize
+  auto device_view_copy = device_view;
+
+  Kokkos::resize(device_view, 2 * n);
+
+  // Loop in reverse to increase likelihood of missing fence detection assuming
+  // that resize copies values in order.
+  for (int i = 2 * n - 1; i >= 0; --i) device_view(i) = i + 1;
+
+  Kokkos::fence();
+
+  // Check that Kokkos::resize completed before setting the values on the host
+  // manually (possibly because of missing fences).
+  for (int i = 0; i < 2 * n; ++i) ASSERT_EQ(device_view(i), i + 1);
+}
+
+template <typename SharedMemorySpace>
+void test_dyn_rank_view_realloc() {
+  int n = 1000;
+  Kokkos::DynRankView<double, SharedMemorySpace> device_view("device view", n);
+  // Make sure we don't deallocate memory in Kokkos::realloc
+  auto device_view_copy = device_view;
+
+  Kokkos::realloc(device_view, 2 * n);
+
+  // Loop in reverse to increase likelihood of missing fence detection assuming
+  // that realloc sets values in order.
+  for (int i = 2 * n - 1; i >= 0; --i) device_view(i) = i + 1;
+
+  Kokkos::fence();
+
+  // Check that Kokkos::realloc completed before setting the values on the host
+  // manually (possibly because of missing fences).
+  for (int i = 0; i < 2 * n; ++i) ASSERT_EQ(device_view(i), i + 1);
+}
+
+#ifdef KOKKOS_HAS_SHARED_SPACE
+TEST(TEST_CATEGORY, dyn_rank_view_check_fence_resize_realloc) {
+  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::DefaultExecutionSpace>) {
+    test_dyn_rank_view_resize<Kokkos::SharedSpace>();
+    test_dyn_rank_view_realloc<Kokkos::SharedSpace>();
+  } else {
+    GTEST_SKIP() << "skipping since not default execution space";
+  }
+}
+#endif
+
 }  // namespace Test
diff --git a/containers/unit_tests/TestDynamicView.hpp b/containers/unit_tests/TestDynamicView.hpp
index cd1511276f..c8f8fed3b8 100644
--- a/containers/unit_tests/TestDynamicView.hpp
+++ b/containers/unit_tests/TestDynamicView.hpp
@@ -274,19 +274,13 @@ struct TestDynamicView {
       // swapped in the deep_copy implementation.
       // Once that's fixed, both deep_copy's will fail at runtime because the
       // destination execution space cannot access the source memory space.
-      try {
-        Kokkos::deep_copy(host_view, device_dynamic_view);
-      } catch (std::runtime_error const& error) {
-        std::string msg = error.what();
-        std::cerr << "Copy from on-device DynamicView to on-host View failed:\n"
-                  << msg << std::endl;
-      }
-      try {
-        Kokkos::deep_copy(device_dynamic_view, host_view);
-      } catch (std::runtime_error const& error) {
-        std::string msg = error.what();
-        std::cerr << "Copy from on-host View to on-device DynamicView failed:\n"
-                  << msg << std::endl;
+      // Check if the memory spaces are different before testing the deep_copy.
+      if (!Kokkos::SpaceAccessibility<Kokkos::HostSpace,
+                                      memory_space>::accessible) {
+        ASSERT_THROW(Kokkos::deep_copy(host_view, device_dynamic_view),
+                     std::runtime_error);
+        ASSERT_THROW(Kokkos::deep_copy(device_dynamic_view, host_view),
+                     std::runtime_error);
       }
     }
   }
diff --git a/containers/unit_tests/TestIsViewTrait.cpp b/containers/unit_tests/TestIsViewTrait.cpp
new file mode 100644
index 0000000000..994ba7ca0c
--- /dev/null
+++ b/containers/unit_tests/TestIsViewTrait.cpp
@@ -0,0 +1,68 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_DualView.hpp>
+#include <Kokkos_DynRankView.hpp>
+#include <Kokkos_DynamicView.hpp>
+#include <Kokkos_OffsetView.hpp>
+#include <Kokkos_ScatterView.hpp>
+
+namespace {
+
+using view_t          = Kokkos::View<int*>;
+using dual_view_t     = Kokkos::DualView<int*>;
+using dyn_rank_view_t = Kokkos::DynRankView<int*>;
+using dynamic_view_t  = Kokkos::Experimental::DynamicView<int*>;
+using offset_view_t   = Kokkos::Experimental::OffsetView<int*>;
+using scatter_view_t  = Kokkos::Experimental::ScatterView<int*>;
+
+static_assert(Kokkos::is_dual_view_v<dual_view_t>);
+static_assert(!Kokkos::is_dyn_rank_view_v<dual_view_t>);
+static_assert(!Kokkos::is_dynamic_view_v<dual_view_t>);
+static_assert(!Kokkos::Experimental::is_offset_view_v<dual_view_t>);
+static_assert(!Kokkos::Experimental::is_scatter_view_v<dual_view_t>);
+static_assert(!Kokkos::is_view_v<dual_view_t>);
+
+static_assert(!Kokkos::is_dual_view_v<dyn_rank_view_t>);
+static_assert(Kokkos::is_dyn_rank_view_v<dyn_rank_view_t>);
+static_assert(!Kokkos::is_dynamic_view_v<dyn_rank_view_t>);
+static_assert(!Kokkos::Experimental::is_offset_view_v<dyn_rank_view_t>);
+static_assert(!Kokkos::Experimental::is_scatter_view_v<dyn_rank_view_t>);
+static_assert(!Kokkos::is_view_v<dyn_rank_view_t>);
+
+static_assert(!Kokkos::is_dual_view_v<dynamic_view_t>);
+static_assert(!Kokkos::is_dyn_rank_view_v<dynamic_view_t>);
+static_assert(Kokkos::is_dynamic_view_v<dynamic_view_t>);
+static_assert(!Kokkos::Experimental::is_offset_view_v<dynamic_view_t>);
+static_assert(!Kokkos::Experimental::is_scatter_view_v<dynamic_view_t>);
+static_assert(!Kokkos::is_view_v<dynamic_view_t>);
+
+static_assert(!Kokkos::is_dual_view_v<offset_view_t>);
+static_assert(!Kokkos::is_dyn_rank_view_v<offset_view_t>);
+static_assert(!Kokkos::is_dynamic_view_v<offset_view_t>);
+static_assert(Kokkos::Experimental::is_offset_view_v<offset_view_t>);
+static_assert(!Kokkos::Experimental::is_scatter_view_v<offset_view_t>);
+static_assert(!Kokkos::is_view_v<offset_view_t>);
+
+static_assert(!Kokkos::is_dual_view_v<scatter_view_t>);
+static_assert(!Kokkos::is_dyn_rank_view_v<scatter_view_t>);
+static_assert(!Kokkos::is_dynamic_view_v<scatter_view_t>);
+static_assert(!Kokkos::Experimental::is_offset_view_v<scatter_view_t>);
+static_assert(Kokkos::Experimental::is_scatter_view_v<scatter_view_t>);
+static_assert(!Kokkos::is_view_v<scatter_view_t>);
+
+}  // namespace
diff --git a/containers/unit_tests/TestScatterView.hpp b/containers/unit_tests/TestScatterView.hpp
index 347e914ea5..733f43122c 100644
--- a/containers/unit_tests/TestScatterView.hpp
+++ b/containers/unit_tests/TestScatterView.hpp
@@ -726,9 +726,9 @@ void test_scatter_view(int64_t n) {
   }
 #endif
   // with hundreds of threads we were running out of memory.
-  // limit (n) so that duplication doesn't exceed 4GB
+  // limit (n) so that duplication doesn't exceed 1GB
   constexpr std::size_t maximum_allowed_total_bytes =
-      4ull * 1024ull * 1024ull * 1024ull;
+      1ull * 1024ull * 1024ull * 1024ull;
   std::size_t const maximum_allowed_copy_bytes =
       maximum_allowed_total_bytes /
       std::size_t(execution_space().concurrency());
@@ -770,9 +770,18 @@ TEST(TEST_CATEGORY, scatterview) {
   int big_n = 100 * 1000;
 #else
 
-#ifdef KOKKOS_ENABLE_SERIAL
+#if defined(KOKKOS_ENABLE_SERIAL) || defined(KOKKOS_ENABLE_OPENMP)
+#if defined(KOKKOS_ENABLE_SERIAL)
   bool is_serial = std::is_same<TEST_EXECSPACE, Kokkos::Serial>::value;
-  int big_n      = is_serial ? 100 * 1000 : 10000 * 1000;
+#else
+  bool is_serial = false;
+#endif
+#if defined(KOKKOS_ENABLE_OPENMP)
+  bool is_openmp = std::is_same<TEST_EXECSPACE, Kokkos::OpenMP>::value;
+#else
+  bool is_openmp = false;
+#endif
+  int big_n      = is_serial || is_openmp ? 100 * 1000 : 10000 * 1000;
 #else
   int big_n = 10000 * 1000;
 #endif
diff --git a/containers/unit_tests/TestUnorderedMap.hpp b/containers/unit_tests/TestUnorderedMap.hpp
index 989779b53a..296c9f42ac 100644
--- a/containers/unit_tests/TestUnorderedMap.hpp
+++ b/containers/unit_tests/TestUnorderedMap.hpp
@@ -25,18 +25,31 @@ namespace Test {
 
 namespace Impl {
 
-template <typename MapType, bool Near = false>
+template <typename MapType,
+          typename InsertOp = typename MapType::default_op_type,
+          bool Near = false, bool CheckValues = false>
 struct TestInsert {
   using map_type        = MapType;
   using execution_space = typename map_type::execution_space;
   using value_type      = uint32_t;
 
+  struct ExpectedValues {
+    unsigned map_idx;
+    typename map_type::value_type v;
+  };
+  using expected_values_type = Kokkos::View<ExpectedValues *, execution_space>;
+  expected_values_type expected_values;
+
   map_type map;
   uint32_t inserts;
   uint32_t collisions;
+  InsertOp insert_op;
 
   TestInsert(map_type arg_map, uint32_t arg_inserts, uint32_t arg_collisions)
-      : map(arg_map), inserts(arg_inserts), collisions(arg_collisions) {}
+      : map(arg_map), inserts(arg_inserts), collisions(arg_collisions) {
+    auto len = map.capacity() > arg_inserts ? map.capacity() : arg_inserts;
+    expected_values = expected_values_type("ExpectedValues", len);
+  }
 
   void testit(bool rehash_on_fail = true) {
     execution_space().fence();
@@ -54,7 +67,29 @@ struct TestInsert {
       }
     } while (rehash_on_fail && failed_count > 0u);
 
+    // Trigger the m_size mutable bug.
+    typename map_type::HostMirror map_h;
     execution_space().fence();
+    Kokkos::deep_copy(map_h, map);
+    execution_space().fence();
+    ASSERT_EQ(map_h.size(), map.size());
+
+    if (!rehash_on_fail && CheckValues) {
+      typename expected_values_type::HostMirror expected_values_h =
+          create_mirror_view(expected_values);
+      Kokkos::deep_copy(expected_values_h, expected_values);
+      for (unsigned i = 0; i < map_h.size(); i++) {
+        auto map_idx = expected_values_h(i).map_idx;
+        if (map_idx != static_cast<unsigned>(~0)) {
+          ASSERT_EQ(expected_values_h(map_idx).v, map_h.value_at(map_idx));
+        }
+      }
+    }
+
+    const unsigned int old_size = map_h.size();
+    map_h.clear();
+    ASSERT_EQ(map.size(), old_size);
+    ASSERT_EQ(map_h.size(), 0u);
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -65,10 +100,47 @@ struct TestInsert {
     failed_count += count;
   }
 
+  template <typename UmapOpType = InsertOp>
+  KOKKOS_FORCEINLINE_FUNCTION bool is_op_noop() const {
+    using vt             = typename map_type::value_type;
+    using Device         = typename map_type::device_type;
+    using UmapOpTypeArg1 = Kokkos::View<
+        std::remove_const_t<std::conditional_t<std::is_void_v<vt>, int, vt>> *,
+        Device>;
+    return std::is_base_of_v<
+        InsertOp, typename Kokkos::UnorderedMapInsertOpTypes<UmapOpTypeArg1,
+                                                             uint32_t>::NoOp>;
+  }
+
+  template <typename UmapOpType = InsertOp>
+  KOKKOS_FORCEINLINE_FUNCTION bool is_op_atomic_add() const {
+    using vt             = typename map_type::value_type;
+    using Device         = typename map_type::device_type;
+    using UmapOpTypeArg1 = Kokkos::View<
+        std::remove_const_t<std::conditional_t<std::is_void_v<vt>, int, vt>> *,
+        Device>;
+    return std::is_base_of_v<UmapOpType,
+                             typename Kokkos::UnorderedMapInsertOpTypes<
+                                 UmapOpTypeArg1, uint32_t>::AtomicAdd>;
+  }
+
   KOKKOS_INLINE_FUNCTION
   void operator()(uint32_t i, value_type &failed_count) const {
     const uint32_t key = Near ? i / collisions : i % (inserts / collisions);
-    if (map.insert(key, i).failed()) ++failed_count;
+    auto ret           = map.insert(key, i, insert_op);
+    if (ret.failed()) {
+      ++failed_count;
+      expected_values(i).map_idx = static_cast<unsigned>(~0);
+    } else if (CheckValues) {
+      auto map_idx                     = map.find(key);
+      expected_values(map_idx).map_idx = map_idx;
+      auto ptr                         = expected_values.data();
+      if (is_op_atomic_add()) {
+        Kokkos::atomic_add(&((ptr + map_idx)[0].v), i);
+      } else if (ret.success() && is_op_noop()) {
+        Kokkos::atomic_store(&((ptr + map_idx)[0].v), i);
+      }
+    }
   }
 };
 
@@ -149,26 +221,26 @@ struct TestFind {
 // MSVC reports a syntax error for this test.
 // WORKAROUND MSVC
 #ifndef _WIN32
-template <typename Device>
+template <typename Device, class map_type, class const_map_type,
+          class insert_op_type, bool check_values = false>
 void test_insert(uint32_t num_nodes, uint32_t num_inserts,
                  uint32_t num_duplicates, bool near) {
-  using map_type = Kokkos::UnorderedMap<uint32_t, uint32_t, Device>;
-  using const_map_type =
-      Kokkos::UnorderedMap<const uint32_t, const uint32_t, Device>;
-
   const uint32_t expected_inserts =
       (num_inserts + num_duplicates - 1u) / num_duplicates;
+  typename map_type::size_type arg_capacity_hint = 0;
+  typename map_type::hasher_type arg_hasher;
+  typename map_type::equal_to_type arg_equal_to;
 
-  map_type map;
+  map_type map(arg_capacity_hint, arg_hasher, arg_equal_to);
   map.rehash(num_nodes, false);
 
   if (near) {
-    Impl::TestInsert<map_type, true> test_insert(map, num_inserts,
-                                                 num_duplicates);
+    Impl::TestInsert<map_type, insert_op_type, true, check_values> test_insert(
+        map, num_inserts, num_duplicates);
     test_insert.testit();
   } else {
-    Impl::TestInsert<map_type, false> test_insert(map, num_inserts,
-                                                  num_duplicates);
+    Impl::TestInsert<map_type, insert_op_type, false, check_values> test_insert(
+        map, num_inserts, num_duplicates);
     test_insert.testit();
   }
 
@@ -186,8 +258,7 @@ void test_insert(uint32_t num_nodes, uint32_t num_inserts,
 
     {
       uint32_t find_errors = 0;
-      Impl::TestFind<const_map_type> test_find(map, num_inserts,
-                                               num_duplicates);
+      Impl::TestFind<map_type> test_find(map, num_inserts, num_duplicates);
       test_find.testit(find_errors);
       EXPECT_EQ(0u, find_errors);
     }
@@ -199,6 +270,64 @@ void test_insert(uint32_t num_nodes, uint32_t num_inserts,
     map.end_erase();
     EXPECT_EQ(0u, map.size());
   }
+
+  // Check the values from the insert operation
+  {
+    Impl::TestInsert<map_type, insert_op_type, true> test_insert(
+        map, num_inserts, num_duplicates);
+    test_insert.testit(false);
+  }
+}
+
+template <typename Device>
+void test_inserts(uint32_t num_nodes, uint32_t num_inserts,
+                  uint32_t num_duplicates, bool near) {
+  using key_type        = uint32_t;
+  using value_type      = uint32_t;
+  using value_view_type = Kokkos::View<value_type *, Device>;
+  using size_type       = uint32_t;
+  using hasher_type     = typename Kokkos::pod_hash<key_type>;
+  using equal_to_type   = typename Kokkos::pod_equal_to<key_type>;
+
+  using map_op_type =
+      Kokkos::UnorderedMapInsertOpTypes<value_view_type, size_type>;
+  using noop_type = typename map_op_type::NoOp;
+
+  using map_type = Kokkos::UnorderedMap<key_type, value_type, Device,
+                                        hasher_type, equal_to_type>;
+  using const_map_type =
+      Kokkos::UnorderedMap<const key_type, const value_type, Device,
+                           hasher_type, equal_to_type>;
+
+  test_insert<Device, map_type, const_map_type, noop_type>(
+      num_nodes, num_inserts, num_duplicates, near);
+}
+
+template <typename Device>
+void test_all_insert_ops(uint32_t num_nodes, uint32_t num_inserts,
+                         uint32_t num_duplicates, bool near) {
+  using key_type        = uint32_t;
+  using value_type      = uint32_t;
+  using value_view_type = Kokkos::View<value_type *, Device>;
+  using size_type       = uint32_t;
+  using hasher_type     = typename Kokkos::pod_hash<key_type>;
+  using equal_to_type   = typename Kokkos::pod_equal_to<key_type>;
+
+  using map_op_type =
+      Kokkos::UnorderedMapInsertOpTypes<value_view_type, size_type>;
+  using noop_type       = typename map_op_type::NoOp;
+  using atomic_add_type = typename map_op_type::AtomicAdd;
+
+  using map_type = Kokkos::UnorderedMap<key_type, value_type, Device,
+                                        hasher_type, equal_to_type>;
+  using const_map_type =
+      Kokkos::UnorderedMap<const key_type, const value_type, Device,
+                           hasher_type, equal_to_type>;
+
+  test_insert<Device, map_type, const_map_type, noop_type, true>(
+      num_nodes, num_inserts, num_duplicates, near);
+  test_insert<Device, map_type, const_map_type, atomic_add_type, true>(
+      num_nodes, num_inserts, num_duplicates, near);
 }
 #endif
 
@@ -274,8 +403,12 @@ TEST(TEST_CATEGORY, UnorderedMap_insert) {
   }
 #endif
   for (int i = 0; i < 500; ++i) {
-    test_insert<TEST_EXECSPACE>(100000, 90000, 100, true);
-    test_insert<TEST_EXECSPACE>(100000, 90000, 100, false);
+    test_inserts<TEST_EXECSPACE>(100000, 90000, 100, true);
+    test_inserts<TEST_EXECSPACE>(100000, 90000, 100, false);
+  }
+  for (int i = 0; i < 5; ++i) {
+    test_all_insert_ops<TEST_EXECSPACE>(1000, 900, 10, true);
+    test_all_insert_ops<TEST_EXECSPACE>(1000, 900, 10, false);
   }
 }
 #endif
@@ -328,6 +461,64 @@ TEST(TEST_CATEGORY, UnorderedMap_clear_zero_size) {
   ASSERT_EQ(0u, m.size());
 }
 
+TEST(TEST_CATEGORY, UnorderedMap_consistent_size) {
+  using Map =
+      Kokkos::UnorderedMap<int, void, Kokkos::DefaultHostExecutionSpace>;
+
+  Map m(11);
+  m.insert(7);
+  ;
+  ASSERT_EQ(1u, m.size());
+
+  {
+    auto m2 = m;
+    m2.insert(2);
+    // This line triggers modified flags to be cleared in both m and m2
+    [[maybe_unused]] auto sz = m2.size();
+  }
+
+  ASSERT_EQ(2u, m.size());
+}
+
+struct TestMapCopy {
+  using map_type = Kokkos::UnorderedMap<int, void, TEST_EXECSPACE>;
+  map_type m_map;
+
+  KOKKOS_FUNCTION
+  void test_insert_to_map_copy(map_type const &input_map, const int i) const {
+    auto map = input_map;
+    map.insert(i);
+  }
+
+  KOKKOS_FUNCTION
+  void operator()(const int i) const { test_insert_to_map_copy(m_map, i); }
+};
+
+TEST(TEST_CATEGORY, UnorderedMap_shallow_copyable_on_device) {
+  TestMapCopy test_map_copy;
+
+  Kokkos::parallel_for(Kokkos::RangePolicy<TEST_EXECSPACE>(0, 1),
+                       test_map_copy);
+  ASSERT_EQ(1u, test_map_copy.m_map.size());
+}
+
+#if !defined(KOKKOS_ENABLE_CUDA) || \
+    (defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_CUDA_LAMBDA))
+void test_unordered_map_device_capture() {
+  TestMapCopy::map_type map;
+
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<TEST_EXECSPACE>(0, 1),
+      KOKKOS_LAMBDA(int const i) { map.insert(i); });
+
+  ASSERT_EQ(1u, map.size());
+}
+
+TEST(TEST_CATEGORY, UnorderedMap_lambda_capturable) {
+  test_unordered_map_device_capture();
+}
+#endif
+
 }  // namespace Test
 
 #endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/containers/unit_tests/TestVector.hpp b/containers/unit_tests/TestVector.hpp
index fa59607484..a7d341b789 100644
--- a/containers/unit_tests/TestVector.hpp
+++ b/containers/unit_tests/TestVector.hpp
@@ -49,61 +49,27 @@ struct test_vector_insert {
 
     it = a.begin();
     it += 17;
-// Looks like some std::vector implementations do not have the restriction
-// right on the overload taking three iterators, and thus the following call
-// will hit that overload and then fail to compile.
-#if defined(KOKKOS_COMPILER_INTEL)
-// And at least GCC 4.8.4 doesn't implement vector insert correct for C++11
-// Return type is void ...
-#if (__GNUC__ < 5)
-    a.insert(it, typename Vector::size_type(n + 5), scalar_type(5));
-    it_return = a.begin() + 17;
-#else
-    it_return = a.insert(it, typename Vector::size_type(n + 5), scalar_type(5));
-#endif
-#else
-#if (__GNUC__ < 5)
-    a.insert(it, n + 5, scalar_type(5));
-    it_return = a.begin() + 17;
-#else
     it_return = a.insert(it, n + 5, scalar_type(5));
-#endif
-#endif
 
     ASSERT_EQ(a.size(), n + 1 + n + 5);
-    ASSERT_EQ(std::distance(it_return, a.begin() + 17), 0u);
+    ASSERT_EQ(std::distance(it_return, a.begin() + 17), 0);
 
     Vector b;
 
-// Looks like some std::vector implementations do not have the restriction
-// right on the overload taking three iterators, and thus the following call
-// will hit that overload and then fail to compile.
-#if defined(KOKKOS_COMPILER_INTEL)
-    b.insert(b.begin(), typename Vector::size_type(7), 9);
-#else
     b.insert(b.begin(), 7, 9);
-#endif
     ASSERT_EQ(b.size(), 7u);
     ASSERT_EQ(b[0], scalar_type(9));
 
     it = a.begin();
     it += 27 + n;
-#if (__GNUC__ < 5)
-    a.insert(it, b.begin(), b.end());
-    it_return = a.begin() + (27 + n);
-#else
     it_return = a.insert(it, b.begin(), b.end());
-#endif
+
     ASSERT_EQ(a.size(), n + 1 + n + 5 + 7);
-    ASSERT_EQ(std::distance(it_return, a.begin() + 27 + n), 0u);
+    ASSERT_EQ(std::distance(it_return, a.begin() + 27 + n), 0);
 
     // Testing insert at end via all three function interfaces
     a.insert(a.end(), 11);
-#if defined(KOKKOS_COMPILER_INTEL)
-    a.insert(a.end(), typename Vector::size_type(2), 12);
-#else
     a.insert(a.end(), 2, 12);
-#endif
     a.insert(a.end(), b.begin(), b.end());
   }
 
diff --git a/containers/unit_tests/TestWithoutInitializing.hpp b/containers/unit_tests/TestWithoutInitializing.hpp
index d3bb05195c..7201cd402a 100644
--- a/containers/unit_tests/TestWithoutInitializing.hpp
+++ b/containers/unit_tests/TestWithoutInitializing.hpp
@@ -24,6 +24,19 @@
 
 #include <../../core/unit_test/tools/include/ToolTestingUtilities.hpp>
 
+/// Some tests are skipped for @c CudaUVM memory space.
+/// @todo To be revised according to the future of @c KOKKOS_ENABLE_CUDA_UVM.
+///@{
+#ifdef KOKKOS_ENABLE_CUDA
+#define GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE                            \
+  if constexpr (std::is_same_v<typename TEST_EXECSPACE::memory_space, \
+                               Kokkos::CudaUVMSpace>)                 \
+    GTEST_SKIP() << "skipping since CudaUVMSpace requires additional fences";
+#else
+#define GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
+#endif
+///@}
+
 TEST(TEST_CATEGORY, resize_realloc_no_init_dualview) {
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableKernels());
@@ -125,11 +138,7 @@ TEST(TEST_CATEGORY, resize_exec_space_dualview) {
 }
 
 TEST(TEST_CATEGORY, realloc_exec_space_dualview) {
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<typename TEST_EXECSPACE::memory_space,
-                   Kokkos::CudaUVMSpace>::value)
-    GTEST_SKIP() << "skipping since CudaUVMSpace requires additional fences";
-#endif
+  GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
 
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableFences());
@@ -221,11 +230,8 @@ TEST(TEST_CATEGORY, resize_exec_space_dynrankview) {
 }
 
 TEST(TEST_CATEGORY, realloc_exec_space_dynrankview) {
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<typename TEST_EXECSPACE::memory_space,
-                   Kokkos::CudaUVMSpace>::value)
-    GTEST_SKIP() << "skipping since CudaUVMSpace requires additional fences";
-#endif
+  GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
+
 // FIXME_THREADS The Threads backend fences every parallel_for
 #ifdef KOKKOS_ENABLE_THREADS
   if (std::is_same<TEST_EXECSPACE, Kokkos::Threads>::value)
@@ -363,16 +369,20 @@ TEST(TEST_CATEGORY, resize_exec_space_scatterview) {
 }
 
 TEST(TEST_CATEGORY, realloc_exec_space_scatterview) {
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<typename TEST_EXECSPACE::memory_space,
-                   Kokkos::CudaUVMSpace>::value)
-    GTEST_SKIP() << "skipping since CudaUVMSpace requires additional fences";
-#endif
+  GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
+
 // FIXME_THREADS The Threads backend fences every parallel_for
 #ifdef KOKKOS_ENABLE_THREADS
   if (std::is_same<typename TEST_EXECSPACE, Kokkos::Threads>::value)
     GTEST_SKIP() << "skipping since the Threads backend isn't asynchronous";
 #endif
+#if defined(KOKKOS_ENABLE_HPX) && \
+    !defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+  if (std::is_same<Kokkos::DefaultExecutionSpace,
+                   Kokkos::Experimental::HPX>::value)
+    GTEST_SKIP() << "skipping since the HPX backend always fences with async "
+                    "dispatch disabled";
+#endif
 
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableFences());
@@ -470,11 +480,8 @@ TEST(TEST_CATEGORY, create_mirror_no_init_dynrankview_viewctor) {
 }
 
 TEST(TEST_CATEGORY, create_mirror_view_and_copy_dynrankview) {
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<typename TEST_EXECSPACE::memory_space,
-                   Kokkos::CudaUVMSpace>::value)
-    return;
-#endif
+  GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
+
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableKernels(),
                      Config::EnableFences());
@@ -577,11 +584,8 @@ TEST(TEST_CATEGORY, create_mirror_no_init_offsetview_view_ctor) {
 }
 
 TEST(TEST_CATEGORY, create_mirror_view_and_copy_offsetview) {
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<typename TEST_EXECSPACE::memory_space,
-                   Kokkos::CudaUVMSpace>::value)
-    return;
-#endif
+  GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
+
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableKernels(),
                      Config::EnableFences());
@@ -652,11 +656,8 @@ TEST(TEST_CATEGORY, create_mirror_no_init_dynamicview) {
 }
 
 TEST(TEST_CATEGORY, create_mirror_view_and_copy_dynamicview) {
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<typename TEST_EXECSPACE::memory_space,
-                   Kokkos::CudaUVMSpace>::value)
-    return;
-#endif
+  GTEST_SKIP_IF_CUDAUVM_MEMORY_SPACE
+
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableKernels(),
                      Config::EnableFences());
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 5d9fde56d2..0917928001 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -1,15 +1,22 @@
-
-
-KOKKOS_SUBPACKAGE(Core)
-
 IF (NOT Kokkos_INSTALL_TESTING)
   ADD_SUBDIRECTORY(src)
 ENDIF()
 
-KOKKOS_ADD_TEST_DIRECTORIES(unit_test)
-IF (NOT KOKKOS_HAS_TRILINOS)
-  # We are using the githash etc in here, which does not work correct in Trilinos
-  KOKKOS_ADD_TEST_DIRECTORIES(perf_test)
-ENDIF()
+FUNCTION(KOKKOS_ADD_BENCHMARK_DIRECTORY DIR_NAME)
+  IF(NOT Kokkos_ENABLE_BENCHMARKS)
+    RETURN()
+  ENDIF()
+
+  IF(KOKKOS_HAS_TRILINOS)
+    message(
+      STATUS
+      "Benchmarks are not supported when building as part of Trilinos"
+    )
+    RETURN()
+  ENDIF()
 
-KOKKOS_SUBPACKAGE_POSTPROCESS()
+  ADD_SUBDIRECTORY(${DIR_NAME})
+ENDFUNCTION()
+
+KOKKOS_ADD_TEST_DIRECTORIES(unit_test)
+KOKKOS_ADD_BENCHMARK_DIRECTORY(perf_test)
diff --git a/core/cmake/Dependencies.cmake b/core/cmake/Dependencies.cmake
deleted file mode 100644
index 611c089b2e..0000000000
--- a/core/cmake/Dependencies.cmake
+++ /dev/null
@@ -1,6 +0,0 @@
-TRIBITS_PACKAGE_DEFINE_DEPENDENCIES(
-  LIB_OPTIONAL_TPLS Pthread CUDA HWLOC DLlib
-  TEST_OPTIONAL_TPLS CUSPARSE
-  )
-
-TRIBITS_TPL_TENTATIVELY_ENABLE(DLlib)
diff --git a/core/perf_test/BenchmarkMain.cpp b/core/perf_test/BenchmarkMain.cpp
index bba2bca36d..2232019c19 100644
--- a/core/perf_test/BenchmarkMain.cpp
+++ b/core/perf_test/BenchmarkMain.cpp
@@ -16,15 +16,20 @@
 
 #include <benchmark/benchmark.h>
 
-#include <Benchmark_Context.hpp>
+#include "Benchmark_Context.hpp"
 #include <Kokkos_Core.hpp>
 
+#include "PerfTest_Category.hpp"
+
 int main(int argc, char** argv) {
   Kokkos::initialize(argc, argv);
   benchmark::Initialize(&argc, argv);
   benchmark::SetDefaultTimeUnit(benchmark::kSecond);
   KokkosBenchmark::add_benchmark_context(true);
 
+  (void)Test::command_line_num_args(argc);
+  (void)Test::command_line_arg(0, argv);
+
   benchmark::RunSpecifiedBenchmarks();
 
   benchmark::Shutdown();
diff --git a/core/perf_test/Benchmark_Context.cpp b/core/perf_test/Benchmark_Context.cpp
new file mode 100644
index 0000000000..9aa63cc34f
--- /dev/null
+++ b/core/perf_test/Benchmark_Context.cpp
@@ -0,0 +1,81 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include "Benchmark_Context.hpp"
+
+namespace KokkosBenchmark {
+
+/**
+ * \brief Remove unwanted spaces and colon signs from input string. In case of
+ * invalid input it will return an empty string.
+ */
+std::string remove_unwanted_characters(const std::string& str) {
+  auto from = str.find_first_not_of(" :");
+  auto to   = str.find_last_not_of(" :");
+
+  if (from == std::string::npos || to == std::string::npos) {
+    return "";
+  }
+
+  // return extracted part of string without unwanted spaces and colon signs
+  return str.substr(from, to + 1);
+}
+
+/**
+ * \brief Extract all key:value pairs from kokkos configuration and add it to
+ * the benchmark context
+ */
+void add_kokkos_configuration(bool verbose) {
+  std::ostringstream msg;
+  Kokkos::print_configuration(msg, verbose);
+
+  // Iterate over lines returned from kokkos and extract key:value pairs
+  std::stringstream ss{msg.str()};
+  for (std::string line; std::getline(ss, line, '\n');) {
+    auto found = line.find_first_of(':');
+    if (found != std::string::npos) {
+      auto val = remove_unwanted_characters(line.substr(found + 1));
+      // Ignore line without value, for example a category name
+      if (!val.empty()) {
+        benchmark::AddCustomContext(
+            remove_unwanted_characters(line.substr(0, found)), val);
+      }
+    }
+  }
+}
+
+void add_git_info() {
+  if (!Kokkos::Impl::GIT_BRANCH.empty()) {
+    benchmark::AddCustomContext("GIT_BRANCH", Kokkos::Impl::GIT_BRANCH);
+    benchmark::AddCustomContext("GIT_COMMIT_HASH",
+                                Kokkos::Impl::GIT_COMMIT_HASH);
+    benchmark::AddCustomContext("GIT_CLEAN_STATUS",
+                                Kokkos::Impl::GIT_CLEAN_STATUS);
+    benchmark::AddCustomContext("GIT_COMMIT_DESCRIPTION",
+                                Kokkos::Impl::GIT_COMMIT_DESCRIPTION);
+    benchmark::AddCustomContext("GIT_COMMIT_DATE",
+                                Kokkos::Impl::GIT_COMMIT_DATE);
+  }
+}
+
+void add_benchmark_context(bool verbose) {
+  // Add Kokkos configuration to benchmark context data
+  add_kokkos_configuration(verbose);
+  // Add git information to benchmark context data
+  add_git_info();
+}
+
+}  // namespace KokkosBenchmark
diff --git a/core/perf_test/Benchmark_Context.hpp b/core/perf_test/Benchmark_Context.hpp
index ba6eff6646..e823b3a8ad 100644
--- a/core/perf_test/Benchmark_Context.hpp
+++ b/core/perf_test/Benchmark_Context.hpp
@@ -26,62 +26,34 @@
 
 namespace KokkosBenchmark {
 
-/// \brief Remove unwanted spaces and colon signs from input string. In case of
-/// invalid input it will return an empty string.
-std::string remove_unwanted_characters(std::string str) {
-  auto from = str.find_first_not_of(" :");
-  auto to   = str.find_last_not_of(" :");
-
-  if (from == std::string::npos || to == std::string::npos) {
-    return "";
-  }
-
-  // return extracted part of string without unwanted spaces and colon signs
-  return str.substr(from, to + 1);
-}
-
-/// \brief Extract all key:value pairs from kokkos configuration and add it to
-/// the benchmark context
-void add_kokkos_configuration(bool verbose) {
-  std::ostringstream msg;
-  Kokkos::print_configuration(msg, verbose);
-
-  // Iterate over lines returned from kokkos and extract key:value pairs
-  std::stringstream ss{msg.str()};
-  for (std::string line; std::getline(ss, line, '\n');) {
-    auto found = line.find_first_of(':');
-    if (found != std::string::npos) {
-      auto val = remove_unwanted_characters(line.substr(found + 1));
-      // Ignore line without value, for example a category name
-      if (!val.empty()) {
-        benchmark::AddCustomContext(
-            remove_unwanted_characters(line.substr(0, found)), val);
-      }
-    }
-  }
-}
-
-/// \brief Add all data related to git to benchmark context
-void add_git_info() {
-  if (!Kokkos::Impl::GIT_BRANCH.empty()) {
-    benchmark::AddCustomContext("GIT_BRANCH", Kokkos::Impl::GIT_BRANCH);
-    benchmark::AddCustomContext("GIT_COMMIT_HASH",
-                                Kokkos::Impl::GIT_COMMIT_HASH);
-    benchmark::AddCustomContext("GIT_CLEAN_STATUS",
-                                Kokkos::Impl::GIT_CLEAN_STATUS);
-    benchmark::AddCustomContext("GIT_COMMIT_DESCRIPTION",
-                                Kokkos::Impl::GIT_COMMIT_DESCRIPTION);
-    benchmark::AddCustomContext("GIT_COMMIT_DATE",
-                                Kokkos::Impl::GIT_COMMIT_DATE);
-  }
+/**
+ * \brief Gather all context information and add it to benchmark context data
+ */
+void add_benchmark_context(bool verbose = false);
+
+/**
+ * \brief Mark the label as a figure of merit.
+ */
+inline std::string benchmark_fom(const std::string& label) {
+  return "FOM: " + label;
 }
 
-/// \brief Gather all context information and add it to benchmark context data
-void add_benchmark_context(bool verbose = false) {
-  // Add Kokkos configuration to benchmark context data
-  add_kokkos_configuration(verbose);
-  // Add git information to benchmark context data
-  add_git_info();
+/**
+ * \brief Report throughput and amount of data processed for simple View
+ * operations
+ */
+template <class ViewType>
+void report_results(benchmark::State& state, ViewType view, int data_ratio,
+                    double time) {
+  // data processed in megabytes
+  const double data_processed = data_ratio * view.size() *
+                                sizeof(typename ViewType::value_type) /
+                                1'000'000;
+
+  state.SetIterationTime(time);
+  state.counters["MB"] = benchmark::Counter(data_processed);
+  state.counters[KokkosBenchmark::benchmark_fom("GB/s")] = benchmark::Counter(
+      data_processed / 1'000, benchmark::Counter::kIsIterationInvariantRate);
 }
 
 }  // namespace KokkosBenchmark
diff --git a/core/perf_test/CMakeLists.txt b/core/perf_test/CMakeLists.txt
index 814102975f..66319f43f5 100644
--- a/core/perf_test/CMakeLists.txt
+++ b/core/perf_test/CMakeLists.txt
@@ -1,108 +1,31 @@
-
-#INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-#INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
-
-
-# warning: PerfTest_CustomReduction.cpp uses
-# ../../algorithms/src/Kokkos_Random.hpp
-# we'll just allow it to be included, but note
-# that in TriBITS KokkosAlgorithms can be disabled...
-#INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/../../algorithms/src")
-
 # FIXME_OPENMPTARGET - the NVIDIA HPC compiler nvc++ in the OpenMPTarget backend does not pass the perf_tests.
 # FIXME_OPENACC - temporarily disabled due to unimplemented features
 IF ((KOKKOS_ENABLE_OPENMPTARGET OR KOKKOS_ENABLE_OPENACC) AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
   RETURN()
 ENDIF()
 
+# all PerformanceTest_* executables are part of regular tests
+# TODO: finish converting these into benchmarks (in progress)
+IF(KOKKOS_ENABLE_TESTS)
+  IF(KOKKOS_ENABLE_CUDA OR KOKKOS_ENABLE_HIP OR KOKKOS_ENABLE_SYCL)
+    KOKKOS_ADD_EXECUTABLE (
+      PerformanceTest_SharedSpace
+      SOURCES test_sharedSpace.cpp
+    )
+  ENDIF()
 
-SET(SOURCES
-  PerfTestMain.cpp
-  PerfTestGramSchmidt.cpp
-  PerfTestHexGrad.cpp
-  PerfTest_CustomReduction.cpp
-  PerfTest_ExecSpacePartitioning.cpp
-  PerfTest_ViewAllocate.cpp
-  PerfTest_ViewFill_123.cpp
-  PerfTest_ViewFill_45.cpp
-  PerfTest_ViewFill_6.cpp
-  PerfTest_ViewFill_7.cpp
-  PerfTest_ViewFill_8.cpp
-  PerfTest_ViewResize_123.cpp
-  PerfTest_ViewResize_45.cpp
-  PerfTest_ViewResize_6.cpp
-  PerfTest_ViewResize_7.cpp
-  PerfTest_ViewResize_8.cpp
-  )
-
-IF(Kokkos_ENABLE_OPENMPTARGET)
-# FIXME OPENMPTARGET requires TeamPolicy Reductions and Custom Reduction
-  LIST(REMOVE_ITEM SOURCES
-    PerfTestGramSchmidt.cpp
-    PerfTest_CustomReduction.cpp
-    PerfTest_ExecSpacePartitioning.cpp
-  )
-ENDIF()
-
-IF(KOKKOS_ENABLE_CUDA OR KOKKOS_ENABLE_HIP OR KOKKOS_ENABLE_SYCL)
-  KOKKOS_ADD_EXECUTABLE (
-    PerformanceTest_SharedSpace
-    SOURCES test_sharedSpace.cpp
-  )
-ENDIF()
-
-# Per #374, we always want to build this test, but we only want to run
-# it as a PERFORMANCE test.  That's why we separate building the test
-# from running the test.
-
-#leave these as basic includes for now
-#I don't need anything transitive
-KOKKOS_INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/../../algorithms/src")
-KOKKOS_INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
-
-# This test currently times out for MSVC
-IF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL "MSVC")
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    PerfTestExec
-    SOURCES ${SOURCES}
-    CATEGORIES PERFORMANCE
-  )
-ENDIF()
-
-KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  PerformanceTest_Atomic
-  SOURCES test_atomic.cpp
-  CATEGORIES PERFORMANCE
-)
-
-IF(NOT KOKKOS_ENABLE_CUDA OR KOKKOS_ENABLE_CUDA_LAMBDA)
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    PerformanceTest_Atomic_MinMax
-    SOURCES test_atomic_minmax_simple.cpp
-    CATEGORIES PERFORMANCE
-  )
-ENDIF()
+  KOKKOS_INCLUDE_DIRECTORIES(REQUIRED_DURING_INSTALLATION_TESTING ${CMAKE_CURRENT_SOURCE_DIR})
 
-# FIXME_NVHPC
-IF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
-KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  PerformanceTest_Mempool
-  SOURCES test_mempool.cpp
-  CATEGORIES PERFORMANCE
-)
-ENDIF()
-
-IF(NOT Kokkos_ENABLE_OPENMPTARGET)
-# FIXME OPENMPTARGET needs tasking
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    PerformanceTest_TaskDag
-    SOURCES test_taskdag.cpp
-    CATEGORIES PERFORMANCE
-  )
+  IF(NOT Kokkos_ENABLE_OPENMPTARGET)
+  # FIXME OPENMPTARGET needs tasking
+    KOKKOS_ADD_EXECUTABLE_AND_TEST(
+      PerformanceTest_TaskDag
+      SOURCES test_taskdag.cpp
+      CATEGORIES PERFORMANCE
+    )
+  ENDIF()
 ENDIF()
 
-
 IF(NOT Kokkos_ENABLE_BENCHMARKS)
   RETURN()
 ENDIF()
@@ -111,6 +34,7 @@ IF (KOKKOS_HAS_TRILINOS)
   message(FATAL_ERROR "Benchmarks are not supported when building as part of Trilinos")
 ENDIF()
 
+# Find or download google/benchmark library
 find_package(benchmark QUIET)
 IF(benchmark_FOUND)
   MESSAGE(STATUS "Using google benchmark found in ${benchmark_DIR}")
@@ -119,7 +43,7 @@ ELSE()
   include(FetchContent)
   SET(BENCHMARK_ENABLE_TESTING OFF)
 
-  list(APPEND CMAKE_MESSAGE_INDENT "    ")
+  list(APPEND CMAKE_MESSAGE_INDENT "[benchmark] ")
   FetchContent_Declare(
     googlebenchmark
     URL https://github.com/google/benchmark/archive/refs/tags/v1.6.2.tar.gz
@@ -128,8 +52,6 @@ ELSE()
   FetchContent_MakeAvailable(googlebenchmark)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
 
-  include_directories(${benchmark_SOURCE_DIR}/include)
-
   # Suppress clang-tidy diagnostics on code that we do not have control over
   IF(CMAKE_CXX_CLANG_TIDY)
     SET_TARGET_PROPERTIES(benchmark PROPERTIES CXX_CLANG_TIDY "")
@@ -157,6 +79,10 @@ FUNCTION(KOKKOS_ADD_BENCHMARK NAME)
   ENDIF()
 
   SET(BENCHMARK_NAME ${PACKAGE_NAME}_${NAME})
+  LIST(APPEND BENCHMARK_SOURCES
+    BenchmarkMain.cpp
+    Benchmark_Context.cpp
+  )
 
   ADD_EXECUTABLE(
     ${BENCHMARK_NAME}
@@ -166,6 +92,11 @@ FUNCTION(KOKKOS_ADD_BENCHMARK NAME)
     ${BENCHMARK_NAME}
     PRIVATE benchmark::benchmark Kokkos::kokkos impl_git_version
   )
+  TARGET_INCLUDE_DIRECTORIES(
+    ${BENCHMARK_NAME}
+    SYSTEM PRIVATE ${benchmark_SOURCE_DIR}/include
+  )
+
   FOREACH(SOURCE_FILE ${BENCHMARK_SOURCES})
     SET_SOURCE_FILES_PROPERTIES(
       ${SOURCE_FILE}
@@ -188,7 +119,11 @@ ENDFUNCTION()
 
 SET(
   BENCHMARK_SOURCES
-  BenchmarkMain.cpp
+  PerfTestGramSchmidt.cpp
+  PerfTest_CustomReduction.cpp
+  PerfTest_ExecSpacePartitioning.cpp
+  PerfTestHexGrad.cpp
+  PerfTest_ViewAllocate.cpp
   PerfTest_ViewCopy_a123.cpp
   PerfTest_ViewCopy_b123.cpp
   PerfTest_ViewCopy_c123.cpp
@@ -210,9 +145,50 @@ SET(
   PerfTest_ViewCopy_c8.cpp
   PerfTest_ViewCopy_d8.cpp
   PerfTest_ViewCopy_Raw.cpp
+  PerfTest_ViewFill_123.cpp
+  PerfTest_ViewFill_45.cpp
+  PerfTest_ViewFill_6.cpp
+  PerfTest_ViewFill_7.cpp
+  PerfTest_ViewFill_8.cpp
+  PerfTest_ViewFill_Raw.cpp
+  PerfTest_ViewResize_123.cpp
+  PerfTest_ViewResize_45.cpp
+  PerfTest_ViewResize_6.cpp
+  PerfTest_ViewResize_7.cpp
+  PerfTest_ViewResize_8.cpp
+  PerfTest_ViewResize_Raw.cpp
 )
 
+IF(Kokkos_ENABLE_OPENMPTARGET)
+# FIXME OPENMPTARGET requires TeamPolicy Reductions and Custom Reduction
+  LIST(REMOVE_ITEM BENCHMARK_SOURCES
+    PerfTestGramSchmidt.cpp
+    PerfTest_CustomReduction.cpp
+    PerfTest_ExecSpacePartitioning.cpp
+  )
+ENDIF()
+
 KOKKOS_ADD_BENCHMARK(
   PerformanceTest_Benchmark
   SOURCES ${BENCHMARK_SOURCES}
 )
+
+IF(NOT KOKKOS_ENABLE_CUDA OR KOKKOS_ENABLE_CUDA_LAMBDA)
+  KOKKOS_ADD_BENCHMARK(
+    Benchmark_Atomic_MinMax
+    SOURCES test_atomic_minmax_simple.cpp
+  )
+ENDIF()
+
+# FIXME_NVHPC
+IF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
+  KOKKOS_ADD_BENCHMARK(
+    PerformanceTest_Mempool
+    SOURCES test_mempool.cpp
+  )
+ENDIF()
+
+KOKKOS_ADD_BENCHMARK(
+  PerformanceTest_Atomic
+  SOURCES test_atomic.cpp
+)
diff --git a/core/perf_test/Makefile b/core/perf_test/Makefile
index 396387c622..5e1e0f6541 100644
--- a/core/perf_test/Makefile
+++ b/core/perf_test/Makefile
@@ -14,7 +14,7 @@ else
   CXX = g++
 endif
 
-CXXFLAGS = -O3 
+CXXFLAGS = -O3
 #CXXFLAGS += -DGENERIC_REDUCER
 LINK ?= $(CXX)
 LDFLAGS ?=
@@ -29,43 +29,12 @@ TARGETS =
 
 #
 
-OBJ_PERF = PerfTestMain.o gtest-all.o
-OBJ_PERF += PerfTest_ExecSpacePartitioning.o
-OBJ_PERF += PerfTestGramSchmidt.o
-OBJ_PERF += PerfTestHexGrad.o
-OBJ_PERF += PerfTest_CustomReduction.o
-OBJ_PERF += PerfTest_ViewAllocate.o
-OBJ_PERF += PerfTest_ViewFill_123.o PerfTest_ViewFill_45.o PerfTest_ViewFill_6.o PerfTest_ViewFill_7.o PerfTest_ViewFill_8.o
-OBJ_PERF += PerfTest_ViewResize_123.o PerfTest_ViewResize_45.o PerfTest_ViewResize_6.o PerfTest_ViewResize_7.o PerfTest_ViewResize_8.o
-TARGETS += KokkosCore_PerformanceTest
-TEST_TARGETS += test-performance
-
-#
-
-OBJ_ATOMICS = test_atomic.o 
-TARGETS += KokkosCore_PerformanceTest_Atomics
-TEST_TARGETS += test-atomic
-
-#
-
-OBJ_MEMPOOL = test_mempool.o 
-TARGETS += KokkosCore_PerformanceTest_Mempool
-TEST_TARGETS += test-mempool
-
-#
-
-OBJ_TASKDAG = test_taskdag.o 
+OBJ_TASKDAG = test_taskdag.o
 TARGETS += KokkosCore_PerformanceTest_TaskDAG
 TEST_TARGETS += test-taskdag
 
 #
 
-OBJ_ATOMICS_MINMAX = test_atomic_minmax_simple.o
-TARGETS += KokkosCore_PerformanceTest_Atomics_MinMax
-TEST_TARGETS += test-atomic-minmax
-
-#
-
 KokkosCore_PerformanceTest: $(OBJ_PERF) $(KOKKOS_LINK_DEPENDS)
 	$(LINK) $(EXTRA_PATH) $(OBJ_PERF) $(KOKKOS_LIBS) $(LIB) $(KOKKOS_LDFLAGS) $(LDFLAGS) -o KokkosCore_PerformanceTest
 
diff --git a/core/perf_test/PerfTestBlasKernels.hpp b/core/perf_test/PerfTestBlasKernels.hpp
index 1d7073fe5a..5e6e52f115 100644
--- a/core/perf_test/PerfTestBlasKernels.hpp
+++ b/core/perf_test/PerfTestBlasKernels.hpp
@@ -25,8 +25,8 @@ template <class Type>
 struct Dot {
   using execution_space = typename Type::execution_space;
 
-  static_assert(static_cast<unsigned>(Type::Rank) == static_cast<unsigned>(1),
-                "Dot static_assert Fail: Rank != 1");
+  static_assert(static_cast<unsigned>(Type::rank) == static_cast<unsigned>(1),
+                "Dot static_assert Fail: rank != 1");
 
   using value_type = double;
 
@@ -56,8 +56,8 @@ template <class Type>
 struct DotSingle {
   using execution_space = typename Type::execution_space;
 
-  static_assert(static_cast<unsigned>(Type::Rank) == static_cast<unsigned>(1),
-                "DotSingle static_assert Fail: Rank != 1");
+  static_assert(static_cast<unsigned>(Type::rank) == static_cast<unsigned>(1),
+                "DotSingle static_assert Fail: rank != 1");
 
   using value_type = double;
 
@@ -88,13 +88,13 @@ template <class ScalarType, class VectorType>
 struct Scale {
   using execution_space = typename VectorType::execution_space;
 
-  static_assert(static_cast<unsigned>(ScalarType::Rank) ==
+  static_assert(static_cast<unsigned>(ScalarType::rank) ==
                     static_cast<unsigned>(0),
-                "Scale static_assert Fail: ScalarType::Rank != 0");
+                "Scale static_assert Fail: ScalarType::rank != 0");
 
-  static_assert(static_cast<unsigned>(VectorType::Rank) ==
+  static_assert(static_cast<unsigned>(VectorType::rank) ==
                     static_cast<unsigned>(1),
-                "Scale static_assert Fail: VectorType::Rank != 1");
+                "Scale static_assert Fail: VectorType::rank != 1");
 
 #if 1
   typename ScalarType::const_type alpha;
@@ -115,17 +115,17 @@ template <class ScalarType, class ConstVectorType, class VectorType>
 struct AXPBY {
   using execution_space = typename VectorType::execution_space;
 
-  static_assert(static_cast<unsigned>(ScalarType::Rank) ==
+  static_assert(static_cast<unsigned>(ScalarType::rank) ==
                     static_cast<unsigned>(0),
-                "AXPBY static_assert Fail: ScalarType::Rank != 0");
+                "AXPBY static_assert Fail: ScalarType::rank != 0");
 
-  static_assert(static_cast<unsigned>(ConstVectorType::Rank) ==
+  static_assert(static_cast<unsigned>(ConstVectorType::rank) ==
                     static_cast<unsigned>(1),
-                "AXPBY static_assert Fail: ConstVectorType::Rank != 1");
+                "AXPBY static_assert Fail: ConstVectorType::rank != 1");
 
-  static_assert(static_cast<unsigned>(VectorType::Rank) ==
+  static_assert(static_cast<unsigned>(VectorType::rank) ==
                     static_cast<unsigned>(1),
-                "AXPBY static_assert Fail: VectorType::Rank != 1");
+                "AXPBY static_assert Fail: VectorType::rank != 1");
 
 #if 1
   typename ScalarType::const_type alpha, beta;
diff --git a/core/perf_test/PerfTestGramSchmidt.cpp b/core/perf_test/PerfTestGramSchmidt.cpp
index c8f8487ffc..ddfa73d4ba 100644
--- a/core/perf_test/PerfTestGramSchmidt.cpp
+++ b/core/perf_test/PerfTestGramSchmidt.cpp
@@ -15,11 +15,11 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <PerfTest_Category.hpp>
+#include <benchmark/benchmark.h>
+#include "PerfTest_Category.hpp"
 
 #include <cmath>
-#include <PerfTestBlasKernels.hpp>
+#include "PerfTestBlasKernels.hpp"
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -137,87 +137,61 @@ struct ModifiedGramSchmidt {
 
   //--------------------------------------------------------------------------
 
-  static double test(const size_type length, const size_type count,
-                     const size_t iter = 1) {
+  static double test(const size_type length, const size_type count) {
     multivector_type Q_("Q", length, count);
     multivector_type R_("R", count, count);
 
     typename multivector_type::HostMirror A = Kokkos::create_mirror(Q_);
 
     // Create and fill A on the host
-
     for (size_type j = 0; j < count; ++j) {
       for (size_type i = 0; i < length; ++i) {
         A(i, j) = (i + 1) * (j + 1);
       }
     }
 
-    double dt_min = 0;
-
-    for (size_t i = 0; i < iter; ++i) {
-      Kokkos::deep_copy(Q_, A);
-
-      // A = Q * R
+    Kokkos::deep_copy(Q_, A);
 
-      const double dt = factorization(Q_, R_);
+    // A = Q * R
+    const double dt = factorization(Q_, R_);
 
-      if (0 == i)
-        dt_min = dt;
-      else
-        dt_min = dt < dt_min ? dt : dt_min;
-    }
-
-    return dt_min;
+    return dt;
   }
 };
 
-template <class DeviceType>
-void run_test_gramschmidt(int exp_beg, int exp_end, int num_trials,
-                          const char deviceTypeName[]) {
-  std::string label_gramschmidt;
-  label_gramschmidt.append("\"GramSchmidt< double , ");
-  label_gramschmidt.append(deviceTypeName);
-  label_gramschmidt.append(" >\"");
-
-  for (int i = exp_beg; i < exp_end; ++i) {
-    double min_seconds = 0.0;
-    double max_seconds = 0.0;
-    double avg_seconds = 0.0;
-
-    const int parallel_work_length = 1 << i;
-
-    for (int j = 0; j < num_trials; ++j) {
-      const double seconds = ModifiedGramSchmidt<double, DeviceType>::test(
-          parallel_work_length, 32);
-
-      if (0 == j) {
-        min_seconds = seconds;
-        max_seconds = seconds;
-      } else {
-        if (seconds < min_seconds) min_seconds = seconds;
-        if (seconds > max_seconds) max_seconds = seconds;
-      }
-      avg_seconds += seconds;
-    }
-    avg_seconds /= num_trials;
+template <class Scalar>
+static void GramSchmidt(benchmark::State& state) {
+  const int parallel_work_length = state.range(0);
+
+  for (auto _ : state) {
+    const double seconds =
+        ModifiedGramSchmidt<Scalar, Kokkos::DefaultExecutionSpace>::test(
+            parallel_work_length, 32);
 
-    std::cout << label_gramschmidt << " , " << parallel_work_length << " , "
-              << min_seconds << " , " << (min_seconds / parallel_work_length)
-              << ", " << avg_seconds << std::endl;
+    state.SetIterationTime(seconds);
+    state.counters["Count"] = benchmark::Counter(parallel_work_length);
+    state.counters["Time normalized"] =
+        benchmark::Counter(seconds / parallel_work_length);
   }
 }
 
-TEST(default_exec, gramschmidt) {
-  int exp_beg    = 10;
-  int exp_end    = 20;
-  int num_trials = 5;
-
-  if (command_line_num_args() > 1) exp_beg = std::stoi(command_line_arg(1));
-  if (command_line_num_args() > 2) exp_end = std::stoi(command_line_arg(2));
-  if (command_line_num_args() > 3) num_trials = std::stoi(command_line_arg(3));
-
-  EXPECT_NO_THROW(run_test_gramschmidt<Kokkos::DefaultExecutionSpace>(
-      exp_beg, exp_end, num_trials, Kokkos::DefaultExecutionSpace::name()));
-}
+// FIXME_SYCL SYCL+Cuda reports "an illegal memory access was encountered"
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+BENCHMARK(GramSchmidt<double>)
+    ->ArgName("Count")
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 1 << 18, 2),
+    })
+    ->UseManualTime()
+    ->Iterations(5);
+#else
+BENCHMARK(GramSchmidt<double>)
+    ->ArgName("Count")
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 1 << 19, 2),
+    })
+    ->UseManualTime()
+    ->Iterations(5);
+#endif
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTestHexGrad.cpp b/core/perf_test/PerfTestHexGrad.cpp
index ef92de7ce1..98cb246c71 100644
--- a/core/perf_test/PerfTestHexGrad.cpp
+++ b/core/perf_test/PerfTestHexGrad.cpp
@@ -15,8 +15,9 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <PerfTest_Category.hpp>
+#include <benchmark/benchmark.h>
+#include "Benchmark_Context.hpp"
+#include "PerfTest_Category.hpp"
 
 namespace Test {
 
@@ -195,78 +196,43 @@ struct HexGrad {
 
   //--------------------------------------------------------------------------
 
-  static double test(const int count, const int iter = 1) {
+  static double test(const int count) {
     elem_coord_type coord("coord", count);
     elem_grad_type grad("grad", count);
 
     // Execute the parallel kernels on the arrays:
-
-    double dt_min = 0;
-
     Kokkos::parallel_for(count, Init(coord));
     execution_space().fence();
 
-    for (int i = 0; i < iter; ++i) {
-      Kokkos::Timer timer;
-      Kokkos::parallel_for(count, HexGrad<execution_space>(coord, grad));
-      execution_space().fence();
-      const double dt = timer.seconds();
-      if (0 == i)
-        dt_min = dt;
-      else
-        dt_min = dt < dt_min ? dt : dt_min;
-    }
-
-    return dt_min;
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(count, HexGrad<execution_space>(coord, grad));
+    execution_space().fence();
+    return timer.seconds();
   }
 };
 
-template <class DeviceType>
-void run_test_hexgrad(int exp_beg, int exp_end, int num_trials,
-                      const char deviceTypeName[]) {
-  std::string label_hexgrad;
-  label_hexgrad.append("\"HexGrad< double , ");
-  label_hexgrad.append(deviceTypeName);
-  label_hexgrad.append(" >\"");
-
-  for (int i = exp_beg; i < exp_end; ++i) {
-    double min_seconds = 0.0;
-    double max_seconds = 0.0;
-    double avg_seconds = 0.0;
-
-    const int parallel_work_length = 1 << i;
-
-    for (int j = 0; j < num_trials; ++j) {
-      const double seconds = HexGrad<DeviceType>::test(parallel_work_length);
-
-      if (0 == j) {
-        min_seconds = seconds;
-        max_seconds = seconds;
-      } else {
-        if (seconds < min_seconds) min_seconds = seconds;
-        if (seconds > max_seconds) max_seconds = seconds;
-      }
-      avg_seconds += seconds;
-    }
-    avg_seconds /= num_trials;
+template <class CoordScalarType>
+static void HexGrad_Benchmark(benchmark::State& state) {
+  const auto parallel_work_length = state.range(0);
+
+  for (auto _ : state) {
+    const auto time =
+        HexGrad<Kokkos::DefaultExecutionSpace, CoordScalarType>::test(
+            parallel_work_length);
 
-    std::cout << label_hexgrad << " , " << parallel_work_length << " , "
-              << min_seconds << " , " << (min_seconds / parallel_work_length)
-              << avg_seconds << std::endl;
+    state.SetIterationTime(time);
+    state.counters["Count"] = benchmark::Counter(parallel_work_length);
+    state.counters["Time normalized"] =
+        benchmark::Counter(time / parallel_work_length);
   }
 }
 
-TEST(default_exec, hexgrad) {
-  int exp_beg    = 10;
-  int exp_end    = 20;
-  int num_trials = 5;
-
-  if (command_line_num_args() > 1) exp_beg = std::stoi(command_line_arg(1));
-  if (command_line_num_args() > 2) exp_end = std::stoi(command_line_arg(2));
-  if (command_line_num_args() > 3) num_trials = std::stoi(command_line_arg(3));
-
-  EXPECT_NO_THROW(run_test_hexgrad<Kokkos::DefaultExecutionSpace>(
-      exp_beg, exp_end, num_trials, Kokkos::DefaultExecutionSpace::name()));
-}
+BENCHMARK(HexGrad_Benchmark<double>)
+    ->ArgName("count")
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 1 << 19, 2),
+    })
+    ->UseManualTime()
+    ->Iterations(5);
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTestMain.cpp b/core/perf_test/PerfTestMain.cpp
index 2729432adc..7315f26e5c 100644
--- a/core/perf_test/PerfTestMain.cpp
+++ b/core/perf_test/PerfTestMain.cpp
@@ -18,24 +18,7 @@
 #include <cstdlib>
 
 #include <Kokkos_Core.hpp>
-
-namespace Test {
-int command_line_num_args(int n = 0) {
-  static int n_args = 0;
-  if (n > 0) n_args = n;
-  return n_args;
-}
-
-const char* command_line_arg(int k, char** input_args = nullptr) {
-  static char** args;
-  if (input_args != nullptr) args = input_args;
-  if (command_line_num_args() > k)
-    return args[k];
-  else
-    return nullptr;
-}
-
-}  // namespace Test
+#include <PerfTest_Category.hpp>
 
 int main(int argc, char* argv[]) {
   ::testing::InitGoogleTest(&argc, argv);
diff --git a/core/perf_test/PerfTest_Category.hpp b/core/perf_test/PerfTest_Category.hpp
index 126c961147..60f76ea8f5 100644
--- a/core/perf_test/PerfTest_Category.hpp
+++ b/core/perf_test/PerfTest_Category.hpp
@@ -17,12 +17,22 @@
 #ifndef KOKKOS_TEST_PERFTEST_CAT_HPP
 #define KOKKOS_TEST_PERFTEST_CAT_HPP
 
-#include <gtest/gtest.h>
-
 namespace Test {
 
-extern int command_line_num_args(int n = 0);
-extern const char* command_line_arg(int k, char** input_args = nullptr);
+inline int command_line_num_args(int n = 0) {
+  static int n_args = 0;
+  if (n > 0) n_args = n;
+  return n_args;
+}
+
+inline const char* command_line_arg(int k, char** input_args = nullptr) {
+  static char** args;
+  if (input_args != nullptr) args = input_args;
+  if (command_line_num_args() > k)
+    return args[k];
+  else
+    return nullptr;
+}
 
 }  // namespace Test
 
diff --git a/core/perf_test/PerfTest_CustomReduction.cpp b/core/perf_test/PerfTest_CustomReduction.cpp
index 049301f9a7..2110f38a91 100644
--- a/core/perf_test/PerfTest_CustomReduction.cpp
+++ b/core/perf_test/PerfTest_CustomReduction.cpp
@@ -15,14 +15,16 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <PerfTest_Category.hpp>
+#include <benchmark/benchmark.h>
+#include "Benchmark_Context.hpp"
+#include "PerfTest_Category.hpp"
 #include <Kokkos_Random.hpp>
+#include <utility>
 
 #ifdef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
 namespace Test {
 template <class Scalar>
-void custom_reduction_test(int N, int R, int num_trials) {
+std::pair<double, Scalar> custom_reduction_test(int N, int R) {
   Kokkos::Random_XorShift64_Pool<> rand_pool(183291);
   Kokkos::View<Scalar*> a("A", N);
   Kokkos::fill_random(a, rand_pool, 1.0);
@@ -62,49 +64,70 @@ void custom_reduction_test(int N, int R, int num_trials) {
 
   // Timing
   Kokkos::Timer timer;
-  for (int r = 0; r < num_trials; r++) {
-    Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<>(N / 1024, team_size),
-        KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team,
-                      Scalar& lmax) {
-          Scalar team_max = Scalar(0);
-          for (int rr = 0; rr < R; rr++) {
-            int i = team.league_rank();
-            Kokkos::parallel_reduce(
-                Kokkos::TeamThreadRange(team, 32),
-                [&](const int& j, Scalar& thread_max) {
-                  Scalar t_max = Scalar(0);
-                  Kokkos::parallel_reduce(
-                      Kokkos::ThreadVectorRange(team, 32),
-                      [&](const int& k, Scalar& max_) {
-                        const Scalar val = a((i * 32 + j) * 32 + k);
-                        if (val > max_) max_ = val;
-                        if ((k == 11) && (j == 17) && (i == 2)) max_ = 11.5;
-                      },
-                      Kokkos::Max<Scalar>(t_max));
-                  if (t_max > thread_max) thread_max = t_max;
-                },
-                Kokkos::Max<Scalar>(team_max));
-          }
-          if (team_max > lmax) lmax = team_max;
-        },
-        Kokkos::Max<Scalar>(max));
-  }
-  double time = timer.seconds();
-  printf("%e %e %e\n", time,
-         1.0 * N * R * num_trials * sizeof(Scalar) / time / 1024 / 1024 / 1024,
-         max);
+  Kokkos::parallel_reduce(
+      Kokkos::TeamPolicy<>(N / 1024, team_size),
+      KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type& team,
+                    Scalar& lmax) {
+        Scalar team_max = Scalar(0);
+        for (int rr = 0; rr < R; rr++) {
+          int i = team.league_rank();
+          Kokkos::parallel_reduce(
+              Kokkos::TeamThreadRange(team, 32),
+              [&](const int& j, Scalar& thread_max) {
+                Scalar t_max = Scalar(0);
+                Kokkos::parallel_reduce(
+                    Kokkos::ThreadVectorRange(team, 32),
+                    [&](const int& k, Scalar& max_) {
+                      const Scalar val = a((i * 32 + j) * 32 + k);
+                      if (val > max_) max_ = val;
+                      if ((k == 11) && (j == 17) && (i == 2)) max_ = 11.5;
+                    },
+                    Kokkos::Max<Scalar>(t_max));
+                if (t_max > thread_max) thread_max = t_max;
+              },
+              Kokkos::Max<Scalar>(team_max));
+        }
+        if (team_max > lmax) lmax = team_max;
+      },
+      Kokkos::Max<Scalar>(max));
+
+  return std::make_pair(timer.seconds(), max);
 }
 
-TEST(default_exec, custom_reduction) {
-  int N          = 100000;
-  int R          = 1000;
-  int num_trials = 1;
+int get_N(benchmark::State& state) {
+  return (Test::command_line_num_args() > 1)
+             ? std::stoi(Test::command_line_arg(1))
+             : state.range(0);
+}
 
-  if (command_line_num_args() > 1) N = std::stoi(command_line_arg(1));
-  if (command_line_num_args() > 2) R = std::stoi(command_line_arg(2));
-  if (command_line_num_args() > 3) num_trials = std::stoi(command_line_arg(3));
-  custom_reduction_test<double>(N, R, num_trials);
+int get_R(benchmark::State& state) {
+  return (Test::command_line_num_args() > 2)
+             ? std::stoi(Test::command_line_arg(2))
+             : state.range(1);
 }
+
+template <class Scalar>
+static void CustomReduction(benchmark::State& state) {
+  int N = get_N(state);
+  int R = get_R(state);
+
+  for (auto _ : state) {
+    auto results = custom_reduction_test<double>(N, R);
+    // data processed in gigabytes
+    const double data_processed =
+        N * R * sizeof(Scalar) / results.first / 1'000'000'000;
+
+    state.SetIterationTime(results.first);
+    state.counters[KokkosBenchmark::benchmark_fom("GB/s")] = benchmark::Counter(
+        data_processed, benchmark::Counter::kIsIterationInvariantRate);
+    state.counters["Max"] = benchmark::Counter(results.second);
+  }
+}
+
+BENCHMARK(CustomReduction<double>)
+    ->ArgNames({"N", "R"})
+    ->Args({100'000, 1'000})
+    ->UseManualTime();
+
 }  // namespace Test
 #endif
diff --git a/core/perf_test/PerfTest_ExecSpacePartitioning.cpp b/core/perf_test/PerfTest_ExecSpacePartitioning.cpp
index 48419c7ec6..d2a3d0b823 100644
--- a/core/perf_test/PerfTest_ExecSpacePartitioning.cpp
+++ b/core/perf_test/PerfTest_ExecSpacePartitioning.cpp
@@ -15,8 +15,8 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <PerfTest_Category.hpp>
+#include <benchmark/benchmark.h>
+#include "PerfTest_Category.hpp"
 
 namespace Test {
 
@@ -54,7 +54,7 @@ bool is_overlapping<Kokkos::HIP>(const Kokkos::HIP&) {
 }
 #endif
 
-#ifdef KOKKOS_ENABLE_SYCL
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
 template <>
 bool is_overlapping<Kokkos::Experimental::SYCL>(
     const Kokkos::Experimental::SYCL&) {
@@ -154,10 +154,10 @@ struct FunctorTeamReduce {
   }
 };
 
-TEST(default_exec, overlap_range_policy) {
-  int N = 2000;
-  int M = 10000;
-  int R = 10;
+static void OverlapRangePolicy(benchmark::State& state) {
+  int N = state.range(0);
+  int M = state.range(1);
+  int R = state.range(2);
 
   TEST_EXECSPACE space;
   std::vector<TEST_EXECSPACE> execution_space_instances =
@@ -165,160 +165,172 @@ TEST(default_exec, overlap_range_policy) {
   TEST_EXECSPACE space1 = execution_space_instances[0];
   TEST_EXECSPACE space2 = execution_space_instances[1];
 
-  Kokkos::View<double**, TEST_EXECSPACE> a("A", N, M);
-  FunctorRange f(M, R, a);
-  FunctorRangeReduce fr(M, R, a);
-  Kokkos::parallel_for("default_exec::overlap_range_policy::kernel0",
-                       Kokkos::RangePolicy<TEST_EXECSPACE>(0, N),
-                       FunctorRange(M, R, a));
-
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel1",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel2",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-
-  Kokkos::Timer timer;
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel3",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel4",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-
-  timer.reset();
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel5",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorRange(M, R, a));
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel6",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorRange(M, R, a));
-  Kokkos::fence();
-  double time_overlap = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel7",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel8",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-  double time_end = timer.seconds();
-
-  if (is_overlapping(space)) {
-    ASSERT_GT(time_end, 1.5 * time_overlap);
-  }
-  printf("Time RangePolicy: NonOverlap: %lf Time Overlap: %lf\n", time_end,
-         time_overlap);
-
-  Kokkos::View<double, TEST_EXECSPACE> result("result");
-  Kokkos::View<double, TEST_EXECSPACE> result1("result1");
-  Kokkos::View<double, TEST_EXECSPACE> result2("result2");
-  Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
-  Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
-  Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_range_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::fence();
-  double time_fenced = timer.seconds();
-  Kokkos::deep_copy(h_result, result);
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_range_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  double time_not_fenced = timer.seconds();
-  Kokkos::fence();
-  if (is_overlapping(space)) {
-    ASSERT_GT(time_fenced, 2.0 * time_not_fenced);
-  }
+  for (auto _ : state) {
+    Kokkos::View<double**, TEST_EXECSPACE> a("A", N, M);
+    FunctorRange f(M, R, a);
+    FunctorRangeReduce fr(M, R, a);
+    Kokkos::parallel_for("default_exec::overlap_range_policy::kernel0",
+                         Kokkos::RangePolicy<TEST_EXECSPACE>(0, N),
+                         FunctorRange(M, R, a));
+
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel1",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel2",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel3",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel4",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel5",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorRange(M, R, a));
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel6",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorRange(M, R, a));
+    Kokkos::fence();
+    double time_overlap = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel7",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel8",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+    double time_end = timer.seconds();
+
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_end > 1.5 * time_overlap);
+    }
+    state.counters["Time NonOverlap"] = benchmark::Counter(time_end);
+    state.counters["Time Overlap"]    = benchmark::Counter(time_overlap);
+
+    Kokkos::View<double, TEST_EXECSPACE> result("result");
+    Kokkos::View<double, TEST_EXECSPACE> result1("result1");
+    Kokkos::View<double, TEST_EXECSPACE> result2("result2");
+    Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
+    Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
+    Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_range_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::fence();
+    double time_fenced = timer.seconds();
+    Kokkos::deep_copy(h_result, result);
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_range_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    double time_not_fenced = timer.seconds();
+    Kokkos::fence();
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_fenced > 2.0 * time_not_fenced);
+    }
 
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_range_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_range_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::fence();
-  double time_no_overlapped_reduce = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_range_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result1);
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_range_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result2);
-  Kokkos::fence();
-  double time_overlapped_reduce = timer.seconds();
-
-  Kokkos::deep_copy(h_result2, result2);
-  Kokkos::deep_copy(h_result1, result1);
-
-  ASSERT_EQ(h_result1(), h_result());
-  ASSERT_EQ(h_result2(), h_result());
-
-  if (is_overlapping(space)) {
-    ASSERT_LT(time_overlapped_reduce, 1.5 * time_no_overlapped_reduce);
+    state.counters["Time fenced"]     = benchmark::Counter(time_fenced);
+    state.counters["Time not fenced"] = benchmark::Counter(time_not_fenced);
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_range_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_range_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::fence();
+    double time_no_overlapped_reduce = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_range_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space1, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result1);
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_range_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::RangePolicy<TEST_EXECSPACE>(space2, 0, N),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result2);
+    Kokkos::fence();
+    double time_overlapped_reduce = timer.seconds();
+
+    Kokkos::deep_copy(h_result2, result2);
+    Kokkos::deep_copy(h_result1, result1);
+
+    KOKKOS_ASSERT(h_result1() == h_result());
+    KOKKOS_ASSERT(h_result2() == h_result());
+
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_overlapped_reduce < 1.5 * time_no_overlapped_reduce);
+    }
+
+    state.counters["Time Reduce: NonOverlap"] =
+        benchmark::Counter(time_no_overlapped_reduce);
+    state.counters["Time Reduce: Overlap"] =
+        benchmark::Counter(time_overlapped_reduce);
   }
-  printf("Time RangePolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",
-         time_no_overlapped_reduce, time_overlapped_reduce);
 }
 
-TEST(default_exec, overlap_mdrange_policy) {
-  int N = 200;
-  int M = 10000;
-  int R = 10;
+BENCHMARK(OverlapRangePolicy)
+    ->ArgNames({"N", "M", "R"})
+    ->Args({2'000, 10'000, 10});
+
+static void OverlapMDRangePolicy(benchmark::State& state) {
+  int N = state.range(0);
+  int M = state.range(1);
+  int R = state.range(2);
 
   TEST_EXECSPACE space;
   std::vector<TEST_EXECSPACE> execution_space_instances =
@@ -326,178 +338,191 @@ TEST(default_exec, overlap_mdrange_policy) {
   TEST_EXECSPACE space1 = execution_space_instances[0];
   TEST_EXECSPACE space2 = execution_space_instances[1];
 
-  Kokkos::View<double**, TEST_EXECSPACE> a("A", N, M);
-  FunctorMDRange f(M, R, a);
-  FunctorMDRangeReduce fr(M, R, a);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel0",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>({0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorMDRange(M, R, a));
-
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel1",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space1, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel2",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space2, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-
-  Kokkos::Timer timer;
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel3",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel4",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-
-  timer.reset();
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel5",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space1, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorMDRange(M, R, a));
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel6",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space2, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorMDRange(M, R, a));
-  Kokkos::fence();
-  double time_overlap = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel7",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel8",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-  double time_end = timer.seconds();
-
-  if (is_overlapping(space)) {
-    ASSERT_GT(time_end, 1.5 * time_overlap);
-  }
-  printf("Time MDRangePolicy: NonOverlap: %lf Time Overlap: %lf\n", time_end,
-         time_overlap);
-
-  Kokkos::View<double, TEST_EXECSPACE> result("result");
-  Kokkos::View<double, TEST_EXECSPACE> result1("result1");
-  Kokkos::View<double, TEST_EXECSPACE> result2("result2");
-  Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
-  Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
-  Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_mdrange_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::fence();
-  double time_fenced = timer.seconds();
-  Kokkos::deep_copy(h_result, result);
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_mdrange_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  double time_not_fenced = timer.seconds();
-  Kokkos::fence();
-  if (is_overlapping(space)) {
-    ASSERT_GT(time_fenced, 2.0 * time_not_fenced);
-  }
+  for (auto _ : state) {
+    Kokkos::View<double**, TEST_EXECSPACE> a("A", N, M);
+    FunctorMDRange f(M, R, a);
+    FunctorMDRangeReduce fr(M, R, a);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel0",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>({0, 0},
+                                                                   {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorMDRange(M, R, a));
+
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel1",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space1, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel2",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space2, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel3",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel4",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel5",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space1, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorMDRange(M, R, a));
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel6",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space2, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorMDRange(M, R, a));
+    Kokkos::fence();
+    double time_overlap = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel7",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel8",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+    double time_end = timer.seconds();
+
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_end > 1.5 * time_overlap);
+    }
 
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_mdrange_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_mdrange_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::fence();
-  double time_no_overlapped_reduce = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_mdrange_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space1, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result1);
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_mdrange_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(space2, {0, 0},
-                                                                 {N, R}),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result2);
-  Kokkos::fence();
-  double time_overlapped_reduce = timer.seconds();
-
-  Kokkos::deep_copy(h_result2, result2);
-  Kokkos::deep_copy(h_result1, result1);
-
-  ASSERT_EQ(h_result1(), h_result());
-  ASSERT_EQ(h_result2(), h_result());
-
-  if (is_overlapping(space)) {
-    ASSERT_LT(time_overlapped_reduce, 1.5 * time_no_overlapped_reduce);
+    state.counters["Time NonOverlap"] = benchmark::Counter(time_end);
+    state.counters["Time Overlap"]    = benchmark::Counter(time_overlap);
+
+    Kokkos::View<double, TEST_EXECSPACE> result("result");
+    Kokkos::View<double, TEST_EXECSPACE> result1("result1");
+    Kokkos::View<double, TEST_EXECSPACE> result2("result2");
+    Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
+    Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
+    Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_mdrange_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::fence();
+    double time_fenced = timer.seconds();
+    Kokkos::deep_copy(h_result, result);
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_mdrange_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    double time_not_fenced = timer.seconds();
+    Kokkos::fence();
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_fenced > 2.0 * time_not_fenced);
+    }
+
+    state.counters["Time fenced"]     = benchmark::Counter(time_fenced);
+    state.counters["Time not fenced"] = benchmark::Counter(time_not_fenced);
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_mdrange_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_mdrange_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::fence();
+    double time_no_overlapped_reduce = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_mdrange_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space1, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result1);
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_mdrange_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                space2, {0, 0}, {N, R}),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result2);
+    Kokkos::fence();
+    double time_overlapped_reduce = timer.seconds();
+
+    Kokkos::deep_copy(h_result2, result2);
+    Kokkos::deep_copy(h_result1, result1);
+
+    KOKKOS_ASSERT(h_result1() == h_result());
+    KOKKOS_ASSERT(h_result2() == h_result());
+
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_overlapped_reduce < 1.5 * time_no_overlapped_reduce);
+    }
+
+    state.counters["Time Reduce: NonOverlap"] =
+        benchmark::Counter(time_no_overlapped_reduce);
+    state.counters["Time Reduce: Time Overlap"] =
+        benchmark::Counter(time_overlapped_reduce);
   }
-  printf("Time MDRangePolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",
-         time_no_overlapped_reduce, time_overlapped_reduce);
 }
 
-TEST(default_exec, overlap_team_policy) {
-  int N = 20;
-  int M = 1000000;
-  int R = 10;
+BENCHMARK(OverlapMDRangePolicy)
+    ->ArgNames({"N", "M", "R"})
+    ->Args({200, 10'000, 10});
+
+static void OverlapTeamPolicy(benchmark::State& state) {
+  int N = state.range(0);
+  int M = state.range(1);
+  int R = state.range(2);
 
   TEST_EXECSPACE space;
   std::vector<TEST_EXECSPACE> execution_space_instances =
@@ -505,155 +530,170 @@ TEST(default_exec, overlap_team_policy) {
   TEST_EXECSPACE space1 = execution_space_instances[0];
   TEST_EXECSPACE space2 = execution_space_instances[1];
 
-  Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a("A", N, M);
-  FunctorTeam f(M, R, a);
-  FunctorTeamReduce fr(M, R, a);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel0",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorTeam(M, R, a));
-
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel1",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel2",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-
-  Kokkos::Timer timer;
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel3",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel4",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-
-  timer.reset();
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel5",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorTeam(M, R, a));
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel6",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      FunctorTeam(M, R, a));
-  Kokkos::fence();
-  double time_overlap = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel7",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::parallel_for(
-      "default_exec::overlap_range_policy::kernel8",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      f);
-  Kokkos::fence();
-  double time_end = timer.seconds();
-
-  if (is_overlapping(space)) {
-    ASSERT_GT(time_end, 1.5 * time_overlap);
-  }
-  printf("Time TeamPolicy: NonOverlap: %lf Time Overlap: %lf\n", time_end,
-         time_overlap);
-
-  Kokkos::View<double, TEST_EXECSPACE> result("result");
-  Kokkos::View<double, TEST_EXECSPACE> result1("result1");
-  Kokkos::View<double, TEST_EXECSPACE> result2("result2");
-  Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
-  Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
-  Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_team_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::fence();
-  double time_fenced = timer.seconds();
-  Kokkos::deep_copy(h_result, result);
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_team_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  double time_not_fenced = timer.seconds();
-  Kokkos::fence();
-  if (is_overlapping(space)) {
-    ASSERT_GT(time_fenced, 2.0 * time_not_fenced);
-  }
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_team_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_team_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result);
-  Kokkos::fence();
-  double time_no_overlapped_reduce = timer.seconds();
-
-  timer.reset();
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_team_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result1);
-  Kokkos::parallel_reduce(
-      "default_exec::overlap_team_policy::kernel_reduce",
-      Kokkos::Experimental::require(
-          Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
-          Kokkos::Experimental::WorkItemProperty::HintLightWeight),
-      fr, result2);
-  Kokkos::fence();
-  double time_overlapped_reduce = timer.seconds();
-
-  Kokkos::deep_copy(h_result2, result2);
-  Kokkos::deep_copy(h_result1, result1);
-
-  ASSERT_EQ(h_result1(), h_result());
-  ASSERT_EQ(h_result2(), h_result());
-
-  if (is_overlapping(space)) {
-    ASSERT_LT(time_overlapped_reduce, 1.5 * time_no_overlapped_reduce);
+  for (auto _ : state) {
+    Kokkos::View<double**, Kokkos::LayoutRight, TEST_EXECSPACE> a("A", N, M);
+    FunctorTeam f(M, R, a);
+    FunctorTeamReduce fr(M, R, a);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel0",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorTeam(M, R, a));
+
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel1",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel2",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+
+    Kokkos::Timer timer;
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel3",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel4",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel5",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorTeam(M, R, a));
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel6",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        FunctorTeam(M, R, a));
+    Kokkos::fence();
+    double time_overlap = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel7",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::parallel_for(
+        "default_exec::overlap_range_policy::kernel8",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        f);
+    Kokkos::fence();
+    double time_end = timer.seconds();
+
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_end > 1.5 * time_overlap);
+    }
+
+    state.counters["Time NonOverlap"] = benchmark::Counter(time_end);
+    state.counters["Time Overlap"]    = benchmark::Counter(time_overlap);
+
+    Kokkos::View<double, TEST_EXECSPACE> result("result");
+    Kokkos::View<double, TEST_EXECSPACE> result1("result1");
+    Kokkos::View<double, TEST_EXECSPACE> result2("result2");
+    Kokkos::View<double, Kokkos::HostSpace> h_result("h_result");
+    Kokkos::View<double, Kokkos::HostSpace> h_result1("h_result1");
+    Kokkos::View<double, Kokkos::HostSpace> h_result2("h_result2");
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_team_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::fence();
+    double time_fenced = timer.seconds();
+    Kokkos::deep_copy(h_result, result);
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_team_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    double time_not_fenced = timer.seconds();
+    Kokkos::fence();
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_fenced > 2.0 * time_not_fenced);
+    }
+
+    state.counters["Time fenced"]     = benchmark::Counter(time_fenced);
+    state.counters["Time not fenced"] = benchmark::Counter(time_not_fenced);
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_team_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_team_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result);
+    Kokkos::fence();
+    double time_no_overlapped_reduce = timer.seconds();
+
+    timer.reset();
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_team_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space1, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result1);
+    Kokkos::parallel_reduce(
+        "default_exec::overlap_team_policy::kernel_reduce",
+        Kokkos::Experimental::require(
+            Kokkos::TeamPolicy<TEST_EXECSPACE>(space2, N, Kokkos::AUTO),
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight),
+        fr, result2);
+    Kokkos::fence();
+    double time_overlapped_reduce = timer.seconds();
+
+    Kokkos::deep_copy(h_result2, result2);
+    Kokkos::deep_copy(h_result1, result1);
+
+    KOKKOS_ASSERT(h_result1() == h_result());
+    KOKKOS_ASSERT(h_result2() == h_result());
+
+    if (is_overlapping(space)) {
+      KOKKOS_ASSERT(time_overlapped_reduce < 1.5 * time_no_overlapped_reduce);
+    }
+
+    state.counters["Time Reduce: NonOverlap"] =
+        benchmark::Counter(time_no_overlapped_reduce);
+    state.counters["Time Reduce: Time Overlap"] =
+        benchmark::Counter(time_overlapped_reduce);
   }
-  printf("Time TeamPolicy Reduce: NonOverlap: %lf Time Overlap: %lf\n",
-         time_no_overlapped_reduce, time_overlapped_reduce);
 }
+
+BENCHMARK(OverlapTeamPolicy)
+    ->ArgNames({"N", "M", "R"})
+    ->Args({20, 1'000'000, 10});
+
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewAllocate.cpp b/core/perf_test/PerfTest_ViewAllocate.cpp
index c1d9895847..63f1d6b2c7 100644
--- a/core/perf_test/PerfTest_ViewAllocate.cpp
+++ b/core/perf_test/PerfTest_ViewAllocate.cpp
@@ -15,119 +15,218 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <cstdio>
-#include <PerfTest_Category.hpp>
+#include <benchmark/benchmark.h>
+#include "Benchmark_Context.hpp"
 
 namespace Test {
 
+static constexpr int N = 10;
+
 template <class Layout>
-void run_allocateview_tests(int N, int R) {
-  const int N1 = N;
-  const int N2 = N * N;
-  const int N3 = N2 * N;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
-
-  double time1, time2, time3, time4, time5, time6, time7, time8,
-      time_raw = 100000.0;
-  {
+static void ViewAllocate_Rank1(benchmark::State& state) {
+  const int N8 = std::pow(state.range(0), 8);
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a("A1", N8);
-    }
-    time1 = timer.seconds() / R;
+    Kokkos::View<double*, Layout> a("A1", N8);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank2(benchmark::State& state) {
+  const int N4 = std::pow(state.range(0), 4);
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double**, Layout> a("A2", N4, N4);
-    }
-    time2 = timer.seconds() / R;
+    Kokkos::View<double**, Layout> a("A2", N4, N4);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank3(benchmark::State& state) {
+  const int N2 = std::pow(state.range(0), 2);
+  const int N3 = std::pow(state.range(0), 3);
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
-    }
-    time3 = timer.seconds() / R;
+    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank4(benchmark::State& state) {
+  const int N2 = std::pow(state.range(0), 2);
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
-    }
-    time4 = timer.seconds() / R;
+    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank5(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
-    }
-    time5 = timer.seconds() / R;
+    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank6(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
-    }
-    time6 = timer.seconds() / R;
+    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank7(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
-    }
-    time7 = timer.seconds() / R;
+    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Rank8(benchmark::State& state) {
+  const int N1 = state.range(0);
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
-                                             N1);
-    }
-    time8 = timer.seconds() / R;
+    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
+                                           N1);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
+}
+
+template <class Layout>
+static void ViewAllocate_Raw(benchmark::State& state) {
+  const int N8 = std::pow(state.range(0), 8);
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      double* a_ptr =
-          static_cast<double*>(Kokkos::kokkos_malloc("A", sizeof(double) * N8));
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 0.0; });
-      Kokkos::fence();
-      Kokkos::kokkos_free(a_ptr);
-    }
-    time_raw = timer.seconds() / R;
+    double* a_ptr =
+        static_cast<double*>(Kokkos::kokkos_malloc("A", sizeof(double) * N8));
+    Kokkos::parallel_for(
+        N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 0.0; });
+    Kokkos::fence();
+    const auto time = timer.seconds();
+    Kokkos::kokkos_free(a_ptr);
+
+    state.SetIterationTime(time);
+    // data processed in megabytes
+    const double data_processed = 1 * N8 * sizeof(double) / 1'000'000;
+    state.counters["MB"]        = benchmark::Counter(data_processed);
+    state.counters[KokkosBenchmark::benchmark_fom("GB/s")] = benchmark::Counter(
+        data_processed / 1'000, benchmark::Counter::kIsIterationInvariantRate);
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         size / 1024 / time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
-         size / 1024 / time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
-         size / 1024 / time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
-         size / 1024 / time3);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
-         size / 1024 / time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
-         size / 1024 / time5);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
-         size / 1024 / time6);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
-         size / 1024 / time7);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
-         size / 1024 / time8);
 }
 
-TEST(default_exec, ViewCreate) {
-  printf("Create View Performance for LayoutLeft:\n");
-  run_allocateview_tests<Kokkos::LayoutLeft>(10, 1);
-  printf("Create View Performance for LayoutRight:\n");
-  run_allocateview_tests<Kokkos::LayoutRight>(10, 1);
-}
+BENCHMARK(ViewAllocate_Rank1<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank1<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank2<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank2<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank3<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank3<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank4<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank4<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank5<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank5<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank6<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank6<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank7<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank7<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank8<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Rank8<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+BENCHMARK(ViewAllocate_Raw<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewAllocate_Raw<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+#endif
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewCopy.hpp b/core/perf_test/PerfTest_ViewCopy.hpp
index b0216ca6fc..b7b1e1ad48 100644
--- a/core/perf_test/PerfTest_ViewCopy.hpp
+++ b/core/perf_test/PerfTest_ViewCopy.hpp
@@ -18,32 +18,15 @@
 #define KOKKOS_CORE_PERFTEST_BENCHMARK_VIEW_COPY_HPP
 
 #include <Kokkos_Core.hpp>
+
 #include <benchmark/benchmark.h>
+
+#include "Benchmark_Context.hpp"
 #include <cmath>
 
 namespace Test {
 
-/**
- * \brief Mark the label as a figure of merit.
- */
-inline std::string benchmark_fom(const std::string& label) {
-  return "FOM: " + label;
-}
-
-inline void report_results(benchmark::State& state, std::size_t num_elems,
-                           double time) {
-  state.SetIterationTime(time);
-
-  // data size in megabytes
-  const auto size = 1.0 * num_elems * sizeof(double) / 1000 / 1000;
-  // data processed in gigabytes
-  const auto data_processed = 2 * size / 1000;
-
-  state.counters["MB"] =
-      benchmark::Counter(size, benchmark::Counter::kDefaults);
-  state.counters[benchmark_fom("GB/s")] = benchmark::Counter(
-      data_processed, benchmark::Counter::kIsIterationInvariantRate);
-}
+static constexpr int DATA_RATIO = 2;
 
 template <class ViewTypeA, class ViewTypeB>
 void deepcopy_view(ViewTypeA& a, ViewTypeB& b, benchmark::State& state) {
@@ -51,7 +34,7 @@ void deepcopy_view(ViewTypeA& a, ViewTypeB& b, benchmark::State& state) {
     Kokkos::fence();
     Kokkos::Timer timer;
     Kokkos::deep_copy(a, b);
-    report_results(state, a.size(), timer.seconds());
+    KokkosBenchmark::report_results(state, a, DATA_RATIO, timer.seconds());
   }
 }
 
@@ -158,8 +141,7 @@ static void ViewDeepCopy_Raw(benchmark::State& state) {
     Kokkos::parallel_for(
         N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = b_ptr[i]; });
     Kokkos::fence();
-
-    report_results(state, a.size(), timer.seconds());
+    KokkosBenchmark::report_results(state, a, DATA_RATIO, timer.seconds());
   }
 }
 
diff --git a/core/perf_test/PerfTest_ViewCopy_Raw.cpp b/core/perf_test/PerfTest_ViewCopy_Raw.cpp
index 976f800487..67a8d7e555 100644
--- a/core/perf_test/PerfTest_ViewCopy_Raw.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_Raw.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_a123.cpp b/core/perf_test/PerfTest_ViewCopy_a123.cpp
index 3fc1c2480c..db33d11809 100644
--- a/core/perf_test/PerfTest_ViewCopy_a123.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_a123.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_a45.cpp b/core/perf_test/PerfTest_ViewCopy_a45.cpp
index 542f5534be..3200602566 100644
--- a/core/perf_test/PerfTest_ViewCopy_a45.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_a45.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_a6.cpp b/core/perf_test/PerfTest_ViewCopy_a6.cpp
index 782628072d..0855299aad 100644
--- a/core/perf_test/PerfTest_ViewCopy_a6.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_a6.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_a7.cpp b/core/perf_test/PerfTest_ViewCopy_a7.cpp
index 000c8b401c..36577ef2ef 100644
--- a/core/perf_test/PerfTest_ViewCopy_a7.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_a7.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_a8.cpp b/core/perf_test/PerfTest_ViewCopy_a8.cpp
index f7d7c6040a..c449d684f1 100644
--- a/core/perf_test/PerfTest_ViewCopy_a8.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_a8.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_b123.cpp b/core/perf_test/PerfTest_ViewCopy_b123.cpp
index 7820e89973..8675f427d7 100644
--- a/core/perf_test/PerfTest_ViewCopy_b123.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_b123.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_b45.cpp b/core/perf_test/PerfTest_ViewCopy_b45.cpp
index 58f58314b0..93522fcf0d 100644
--- a/core/perf_test/PerfTest_ViewCopy_b45.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_b45.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_b6.cpp b/core/perf_test/PerfTest_ViewCopy_b6.cpp
index 920bf1222f..be95c7cab3 100644
--- a/core/perf_test/PerfTest_ViewCopy_b6.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_b6.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_b7.cpp b/core/perf_test/PerfTest_ViewCopy_b7.cpp
index 11b7a0d0d1..f8eee75ce7 100644
--- a/core/perf_test/PerfTest_ViewCopy_b7.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_b7.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_b8.cpp b/core/perf_test/PerfTest_ViewCopy_b8.cpp
index 56a3d8d4c3..01dda2a33f 100644
--- a/core/perf_test/PerfTest_ViewCopy_b8.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_b8.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_c123.cpp b/core/perf_test/PerfTest_ViewCopy_c123.cpp
index 375f7c8985..25e8747474 100644
--- a/core/perf_test/PerfTest_ViewCopy_c123.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_c123.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_c45.cpp b/core/perf_test/PerfTest_ViewCopy_c45.cpp
index 3625631617..b1f4a7b577 100644
--- a/core/perf_test/PerfTest_ViewCopy_c45.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_c45.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_c6.cpp b/core/perf_test/PerfTest_ViewCopy_c6.cpp
index bcb70b6764..8120664792 100644
--- a/core/perf_test/PerfTest_ViewCopy_c6.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_c6.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_c7.cpp b/core/perf_test/PerfTest_ViewCopy_c7.cpp
index 055d0e344c..cee9f5bd01 100644
--- a/core/perf_test/PerfTest_ViewCopy_c7.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_c7.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_c8.cpp b/core/perf_test/PerfTest_ViewCopy_c8.cpp
index 1e5342ef52..6f204a4222 100644
--- a/core/perf_test/PerfTest_ViewCopy_c8.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_c8.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_d123.cpp b/core/perf_test/PerfTest_ViewCopy_d123.cpp
index d61e01f9f6..6d72bea490 100644
--- a/core/perf_test/PerfTest_ViewCopy_d123.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_d123.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_d45.cpp b/core/perf_test/PerfTest_ViewCopy_d45.cpp
index 385d5b48ae..1a407cd648 100644
--- a/core/perf_test/PerfTest_ViewCopy_d45.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_d45.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_d6.cpp b/core/perf_test/PerfTest_ViewCopy_d6.cpp
index 0ae16012d6..27b1a816fc 100644
--- a/core/perf_test/PerfTest_ViewCopy_d6.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_d6.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_d7.cpp b/core/perf_test/PerfTest_ViewCopy_d7.cpp
index 4ebbb6359b..17d4bf2077 100644
--- a/core/perf_test/PerfTest_ViewCopy_d7.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_d7.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewCopy_d8.cpp b/core/perf_test/PerfTest_ViewCopy_d8.cpp
index 3a888b6155..7bd0263228 100644
--- a/core/perf_test/PerfTest_ViewCopy_d8.cpp
+++ b/core/perf_test/PerfTest_ViewCopy_d8.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewCopy.hpp>
+#include "PerfTest_ViewCopy.hpp"
 
 namespace Test {
 
diff --git a/core/perf_test/PerfTest_ViewFill.hpp b/core/perf_test/PerfTest_ViewFill.hpp
index 7f76ed0ff7..cc5eed85f7 100644
--- a/core/perf_test/PerfTest_ViewFill.hpp
+++ b/core/perf_test/PerfTest_ViewFill.hpp
@@ -14,202 +14,115 @@
 //
 //@HEADER
 
-#include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <cstdio>
-#include <PerfTest_Category.hpp>
+#include "Benchmark_Context.hpp"
+
+#include <cmath>
 
 namespace Test {
 
+static constexpr int N = 10;
+
 template <class ViewType>
-double fill_view(ViewType& a, typename ViewType::const_value_type& val,
-                 int repeat) {
-  Kokkos::Timer timer;
-  for (int i = 0; i < repeat; i++) {
+void fill_view(ViewType& a, typename ViewType::const_value_type& val,
+               benchmark::State& state) {
+  for (auto _ : state) {
+    Kokkos::fence();
+    Kokkos::Timer timer;
     Kokkos::deep_copy(a, val);
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-  Kokkos::fence();
-  return timer.seconds();
 }
 
 template <class Layout>
-void run_fillview_tests123(int N, int R) {
-  const int N1 = N;
+static void ViewFill_Rank1(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N3 = N2 * N1;
   const int N4 = N2 * N2;
   const int N8 = N4 * N4;
 
-  double time1, time2, time3, time_raw = 100000.0;
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    time1 = fill_view(a, 1.1, R) / R;
-  }
-  {
-    Kokkos::View<double**, Layout> a("A2", N4, N4);
-    time2 = fill_view(a, 1.1, R) / R;
-  }
-  {
-    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
-    time3 = fill_view(a, 1.1, R) / R;
-  }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
-  }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         size / 1024 / time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
-         size / 1024 / time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
-         size / 1024 / time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
-         size / 1024 / time3);
+  Kokkos::View<double*, Layout> a("A1", N8);
+  fill_view(a, 1.1, state);
 }
 
 template <class Layout>
-void run_fillview_tests45(int N, int R) {
-  const int N1 = N;
+static void ViewFill_Rank2(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
   const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
 
-  double time4, time5, time_raw = 100000.0;
-  {
-    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
-    time4 = fill_view(a, 1.1, R) / R;
-  }
-  {
-    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
-    time5 = fill_view(a, 1.1, R) / R;
-  }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
-  }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         size / 1024 / time_raw);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
-         size / 1024 / time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
-         size / 1024 / time5);
+  Kokkos::View<double**, Layout> a("A2", N4, N4);
+  fill_view(a, 1.1, state);
 }
 
 template <class Layout>
-void run_fillview_tests6(int N, int R) {
-  const int N1 = N;
+static void ViewFill_Rank3(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
+  const int N3 = N2 * N1;
 
-  double time6, time_raw = 100000.0;
-  {
-    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
-    time6 = fill_view(a, 1.1, R) / R;
-  }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
-  }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         size / 1024 / time_raw);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
-         size / 1024 / time6);
+  Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+  fill_view(a, 1.1, state);
 }
 
 template <class Layout>
-void run_fillview_tests7(int N, int R) {
-  const int N1 = N;
+static void ViewFill_Rank4(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
 
-  double time7, time_raw = 100000.0;
-  {
-    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
-    time7 = fill_view(a, 1.1, R) / R;
-  }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
-  }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         size / 1024 / time_raw);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
-         size / 1024 / time7);
+  Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+  fill_view(a, 1.1, state);
 }
 
 template <class Layout>
-void run_fillview_tests8(int N, int R) {
-  const int N1 = N;
+static void ViewFill_Rank5(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
 
-  double time8, time_raw = 100000.0;
-  {
-    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
-                                           N1);
-    time8 = fill_view(a, 1.1, R) / R;
-  }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
+  Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+  fill_view(a, 1.1, state);
+}
+
+template <class Layout>
+static void ViewFill_Rank6(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+  fill_view(a, 1.1, state);
+}
+
+template <class Layout>
+static void ViewFill_Rank7(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+  fill_view(a, 1.1, state);
+}
+
+template <class Layout>
+static void ViewFill_Rank8(benchmark::State& state) {
+  const int N1 = state.range(0);
+
+  Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1, N1);
+  fill_view(a, 1.1, state);
+}
+
+template <class Layout>
+static void ViewFill_Raw(benchmark::State& state) {
+  const int N8 = std::pow(state.range(0), 8);
+
+  Kokkos::View<double*, Layout> a("A1", N8);
+  double* a_ptr = a.data();
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
-    }
+    Kokkos::parallel_for(
+        N8, KOKKOS_LAMBDA(const int& i) { a_ptr[i] = 1.1; });
     Kokkos::fence();
-    time_raw = timer.seconds() / R;
+
+    KokkosBenchmark::report_results(state, a, 1, timer.seconds());
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         size / 1024 / time_raw);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
-         size / 1024 / time8);
 }
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewFill_123.cpp b/core/perf_test/PerfTest_ViewFill_123.cpp
index 1e050e2311..b95b5279a1 100644
--- a/core/perf_test/PerfTest_ViewFill_123.cpp
+++ b/core/perf_test/PerfTest_ViewFill_123.cpp
@@ -14,13 +14,38 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewFill.hpp>
+#include "PerfTest_ViewFill.hpp"
 
 namespace Test {
-TEST(default_exec, ViewFill_Rank123) {
-  printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests123<Kokkos::LayoutLeft>(10, 1);
-  printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests123<Kokkos::LayoutRight>(10, 1);
-}
+
+BENCHMARK(ViewFill_Rank1<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank1<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank2<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank2<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank3<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank3<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewFill_45.cpp b/core/perf_test/PerfTest_ViewFill_45.cpp
index 2bf93b2048..6a5acfb0d6 100644
--- a/core/perf_test/PerfTest_ViewFill_45.cpp
+++ b/core/perf_test/PerfTest_ViewFill_45.cpp
@@ -14,13 +14,28 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewFill.hpp>
+#include "PerfTest_ViewFill.hpp"
 
 namespace Test {
-TEST(default_exec, ViewFill_Rank45) {
-  printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests45<Kokkos::LayoutLeft>(10, 1);
-  printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests45<Kokkos::LayoutRight>(10, 1);
-}
+
+BENCHMARK(ViewFill_Rank4<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank4<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank5<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank5<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewFill_6.cpp b/core/perf_test/PerfTest_ViewFill_6.cpp
index 588a1e2293..dca20c70df 100644
--- a/core/perf_test/PerfTest_ViewFill_6.cpp
+++ b/core/perf_test/PerfTest_ViewFill_6.cpp
@@ -14,13 +14,18 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewFill.hpp>
+#include "PerfTest_ViewFill.hpp"
 
 namespace Test {
-TEST(default_exec, ViewFill_Rank6) {
-  printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests6<Kokkos::LayoutLeft>(10, 1);
-  printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests6<Kokkos::LayoutRight>(10, 1);
-}
+
+BENCHMARK(ViewFill_Rank6<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank6<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewFill_7.cpp b/core/perf_test/PerfTest_ViewFill_7.cpp
index fffeb951c9..6fa8a418c6 100644
--- a/core/perf_test/PerfTest_ViewFill_7.cpp
+++ b/core/perf_test/PerfTest_ViewFill_7.cpp
@@ -14,13 +14,18 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewFill.hpp>
+#include "PerfTest_ViewFill.hpp"
 
 namespace Test {
-TEST(default_exec, ViewFill_Rank7) {
-  printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests7<Kokkos::LayoutLeft>(10, 1);
-  printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests7<Kokkos::LayoutRight>(10, 1);
-}
+
+BENCHMARK(ViewFill_Rank7<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank7<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewFill_8.cpp b/core/perf_test/PerfTest_ViewFill_8.cpp
index b2188af1a3..954b097d83 100644
--- a/core/perf_test/PerfTest_ViewFill_8.cpp
+++ b/core/perf_test/PerfTest_ViewFill_8.cpp
@@ -14,13 +14,18 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewFill.hpp>
+#include "PerfTest_ViewFill.hpp"
 
 namespace Test {
-TEST(default_exec, ViewFill_Rank8) {
-  printf("ViewFill Performance for LayoutLeft:\n");
-  run_fillview_tests8<Kokkos::LayoutLeft>(10, 1);
-  printf("ViewFill Performance for LayoutRight:\n");
-  run_fillview_tests8<Kokkos::LayoutRight>(10, 1);
-}
+
+BENCHMARK(ViewFill_Rank8<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
+BENCHMARK(ViewFill_Rank8<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
+
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestRandomCommon.hpp b/core/perf_test/PerfTest_ViewFill_Raw.cpp
similarity index 65%
rename from algorithms/unit_tests/TestRandomCommon.hpp
rename to core/perf_test/PerfTest_ViewFill_Raw.cpp
index c53d66f4d0..c11074d915 100644
--- a/algorithms/unit_tests/TestRandomCommon.hpp
+++ b/core/perf_test/PerfTest_ViewFill_Raw.cpp
@@ -14,19 +14,20 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TESTRANDOM_COMMON_HPP
-#define KOKKOS_ALGORITHMS_UNITTESTS_TESTRANDOM_COMMON_HPP
-
-#include <TestRandom.hpp>
+#include "PerfTest_ViewFill.hpp"
 
 namespace Test {
 
-TEST(TEST_CATEGORY, Random_XorShift64) {
-  test_random_xorshift64<TEST_EXECSPACE>();
-}
-TEST(TEST_CATEGORY, Random_XorShift1024_0) {
-  test_random_xorshift1024<TEST_EXECSPACE>();
-}
-}  // namespace Test
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+BENCHMARK(ViewFill_Raw<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
 
+BENCHMARK(ViewFill_Raw<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime();
 #endif
+
+}  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewResize.hpp b/core/perf_test/PerfTest_ViewResize.hpp
index dfcd3f1347..de6981e17a 100644
--- a/core/perf_test/PerfTest_ViewResize.hpp
+++ b/core/perf_test/PerfTest_ViewResize.hpp
@@ -15,346 +15,291 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <gtest/gtest.h>
-#include <cstdio>
-#include <PerfTest_Category.hpp>
+#include <benchmark/benchmark.h>
+#include <cmath>
+#include "Benchmark_Context.hpp"
 
 namespace Test {
 
+static constexpr int R = 10;
+static constexpr int N = 10;
+
 template <class Layout>
-void run_resizeview_tests123(int N, int R) {
-  const int N1 = N;
-  const int N2 = N1 * N1;
-  const int N3 = N2 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
-
-  double time1, time2, time3, time_raw = 100000.0;
-  double time1_noinit, time2_noinit, time3_noinit;
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a_(a);
-      Kokkos::resize(a_, int(N8 * 1.1));
-    }
-    time1 = timer.seconds() / R;
-  }
-  {
-    Kokkos::View<double**, Layout> a("A2", N4, N4);
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double**, Layout> a_(a);
-      Kokkos::resize(a_, int(N4 * 1.1), N4);
-    }
-    time2 = timer.seconds() / R;
-  }
-  {
-    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double***, Layout> a_(a);
-      Kokkos::resize(a_, int(N3 * 1.1), N3, N2);
-    }
-    time3 = timer.seconds() / R;
-  }
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
+static void ViewResize_Rank1(benchmark::State& state) {
+  const int N8 = std::pow(state.range(0), 8);
+  Kokkos::View<double*, Layout> a("A1", N8);
+  Kokkos::View<double*, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N8 * 1.1));
-    }
-    time1_noinit = timer.seconds() / R;
+    Kokkos::resize(a_, int(N8 * 1.1));
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double**, Layout> a("A2", N4, N4);
+}
+
+template <class Layout>
+static void ViewResize_Rank2(benchmark::State& state) {
+  const int N4 = std::pow(state.range(0), 4);
+  Kokkos::View<double**, Layout> a("A2", N4, N4);
+  Kokkos::View<double**, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double**, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N4 * 1.1), N4);
-    }
-    time2_noinit = timer.seconds() / R;
+    Kokkos::resize(a_, int(N4 * 1.1), N4);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+}
+
+template <class Layout>
+static void ViewResize_Rank3(benchmark::State& state) {
+  const int N2 = std::pow(state.range(0), 2);
+  const int N3 = std::pow(state.range(0), 3);
+  Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+  Kokkos::View<double***, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double***, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N3 * 1.1), N3, N2);
-    }
-    time3_noinit = timer.seconds() / R;
+    Kokkos::resize(a_, int(N3 * 1.1), N3, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
+}
+
+template <class Layout>
+static void ViewResize_Rank4(benchmark::State& state) {
+  const int N2 = std::pow(state.range(0), 2);
+  Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+  Kokkos::View<double****, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a1(
-          Kokkos::view_alloc(Kokkos::WithoutInitializing, "A1"), int(N8 * 1.1));
-      double* a1_ptr = a1.data();
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
-      Kokkos::fence();
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
+    Kokkos::resize(a_, int(N2 * 1.1), N2, N2, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         2.0 * size / 1024 / time_raw);
-  printf("   Rank1: %lf s   %lf MB   %lf GB/s\n", time1, size,
-         2.0 * size / 1024 / time1);
-  printf("   Rank2: %lf s   %lf MB   %lf GB/s\n", time2, size,
-         2.0 * size / 1024 / time2);
-  printf("   Rank3: %lf s   %lf MB   %lf GB/s\n", time3, size,
-         2.0 * size / 1024 / time3);
-  printf("   Rank1 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time1_noinit, size, 2.0 * size / 1024 / time1_noinit);
-  printf("   Rank2 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time2_noinit, size, 2.0 * size / 1024 / time2_noinit);
-  printf("   Rank3 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time3_noinit, size, 2.0 * size / 1024 / time3_noinit);
 }
 
 template <class Layout>
-void run_resizeview_tests45(int N, int R) {
-  const int N1 = N;
+static void ViewResize_Rank5(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
 
-  double time4, time5, time_raw = 100000.0;
-  double time4_noinit, time5_noinit;
-  {
-    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+  Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+  Kokkos::View<double*****, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double****, Layout> a_(a);
-      Kokkos::resize(a_, int(N2 * 1.1), N2, N2, N2);
-    }
-    time4 = timer.seconds() / R;
+    Kokkos::resize(a_, int(N2 * 1.1), N2, N1, N1, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+}
+
+template <class Layout>
+static void ViewResize_Rank6(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+  Kokkos::View<double******, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*****, Layout> a_(a);
-      Kokkos::resize(a_, int(N2 * 1.1), N2, N1, N1, N2);
-    }
-    time5 = timer.seconds() / R;
+    Kokkos::resize(a_, int(N2 * 1.1), N1, N1, N1, N1, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+}
+
+template <class Layout>
+static void ViewResize_Rank7(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+  Kokkos::View<double*******, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double****, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N2, N2,
-                     N2);
-    }
-    time4_noinit = timer.seconds() / R;
+    Kokkos::resize(a_, int(N2 * 1.1), N1, N1, N1, N1, N1, N1);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+}
+
+template <class Layout>
+static void ViewResize_Rank8(benchmark::State& state) {
+  const int N1 = state.range(0);
+
+  Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1, N1);
+  Kokkos::View<double********, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*****, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N2, N1, N1,
-                     N2);
-    }
-    time5_noinit = timer.seconds() / R;
+    Kokkos::resize(a_, int(N1 * 1.1), N1, N1, N1, N1, N1, N1, N1);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
+}
+
+template <class Layout>
+static void ViewResize_NoInit_Rank1(benchmark::State& state) {
+  const int N8 = std::pow(state.range(0), 8);
+  Kokkos::View<double*, Layout> a("A1", N8);
+  Kokkos::View<double*, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a1(
-          Kokkos::view_alloc(Kokkos::WithoutInitializing, "A1"), int(N8 * 1.1));
-      double* a1_ptr = a1.data();
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
-      Kokkos::fence();
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N8 * 1.1));
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         2.0 * size / 1024 / time_raw);
-  printf("   Rank4: %lf s   %lf MB   %lf GB/s\n", time4, size,
-         2.0 * size / 1024 / time4);
-  printf("   Rank5: %lf s   %lf MB   %lf GB/s\n", time5, size,
-         2.0 * size / 1024 / time5);
-  printf("   Rank4 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time4_noinit, size, 2.0 * size / 1024 / time4_noinit);
-  printf("   Rank5 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time5_noinit, size, 2.0 * size / 1024 / time5_noinit);
 }
 
 template <class Layout>
-void run_resizeview_tests6(int N, int R) {
-  const int N1 = N;
-  const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
+static void ViewResize_NoInit_Rank2(benchmark::State& state) {
+  const int N4 = std::pow(state.range(0), 4);
+  Kokkos::View<double**, Layout> a("A2", N4, N4);
+  Kokkos::View<double**, Layout> a_(a);
 
-  double time6, time6_noinit, time_raw = 100000.0;
-  {
-    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double******, Layout> a_(a);
-      Kokkos::resize(a_, int(N2 * 1.1), N1, N1, N1, N1, N2);
-    }
-    time6 = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N4 * 1.1), N4);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+}
+
+template <class Layout>
+static void ViewResize_NoInit_Rank3(benchmark::State& state) {
+  const int N2 = std::pow(state.range(0), 2);
+  const int N3 = std::pow(state.range(0), 3);
+  Kokkos::View<double***, Layout> a("A3", N3, N3, N2);
+  Kokkos::View<double***, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double******, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N1, N1, N1,
-                     N1, N2);
-    }
-    time6_noinit = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N3 * 1.1), N3, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
+}
+
+template <class Layout>
+static void ViewResize_NoInit_Rank4(benchmark::State& state) {
+  const int N2 = std::pow(state.range(0), 2);
+  Kokkos::View<double****, Layout> a("A4", N2, N2, N2, N2);
+  Kokkos::View<double****, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a1(
-          Kokkos::view_alloc(Kokkos::WithoutInitializing, "A1"), int(N8 * 1.1));
-      double* a1_ptr = a1.data();
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
-      Kokkos::fence();
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N2, N2, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         2.0 * size / 1024 / time_raw);
-  printf("   Rank6: %lf s   %lf MB   %lf GB/s\n", time6, size,
-         2.0 * size / 1024 / time6);
-  printf("   Rank6 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time6_noinit, size, 2.0 * size / 1024 / time6_noinit);
 }
 
 template <class Layout>
-void run_resizeview_tests7(int N, int R) {
-  const int N1 = N;
+static void ViewResize_NoInit_Rank5(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
 
-  double time7, time7_noinit, time_raw = 100000.0;
-  {
-    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
-    Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*******, Layout> a_(a);
-      Kokkos::resize(a_, int(N2 * 1.1), N1, N1, N1, N1, N1, N1);
-    }
-    time7 = timer.seconds() / R;
-  }
-  {
-    Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+  Kokkos::View<double*****, Layout> a("A5", N2, N2, N1, N1, N2);
+  Kokkos::View<double*****, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*******, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N1, N1, N1,
-                     N1, N1, N1);
-    }
-    time7_noinit = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N2, N1, N1,
+                   N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
+}
+
+template <class Layout>
+static void ViewResize_NoInit_Rank6(benchmark::State& state) {
+  const int N1 = state.range(0);
+  const int N2 = N1 * N1;
+
+  Kokkos::View<double******, Layout> a("A6", N2, N1, N1, N1, N1, N2);
+  Kokkos::View<double******, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a1(
-          Kokkos::view_alloc(Kokkos::WithoutInitializing, "A1"), int(N8 * 1.1));
-      double* a1_ptr = a1.data();
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
-      Kokkos::fence();
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N1, N1, N1,
+                   N1, N2);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         2.0 * size / 1024 / time_raw);
-  printf("   Rank7: %lf s   %lf MB   %lf GB/s\n", time7, size,
-         2.0 * size / 1024 / time7);
-  printf("   Rank7 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time7_noinit, size, 2.0 * size / 1024 / time7_noinit);
 }
 
 template <class Layout>
-void run_resizeview_tests8(int N, int R) {
-  const int N1 = N;
+static void ViewResize_NoInit_Rank7(benchmark::State& state) {
+  const int N1 = state.range(0);
   const int N2 = N1 * N1;
-  const int N4 = N2 * N2;
-  const int N8 = N4 * N4;
 
-  double time8, time8_noinit, time_raw = 100000.0;
-  {
-    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
-                                           N1);
+  Kokkos::View<double*******, Layout> a("A7", N2, N1, N1, N1, N1, N1, N1);
+  Kokkos::View<double*******, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double********, Layout> a_(a);
-      Kokkos::resize(a_, int(N1 * 1.1), N1, N1, N1, N1, N1, N1, N1);
-    }
-    time8 = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N2 * 1.1), N1, N1, N1,
+                   N1, N1, N1);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-  {
-    Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1,
-                                           N1);
+}
+
+template <class Layout>
+static void ViewResize_NoInit_Rank8(benchmark::State& state) {
+  const int N1 = state.range(0);
+
+  Kokkos::View<double********, Layout> a("A8", N1, N1, N1, N1, N1, N1, N1, N1);
+  Kokkos::View<double********, Layout> a_(a);
+
+  for (auto _ : state) {
+    Kokkos::fence();
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double********, Layout> a_(a);
-      Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N1 * 1.1), N1, N1, N1,
-                     N1, N1, N1, N1);
-    }
-    time8_noinit = timer.seconds() / R;
+    Kokkos::resize(Kokkos::WithoutInitializing, a_, int(N1 * 1.1), N1, N1, N1,
+                   N1, N1, N1, N1);
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
-  {
-    Kokkos::View<double*, Layout> a("A1", N8);
-    double* a_ptr = a.data();
+}
+
+template <class Layout>
+static void ViewResize_NoInit_Raw(benchmark::State& state) {
+  const int N8 = std::pow(state.range(0), 8);
+  Kokkos::View<double*, Layout> a("A1", N8);
+  double* a_ptr = a.data();
+
+  for (auto _ : state) {
     Kokkos::Timer timer;
-    for (int r = 0; r < R; r++) {
-      Kokkos::View<double*, Layout> a1(
-          Kokkos::view_alloc(Kokkos::WithoutInitializing, "A1"), int(N8 * 1.1));
-      double* a1_ptr = a1.data();
-      Kokkos::parallel_for(
-          N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
-      Kokkos::fence();
-    }
-    Kokkos::fence();
-    time_raw = timer.seconds() / R;
+    Kokkos::View<double*, Layout> a1(
+        Kokkos::view_alloc(Kokkos::WithoutInitializing, "A1"), int(N8 * 1.1));
+    double* a1_ptr = a1.data();
+    Kokkos::parallel_for(
+        N8, KOKKOS_LAMBDA(const int& i) { a1_ptr[i] = a_ptr[i]; });
+    Kokkos::fence();
+    KokkosBenchmark::report_results(state, a, 2, timer.seconds());
   }
-#endif
-  double size = 1.0 * N8 * 8 / 1024 / 1024;
-  printf("   Raw:   %lf s   %lf MB   %lf GB/s\n", time_raw, size,
-         2.0 * size / 1024 / time_raw);
-  printf("   Rank8: %lf s   %lf MB   %lf GB/s\n", time8, size,
-         2.0 * size / 1024 / time8);
-  printf("   Rank8 (WithoutInitializing): %lf s   %lf MB   %lf GB/s\n",
-         time8_noinit, size, 2.0 * size / 1024 / time8_noinit);
 }
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewResize_123.cpp b/core/perf_test/PerfTest_ViewResize_123.cpp
index ed2e58192c..0b3141eead 100644
--- a/core/perf_test/PerfTest_ViewResize_123.cpp
+++ b/core/perf_test/PerfTest_ViewResize_123.cpp
@@ -14,15 +14,80 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewResize.hpp>
+#include "PerfTest_ViewResize.hpp"
 
 namespace Test {
 
-TEST(default_exec, ViewResize_Rank123) {
-  printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests123<Kokkos::LayoutLeft>(10, 1);
-  printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests123<Kokkos::LayoutRight>(10, 1);
-}
+BENCHMARK(ViewResize_Rank1<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank1<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank2<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank2<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank3<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank3<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank1<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank1<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank2<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank2<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank3<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank3<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewResize_45.cpp b/core/perf_test/PerfTest_ViewResize_45.cpp
index 69028fab08..f5eec387cb 100644
--- a/core/perf_test/PerfTest_ViewResize_45.cpp
+++ b/core/perf_test/PerfTest_ViewResize_45.cpp
@@ -14,15 +14,56 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewResize.hpp>
+#include "PerfTest_ViewResize.hpp"
 
 namespace Test {
 
-TEST(default_exec, ViewResize_Rank_45) {
-  printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests45<Kokkos::LayoutLeft>(10, 1);
-  printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests45<Kokkos::LayoutRight>(10, 1);
-}
+BENCHMARK(ViewResize_Rank4<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank4<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank5<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank5<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank4<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank4<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank5<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank5<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewResize_6.cpp b/core/perf_test/PerfTest_ViewResize_6.cpp
index 486b44a0c1..6b639d3a67 100644
--- a/core/perf_test/PerfTest_ViewResize_6.cpp
+++ b/core/perf_test/PerfTest_ViewResize_6.cpp
@@ -14,15 +14,32 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewResize.hpp>
+#include "PerfTest_ViewResize.hpp"
 
 namespace Test {
 
-TEST(default_exec, ViewResize_Rank6) {
-  printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests6<Kokkos::LayoutLeft>(10, 1);
-  printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests6<Kokkos::LayoutRight>(10, 1);
-}
+BENCHMARK(ViewResize_Rank6<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank6<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank6<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank6<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewResize_7.cpp b/core/perf_test/PerfTest_ViewResize_7.cpp
index 84c2a79ad6..8ebf80e3ff 100644
--- a/core/perf_test/PerfTest_ViewResize_7.cpp
+++ b/core/perf_test/PerfTest_ViewResize_7.cpp
@@ -14,15 +14,32 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewResize.hpp>
+#include "PerfTest_ViewResize.hpp"
 
 namespace Test {
 
-TEST(default_exec, ViewResize_Rank7) {
-  printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests7<Kokkos::LayoutLeft>(10, 1);
-  printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests7<Kokkos::LayoutRight>(10, 1);
-}
+BENCHMARK(ViewResize_Rank7<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank7<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank7<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank7<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
 
 }  // namespace Test
diff --git a/core/perf_test/PerfTest_ViewResize_8.cpp b/core/perf_test/PerfTest_ViewResize_8.cpp
index 25910fb575..5e741e800b 100644
--- a/core/perf_test/PerfTest_ViewResize_8.cpp
+++ b/core/perf_test/PerfTest_ViewResize_8.cpp
@@ -14,23 +14,39 @@
 //
 //@HEADER
 
-#include <PerfTest_ViewResize.hpp>
+#include "PerfTest_ViewResize.hpp"
 
 namespace Test {
 
-TEST(default_exec, ViewResize_Rank8) {
 // FIXME_SYCL Avoid running out of resources on the CUDA GPU used in the CI
 #ifdef KOKKOS_ENABLE_SYCL
-  printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests8<Kokkos::LayoutLeft>(9, 1);
-  printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests8<Kokkos::LayoutRight>(9, 1);
+static constexpr int N_8 = N - 1;
 #else
-  printf("Resize View Performance for LayoutLeft:\n");
-  run_resizeview_tests8<Kokkos::LayoutLeft>(10, 1);
-  printf("Resize View Performance for LayoutRight:\n");
-  run_resizeview_tests8<Kokkos::LayoutRight>(10, 1);
+static constexpr int N_8 = N;
 #endif
-}
+
+BENCHMARK(ViewResize_Rank8<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N_8)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_Rank8<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N_8)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank8<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N_8)
+    ->UseManualTime()
+    ->Iterations(R);
+
+BENCHMARK(ViewResize_NoInit_Rank8<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N_8)
+    ->UseManualTime()
+    ->Iterations(R);
 
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestOpenMP_Sort3D.cpp b/core/perf_test/PerfTest_ViewResize_Raw.cpp
similarity index 59%
rename from algorithms/unit_tests/TestOpenMP_Sort3D.cpp
rename to core/perf_test/PerfTest_ViewResize_Raw.cpp
index cd6e8e8cbf..2d1bcbb3ca 100644
--- a/algorithms/unit_tests/TestOpenMP_Sort3D.cpp
+++ b/core/perf_test/PerfTest_ViewResize_Raw.cpp
@@ -14,24 +14,22 @@
 //
 //@HEADER
 
-#include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_OPENMP
-
-#include <gtest/gtest.h>
-#include <Kokkos_Core.hpp>
-
-//----------------------------------------------------------------------------
-#include <TestRandom.hpp>
-#include <TestSort.hpp>
-#include <iomanip>
+#include "PerfTest_ViewResize.hpp"
 
 namespace Test {
 
-TEST(openmp, SortUnsigned3D) {
-  Impl::test_3D_sort<Kokkos::OpenMP, unsigned>(171);
-}
+#if defined(KOKKOS_ENABLE_CUDA_LAMBDA) || !defined(KOKKOS_ENABLE_CUDA)
+BENCHMARK(ViewResize_NoInit_Raw<Kokkos::LayoutLeft>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
 
-}  // namespace Test
-#else
-void KOKKOS_ALGORITHMS_UNITTESTS_TESTOPENMP_PREVENT_LINK_ERROR() {}
+BENCHMARK(ViewResize_NoInit_Raw<Kokkos::LayoutRight>)
+    ->ArgName("N")
+    ->Arg(N)
+    ->UseManualTime()
+    ->Iterations(R);
 #endif
+
+}  // namespace Test
diff --git a/core/perf_test/test_atomic.cpp b/core/perf_test/test_atomic.cpp
index 5f10afc45a..ce3059f47d 100644
--- a/core/perf_test/test_atomic.cpp
+++ b/core/perf_test/test_atomic.cpp
@@ -18,38 +18,14 @@
 #include <cstring>
 #include <cstdlib>
 
+#include <benchmark/benchmark.h>
+#include "Benchmark_Context.hpp"
+
 #include <Kokkos_Core.hpp>
 #include <Kokkos_Timer.hpp>
 
 using exec_space = Kokkos::DefaultExecutionSpace;
 
-#define RESET 0
-#define BRIGHT 1
-#define DIM 2
-#define UNDERLINE 3
-#define BLINK 4
-#define REVERSE 7
-#define HIDDEN 8
-
-#define BLACK 0
-#define RED 1
-#define GREEN 2
-#define YELLOW 3
-#define BLUE 4
-#define MAGENTA 5
-#define CYAN 6
-#define GREY 7
-#define WHITE 8
-
-void textcolor(int attr, int fg, int bg) {
-  char command[40];
-
-  /* Command is the control command to the terminal */
-  snprintf(command, 40, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40);
-  printf("%s", command);
-}
-void textcolor_standard() { textcolor(RESET, BLACK, WHITE); }
-
 template <class T, class DEVICE_TYPE>
 struct ZeroFunctor {
   using execution_space = DEVICE_TYPE;
@@ -370,7 +346,9 @@ T LoopVariantNonAtomic(int loop, int test) {
 }
 
 template <class T>
-void Loop(int loop, int test, const char* type_name) {
+void Loop(benchmark::State& state, int test) {
+  int loop = state.range(0);
+
   LoopVariant<T>(loop, test);
 
   Kokkos::Timer timer;
@@ -388,86 +366,36 @@ void Loop(int loop, int test, const char* type_name) {
   time *= 1e6 / loop;
   timeNonAtomic *= 1e6 / loop;
   timeSerial *= 1e6 / loop;
-  // textcolor_standard();
-  bool passed = true;
-  if (resSerial != res) passed = false;
-  // if(!passed) textcolor(RESET,BLACK,YELLOW);
-  printf(
-      "%s Test %i %s  --- Loop: %i Value (S,A,NA): %e %e %e Time: %7.4e %7.4e "
-      "%7.4e Size of Type %i)",
-      type_name, test, passed ? "PASSED" : "FAILED", loop, 1.0 * resSerial,
-      1.0 * res, 1.0 * resNonAtomic, timeSerial, time, timeNonAtomic,
-      (int)sizeof(T));
-  // if(!passed) textcolor_standard();
-  printf("\n");
-}
 
-template <class T>
-void Test(int loop, int test, const char* type_name) {
-  if (test == -1) {
-    Loop<T>(loop, 1, type_name);
-    Loop<T>(loop, 2, type_name);
-    Loop<T>(loop, 3, type_name);
-
-  } else
-    Loop<T>(loop, test, type_name);
-}
+  bool passed = (resSerial == res);
 
-int main(int argc, char* argv[]) {
-  int type = -1;
-  int loop = 100000;
-  int test = -1;
-
-  for (int i = 0; i < argc; i++) {
-    if ((strcmp(argv[i], "--test") == 0)) {
-      test = std::stoi(argv[++i]);
-      continue;
-    }
-    if ((strcmp(argv[i], "--type") == 0)) {
-      type = std::stoi(argv[++i]);
-      continue;
-    }
-    if ((strcmp(argv[i], "-l") == 0) || (strcmp(argv[i], "--loop") == 0)) {
-      loop = std::stoi(argv[++i]);
-      continue;
-    }
-  }
+  state.counters["Passed"]           = benchmark::Counter(passed);
+  state.counters["Value serial"]     = benchmark::Counter(resSerial);
+  state.counters["Value atomic"]     = benchmark::Counter(res);
+  state.counters["Value non-atomic"] = benchmark::Counter(resNonAtomic);
+  state.counters["Time serial"]      = benchmark::Counter(timeSerial);
+  state.counters["Time atomic"]      = benchmark::Counter(time);
+  state.counters["Time non-atomic"]  = benchmark::Counter(timeNonAtomic);
+  state.counters["Size of type"]     = benchmark::Counter(sizeof(T));
+}
 
-  Kokkos::initialize(argc, argv);
-
-  printf("Using %s\n", Kokkos::atomic_query_version());
-  bool all_tests = false;
-  if (type == -1) all_tests = true;
-  while (type < 100) {
-    if (type == 1) {
-      Test<int>(loop, test, "int                    ");
-    }
-    if (type == 2) {
-      Test<long int>(loop, test, "long int               ");
-    }
-    if (type == 3) {
-      Test<long long int>(loop, test, "long long int          ");
-    }
-    if (type == 4) {
-      Test<unsigned int>(loop, test, "unsigned int           ");
-    }
-    if (type == 5) {
-      Test<unsigned long int>(loop, test, "unsigned long int      ");
-    }
-    if (type == 6) {
-      Test<unsigned long long int>(loop, test, "unsigned long long int ");
-    }
-    if (type == 10) {
-      // Test<float>(loop,test,"float                  ");
-    }
-    if (type == 11) {
-      Test<double>(loop, test, "double                 ");
-    }
-    if (!all_tests)
-      type = 100;
-    else
-      type++;
+template <class T>
+static void Test_Atomic(benchmark::State& state) {
+  for (auto _ : state) {
+    Loop<T>(state, 1);
+    Loop<T>(state, 2);
+    Loop<T>(state, 3);
   }
-
-  Kokkos::finalize();
 }
+
+static constexpr int LOOP = 100'000;
+
+BENCHMARK(Test_Atomic<int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<long int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<long long int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<unsigned int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<unsigned long int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<unsigned long long int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<float>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<double>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<int>)->Arg(LOOP)->Iterations(10);
diff --git a/core/perf_test/test_atomic_minmax_simple.cpp b/core/perf_test/test_atomic_minmax_simple.cpp
index 4c2ae5c2d1..b838c8eccf 100644
--- a/core/perf_test/test_atomic_minmax_simple.cpp
+++ b/core/perf_test/test_atomic_minmax_simple.cpp
@@ -21,240 +21,536 @@
 // core/src/libkokkoscore.a -ldl && OMP_NUM_THREADS=1
 // ./test_atomic_minmax_simple.x 10000000
 
-#include <cstdio>
-#include <cstdlib>
-
-#include <iostream>
-#include <typeinfo>
+#include <benchmark/benchmark.h>
 
+#include "Benchmark_Context.hpp"
+#include "PerfTest_Category.hpp"
 #include <Kokkos_Core.hpp>
-#include <Kokkos_Timer.hpp>
 
 using exec_space = Kokkos::DefaultExecutionSpace;
 
+constexpr int LENGTH = 1'000'000;
+
+template <typename T>
+Kokkos::View<T*, exec_space> prepare_input(const int length, const T value) {
+  Kokkos::View<T*, exec_space> input("input", length);
+  Kokkos::parallel_for(
+      length, KOKKOS_LAMBDA(const int i) { input(i) = value; });
+  Kokkos::fence();
+  return input;
+}
+
+int get_length(benchmark::State& state) {
+  return (Test::command_line_num_args() == 2)
+             ? std::stoi(Test::command_line_arg(1))
+             : state.range(0);
+}
+
 template <typename T>
-void test(const int length) {
+int check_errors_replacement(Kokkos::View<T*, exec_space> view) {
+  int errors = 0;
+  Kokkos::parallel_reduce(
+      view.size(),
+      KOKKOS_LAMBDA(const int i, int& inner) { inner += (view(i) != (T)i); },
+      errors);
+  Kokkos::fence();
+  return errors;
+}
+
+template <typename T>
+double atomic_min_replacement(Kokkos::View<T*, exec_space> input) {
+  const int length = input.size();
   Kokkos::Timer timer;
+  Kokkos::parallel_for(
+      length, KOKKOS_LAMBDA(const int i) {
+        (void)Kokkos::atomic_fetch_min(&(input(i)), (T)i);
+      });
+  Kokkos::fence();
+  return timer.seconds();
+}
 
-  using vector = Kokkos::View<T*, exec_space>;
-
-  vector inp("input", length);
-  T max = std::numeric_limits<T>::max();
-  T min = std::numeric_limits<T>::lowest();
-
-  // input is max values - all min atomics will replace
-  {
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) { inp(i) = max; });
-    Kokkos::fence();
-
-    timer.reset();
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) {
-          (void)Kokkos::atomic_fetch_min(&(inp(i)), (T)i);
-        });
-    Kokkos::fence();
-    double time = timer.seconds();
-
-    int errors(0);
-    Kokkos::parallel_reduce(
-        length,
-        KOKKOS_LAMBDA(const int i, int& inner) { inner += (inp(i) != (T)i); },
-        errors);
-    Kokkos::fence();
-
-    if (errors) {
-      std::cerr << "Error in 100% min replacements: " << errors << std::endl;
-      std::cerr << "inp(0)=" << inp(0) << std::endl;
+template <typename T>
+static void Atomic_MinReplacements(benchmark::State& state) {
+  const int length = get_length(state);
+  auto inp         = prepare_input(length, std::numeric_limits<T>::max());
+
+  for (auto _ : state) {
+    const auto time   = atomic_min_replacement(inp);
+    const auto errors = check_errors_replacement(inp);
+
+    // report results
+    state.SetIterationTime(time);
+    if (errors > 0) {
+      state.counters["Errors"] = benchmark::Counter(errors);
     }
-    std::cout << "Time for 100% min replacements: " << time << std::endl;
   }
+}
 
-  // input is min values - all max atomics will replace
-  {
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) { inp(i) = min; });
-    Kokkos::fence();
-
-    timer.reset();
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) {
-          (void)Kokkos::atomic_max_fetch(&(inp(i)), (T)i);
-        });
-    Kokkos::fence();
-    double time = timer.seconds();
-
-    int errors(0);
-    Kokkos::parallel_reduce(
-        length,
-        KOKKOS_LAMBDA(const int i, int& inner) { inner += (inp(i) != (T)i); },
-        errors);
-    Kokkos::fence();
-
-    if (errors) {
-      std::cerr << "Error in 100% max replacements: " << errors << std::endl;
-      std::cerr << "inp(0)=" << inp(0) << std::endl;
+template <typename T>
+double atomic_max_replacement(Kokkos::View<T*, exec_space> input) {
+  const int length = input.size();
+  Kokkos::Timer timer;
+  Kokkos::parallel_for(
+      length, KOKKOS_LAMBDA(const int i) {
+        (void)Kokkos::atomic_max_fetch(&(input(i)), (T)i);
+      });
+  Kokkos::fence();
+  return timer.seconds();
+}
+
+template <typename T>
+static void Atomic_MaxReplacements(benchmark::State& state) {
+  const auto length = get_length(state);
+  auto inp          = prepare_input(length, std::numeric_limits<T>::lowest());
+
+  for (auto _ : state) {
+    const auto time   = atomic_max_replacement(inp);
+    const auto errors = check_errors_replacement(inp);
+
+    // report results
+    state.SetIterationTime(time);
+    if (errors > 0) {
+      state.counters["Errors"] = benchmark::Counter(errors);
     }
-    std::cout << "Time for 100% max replacements: " << time << std::endl;
   }
+}
 
-  // input is max values - all max atomics will early exit
-  {
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) { inp(i) = max; });
-    Kokkos::fence();
-
-    timer.reset();
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) {
-          (void)Kokkos::atomic_max_fetch(&(inp(i)), (T)i);
-        });
-    Kokkos::fence();
-    double time = timer.seconds();
-
-    int errors(0);
-    Kokkos::parallel_reduce(
-        length,
-        KOKKOS_LAMBDA(const int i, int& inner) {
-          T ref = max;
-          inner += (inp(i) != ref);
-        },
-        errors);
-    Kokkos::fence();
-
-    if (errors) {
-      std::cerr << "Error in 100% max early exits: " << errors << std::endl;
-      std::cerr << "inp(0)=" << inp(0) << std::endl;
+template <typename T>
+int check_errors_early_exit(Kokkos::View<T*, exec_space> view, const T ref) {
+  int errors = 0;
+  Kokkos::parallel_reduce(
+      view.size(),
+      KOKKOS_LAMBDA(const int i, int& inner) { inner += (view(i) != ref); },
+      errors);
+  Kokkos::fence();
+  return errors;
+}
+
+template <typename T>
+static void Atomic_MaxEarlyExits(benchmark::State& state) {
+  const auto length = get_length(state);
+  auto inp          = prepare_input(length, std::numeric_limits<T>::max());
+
+  for (auto _ : state) {
+    const auto time = atomic_max_replacement(inp);
+    const auto errors =
+        check_errors_early_exit(inp, std::numeric_limits<T>::max());
+
+    // report results
+    state.SetIterationTime(time);
+    if (errors > 0) {
+      state.counters["Errors"] = benchmark::Counter(errors);
     }
-    std::cout << "Time for 100% max early exits: " << time << std::endl;
   }
+}
 
-  // input is min values - all min atomics will early exit
-  {
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) { inp(i) = min; });
-    Kokkos::fence();
-
-    timer.reset();
-    Kokkos::parallel_for(
-        length, KOKKOS_LAMBDA(const int i) {
-          (void)Kokkos::atomic_min_fetch(&(inp(i)), (T)i);
-        });
-    Kokkos::fence();
-    double time = timer.seconds();
-
-    int errors(0);
-    Kokkos::parallel_reduce(
-        length,
-        KOKKOS_LAMBDA(const int i, int& inner) {
-          T ref = min;
-          inner += (inp(i) != ref);
-        },
-        errors);
-    Kokkos::fence();
-
-    if (errors) {
-      std::cerr << "Error in 100% min early exits: " << errors << std::endl;
-      std::cerr << "inp(0)=" << inp(0) << std::endl;
-      if (length > 9) std::cout << "inp(9)=" << inp(9) << std::endl;
+template <typename T>
+static void Atomic_MinEarlyExits(benchmark::State& state) {
+  const auto length = get_length(state);
+  auto inp          = prepare_input(length, std::numeric_limits<T>::lowest());
+
+  for (auto _ : state) {
+    const auto time = atomic_min_replacement(inp);
+    const auto errors =
+        check_errors_early_exit(inp, std::numeric_limits<T>::lowest());
+
+    // report results
+    state.SetIterationTime(time);
+    if (errors > 0) {
+      state.counters["Errors"] = benchmark::Counter(errors);
     }
-    std::cout << "Time for 100% min early exits: " << time << std::endl;
   }
+}
 
-  // limit iterations for contentious test, takes ~50x longer for same length
-  auto con_length = length / 5;
-  // input is min values - some max atomics will replace
-  {
-    Kokkos::parallel_for(
-        1, KOKKOS_LAMBDA(const int i) { inp(i) = min; });
-    Kokkos::fence();
-
-    T current(0);
-    timer.reset();
-    Kokkos::parallel_reduce(
-        con_length,
-        KOKKOS_LAMBDA(const int i, T& inner) {
-          inner = Kokkos::atomic_max_fetch(&(inp(0)), inner + 1);
-          if (i == con_length - 1) {
-            Kokkos::atomic_max_fetch(&(inp(0)), max);
-            inner = max;
-          }
-        },
-        Kokkos::Max<T>(current));
-    Kokkos::fence();
-    double time = timer.seconds();
-
-    if (current < max) {
-      std::cerr << "Error in contentious max replacements: " << std::endl;
-      std::cerr << "final=" << current << " inp(0)=" << inp(0) << " max=" << max
-                << std::endl;
-    }
-    std::cout << "Time for contentious max " << con_length
-              << " replacements: " << time << std::endl;
+template <typename T>
+void report_errors_contentious_replacement(benchmark::State& state,
+                                           const T final, const T first,
+                                           const T expected) {
+  state.counters["Errors"]   = benchmark::Counter(1);
+  state.counters["Final"]    = benchmark::Counter(final);
+  state.counters["First"]    = benchmark::Counter(first);
+  state.counters["Expected"] = benchmark::Counter(expected);
+}
+
+template <typename T>
+double atomic_contentious_max_replacement(benchmark::State& state,
+                                          Kokkos::View<T*, exec_space> input,
+                                          const int con_length) {
+  const auto max = std::numeric_limits<T>::max();
+  T current      = 0;
+
+  Kokkos::Timer timer;
+  Kokkos::parallel_reduce(
+      con_length,
+      KOKKOS_LAMBDA(const int i, T& inner) {
+        inner = Kokkos::atomic_max_fetch(&(input(0)), inner + 1);
+        if (i == con_length - 1) {
+          Kokkos::atomic_max_fetch(&(input(0)), max);
+          inner = max;
+        }
+      },
+      Kokkos::Max<T>(current));
+  Kokkos::fence();
+  const auto time = timer.seconds();
+
+  if (current < max) {
+    report_errors_contentious_replacement(state, current, input(0), max);
   }
 
-  // input is max values - some min atomics will replace
-  {
-    Kokkos::parallel_for(
-        1, KOKKOS_LAMBDA(const int i) { inp(i) = max; });
-    Kokkos::fence();
-
-    timer.reset();
-    T current(100000000);
-    Kokkos::parallel_reduce(
-        con_length,
-        KOKKOS_LAMBDA(const int i, T& inner) {
-          inner = Kokkos::atomic_min_fetch(&(inp(0)), inner - 1);
-          if (i == con_length - 1) {
-            Kokkos::atomic_min_fetch(&(inp(0)), min);
-            inner = min;
-          }
-        },
-        Kokkos::Min<T>(current));
-    Kokkos::fence();
-    double time = timer.seconds();
-
-    if (current > min) {
-      std::cerr << "Error in contentious min replacements: " << std::endl;
-      std::cerr << "final=" << current << " inp(0)=" << inp(0) << " min=" << min
-                << std::endl;
-    }
-    std::cout << "Time for contentious min " << con_length
-              << " replacements: " << time << std::endl;
+  return time;
+}
+
+template <typename T>
+static void Atomic_ContentiousMaxReplacements(benchmark::State& state) {
+  const auto length = get_length(state);
+  auto inp          = prepare_input(1, std::numeric_limits<T>::lowest());
+
+  for (auto _ : state) {
+    const auto time = atomic_contentious_max_replacement(state, inp, length);
+
+    state.SetIterationTime(time);
   }
 }
 
-int main(int argc, char* argv[]) {
-  Kokkos::initialize(argc, argv);
-  {
-    int length = 1000000;
-    if (argc == 2) {
-      length = std::stoi(argv[1]);
-    }
+template <typename T>
+double atomic_contentious_min_replacement(benchmark::State& state,
+                                          Kokkos::View<T*, exec_space> input,
+                                          const int con_length) {
+  const auto min = std::numeric_limits<T>::lowest();
+  T current      = 0;
 
-    if (length < 1) {
-      throw std::invalid_argument("");
-    }
+  Kokkos::Timer timer;
+  Kokkos::parallel_reduce(
+      con_length,
+      KOKKOS_LAMBDA(const int i, T& inner) {
+        inner = Kokkos::atomic_min_fetch(&(input(0)), inner - 1);
+        if (i == con_length - 1) {
+          Kokkos::atomic_min_fetch(&(input(0)), min);
+          inner = min;
+        }
+      },
+      Kokkos::Min<T>(current));
+  Kokkos::fence();
+  const auto time = timer.seconds();
+
+  if (current > min) {
+    report_errors_contentious_replacement(state, current, input(0), min);
+  }
 
-    std::cout << "================ int" << std::endl;
-    test<int>(length);
-    std::cout << "================ long" << std::endl;
-    test<long>(length);
-    std::cout << "================ long long" << std::endl;
-    test<long long>(length);
-
-    std::cout << "================ unsigned int" << std::endl;
-    test<unsigned int>(length);
-    std::cout << "================ unsigned long" << std::endl;
-    test<unsigned long>(length);
-    std::cout << "================ unsigned long long" << std::endl;
-    test<unsigned long long>(length);
-
-    std::cout << "================ float" << std::endl;
-    test<float>(length);
-    std::cout << "================ double" << std::endl;
-    test<double>(length);
+  return time;
+}
+
+template <typename T>
+static void Atomic_ContentiousMinReplacements(benchmark::State& state) {
+  const auto length = get_length(state);
+  auto inp          = prepare_input(1, std::numeric_limits<T>::max());
+
+  for (auto _ : state) {
+    const auto time = atomic_contentious_max_replacement(state, inp, length);
+
+    state.SetIterationTime(time);
   }
-  Kokkos::finalize();
-  return 0;
 }
+
+// int
+BENCHMARK(Atomic_MinReplacements<int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// long
+BENCHMARK(Atomic_MinReplacements<long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// long long
+BENCHMARK(Atomic_MinReplacements<long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// unsigned int
+BENCHMARK(Atomic_MinReplacements<unsigned int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<unsigned int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<unsigned int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<unsigned int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<unsigned int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<unsigned int>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// unsigned long
+BENCHMARK(Atomic_MinReplacements<unsigned long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<unsigned long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<unsigned long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<unsigned long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<unsigned long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<unsigned long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// unsigned long long
+BENCHMARK(Atomic_MinReplacements<unsigned long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<unsigned long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<unsigned long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<unsigned long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<unsigned long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<unsigned long long>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// float
+BENCHMARK(Atomic_MinReplacements<float>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<float>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<float>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<float>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<float>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<float>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+///////////////////////////////////////////////////////////////////////
+
+// double
+BENCHMARK(Atomic_MinReplacements<double>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxReplacements<double>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MaxEarlyExits<double>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_MinEarlyExits<double>)
+    ->ArgName("Length")
+    ->Arg(LENGTH)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMaxReplacements<double>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
+
+BENCHMARK(Atomic_ContentiousMinReplacements<double>)
+    ->ArgName("Length")
+    ->Arg(LENGTH / 5)
+    ->UseManualTime()
+    ->Iterations(10);
diff --git a/core/perf_test/test_mempool.cpp b/core/perf_test/test_mempool.cpp
index e4e1b4c9a3..abb6180346 100644
--- a/core/perf_test/test_mempool.cpp
+++ b/core/perf_test/test_mempool.cpp
@@ -19,9 +19,13 @@
 #include <cstdlib>
 #include <limits>
 
+#include <benchmark/benchmark.h>
 #include <Kokkos_Core.hpp>
 #include <Kokkos_Timer.hpp>
 
+#include "Benchmark_Context.hpp"
+#include "PerfTest_Category.hpp"
+
 using ExecSpace   = Kokkos::DefaultExecutionSpace;
 using MemorySpace = Kokkos::DefaultExecutionSpace::memory_space;
 
@@ -146,53 +150,8 @@ struct TestFunctor {
   }
 };
 
-int main(int argc, char* argv[]) {
-  static const char help_flag[]         = "--help";
-  static const char alloc_size_flag[]   = "--alloc_size=";
-  static const char super_size_flag[]   = "--super_size=";
-  static const char chunk_span_flag[]   = "--chunk_span=";
-  static const char fill_stride_flag[]  = "--fill_stride=";
-  static const char fill_level_flag[]   = "--fill_level=";
-  static const char repeat_outer_flag[] = "--repeat_outer=";
-  static const char repeat_inner_flag[] = "--repeat_inner=";
-
-  long total_alloc_size   = 1000000;
-  int min_superblock_size = 10000;
-  int chunk_span          = 5;
-  int fill_stride         = 1;
-  int fill_level          = 70;
-  int repeat_outer        = 1;
-  int repeat_inner        = 1;
-
-  int ask_help = 0;
-
-  for (int i = 1; i < argc; i++) {
-    const char* const a = argv[i];
-
-    if (!strncmp(a, help_flag, strlen(help_flag))) ask_help = 1;
-
-    if (!strncmp(a, alloc_size_flag, strlen(alloc_size_flag)))
-      total_alloc_size = atol(a + strlen(alloc_size_flag));
-
-    if (!strncmp(a, super_size_flag, strlen(super_size_flag)))
-      min_superblock_size = std::stoi(a + strlen(super_size_flag));
-
-    if (!strncmp(a, fill_stride_flag, strlen(fill_stride_flag)))
-      fill_stride = std::stoi(a + strlen(fill_stride_flag));
-
-    if (!strncmp(a, fill_level_flag, strlen(fill_level_flag)))
-      fill_level = std::stoi(a + strlen(fill_level_flag));
-
-    if (!strncmp(a, chunk_span_flag, strlen(chunk_span_flag)))
-      chunk_span = std::stoi(a + strlen(chunk_span_flag));
-
-    if (!strncmp(a, repeat_outer_flag, strlen(repeat_outer_flag)))
-      repeat_outer = std::stoi(a + strlen(repeat_outer_flag));
-
-    if (!strncmp(a, repeat_inner_flag, strlen(repeat_inner_flag)))
-      repeat_inner = std::stoi(a + strlen(repeat_inner_flag));
-  }
-
+int get_number_alloc(int chunk_span, int min_superblock_size,
+                     long total_alloc_size, int fill_level) {
   int chunk_span_bytes = 0;
   for (int i = 0; i < chunk_span; ++i) {
     auto chunk_bytes = TestFunctor::chunk * (1 + i);
@@ -212,81 +171,85 @@ int main(int argc, char* argv[]) {
   auto bytes_wanted       = (actual_total_bytes * fill_level) / 100;
   auto chunk_spans        = bytes_wanted / chunk_span_bytes;
   auto number_alloc       = int(chunk_spans * chunk_span);
+  return number_alloc;
+}
+
+template <class T>
+T get_parameter(const char flag[], T default_value) {
+  auto argc  = Test::command_line_num_args();
+  auto value = default_value;
+
+  for (int i = 1; i < argc; i++) {
+    const char* const a = Test::command_line_arg(i);
 
-  if (ask_help) {
-    std::cout << "command line options:"
-              << " " << help_flag << " " << alloc_size_flag << "##"
-              << " " << super_size_flag << "##"
-              << " " << fill_stride_flag << "##"
-              << " " << fill_level_flag << "##"
-              << " " << chunk_span_flag << "##"
-              << " " << repeat_outer_flag << "##"
-              << " " << repeat_inner_flag << "##" << std::endl;
-    return 0;
+    if (!strncmp(a, flag, strlen(flag))) value = std::stoi(a + strlen(flag));
   }
 
-  Kokkos::initialize(argc, argv);
+  return value;
+}
 
-  double sum_fill_time  = 0;
-  double sum_cycle_time = 0;
-  double sum_both_time  = 0;
-  double min_fill_time  = std::numeric_limits<double>::max();
-  double min_cycle_time = std::numeric_limits<double>::max();
-  double min_both_time  = std::numeric_limits<double>::max();
-  // one alloc in fill, alloc/dealloc pair in repeat_inner
-  for (int i = 0; i < repeat_outer; ++i) {
+static void Mempool_Fill(benchmark::State& state) {
+  long total_alloc_size =
+      get_parameter("--alloc_size=", static_cast<long>(state.range(0)));
+  int min_superblock_size = get_parameter("--super_size=", state.range(1));
+  int chunk_span          = get_parameter("--chunk_span=", state.range(2));
+  int fill_stride         = get_parameter("--fill_stride=", state.range(3));
+  int fill_level          = get_parameter("--fill_level=", state.range(4));
+  int repeat_inner        = get_parameter("--repeat_inner=", state.range(5));
+  int number_alloc        = get_number_alloc(chunk_span, min_superblock_size,
+                                      total_alloc_size, fill_level);
+
+  for (auto _ : state) {
     TestFunctor functor(total_alloc_size, min_superblock_size, number_alloc,
                         fill_stride, chunk_span, repeat_inner);
-
     Kokkos::Timer timer;
 
     if (!functor.test_fill()) {
       Kokkos::abort("fill ");
     }
 
-    auto t0 = timer.seconds();
+    state.SetIterationTime(timer.seconds());
+    state.counters[KokkosBenchmark::benchmark_fom("fill ops per second")] =
+        benchmark::Counter(number_alloc,
+                           benchmark::Counter::kIsIterationInvariantRate);
+  }
+}
+
+static void Mempool_Alloc_Dealloc(benchmark::State& state) {
+  long total_alloc_size =
+      get_parameter("--alloc_size=", static_cast<long>(state.range(0)));
+  int min_superblock_size = get_parameter("--super_size=", state.range(1));
+  int chunk_span          = get_parameter("--chunk_span=", state.range(2));
+  int fill_stride         = get_parameter("--fill_stride=", state.range(3));
+  int fill_level          = get_parameter("--fill_level=", state.range(4));
+  int repeat_inner        = get_parameter("--repeat_inner=", state.range(5));
+  int number_alloc        = get_number_alloc(chunk_span, min_superblock_size,
+                                      total_alloc_size, fill_level);
+
+  for (auto _ : state) {
+    TestFunctor functor(total_alloc_size, min_superblock_size, number_alloc,
+                        fill_stride, chunk_span, repeat_inner);
+    Kokkos::Timer timer;
 
     if (!functor.test_alloc_dealloc()) {
       Kokkos::abort("alloc/dealloc ");
     }
 
-    auto t1              = timer.seconds();
-    auto this_fill_time  = t0;
-    auto this_cycle_time = t1 - t0;
-    auto this_both_time  = t1;
-    sum_fill_time += this_fill_time;
-    sum_cycle_time += this_cycle_time;
-    sum_both_time += this_both_time;
-    min_fill_time  = std::min(min_fill_time, this_fill_time);
-    min_cycle_time = std::min(min_cycle_time, this_cycle_time);
-    min_both_time  = std::min(min_both_time, this_both_time);
+    state.SetIterationTime(timer.seconds());
+    state.counters[KokkosBenchmark::benchmark_fom("cycle ops per second")] =
+        benchmark::Counter(2 * number_alloc * repeat_inner,
+                           benchmark::Counter::kIsIterationInvariantRate);
   }
+}
 
-  Kokkos::finalize();
-
-  printf(
-      "\"mempool: alloc super stride level span inner outer number\" %ld %d %d "
-      "%d %d %d %d %d\n",
-      total_alloc_size, min_superblock_size, fill_stride, fill_level,
-      chunk_span, repeat_inner, repeat_outer, number_alloc);
-
-  auto avg_fill_time  = sum_fill_time / repeat_outer;
-  auto avg_cycle_time = sum_cycle_time / repeat_outer;
-  auto avg_both_time  = sum_both_time / repeat_outer;
-
-  printf("\"mempool: fill time (min, avg)\" %.8f %.8f\n", min_fill_time,
-         avg_fill_time);
-
-  printf("\"mempool: cycle time (min, avg)\" %.8f %.8f\n", min_cycle_time,
-         avg_cycle_time);
-
-  printf("\"mempool: test time (min, avg)\" %.8f %.8f\n", min_both_time,
-         avg_both_time);
+const std::vector<std::string> ARG_NAMES = {
+    "total_alloc_size", "min_superblock_size", "chunk_span",
+    "fill_stride",      "fill_level",          "repeat_inner"};
+const std::vector<int64_t> ARGS = {1'000'000, 10'000, 5, 1, 70, 1};
 
-  printf("\"mempool: fill ops per second (max, avg)\" %g %g\n",
-         number_alloc / min_fill_time, number_alloc / avg_fill_time);
+BENCHMARK(Mempool_Fill)->ArgNames(ARG_NAMES)->Args(ARGS)->UseManualTime();
 
-  printf("\"mempool: cycle ops per second (max, avg)\" %g %g\n",
-         (2 * number_alloc * repeat_inner) / min_cycle_time,
-         (2 * number_alloc * repeat_inner) / avg_cycle_time);
-}
+BENCHMARK(Mempool_Alloc_Dealloc)
+    ->ArgNames(ARG_NAMES)
+    ->Args(ARGS)
+    ->UseManualTime();
diff --git a/core/src/CMakeLists.txt b/core/src/CMakeLists.txt
index 862c0c47dd..012af0a7d0 100644
--- a/core/src/CMakeLists.txt
+++ b/core/src/CMakeLists.txt
@@ -3,13 +3,19 @@ KOKKOS_INCLUDE_DIRECTORIES(
   ${CMAKE_CURRENT_SOURCE_DIR}
   ${KOKKOS_TOP_BUILD_DIR}
 )
-IF (Kokkos_ENABLE_IMPL_DESUL_ATOMICS AND NOT desul_FOUND)
+IF (NOT desul_FOUND)
   IF(KOKKOS_ENABLE_CUDA)
     SET(DESUL_ATOMICS_ENABLE_CUDA ON)
   ENDIF()
+  IF(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
+    SET(DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION ON)
+  ENDIF()
   IF(KOKKOS_ENABLE_HIP)
     SET(DESUL_ATOMICS_ENABLE_HIP ON)
   ENDIF()
+  IF(KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE)
+    SET(DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION ON)
+  ENDIF()
   IF(KOKKOS_ENABLE_SYCL)
     SET(DESUL_ATOMICS_ENABLE_SYCL ON)
   ENDIF()
@@ -88,8 +94,14 @@ IF (KOKKOS_ENABLE_SYCL)
   APPEND_GLOB(KOKKOS_CORE_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/SYCL/*.hpp)
 ENDIF()
 
-IF (Kokkos_ENABLE_IMPL_DESUL_ATOMICS AND NOT desul_FOUND)
-  APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/src/*.cpp)
+IF (NOT desul_FOUND)
+  IF (KOKKOS_ENABLE_CUDA)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/src/Lock_Array_CUDA.cpp)
+  ELSEIF (KOKKOS_ENABLE_HIP)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/src/Lock_Array_HIP.cpp)
+  ELSEIF (KOKKOS_ENABLE_SYCL)
+    APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/src/Lock_Array_SYCL.cpp)
+  ENDIF()
   APPEND_GLOB(KOKKOS_CORE_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/include/desul/*.hpp)
   APPEND_GLOB(KOKKOS_CORE_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/include/desul/*/*.hpp)
   APPEND_GLOB(KOKKOS_CORE_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/include/desul/*/*/*.hpp)
@@ -125,7 +137,7 @@ KOKKOS_LIB_INCLUDE_DIRECTORIES(kokkoscore
   ${CMAKE_CURRENT_BINARY_DIR}
   ${CMAKE_CURRENT_SOURCE_DIR}
 )
-IF (Kokkos_ENABLE_IMPL_DESUL_ATOMICS AND NOT desul_FOUND)
+IF (NOT desul_FOUND)
   KOKKOS_LIB_INCLUDE_DIRECTORIES(kokkoscore
     ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/include
   )
@@ -181,17 +193,18 @@ IF (NOT WIN32)
 ENDIF()
 IF (NOT KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
   KOKKOS_LINK_TPL(kokkoscore PUBLIC ROCM)
+  KOKKOS_LINK_TPL(kokkoscore PUBLIC ONEDPL)
 ENDIF()
 
 # FIXME: We need a proper solution to figure out whether to enable
 #        libatomic
 # Most compilers only require libatomic for 128-bit CAS
 # I (CT) had removed 128bit CAS from desul to not need libatomic.
-IF (Kokkos_ENABLE_IMPL_DESUL_ATOMICS AND KOKKOS_ENABLE_OPENMPTARGET)
+IF (KOKKOS_ENABLE_OPENMPTARGET)
   target_link_libraries(kokkoscore PUBLIC atomic)
 ENDIF()
 
-IF (Kokkos_ENABLE_IMPL_DESUL_ATOMICS AND desul_FOUND)
+IF (desul_FOUND)
   target_link_libraries(kokkoscore PUBLIC desul_atomics)
 ENDIF()
 
diff --git a/core/src/Kokkos_Cuda.hpp b/core/src/Cuda/Kokkos_Cuda.hpp
similarity index 92%
rename from core/src/Kokkos_Cuda.hpp
rename to core/src/Cuda/Kokkos_Cuda.hpp
index fce7351b32..6c78a7984d 100644
--- a/core/src/Kokkos_Cuda.hpp
+++ b/core/src/Cuda/Kokkos_Cuda.hpp
@@ -31,7 +31,7 @@ static_assert(false,
 #include <vector>
 
 #include <impl/Kokkos_AnalyzePolicy.hpp>
-#include <Kokkos_CudaSpace.hpp>
+#include <Cuda/Kokkos_CudaSpace.hpp>
 #include <Cuda/Kokkos_Cuda_Error.hpp>  // CUDA_SAFE_CALL
 
 #include <Kokkos_Parallel.hpp>
@@ -241,28 +241,6 @@ struct DeviceTypeTraits<Cuda> {
 };
 }  // namespace Experimental
 }  // namespace Tools
-
-namespace Impl {
-
-template <class DT, class... DP>
-struct ZeroMemset<Kokkos::Cuda, DT, DP...> {
-  ZeroMemset(const Kokkos::Cuda& exec_space_instance,
-             const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaMemsetAsync(
-        dst.data(), 0,
-        dst.size() * sizeof(typename View<DT, DP...>::value_type),
-        exec_space_instance.cuda_stream()));
-  }
-
-  ZeroMemset(const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaMemset(dst.data(), 0,
-                   dst.size() * sizeof(typename View<DT, DP...>::value_type)));
-  }
-};
-}  // namespace Impl
 }  // namespace Kokkos
 
 /*--------------------------------------------------------------------------*/
diff --git a/core/src/Cuda/Kokkos_CudaSpace.cpp b/core/src/Cuda/Kokkos_CudaSpace.cpp
index 87b4c8c00c..334c93d17e 100644
--- a/core/src/Cuda/Kokkos_CudaSpace.cpp
+++ b/core/src/Cuda/Kokkos_CudaSpace.cpp
@@ -22,8 +22,8 @@
 #ifdef KOKKOS_ENABLE_CUDA
 
 #include <Kokkos_Core.hpp>
-#include <Kokkos_Cuda.hpp>
-#include <Kokkos_CudaSpace.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
+#include <Cuda/Kokkos_CudaSpace.hpp>
 
 #include <cstdlib>
 #include <iostream>
@@ -172,10 +172,11 @@ void *impl_allocate_common(const Cuda &exec_space, const char *arg_label,
     if (exec_space_provided) {
       cudaStream_t stream = exec_space.cuda_stream();
       error_code          = cudaMallocAsync(&ptr, arg_alloc_size, stream);
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamSynchronize(stream));
+      exec_space.fence("Kokkos::Cuda: backend fence after async malloc");
     } else {
       error_code = cudaMallocAsync(&ptr, arg_alloc_size, 0);
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
+      Impl::cuda_device_synchronize(
+          "Kokkos::Cuda: backend fence after async malloc");
     }
   } else {
     error_code = cudaMalloc(&ptr, arg_alloc_size);
@@ -324,9 +325,11 @@ void CudaSpace::impl_deallocate(
 #error CUDART_VERSION undefined!
 #elif (defined(KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC) && CUDART_VERSION >= 11020)
     if (arg_alloc_size >= memory_threshold_g) {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
+      Impl::cuda_device_synchronize(
+          "Kokkos::Cuda: backend fence before async free");
       KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeAsync(arg_alloc_ptr, 0));
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
+      Impl::cuda_device_synchronize(
+          "Kokkos::Cuda: backend fence after async free");
     } else {
       KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
     }
@@ -420,49 +423,6 @@ SharedAllocationRecord<void, void>
     SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::s_root_record;
 #endif
 
-::cudaTextureObject_t
-SharedAllocationRecord<Kokkos::CudaSpace, void>::attach_texture_object(
-    const unsigned sizeof_alias, void *const alloc_ptr,
-    size_t const alloc_size) {
-  enum { TEXTURE_BOUND_1D = 1u << 27 };
-
-  if ((alloc_ptr == nullptr) ||
-      (sizeof_alias * TEXTURE_BOUND_1D <= alloc_size)) {
-    std::ostringstream msg;
-    msg << "Kokkos::CudaSpace ERROR: Cannot attach texture object to"
-        << " alloc_ptr(" << alloc_ptr << ")"
-        << " alloc_size(" << alloc_size << ")"
-        << " max_size(" << (sizeof_alias * TEXTURE_BOUND_1D) << ")";
-    std::cerr << msg.str() << std::endl;
-    std::cerr.flush();
-    Kokkos::Impl::throw_runtime_exception(msg.str());
-  }
-
-  ::cudaTextureObject_t tex_obj;
-
-  struct cudaResourceDesc resDesc;
-  struct cudaTextureDesc texDesc;
-
-  memset(&resDesc, 0, sizeof(resDesc));
-  memset(&texDesc, 0, sizeof(texDesc));
-
-  resDesc.resType = cudaResourceTypeLinear;
-  resDesc.res.linear.desc =
-      (sizeof_alias == 4
-           ? cudaCreateChannelDesc<int>()
-           : (sizeof_alias == 8
-                  ? cudaCreateChannelDesc< ::int2>()
-                  :
-                  /* sizeof_alias == 16 */ cudaCreateChannelDesc< ::int4>()));
-  resDesc.res.linear.sizeInBytes = alloc_size;
-  resDesc.res.linear.devPtr      = alloc_ptr;
-
-  KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaCreateTextureObject(&tex_obj, &resDesc, &texDesc, nullptr));
-
-  return tex_obj;
-}
-
 //==============================================================================
 // <editor-fold desc="SharedAllocationRecord destructors"> {{{1
 
@@ -521,7 +481,6 @@ SharedAllocationRecord<Kokkos::CudaSpace, void>::SharedAllocationRecord(
                                                arg_alloc_size),
           sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
           arg_label),
-      m_tex_obj(0),
       m_space(arg_space) {
 
   SharedAllocationHeader header;
@@ -552,7 +511,6 @@ SharedAllocationRecord<Kokkos::CudaSpace, void>::SharedAllocationRecord(
                                                arg_label, arg_alloc_size),
           sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
           arg_label),
-      m_tex_obj(0),
       m_space(arg_space) {
 
   SharedAllocationHeader header;
@@ -579,7 +537,6 @@ SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::SharedAllocationRecord(
                                                arg_alloc_size),
           sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
           arg_label),
-      m_tex_obj(0),
       m_space(arg_space) {
   this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
                                                   arg_label);
diff --git a/core/src/Kokkos_CudaSpace.hpp b/core/src/Cuda/Kokkos_CudaSpace.hpp
similarity index 92%
rename from core/src/Kokkos_CudaSpace.hpp
rename to core/src/Cuda/Kokkos_CudaSpace.hpp
index eec9999f61..b8fa335cd3 100644
--- a/core/src/Kokkos_CudaSpace.hpp
+++ b/core/src/Cuda/Kokkos_CudaSpace.hpp
@@ -534,15 +534,10 @@ class SharedAllocationRecord<Kokkos::CudaSpace, void>
   SharedAllocationRecord(const SharedAllocationRecord&) = delete;
   SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
 
-  static ::cudaTextureObject_t attach_texture_object(
-      const unsigned sizeof_alias, void* const alloc_ptr,
-      const size_t alloc_size);
-
 #ifdef KOKKOS_ENABLE_DEBUG
   static RecordBase s_root_record;
 #endif
 
-  ::cudaTextureObject_t m_tex_obj = 0;
   const Kokkos::CudaSpace m_space;
 
  protected:
@@ -566,7 +561,6 @@ class SharedAllocationRecord<Kokkos::CudaSpace, void>
                                                  arg_alloc_size),
             sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
             arg_label),
-        m_tex_obj(0),
         m_space(arg_space) {
 
     SharedAllocationHeader header;
@@ -592,30 +586,6 @@ class SharedAllocationRecord<Kokkos::CudaSpace, void>
   // helper function to work around MSVC+NVCC issue
   // https://github.com/kokkos/kokkos/issues/5258
   static void deep_copy_header_no_exec(void*, const void*);
-
- public:
-  template <typename AliasType>
-  inline ::cudaTextureObject_t attach_texture_object() {
-    static_assert((std::is_same<AliasType, int>::value ||
-                   std::is_same<AliasType, ::int2>::value ||
-                   std::is_same<AliasType, ::int4>::value),
-                  "Cuda texture fetch only supported for alias types of int, "
-                  "::int2, or ::int4");
-
-    if (m_tex_obj == 0) {
-      m_tex_obj = attach_texture_object(sizeof(AliasType),
-                                        (void*)RecordBase::m_alloc_ptr,
-                                        RecordBase::m_alloc_size);
-    }
-
-    return m_tex_obj;
-  }
-
-  template <typename AliasType>
-  inline int attach_texture_object_offset(const AliasType* const ptr) {
-    // Texture object is attached to the entire allocation range
-    return ptr - reinterpret_cast<AliasType*>(RecordBase::m_alloc_ptr);
-  }
 };
 
 template <>
@@ -632,7 +602,6 @@ class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>
 
   static RecordBase s_root_record;
 
-  ::cudaTextureObject_t m_tex_obj = 0;
   const Kokkos::CudaUVMSpace m_space;
 
  protected:
@@ -657,7 +626,6 @@ class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>
                                                  arg_alloc_size),
             sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
             arg_label),
-        m_tex_obj(0),
         m_space(arg_space) {
     this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
                                                     arg_label);
@@ -667,31 +635,6 @@ class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>
       const Kokkos::CudaUVMSpace& arg_space, const std::string& arg_label,
       const size_t arg_alloc_size,
       const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
- public:
-  template <typename AliasType>
-  inline ::cudaTextureObject_t attach_texture_object() {
-    static_assert((std::is_same<AliasType, int>::value ||
-                   std::is_same<AliasType, ::int2>::value ||
-                   std::is_same<AliasType, ::int4>::value),
-                  "Cuda texture fetch only supported for alias types of int, "
-                  "::int2, or ::int4");
-
-    if (m_tex_obj == 0) {
-      m_tex_obj = SharedAllocationRecord<Kokkos::CudaSpace, void>::
-          attach_texture_object(sizeof(AliasType),
-                                (void*)RecordBase::m_alloc_ptr,
-                                RecordBase::m_alloc_size);
-    }
-
-    return m_tex_obj;
-  }
-
-  template <typename AliasType>
-  inline int attach_texture_object_offset(const AliasType* const ptr) {
-    // Texture object is attached to the entire allocation range
-    return ptr - reinterpret_cast<AliasType*>(RecordBase::m_alloc_ptr);
-  }
 };
 
 template <>
diff --git a/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp b/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp
deleted file mode 100644
index cb196f6e8f..0000000000
--- a/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp
+++ /dev/null
@@ -1,979 +0,0 @@
-/*
-@HEADER
-================================================================================
-
-ORIGINAL LICENSE
-----------------
-
-Copyright (c) 2018, NVIDIA Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-================================================================================
-
-LICENSE ASSOCIATED WITH SUBSEQUENT MODIFICATIONS
-------------------------------------------------
-
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// ************************************************************************
-@HEADER
-*/
-
-#include <Kokkos_Macros.hpp>
-#if defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-
-#include <cassert>
-
-#ifndef _SIMT_DETAILS_CONFIG
-#define _SIMT_DETAILS_CONFIG
-
-namespace Kokkos {
-namespace Impl {
-
-#ifndef __simt_scope
-// Modification: Kokkos GPU atomics should default to `gpu` scope
-#define __simt_scope "gpu"
-#endif
-
-#define __simt_fence_signal_() asm volatile("" ::: "memory")
-#define __simt_fence_sc_() \
-  asm volatile("fence.sc." __simt_scope ";" ::: "memory")
-#define __simt_fence_() asm volatile("fence." __simt_scope ";" ::: "memory")
-
-#define __simt_load_acquire_8_as_32(ptr, ret)             \
-  asm volatile("ld.acquire." __simt_scope ".b8 %0, [%1];" \
-               : "=r"(ret)                                \
-               : "l"(ptr)                                 \
-               : "memory")
-#define __simt_load_relaxed_8_as_32(ptr, ret)             \
-  asm volatile("ld.relaxed." __simt_scope ".b8 %0, [%1];" \
-               : "=r"(ret)                                \
-               : "l"(ptr)                                 \
-               : "memory")
-#define __simt_store_release_8_as_32(ptr, desired)                    \
-  asm volatile("st.release." __simt_scope ".b8 [%0], %1;" ::"l"(ptr), \
-               "r"(desired)                                           \
-               : "memory")
-#define __simt_store_relaxed_8_as_32(ptr, desired)                    \
-  asm volatile("st.relaxed." __simt_scope ".b8 [%0], %1;" ::"l"(ptr), \
-               "r"(desired)                                           \
-               : "memory")
-
-#define __simt_load_acquire_16(ptr, ret)                   \
-  asm volatile("ld.acquire." __simt_scope ".b16 %0, [%1];" \
-               : "=h"(ret)                                 \
-               : "l"(ptr)                                  \
-               : "memory")
-#define __simt_load_relaxed_16(ptr, ret)                   \
-  asm volatile("ld.relaxed." __simt_scope ".b16 %0, [%1];" \
-               : "=h"(ret)                                 \
-               : "l"(ptr)                                  \
-               : "memory")
-#define __simt_store_release_16(ptr, desired)                          \
-  asm volatile("st.release." __simt_scope ".b16 [%0], %1;" ::"l"(ptr), \
-               "h"(desired)                                            \
-               : "memory")
-#define __simt_store_relaxed_16(ptr, desired)                          \
-  asm volatile("st.relaxed." __simt_scope ".b16 [%0], %1;" ::"l"(ptr), \
-               "h"(desired)                                            \
-               : "memory")
-
-#define __simt_load_acquire_32(ptr, ret)                   \
-  asm volatile("ld.acquire." __simt_scope ".b32 %0, [%1];" \
-               : "=r"(ret)                                 \
-               : "l"(ptr)                                  \
-               : "memory")
-#define __simt_load_relaxed_32(ptr, ret)                   \
-  asm volatile("ld.relaxed." __simt_scope ".b32 %0, [%1];" \
-               : "=r"(ret)                                 \
-               : "l"(ptr)                                  \
-               : "memory")
-#define __simt_store_release_32(ptr, desired)                          \
-  asm volatile("st.release." __simt_scope ".b32 [%0], %1;" ::"l"(ptr), \
-               "r"(desired)                                            \
-               : "memory")
-#define __simt_store_relaxed_32(ptr, desired)                          \
-  asm volatile("st.relaxed." __simt_scope ".b32 [%0], %1;" ::"l"(ptr), \
-               "r"(desired)                                            \
-               : "memory")
-#define __simt_exch_release_32(ptr, old, desired)                     \
-  asm volatile("atom.exch.release." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                            \
-               : "l"(ptr), "r"(desired)                               \
-               : "memory")
-#define __simt_exch_acquire_32(ptr, old, desired)                     \
-  asm volatile("atom.exch.acquire." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                            \
-               : "l"(ptr), "r"(desired)                               \
-               : "memory")
-#define __simt_exch_acq_rel_32(ptr, old, desired)                     \
-  asm volatile("atom.exch.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                            \
-               : "l"(ptr), "r"(desired)                               \
-               : "memory")
-#define __simt_exch_relaxed_32(ptr, old, desired)                     \
-  asm volatile("atom.exch.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                            \
-               : "l"(ptr), "r"(desired)                               \
-               : "memory")
-#define __simt_cas_release_32(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.release." __simt_scope ".b32 %0, [%1], %2, %3;" \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define __simt_cas_acquire_32(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.acquire." __simt_scope ".b32 %0, [%1], %2, %3;" \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define __simt_cas_acq_rel_32(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.acq_rel." __simt_scope ".b32 %0, [%1], %2, %3;" \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define __simt_cas_relaxed_32(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.relaxed." __simt_scope ".b32 %0, [%1], %2, %3;" \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define __simt_add_release_32(ptr, old, addend)                      \
-  asm volatile("atom.add.release." __simt_scope ".u32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(addend)                               \
-               : "memory")
-#define __simt_add_acquire_32(ptr, old, addend)                      \
-  asm volatile("atom.add.acquire." __simt_scope ".u32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(addend)                               \
-               : "memory")
-#define __simt_add_acq_rel_32(ptr, old, addend)                      \
-  asm volatile("atom.add.acq_rel." __simt_scope ".u32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(addend)                               \
-               : "memory")
-#define __simt_add_relaxed_32(ptr, old, addend)                      \
-  asm volatile("atom.add.relaxed." __simt_scope ".u32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(addend)                               \
-               : "memory")
-#define __simt_and_release_32(ptr, old, andend)                      \
-  asm volatile("atom.and.release." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(andend)                               \
-               : "memory")
-#define __simt_and_acquire_32(ptr, old, andend)                      \
-  asm volatile("atom.and.acquire." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(andend)                               \
-               : "memory")
-#define __simt_and_acq_rel_32(ptr, old, andend)                      \
-  asm volatile("atom.and.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(andend)                               \
-               : "memory")
-#define __simt_and_relaxed_32(ptr, old, andend)                      \
-  asm volatile("atom.and.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(andend)                               \
-               : "memory")
-#define __simt_or_release_32(ptr, old, orend)                       \
-  asm volatile("atom.or.release." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                          \
-               : "l"(ptr), "r"(orend)                               \
-               : "memory")
-#define __simt_or_acquire_32(ptr, old, orend)                       \
-  asm volatile("atom.or.acquire." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                          \
-               : "l"(ptr), "r"(orend)                               \
-               : "memory")
-#define __simt_or_acq_rel_32(ptr, old, orend)                       \
-  asm volatile("atom.or.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                          \
-               : "l"(ptr), "r"(orend)                               \
-               : "memory")
-#define __simt_or_relaxed_32(ptr, old, orend)                       \
-  asm volatile("atom.or.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                          \
-               : "l"(ptr), "r"(orend)                               \
-               : "memory")
-#define __simt_xor_release_32(ptr, old, xorend)                      \
-  asm volatile("atom.xor.release." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(xorend)                               \
-               : "memory")
-#define __simt_xor_acquire_32(ptr, old, xorend)                      \
-  asm volatile("atom.xor.acquire." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(xorend)                               \
-               : "memory")
-#define __simt_xor_acq_rel_32(ptr, old, xorend)                      \
-  asm volatile("atom.xor.acq_rel." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(xorend)                               \
-               : "memory")
-#define __simt_xor_relaxed_32(ptr, old, xorend)                      \
-  asm volatile("atom.xor.relaxed." __simt_scope ".b32 %0, [%1], %2;" \
-               : "=r"(old)                                           \
-               : "l"(ptr), "r"(xorend)                               \
-               : "memory")
-
-#define __simt_load_acquire_64(ptr, ret)                   \
-  asm volatile("ld.acquire." __simt_scope ".b64 %0, [%1];" \
-               : "=l"(ret)                                 \
-               : "l"(ptr)                                  \
-               : "memory")
-#define __simt_load_relaxed_64(ptr, ret)                   \
-  asm volatile("ld.relaxed." __simt_scope ".b64 %0, [%1];" \
-               : "=l"(ret)                                 \
-               : "l"(ptr)                                  \
-               : "memory")
-#define __simt_store_release_64(ptr, desired)                          \
-  asm volatile("st.release." __simt_scope ".b64 [%0], %1;" ::"l"(ptr), \
-               "l"(desired)                                            \
-               : "memory")
-#define __simt_store_relaxed_64(ptr, desired)                          \
-  asm volatile("st.relaxed." __simt_scope ".b64 [%0], %1;" ::"l"(ptr), \
-               "l"(desired)                                            \
-               : "memory")
-#define __simt_exch_release_64(ptr, old, desired)                     \
-  asm volatile("atom.exch.release." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                            \
-               : "l"(ptr), "l"(desired)                               \
-               : "memory")
-#define __simt_exch_acquire_64(ptr, old, desired)                     \
-  asm volatile("atom.exch.acquire." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                            \
-               : "l"(ptr), "l"(desired)                               \
-               : "memory")
-#define __simt_exch_acq_rel_64(ptr, old, desired)                     \
-  asm volatile("atom.exch.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                            \
-               : "l"(ptr), "l"(desired)                               \
-               : "memory")
-#define __simt_exch_relaxed_64(ptr, old, desired)                     \
-  asm volatile("atom.exch.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                            \
-               : "l"(ptr), "l"(desired)                               \
-               : "memory")
-#define __simt_cas_release_64(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.release." __simt_scope ".b64 %0, [%1], %2, %3;" \
-               : "=l"(old)                                               \
-               : "l"(ptr), "l"(expected), "l"(desired)                   \
-               : "memory")
-#define __simt_cas_acquire_64(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.acquire." __simt_scope ".b64 %0, [%1], %2, %3;" \
-               : "=l"(old)                                               \
-               : "l"(ptr), "l"(expected), "l"(desired)                   \
-               : "memory")
-#define __simt_cas_acq_rel_64(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.acq_rel." __simt_scope ".b64 %0, [%1], %2, %3;" \
-               : "=l"(old)                                               \
-               : "l"(ptr), "l"(expected), "l"(desired)                   \
-               : "memory")
-#define __simt_cas_relaxed_64(ptr, old, expected, desired)               \
-  asm volatile("atom.cas.relaxed." __simt_scope ".b64 %0, [%1], %2, %3;" \
-               : "=l"(old)                                               \
-               : "l"(ptr), "l"(expected), "l"(desired)                   \
-               : "memory")
-#define __simt_add_release_64(ptr, old, addend)                      \
-  asm volatile("atom.add.release." __simt_scope ".u64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(addend)                               \
-               : "memory")
-#define __simt_add_acquire_64(ptr, old, addend)                      \
-  asm volatile("atom.add.acquire." __simt_scope ".u64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(addend)                               \
-               : "memory")
-#define __simt_add_acq_rel_64(ptr, old, addend)                      \
-  asm volatile("atom.add.acq_rel." __simt_scope ".u64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(addend)                               \
-               : "memory")
-#define __simt_add_relaxed_64(ptr, old, addend)                      \
-  asm volatile("atom.add.relaxed." __simt_scope ".u64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(addend)                               \
-               : "memory")
-#define __simt_and_release_64(ptr, old, andend)                      \
-  asm volatile("atom.and.release." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(andend)                               \
-               : "memory")
-#define __simt_and_acquire_64(ptr, old, andend)                      \
-  asm volatile("atom.and.acquire." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(andend)                               \
-               : "memory")
-#define __simt_and_acq_rel_64(ptr, old, andend)                      \
-  asm volatile("atom.and.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(andend)                               \
-               : "memory")
-#define __simt_and_relaxed_64(ptr, old, andend)                      \
-  asm volatile("atom.and.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(andend)                               \
-               : "memory")
-#define __simt_or_release_64(ptr, old, orend)                       \
-  asm volatile("atom.or.release." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                          \
-               : "l"(ptr), "l"(orend)                               \
-               : "memory")
-#define __simt_or_acquire_64(ptr, old, orend)                       \
-  asm volatile("atom.or.acquire." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                          \
-               : "l"(ptr), "l"(orend)                               \
-               : "memory")
-#define __simt_or_acq_rel_64(ptr, old, orend)                       \
-  asm volatile("atom.or.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                          \
-               : "l"(ptr), "l"(orend)                               \
-               : "memory")
-#define __simt_or_relaxed_64(ptr, old, orend)                       \
-  asm volatile("atom.or.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                          \
-               : "l"(ptr), "l"(orend)                               \
-               : "memory")
-#define __simt_xor_release_64(ptr, old, xorend)                      \
-  asm volatile("atom.xor.release." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(xorend)                               \
-               : "memory")
-#define __simt_xor_acquire_64(ptr, old, xorend)                      \
-  asm volatile("atom.xor.acquire." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(xorend)                               \
-               : "memory")
-#define __simt_xor_acq_rel_64(ptr, old, xorend)                      \
-  asm volatile("atom.xor.acq_rel." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(xorend)                               \
-               : "memory")
-#define __simt_xor_relaxed_64(ptr, old, xorend)                      \
-  asm volatile("atom.xor.relaxed." __simt_scope ".b64 %0, [%1], %2;" \
-               : "=l"(old)                                           \
-               : "l"(ptr), "l"(xorend)                               \
-               : "memory")
-
-#define __simt_nanosleep(timeout) \
-  asm volatile("nanosleep.u32 %0;" ::"r"(unsigned(timeout)) :)
-
-/*
-    definitions
-*/
-
-#ifndef __GCC_ATOMIC_BOOL_LOCK_FREE
-#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
-#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
-#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
-#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
-#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
-#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
-#define __GCC_ATOMIC_INT_LOCK_FREE 2
-#define __GCC_ATOMIC_LONG_LOCK_FREE 2
-#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
-#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
-#endif
-
-#ifndef __ATOMIC_RELAXED
-#define __ATOMIC_RELAXED 0
-#define __ATOMIC_CONSUME 1
-#define __ATOMIC_ACQUIRE 2
-#define __ATOMIC_RELEASE 3
-#define __ATOMIC_ACQ_REL 4
-#define __ATOMIC_SEQ_CST 5
-#endif
-
-inline __device__ int __stronger_order_simt_(int a, int b) {
-  if (b == __ATOMIC_SEQ_CST) return __ATOMIC_SEQ_CST;
-  if (b == __ATOMIC_RELAXED) return a;
-  switch (a) {
-    case __ATOMIC_SEQ_CST:
-    case __ATOMIC_ACQ_REL: return a;
-    case __ATOMIC_CONSUME:
-    case __ATOMIC_ACQUIRE:
-      if (b != __ATOMIC_ACQUIRE)
-        return __ATOMIC_ACQ_REL;
-      else
-        return __ATOMIC_ACQUIRE;
-    case __ATOMIC_RELEASE:
-      if (b != __ATOMIC_RELEASE)
-        return __ATOMIC_ACQ_REL;
-      else
-        return __ATOMIC_RELEASE;
-    case __ATOMIC_RELAXED: return b;
-    default: assert(0);
-  }
-  return __ATOMIC_SEQ_CST;
-}
-
-/*
-    base
-*/
-
-#define DO__atomic_load_simt_(bytes, bits)                                \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0> \
-  void __device__ __atomic_load_simt_(const type *ptr, type *ret,         \
-                                      int memorder) {                     \
-    int##bits##_t tmp = 0;                                                \
-    switch (memorder) {                                                   \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                          \
-      case __ATOMIC_CONSUME:                                              \
-      case __ATOMIC_ACQUIRE: __simt_load_acquire_##bits(ptr, tmp); break; \
-      case __ATOMIC_RELAXED: __simt_load_relaxed_##bits(ptr, tmp); break; \
-      default: assert(0);                                                 \
-    }                                                                     \
-    memcpy(ret, &tmp, bytes);                                             \
-  }
-DO__atomic_load_simt_(1, 32) DO__atomic_load_simt_(2, 16)
-    DO__atomic_load_simt_(4, 32) DO__atomic_load_simt_(8, 64)
-
-        template <class type>
-        type __device__ __atomic_load_n_simt_(const type *ptr, int memorder) {
-  type ret;
-  __atomic_load_simt_(ptr, &ret, memorder);
-  return ret;
-}
-
-#define DO__atomic_store_simt_(bytes, bits)                                  \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0>    \
-  void __device__ __atomic_store_simt_(type *ptr, type *val, int memorder) { \
-    int##bits##_t tmp = 0;                                                   \
-    memcpy(&tmp, val, bytes);                                                \
-    switch (memorder) {                                                      \
-      case __ATOMIC_RELEASE: __simt_store_release_##bits(ptr, tmp); break;   \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                             \
-      case __ATOMIC_RELAXED: __simt_store_relaxed_##bits(ptr, tmp); break;   \
-      default: assert(0);                                                    \
-    }                                                                        \
-  }
-DO__atomic_store_simt_(1, 32) DO__atomic_store_simt_(2, 16)
-    DO__atomic_store_simt_(4, 32) DO__atomic_store_simt_(8, 64)
-
-        template <class type>
-        void __device__
-    __atomic_store_n_simt_(type *ptr, type val, int memorder) {
-  __atomic_store_simt_(ptr, &val, memorder);
-}
-
-#define DO__atomic_compare_exchange_simt_(bytes, bits)                    \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0> \
-  bool __device__ __atomic_compare_exchange_simt_(                        \
-      type *ptr, type *expected, const type *desired, bool,               \
-      int success_memorder, int failure_memorder) {                       \
-    int##bits##_t tmp = 0, old = 0, old_tmp;                              \
-    memcpy(&tmp, desired, bytes);                                         \
-    memcpy(&old, expected, bytes);                                        \
-    old_tmp = old;                                                        \
-    switch (__stronger_order_simt_(success_memorder, failure_memorder)) { \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                          \
-      case __ATOMIC_CONSUME:                                              \
-      case __ATOMIC_ACQUIRE:                                              \
-        __simt_cas_acquire_##bits(ptr, old, old_tmp, tmp);                \
-        break;                                                            \
-      case __ATOMIC_ACQ_REL:                                              \
-        __simt_cas_acq_rel_##bits(ptr, old, old_tmp, tmp);                \
-        break;                                                            \
-      case __ATOMIC_RELEASE:                                              \
-        __simt_cas_release_##bits(ptr, old, old_tmp, tmp);                \
-        break;                                                            \
-      case __ATOMIC_RELAXED:                                              \
-        __simt_cas_relaxed_##bits(ptr, old, old_tmp, tmp);                \
-        break;                                                            \
-      default: assert(0);                                                 \
-    }                                                                     \
-    bool const ret = old == old_tmp;                                      \
-    memcpy(expected, &old, bytes);                                        \
-    return ret;                                                           \
-  }
-DO__atomic_compare_exchange_simt_(4, 32)
-    DO__atomic_compare_exchange_simt_(8, 64)
-
-        template <class type, std::enable_if_t<sizeof(type) <= 2, int> = 0>
-        bool __device__
-    __atomic_compare_exchange_simt_(type *ptr, type *expected,
-                                    const type *desired, bool,
-                                    int success_memorder,
-                                    int failure_memorder) {
-  using R = std::conditional_t<std::is_volatile<type>::value, volatile uint32_t,
-                               uint32_t>;
-  auto const aligned = (R *)((intptr_t)ptr & ~(sizeof(uint32_t) - 1));
-  auto const offset  = uint32_t((intptr_t)ptr & (sizeof(uint32_t) - 1)) * 8;
-  auto const mask    = ((1 << sizeof(type) * 8) - 1) << offset;
-
-  uint32_t old = *expected << offset, old_value;
-  while (1) {
-    old_value = (old & mask) >> offset;
-    if (old_value != *expected) break;
-    uint32_t const attempt = (old & ~mask) | (*desired << offset);
-    if (__atomic_compare_exchange_simt_(aligned, &old, &attempt, true,
-                                        success_memorder, failure_memorder))
-      return true;
-  }
-  *expected = old_value;
-  return false;
-}
-
-template <class type>
-bool __device__ __atomic_compare_exchange_n_simt_(type *ptr, type *expected,
-                                                  type desired, bool weak,
-                                                  int success_memorder,
-                                                  int failure_memorder) {
-  return __atomic_compare_exchange_simt_(ptr, expected, &desired, weak,
-                                         success_memorder, failure_memorder);
-}
-
-#define DO__atomic_exchange_simt_(bytes, bits)                                 \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0>      \
-  void __device__ __atomic_exchange_simt_(type *ptr, type *val, type *ret,     \
-                                          int memorder) {                      \
-    int##bits##_t tmp = 0;                                                     \
-    memcpy(&tmp, val, bytes);                                                  \
-    switch (memorder) {                                                        \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                               \
-      case __ATOMIC_CONSUME:                                                   \
-      case __ATOMIC_ACQUIRE: __simt_exch_acquire_##bits(ptr, tmp, tmp); break; \
-      case __ATOMIC_ACQ_REL: __simt_exch_acq_rel_##bits(ptr, tmp, tmp); break; \
-      case __ATOMIC_RELEASE: __simt_exch_release_##bits(ptr, tmp, tmp); break; \
-      case __ATOMIC_RELAXED: __simt_exch_relaxed_##bits(ptr, tmp, tmp); break; \
-      default: assert(0);                                                      \
-    }                                                                          \
-    memcpy(ret, &tmp, bytes);                                                  \
-  }
-DO__atomic_exchange_simt_(4, 32) DO__atomic_exchange_simt_(8, 64)
-
-    template <class type, std::enable_if_t<sizeof(type) <= 2, int> = 0>
-    void __device__
-    __atomic_exchange_simt_(type *ptr, type *val, type *ret, int memorder) {
-  type expected = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-  while (!__atomic_compare_exchange_simt_(ptr, &expected, val, true, memorder,
-                                          memorder))
-    ;
-  *ret = expected;
-}
-
-template <class type>
-type __device__ __atomic_exchange_n_simt_(type *ptr, type val, int memorder) {
-  type ret;
-  __atomic_exchange_simt_(ptr, &val, &ret, memorder);
-  return ret;
-}
-
-#define DO__atomic_fetch_add_simt_(bytes, bits)                               \
-  template <class type, class delta,                                          \
-            std::enable_if_t<sizeof(type) == bytes, int> = 0>                 \
-  type __device__ __atomic_fetch_add_simt_(type *ptr, delta val,              \
-                                           int memorder) {                    \
-    type ret;                                                                 \
-    switch (memorder) {                                                       \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                              \
-      case __ATOMIC_CONSUME:                                                  \
-      case __ATOMIC_ACQUIRE: __simt_add_acquire_##bits(ptr, ret, val); break; \
-      case __ATOMIC_ACQ_REL: __simt_add_acq_rel_##bits(ptr, ret, val); break; \
-      case __ATOMIC_RELEASE: __simt_add_release_##bits(ptr, ret, val); break; \
-      case __ATOMIC_RELAXED: __simt_add_relaxed_##bits(ptr, ret, val); break; \
-      default: assert(0);                                                     \
-    }                                                                         \
-    return ret;                                                               \
-  }
-DO__atomic_fetch_add_simt_(4, 32) DO__atomic_fetch_add_simt_(8, 64)
-
-    template <class type, class delta,
-              std::enable_if_t<sizeof(type) <= 2, int> = 0>
-    type __device__
-    __atomic_fetch_add_simt_(type *ptr, delta val, int memorder) {
-  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-  type const desired = expected + val;
-  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
-                                          memorder, memorder))
-    ;
-  return expected;
-}
-
-#define DO__atomic_fetch_sub_simt_(bytes, bits)                                \
-  template <class type, class delta,                                           \
-            std::enable_if_t<sizeof(type) == bytes, int> = 0>                  \
-  type __device__ __atomic_fetch_sub_simt_(type *ptr, delta val,               \
-                                           int memorder) {                     \
-    type ret;                                                                  \
-    switch (memorder) {                                                        \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                               \
-      case __ATOMIC_CONSUME:                                                   \
-      case __ATOMIC_ACQUIRE: __simt_add_acquire_##bits(ptr, ret, -val); break; \
-      case __ATOMIC_ACQ_REL: __simt_add_acq_rel_##bits(ptr, ret, -val); break; \
-      case __ATOMIC_RELEASE: __simt_add_release_##bits(ptr, ret, -val); break; \
-      case __ATOMIC_RELAXED: __simt_add_relaxed_##bits(ptr, ret, -val); break; \
-      default: assert(0);                                                      \
-    }                                                                          \
-    return ret;                                                                \
-  }
-DO__atomic_fetch_sub_simt_(4, 32) DO__atomic_fetch_sub_simt_(8, 64)
-
-    template <class type, class delta,
-              std::enable_if_t<sizeof(type) <= 2, int> = 0>
-    type __device__
-    __atomic_fetch_sub_simt_(type *ptr, delta val, int memorder) {
-  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-  type const desired = expected - val;
-  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
-                                          memorder, memorder))
-    ;
-  return expected;
-}
-
-#define DO__atomic_fetch_and_simt_(bytes, bits)                               \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0>     \
-  type __device__ __atomic_fetch_and_simt_(type *ptr, type val,               \
-                                           int memorder) {                    \
-    type ret;                                                                 \
-    switch (memorder) {                                                       \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                              \
-      case __ATOMIC_CONSUME:                                                  \
-      case __ATOMIC_ACQUIRE: __simt_and_acquire_##bits(ptr, ret, val); break; \
-      case __ATOMIC_ACQ_REL: __simt_and_acq_rel_##bits(ptr, ret, val); break; \
-      case __ATOMIC_RELEASE: __simt_and_release_##bits(ptr, ret, val); break; \
-      case __ATOMIC_RELAXED: __simt_and_relaxed_##bits(ptr, ret, val); break; \
-      default: assert(0);                                                     \
-    }                                                                         \
-    return ret;                                                               \
-  }
-DO__atomic_fetch_and_simt_(4, 32) DO__atomic_fetch_and_simt_(8, 64)
-
-    template <class type, class delta,
-              std::enable_if_t<sizeof(type) <= 2, int> = 0>
-    type __device__
-    __atomic_fetch_and_simt_(type *ptr, delta val, int memorder) {
-  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-  type const desired = expected & val;
-  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
-                                          memorder, memorder))
-    ;
-  return expected;
-}
-
-#define DO__atomic_fetch_xor_simt_(bytes, bits)                               \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0>     \
-  type __device__ __atomic_fetch_xor_simt_(type *ptr, type val,               \
-                                           int memorder) {                    \
-    type ret;                                                                 \
-    switch (memorder) {                                                       \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                              \
-      case __ATOMIC_CONSUME:                                                  \
-      case __ATOMIC_ACQUIRE: __simt_xor_acquire_##bits(ptr, ret, val); break; \
-      case __ATOMIC_ACQ_REL: __simt_xor_acq_rel_##bits(ptr, ret, val); break; \
-      case __ATOMIC_RELEASE: __simt_xor_release_##bits(ptr, ret, val); break; \
-      case __ATOMIC_RELAXED: __simt_xor_relaxed_##bits(ptr, ret, val); break; \
-      default: assert(0);                                                     \
-    }                                                                         \
-    return ret;                                                               \
-  }
-DO__atomic_fetch_xor_simt_(4, 32) DO__atomic_fetch_xor_simt_(8, 64)
-
-    template <class type, class delta,
-              std::enable_if_t<sizeof(type) <= 2, int> = 0>
-    type __device__
-    __atomic_fetch_xor_simt_(type *ptr, delta val, int memorder) {
-  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-  type const desired = expected ^ val;
-  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
-                                          memorder, memorder))
-    ;
-  return expected;
-}
-
-#define DO__atomic_fetch_or_simt_(bytes, bits)                                 \
-  template <class type, std::enable_if_t<sizeof(type) == bytes, int> = 0>      \
-  type __device__ __atomic_fetch_or_simt_(type *ptr, type val, int memorder) { \
-    type ret;                                                                  \
-    switch (memorder) {                                                        \
-      case __ATOMIC_SEQ_CST: __simt_fence_sc_();                               \
-      case __ATOMIC_CONSUME:                                                   \
-      case __ATOMIC_ACQUIRE: __simt_or_acquire_##bits(ptr, ret, val); break;   \
-      case __ATOMIC_ACQ_REL: __simt_or_acq_rel_##bits(ptr, ret, val); break;   \
-      case __ATOMIC_RELEASE: __simt_or_release_##bits(ptr, ret, val); break;   \
-      case __ATOMIC_RELAXED: __simt_or_relaxed_##bits(ptr, ret, val); break;   \
-      default: assert(0);                                                      \
-    }                                                                          \
-    return ret;                                                                \
-  }
-DO__atomic_fetch_or_simt_(4, 32) DO__atomic_fetch_or_simt_(8, 64)
-
-    template <class type, class delta,
-              std::enable_if_t<sizeof(type) <= 2, int> = 0>
-    type __device__
-    __atomic_fetch_or_simt_(type *ptr, delta val, int memorder) {
-  type expected      = __atomic_load_n_simt_(ptr, __ATOMIC_RELAXED);
-  type const desired = expected | val;
-  while (!__atomic_compare_exchange_simt_(ptr, &expected, &desired, true,
-                                          memorder, memorder))
-    ;
-  return expected;
-}
-
-template <class type>
-inline bool __device__ __atomic_test_and_set_simt_(type *ptr, int memorder) {
-  return __atomic_exchange_n_simt_((char *)ptr, (char)1, memorder) == 1;
-}
-template <class type>
-inline void __device__ __atomic_clear_simt_(type *ptr, int memorder) {
-  return __atomic_store_n_simt_((char *)ptr, (char)0, memorder);
-}
-
-inline constexpr __device__ bool __atomic_always_lock_free_simt_(size_t size,
-                                                                 void *) {
-  return size <= 8;
-}
-inline __device__ bool __atomic_is_lock_free_simt_(size_t size, void *ptr) {
-  return __atomic_always_lock_free_simt_(size, ptr);
-}
-
-/*
-    fences
-*/
-
-inline void __device__ __atomic_thread_fence_simt(int memorder) {
-  switch (memorder) {
-    case __ATOMIC_SEQ_CST: __simt_fence_sc_(); break;
-    case __ATOMIC_CONSUME:
-    case __ATOMIC_ACQUIRE:
-    case __ATOMIC_ACQ_REL:
-    case __ATOMIC_RELEASE: __simt_fence_(); break;
-    case __ATOMIC_RELAXED: break;
-    default: assert(0);
-  }
-}
-inline void __device__ __atomic_signal_fence_simt(int memorder) {
-  __atomic_thread_fence_simt(memorder);
-}
-
-/*
-    non-volatile
-*/
-
-template <class type>
-type __device__ __atomic_load_n_simt(const type *ptr, int memorder) {
-  return __atomic_load_n_simt_(const_cast<const type *>(ptr), memorder);
-}
-template <class type>
-void __device__ __atomic_load_simt(const type *ptr, type *ret, int memorder) {
-  __atomic_load_simt_(const_cast<const type *>(ptr), ret, memorder);
-}
-template <class type>
-void __device__ __atomic_store_n_simt(type *ptr, type val, int memorder) {
-  __atomic_store_n_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-void __device__ __atomic_store_simt(type *ptr, type *val, int memorder) {
-  __atomic_store_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_exchange_n_simt(type *ptr, type val, int memorder) {
-  return __atomic_exchange_n_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-void __device__ __atomic_exchange_simt(type *ptr, type *val, type *ret,
-                                       int memorder) {
-  __atomic_exchange_simt_(const_cast<type *>(ptr), val, ret, memorder);
-}
-template <class type>
-bool __device__ __atomic_compare_exchange_n_simt(type *ptr, type *expected,
-                                                 type desired, bool weak,
-                                                 int success_memorder,
-                                                 int failure_memorder) {
-  return __atomic_compare_exchange_n_simt_(const_cast<type *>(ptr), expected,
-                                           desired, weak, success_memorder,
-                                           failure_memorder);
-}
-template <class type>
-bool __device__ __atomic_compare_exchange_simt(type *ptr, type *expected,
-                                               type *desired, bool weak,
-                                               int success_memorder,
-                                               int failure_memorder) {
-  return __atomic_compare_exchange_simt_(const_cast<type *>(ptr), expected,
-                                         desired, weak, success_memorder,
-                                         failure_memorder);
-}
-template <class type, class delta>
-type __device__ __atomic_fetch_add_simt(type *ptr, delta val, int memorder) {
-  return __atomic_fetch_add_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type, class delta>
-type __device__ __atomic_fetch_sub_simt(type *ptr, delta val, int memorder) {
-  return __atomic_fetch_sub_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_fetch_and_simt(type *ptr, type val, int memorder) {
-  return __atomic_fetch_and_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_fetch_xor_simt(type *ptr, type val, int memorder) {
-  return __atomic_fetch_xor_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_fetch_or_simt(type *ptr, type val, int memorder) {
-  return __atomic_fetch_or_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-bool __device__ __atomic_test_and_set_simt(void *ptr, int memorder) {
-  return __atomic_test_and_set_simt_(const_cast<void *>(ptr), memorder);
-}
-template <class type>
-void __device__ __atomic_clear_simt(void *ptr, int memorder) {
-  return __atomic_clear_simt_(const_cast<void *>(ptr), memorder);
-}
-inline bool __device__ __atomic_always_lock_free_simt(size_t size, void *ptr) {
-  return __atomic_always_lock_free_simt_(size, const_cast<void *>(ptr));
-}
-inline bool __device__ __atomic_is_lock_free_simt(size_t size, void *ptr) {
-  return __atomic_is_lock_free_simt_(size, const_cast<void *>(ptr));
-}
-
-/*
-    volatile
-*/
-
-template <class type>
-type __device__ __atomic_load_n_simt(const volatile type *ptr, int memorder) {
-  return __atomic_load_n_simt_(const_cast<const type *>(ptr), memorder);
-}
-template <class type>
-void __device__ __atomic_load_simt(const volatile type *ptr, type *ret,
-                                   int memorder) {
-  __atomic_load_simt_(const_cast<const type *>(ptr), ret, memorder);
-}
-template <class type>
-void __device__ __atomic_store_n_simt(volatile type *ptr, type val,
-                                      int memorder) {
-  __atomic_store_n_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-void __device__ __atomic_store_simt(volatile type *ptr, type *val,
-                                    int memorder) {
-  __atomic_store_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_exchange_n_simt(volatile type *ptr, type val,
-                                         int memorder) {
-  return __atomic_exchange_n_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-void __device__ __atomic_exchange_simt(volatile type *ptr, type *val, type *ret,
-                                       int memorder) {
-  __atomic_exchange_simt_(const_cast<type *>(ptr), val, ret, memorder);
-}
-template <class type>
-bool __device__ __atomic_compare_exchange_n_simt(volatile type *ptr,
-                                                 type *expected, type desired,
-                                                 bool weak,
-                                                 int success_memorder,
-                                                 int failure_memorder) {
-  return __atomic_compare_exchange_n_simt_(const_cast<type *>(ptr), expected,
-                                           desired, weak, success_memorder,
-                                           failure_memorder);
-}
-template <class type>
-bool __device__ __atomic_compare_exchange_simt(volatile type *ptr,
-                                               type *expected, type *desired,
-                                               bool weak, int success_memorder,
-                                               int failure_memorder) {
-  return __atomic_compare_exchange_simt_(const_cast<type *>(ptr), expected,
-                                         desired, weak, success_memorder,
-                                         failure_memorder);
-}
-template <class type, class delta>
-type __device__ __atomic_fetch_add_simt(volatile type *ptr, delta val,
-                                        int memorder) {
-  return __atomic_fetch_add_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type, class delta>
-type __device__ __atomic_fetch_sub_simt(volatile type *ptr, delta val,
-                                        int memorder) {
-  return __atomic_fetch_sub_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_fetch_and_simt(volatile type *ptr, type val,
-                                        int memorder) {
-  return __atomic_fetch_and_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_fetch_xor_simt(volatile type *ptr, type val,
-                                        int memorder) {
-  return __atomic_fetch_xor_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-type __device__ __atomic_fetch_or_simt(volatile type *ptr, type val,
-                                       int memorder) {
-  return __atomic_fetch_or_simt_(const_cast<type *>(ptr), val, memorder);
-}
-template <class type>
-bool __device__ __atomic_test_and_set_simt(volatile void *ptr, int memorder) {
-  return __atomic_test_and_set_simt_(const_cast<void *>(ptr), memorder);
-}
-template <class type>
-void __device__ __atomic_clear_simt(volatile void *ptr, int memorder) {
-  return __atomic_clear_simt_(const_cast<void *>(ptr), memorder);
-}
-
-}  // end namespace Impl
-}  // end namespace Kokkos
-
-#endif  //_SIMT_DETAILS_CONFIG
-
-#ifndef KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
-/*
-    builtins
-*/
-
-#define __atomic_load_n __atomic_load_n_simt
-#define __atomic_load __atomic_load_simt
-#define __atomic_store_n __atomic_store_n_simt
-#define __atomic_store __atomic_store_simt
-#define __atomic_exchange_n __atomic_exchange_n_simt
-#define __atomic_exchange __atomic_exchange_simt
-#define __atomic_compare_exchange_n __atomic_compare_exchange_n_simt
-#define __atomic_compare_exchange __atomic_compare_exchange_simt
-#define __atomic_fetch_add __atomic_fetch_add_simt
-#define __atomic_fetch_sub __atomic_fetch_sub_simt
-#define __atomic_fetch_and __atomic_fetch_and_simt
-#define __atomic_fetch_xor __atomic_fetch_xor_simt
-#define __atomic_fetch_or __atomic_fetch_or_simt
-#define __atomic_test_and_set __atomic_test_and_set_simt
-#define __atomic_clear __atomic_clear_simt
-#define __atomic_always_lock_free __atomic_always_lock_free_simt
-#define __atomic_is_lock_free __atomic_is_lock_free_simt
-#define __atomic_thread_fence __atomic_thread_fence_simt
-#define __atomic_signal_fence __atomic_signal_fence_simt
-
-#define KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
-
-#endif  //__CUDA_ARCH__ && KOKKOS_ENABLE_CUDA_ASM_ATOMICS
-#endif  // KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
diff --git a/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp b/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp
deleted file mode 100644
index a7dfc15d7a..0000000000
--- a/core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifdef KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
-
-#undef __atomic_load_n
-#undef __atomic_load
-#undef __atomic_store_n
-#undef __atomic_store
-#undef __atomic_exchange_n
-#undef __atomic_exchange
-#undef __atomic_compare_exchange_n
-#undef __atomic_compare_exchange
-#undef __atomic_fetch_add
-#undef __atomic_fetch_sub
-#undef __atomic_fetch_and
-#undef __atomic_fetch_xor
-#undef __atomic_fetch_or
-#undef __atomic_test_and_set
-#undef __atomic_clear
-#undef __atomic_always_lock_free
-#undef __atomic_is_lock_free
-#undef __atomic_thread_fence
-#undef __atomic_signal_fence
-
-#undef KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
-
-#endif  // KOKKOS_SIMT_ATOMIC_BUILTIN_REPLACEMENTS_DEFINED
diff --git a/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp b/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp
index 8e5d4a0706..86649fa015 100644
--- a/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp
@@ -30,12 +30,19 @@
 #include <Kokkos_Parallel_Reduce.hpp>
 #include <Kokkos_PointerOwnership.hpp>
 
-#include <Kokkos_Cuda.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
 #include <cuda_runtime_api.h>
 
 namespace Kokkos {
 namespace Impl {
 
+// FIXME Remove once all backends implement the new reduce interface
+template <class CombinedFunctorReducer, class PolicyType>
+struct PatternImplSpecializationFromTag<
+    Kokkos::ParallelReduceTag, CombinedFunctorReducer, PolicyType, Kokkos::Cuda>
+    : type_identity<
+          ParallelReduce<CombinedFunctorReducer, PolicyType, Kokkos::Cuda>> {};
+
 template <class PolicyType, class Functor, class PatternTag, class... Args>
 class GraphNodeKernelImpl<Kokkos::Cuda, PolicyType, Functor, PatternTag,
                           Args...>
@@ -133,8 +140,9 @@ template <class KernelType>
 struct get_graph_node_kernel_type<KernelType, Kokkos::ParallelReduceTag>
     : type_identity<GraphNodeKernelImpl<
           Kokkos::Cuda, typename KernelType::Policy,
-          typename KernelType::functor_type, Kokkos::ParallelReduceTag,
-          typename KernelType::reducer_type>> {};
+          CombinedFunctorReducer<typename KernelType::functor_type,
+                                 typename KernelType::reducer_type>,
+          Kokkos::ParallelReduceTag>> {};
 
 //==============================================================================
 // <editor-fold desc="get_cuda_graph_*() helper functions"> {{{1
diff --git a/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp b/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp
index a586d30147..17de1be7a6 100644
--- a/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp
@@ -25,7 +25,7 @@
 
 #include <impl/Kokkos_GraphImpl.hpp>  // GraphAccess needs to be complete
 
-#include <Kokkos_Cuda.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
 #include <cuda_runtime_api.h>
 
 namespace Kokkos {
diff --git a/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp b/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp
index 26face64c9..0609d0ffa6 100644
--- a/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp
@@ -30,7 +30,7 @@
 #include <impl/Kokkos_GraphNodeImpl.hpp>
 #include <Cuda/Kokkos_Cuda_GraphNode_Impl.hpp>
 
-#include <Kokkos_Cuda.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
 #include <cuda_runtime_api.h>
 #include <Cuda/Kokkos_Cuda_Error.hpp>
 
diff --git a/core/src/Cuda/Kokkos_Cuda_Half_Conversion.hpp b/core/src/Cuda/Kokkos_Cuda_Half_Conversion.hpp
index eaa6263c40..59acaa6d76 100644
--- a/core/src/Cuda/Kokkos_Cuda_Half_Conversion.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Half_Conversion.hpp
@@ -260,10 +260,16 @@ KOKKOS_INLINE_FUNCTION
 
 /************************** bhalf conversions *********************************/
 // Go in this branch if CUDA version is >= 11.0.0 and less than 11.1.0 or if the
-// architecture is not Ampere
+// architecture is older than Ampere
+#if !defined(KOKKOS_ARCH_KEPLER) && !defined(KOKKOS_ARCH_MAXWELL) && \
+    !defined(KOKKOS_ARCH_PASCAL) && !defined(KOKKOS_ARCH_VOLTA) &&   \
+    !defined(KOKKOS_ARCH_TURING75)
+#define KOKKOS_IMPL_NVIDIA_GPU_ARCH_SUPPORT_BHALF
+#endif
+
 #if CUDA_VERSION >= 11000 && \
     (CUDA_VERSION < 11010 || \
-     !(defined(KOKKOS_ARCH_AMPERE) || defined(KOKKOS_ARCH_HOPPER)))
+     !defined(KOKKOS_IMPL_NVIDIA_GPU_ARCH_SUPPORT_BHALF))
 KOKKOS_INLINE_FUNCTION
 bhalf_t cast_to_bhalf(bhalf_t val) { return val; }
 
@@ -390,8 +396,7 @@ KOKKOS_INLINE_FUNCTION
 }
 #endif  // CUDA_VERSION >= 11000 && CUDA_VERSION < 11010
 
-#if CUDA_VERSION >= 11010 && \
-    ((defined(KOKKOS_ARCH_AMPERE) || defined(KOKKOS_ARCH_HOPPER)))
+#if CUDA_VERSION >= 11010 && defined(KOKKOS_IMPL_NVIDIA_GPU_ARCH_SUPPORT_BHALF)
 KOKKOS_INLINE_FUNCTION
 bhalf_t cast_to_bhalf(bhalf_t val) { return val; }
 KOKKOS_INLINE_FUNCTION
@@ -473,6 +478,8 @@ KOKKOS_INLINE_FUNCTION
   return static_cast<T>(cast_from_bhalf<unsigned long long>(val));
 }
 #endif  // CUDA_VERSION >= 11010
+
+#undef KOKKOS_IMPL_NVIDIA_GPU_ARCH_SUPPORT_BHALF
 }  // namespace Experimental
 
 #if (CUDA_VERSION >= 11000)
diff --git a/core/src/Cuda/Kokkos_Cuda_Instance.cpp b/core/src/Cuda/Kokkos_Cuda_Instance.cpp
index 3dbe179d66..cb88c5adf1 100644
--- a/core/src/Cuda/Kokkos_Cuda_Instance.cpp
+++ b/core/src/Cuda/Kokkos_Cuda_Instance.cpp
@@ -29,7 +29,6 @@
 #include <Cuda/Kokkos_Cuda_Error.hpp>
 #include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
 #include <Cuda/Kokkos_Cuda_Instance.hpp>
-#include <Cuda/Kokkos_Cuda_Locks.hpp>
 #include <Cuda/Kokkos_Cuda_UniqueToken.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_Tools.hpp>
@@ -129,9 +128,17 @@ void cuda_device_synchronize(const std::string &name) {
       name,
       Kokkos::Tools::Experimental::SpecialSynchronizationCases::
           GlobalDeviceSynchronization,
+#if defined(KOKKOS_COMPILER_CLANG)
+      // annotate with __host__ silence a clang warning about using
+      // cudaDeviceSynchronize in device code
+      [] __host__() {  // TODO: correct device ID
+        KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
+      });
+#else
       []() {  // TODO: correct device ID
         KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
       });
+#endif
 }
 
 void cuda_stream_synchronize(const cudaStream_t stream, const CudaInternal *ptr,
@@ -401,7 +408,9 @@ Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default
 #endif
 
   // Init the array for used for arbitrarily sized atomics
-  if (this == &singleton()) Impl::initialize_host_cuda_lock_arrays();
+  if (this == &singleton()) {
+    desul::Impl::init_lock_arrays();  // FIXME
+  }
 
   // Allocate a staging buffer for constant mem in pinned host memory
   // and an event to avoid overwriting driver for previous kernel launches
@@ -420,10 +429,11 @@ Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default
     m_team_scratch_ptr[i]          = nullptr;
   }
 
+  m_num_scratch_locks = concurrency();
   KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMalloc(&m_scratch_locks, sizeof(int32_t) * concurrency()));
+      cudaMalloc(&m_scratch_locks, sizeof(int32_t) * m_num_scratch_locks));
   KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMemset(m_scratch_locks, 0, sizeof(int32_t) * concurrency()));
+      cudaMemset(m_scratch_locks, 0, sizeof(int32_t) * m_num_scratch_locks));
 }
 
 //----------------------------------------------------------------------------
@@ -574,7 +584,7 @@ void CudaInternal::finalize() {
   // Only finalize this if we're the singleton
   if (this == &singleton()) {
     (void)Impl::cuda_global_unique_token_locks(true);
-    Impl::finalize_host_cuda_lock_arrays();
+    desul::Impl::finalize_lock_arrays();  // FIXME
 
     KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeHost(constantMemHostStaging));
     KOKKOS_IMPL_CUDA_SAFE_CALL(cudaEventDestroy(constantMemReusable));
@@ -618,7 +628,8 @@ void CudaInternal::finalize() {
   }
 
   KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(m_scratch_locks));
-  m_scratch_locks = nullptr;
+  m_scratch_locks     = nullptr;
+  m_num_scratch_locks = 0;
 }
 
 //----------------------------------------------------------------------------
@@ -856,14 +867,6 @@ void Cuda::print_configuration(std::ostream &os, bool /*verbose*/) const {
   os << "Device Execution Space:\n";
   os << "  KOKKOS_ENABLE_CUDA: yes\n";
 
-  os << "Cuda Atomics:\n";
-  os << "  KOKKOS_ENABLE_CUDA_ATOMICS: ";
-#ifdef KOKKOS_ENABLE_CUDA_ATOMICS
-  os << "yes\n";
-#else
-  os << "no\n";
-#endif
-
   os << "Cuda Options:\n";
   os << "  KOKKOS_ENABLE_CUDA_LAMBDA: ";
 #ifdef KOKKOS_ENABLE_CUDA_LAMBDA
diff --git a/core/src/Cuda/Kokkos_Cuda_Instance.hpp b/core/src/Cuda/Kokkos_Cuda_Instance.hpp
index af34a5b9db..ddbddfd674 100644
--- a/core/src/Cuda/Kokkos_Cuda_Instance.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Instance.hpp
@@ -138,7 +138,8 @@ class CudaInternal {
   mutable int64_t m_team_scratch_current_size[10];
   mutable void* m_team_scratch_ptr[10];
   mutable std::atomic_int m_team_scratch_pool[10];
-  std::int32_t* m_scratch_locks;
+  int32_t* m_scratch_locks;
+  size_t m_num_scratch_locks;
 
   bool was_initialized = false;
   bool was_finalized   = false;
@@ -234,11 +235,13 @@ std::vector<Cuda> partition_space(const Cuda&, Args...) {
 }
 
 template <class T>
-std::vector<Cuda> partition_space(const Cuda&, std::vector<T>& weights) {
+std::vector<Cuda> partition_space(const Cuda&, std::vector<T> const& weights) {
   static_assert(
       std::is_arithmetic<T>::value,
       "Kokkos Error: partitioning arguments must be integers or floats");
 
+  // We only care about the number of instances to create and ignore weights
+  // otherwise.
   std::vector<Cuda> instances(weights.size());
   Impl::create_Cuda_instances(instances);
   return instances;
diff --git a/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp b/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
index 5afad7a6a3..3a96f850a9 100644
--- a/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
@@ -28,7 +28,6 @@
 #include <impl/Kokkos_Error.hpp>
 #include <Cuda/Kokkos_Cuda_abort.hpp>
 #include <Cuda/Kokkos_Cuda_Error.hpp>
-#include <Cuda/Kokkos_Cuda_Locks.hpp>
 #include <Cuda/Kokkos_Cuda_Instance.hpp>
 #include <impl/Kokkos_GraphImpl_fwd.hpp>
 #include <Cuda/Kokkos_Cuda_GraphNodeKernel.hpp>
@@ -664,7 +663,7 @@ struct CudaParallelLaunchImpl<
             shmem, desired_occupancy);
       }
 
-      ensure_cuda_lock_arrays_on_device();
+      desul::ensure_cuda_lock_arrays_on_device();
 
       // Invoke the driver function on the device
       base_t::invoke_kernel(driver, grid, block, shmem, cuda_instance);
diff --git a/core/src/Cuda/Kokkos_Cuda_Locks.cpp b/core/src/Cuda/Kokkos_Cuda_Locks.cpp
deleted file mode 100644
index b18fda80f0..0000000000
--- a/core/src/Cuda/Kokkos_Cuda_Locks.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
-#define KOKKOS_IMPL_PUBLIC_INCLUDE
-#endif
-
-#include <Kokkos_Core.hpp>
-#ifdef KOKKOS_ENABLE_CUDA
-#include <Cuda/Kokkos_Cuda_Locks.hpp>
-#include <Cuda/Kokkos_Cuda_Error.hpp>
-
-#ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-namespace Kokkos {
-namespace Impl {
-__device__ __constant__ CudaLockArrays g_device_cuda_lock_arrays = {nullptr, 0};
-}
-}  // namespace Kokkos
-#endif
-
-namespace Kokkos {
-
-namespace {
-
-__global__ void init_lock_array_kernel_atomic() {
-  unsigned i = blockIdx.x * blockDim.x + threadIdx.x;
-  if (i < CUDA_SPACE_ATOMIC_MASK + 1) {
-    Kokkos::Impl::g_device_cuda_lock_arrays.atomic[i] = 0;
-  }
-}
-
-}  // namespace
-
-namespace Impl {
-
-CudaLockArrays g_host_cuda_lock_arrays = {nullptr, 0};
-
-void initialize_host_cuda_lock_arrays() {
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-  desul::Impl::init_lock_arrays();
-  desul::ensure_cuda_lock_arrays_on_device();
-#endif
-  if (g_host_cuda_lock_arrays.atomic != nullptr) return;
-  KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMalloc(&g_host_cuda_lock_arrays.atomic,
-                 sizeof(int) * (CUDA_SPACE_ATOMIC_MASK + 1)));
-  Impl::cuda_device_synchronize(
-      "Kokkos::Impl::initialize_host_cuda_lock_arrays: Pre Init Lock Arrays");
-  g_host_cuda_lock_arrays.n = CudaInternal::concurrency();
-  copy_cuda_lock_arrays_to_device();
-  init_lock_array_kernel_atomic<<<(CUDA_SPACE_ATOMIC_MASK + 1 + 255) / 256,
-                                  256>>>();
-  Impl::cuda_device_synchronize(
-      "Kokkos::Impl::initialize_host_cuda_lock_arrays: Post Init Lock Arrays");
-}
-
-void finalize_host_cuda_lock_arrays() {
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-  desul::Impl::finalize_lock_arrays();
-#endif
-
-  if (g_host_cuda_lock_arrays.atomic == nullptr) return;
-  cudaFree(g_host_cuda_lock_arrays.atomic);
-  g_host_cuda_lock_arrays.atomic = nullptr;
-  g_host_cuda_lock_arrays.n      = 0;
-#ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-  copy_cuda_lock_arrays_to_device();
-#endif
-}
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-#else
-
-void KOKKOS_CORE_SRC_CUDA_CUDA_LOCKS_PREVENT_LINK_ERROR() {}
-
-#endif
diff --git a/core/src/Cuda/Kokkos_Cuda_Locks.hpp b/core/src/Cuda/Kokkos_Cuda_Locks.hpp
deleted file mode 100644
index 3916ae2c53..0000000000
--- a/core/src/Cuda/Kokkos_Cuda_Locks.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_CUDA_LOCKS_HPP
-#define KOKKOS_CUDA_LOCKS_HPP
-
-#include <Kokkos_Macros.hpp>
-
-#ifdef KOKKOS_ENABLE_CUDA
-
-#include <cstdint>
-
-#include <Cuda/Kokkos_Cuda_Error.hpp>
-
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-#include <desul/atomics/Lock_Array_CUDA.hpp>
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-struct CudaLockArrays {
-  std::int32_t* atomic;
-  std::int32_t n;
-};
-
-/// \brief This global variable in Host space is the central definition
-///        of these arrays.
-extern CudaLockArrays g_host_cuda_lock_arrays;
-
-/// \brief After this call, the g_host_cuda_lock_arrays variable has
-///        valid, initialized arrays.
-///
-/// This call is idempotent.
-void initialize_host_cuda_lock_arrays();
-
-/// \brief After this call, the g_host_cuda_lock_arrays variable has
-///        all null pointers, and all array memory has been freed.
-///
-/// This call is idempotent.
-void finalize_host_cuda_lock_arrays();
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-
-/// \brief This global variable in CUDA space is what kernels use
-///        to get access to the lock arrays.
-///
-/// When relocatable device code is enabled, there can be one single
-/// instance of this global variable for the entire executable,
-/// whose definition will be in Kokkos_Cuda_Locks.cpp (and whose declaration
-/// here must then be extern.
-/// This one instance will be initialized by initialize_host_cuda_lock_arrays
-/// and need not be modified afterwards.
-///
-/// When relocatable device code is disabled, an instance of this variable
-/// will be created in every translation unit that sees this header file
-/// (we make this clear by marking it static, meaning no other translation
-///  unit can link to it).
-/// Since the Kokkos_Cuda_Locks.cpp translation unit cannot initialize the
-/// instances in other translation units, we must update this CUDA global
-/// variable based on the Host global variable prior to running any kernels
-/// that will use it.
-/// That is the purpose of the ensure_cuda_lock_arrays_on_device function.
-__device__
-#ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-    __constant__ extern
-#endif
-    CudaLockArrays g_device_cuda_lock_arrays;
-
-#define CUDA_SPACE_ATOMIC_MASK 0x1FFFF
-
-/// \brief Acquire a lock for the address
-///
-/// This function tries to acquire the lock for the hash value derived
-/// from the provided ptr. If the lock is successfully acquired the
-/// function returns true. Otherwise it returns false.
-__device__ inline bool lock_address_cuda_space(void* ptr) {
-  size_t offset = size_t(ptr);
-  offset        = offset >> 2;
-  offset        = offset & CUDA_SPACE_ATOMIC_MASK;
-  return (0 == atomicCAS(&g_device_cuda_lock_arrays.atomic[offset], 0, 1));
-}
-
-/// \brief Release lock for the address
-///
-/// This function releases the lock for the hash value derived
-/// from the provided ptr. This function should only be called
-/// after previously successfully acquiring a lock with
-/// lock_address.
-__device__ inline void unlock_address_cuda_space(void* ptr) {
-  size_t offset = size_t(ptr);
-  offset        = offset >> 2;
-  offset        = offset & CUDA_SPACE_ATOMIC_MASK;
-  atomicExch(&g_device_cuda_lock_arrays.atomic[offset], 0);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-// Make lock_array_copied an explicit translation unit scope thingy
-namespace Kokkos {
-namespace Impl {
-namespace {
-static int lock_array_copied = 0;
-inline int eliminate_warning_for_lock_array() { return lock_array_copied; }
-}  // namespace
-
-#ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-inline
-#else
-inline static
-#endif
-    void
-    copy_cuda_lock_arrays_to_device() {
-  if (lock_array_copied == 0) {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaMemcpyToSymbol(g_device_cuda_lock_arrays,
-                                                  &g_host_cuda_lock_arrays,
-                                                  sizeof(CudaLockArrays)));
-  }
-  lock_array_copied = 1;
-}
-
-#ifndef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-
-#ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-inline void ensure_cuda_lock_arrays_on_device() {}
-#else
-inline static void ensure_cuda_lock_arrays_on_device() {
-  copy_cuda_lock_arrays_to_device();
-}
-#endif
-
-#else
-
-#ifdef KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
-inline void ensure_cuda_lock_arrays_on_device() {}
-#else
-// Still Need COPY_CUDA_LOCK_ARRAYS for team scratch etc.
-inline static void ensure_cuda_lock_arrays_on_device() {
-  copy_cuda_lock_arrays_to_device();
-  desul::ensure_cuda_lock_arrays_on_device();
-}
-#endif
-
-#endif /* defined( KOKKOS_ENABLE_IMPL_DESUL_ATOMICS ) */
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif /* defined( KOKKOS_ENABLE_CUDA ) */
-
-#endif /* #ifndef KOKKOS_CUDA_LOCKS_HPP */
diff --git a/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp b/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp
index 0015d1ea14..8aae27d091 100644
--- a/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp
@@ -188,11 +188,13 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, Kokkos::Cuda> {
       : m_functor(arg_functor), m_rp(arg_policy) {}
 };
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
-                     Kokkos::Cuda> {
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>, Kokkos::Cuda> {
  public:
-  using Policy = Kokkos::MDRangePolicy<Traits...>;
+  using Policy      = Kokkos::MDRangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
   using array_index_type = typename Policy::array_index_type;
@@ -202,37 +204,41 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   using Member       = typename Policy::member_type;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
-
-  using Analysis =
-      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy,
-                                    ReducerTypeFwd>;
-
  public:
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
   using functor_type   = FunctorType;
   using size_type      = Cuda::size_type;
   using reducer_type   = ReducerType;
 
+  // Conditionally set word_size_type to int16_t or int8_t if value_type is
+  // smaller than int32_t (Kokkos::Cuda::size_type)
+  // word_size_type is used to determine the word count, shared memory buffer
+  // size, and global memory buffer size before the reduction is performed.
+  // Within the reduction, the word count is recomputed based on word_size_type
+  // and when calculating indexes into the shared/global memory buffers for
+  // performing the reduction, word_size_type is used again.
+  // For scalars > 4 bytes in size, indexing into shared/global memory relies
+  // on the block and grid dimensions to ensure that we index at the correct
+  // offset rather than at every 4 byte word; such that, when the join is
+  // performed, we have the correct data that was copied over in chunks of 4
+  // bytes.
+  static_assert(sizeof(size_type) == 4);
+  using word_size_type = std::conditional_t<
+      sizeof(value_type) < 4,
+      std::conditional_t<sizeof(value_type) == 2, int16_t, int8_t>, size_type>;
+
   // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
   // blockDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;  // used for workrange and nwork
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
-  size_type* m_scratch_space;
+  word_size_type* m_scratch_space;
   size_type* m_scratch_flags;
-  size_type* m_unified_space;
+  word_size_type* m_unified_space;
 
   using DeviceIteratePattern = typename Kokkos::Impl::Reduce::DeviceIterateTile<
       Policy::rank, Policy, FunctorType, typename Policy::work_tag,
@@ -241,7 +247,7 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   // Shall we use the shfl based reduction or not (only use it for static sized
   // types of more than 128bit
   static constexpr bool UseShflReduction = false;
-  //((sizeof(value_type)>2*sizeof(double)) && Analysis::StaticValueSize)
+  //((sizeof(value_type)>2*sizeof(double)) && ReducerType::static_value_size())
   // Some crutch to do function overloading
 
  public:
@@ -253,29 +259,28 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   inline __device__ void exec_range(reference_type update) const {
     Kokkos::Impl::Reduce::DeviceIterateTile<Policy::rank, Policy, FunctorType,
                                             typename Policy::work_tag,
-                                            reference_type>(m_policy, m_functor,
-                                                            update)
+                                            reference_type>(
+        m_policy, m_functor_reducer.get_functor(), update)
         .exec_range();
   }
 
   inline __device__ void operator()() const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-    const integral_nonzero_constant<size_type, Analysis::StaticValueSize /
-                                                   sizeof(size_type)>
-        word_count(Analysis::value_size(
-                       ReducerConditional::select(m_functor, m_reducer)) /
-                   sizeof(size_type));
+    const integral_nonzero_constant<word_size_type,
+                                    ReducerType::static_value_size() /
+                                        sizeof(word_size_type)>
+        word_count(m_functor_reducer.get_reducer().value_size() /
+                   sizeof(word_size_type));
 
     {
-      reference_type value = final_reducer.init(reinterpret_cast<pointer_type>(
-          kokkos_impl_cuda_shared_memory<size_type>() +
-          threadIdx.y * word_count.value));
+      reference_type value =
+          m_functor_reducer.get_reducer().init(reinterpret_cast<pointer_type>(
+              kokkos_impl_cuda_shared_memory<word_size_type>() +
+              threadIdx.y * word_count.value));
 
       // Number of blocks is bounded so that the reduction can be limited to two
       // passes. Each thread block is given an approximately equal amount of
       // work to perform. Accumulate the values for this block. The accumulation
-      // ordering does not match the final pass, but is arithmatically
+      // ordering does not match the final pass, but is arithmetically
       // equivalent.
 
       this->exec_range(value);
@@ -284,20 +289,22 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     // Reduce with final value at blockDim.y - 1 location.
     // Problem: non power-of-two blockDim
     if (cuda_single_inter_block_reduce_scan<false>(
-            final_reducer, blockIdx.x, gridDim.x,
-            kokkos_impl_cuda_shared_memory<size_type>(), m_scratch_space,
+            m_functor_reducer.get_reducer(), blockIdx.x, gridDim.x,
+            kokkos_impl_cuda_shared_memory<word_size_type>(), m_scratch_space,
             m_scratch_flags)) {
       // This is the final block with the final result at the final threads'
       // location
-      size_type* const shared = kokkos_impl_cuda_shared_memory<size_type>() +
-                                (blockDim.y - 1) * word_count.value;
-      size_type* const global =
+      word_size_type* const shared =
+          kokkos_impl_cuda_shared_memory<word_size_type>() +
+          (blockDim.y - 1) * word_count.value;
+      word_size_type* const global =
           m_result_ptr_device_accessible
-              ? reinterpret_cast<size_type*>(m_result_ptr)
+              ? reinterpret_cast<word_size_type*>(m_result_ptr)
               : (m_unified_space ? m_unified_space : m_scratch_space);
 
       if (threadIdx.y == 0) {
-        final_reducer.final(reinterpret_cast<value_type*>(shared));
+        m_functor_reducer.get_reducer().final(
+            reinterpret_cast<value_type*>(shared));
       }
 
       if (CudaTraits::WarpSize < word_count.value) {
@@ -314,9 +321,11 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   inline unsigned local_block_size(const FunctorType& f) {
     unsigned n = CudaTraits::WarpSize * 8;
     int shmem_size =
-        cuda_single_inter_block_reduce_scan_shmem<false, FunctorType, WorkTag>(
+        cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, value_type>(
             f, n);
-    using closure_type = Impl::ParallelReduce<FunctorType, Policy, ReducerType>;
+    using closure_type =
+        Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             Policy, Kokkos::Cuda>;
     cudaFuncAttributes attr =
         CudaParallelLaunch<closure_type,
                            LaunchBounds>::get_cuda_func_attributes();
@@ -330,39 +339,39 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
                  m_policy.space().impl_internal_space_instance(), attr, f, 1,
                  shmem_size, 0)))) {
       n >>= 1;
-      shmem_size = cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                             WorkTag>(f, n);
+      shmem_size =
+          cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, value_type>(
+              f, n);
     }
     return n;
   }
 
   inline void execute() {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
     const auto nwork = m_policy.m_num_tiles;
     if (nwork) {
       int block_size = m_policy.m_prod_tile_dims;
       // CONSTRAINT: Algorithm requires block_size >= product of tile dimensions
       // Nearest power of two
-      int exponent_pow_two    = std::ceil(std::log2(block_size));
-      block_size              = std::pow(2, exponent_pow_two);
-      int suggested_blocksize = local_block_size(m_functor);
+      int exponent_pow_two = std::ceil(std::log2(block_size));
+      block_size           = std::pow(2, exponent_pow_two);
+      int suggested_blocksize =
+          local_block_size(m_functor_reducer.get_functor());
 
       block_size = (block_size > suggested_blocksize)
                        ? block_size
                        : suggested_blocksize;  // Note: block_size must be less
                                                // than or equal to 512
 
-      m_scratch_space = cuda_internal_scratch_space(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)) *
-                                block_size /* block_size == max block_count */);
+      m_scratch_space =
+          reinterpret_cast<word_size_type*>(cuda_internal_scratch_space(
+              m_policy.space(),
+              m_functor_reducer.get_reducer().value_size() *
+                  block_size /* block_size == max block_count */));
       m_scratch_flags =
           cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type));
-      m_unified_space = cuda_internal_scratch_unified(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)));
+      m_unified_space =
+          reinterpret_cast<word_size_type*>(cuda_internal_scratch_unified(
+              m_policy.space(), m_functor_reducer.get_reducer().value_size()));
 
       // REQUIRED ( 1 , N , 1 )
       const dim3 block(1, block_size, 1);
@@ -373,9 +382,9 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
       const int shmem =
           UseShflReduction
               ? 0
-              : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                          WorkTag>(m_functor,
-                                                                   block.y);
+              : cuda_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                          value_type>(
+                    m_functor_reducer.get_functor(), block.y);
 
       CudaParallelLaunch<ParallelReduce, LaunchBounds>(
           *this, grid, block, shmem,
@@ -389,14 +398,12 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
                 "Kokkos::Impl::ParallelReduce<Cuda, MDRangePolicy>::execute: "
                 "Result Not Device Accessible");
 
-            const int count = Analysis::value_count(
-                ReducerConditional::select(m_functor, m_reducer));
+            const int count = m_functor_reducer.get_reducer().value_count();
             for (int i = 0; i < count; ++i) {
               m_result_ptr[i] = pointer_type(m_unified_space)[i];
             }
           } else {
-            const int size = Analysis::value_size(
-                ReducerConditional::select(m_functor, m_reducer));
+            const int size = m_functor_reducer.get_reducer().value_size();
             DeepCopy<HostSpace, CudaSpace, Cuda>(m_policy.space(), m_result_ptr,
                                                  m_scratch_space, size);
           }
@@ -405,19 +412,16 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     } else {
       if (m_result_ptr) {
         // TODO @graph We need to effectively insert this in to the graph
-        final_reducer.init(m_result_ptr);
+        m_functor_reducer.get_reducer().init(m_result_ptr);
       }
     }
   }
 
   template <class ViewType>
-  ParallelReduce(
-      const FunctorType& arg_functor, const Policy& arg_policy,
-      const ViewType& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<Kokkos::CudaSpace,
@@ -425,23 +429,8 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
         m_scratch_space(nullptr),
         m_scratch_flags(nullptr),
         m_unified_space(nullptr) {
-    check_reduced_view_shmem_size<WorkTag>(m_policy, m_functor);
-  }
-
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::CudaSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_scratch_space(nullptr),
-        m_scratch_flags(nullptr),
-        m_unified_space(nullptr) {
-    check_reduced_view_shmem_size<WorkTag>(m_policy, m_functor);
+    check_reduced_view_shmem_size<WorkTag, value_type>(
+        m_policy, m_functor_reducer.get_functor());
   }
 };
 }  // namespace Impl
diff --git a/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp b/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp
index c5e89fc3da..5226c48bd9 100644
--- a/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp
@@ -114,11 +114,13 @@ class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
       : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
                      Kokkos::Cuda> {
  public:
-  using Policy = Kokkos::RangePolicy<Traits...>;
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
   using WorkRange    = typename Policy::WorkRange;
@@ -126,22 +128,10 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   using Member       = typename Policy::member_type;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
-
-  using Analysis =
-      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy,
-                                    ReducerTypeFwd>;
-
  public:
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
   using functor_type   = FunctorType;
   // Conditionally set word_size_type to int16_t or int8_t if value_type is
   // smaller than int32_t (Kokkos::Cuda::size_type)
@@ -165,9 +155,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
   // blockDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
   const bool m_result_ptr_host_accessible;
@@ -179,7 +168,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
 
   // FIXME_CUDA Shall we use the shfl based reduction or not (only use it for
   // static sized types of more than 128bit:
-  // sizeof(value_type)>2*sizeof(double)) && Analysis::StaticValueSize)
+  // sizeof(value_type)>2*sizeof(double)) && ReducerType::static_value_size())
   static constexpr bool UseShflReduction = false;
 
  public:
@@ -189,34 +178,32 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update) const {
-    m_functor(i, update);
+    m_functor_reducer.get_functor()(i, update);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update) const {
-    m_functor(TagType(), i, update);
+    m_functor_reducer.get_functor()(TagType(), i, update);
   }
 
   __device__ inline void operator()() const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
-    const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
-                                                        sizeof(word_size_type)>
-        word_count(Analysis::value_size(
-                       ReducerConditional::select(m_functor, m_reducer)) /
+    const integral_nonzero_constant<word_size_type,
+                                    ReducerType::static_value_size() /
+                                        sizeof(word_size_type)>
+        word_count(m_functor_reducer.get_reducer().value_size() /
                    sizeof(word_size_type));
 
     {
-      reference_type value = final_reducer.init(reinterpret_cast<pointer_type>(
-          kokkos_impl_cuda_shared_memory<word_size_type>() +
-          threadIdx.y * word_count.value));
+      reference_type value =
+          m_functor_reducer.get_reducer().init(reinterpret_cast<pointer_type>(
+              kokkos_impl_cuda_shared_memory<word_size_type>() +
+              threadIdx.y * word_count.value));
 
       // Number of blocks is bounded so that the reduction can be limited to two
       // passes. Each thread block is given an approximately equal amount of
       // work to perform. Accumulate the values for this block. The accumulation
-      // ordering does not match the final pass, but is arithmatically
+      // ordering does not match the final pass, but is arithmetically
       // equivalent.
 
       const WorkRange range(m_policy, blockIdx.x, gridDim.x);
@@ -233,7 +220,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     bool do_final_reduction = true;
     if (!zero_length)
       do_final_reduction = cuda_single_inter_block_reduce_scan<false>(
-          final_reducer, blockIdx.x, gridDim.x,
+          m_functor_reducer.get_reducer(), blockIdx.x, gridDim.x,
           kokkos_impl_cuda_shared_memory<word_size_type>(), m_scratch_space,
           m_scratch_flags);
 
@@ -250,7 +237,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
               : (m_unified_space ? m_unified_space : m_scratch_space);
 
       if (threadIdx.y == 0) {
-        final_reducer.final(reinterpret_cast<value_type*>(shared));
+        m_functor_reducer.get_reducer().final(
+            reinterpret_cast<value_type*>(shared));
       }
 
       if (CudaTraits::WarpSize < word_count.value) {
@@ -267,9 +255,11 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   inline unsigned local_block_size(const FunctorType& f) {
     unsigned n = CudaTraits::WarpSize * 8;
     int shmem_size =
-        cuda_single_inter_block_reduce_scan_shmem<false, FunctorType, WorkTag>(
+        cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, value_type>(
             f, n);
-    using closure_type = Impl::ParallelReduce<FunctorType, Policy, ReducerType>;
+    using closure_type =
+        Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             Policy, Kokkos::Cuda>;
     cudaFuncAttributes attr =
         CudaParallelLaunch<closure_type,
                            LaunchBounds>::get_cuda_func_attributes();
@@ -283,31 +273,28 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                  m_policy.space().impl_internal_space_instance(), attr, f, 1,
                  shmem_size, 0)))) {
       n >>= 1;
-      shmem_size = cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                             WorkTag>(f, n);
+      shmem_size =
+          cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, value_type>(
+              f, n);
     }
     return n;
   }
 
   inline void execute() {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
     const index_type nwork     = m_policy.end() - m_policy.begin();
-    const bool need_device_set = Analysis::has_init_member_function ||
-                                 Analysis::has_final_member_function ||
+    const bool need_device_set = ReducerType::has_init_member_function() ||
+                                 ReducerType::has_final_member_function() ||
                                  !m_result_ptr_host_accessible ||
                                  Policy::is_graph_kernel::value ||
                                  !std::is_same<ReducerType, InvalidType>::value;
     if ((nwork > 0) || need_device_set) {
-      const int block_size = local_block_size(m_functor);
+      const int block_size = local_block_size(m_functor_reducer.get_functor());
 
       KOKKOS_ASSERT(block_size > 0);
 
       // TODO: down casting these uses more space than required?
       m_scratch_space = (word_size_type*)cuda_internal_scratch_space(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)) *
+          m_policy.space(), m_functor_reducer.get_reducer().value_size() *
                                 block_size /* block_size == max block_count */);
 
       // Intentionally do not downcast to word_size_type since we use Cuda
@@ -316,8 +303,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                                                     sizeof(Cuda::size_type));
       m_unified_space =
           reinterpret_cast<word_size_type*>(cuda_internal_scratch_unified(
-              m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                    m_functor, m_reducer))));
+              m_policy.space(), m_functor_reducer.get_reducer().value_size()));
 
       // REQUIRED ( 1 , N , 1 )
       dim3 block(1, block_size, 1);
@@ -329,9 +315,9 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
       const int shmem =
           UseShflReduction
               ? 0
-              : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                          WorkTag>(m_functor,
-                                                                   block.y);
+              : cuda_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                          value_type>(
+                    m_functor_reducer.get_functor(), block.y);
 
       if ((nwork == 0)
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
@@ -354,14 +340,12 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                 "Kokkos::Impl::ParallelReduce<Cuda, RangePolicy>::execute: "
                 "Result "
                 "Not Device Accessible");
-            const int count = Analysis::value_count(
-                ReducerConditional::select(m_functor, m_reducer));
+            const int count = m_functor_reducer.get_reducer().value_count();
             for (int i = 0; i < count; ++i) {
               m_result_ptr[i] = pointer_type(m_unified_space)[i];
             }
           } else {
-            const int size = Analysis::value_size(
-                ReducerConditional::select(m_functor, m_reducer));
+            const int size = m_functor_reducer.get_reducer().value_size();
             DeepCopy<HostSpace, CudaSpace, Cuda>(m_policy.space(), m_result_ptr,
                                                  m_scratch_space, size);
           }
@@ -370,19 +354,16 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     } else {
       if (m_result_ptr) {
         // TODO @graph We need to effectively insert this in to the graph
-        final_reducer.init(m_result_ptr);
+        m_functor_reducer.get_reducer().init(m_result_ptr);
       }
     }
   }
 
   template <class ViewType>
-  ParallelReduce(
-      const FunctorType& arg_functor, const Policy& arg_policy,
-      const ViewType& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<Kokkos::CudaSpace,
@@ -393,27 +374,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         m_scratch_space(nullptr),
         m_scratch_flags(nullptr),
         m_unified_space(nullptr) {
-    check_reduced_view_shmem_size<WorkTag>(m_policy, m_functor);
-  }
-
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::CudaSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_result_ptr_host_accessible(
-            MemorySpaceAccess<Kokkos::HostSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_scratch_space(nullptr),
-        m_scratch_flags(nullptr),
-        m_unified_space(nullptr) {
-    check_reduced_view_shmem_size<WorkTag>(m_policy, m_functor);
+    check_reduced_view_shmem_size<WorkTag, value_type>(
+        m_policy, m_functor_reducer.get_functor());
   }
 };
 
@@ -429,7 +391,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
   using LaunchBounds = typename Policy::launch_bounds;
 
   using Analysis = Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::SCAN,
-                                                 Policy, FunctorType>;
+                                                 Policy, FunctorType, void>;
 
  public:
   using pointer_type   = typename Analysis::pointer_type;
@@ -460,7 +422,8 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
   //  (c) gridDim.x  <= blockDim.y * blockDim.y
   //  (d) gridDim.y  == gridDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
   const Policy m_policy;
   word_size_type* m_scratch_space;
   size_type* m_scratch_flags;
@@ -472,23 +435,25 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update, const bool final_result) const {
-    m_functor(i, update, final_result);
+    m_functor_reducer.get_functor()(i, update, final_result);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update, const bool final_result) const {
-    m_functor(TagType(), i, update, final_result);
+    m_functor_reducer.get_functor()(TagType(), i, update, final_result);
   }
 
   //----------------------------------------
 
   __device__ inline void initial() const {
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
                                                         sizeof(word_size_type)>
-        word_count(Analysis::value_size(m_functor) / sizeof(word_size_type));
+        word_count(Analysis::value_size(m_functor_reducer.get_functor()) /
+                   sizeof(word_size_type));
 
     word_size_type* const shared_value =
         kokkos_impl_cuda_shared_memory<word_size_type>() +
@@ -499,7 +464,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
     // Number of blocks is bounded so that the reduction can be limited to two
     // passes. Each thread block is given an approximately equal amount of work
     // to perform. Accumulate the values for this block. The accumulation
-    // ordering does not match the final pass, but is arithmatically equivalent.
+    // ordering does not match the final pass, but is arithmetically equivalent.
 
     const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
@@ -524,11 +489,13 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
   //----------------------------------------
 
   __device__ inline void final() const {
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
                                                         sizeof(word_size_type)>
-        word_count(Analysis::value_size(m_functor) / sizeof(word_size_type));
+        word_count(Analysis::value_size(m_functor_reducer.get_functor()) /
+                   sizeof(word_size_type));
 
     // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] ,
     // value[2] , ... }
@@ -643,11 +610,12 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
     // testing
 
     unsigned n = CudaTraits::WarpSize * 4;
-    while (n && unsigned(m_policy.space()
-                             .impl_internal_space_instance()
-                             ->m_maxShmemPerBlock) <
-                    cuda_single_inter_block_reduce_scan_shmem<true, FunctorType,
-                                                              WorkTag>(f, n)) {
+    while (n &&
+           unsigned(m_policy.space()
+                        .impl_internal_space_instance()
+                        ->m_maxShmemPerBlock) <
+               cuda_single_inter_block_reduce_scan_shmem<true, WorkTag,
+                                                         value_type>(f, n)) {
       n >>= 1;
     }
     return n;
@@ -658,7 +626,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
     if (nwork) {
       constexpr int GridMaxComputeCapability_2x = 0x0ffff;
 
-      const int block_size = local_block_size(m_functor);
+      const int block_size = local_block_size(m_functor_reducer.get_functor());
       KOKKOS_ASSERT(block_size > 0);
 
       const int grid_max =
@@ -678,13 +646,15 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
 
       m_scratch_space =
           reinterpret_cast<word_size_type*>(cuda_internal_scratch_space(
-              m_policy.space(), Analysis::value_size(m_functor) * grid_x));
+              m_policy.space(),
+              Analysis::value_size(m_functor_reducer.get_functor()) * grid_x));
       m_scratch_flags =
           cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type) * 1);
 
       dim3 grid(grid_x, 1, 1);
       dim3 block(1, block_size, 1);  // REQUIRED DIMENSIONS ( 1 , N , 1 )
-      const int shmem = Analysis::value_size(m_functor) * (block_size + 2);
+      const int shmem = Analysis::value_size(m_functor_reducer.get_functor()) *
+                        (block_size + 2);
 
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
       if (m_run_serial) {
@@ -709,7 +679,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
   }
 
   ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_functor(arg_functor),
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
         m_policy(arg_policy),
         m_scratch_space(nullptr),
         m_scratch_flags(nullptr),
@@ -735,8 +705,9 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   using WorkRange    = typename Policy::WorkRange;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using Analysis = Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::SCAN,
-                                                 Policy, FunctorType>;
+  using Analysis =
+      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                    FunctorType, ReturnType>;
 
  public:
   using value_type     = typename Analysis::value_type;
@@ -767,7 +738,8 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   //  (c) gridDim.x  <= blockDim.y * blockDim.y
   //  (d) gridDim.y  == gridDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
   const Policy m_policy;
   word_size_type* m_scratch_space;
   size_type* m_scratch_flags;
@@ -782,23 +754,25 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update, const bool final_result) const {
-    m_functor(i, update, final_result);
+    m_functor_reducer.get_functor()(i, update, final_result);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update, const bool final_result) const {
-    m_functor(TagType(), i, update, final_result);
+    m_functor_reducer.get_functor()(TagType(), i, update, final_result);
   }
 
   //----------------------------------------
 
   __device__ inline void initial() const {
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
                                                         sizeof(word_size_type)>
-        word_count(Analysis::value_size(m_functor) / sizeof(word_size_type));
+        word_count(Analysis::value_size(m_functor_reducer.get_functor()) /
+                   sizeof(word_size_type));
 
     word_size_type* const shared_value =
         kokkos_impl_cuda_shared_memory<word_size_type>() +
@@ -809,7 +783,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     // Number of blocks is bounded so that the reduction can be limited to two
     // passes. Each thread block is given an approximately equal amount of work
     // to perform. Accumulate the values for this block. The accumulation
-    // ordering does not match the final pass, but is arithmatically equivalent.
+    // ordering does not match the final pass, but is arithmetically equivalent.
 
     const WorkRange range(m_policy, blockIdx.x, gridDim.x);
 
@@ -834,11 +808,12 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   //----------------------------------------
 
   __device__ inline void final() const {
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
                                                         sizeof(word_size_type)>
-        word_count(Analysis::value_size(m_functor) / sizeof(word_size_type));
+        word_count(final_reducer.value_size() / sizeof(word_size_type));
 
     // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] ,
     // value[2] , ... }
@@ -959,11 +934,12 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     // testing
 
     unsigned n = CudaTraits::WarpSize * 4;
-    while (n && unsigned(m_policy.space()
-                             .impl_internal_space_instance()
-                             ->m_maxShmemPerBlock) <
-                    cuda_single_inter_block_reduce_scan_shmem<true, FunctorType,
-                                                              WorkTag>(f, n)) {
+    while (n &&
+           unsigned(m_policy.space()
+                        .impl_internal_space_instance()
+                        ->m_maxShmemPerBlock) <
+               cuda_single_inter_block_reduce_scan_shmem<true, WorkTag,
+                                                         value_type>(f, n)) {
       n >>= 1;
     }
     return n;
@@ -974,7 +950,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     if (nwork) {
       enum { GridMaxComputeCapability_2x = 0x0ffff };
 
-      const int block_size = local_block_size(m_functor);
+      const int block_size = local_block_size(m_functor_reducer.get_functor());
       KOKKOS_ASSERT(block_size > 0);
 
       const int grid_max =
@@ -992,15 +968,17 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
       // How many block are really needed for this much work:
       const int grid_x = (nwork + work_per_block - 1) / work_per_block;
 
+      const typename Analysis::Reducer& final_reducer =
+          m_functor_reducer.get_reducer();
       m_scratch_space =
           reinterpret_cast<word_size_type*>(cuda_internal_scratch_space(
-              m_policy.space(), Analysis::value_size(m_functor) * grid_x));
+              m_policy.space(), final_reducer.value_size() * grid_x));
       m_scratch_flags =
           cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type) * 1);
 
       dim3 grid(grid_x, 1, 1);
       dim3 block(1, block_size, 1);  // REQUIRED DIMENSIONS ( 1 , N , 1 )
-      const int shmem = Analysis::value_size(m_functor) * (block_size + 2);
+      const int shmem = final_reducer.value_size() * (block_size + 2);
 
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
       if (m_run_serial) {
@@ -1021,7 +999,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
           m_policy.space()
               .impl_internal_space_instance());  // copy to device and execute
 
-      const int size = Analysis::value_size(m_functor);
+      const int size = final_reducer.value_size();
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
       if (m_run_serial)
         DeepCopy<HostSpace, CudaSpace, Cuda>(m_policy.space(), &m_returnvalue,
@@ -1042,7 +1020,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   ParallelScanWithTotal(const FunctorType& arg_functor,
                         const Policy& arg_policy,
                         const ViewType& arg_result_view)
-      : m_functor(arg_functor),
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
         m_policy(arg_policy),
         m_scratch_space(nullptr),
         m_scratch_flags(nullptr),
diff --git a/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp b/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp
index cdff86ccfc..c5a211a807 100644
--- a/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp
@@ -31,7 +31,6 @@
 #include <Cuda/Kokkos_Cuda_KernelLaunch.hpp>
 #include <Cuda/Kokkos_Cuda_ReduceScan.hpp>
 #include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
-#include <Cuda/Kokkos_Cuda_Locks.hpp>
 #include <Cuda/Kokkos_Cuda_Team.hpp>
 #include <Kokkos_MinMaxClamp.hpp>
 #include <Kokkos_Vectorization.hpp>
@@ -115,13 +114,11 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
                            const ParallelReduceTag&) const {
     using functor_analysis_type =
         Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                              TeamPolicyInternal, FunctorType>;
-    using reducer_type = typename Impl::ParallelReduceReturnValue<
-        void, typename functor_analysis_type::value_type,
-        FunctorType>::reducer_type;
-    using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             reducer_type>;
+                              TeamPolicyInternal, FunctorType, void>;
+    using closure_type = Impl::ParallelReduce<
+        CombinedFunctorReducer<FunctorType,
+                               typename functor_analysis_type::Reducer>,
+        TeamPolicy<Properties...>, Kokkos::Cuda>;
     return internal_team_size_max<closure_type>(f);
   }
 
@@ -129,8 +126,8 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
   inline int team_size_max(const FunctorType& f, const ReducerType& /*r*/,
                            const ParallelReduceTag&) const {
     using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             ReducerType>;
+        Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             TeamPolicy<Properties...>, Kokkos::Cuda>;
     return internal_team_size_max<closure_type>(f);
   }
 
@@ -156,13 +153,11 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
                                    const ParallelReduceTag&) const {
     using functor_analysis_type =
         Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                              TeamPolicyInternal, FunctorType>;
-    using reducer_type = typename Impl::ParallelReduceReturnValue<
-        void, typename functor_analysis_type::value_type,
-        FunctorType>::reducer_type;
-    using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             reducer_type>;
+                              TeamPolicyInternal, FunctorType, void>;
+    using closure_type = Impl::ParallelReduce<
+        CombinedFunctorReducer<FunctorType,
+                               typename functor_analysis_type::Reducer>,
+        TeamPolicy<Properties...>, Kokkos::Cuda>;
     return internal_team_size_recommended<closure_type>(f);
   }
 
@@ -170,8 +165,8 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
   int team_size_recommended(const FunctorType& f, const ReducerType&,
                             const ParallelReduceTag&) const {
     using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             ReducerType>;
+        Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             TeamPolicy<Properties...>, Kokkos::Cuda>;
     return internal_team_size_recommended<closure_type>(f);
   }
 
@@ -370,7 +365,7 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
         typename Impl::DeduceFunctorPatternInterface<ClosureType>::type;
     using Analysis =
         Impl::FunctorAnalysis<Interface, typename ClosureType::Policy,
-                              FunctorType>;
+                              FunctorType, void>;
 
     cudaFuncAttributes attr =
         CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
@@ -408,14 +403,15 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
 };
 
 __device__ inline int64_t cuda_get_scratch_index(Cuda::size_type league_size,
-                                                 int32_t* scratch_locks) {
+                                                 int32_t* scratch_locks,
+                                                 size_t num_scratch_locks) {
   int64_t threadid = 0;
   __shared__ int64_t base_thread_id;
   if (threadIdx.x == 0 && threadIdx.y == 0) {
     int64_t const wraparound_len = Kokkos::max(
-        int64_t(1), Kokkos::min(int64_t(league_size),
-                                (int64_t(g_device_cuda_lock_arrays.n)) /
-                                    (blockDim.x * blockDim.y)));
+        int64_t(1),
+        Kokkos::min(int64_t(league_size),
+                    int64_t(num_scratch_locks) / (blockDim.x * blockDim.y)));
     threadid = (blockIdx.x * blockDim.z + threadIdx.z) % wraparound_len;
     threadid *= blockDim.x * blockDim.y;
     int done = 0;
@@ -477,6 +473,7 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
   size_t m_scratch_size[2];
   int m_scratch_pool_id = -1;
   int32_t* m_scratch_locks;
+  size_t m_num_scratch_locks;
 
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_team(
@@ -497,7 +494,8 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
     // Iterate this block through the league
     int64_t threadid = 0;
     if (m_scratch_size[1] > 0) {
-      threadid = cuda_get_scratch_index(m_league_size, m_scratch_locks);
+      threadid = cuda_get_scratch_index(m_league_size, m_scratch_locks,
+                                        m_num_scratch_locks);
     }
 
     const int int_league_size = (int)m_league_size;
@@ -605,32 +603,22 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
   }
 };
 
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::Cuda> {
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>, Kokkos::Cuda> {
  public:
-  using Policy = TeamPolicy<Properties...>;
+  using Policy      = TeamPolicy<Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
   using Member       = typename Policy::member_type;
   using WorkTag      = typename Policy::work_tag;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
-
-  using Analysis =
-      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy,
-                                    ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-  using value_type     = typename Analysis::value_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+  using value_type     = typename ReducerType::value_type;
 
  public:
   using functor_type = FunctorType;
@@ -638,7 +626,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   using reducer_type = ReducerType;
 
   static constexpr bool UseShflReduction =
-      (true && (Analysis::StaticValueSize != 0));
+      (true && (ReducerType::static_value_size() != 0));
 
  private:
   struct ShflReductionTag {};
@@ -652,9 +640,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   //  [ team   shared space ]
   //
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
   const bool m_result_ptr_host_accessible;
@@ -668,6 +655,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   size_t m_scratch_size[2];
   int m_scratch_pool_id = -1;
   int32_t* m_scratch_locks;
+  size_t m_num_scratch_locks;
   const size_type m_league_size;
   int m_team_size;
   const size_type m_vector_size;
@@ -675,13 +663,13 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_team(
       const Member& member, reference_type update) const {
-    m_functor(member, update);
+    m_functor_reducer.get_functor()(member, update);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_team(
       const Member& member, reference_type update) const {
-    m_functor(TagType(), member, update);
+    m_functor_reducer.get_functor()(TagType(), member, update);
   }
 
  public:
@@ -690,7 +678,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   __device__ inline void operator()() const {
     int64_t threadid = 0;
     if (m_scratch_size[1] > 0) {
-      threadid = cuda_get_scratch_index(m_league_size, m_scratch_locks);
+      threadid = cuda_get_scratch_index(m_league_size, m_scratch_locks,
+                                        m_num_scratch_locks);
     }
 
     using ReductionTag = std::conditional_t<UseShflReduction, ShflReductionTag,
@@ -702,18 +691,14 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   }
 
   __device__ inline void run(SHMEMReductionTag&, const int& threadid) const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
-    const integral_nonzero_constant<size_type, Analysis::StaticValueSize /
-                                                   sizeof(size_type)>
-        word_count(Analysis::value_size(
-                       ReducerConditional::select(m_functor, m_reducer)) /
+    const integral_nonzero_constant<
+        size_type, ReducerType::static_value_size() / sizeof(size_type)>
+        word_count(m_functor_reducer.get_reducer().value_size() /
                    sizeof(size_type));
 
-    reference_type value =
-        final_reducer.init(kokkos_impl_cuda_shared_memory<size_type>() +
-                           threadIdx.y * word_count.value);
+    reference_type value = m_functor_reducer.get_reducer().init(
+        kokkos_impl_cuda_shared_memory<size_type>() +
+        threadIdx.y * word_count.value);
 
     // Iterate this block through the league
     const int int_league_size = (int)m_league_size;
@@ -734,7 +719,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     bool do_final_reduction = true;
     if (!zero_length)
       do_final_reduction = cuda_single_inter_block_reduce_scan<false>(
-          final_reducer, blockIdx.x, gridDim.x,
+          m_functor_reducer.get_reducer(), blockIdx.x, gridDim.x,
           kokkos_impl_cuda_shared_memory<size_type>(), m_scratch_space,
           m_scratch_flags);
 
@@ -750,7 +735,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
               : (m_unified_space ? m_unified_space : m_scratch_space);
 
       if (threadIdx.y == 0) {
-        final_reducer.final(reinterpret_cast<value_type*>(shared));
+        m_functor_reducer.get_reducer().final(
+            reinterpret_cast<value_type*>(shared));
       }
 
       if (CudaTraits::WarpSize < word_count.value) {
@@ -764,11 +750,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   }
 
   __device__ inline void run(ShflReductionTag, const int& threadid) const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
     value_type value;
-    final_reducer.init(&value);
+    m_functor_reducer.get_reducer().init(&value);
 
     // Iterate this block through the league
     const int int_league_size = (int)m_league_size;
@@ -791,29 +774,26 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                                              : m_scratch_space);
 
     value_type init;
-    final_reducer.init(&init);
+    m_functor_reducer.get_reducer().init(&init);
 
     if (int_league_size == 0) {
-      final_reducer.final(&value);
+      m_functor_reducer.get_reducer().final(&value);
       *result = value;
-    } else if (Impl::cuda_inter_block_reduction(value, init, final_reducer,
-                                                m_scratch_space, result,
-                                                m_scratch_flags, blockDim.y)) {
+    } else if (Impl::cuda_inter_block_reduction(
+                   value, init, m_functor_reducer.get_reducer(),
+                   m_scratch_space, result, m_scratch_flags, blockDim.y)) {
       const unsigned id = threadIdx.y * blockDim.x + threadIdx.x;
       if (id == 0) {
-        final_reducer.final(&value);
+        m_functor_reducer.get_reducer().final(&value);
         *result = value;
       }
     }
   }
 
   inline void execute() {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
     const bool is_empty_range  = m_league_size == 0 || m_team_size == 0;
-    const bool need_device_set = Analysis::has_init_member_function ||
-                                 Analysis::has_final_member_function ||
+    const bool need_device_set = ReducerType::has_init_member_function() ||
+                                 ReducerType::has_final_member_function() ||
                                  !m_result_ptr_host_accessible ||
                                  Policy::is_graph_kernel::value ||
                                  !std::is_same<ReducerType, InvalidType>::value;
@@ -823,14 +803,12 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                                : std::min(int(m_league_size), m_team_size));
 
       m_scratch_space = cuda_internal_scratch_space(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)) *
-                                block_count);
+          m_policy.space(),
+          m_functor_reducer.get_reducer().value_size() * block_count);
       m_scratch_flags =
           cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type));
       m_unified_space = cuda_internal_scratch_unified(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)));
+          m_policy.space(), m_functor_reducer.get_reducer().value_size());
 
       dim3 block(m_vector_size, m_team_size, 1);
       dim3 grid(block_count, 1, 1);
@@ -857,14 +835,12 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
         if (m_result_ptr) {
           if (m_unified_space) {
-            const int count = Analysis::value_count(
-                ReducerConditional::select(m_functor, m_reducer));
+            const int count = m_functor_reducer.get_reducer().value_count();
             for (int i = 0; i < count; ++i) {
               m_result_ptr[i] = pointer_type(m_unified_space)[i];
             }
           } else {
-            const int size = Analysis::value_size(
-                ReducerConditional::select(m_functor, m_reducer));
+            const int size = m_functor_reducer.get_reducer().value_size();
             DeepCopy<HostSpace, CudaSpace>(m_result_ptr, m_scratch_space, size);
           }
         }
@@ -872,19 +848,16 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     } else {
       if (m_result_ptr) {
         // TODO @graph We need to effectively insert this in to the graph
-        final_reducer.init(m_result_ptr);
+        m_functor_reducer.get_reducer().init(m_result_ptr);
       }
     }
   }
 
   template <class ViewType>
-  ParallelReduce(
-      const FunctorType& arg_functor, const Policy& arg_policy,
-      const ViewType& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<Kokkos::CudaSpace,
@@ -911,7 +884,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         m_team_size >= 0
             ? m_team_size
             : Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
-                  internal_space_instance, attr, m_functor, m_vector_size,
+                  internal_space_instance, attr,
+                  m_functor_reducer.get_functor(), m_vector_size,
                   m_policy.team_scratch_size(0),
                   m_policy.thread_scratch_size(0)) /
                   m_vector_size;
@@ -919,16 +893,17 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     m_team_begin =
         UseShflReduction
             ? 0
-            : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                        WorkTag>(arg_functor,
-                                                                 m_team_size);
+            : cuda_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                        value_type>(
+                  arg_functor_reducer.get_functor(), m_team_size);
     m_shmem_begin = sizeof(double) * (m_team_size + 2);
-    m_shmem_size =
-        m_policy.scratch_size(0, m_team_size) +
-        FunctorTeamShmemSize<FunctorType>::value(arg_functor, m_team_size);
-    m_scratch_size[0] = m_shmem_size;
-    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
-    m_scratch_locks   = internal_space_instance->m_scratch_locks;
+    m_shmem_size  = m_policy.scratch_size(0, m_team_size) +
+                   FunctorTeamShmemSize<FunctorType>::value(
+                       arg_functor_reducer.get_functor(), m_team_size);
+    m_scratch_size[0]   = m_shmem_size;
+    m_scratch_size[1]   = m_policy.scratch_size(1, m_team_size);
+    m_scratch_locks     = internal_space_instance->m_scratch_locks;
+    m_num_scratch_locks = internal_space_instance->m_num_scratch_locks;
     if (m_team_size <= 0) {
       m_scratch_ptr[1] = nullptr;
     } else {
@@ -974,112 +949,9 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     }
 
     if (int(m_team_size) >
-        arg_policy.team_size_max(m_functor, m_reducer, ParallelReduceTag())) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too "
-                      "large team size."));
-    }
-  }
-
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::CudaSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_result_ptr_host_accessible(
-            MemorySpaceAccess<Kokkos::HostSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_scratch_space(nullptr),
-        m_scratch_flags(nullptr),
-        m_unified_space(nullptr),
-        m_team_begin(0),
-        m_shmem_begin(0),
-        m_shmem_size(0),
-        m_scratch_ptr{nullptr, nullptr},
-        m_league_size(arg_policy.league_size()),
-        m_team_size(arg_policy.team_size()),
-        m_vector_size(arg_policy.impl_vector_length()) {
-    auto internal_space_instance =
-        m_policy.space().impl_internal_space_instance();
-    cudaFuncAttributes attr =
-        CudaParallelLaunch<ParallelReduce,
-                           LaunchBounds>::get_cuda_func_attributes();
-
-    // Valid team size not provided, deduce team size
-    m_team_size =
-        m_team_size >= 0
-            ? m_team_size
-            : Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
-                  internal_space_instance, attr, m_functor, m_vector_size,
-                  m_policy.team_scratch_size(0),
-                  m_policy.thread_scratch_size(0)) /
-                  m_vector_size;
-
-    m_team_begin =
-        UseShflReduction
-            ? 0
-            : cuda_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                        WorkTag>(arg_functor,
-                                                                 m_team_size);
-    m_shmem_begin = sizeof(double) * (m_team_size + 2);
-    m_shmem_size =
-        m_policy.scratch_size(0, m_team_size) +
-        FunctorTeamShmemSize<FunctorType>::value(arg_functor, m_team_size);
-    m_scratch_size[0] = m_shmem_size;
-    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
-    m_scratch_locks   = internal_space_instance->m_scratch_locks;
-    if (m_team_size <= 0) {
-      m_scratch_ptr[1] = nullptr;
-    } else {
-      m_scratch_pool_id = internal_space_instance->acquire_team_scratch_space();
-      m_scratch_ptr[1]  = internal_space_instance->resize_team_scratch_space(
-          m_scratch_pool_id,
-          static_cast<std::int64_t>(m_scratch_size[1]) *
-              (std::min(
-                  static_cast<std::int64_t>(Cuda().concurrency() /
-                                            (m_team_size * m_vector_size)),
-                  static_cast<std::int64_t>(m_league_size))));
-    }
-
-    // The global parallel_reduce does not support vector_length other than 1 at
-    // the moment
-    if ((arg_policy.impl_vector_length() > 1) && !UseShflReduction)
-      Impl::throw_runtime_exception(
-          "Kokkos::parallel_reduce with a TeamPolicy using a vector length of "
-          "greater than 1 is not currently supported for CUDA for dynamic "
-          "sized reduction types.");
-
-    if ((m_team_size < 32) && !UseShflReduction)
-      Impl::throw_runtime_exception(
-          "Kokkos::parallel_reduce with a TeamPolicy using a team_size smaller "
-          "than 32 is not currently supported with CUDA for dynamic sized "
-          "reduction types.");
-
-    // Functor's reduce memory, team scan memory, and team shared memory depend
-    // upon team size.
-
-    const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
-
-    if ((!Kokkos::Impl::is_integral_power_of_two(m_team_size) &&
-         !UseShflReduction) ||
-        internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelReduce< Cuda > bad team size"));
-    }
-
-    size_type team_size_max =
-        Kokkos::Impl::cuda_get_max_block_size<FunctorType, LaunchBounds>(
-            internal_space_instance, attr, m_functor, m_vector_size,
-            m_policy.team_scratch_size(0), m_policy.thread_scratch_size(0)) /
-        m_vector_size;
-
-    if ((int)m_team_size > (int)team_size_max) {
+        arg_policy.team_size_max(m_functor_reducer.get_functor(),
+                                 m_functor_reducer.get_reducer(),
+                                 ParallelReduceTag())) {
       Kokkos::Impl::throw_runtime_exception(
           std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too "
                       "large team size."));
diff --git a/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp b/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
index 59fdd13513..2cdc291358 100644
--- a/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
@@ -672,34 +672,35 @@ __device__ bool cuda_single_inter_block_reduce_scan(
 }
 
 // Size in bytes required for inter block reduce or scan
-template <bool DoScan, class FunctorType, class ArgTag>
+template <bool DoScan, class ArgTag, class ValueType, class FunctorType>
 inline std::enable_if_t<DoScan, unsigned>
 cuda_single_inter_block_reduce_scan_shmem(const FunctorType& functor,
                                           const unsigned BlockSize) {
   using Analysis =
       Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                            RangePolicy<Cuda, ArgTag>, FunctorType>;
+                            RangePolicy<Cuda, ArgTag>, FunctorType, ValueType>;
 
   return (BlockSize + 2) * Analysis::value_size(functor);
 }
 
-template <bool DoScan, class FunctorType, class ArgTag>
+template <bool DoScan, class ArgTag, class ValueType, class FunctorType>
 inline std::enable_if_t<!DoScan, unsigned>
 cuda_single_inter_block_reduce_scan_shmem(const FunctorType& functor,
                                           const unsigned BlockSize) {
   using Analysis =
       Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                            RangePolicy<Cuda, ArgTag>, FunctorType>;
+                            RangePolicy<Cuda, ArgTag>, FunctorType, ValueType>;
 
   return (BlockSize + 2) * Analysis::value_size(functor);
 }
 
-template <typename WorkTag, typename Policy, typename FunctorType>
+template <typename WorkTag, typename ValueType, typename Policy,
+          typename FunctorType>
 inline void check_reduced_view_shmem_size(const Policy& policy,
                                           const FunctorType& functor) {
   size_t minBlockSize = CudaTraits::WarpSize * 1;
   unsigned reqShmemSize =
-      cuda_single_inter_block_reduce_scan_shmem<false, FunctorType, WorkTag>(
+      cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, ValueType>(
           functor, minBlockSize);
   size_t maxShmemPerBlock =
       policy.space().impl_internal_space_instance()->m_maxShmemPerBlock;
diff --git a/core/src/Cuda/Kokkos_Cuda_Task.hpp b/core/src/Cuda/Kokkos_Cuda_Task.hpp
index 76e4122af2..d579214cd4 100644
--- a/core/src/Cuda/Kokkos_Cuda_Task.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Task.hpp
@@ -1042,7 +1042,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   // Extract value_type from closure
 
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
 
   if (1 < loop_boundaries.thread.team_size()) {
     // make sure all threads perform all loop iterations
@@ -1107,7 +1108,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   // Extract value_type from closure
 
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
 
   if (1 < loop_boundaries.thread.team_size()) {
     // make sure all threads perform all loop iterations
diff --git a/core/src/Cuda/Kokkos_Cuda_Team.hpp b/core/src/Cuda/Kokkos_Cuda_Team.hpp
index fc3f46bce6..b4315a72e9 100644
--- a/core/src/Cuda/Kokkos_Cuda_Team.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Team.hpp
@@ -196,9 +196,10 @@ class CudaTeamMember {
     (void)reducer;
     (void)value;
     KOKKOS_IF_ON_DEVICE(
-        (typename Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                        TeamPolicy<Cuda>, ReducerType>::Reducer
-             wrapped_reducer(&reducer);
+        (typename Impl::FunctorAnalysis<
+             Impl::FunctorPatternInterface::REDUCE, TeamPolicy<Cuda>,
+             ReducerType, typename ReducerType::value_type>::Reducer
+             wrapped_reducer(reducer);
          cuda_intra_block_reduction(value, wrapped_reducer, blockDim.y);
          reducer.reference() = value;))
   }
@@ -228,7 +229,8 @@ class CudaTeamMember {
         Impl::CudaJoinFunctor<Type> cuda_join_functor;
         typename Impl::FunctorAnalysis<
             Impl::FunctorPatternInterface::SCAN, TeamPolicy<Cuda>,
-            Impl::CudaJoinFunctor<Type>>::Reducer reducer(&cuda_join_functor);
+            Impl::CudaJoinFunctor<Type>, Type>::Reducer
+            reducer(cuda_join_functor);
         Impl::cuda_intra_block_reduce_scan<true>(reducer, base_data + 1);
 
         if (global_accum) {
@@ -376,18 +378,10 @@ struct ThreadVectorRangeBoundariesStruct<iType, CudaTeamMember> {
   ThreadVectorRangeBoundariesStruct(const CudaTeamMember, index_type count)
       : start(static_cast<index_type>(0)), end(count) {}
 
-  KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct(index_type count)
-      : start(static_cast<index_type>(0)), end(count) {}
-
   KOKKOS_INLINE_FUNCTION
   ThreadVectorRangeBoundariesStruct(const CudaTeamMember, index_type arg_begin,
                                     index_type arg_end)
       : start(arg_begin), end(arg_end) {}
-
-  KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct(index_type arg_begin, index_type arg_end)
-      : start(arg_begin), end(arg_end) {}
 };
 
 }  // namespace Impl
@@ -492,9 +486,6 @@ KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
 parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
                     iType, Impl::CudaTeamMember>& loop_boundaries,
                 const Closure& closure, const ReducerType& reducer) {
-  (void)loop_boundaries;
-  (void)closure;
-  (void)reducer;
   KOKKOS_IF_ON_DEVICE(
       (typename ReducerType::value_type value;
 
@@ -504,6 +495,11 @@ parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
             i < loop_boundaries.end; i += blockDim.y) { closure(i, value); }
 
        loop_boundaries.member.team_reduce(reducer, value);))
+  // Avoid bogus warning about reducer value being uninitialized with combined
+  // reducers
+  KOKKOS_IF_ON_HOST(((void)loop_boundaries; (void)closure;
+                     reducer.init(reducer.reference());
+                     Kokkos::abort("Should only run on the device!");));
 }
 
 /** \brief  Inter-thread parallel_reduce assuming summation.
@@ -552,9 +548,6 @@ KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
 parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
                     iType, Impl::CudaTeamMember>& loop_boundaries,
                 const Closure& closure, const ReducerType& reducer) {
-  (void)loop_boundaries;
-  (void)closure;
-  (void)reducer;
   KOKKOS_IF_ON_DEVICE((typename ReducerType::value_type value;
                        reducer.init(value);
 
@@ -565,6 +558,11 @@ parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
 
                        loop_boundaries.member.vector_reduce(reducer, value);
                        loop_boundaries.member.team_reduce(reducer, value);))
+  // Avoid bogus warning about reducer value being uninitialized with combined
+  // reducers
+  KOKKOS_IF_ON_HOST(((void)loop_boundaries; (void)closure;
+                     reducer.init(reducer.reference());
+                     Kokkos::abort("Should only run on the device!");));
 }
 
 template <typename iType, class Closure, typename ValueType>
@@ -632,9 +630,6 @@ KOKKOS_INLINE_FUNCTION std::enable_if_t<is_reducer<ReducerType>::value>
 parallel_reduce(Impl::ThreadVectorRangeBoundariesStruct<
                     iType, Impl::CudaTeamMember> const& loop_boundaries,
                 Closure const& closure, ReducerType const& reducer) {
-  (void)loop_boundaries;
-  (void)closure;
-  (void)reducer;
   KOKKOS_IF_ON_DEVICE((
 
       reducer.init(reducer.reference());
@@ -646,6 +641,11 @@ parallel_reduce(Impl::ThreadVectorRangeBoundariesStruct<
       Impl::CudaTeamMember::vector_reduce(reducer);
 
       ))
+  // Avoid bogus warning about reducer value being uninitialized with combined
+  // reducers
+  KOKKOS_IF_ON_HOST(((void)loop_boundaries; (void)closure;
+                     reducer.init(reducer.reference());
+                     Kokkos::abort("Should only run on the device!");));
 }
 
 /** \brief  Intra-thread vector parallel_reduce.
@@ -696,8 +696,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     const FunctorType& lambda) {
   // Extract value_type from lambda
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void,
-      FunctorType>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
 
   const auto start     = loop_bounds.start;
   const auto end       = loop_bounds.end;
@@ -833,7 +833,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
         loop_boundaries,
     const Closure& closure) {
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
   value_type dummy;
   parallel_scan(loop_boundaries, closure, Kokkos::Sum<value_type>(dummy));
 }
diff --git a/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp b/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
index 1ade4c34b6..abb747e39a 100644
--- a/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
@@ -20,7 +20,7 @@
 #include <Kokkos_Macros.hpp>
 #ifdef KOKKOS_ENABLE_CUDA
 
-#include <Kokkos_CudaSpace.hpp>
+#include <Cuda/Kokkos_CudaSpace.hpp>
 #include <Kokkos_UniqueToken.hpp>
 #include <impl/Kokkos_SharedAlloc.hpp>
 
@@ -104,13 +104,9 @@ class UniqueToken<Cuda, UniqueTokenScope::Global> {
       idx = idx % size();
     }
 #endif
-// Make sure that all writes in the previous lock owner are visible to me
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
+    // Make sure that all writes in the previous lock owner are visible to me
     desul::atomic_thread_fence(desul::MemoryOrderAcquire(),
                                desul::MemoryScopeDevice());
-#else
-    Kokkos::memory_fence();
-#endif
     return idx;
   }
 
@@ -125,13 +121,9 @@ class UniqueToken<Cuda, UniqueTokenScope::Global> {
   /// \brief release an acquired value
   KOKKOS_INLINE_FUNCTION
   void release(size_type idx) const noexcept {
-// Make sure my writes are visible to the next lock owner
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
+    // Make sure my writes are visible to the next lock owner
     desul::atomic_thread_fence(desul::MemoryOrderRelease(),
                                desul::MemoryScopeDevice());
-#else
-    Kokkos::memory_fence();
-#endif
     (void)Kokkos::atomic_exchange(&m_locks(idx), 0);
   }
 };
diff --git a/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp b/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
index d5d11f499a..a945a716bc 100644
--- a/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
@@ -17,7 +17,7 @@
 #ifndef KOKKOS_CUDA_WORKGRAPHPOLICY_HPP
 #define KOKKOS_CUDA_WORKGRAPHPOLICY_HPP
 
-#include <Kokkos_Cuda.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
 #include <Cuda/Kokkos_Cuda_KernelLaunch.hpp>
 
 namespace Kokkos {
diff --git a/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp b/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp
new file mode 100644
index 0000000000..001cf0cce0
--- /dev/null
+++ b/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp
@@ -0,0 +1,46 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+#ifndef KOKKOS_CUDA_ZEROMEMSET_HPP
+#define KOKKOS_CUDA_ZEROMEMSET_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class T, class... P>
+struct ZeroMemset<Kokkos::Cuda, View<T, P...>> {
+  ZeroMemset(const Kokkos::Cuda& exec_space_instance, const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaMemsetAsync(
+        dst.data(), 0, dst.size() * sizeof(typename View<T, P...>::value_type),
+        exec_space_instance.cuda_stream()));
+  }
+
+  ZeroMemset(const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        cudaMemset(dst.data(), 0,
+                   dst.size() * sizeof(typename View<T, P...>::value_type)));
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // !defined(KOKKOS_CUDA_ZEROMEMSET_HPP)
diff --git a/core/src/HIP/Kokkos_HIP.cpp b/core/src/HIP/Kokkos_HIP.cpp
index 766f815c72..94cd97b2b9 100644
--- a/core/src/HIP/Kokkos_HIP.cpp
+++ b/core/src/HIP/Kokkos_HIP.cpp
@@ -20,7 +20,6 @@
 
 #include <HIP/Kokkos_HIP.hpp>
 #include <HIP/Kokkos_HIP_Instance.hpp>
-#include <HIP/Kokkos_HIP_Locks.hpp>
 
 #include <impl/Kokkos_DeviceManagement.hpp>
 #include <impl/Kokkos_ExecSpaceManager.hpp>
@@ -79,7 +78,7 @@ void HIP::impl_initialize(InitializationSettings const& settings) {
       Impl::HIPInternal::m_maxWavesPerCU * Impl::HIPTraits::WarpSize;
 
   // Init the array for used for arbitrarily sized atomics
-  Impl::initialize_host_hip_lock_arrays();
+  desul::Impl::init_lock_arrays();  // FIXME
 
   // Allocate a staging buffer for constant mem in pinned host memory
   // and an event to avoid overwriting driver for previous kernel launches
diff --git a/core/src/HIP/Kokkos_HIP.hpp b/core/src/HIP/Kokkos_HIP.hpp
index d48be32280..d7cc25ffe1 100644
--- a/core/src/HIP/Kokkos_HIP.hpp
+++ b/core/src/HIP/Kokkos_HIP.hpp
@@ -137,26 +137,6 @@ struct DeviceTypeTraits<HIP> {
 };
 }  // namespace Experimental
 }  // namespace Tools
-
-namespace Impl {
-template <class DT, class... DP>
-struct ZeroMemset<HIP, DT, DP...> {
-  ZeroMemset(const HIP& exec_space, const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    KOKKOS_IMPL_HIP_SAFE_CALL(hipMemsetAsync(
-        dst.data(), 0,
-        dst.size() * sizeof(typename View<DT, DP...>::value_type),
-        exec_space.hip_stream()));
-  }
-
-  ZeroMemset(const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    KOKKOS_IMPL_HIP_SAFE_CALL(
-        hipMemset(dst.data(), 0,
-                  dst.size() * sizeof(typename View<DT, DP...>::value_type)));
-  }
-};
-}  // namespace Impl
 }  // namespace Kokkos
 
 #endif
diff --git a/core/src/HIP/Kokkos_HIP_Atomic.hpp b/core/src/HIP/Kokkos_HIP_Atomic.hpp
deleted file mode 100644
index 49f89ed332..0000000000
--- a/core/src/HIP/Kokkos_HIP_Atomic.hpp
+++ /dev/null
@@ -1,590 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_HIP_ATOMIC_HPP
-#define KOKKOS_HIP_ATOMIC_HPP
-
-#include <impl/Kokkos_Atomic_Memory_Order.hpp>
-#include <impl/Kokkos_Memory_Fence.hpp>
-#include <HIP/Kokkos_HIP_Locks.hpp>
-
-#if defined(KOKKOS_ENABLE_HIP_ATOMICS)
-namespace Kokkos {
-// HIP can do:
-// Types int/unsigned int
-// variants:
-// atomic_exchange/compare_exchange/fetch_add/fetch_sub/fetch_max/fetch_min/fetch_and/fetch_or/fetch_xor/fetch_inc/fetch_dec
-
-// atomic_exchange -------------------------------------------------------------
-
-__inline__ __device__ int atomic_exchange(volatile int *const dest,
-                                          const int val) {
-  return atomicExch(const_cast<int *>(dest), val);
-}
-
-__inline__ __device__ unsigned int atomic_exchange(
-    volatile unsigned int *const dest, const unsigned int val) {
-  return atomicExch(const_cast<unsigned int *>(dest), val);
-}
-
-__inline__ __device__ unsigned long long int atomic_exchange(
-    volatile unsigned long long int *const dest,
-    const unsigned long long int val) {
-  return atomicExch(const_cast<unsigned long long *>(dest), val);
-}
-
-__inline__ __device__ float atomic_exchange(volatile float *const dest,
-                                            const float val) {
-  return atomicExch(const_cast<float *>(dest), val);
-}
-
-template <typename T>
-__inline__ __device__ T
-atomic_exchange(volatile T *const dest,
-                std::enable_if_t<sizeof(T) == sizeof(int), const T &> val) {
-  int tmp = atomicExch(reinterpret_cast<int *>(const_cast<T *>(dest)),
-                       *reinterpret_cast<int *>(const_cast<T *>(&val)));
-  return reinterpret_cast<T &>(tmp);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_exchange(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T &>
-        val) {
-  using type = unsigned long long int;
-
-  type tmp = atomicExch(reinterpret_cast<type *>(const_cast<T *>(dest)),
-                        *reinterpret_cast<type *>(const_cast<T *>(&val)));
-  return reinterpret_cast<T &>(tmp);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_exchange(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long long),
-                     const T> &val) {
-  T return_val;
-  int done                 = 0;
-  unsigned int active      = __ballot(1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_hip_space((void *)dest)) {
-        return_val = *dest;
-        *dest      = val;
-        Impl::unlock_address_hip_space((void *)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot(done);
-  }
-  return return_val;
-}
-
-// atomic_assign ---------------------------------------------------------------
-
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T &> val) {
-  atomicExch(reinterpret_cast<int *>(const_cast<T *>(dest)),
-             *reinterpret_cast<int *>(const_cast<T *>(&val)));
-}
-
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T &>
-        val) {
-  using type = unsigned long long int;
-  atomicExch(reinterpret_cast<type *>(const_cast<T *>(dest)),
-             *reinterpret_cast<type *>(const_cast<T *>(&val)));
-}
-
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) != sizeof(unsigned long long int),
-                     const T &>
-        val) {
-  atomic_exchange(dest, val);
-}
-
-// atomic_compare_exchange -----------------------------------------------------
-
-inline __device__ int atomic_compare_exchange(volatile int *dest, int compare,
-                                              const int &val) {
-  return atomicCAS(const_cast<int *>(dest), compare, val);
-}
-
-inline __device__ unsigned int atomic_compare_exchange(
-    volatile unsigned int *dest, unsigned int compare,
-    const unsigned int &val) {
-  return atomicCAS(const_cast<unsigned int *>(dest), compare, val);
-}
-
-inline __device__ unsigned long long int atomic_compare_exchange(
-    volatile unsigned long long int *dest, unsigned long long int compare,
-    const unsigned long long int &val) {
-  return atomicCAS(const_cast<unsigned long long int *>(dest), compare, val);
-}
-
-template <class T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T *dest, T compare,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T &> val) {
-  // FIXME_HIP UB
-  union U {
-    int i;
-    T f;
-    __inline__ __device__ U() {}
-  } idest, icompare, ival;
-  icompare.f = compare;
-  ival.f     = val;
-  idest.i    = atomicCAS(reinterpret_cast<int *>(const_cast<T *>(dest)),
-                      icompare.i, ival.i);
-  return idest.f;
-}
-
-template <class T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T *dest, T compare,
-    std::enable_if_t<sizeof(T) == sizeof(unsigned long long int), const T &>
-        val) {
-  // FIXME_HIP UB
-  union U {
-    unsigned long long int i;
-    T f;
-    __inline__ __device__ U() {}
-  } idest, icompare, ival;
-  icompare.f = compare;
-  ival.f     = val;
-  idest.i    = atomicCAS(
-      reinterpret_cast<unsigned long long int *>(const_cast<T *>(dest)),
-      icompare.i, ival.i);
-  return idest.f;
-}
-
-template <typename T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T *const dest, const T &compare,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long long),
-                     const T> &val) {
-  T return_val;
-  int done                 = 0;
-  unsigned int active      = __ballot(1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_hip_space((void *)dest)) {
-        return_val = *dest;
-        if (return_val == compare) *dest = val;
-        Impl::unlock_address_hip_space((void *)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot(done);
-  }
-  return return_val;
-}
-
-// atomic_fetch_add ------------------------------------------------------------
-
-inline __device__ int atomic_fetch_add(volatile int *dest, const int &val) {
-  return atomicAdd(const_cast<int *>(dest), val);
-}
-
-inline __device__ unsigned int atomic_fetch_add(volatile unsigned int *dest,
-                                                const unsigned int &val) {
-  return atomicAdd(const_cast<unsigned int *>(dest), val);
-}
-
-inline __device__ unsigned long long atomic_fetch_add(
-    volatile unsigned long long *dest, const unsigned long long &val) {
-  return atomicAdd(const_cast<unsigned long long *>(dest), val);
-}
-
-inline __device__ float atomic_fetch_add(volatile float *dest,
-                                         const float &val) {
-  return atomicAdd(const_cast<float *>(dest), val);
-}
-
-template <typename T>
-inline __device__ T
-atomic_fetch_add(volatile T *const dest,
-                 std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  // FIXME_HIP UB
-  union U {
-    int i;
-    T t;
-    __inline__ __device__ U() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = atomicCAS(reinterpret_cast<int *>(const_cast<T *>(dest)),
-                         assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <typename T>
-inline __device__ T atomic_fetch_add(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) == sizeof(long long), const T> val) {
-  // FIXME_HIP UB
-  union U {
-    unsigned long long i;
-    T t;
-    __inline__ __device__ U() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = atomic_compare_exchange(
-        reinterpret_cast<volatile unsigned long long *>(dest), assume.i,
-        newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-__inline__ __device__ char atomic_fetch_add(volatile char *dest,
-                                            const char &val) {
-  unsigned int oldval, newval, assume;
-  oldval = *reinterpret_cast<volatile unsigned int *>(&dest);
-
-  do {
-    assume = oldval;
-    newval = assume & 0x7fffff00 + ((assume & 0xff) + val) & 0xff;
-    oldval =
-        atomicCAS(reinterpret_cast<unsigned int *>(const_cast<char *>(dest)),
-                  assume, newval);
-  } while (assume != oldval);
-
-  return oldval;
-}
-
-__inline__ __device__ short atomic_fetch_add(volatile short *dest,
-                                             const short &val) {
-  unsigned int oldval, newval, assume;
-  oldval = *reinterpret_cast<volatile unsigned int *>(&dest);
-
-  do {
-    assume = oldval;
-    newval = assume & 0x7fff0000 + ((assume & 0xffff) + val) & 0xffff;
-    oldval =
-        atomicCAS(reinterpret_cast<unsigned int *>(const_cast<short *>(dest)),
-                  assume, newval);
-  } while (assume != oldval);
-
-  return oldval;
-}
-
-__inline__ __device__ long long atomic_fetch_add(volatile long long *dest,
-                                                 const long long &val) {
-  return atomicAdd(
-      reinterpret_cast<unsigned long long *>(const_cast<long long *>(dest)),
-      val);
-}
-
-template <class T>
-__inline__ __device__ T atomic_fetch_add(
-    volatile T *dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long long),
-                     const T &>
-        val) {
-  T return_val;
-  int done                 = 0;
-  unsigned int active      = __ballot(1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Kokkos::Impl::lock_address_hip_space((void *)dest)) {
-        return_val = *dest;
-        *dest      = return_val + val;
-        Kokkos::Impl::unlock_address_hip_space((void *)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot(done);
-  }
-  return return_val;
-}
-
-// atmic_fetch_sub -------------------------------------------------------------
-
-__inline__ __device__ int atomic_fetch_sub(volatile int *dest, int const &val) {
-  return atomicSub(const_cast<int *>(dest), val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_sub(volatile unsigned int *dest,
-                                                    unsigned int const &val) {
-  return atomicSub(const_cast<unsigned int *>(dest), val);
-}
-
-__inline__ __device__ unsigned long long atomic_fetch_sub(
-    unsigned long long *dest, int64_t const &val) {
-  return atomicAdd(reinterpret_cast<unsigned long long *>(dest),
-                   -reinterpret_cast<unsigned long long const &>(val));
-}
-
-__inline__ __device__ char atomic_fetch_sub(volatile char *dest,
-                                            const char &val) {
-  unsigned int oldval, newval, assume;
-  oldval = *reinterpret_cast<volatile unsigned int *>(dest);
-
-  do {
-    assume = oldval;
-    newval = assume & 0x7fffff00 + ((assume & 0xff) - val) & 0xff;
-    oldval =
-        atomicCAS(reinterpret_cast<unsigned int *>(const_cast<char *>(dest)),
-                  assume, newval);
-  } while (assume != oldval);
-
-  return oldval;
-}
-
-__inline__ __device__ short atomic_fetch_sub(volatile short *dest,
-                                             const short &val) {
-  unsigned int oldval, newval, assume;
-  oldval = *reinterpret_cast<volatile unsigned int *>(dest);
-
-  do {
-    assume = oldval;
-    newval = assume & 0x7fff0000 + ((assume & 0xffff) - val) & 0xffff;
-    oldval =
-        atomicCAS(reinterpret_cast<unsigned int *>(const_cast<short *>(dest)),
-                  assume, newval);
-  } while (assume != oldval);
-
-  return oldval;
-}
-
-__inline__ __device__ long long atomic_fetch_sub(volatile long long *dest,
-                                                 const long long &val) {
-  return static_cast<long long>(atomicAdd(
-      reinterpret_cast<unsigned long long int *>(const_cast<long long *>(dest)),
-      -reinterpret_cast<unsigned long long int const &>(val)));
-}
-
-template <class T>
-__inline__ __device__ T atomic_fetch_sub(
-    volatile T *dest, std::enable_if_t<sizeof(T) == sizeof(int), T> val) {
-  // FIXME_HIP UB
-  union U {
-    int i;
-    T t;
-    __inline__ __device__ U() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t - val;
-    oldval.i = atomic_compare_exchange(reinterpret_cast<volatile int *>(dest),
-                                       assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <typename T>
-inline __device__ T atomic_fetch_sub(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) == sizeof(long long), const T> val) {
-  // FIXME_HIP UB
-  union U {
-    unsigned long long i;
-    T t;
-    __inline__ __device__ U() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t - val;
-    oldval.i = atomic_compare_exchange(
-        reinterpret_cast<volatile unsigned long long *>(dest), assume.i,
-        newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <class T>
-__inline__ __device__ T atomic_fetch_sub(
-    volatile T *dest, std::enable_if_t<sizeof(T) == sizeof(char), T> val) {
-  unsigned int oldval, newval, assume;
-  oldval = *reinterpret_cast<volatile unsigned int *>(dest);
-
-  do {
-    assume = oldval;
-    newval = assume & 0x7fffff00 + ((assume & 0xff) - val) & 0xff;
-    oldval = atomicCAS(reinterpret_cast<unsigned int *>(dest), assume, newval);
-  } while (assume != oldval);
-
-  return reinterpret_cast<T>(oldval) & 0xff;
-}
-
-template <class T>
-__inline__ __device__ T atomic_fetch_sub(
-    volatile T *dest, std::enable_if_t<sizeof(T) == sizeof(short), T> val) {
-  unsigned int oldval, newval, assume;
-  oldval = *reinterpret_cast<int *>(dest);
-
-  do {
-    assume = oldval;
-    newval = assume & 0x7fff0000 + ((assume & 0xffff) - val) & 0xffff;
-    oldval = atomicCAS(reinterpret_cast<unsigned int *>(dest), assume, newval);
-  } while (assume != oldval);
-
-  return reinterpret_cast<T>(oldval) & 0xffff;
-}
-
-template <typename T>
-__inline__ __device__ T atomic_fetch_sub(
-    volatile T *const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long long),
-                     const T> &val) {
-  T return_val;
-  int done                 = 0;
-  unsigned int active      = __ballot(1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_hip_space((void *)dest)) {
-        return_val = *dest;
-        *dest      = return_val - val;
-        Impl::unlock_address_hip_space((void *)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot(done);
-  }
-  return return_val;
-}
-
-// atomic_fetch_or -------------------------------------------------------------
-
-__inline__ __device__ int atomic_fetch_or(volatile int *const dest,
-                                          int const val) {
-  return atomicOr(const_cast<int *>(dest), val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_or(
-    volatile unsigned int *const dest, unsigned int const val) {
-  return atomicOr(const_cast<unsigned int *>(dest), val);
-}
-
-__inline__ __device__ unsigned long long int atomic_fetch_or(
-    volatile unsigned long long int *const dest,
-    unsigned long long int const val) {
-  return atomicOr(const_cast<unsigned long long int *>(dest), val);
-}
-
-// atomic_fetch_and ------------------------------------------------------------
-
-__inline__ __device__ int atomic_fetch_and(volatile int *const dest,
-                                           int const val) {
-  return atomicAnd(const_cast<int *>(dest), val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_and(
-    volatile unsigned int *const dest, unsigned int const val) {
-  return atomicAnd(const_cast<unsigned int *>(dest), val);
-}
-
-__inline__ __device__ unsigned long long int atomic_fetch_and(
-    volatile unsigned long long int *const dest,
-    unsigned long long int const val) {
-  return atomicAnd(const_cast<unsigned long long int *>(dest), val);
-}
-
-namespace Impl {
-
-template <typename T>
-__inline__ __device__ void _atomic_store(T *ptr, T val,
-                                         memory_order_relaxed_t) {
-  (void)atomic_exchange(ptr, val);
-}
-
-template <typename T>
-__inline__ __device__ void _atomic_store(T *ptr, T val,
-                                         memory_order_seq_cst_t) {
-  memory_fence();
-  atomic_store(ptr, val, memory_order_relaxed);
-  memory_fence();
-}
-
-template <typename T>
-__inline__ __device__ void _atomic_store(T *ptr, T val,
-                                         memory_order_release_t) {
-  memory_fence();
-  atomic_store(ptr, val, memory_order_relaxed);
-}
-
-template <typename T>
-__inline__ __device__ void _atomic_store(T *ptr, T val) {
-  atomic_store(ptr, val, memory_order_relaxed);
-}
-
-template <typename T>
-__inline__ __device__ T _atomic_load(T *ptr, memory_order_relaxed_t) {
-  T dummy{};
-  return atomic_compare_exchange(ptr, dummy, dummy);
-}
-
-template <typename T>
-__inline__ __device__ T _atomic_load(T *ptr, memory_order_seq_cst_t) {
-  memory_fence();
-  T rv = atomic_load(ptr, memory_order_relaxed);
-  memory_fence();
-  return rv;
-}
-
-template <typename T>
-__inline__ __device__ T _atomic_load(T *ptr, memory_order_acquire_t) {
-  T rv = atomic_load(ptr, memory_order_relaxed);
-  memory_fence();
-  return rv;
-}
-
-template <typename T>
-__inline__ __device__ T _atomic_load(T *ptr) {
-  return atomic_load(ptr, memory_order_relaxed);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-#endif
-
-#endif
diff --git a/core/src/HIP/Kokkos_HIP_Error.hpp b/core/src/HIP/Kokkos_HIP_Error.hpp
index e09382c705..43d63c090b 100644
--- a/core/src/HIP/Kokkos_HIP_Error.hpp
+++ b/core/src/HIP/Kokkos_HIP_Error.hpp
@@ -70,7 +70,7 @@ class HIPRawMemoryAllocationFailure : public RawMemoryAllocationFailure {
 
   void append_additional_error_information(std::ostream& o) const override {
     if (m_error_code != hipSuccess) {
-      o << "  The HIP allocation returned the error code \"\""
+      o << "  The HIP allocation returned the error code \""
         << hipGetErrorName(m_error_code) << "\".";
     }
   }
diff --git a/core/src/HIP/Kokkos_HIP_Instance.cpp b/core/src/HIP/Kokkos_HIP_Instance.cpp
index 28c9c1cb6a..7840ad905b 100644
--- a/core/src/HIP/Kokkos_HIP_Instance.cpp
+++ b/core/src/HIP/Kokkos_HIP_Instance.cpp
@@ -180,10 +180,11 @@ void HIPInternal::initialize(hipStream_t stream, bool manage_stream) {
     Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
+  m_num_scratch_locks = concurrency();
   KOKKOS_IMPL_HIP_SAFE_CALL(
-      hipMalloc(&m_scratch_locks, sizeof(int32_t) * concurrency()));
+      hipMalloc(&m_scratch_locks, sizeof(int32_t) * m_num_scratch_locks));
   KOKKOS_IMPL_HIP_SAFE_CALL(
-      hipMemset(m_scratch_locks, 0, sizeof(int32_t) * concurrency()));
+      hipMemset(m_scratch_locks, 0, sizeof(int32_t) * m_num_scratch_locks));
 }
 
 //----------------------------------------------------------------------------
@@ -326,7 +327,7 @@ void HIPInternal::finalize() {
 
   if (this == &singleton()) {
     (void)Kokkos::Impl::hip_global_unique_token_locks(true);
-    Impl::finalize_host_hip_lock_arrays();
+    desul::Impl::finalize_lock_arrays();  // FIXME
 
     KOKKOS_IMPL_HIP_SAFE_CALL(hipHostFree(constantMemHostStaging));
     KOKKOS_IMPL_HIP_SAFE_CALL(hipEventDestroy(constantMemReusable));
@@ -363,7 +364,8 @@ void HIPInternal::finalize() {
   }
 
   KOKKOS_IMPL_HIP_SAFE_CALL(hipFree(m_scratch_locks));
-  m_scratch_locks = nullptr;
+  m_scratch_locks     = nullptr;
+  m_num_scratch_locks = 0;
 }
 
 //----------------------------------------------------------------------------
@@ -397,14 +399,6 @@ Kokkos::HIP::size_type *hip_internal_scratch_flags(const HIP &instance,
 
 namespace Kokkos {
 namespace Impl {
-void hip_device_synchronize(const std::string &name) {
-  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::HIP>(
-      name,
-      Kokkos::Tools::Experimental::SpecialSynchronizationCases::
-          GlobalDeviceSynchronization,
-      [&]() { KOKKOS_IMPL_HIP_SAFE_CALL(hipDeviceSynchronize()); });
-}
-
 void hip_internal_error_throw(hipError_t e, const char *name, const char *file,
                               const int line) {
   std::ostringstream out;
diff --git a/core/src/HIP/Kokkos_HIP_Instance.hpp b/core/src/HIP/Kokkos_HIP_Instance.hpp
index 06fab84b56..9595a3e0b0 100644
--- a/core/src/HIP/Kokkos_HIP_Instance.hpp
+++ b/core/src/HIP/Kokkos_HIP_Instance.hpp
@@ -22,6 +22,7 @@
 #include <HIP/Kokkos_HIP_Space.hpp>
 #include <HIP/Kokkos_HIP_Error.hpp>
 
+#include <atomic>
 #include <mutex>
 
 namespace Kokkos {
@@ -104,7 +105,8 @@ class HIPInternal {
   mutable int64_t m_team_scratch_current_size[10] = {};
   mutable void *m_team_scratch_ptr[10]            = {};
   mutable std::atomic_int m_team_scratch_pool[10] = {};
-  std::int32_t *m_scratch_locks;
+  int32_t *m_scratch_locks                        = nullptr;
+  size_t m_num_scratch_locks                      = 0;
 
   bool was_finalized = false;
 
@@ -177,11 +179,13 @@ std::vector<HIP> partition_space(const HIP &, Args...) {
 }
 
 template <class T>
-std::vector<HIP> partition_space(const HIP &, std::vector<T> &weights) {
+std::vector<HIP> partition_space(const HIP &, std::vector<T> const &weights) {
   static_assert(
       std::is_arithmetic<T>::value,
       "Kokkos Error: partitioning arguments must be integers or floats");
 
+  // We only care about the number of instances to create and ignore weights
+  // otherwise.
   std::vector<HIP> instances(weights.size());
   Impl::create_HIP_instances(instances);
   return instances;
diff --git a/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp b/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp
index e2fe5a6d83..0bc3529530 100644
--- a/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp
+++ b/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp
@@ -24,7 +24,6 @@
 #include <HIP/Kokkos_HIP_Error.hpp>
 #include <HIP/Kokkos_HIP_Instance.hpp>
 #include <HIP/Kokkos_HIP_Space.hpp>
-#include <HIP/Kokkos_HIP_Locks.hpp>
 
 // Must use global variable on the device with HIP-Clang
 #ifdef __HIP__
@@ -415,7 +414,8 @@ struct HIPParallelLaunchKernelInvoker<DriverType, LaunchBounds,
 
     // Copy functor (synchronously) to staging buffer in pinned host memory
     unsigned long *staging = hip_instance->constantMemHostStaging;
-    std::memcpy(staging, &driver, sizeof(DriverType));
+    std::memcpy(static_cast<void *>(staging),
+                static_cast<const void *>(&driver), sizeof(DriverType));
 
     // Copy functor asynchronously from there to constant memory on the device
     KOKKOS_IMPL_HIP_SAFE_CALL(hipMemcpyToSymbolAsync(
@@ -462,7 +462,7 @@ struct HIPParallelLaunch<
             "HIPParallelLaunch FAILED: shared memory request is too large");
       }
 
-      KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE();
+      desul::ensure_hip_lock_arrays_on_device();
 
       // Invoke the driver function on the device
       base_t::invoke_kernel(driver, grid, block, shmem, hip_instance);
diff --git a/core/src/HIP/Kokkos_HIP_Locks.cpp b/core/src/HIP/Kokkos_HIP_Locks.cpp
deleted file mode 100644
index 76d3f6f5c8..0000000000
--- a/core/src/HIP/Kokkos_HIP_Locks.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
-#define KOKKOS_IMPL_PUBLIC_INCLUDE
-#endif
-
-#include <Kokkos_Macros.hpp>
-
-#include <HIP/Kokkos_HIP_Locks.hpp>
-#include <HIP/Kokkos_HIP_Error.hpp>
-#include <HIP/Kokkos_HIP.hpp>
-#include <HIP/Kokkos_HIP_Instance.hpp>
-
-#include <hip/hip_runtime.h>
-
-#include <iostream>
-
-namespace Kokkos {
-
-#ifdef KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
-namespace Impl {
-__device__ __constant__ HIPLockArrays g_device_hip_lock_arrays = {nullptr, 0};
-}
-#endif
-
-namespace {
-
-__global__ void init_lock_array_kernel_atomic() {
-  unsigned i = blockIdx.x * blockDim.x + threadIdx.x;
-  if (i < KOKKOS_IMPL_HIP_SPACE_ATOMIC_MASK + 1) {
-    Kokkos::Impl::g_device_hip_lock_arrays.atomic[i] = 0;
-  }
-}
-
-}  // namespace
-
-namespace Impl {
-
-HIPLockArrays g_host_hip_lock_arrays = {nullptr, 0};
-
-void initialize_host_hip_lock_arrays() {
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-  desul::Impl::init_lock_arrays();
-
-  DESUL_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE();
-#endif
-
-  if (g_host_hip_lock_arrays.atomic != nullptr) return;
-  KOKKOS_IMPL_HIP_SAFE_CALL(hipMalloc(
-      &g_host_hip_lock_arrays.atomic,
-      sizeof(std::int32_t) * (KOKKOS_IMPL_HIP_SPACE_ATOMIC_MASK + 1)));
-
-  g_host_hip_lock_arrays.n = HIPInternal::concurrency();
-
-  KOKKOS_COPY_HIP_LOCK_ARRAYS_TO_DEVICE();
-  init_lock_array_kernel_atomic<<<
-      (KOKKOS_IMPL_HIP_SPACE_ATOMIC_MASK + 1 + 255) / 256, 256, 0, nullptr>>>();
-}
-
-void finalize_host_hip_lock_arrays() {
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-  desul::Impl::finalize_lock_arrays();
-#endif
-
-  if (g_host_hip_lock_arrays.atomic == nullptr) return;
-  KOKKOS_IMPL_HIP_SAFE_CALL(hipFree(g_host_hip_lock_arrays.atomic));
-  g_host_hip_lock_arrays.atomic = nullptr;
-  g_host_hip_lock_arrays.n      = 0;
-#ifdef KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
-  KOKKOS_COPY_HIP_LOCK_ARRAYS_TO_DEVICE();
-#endif
-}
-
-}  // namespace Impl
-
-}  // namespace Kokkos
diff --git a/core/src/HIP/Kokkos_HIP_Locks.hpp b/core/src/HIP/Kokkos_HIP_Locks.hpp
deleted file mode 100644
index fbed4afd3f..0000000000
--- a/core/src/HIP/Kokkos_HIP_Locks.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_HIP_LOCKS_HPP
-#define KOKKOS_HIP_LOCKS_HPP
-
-#include <Kokkos_Macros.hpp>
-
-#include <cstdint>
-
-#include <HIP/Kokkos_HIP_Error.hpp>
-
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-#include <desul/atomics/Lock_Array_HIP.hpp>
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-struct HIPLockArrays {
-  std::int32_t* atomic;
-  std::int32_t n;
-};
-
-/// \brief This global variable in Host space is the central definition
-///        of these arrays.
-extern HIPLockArrays g_host_hip_lock_arrays;
-
-/// \brief After this call, the g_host_hip_lock_arrays variable has
-///        valid, initialized arrays.
-///
-/// This call is idempotent.
-void initialize_host_hip_lock_arrays();
-
-/// \brief After this call, the g_host_hip_lock_arrays variable has
-///        all null pointers, and all array memory has been freed.
-///
-/// This call is idempotent.
-void finalize_host_hip_lock_arrays();
-
-#if defined(__HIPCC__)
-
-/// \brief This global variable in HIP space is what kernels use
-///        to get access to the lock arrays.
-///
-/// When relocatable device code is enabled, there can be one single
-/// instance of this global variable for the entire executable,
-/// whose definition will be in Kokkos_HIP_Locks.cpp (and whose declaration
-/// here must then be extern).
-/// This one instance will be initialized by initialize_host_HIP_lock_arrays
-/// and need not be modified afterwards.
-///
-/// When relocatable device code is disabled, an instance of this variable
-/// will be created in every translation unit that sees this header file.
-/// Since the Kokkos_HIP_Locks.cpp translation unit cannot initialize the
-/// instances in other translation units, we must update this HIP global
-/// variable based on the Host global variable prior to running any kernels
-/// that will use it.
-/// That is the purpose of the KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE macro.
-__device__
-#ifdef KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
-    __constant__ extern
-#endif
-    HIPLockArrays g_device_hip_lock_arrays;
-
-#define KOKKOS_IMPL_HIP_SPACE_ATOMIC_MASK 0x1FFFF
-
-/// \brief Acquire a lock for the address
-///
-/// This function tries to acquire the lock for the hash value derived
-/// from the provided ptr. If the lock is successfully acquired the
-/// function returns true. Otherwise it returns false.
-__device__ inline bool lock_address_hip_space(void* ptr) {
-  auto offset = reinterpret_cast<size_t>(ptr);
-  offset      = offset >> 2;
-  offset      = offset & KOKKOS_IMPL_HIP_SPACE_ATOMIC_MASK;
-  return (0 == atomicCAS(&g_device_hip_lock_arrays.atomic[offset], 0, 1));
-}
-
-/// \brief Release lock for the address
-///
-/// This function releases the lock for the hash value derived
-/// from the provided ptr. This function should only be called
-/// after previously successfully aquiring a lock with
-/// lock_address.
-__device__ inline void unlock_address_hip_space(void* ptr) {
-  auto offset = reinterpret_cast<size_t>(ptr);
-  offset      = offset >> 2;
-  offset      = offset & KOKKOS_IMPL_HIP_SPACE_ATOMIC_MASK;
-  atomicExch(&g_device_hip_lock_arrays.atomic[offset], 0);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-// Make lock_array_copied an explicit translation unit scope thingy
-namespace Kokkos {
-namespace Impl {
-namespace {
-static int lock_array_copied = 0;
-inline int eliminate_warning_for_lock_array() { return lock_array_copied; }
-}  // namespace
-}  // namespace Impl
-}  // namespace Kokkos
-
-/* Dan Ibanez: it is critical that this code be a macro, so that it will
-   capture the right address for g_device_hip_lock_arrays!
-   putting this in an inline function will NOT do the right thing! */
-#define KOKKOS_COPY_HIP_LOCK_ARRAYS_TO_DEVICE()                 \
-  {                                                             \
-    if (::Kokkos::Impl::lock_array_copied == 0) {               \
-      KOKKOS_IMPL_HIP_SAFE_CALL(hipMemcpyToSymbol(              \
-          HIP_SYMBOL(::Kokkos::Impl::g_device_hip_lock_arrays), \
-          &::Kokkos::Impl::g_host_hip_lock_arrays,              \
-          sizeof(::Kokkos::Impl::HIPLockArrays)));              \
-    }                                                           \
-    ::Kokkos::Impl::lock_array_copied = 1;                      \
-  }
-
-#ifndef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-
-#ifdef KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
-#define KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE()
-#else
-#define KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE() \
-  KOKKOS_COPY_HIP_LOCK_ARRAYS_TO_DEVICE()
-#endif
-
-#else
-
-#ifdef KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
-#define KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE()
-#else
-// Still Need COPY_CUDA_LOCK_ARRAYS for team scratch etc.
-#define KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE() \
-  KOKKOS_COPY_HIP_LOCK_ARRAYS_TO_DEVICE()         \
-  DESUL_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE()
-#endif
-
-#endif /* defined( KOKKOS_ENABLE_IMPL_DESUL_ATOMICS ) */
-
-#endif /* defined( __HIPCC__ ) */
-
-#endif /* #ifndef KOKKOS_HIP_LOCKS_HPP */
diff --git a/core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp b/core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp
index 10ec301d15..ec1e143849 100644
--- a/core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp
+++ b/core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp
@@ -165,11 +165,13 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, HIP> {
 };
 
 // ParallelReduce
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
-                     HIP> {
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>, HIP> {
  public:
-  using Policy = Kokkos::MDRangePolicy<Traits...>;
+  using Policy      = Kokkos::MDRangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
   using array_index_type = typename Policy::array_index_type;
@@ -179,34 +181,38 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   using Member       = typename Policy::member_type;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
-
-  using Analysis =
-      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy,
-                                    ReducerTypeFwd>;
-
  public:
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
   using functor_type   = FunctorType;
   using size_type      = HIP::size_type;
 
+  // Conditionally set word_size_type to int16_t or int8_t if value_type is
+  // smaller than int32_t (Kokkos::HIP::size_type)
+  // word_size_type is used to determine the word count, shared memory buffer
+  // size, and global memory buffer size before the reduction is performed.
+  // Within the reduction, the word count is recomputed based on word_size_type
+  // and when calculating indexes into the shared/global memory buffers for
+  // performing the reduction, word_size_type is used again.
+  // For scalars > 4 bytes in size, indexing into shared/global memory relies
+  // on the block and grid dimensions to ensure that we index at the correct
+  // offset rather than at every 4 byte word; such that, when the join is
+  // performed, we have the correct data that was copied over in chunks of 4
+  // bytes.
+  static_assert(sizeof(size_type) == 4);
+  using word_size_type = std::conditional_t<
+      sizeof(value_type) < 4,
+      std::conditional_t<sizeof(value_type) == 2, int16_t, int8_t>, size_type>;
+
   // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
   // blockDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;  // used for workrange and nwork
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
-  size_type* m_scratch_space;
+  word_size_type* m_scratch_space;
   size_type* m_scratch_flags;
 
   using DeviceIteratePattern = typename Kokkos::Impl::Reduce::DeviceIterateTile<
@@ -214,28 +220,27 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
 
  public:
   inline __device__ void exec_range(reference_type update) const {
-    DeviceIteratePattern(m_policy, m_functor, update).exec_range();
+    DeviceIteratePattern(m_policy, m_functor_reducer.get_functor(), update)
+        .exec_range();
   }
 
   inline __device__ void operator()() const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
-    const integral_nonzero_constant<size_type, Analysis::StaticValueSize /
-                                                   sizeof(size_type)>
-        word_count(Analysis::value_size(
-                       ReducerConditional::select(m_functor, m_reducer)) /
-                   sizeof(size_type));
+    const integral_nonzero_constant<word_size_type,
+                                    ReducerType::static_value_size() /
+                                        sizeof(word_size_type)>
+        word_count(reducer.value_size() / sizeof(word_size_type));
 
     {
-      reference_type value = final_reducer.init(reinterpret_cast<pointer_type>(
-          kokkos_impl_hip_shared_memory<size_type>() +
+      reference_type value = reducer.init(reinterpret_cast<pointer_type>(
+          kokkos_impl_hip_shared_memory<word_size_type>() +
           threadIdx.y * word_count.value));
 
       // Number of blocks is bounded so that the reduction can be limited to two
       // passes. Each thread block is given an approximately equal amount of
       // work to perform. Accumulate the values for this block. The accumulation
-      // ordering does not match the final pass, but is arithmatically
+      // ordering does not match the final pass, but is arithmetically
       // equivalent.
 
       this->exec_range(value);
@@ -244,19 +249,21 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     // Reduce with final value at blockDim.y - 1 location.
     // Problem: non power-of-two blockDim
     if (::Kokkos::Impl::hip_single_inter_block_reduce_scan<false>(
-            final_reducer, blockIdx.x, gridDim.x,
-            kokkos_impl_hip_shared_memory<size_type>(), m_scratch_space,
+            reducer, blockIdx.x, gridDim.x,
+            kokkos_impl_hip_shared_memory<word_size_type>(), m_scratch_space,
             m_scratch_flags)) {
       // This is the final block with the final result at the final threads'
       // location
-      size_type* const shared = kokkos_impl_hip_shared_memory<size_type>() +
-                                (blockDim.y - 1) * word_count.value;
-      size_type* const global = m_result_ptr_device_accessible
-                                    ? reinterpret_cast<size_type*>(m_result_ptr)
-                                    : m_scratch_space;
+      word_size_type* const shared =
+          kokkos_impl_hip_shared_memory<word_size_type>() +
+          (blockDim.y - 1) * word_count.value;
+      word_size_type* const global =
+          m_result_ptr_device_accessible
+              ? reinterpret_cast<word_size_type*>(m_result_ptr)
+              : m_scratch_space;
 
       if (threadIdx.y == 0) {
-        final_reducer.final(reinterpret_cast<value_type*>(shared));
+        reducer.final(reinterpret_cast<value_type*>(shared));
       }
 
       if (Impl::HIPTraits::WarpSize < word_count.value) {
@@ -274,13 +281,12 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   inline unsigned local_block_size(const FunctorType& f) {
     const auto& instance = m_policy.space().impl_internal_space_instance();
     auto shmem_functor   = [&f](unsigned n) {
-      return hip_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                      WorkTag>(f, n);
+      return hip_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                      value_type>(f, n);
     };
-    using closure_type = ParallelReduce<FunctorType, Policy, ReducerType, HIP>;
 
     unsigned block_size =
-        Kokkos::Impl::hip_get_preferred_blocksize<closure_type, LaunchBounds>(
+        Kokkos::Impl::hip_get_preferred_blocksize<ParallelReduce, LaunchBounds>(
             instance, shmem_functor);
     if (block_size == 0) {
       Kokkos::Impl::throw_runtime_exception(
@@ -291,29 +297,28 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   }
 
   inline void execute() {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    ReducerType reducer = m_functor_reducer.get_reducer();
 
-    using ClosureType =
-        ParallelReduce<FunctorType, Policy, ReducerType, Kokkos::HIP>;
     const auto nwork = m_policy.m_num_tiles;
     if (nwork) {
       int block_size = m_policy.m_prod_tile_dims;
       // CONSTRAINT: Algorithm requires block_size >= product of tile dimensions
       // Nearest power of two
-      int exponent_pow_two    = std::ceil(std::log2(block_size));
-      block_size              = std::pow(2, exponent_pow_two);
-      int suggested_blocksize = local_block_size(m_functor);
+      int exponent_pow_two = std::ceil(std::log2(block_size));
+      block_size           = std::pow(2, exponent_pow_two);
+      int suggested_blocksize =
+          local_block_size(m_functor_reducer.get_functor());
 
       block_size = (block_size > suggested_blocksize)
                        ? block_size
                        : suggested_blocksize;  // Note: block_size must be less
                                                // than or equal to 512
 
-      m_scratch_space = hip_internal_scratch_space(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)) *
-                                block_size /* block_size == max block_count */);
+      m_scratch_space =
+          reinterpret_cast<word_size_type*>(hip_internal_scratch_space(
+              m_policy.space(),
+              reducer.value_size() *
+                  block_size /* block_size == max block_count */));
       m_scratch_flags =
           hip_internal_scratch_flags(m_policy.space(), sizeof(size_type));
 
@@ -326,34 +331,31 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
 
       const int shmem =
           ::Kokkos::Impl::hip_single_inter_block_reduce_scan_shmem<
-              false, FunctorType, WorkTag>(m_functor, block.y);
+              false, WorkTag, value_type>(m_functor_reducer.get_functor(),
+                                          block.y);
 
-      hip_parallel_launch<ClosureType, LaunchBounds>(
+      hip_parallel_launch<ParallelReduce, LaunchBounds>(
           *this, grid, block, shmem,
           m_policy.space().impl_internal_space_instance(),
           false);  // copy to device and execute
 
       if (!m_result_ptr_device_accessible && m_result_ptr) {
-        const int size = Analysis::value_size(
-            ReducerConditional::select(m_functor, m_reducer));
+        const int size = reducer.value_size();
         DeepCopy<HostSpace, HIPSpace, HIP>(m_policy.space(), m_result_ptr,
                                            m_scratch_space, size);
       }
     } else {
       if (m_result_ptr) {
-        final_reducer.init(m_result_ptr);
+        reducer.init(m_result_ptr);
       }
     }
   }
 
   template <class ViewType>
-  ParallelReduce(
-      const FunctorType& arg_functor, const Policy& arg_policy,
-      const ViewType& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<HIPSpace,
@@ -361,23 +363,10 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
         m_scratch_space(nullptr),
         m_scratch_flags(nullptr) {}
 
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<HIPSpace, typename ReducerType::result_view_type::
-                                            memory_space>::accessible),
-        m_scratch_space(nullptr),
-        m_scratch_flags(nullptr) {}
-
   template <typename Policy, typename Functor>
   static int max_tile_size_product(const Policy&, const Functor&) {
-    using closure_type =
-        ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>,
-                       ReducerType, HIP>;
+    using closure_type  = ParallelReduce<CombinedFunctorReducerType,
+                                        Kokkos::MDRangePolicy<Traits...>, HIP>;
     unsigned block_size = hip_get_max_blocksize<closure_type, LaunchBounds>();
     if (block_size == 0) {
       Kokkos::Impl::throw_runtime_exception(
diff --git a/core/src/HIP/Kokkos_HIP_Parallel_Range.hpp b/core/src/HIP/Kokkos_HIP_Parallel_Range.hpp
index d8c52aa95f..7b08832d3b 100644
--- a/core/src/HIP/Kokkos_HIP_Parallel_Range.hpp
+++ b/core/src/HIP/Kokkos_HIP_Parallel_Range.hpp
@@ -101,11 +101,13 @@ class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::HIP> {
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
                      Kokkos::HIP> {
  public:
-  using Policy = Kokkos::RangePolicy<Traits...>;
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
   using WorkRange    = typename Policy::WorkRange;
@@ -113,22 +115,10 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   using Member       = typename Policy::member_type;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
-
-  using Analysis =
-      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy,
-                                    ReducerTypeFwd>;
-
  public:
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
   using functor_type   = FunctorType;
   using size_type      = Kokkos::HIP::size_type;
   using index_type     = typename Policy::index_type;
@@ -136,9 +126,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
   // blockDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
   const bool m_result_ptr_host_accessible;
@@ -146,7 +135,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   size_type* m_scratch_flags = nullptr;
 
   static bool constexpr UseShflReduction =
-      static_cast<bool>(Analysis::StaticValueSize);
+      static_cast<bool>(ReducerType::static_value_size());
 
  private:
   struct ShflReductionTag {};
@@ -156,13 +145,13 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update) const {
-    m_functor(i, update);
+    m_functor_reducer.get_functor()(i, update);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update) const {
-    m_functor(TagType(), i, update);
+    m_functor_reducer.get_functor()(TagType(), i, update);
   }
 
  public:
@@ -173,16 +162,13 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   }
 
   __device__ inline void run(SHMEMReductionTag) const {
-    const integral_nonzero_constant<size_type, Analysis::StaticValueSize /
-                                                   sizeof(size_type)>
-        word_count(Analysis::value_size(
-                       ReducerConditional::select(m_functor, m_reducer)) /
-                   sizeof(size_type));
-
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+    const integral_nonzero_constant<
+        size_type, ReducerType::static_value_size() / sizeof(size_type)>
+        word_count(reducer.value_size() / sizeof(size_type));
+
     {
-      reference_type value = final_reducer.init(reinterpret_cast<pointer_type>(
+      reference_type value = reducer.init(reinterpret_cast<pointer_type>(
           ::Kokkos::kokkos_impl_hip_shared_memory<size_type>() +
           threadIdx.y * word_count.value));
 
@@ -205,7 +191,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     bool do_final_reduction = m_policy.begin() == m_policy.end();
     if (!do_final_reduction)
       do_final_reduction = hip_single_inter_block_reduce_scan<false>(
-          final_reducer, blockIdx.x, gridDim.x,
+          reducer, blockIdx.x, gridDim.x,
           ::Kokkos::kokkos_impl_hip_shared_memory<size_type>(), m_scratch_space,
           m_scratch_flags);
     if (do_final_reduction) {
@@ -220,7 +206,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                                     : m_scratch_space;
 
       if (threadIdx.y == 0) {
-        final_reducer.final(reinterpret_cast<value_type*>(shared));
+        reducer.final(reinterpret_cast<value_type*>(shared));
       }
 
       if (::Kokkos::Impl::HIPTraits::WarpSize < word_count.value) {
@@ -234,11 +220,10 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   }
 
   __device__ inline void run(ShflReductionTag) const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
     value_type value;
-    final_reducer.init(&value);
+    reducer.init(&value);
     // Number of blocks is bounded so that the reduction can be limited to two
     // passes. Each thread block is given an approximately equal amount of work
     // to perform. Accumulate the values for this block. The accumulation
@@ -262,18 +247,18 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         (max_active_thread == 0) ? blockDim.y : max_active_thread;
 
     value_type init;
-    final_reducer.init(&init);
+    reducer.init(&init);
     if (m_policy.begin() == m_policy.end()) {
-      final_reducer.final(&value);
+      reducer.final(&value);
       pointer_type const final_result =
           m_result_ptr_device_accessible ? m_result_ptr : result;
       *final_result = value;
     } else if (Impl::hip_inter_block_shuffle_reduction<>(
-                   value, init, final_reducer, m_scratch_space, result,
+                   value, init, reducer, m_scratch_space, result,
                    m_scratch_flags, max_active_thread)) {
       unsigned int const id = threadIdx.y * blockDim.x + threadIdx.x;
       if (id == 0) {
-        final_reducer.final(&value);
+        reducer.final(&value);
         pointer_type const final_result =
             m_result_ptr_device_accessible ? m_result_ptr : result;
         *final_result = value;
@@ -285,45 +270,57 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   inline unsigned local_block_size(const FunctorType& f) {
     const auto& instance = m_policy.space().impl_internal_space_instance();
     auto shmem_functor   = [&f](unsigned n) {
-      return hip_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                      WorkTag>(f, n);
+      return hip_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                      value_type>(f, n);
     };
-    using DriverType =
-        ParallelReduce<FunctorType, Policy, ReducerType, Kokkos::HIP>;
-    return Kokkos::Impl::hip_get_preferred_blocksize<DriverType, LaunchBounds>(
+    return Kokkos::Impl::hip_get_preferred_blocksize<ParallelReduce,
+                                                     LaunchBounds>(
         instance, shmem_functor);
   }
 
   inline void execute() {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
     const index_type nwork     = m_policy.end() - m_policy.begin();
-    const bool need_device_set = Analysis::has_init_member_function ||
-                                 Analysis::has_final_member_function ||
+    const bool need_device_set = ReducerType::has_init_member_function() ||
+                                 ReducerType::has_final_member_function() ||
                                  !m_result_ptr_host_accessible ||
                                  !std::is_same<ReducerType, InvalidType>::value;
     if ((nwork > 0) || need_device_set) {
-      const int block_size = local_block_size(m_functor);
+      const int block_size = local_block_size(m_functor_reducer.get_functor());
       if (block_size == 0) {
         Kokkos::Impl::throw_runtime_exception(
             std::string("Kokkos::Impl::ParallelReduce< HIP > could not find a "
                         "valid execution configuration."));
       }
 
+      // REQUIRED ( 1 , N , 1 )
+      dim3 block(1, block_size, 1);
+      // use a slightly less constrained, but still well bounded limit for
+      // scratch
+      int nblocks = (nwork + block.y - 1) / block.y;
+      // Heuristic deciding the value of nblocks. The values for the light
+      // weight case have been chosen using a vector product benchmark on MI250.
+      constexpr auto light_weight =
+          Kokkos::Experimental::WorkItemProperty::HintLightWeight;
+      constexpr typename Policy::work_item_property property;
+      if ((property & light_weight) == light_weight) {
+        if (nblocks < block_size) {
+          // Keep nblocks as is
+        } else if (nblocks < 16 * block_size) {
+          nblocks = block_size;
+        } else {
+          nblocks = 4 * block_size;
+        }
+      } else {
+        nblocks = std::min(nblocks, 4096);
+      }
       m_scratch_space = ::Kokkos::Impl::hip_internal_scratch_space(
-          m_policy.space(), Analysis::value_size(ReducerConditional::select(
-                                m_functor, m_reducer)) *
-                                block_size /* block_size == max block_count */);
+          m_policy.space(), reducer.value_size() * nblocks);
       m_scratch_flags = ::Kokkos::Impl::hip_internal_scratch_flags(
           m_policy.space(), sizeof(size_type));
-
-      // REQUIRED ( 1 , N , 1 )
-      dim3 block(1, block_size, 1);
       // Required grid.x <= block.y
-      dim3 grid(std::min(block.y, static_cast<uint32_t>((nwork + block.y - 1) /
-                                                        block.y)),
-                1, 1);
+      dim3 grid(nblocks, 1, 1);
 
       if (nwork == 0) {
         block = dim3(1, 1, 1);
@@ -332,38 +329,32 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
       const int shmem =
           UseShflReduction
               ? 0
-              : hip_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                         WorkTag>(m_functor,
-                                                                  block.y);
+              : hip_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                         value_type>(
+                    m_functor_reducer.get_functor(), block.y);
 
-      using DriverType =
-          ParallelReduce<FunctorType, Policy, ReducerType, Kokkos::HIP>;
-      Kokkos::Impl::hip_parallel_launch<DriverType, LaunchBounds>(
+      Kokkos::Impl::hip_parallel_launch<ParallelReduce, LaunchBounds>(
           *this, grid, block, shmem,
           m_policy.space().impl_internal_space_instance(),
           false);  // copy to device and execute
 
       if (!m_result_ptr_device_accessible && m_result_ptr) {
-        const int size = Analysis::value_size(
-            ReducerConditional::select(m_functor, m_reducer));
+        const int size = reducer.value_size();
         DeepCopy<HostSpace, HIPSpace, HIP>(m_policy.space(), m_result_ptr,
                                            m_scratch_space, size);
       }
     } else {
       if (m_result_ptr) {
-        final_reducer.init(m_result_ptr);
+        reducer.init(m_result_ptr);
       }
     }
   }
 
   template <class ViewType>
-  ParallelReduce(
-      const FunctorType& arg_functor, const Policy& arg_policy,
-      const ViewType& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<HIPSpace,
@@ -371,23 +362,9 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         m_result_ptr_host_accessible(
             MemorySpaceAccess<Kokkos::HostSpace,
                               typename ViewType::memory_space>::accessible) {}
-
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<HIPSpace, typename ReducerType::result_view_type::
-                                            memory_space>::accessible),
-        m_result_ptr_host_accessible(
-            MemorySpaceAccess<Kokkos::HostSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible) {}
 };
 
-template <class FunctorType, class... Traits>
+template <class FunctorType, class ValueType, class... Traits>
 class ParallelScanHIPBase {
  public:
   using Policy = Kokkos::RangePolicy<Traits...>;
@@ -398,8 +375,9 @@ class ParallelScanHIPBase {
   using WorkRange    = typename Policy::WorkRange;
   using LaunchBounds = typename Policy::launch_bounds;
 
-  using Analysis = Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::SCAN,
-                                                 Policy, FunctorType>;
+  using Analysis =
+      Kokkos::Impl::FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                    FunctorType, ValueType>;
 
  public:
   using value_type     = typename Analysis::value_type;
@@ -431,7 +409,8 @@ class ParallelScanHIPBase {
   //  (c) gridDim.x  <= blockDim.y * blockDim.y
   //  (d) gridDim.y  == gridDim.z == 1
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
   const Policy m_policy;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
@@ -444,23 +423,24 @@ class ParallelScanHIPBase {
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update, const bool final_result) const {
-    m_functor(i, update, final_result);
+    m_functor_reducer.get_functor()(i, update, final_result);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_range(
       const Member& i, reference_type update, const bool final_result) const {
-    m_functor(TagType(), i, update, final_result);
+    m_functor_reducer.get_functor()(TagType(), i, update, final_result);
   }
 
   //----------------------------------------
 
   __device__ inline void initial() const {
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
                                                         sizeof(word_size_type)>
-        word_count(Analysis::value_size(m_functor) / sizeof(word_size_type));
+        word_count(final_reducer.value_size() / sizeof(word_size_type));
 
     pointer_type const shared_value = reinterpret_cast<pointer_type>(
         kokkos_impl_hip_shared_memory<word_size_type>() +
@@ -494,11 +474,12 @@ class ParallelScanHIPBase {
   //----------------------------------------
 
   __device__ inline void final() const {
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     const integral_nonzero_constant<word_size_type, Analysis::StaticValueSize /
                                                         sizeof(word_size_type)>
-        word_count(Analysis::value_size(m_functor) / sizeof(word_size_type));
+        word_count(final_reducer.value_size() / sizeof(word_size_type));
 
     // Use shared memory as an exclusive scan: { 0 , value[0] , value[1] ,
     // value[2] , ... }
@@ -609,27 +590,28 @@ class ParallelScanHIPBase {
       // How many block are really needed for this much work:
       m_grid_x = (nwork + work_per_block - 1) / work_per_block;
 
+      const typename Analysis::Reducer& final_reducer =
+          m_functor_reducer.get_reducer();
       m_scratch_space =
           reinterpret_cast<word_size_type*>(Impl::hip_internal_scratch_space(
-              m_policy.space(), Analysis::value_size(m_functor) * m_grid_x));
+              m_policy.space(), final_reducer.value_size() * m_grid_x));
       m_scratch_flags = Impl::hip_internal_scratch_flags(m_policy.space(),
                                                          sizeof(size_type) * 1);
 
       dim3 grid(m_grid_x, 1, 1);
       dim3 block(1, block_size, 1);  // REQUIRED DIMENSIONS ( 1 , N , 1 )
-      const int shmem = Analysis::value_size(m_functor) * (block_size + 2);
+      const int shmem = final_reducer.value_size() * (block_size + 2);
 
       m_final = false;
       // these ones are OK to be just the base because the specializations
       // do not modify the kernel at all
-      using DriverType = ParallelScanHIPBase<FunctorType, Traits...>;
-      Impl::hip_parallel_launch<DriverType, LaunchBounds>(
+      Impl::hip_parallel_launch<ParallelScanHIPBase, LaunchBounds>(
           *this, grid, block, shmem,
           m_policy.space().impl_internal_space_instance(),
           false);  // copy to device and execute
 
       m_final = true;
-      Impl::hip_parallel_launch<DriverType, LaunchBounds>(
+      Impl::hip_parallel_launch<ParallelScanHIPBase, LaunchBounds>(
           *this, grid, block, shmem,
           m_policy.space().impl_internal_space_instance(),
           false);  // copy to device and execute
@@ -639,7 +621,7 @@ class ParallelScanHIPBase {
   ParallelScanHIPBase(const FunctorType& arg_functor, const Policy& arg_policy,
                       pointer_type arg_result_ptr,
                       bool arg_result_ptr_device_accessible)
-      : m_functor(arg_functor),
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
         m_policy(arg_policy),
         m_result_ptr(arg_result_ptr),
         m_result_ptr_device_accessible(arg_result_ptr_device_accessible) {}
@@ -647,13 +629,14 @@ class ParallelScanHIPBase {
 
 template <class FunctorType, class... Traits>
 class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, HIP>
-    : public ParallelScanHIPBase<FunctorType, Traits...> {
+    : public ParallelScanHIPBase<FunctorType, void, Traits...> {
  public:
-  using Base = ParallelScanHIPBase<FunctorType, Traits...>;
+  using Base = ParallelScanHIPBase<FunctorType, void, Traits...>;
   using Base::operator();
 
   inline void execute() {
-    const int block_size = static_cast<int>(local_block_size(Base::m_functor));
+    const int block_size = static_cast<int>(
+        local_block_size(Base::m_functor_reducer.get_functor()));
     if (block_size == 0) {
       Kokkos::Impl::throw_runtime_exception(
           std::string("Kokkos::Impl::ParallelScan< HIP > could not find a "
@@ -674,9 +657,8 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, HIP>
     const auto& instance =
         Base::m_policy.space().impl_internal_space_instance();
     auto shmem_functor = [&f](unsigned n) {
-      return hip_single_inter_block_reduce_scan_shmem<true, FunctorType,
-                                                      typename Base::WorkTag>(
-          f, n);
+      return hip_single_inter_block_reduce_scan_shmem<
+          true, typename Base::WorkTag, void>(f, n);
     };
     using DriverType = ParallelScan<FunctorType, typename Base::Policy, HIP>;
     return Impl::hip_get_preferred_blocksize<DriverType,
@@ -690,13 +672,14 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, HIP>
 template <class FunctorType, class ReturnType, class... Traits>
 class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
                             ReturnType, HIP>
-    : public ParallelScanHIPBase<FunctorType, Traits...> {
+    : public ParallelScanHIPBase<FunctorType, ReturnType, Traits...> {
  public:
-  using Base = ParallelScanHIPBase<FunctorType, Traits...>;
+  using Base = ParallelScanHIPBase<FunctorType, ReturnType, Traits...>;
   using Base::operator();
 
   inline void execute() {
-    const int block_size = static_cast<int>(local_block_size(Base::m_functor));
+    const int block_size = static_cast<int>(
+        local_block_size(Base::m_functor_reducer.get_functor()));
     if (block_size == 0) {
       Kokkos::Impl::throw_runtime_exception(
           std::string("Kokkos::Impl::ParallelScan< HIP > could not find a "
@@ -707,7 +690,8 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
 
     const auto nwork = Base::m_policy.end() - Base::m_policy.begin();
     if (nwork && !Base::m_result_ptr_device_accessible) {
-      const int size = Base::Analysis::value_size(Base::m_functor);
+      const int size =
+          Base::Analysis::value_size(Base::m_functor_reducer.get_functor());
       DeepCopy<HostSpace, HIPSpace, HIP>(
           Base::m_policy.space(), Base::m_result_ptr,
           Base::m_scratch_space + (Base::m_grid_x - 1) * size /
@@ -731,9 +715,8 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     const auto& instance =
         Base::m_policy.space().impl_internal_space_instance();
     auto shmem_functor = [&f](unsigned n) {
-      return hip_single_inter_block_reduce_scan_shmem<true, FunctorType,
-                                                      typename Base::WorkTag>(
-          f, n);
+      return hip_single_inter_block_reduce_scan_shmem<
+          true, typename Base::WorkTag, ReturnType>(f, n);
     };
     using DriverType = ParallelScanWithTotal<FunctorType, typename Base::Policy,
                                              ReturnType, HIP>;
diff --git a/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp b/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp
index 442ca8aef2..0d75c3ca86 100644
--- a/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp
+++ b/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp
@@ -22,7 +22,6 @@
 #if defined(__HIPCC__)
 
 #include <HIP/Kokkos_HIP_KernelLaunch.hpp>
-#include <HIP/Kokkos_HIP_Locks.hpp>
 #include <HIP/Kokkos_HIP_Team.hpp>
 #include <HIP/Kokkos_HIP_Instance.hpp>
 #include <Kokkos_MinMaxClamp.hpp>
@@ -75,7 +74,7 @@ class TeamPolicyInternal<HIP, Properties...>
     using closure_type =
         Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
 
-    return internal_team_size_common<BlockType::Max, closure_type>(f);
+    return internal_team_size_common<BlockType::Max, closure_type, void>(f);
   }
 
   template <class FunctorType>
@@ -83,23 +82,24 @@ class TeamPolicyInternal<HIP, Properties...>
                            const ParallelReduceTag&) const {
     using functor_analysis_type =
         Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                              TeamPolicyInternal, FunctorType>;
-    using reducer_type = typename Impl::ParallelReduceReturnValue<
-        void, typename functor_analysis_type::value_type,
-        FunctorType>::reducer_type;
-    using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             reducer_type>;
-    return internal_team_size_common<BlockType::Max, closure_type>(f);
+                              TeamPolicyInternal, FunctorType, void>;
+    using closure_type = Impl::ParallelReduce<
+        CombinedFunctorReducer<FunctorType,
+                               typename functor_analysis_type::Reducer>,
+        TeamPolicy<Properties...>, Kokkos::HIP>;
+    return internal_team_size_common<
+        BlockType::Max, closure_type,
+        typename functor_analysis_type::value_type>(f);
   }
 
   template <typename FunctorType, typename ReducerType>
   inline int team_size_max(const FunctorType& f, const ReducerType&,
                            const ParallelReduceTag&) const {
     using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             ReducerType>;
-    return internal_team_size_common<BlockType::Max, closure_type>(f);
+        Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             TeamPolicy<Properties...>, Kokkos::HIP>;
+    return internal_team_size_common<BlockType::Max, closure_type,
+                                     typename ReducerType::value_type>(f);
   }
 
   template <typename FunctorType>
@@ -107,7 +107,8 @@ class TeamPolicyInternal<HIP, Properties...>
     using closure_type =
         Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
 
-    return internal_team_size_common<BlockType::Preferred, closure_type>(f);
+    return internal_team_size_common<BlockType::Preferred, closure_type, void>(
+        f);
   }
 
   template <typename FunctorType>
@@ -115,23 +116,24 @@ class TeamPolicyInternal<HIP, Properties...>
                                    ParallelReduceTag const&) const {
     using functor_analysis_type =
         Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                              TeamPolicyInternal, FunctorType>;
-    using reducer_type = typename Impl::ParallelReduceReturnValue<
-        void, typename functor_analysis_type::value_type,
-        FunctorType>::reducer_type;
-    using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             reducer_type>;
-    return internal_team_size_common<BlockType::Preferred, closure_type>(f);
+                              TeamPolicyInternal, FunctorType, void>;
+    using closure_type = Impl::ParallelReduce<
+        CombinedFunctorReducer<FunctorType,
+                               typename functor_analysis_type::Reducer>,
+        TeamPolicy<Properties...>, Kokkos::HIP>;
+    return internal_team_size_common<
+        BlockType::Preferred, closure_type,
+        typename functor_analysis_type::value_type>(f);
   }
 
   template <typename FunctorType, typename ReducerType>
   int team_size_recommended(FunctorType const& f, ReducerType const&,
                             ParallelReduceTag const&) const {
     using closure_type =
-        Impl::ParallelReduce<FunctorType, TeamPolicy<Properties...>,
-                             ReducerType>;
-    return internal_team_size_common<BlockType::Preferred, closure_type>(f);
+        Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             TeamPolicy<Properties...>, Kokkos::HIP>;
+    return internal_team_size_common<BlockType::Preferred, closure_type,
+                                     typename ReducerType::value_type>(f);
   }
 
   inline bool impl_auto_vector_length() const { return m_tune_vector_length; }
@@ -330,7 +332,8 @@ class TeamPolicyInternal<HIP, Properties...>
   using member_type = Kokkos::Impl::HIPTeamMember;
 
  protected:
-  template <BlockType BlockSize, class ClosureType, class FunctorType>
+  template <BlockType BlockSize, class ClosureType, class ValueType,
+            class FunctorType>
   int internal_team_size_common(FunctorType const& f) const {
     const unsigned shmem_block = team_scratch_size(0) + 2 * sizeof(double);
     unsigned shmem_thread      = thread_scratch_size(0) + sizeof(double);
@@ -340,7 +343,7 @@ class TeamPolicyInternal<HIP, Properties...>
           typename Impl::DeduceFunctorPatternInterface<ClosureType>::type;
       using Analysis =
           Impl::FunctorAnalysis<Interface, typename ClosureType::Policy,
-                                FunctorType>;
+                                FunctorType, ValueType>;
       shmem_thread +=
           ((Analysis::StaticValueSize != 0) ? 0 : Analysis::value_size(f));
     }
@@ -384,14 +387,14 @@ class TeamPolicyInternal<HIP, Properties...>
 };
 
 __device__ inline int64_t hip_get_scratch_index(HIP::size_type league_size,
-                                                int32_t* scratch_locks) {
+                                                int32_t* scratch_locks,
+                                                size_t num_scratch_locks) {
   int64_t threadid = 0;
   __shared__ int64_t base_thread_id;
   if (threadIdx.x == 0 && threadIdx.y == 0) {
     int64_t const wraparound_len =
         Kokkos::min(int64_t(league_size),
-                    (int64_t(Kokkos::Impl::g_device_hip_lock_arrays.n)) /
-                        (blockDim.x * blockDim.y));
+                    int64_t(num_scratch_locks) / (blockDim.x * blockDim.y));
     threadid = (blockIdx.x * blockDim.z + threadIdx.z) % wraparound_len;
     threadid *= blockDim.x * blockDim.y;
     int done = 0;
@@ -448,6 +451,7 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP> {
   size_t m_scratch_size[2];
   int m_scratch_pool_id = -1;
   int32_t* m_scratch_locks;
+  size_t m_num_scratch_locks;
 
   template <typename TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_team(
@@ -466,7 +470,8 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP> {
     // Iterate this block through the league
     int64_t threadid = 0;
     if (m_scratch_size[1] > 0) {
-      threadid = hip_get_scratch_index(m_league_size, m_scratch_locks);
+      threadid = hip_get_scratch_index(m_league_size, m_scratch_locks,
+                                       m_num_scratch_locks);
     }
 
     int const int_league_size = static_cast<int>(m_league_size);
@@ -514,9 +519,10 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP> {
     m_shmem_size =
         (m_policy.scratch_size(0, m_team_size) +
          FunctorTeamShmemSize<FunctorType>::value(m_functor, m_team_size));
-    m_scratch_size[0] = m_policy.scratch_size(0, m_team_size);
-    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
-    m_scratch_locks   = internal_space_instance->m_scratch_locks;
+    m_scratch_size[0]   = m_policy.scratch_size(0, m_team_size);
+    m_scratch_size[1]   = m_policy.scratch_size(1, m_team_size);
+    m_scratch_locks     = internal_space_instance->m_scratch_locks;
+    m_num_scratch_locks = internal_space_instance->m_num_scratch_locks;
 
     // Functor's reduce memory, team scan memory, and team shared memory depend
     // upon team size.
@@ -559,37 +565,28 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP> {
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, HIP> {
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>, HIP> {
  public:
-  using Policy = TeamPolicyInternal<HIP, Properties...>;
+  using Policy      = TeamPolicyInternal<HIP, Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
   using member_type   = typename Policy::member_type;
   using work_tag      = typename Policy::work_tag;
   using launch_bounds = typename Policy::launch_bounds;
 
-  using reducer_conditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using reducer_type_fwd = typename reducer_conditional::type;
-  using work_tag_fwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  work_tag, void>::type;
-
-  using analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         Policy, reducer_type_fwd>;
-
-  using pointer_type   = typename analysis::pointer_type;
-  using reference_type = typename analysis::reference_type;
-  using value_type     = typename analysis::value_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+  using value_type     = typename ReducerType::value_type;
 
  public:
-  using functor_type = FunctorType;
-  using size_type    = HIP::size_type;
+  using size_type = HIP::size_type;
 
-  static int constexpr UseShflReduction = (analysis::StaticValueSize != 0);
+  static int constexpr UseShflReduction =
+      (ReducerType::static_value_size() != 0);
 
  private:
   struct ShflReductionTag {};
@@ -603,9 +600,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   //  [ team   shared space ]
   //
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
   const bool m_result_ptr_host_accessible;
@@ -618,6 +614,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   size_t m_scratch_size[2];
   int m_scratch_pool_id = -1;
   int32_t* m_scratch_locks;
+  size_t m_num_scratch_locks;
   const size_type m_league_size;
   int m_team_size;
   const size_type m_vector_size;
@@ -625,13 +622,13 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   template <class TagType>
   __device__ inline std::enable_if_t<std::is_void<TagType>::value> exec_team(
       member_type const& member, reference_type update) const {
-    m_functor(member, update);
+    m_functor_reducer.get_functor()(member, update);
   }
 
   template <class TagType>
   __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_team(
       member_type const& member, reference_type update) const {
-    m_functor(TagType(), member, update);
+    m_functor_reducer.get_functor()(TagType(), member, update);
   }
 
   __device__ inline void iterate_through_league(int const threadid,
@@ -656,7 +653,8 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   __device__ inline void operator()() const {
     int64_t threadid = 0;
     if (m_scratch_size[1] > 0) {
-      threadid = hip_get_scratch_index(m_league_size, m_scratch_locks);
+      threadid = hip_get_scratch_index(m_league_size, m_scratch_locks,
+                                       m_num_scratch_locks);
     }
 
     using ReductionTag = std::conditional_t<UseShflReduction, ShflReductionTag,
@@ -669,18 +667,15 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   }
 
   __device__ inline void run(SHMEMReductionTag, int const threadid) const {
-    typename analysis::Reducer final_reducer(
-        &reducer_conditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
-    integral_nonzero_constant<size_type, analysis::StaticValueSize /
+    integral_nonzero_constant<size_type, ReducerType::static_value_size() /
                                              sizeof(size_type)> const
-        word_count(analysis::value_size(
-                       reducer_conditional::select(m_functor, m_reducer)) /
-                   sizeof(size_type));
+        word_count(reducer.value_size() / sizeof(size_type));
 
     reference_type value =
-        final_reducer.init(kokkos_impl_hip_shared_memory<size_type>() +
-                           threadIdx.y * word_count.value);
+        reducer.init(kokkos_impl_hip_shared_memory<size_type>() +
+                     threadIdx.y * word_count.value);
 
     // Iterate this block through the league
     iterate_through_league(threadid, value);
@@ -690,9 +685,9 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     if (!do_final_reduce)
       do_final_reduce =
           hip_single_inter_block_reduce_scan<false, FunctorType, work_tag>(
-              reducer_conditional::select(m_functor, m_reducer), blockIdx.x,
-              gridDim.x, kokkos_impl_hip_shared_memory<size_type>(),
-              m_scratch_space, m_scratch_flags);
+              reducer, blockIdx.x, gridDim.x,
+              kokkos_impl_hip_shared_memory<size_type>(), m_scratch_space,
+              m_scratch_flags);
     if (do_final_reduce) {
       // This is the final block with the final result at the final threads'
       // location
@@ -704,7 +699,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                                     : m_scratch_space;
 
       if (threadIdx.y == 0) {
-        final_reducer.final(reinterpret_cast<value_type*>(shared));
+        reducer.final(reinterpret_cast<value_type*>(shared));
       }
 
       if (HIPTraits::WarpSize < word_count.value) {
@@ -718,11 +713,10 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   }
 
   __device__ inline void run(ShflReductionTag, int const threadid) const {
-    typename analysis::Reducer final_reducer(
-        &reducer_conditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
     value_type value;
-    final_reducer.init(&value);
+    reducer.init(&value);
 
     // Iterate this block through the league
     iterate_through_league(threadid, value);
@@ -733,28 +727,27 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
             : reinterpret_cast<pointer_type>(m_scratch_space);
 
     value_type init;
-    final_reducer.init(&init);
+    reducer.init(&init);
     if (m_league_size == 0) {
-      final_reducer.final(&value);
+      reducer.final(&value);
       *result = value;
     } else if (Impl::hip_inter_block_shuffle_reduction(
-                   value, init, final_reducer, m_scratch_space, result,
+                   value, init, reducer, m_scratch_space, result,
                    m_scratch_flags, blockDim.y)) {
       unsigned int const id = threadIdx.y * blockDim.x + threadIdx.x;
       if (id == 0) {
-        final_reducer.final(&value);
+        reducer.final(&value);
         *result = value;
       }
     }
   }
 
   inline void execute() {
-    typename analysis::Reducer final_reducer(
-        &reducer_conditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
     const bool is_empty_range  = m_league_size == 0 || m_team_size == 0;
-    const bool need_device_set = analysis::has_init_member_function ||
-                                 analysis::has_final_member_function ||
+    const bool need_device_set = ReducerType::has_init_member_function() ||
+                                 ReducerType::has_final_member_function() ||
                                  !m_result_ptr_host_accessible ||
                                  !std::is_same<ReducerType, InvalidType>::value;
     if (!is_empty_range || need_device_set) {
@@ -764,9 +757,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
               : std::min(static_cast<int>(m_league_size), m_team_size);
 
       m_scratch_space = hip_internal_scratch_space(
-          m_policy.space(), analysis::value_size(reducer_conditional::select(
-                                m_functor, m_reducer)) *
-                                block_count);
+          m_policy.space(), reducer.value_size() * block_count);
       m_scratch_flags =
           hip_internal_scratch_flags(m_policy.space(), sizeof(size_type));
 
@@ -778,10 +769,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
       }
       const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
 
-      using closure_type =
-          ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                         ReducerType, HIP>;
-      Impl::hip_parallel_launch<closure_type, launch_bounds>(
+      Impl::hip_parallel_launch<ParallelReduce, launch_bounds>(
           *this, grid, block, shmem_size_total,
           m_policy.space().impl_internal_space_instance(),
           true);  // copy to device and execute
@@ -790,26 +778,22 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         m_policy.space().impl_internal_space_instance()->fence();
 
         if (m_result_ptr) {
-          const int size = analysis::value_size(
-              reducer_conditional::select(m_functor, m_reducer));
+          const int size = reducer.value_size();
           DeepCopy<HostSpace, HIPSpace>(m_result_ptr, m_scratch_space, size);
         }
       }
     } else {
       if (m_result_ptr) {
-        final_reducer.init(m_result_ptr);
+        reducer.init(m_result_ptr);
       }
     }
   }
 
   template <class ViewType>
-  ParallelReduce(
-      FunctorType const& arg_functor, Policy const& arg_policy,
-      ViewType const& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(CombinedFunctorReducerType const& arg_functor_reducer,
+                 Policy const& arg_policy, ViewType const& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<HIPSpace,
@@ -830,21 +814,24 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         m_policy.space().impl_internal_space_instance();
     m_team_size = m_team_size >= 0 ? m_team_size
                                    : arg_policy.team_size_recommended(
-                                         arg_functor, ParallelReduceTag());
+                                         arg_functor_reducer.get_functor(),
+                                         arg_functor_reducer.get_reducer(),
+                                         ParallelReduceTag());
 
     m_team_begin =
         UseShflReduction
             ? 0
-            : hip_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                       work_tag>(arg_functor,
-                                                                 m_team_size);
+            : hip_single_inter_block_reduce_scan_shmem<false, work_tag,
+                                                       value_type>(
+                  arg_functor_reducer.get_functor(), m_team_size);
     m_shmem_begin = sizeof(double) * (m_team_size + 2);
-    m_shmem_size =
-        m_policy.scratch_size(0, m_team_size) +
-        FunctorTeamShmemSize<FunctorType>::value(arg_functor, m_team_size);
-    m_scratch_size[0] = m_shmem_size;
-    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
-    m_scratch_locks   = internal_space_instance->m_scratch_locks;
+    m_shmem_size  = m_policy.scratch_size(0, m_team_size) +
+                   FunctorTeamShmemSize<FunctorType>::value(
+                       arg_functor_reducer.get_functor(), m_team_size);
+    m_scratch_size[0]   = m_shmem_size;
+    m_scratch_size[1]   = m_policy.scratch_size(1, m_team_size);
+    m_scratch_locks     = internal_space_instance->m_scratch_locks;
+    m_num_scratch_locks = internal_space_instance->m_num_scratch_locks;
     if (m_team_size <= 0) {
       m_scratch_ptr[1] = nullptr;
     } else {
@@ -889,96 +876,9 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                       "L0 scratch memory"));
     }
 
-    size_t max_size =
-        arg_policy.team_size_max(arg_functor, ParallelReduceTag());
-    if (static_cast<int>(m_team_size) > static_cast<int>(max_size)) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelReduce< HIP > requested too "
-                      "large team size."));
-    }
-  }
-
-  ParallelReduce(FunctorType const& arg_functor, Policy const& arg_policy,
-                 ReducerType const& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<HIPSpace, typename ReducerType::result_view_type::
-                                            memory_space>::accessible),
-        m_result_ptr_host_accessible(
-            MemorySpaceAccess<Kokkos::HostSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_scratch_space(nullptr),
-        m_scratch_flags(nullptr),
-        m_team_begin(0),
-        m_shmem_begin(0),
-        m_shmem_size(0),
-        m_scratch_ptr{nullptr, nullptr},
-        m_league_size(arg_policy.league_size()),
-        m_team_size(arg_policy.team_size()),
-        m_vector_size(arg_policy.impl_vector_length()) {
-    auto internal_space_instance =
-        m_policy.space().impl_internal_space_instance();
-    m_team_size = m_team_size >= 0
-                      ? m_team_size
-                      : arg_policy.team_size_recommended(arg_functor, reducer,
-                                                         ParallelReduceTag());
-    m_team_begin =
-        UseShflReduction
-            ? 0
-            : hip_single_inter_block_reduce_scan_shmem<false, FunctorType,
-                                                       work_tag>(arg_functor,
-                                                                 m_team_size);
-    m_shmem_begin = sizeof(double) * (m_team_size + 2);
-    m_shmem_size =
-        m_policy.scratch_size(0, m_team_size) +
-        FunctorTeamShmemSize<FunctorType>::value(arg_functor, m_team_size);
-    m_scratch_size[0] = m_shmem_size;
-    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
-    m_scratch_locks   = internal_space_instance->m_scratch_locks;
-    if (m_team_size <= 0) {
-      m_scratch_ptr[1] = nullptr;
-    } else {
-      m_scratch_pool_id = internal_space_instance->acquire_team_scratch_space();
-      m_scratch_ptr[1]  = internal_space_instance->resize_team_scratch_space(
-          m_scratch_pool_id,
-          static_cast<std::int64_t>(m_scratch_size[1]) *
-              (std::min(
-                  static_cast<std::int64_t>(HIP().concurrency() /
-                                            (m_team_size * m_vector_size)),
-                  static_cast<std::int64_t>(m_league_size))));
-    }
-
-    // The global parallel_reduce does not support vector_length other than 1 at
-    // the moment
-    if ((arg_policy.impl_vector_length() > 1) && !UseShflReduction)
-      Impl::throw_runtime_exception(
-          "Kokkos::parallel_reduce with a TeamPolicy using a vector length of "
-          "greater than 1 is not currently supported for HIP for dynamic "
-          "sized reduction types.");
-
-    if ((m_team_size < HIPTraits::WarpSize) && !UseShflReduction)
-      Impl::throw_runtime_exception(
-          "Kokkos::parallel_reduce with a TeamPolicy using a team_size smaller "
-          "than 64 is not currently supported with HIP for dynamic sized "
-          "reduction types.");
-
-    // Functor's reduce memory, team scan memory, and team shared memory depend
-    // upon team size.
-
-    const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
-    if ((!Kokkos::Impl::is_integral_power_of_two(m_team_size) &&
-         !UseShflReduction) ||
-        internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelReduce< HIP > bad team size"));
-    }
-
-    size_t max_size =
-        arg_policy.team_size_max(arg_functor, reducer, ParallelReduceTag());
+    size_t max_size = arg_policy.team_size_max(
+        arg_functor_reducer.get_functor(), arg_functor_reducer.get_reducer(),
+        ParallelReduceTag());
     if (static_cast<int>(m_team_size) > static_cast<int>(max_size)) {
       Kokkos::Impl::throw_runtime_exception(
           std::string("Kokkos::Impl::ParallelReduce< HIP > requested too "
diff --git a/core/src/HIP/Kokkos_HIP_ReduceScan.hpp b/core/src/HIP/Kokkos_HIP_ReduceScan.hpp
index 9de26b63a7..a533d41537 100644
--- a/core/src/HIP/Kokkos_HIP_ReduceScan.hpp
+++ b/core/src/HIP/Kokkos_HIP_ReduceScan.hpp
@@ -477,22 +477,24 @@ __device__ bool hip_single_inter_block_reduce_scan(
 }
 
 // Size in bytes required for inter block reduce or scan
-template <bool DoScan, class FunctorType, class ArgTag>
+template <bool DoScan, class ArgTag, class ValueType, class FunctorType>
 inline std::enable_if_t<DoScan, unsigned>
 hip_single_inter_block_reduce_scan_shmem(const FunctorType& functor,
                                          const unsigned BlockSize) {
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         RangePolicy<HIP, ArgTag>, FunctorType>;
+  using Analysis =
+      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                            RangePolicy<HIP, ArgTag>, FunctorType, ValueType>;
 
   return (BlockSize + 2) * Analysis::value_size(functor);
 }
 
-template <bool DoScan, class FunctorType, class ArgTag>
+template <bool DoScan, class ArgTag, class ValueType, class FunctorType>
 inline std::enable_if_t<!DoScan, unsigned>
 hip_single_inter_block_reduce_scan_shmem(const FunctorType& functor,
                                          const unsigned BlockSize) {
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         RangePolicy<HIP, ArgTag>, FunctorType>;
+  using Analysis =
+      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                            RangePolicy<HIP, ArgTag>, FunctorType, ValueType>;
 
   return (BlockSize + 2) * Analysis::value_size(functor);
 }
diff --git a/core/src/HIP/Kokkos_HIP_Team.hpp b/core/src/HIP/Kokkos_HIP_Team.hpp
index 5b9faba786..2fed2b7719 100644
--- a/core/src/HIP/Kokkos_HIP_Team.hpp
+++ b/core/src/HIP/Kokkos_HIP_Team.hpp
@@ -181,8 +181,8 @@ class HIPTeamMember {
               typename ReducerType::value_type& value) const noexcept {
 #ifdef __HIP_DEVICE_COMPILE__
     typename Kokkos::Impl::FunctorAnalysis<
-        FunctorPatternInterface::REDUCE, TeamPolicy<HIP>, ReducerType>::Reducer
-        wrapped_reducer(&reducer);
+        FunctorPatternInterface::REDUCE, TeamPolicy<HIP>, ReducerType,
+        typename ReducerType::value_type>::Reducer wrapped_reducer(reducer);
     hip_intra_block_shuffle_reduction(value, wrapped_reducer, blockDim.y);
     reducer.reference() = value;
 #else
@@ -219,7 +219,7 @@ class HIPTeamMember {
     Impl::HIPJoinFunctor<Type> hip_join_functor;
     typename Kokkos::Impl::FunctorAnalysis<
         FunctorPatternInterface::REDUCE, TeamPolicy<HIP>,
-        Impl::HIPJoinFunctor<Type>>::Reducer reducer(&hip_join_functor);
+        Impl::HIPJoinFunctor<Type>, Type>::Reducer reducer(hip_join_functor);
     Impl::hip_intra_block_reduce_scan<true>(reducer, base_data + 1);
 
     if (global_accum) {
@@ -367,18 +367,10 @@ struct ThreadVectorRangeBoundariesStruct<iType, HIPTeamMember> {
   ThreadVectorRangeBoundariesStruct(const HIPTeamMember, index_type count)
       : start(static_cast<index_type>(0)), end(count) {}
 
-  KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct(index_type count)
-      : start(static_cast<index_type>(0)), end(count) {}
-
   KOKKOS_INLINE_FUNCTION
   ThreadVectorRangeBoundariesStruct(const HIPTeamMember, index_type arg_begin,
                                     index_type arg_end)
       : start(arg_begin), end(arg_end) {}
-
-  KOKKOS_INLINE_FUNCTION
-  ThreadVectorRangeBoundariesStruct(index_type arg_begin, index_type arg_end)
-      : start(arg_begin), end(arg_end) {}
 };
 
 }  // namespace Impl
@@ -552,8 +544,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     const FunctorType& lambda) {
   // Extract value_type from lambda
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void,
-      FunctorType>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
 
   const auto start     = loop_bounds.start;
   const auto end       = loop_bounds.end;
@@ -832,7 +824,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
         loop_boundaries,
     const Closure& closure) {
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
   value_type dummy;
   parallel_scan(loop_boundaries, closure, Kokkos::Sum<value_type>(dummy));
 }
diff --git a/core/src/HIP/Kokkos_HIP_UniqueToken.hpp b/core/src/HIP/Kokkos_HIP_UniqueToken.hpp
index 13fc6216d6..313e5f5217 100644
--- a/core/src/HIP/Kokkos_HIP_UniqueToken.hpp
+++ b/core/src/HIP/Kokkos_HIP_UniqueToken.hpp
@@ -97,13 +97,9 @@ class UniqueToken<HIP, UniqueTokenScope::Global> {
       done_active = __ballot(done ? 1 : 0);
     }
 
-// Make sure that all writes in the previous lock owner are visible to me
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
+    // Make sure that all writes in the previous lock owner are visible to me
     desul::atomic_thread_fence(desul::MemoryOrderAcquire(),
                                desul::MemoryScopeDevice());
-#else
-    Kokkos::memory_fence();
-#endif
     return idx;
   }
 
@@ -118,13 +114,9 @@ class UniqueToken<HIP, UniqueTokenScope::Global> {
   /// \brief release an acquired value
   KOKKOS_INLINE_FUNCTION
   void release(size_type idx) const noexcept {
-// Make sure my writes are visible to the next lock owner
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
+    // Make sure my writes are visible to the next lock owner
     desul::atomic_thread_fence(desul::MemoryOrderRelease(),
                                desul::MemoryScopeDevice());
-#else
-    Kokkos::memory_fence();
-#endif
     (void)Kokkos::atomic_exchange(m_locks.data() + idx, 0);
   }
 };
diff --git a/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp b/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp
new file mode 100644
index 0000000000..5c40d0fbc8
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp
@@ -0,0 +1,46 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+#ifndef KOKKOS_HIP_ZEROMEMSET_HPP
+#define KOKKOS_HIP_ZEROMEMSET_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <HIP/Kokkos_HIP.hpp>
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class T, class... P>
+struct ZeroMemset<HIP, View<T, P...>> {
+  ZeroMemset(const HIP& exec_space, const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    KOKKOS_IMPL_HIP_SAFE_CALL(hipMemsetAsync(
+        dst.data(), 0, dst.size() * sizeof(typename View<T, P...>::value_type),
+        exec_space.hip_stream()));
+  }
+
+  ZeroMemset(const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    KOKKOS_IMPL_HIP_SAFE_CALL(
+        hipMemset(dst.data(), 0,
+                  dst.size() * sizeof(typename View<T, P...>::value_type)));
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // !defined(KOKKOS_HIP_ZEROMEMSET_HPP)
diff --git a/core/src/HPX/Kokkos_HPX.cpp b/core/src/HPX/Kokkos_HPX.cpp
index 2074123a15..f6792a98f6 100644
--- a/core/src/HPX/Kokkos_HPX.cpp
+++ b/core/src/HPX/Kokkos_HPX.cpp
@@ -21,38 +21,177 @@
 #include <Kokkos_Core.hpp>
 
 #ifdef KOKKOS_ENABLE_HPX
-#include <Kokkos_HPX.hpp>
+#include <HPX/Kokkos_HPX.hpp>
 
 #include <impl/Kokkos_ExecSpaceManager.hpp>
 
 #include <hpx/local/condition_variable.hpp>
 #include <hpx/local/init.hpp>
+#include <hpx/local/runtime.hpp>
 #include <hpx/local/thread.hpp>
 #include <hpx/local/mutex.hpp>
+#include <hpx/version.hpp>
 
 #include <atomic>
 #include <chrono>
-#include <iostream>
 #include <memory>
+#include <ostream>
 #include <string>
 #include <type_traits>
 
 namespace Kokkos {
+namespace Impl {
+void hpx_thread_buffer::resize(const std::size_t num_threads,
+                               const std::size_t size_per_thread,
+                               const std::size_t extra_space) noexcept {
+  m_num_threads     = num_threads;
+  m_size_per_thread = size_per_thread;
+  m_extra_space     = extra_space;
+
+  pad_to_cache_line(m_size_per_thread);
+
+  std::size_t size_total_new =
+      m_num_threads * m_size_per_thread + m_extra_space;
+
+  if (m_size_total < size_total_new) {
+    // Don't use make_unique here as it value-initializes the elements of the
+    // array, which we have no use for, and can be very slow for large arrays.
+    m_data       = std::unique_ptr<char[]>(new char[size_total_new]);
+    m_size_total = size_total_new;
+  }
+}
+
+void *hpx_thread_buffer::get(std::size_t thread_num) const noexcept {
+  KOKKOS_EXPECTS(thread_num < m_num_threads);
+  if (!m_data) {
+    return nullptr;
+  }
+  return &m_data[thread_num * m_size_per_thread];
+}
+
+void *hpx_thread_buffer::get_extra_space() const noexcept {
+  KOKKOS_EXPECTS(m_extra_space > 0);
+  if (!m_data) {
+    return nullptr;
+  }
+  return &m_data[m_num_threads * m_size_per_thread];
+}
+}  // namespace Impl
+
 namespace Experimental {
 
 bool HPX::m_hpx_initialized = false;
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
 std::atomic<uint32_t> HPX::m_next_instance_id{HPX::impl_default_instance_id() +
                                               1};
 uint32_t HPX::m_active_parallel_region_count{0};
 hpx::spinlock HPX::m_active_parallel_region_count_mutex;
 hpx::condition_variable_any HPX::m_active_parallel_region_count_cond;
 HPX::instance_data HPX::m_default_instance_data;
+
+void HPX::print_configuration(std::ostream &os, const bool) const {
+  os << "Host Parallel Execution Space\n";
+  os << "  KOKKOS_ENABLE_HPX: yes\n";
+  os << "HPX Options:\n";
+#if defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+  os << "  KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH: yes\n";
 #else
-Kokkos::Impl::thread_buffer HPX::m_default_buffer;
+  os << "  KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH: no\n";
 #endif
+  os << "\nHPX Runtime Configuration:\n";
+  os << "Worker threads: " << hpx::get_num_worker_threads() << '\n';
+  os << hpx::complete_version() << '\n';
+  os << hpx::configuration_string() << '\n';
+}
+
+bool &HPX::impl_get_in_parallel() noexcept {
+  static thread_local bool in_parallel = false;
+  return in_parallel;
+}
+
+HPX::impl_in_parallel_scope::impl_in_parallel_scope() noexcept {
+  KOKKOS_EXPECTS(!impl_get_in_parallel());
+  impl_get_in_parallel() = true;
+}
+
+HPX::impl_in_parallel_scope::~impl_in_parallel_scope() noexcept {
+  KOKKOS_EXPECTS(impl_get_in_parallel());
+  impl_get_in_parallel() = false;
+}
+
+HPX::impl_not_in_parallel_scope::impl_not_in_parallel_scope() noexcept {
+  KOKKOS_EXPECTS(impl_get_in_parallel());
+  impl_get_in_parallel() = false;
+}
+
+HPX::impl_not_in_parallel_scope::~impl_not_in_parallel_scope() noexcept {
+  KOKKOS_EXPECTS(!impl_get_in_parallel());
+  impl_get_in_parallel() = true;
+}
+
+void HPX::impl_decrement_active_parallel_region_count() {
+  std::unique_lock<hpx::spinlock> l(m_active_parallel_region_count_mutex);
+  if (--m_active_parallel_region_count == 0) {
+    l.unlock();
+    m_active_parallel_region_count_cond.notify_all();
+  };
+}
+
+void HPX::impl_increment_active_parallel_region_count() {
+  std::unique_lock<hpx::spinlock> l(m_active_parallel_region_count_mutex);
+  ++m_active_parallel_region_count;
+}
+
+void HPX::impl_instance_fence_locked(const std::string &name) const {
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<
+      Kokkos::Experimental::HPX>(
+      name,
+      Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{
+          impl_instance_id()},
+      [&]() {
+        auto &s = impl_get_sender();
+
+        hpx::this_thread::experimental::sync_wait(std::move(s));
+        s = hpx::execution::experimental::unique_any_sender(
+            hpx::execution::experimental::just());
+      });
+}
+
+void HPX::impl_instance_fence(const std::string &name) const {
+  std::lock_guard<hpx::spinlock> l(impl_get_sender_mutex());
+  impl_instance_fence_locked(name);
+}
+
+void HPX::impl_static_fence(const std::string &name) {
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<
+      Kokkos::Experimental::HPX>(
+      name,
+      Kokkos::Tools::Experimental::SpecialSynchronizationCases::
+          GlobalDeviceSynchronization,
+      [&]() {
+        auto &s = HPX().impl_get_sender();
+
+        std::unique_lock<hpx::spinlock> l(HPX().impl_get_sender_mutex());
+
+        // This is a loose fence. Any work scheduled before this will be waited
+        // for, but work scheduled while waiting may also be waited for.
+        {
+          std::unique_lock<hpx::spinlock> l_count(
+              m_active_parallel_region_count_mutex);
+          m_active_parallel_region_count_cond.wait(
+              l_count, [&]() { return m_active_parallel_region_count == 0; });
+        }
 
+        hpx::this_thread::experimental::sync_wait(std::move(s));
+        s = hpx::execution::experimental::unique_any_sender(
+            hpx::execution::experimental::just());
+      });
+}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 int HPX::concurrency() {
+#else
+int HPX::concurrency() const {
+#endif
   hpx::runtime *rt = hpx::get_runtime_ptr();
   if (rt == nullptr) {
     return hpx::threads::hardware_concurrency();
@@ -96,7 +235,11 @@ void HPX::impl_finalize() {
   if (m_hpx_initialized) {
     hpx::runtime *rt = hpx::get_runtime_ptr();
     if (rt != nullptr) {
+#if HPX_VERSION_FULL >= 0x010900
+      hpx::post([]() { hpx::local::finalize(); });
+#else
       hpx::apply([]() { hpx::local::finalize(); });
+#endif
       hpx::local::stop();
     } else {
       Kokkos::abort(
@@ -106,10 +249,78 @@ void HPX::impl_finalize() {
   }
 }
 
+int HPX::impl_thread_pool_size() noexcept {
+  hpx::runtime *rt = hpx::get_runtime_ptr();
+  if (rt == nullptr) {
+    return 0;
+  } else {
+    if (hpx::threads::get_self_ptr() == nullptr) {
+      return hpx::resource::get_thread_pool(0).get_os_thread_count();
+    } else {
+      return hpx::this_thread::get_pool()->get_os_thread_count();
+    }
+  }
+}
+
+int HPX::impl_thread_pool_rank() noexcept {
+  hpx::runtime *rt = hpx::get_runtime_ptr();
+  if (rt == nullptr) {
+    return 0;
+  } else {
+    if (hpx::threads::get_self_ptr() == nullptr) {
+      return 0;
+    } else {
+      return hpx::this_thread::get_pool()->get_pool_index();
+    }
+  }
+}
+
+int HPX::impl_thread_pool_size(int depth) {
+  if (depth == 0) {
+    return impl_thread_pool_size();
+  } else {
+    return 1;
+  }
+}
+
+template void HPX::impl_bulk_plain_erased<int>(
+    bool, bool, std::function<void(int)> &&, int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_plain_erased<unsigned int>(
+    bool, bool, std::function<void(unsigned int)> &&, unsigned int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_plain_erased<long>(
+    bool, bool, std::function<void(long)> &&, long const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_plain_erased<std::size_t>(
+    bool, bool, std::function<void(std::size_t)> &&, std::size_t const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_setup_finalize_erased<int>(
+    bool, bool, std::function<void(int)> &&, std::function<void()> &&,
+    std::function<void()> &&, int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_setup_finalize_erased<unsigned int>(
+    bool, bool, std::function<void(unsigned int)> &&, std::function<void()> &&,
+    std::function<void()> &&, unsigned int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_setup_finalize_erased<long>(
+    bool, bool, std::function<void(long)> &&, std::function<void()> &&,
+    std::function<void()> &&, long const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+template void HPX::impl_bulk_setup_finalize_erased<std::size_t>(
+    bool, bool, std::function<void(std::size_t)> &&, std::function<void()> &&,
+    std::function<void()> &&, std::size_t const,
+    hpx::threads::thread_stacksize stacksize) const;
 }  // namespace Experimental
 
 namespace Impl {
-
 int g_hpx_space_factory_initialized =
     initialize_space_factory<Kokkos::Experimental::HPX>("060_HPX");
 
diff --git a/core/src/HPX/Kokkos_HPX.hpp b/core/src/HPX/Kokkos_HPX.hpp
new file mode 100644
index 0000000000..89117a42bd
--- /dev/null
+++ b/core/src/HPX/Kokkos_HPX.hpp
@@ -0,0 +1,1943 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
+#include <Kokkos_Macros.hpp>
+static_assert(false,
+              "Including non-public Kokkos header files is not allowed.");
+#endif
+#ifndef KOKKOS_HPX_HPP
+#define KOKKOS_HPX_HPP
+
+#include <Kokkos_Macros.hpp>
+#if defined(KOKKOS_ENABLE_HPX)
+
+#include <Kokkos_Core_fwd.hpp>
+
+#include <Kokkos_HostSpace.hpp>
+#include <cstddef>
+#include <iosfwd>
+
+#ifdef KOKKOS_ENABLE_HBWSPACE
+#include <Kokkos_HBWSpace.hpp>
+#endif
+
+#include <Kokkos_HostSpace.hpp>
+#include <Kokkos_Layout.hpp>
+#include <Kokkos_MemoryTraits.hpp>
+#include <Kokkos_Parallel.hpp>
+#include <Kokkos_ScratchSpace.hpp>
+#include <Kokkos_TaskScheduler.hpp>
+#include <impl/Kokkos_ConcurrentBitset.hpp>
+#include <impl/Kokkos_FunctorAnalysis.hpp>
+#include <impl/Kokkos_HostSharedPtr.hpp>
+#include <impl/Kokkos_Tools.hpp>
+#include <impl/Kokkos_TaskQueue.hpp>
+#include <impl/Kokkos_InitializationSettings.hpp>
+
+#include <KokkosExp_MDRangePolicy.hpp>
+
+#include <hpx/local/barrier.hpp>
+#include <hpx/local/condition_variable.hpp>
+#include <hpx/local/execution.hpp>
+#include <hpx/local/future.hpp>
+#include <hpx/local/mutex.hpp>
+#include <hpx/local/thread.hpp>
+
+#include <Kokkos_UniqueToken.hpp>
+
+#include <iosfwd>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+namespace Kokkos {
+namespace Impl {
+class hpx_thread_buffer {
+  static constexpr std::size_t m_cache_line_size = 64;
+
+  std::size_t m_num_threads      = 0;
+  std::size_t m_size_per_thread  = 0;
+  std::size_t m_extra_space      = 0;
+  std::size_t m_size_total       = 0;
+  std::unique_ptr<char[]> m_data = nullptr;
+
+  static constexpr void pad_to_cache_line(std::size_t &size) {
+    size = ((size + m_cache_line_size - 1) / m_cache_line_size) *
+           m_cache_line_size;
+  }
+
+ public:
+  hpx_thread_buffer()                          = default;
+  ~hpx_thread_buffer()                         = default;
+  hpx_thread_buffer(const hpx_thread_buffer &) = delete;
+  hpx_thread_buffer(hpx_thread_buffer &&)      = delete;
+  hpx_thread_buffer &operator=(const hpx_thread_buffer &) = delete;
+  hpx_thread_buffer &operator=(hpx_thread_buffer) = delete;
+
+  void resize(const std::size_t num_threads, const std::size_t size_per_thread,
+              const std::size_t extra_space = 0) noexcept;
+  void *get(std::size_t thread_num) const noexcept;
+  void *get_extra_space() const noexcept;
+};
+
+template <typename T>
+struct hpx_range {
+  T begin;
+  T end;
+};
+
+template <typename T>
+constexpr T get_num_chunks(const T offset, const T chunk_size, const T max) {
+  return (max - offset + chunk_size - 1) / chunk_size;
+}
+
+template <typename T>
+constexpr hpx_range<T> get_chunk_range(const T i_chunk, const T offset,
+                                       const T chunk_size, const T max) {
+  const T begin = offset + i_chunk * chunk_size;
+  const T end   = (std::min)(begin + chunk_size, max);
+  return {begin, end};
+}
+
+template <typename Policy>
+constexpr bool is_light_weight_policy() {
+  constexpr Kokkos::Experimental::WorkItemProperty::HintLightWeight_t
+      light_weight = Kokkos::Experimental::WorkItemProperty::HintLightWeight;
+  return (typename Policy::work_item_property() & light_weight) == light_weight;
+}
+}  // namespace Impl
+
+namespace Experimental {
+class HPX {
+ public:
+  static constexpr uint32_t impl_default_instance_id() { return 1; }
+
+ private:
+  static bool m_hpx_initialized;
+  static std::atomic<uint32_t> m_next_instance_id;
+
+ public:
+  enum class instance_mode { default_, independent };
+
+ private:
+  static uint32_t m_active_parallel_region_count;
+  static hpx::spinlock m_active_parallel_region_count_mutex;
+  static hpx::condition_variable_any m_active_parallel_region_count_cond;
+
+  struct instance_data {
+    instance_data()  = default;
+    ~instance_data() = default;
+    instance_data(uint32_t instance_id) : m_instance_id(instance_id) {}
+    instance_data(uint32_t instance_id,
+                  hpx::execution::experimental::unique_any_sender<> &&sender)
+        : m_instance_id(instance_id), m_sender{std::move(sender)} {}
+
+    instance_data(const instance_data &) = delete;
+    instance_data(instance_data &&)      = delete;
+    instance_data &operator=(const instance_data &) = delete;
+    instance_data &operator=(instance_data) = delete;
+
+    uint32_t m_instance_id{HPX::impl_default_instance_id()};
+    hpx::execution::experimental::unique_any_sender<> m_sender{
+        hpx::execution::experimental::just()};
+    Kokkos::Impl::hpx_thread_buffer m_buffer;
+    hpx::spinlock m_sender_mutex;
+  };
+
+  static void default_instance_deleter(instance_data *) {}
+  static instance_data m_default_instance_data;
+  Kokkos::Impl::HostSharedPtr<instance_data> m_instance_data;
+
+ public:
+  using execution_space      = HPX;
+  using memory_space         = HostSpace;
+  using device_type          = Kokkos::Device<execution_space, memory_space>;
+  using array_layout         = LayoutRight;
+  using size_type            = memory_space::size_type;
+  using scratch_memory_space = ScratchMemorySpace<HPX>;
+
+  HPX()
+      : m_instance_data(Kokkos::Impl::HostSharedPtr<instance_data>(
+            &m_default_instance_data, &default_instance_deleter)) {}
+  ~HPX() = default;
+  HPX(instance_mode mode)
+      : m_instance_data(
+            mode == instance_mode::independent
+                ? (Kokkos::Impl::HostSharedPtr<instance_data>(
+                      new instance_data(m_next_instance_id++)))
+                : Kokkos::Impl::HostSharedPtr<instance_data>(
+                      &m_default_instance_data, &default_instance_deleter)) {}
+  HPX(hpx::execution::experimental::unique_any_sender<> &&sender)
+      : m_instance_data(Kokkos::Impl::HostSharedPtr<instance_data>(
+            new instance_data(m_next_instance_id++, std::move(sender)))) {}
+
+  HPX(HPX &&other)      = default;
+  HPX(const HPX &other) = default;
+
+  HPX &operator=(HPX &&) = default;
+  HPX &operator=(const HPX &) = default;
+
+  void print_configuration(std::ostream &os, bool /*verbose*/ = false) const;
+  instance_data &impl_get_instance_data() const noexcept {
+    KOKKOS_EXPECTS(m_instance_data.get());
+    return *m_instance_data.get();
+  }
+  uint32_t impl_instance_id() const noexcept {
+    return impl_get_instance_data().m_instance_id;
+  }
+
+  static bool &impl_get_in_parallel() noexcept;
+
+  struct impl_in_parallel_scope {
+    impl_in_parallel_scope() noexcept;
+    ~impl_in_parallel_scope() noexcept;
+    impl_in_parallel_scope(impl_in_parallel_scope &&)      = delete;
+    impl_in_parallel_scope(impl_in_parallel_scope const &) = delete;
+    impl_in_parallel_scope &operator=(impl_in_parallel_scope &&) = delete;
+    impl_in_parallel_scope &operator=(impl_in_parallel_scope const &) = delete;
+  };
+
+  struct impl_not_in_parallel_scope {
+    impl_not_in_parallel_scope() noexcept;
+    ~impl_not_in_parallel_scope() noexcept;
+    impl_not_in_parallel_scope(impl_not_in_parallel_scope &&)      = delete;
+    impl_not_in_parallel_scope(impl_not_in_parallel_scope const &) = delete;
+    impl_not_in_parallel_scope &operator=(impl_not_in_parallel_scope &&) =
+        delete;
+    impl_not_in_parallel_scope &operator=(impl_not_in_parallel_scope const &) =
+        delete;
+  };
+
+  static bool in_parallel(HPX const & = HPX()) noexcept {
+    return impl_get_in_parallel();
+  }
+
+  static void impl_decrement_active_parallel_region_count();
+  static void impl_increment_active_parallel_region_count();
+
+  void impl_instance_fence_locked(const std::string &name) const;
+  void impl_instance_fence(const std::string &name) const;
+  static void impl_static_fence(const std::string &name);
+
+  void fence(
+      const std::string &name =
+          "Kokkos::Experimental::HPX::fence: Unnamed Instance Fence") const {
+    impl_instance_fence(name);
+  }
+
+  static bool is_asynchronous(HPX const & = HPX()) noexcept {
+#if defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+    return true;
+#else
+    return false;
+#endif
+  }
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
+  template <typename F>
+  KOKKOS_DEPRECATED static void partition_master(
+      F const &, int requested_num_partitions = 0, int = 0) {
+    if (requested_num_partitions > 1) {
+      Kokkos::abort(
+          "Kokkos::Experimental::HPX::partition_master: can't partition an "
+          "HPX instance\n");
+    }
+  }
+#endif
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  static int concurrency();
+#else
+  int concurrency() const;
+#endif
+  static void impl_initialize(InitializationSettings const &);
+  static bool impl_is_initialized() noexcept;
+  static void impl_finalize();
+  static int impl_thread_pool_size() noexcept;
+  static int impl_thread_pool_rank() noexcept;
+  static int impl_thread_pool_size(int depth);
+
+  static int impl_max_hardware_threads() noexcept {
+    return hpx::threads::hardware_concurrency();
+  }
+
+  static int impl_hardware_thread_id() noexcept {
+    return hpx::get_worker_thread_num();
+  }
+
+  Kokkos::Impl::hpx_thread_buffer &impl_get_buffer() const noexcept {
+    return impl_get_instance_data().m_buffer;
+  }
+
+  hpx::execution::experimental::unique_any_sender<> &impl_get_sender() const
+      noexcept {
+    return impl_get_instance_data().m_sender;
+  }
+
+  hpx::execution::experimental::any_sender<> get_sender() const noexcept {
+    std::lock_guard l(impl_get_sender_mutex());
+    auto &s      = impl_get_sender();
+    auto split_s = hpx::execution::experimental::split(std::move(s));
+    s            = split_s;
+    return hpx::execution::experimental::any_sender<>{split_s};
+  }
+
+  hpx::future<void> impl_get_future() const noexcept {
+    return hpx::execution::experimental::make_future(get_sender());
+  }
+
+  hpx::spinlock &impl_get_sender_mutex() const noexcept {
+    return impl_get_instance_data().m_sender_mutex;
+  }
+
+  template <typename I>
+  void impl_bulk_plain_erased(
+      [[maybe_unused]] bool force_synchronous, bool is_light_weight_policy,
+      std::function<void(I)> &&f, I const n,
+      hpx::threads::thread_stacksize stacksize =
+          hpx::threads::thread_stacksize::default_) const {
+    Kokkos::Experimental::HPX::impl_increment_active_parallel_region_count();
+
+    namespace ex = hpx::execution::experimental;
+
+    auto &sen = impl_get_sender();
+    auto &mut = impl_get_sender_mutex();
+
+    std::lock_guard<hpx::spinlock> l(mut);
+    hpx::util::ignore_lock(&mut);
+
+    {
+      if (n == 1 && is_light_weight_policy &&
+          (hpx::threads::get_self_ptr() != nullptr)) {
+        sen = std::move(sen) | ex::then(hpx::bind_front(std::move(f), 0)) |
+              ex::then(Kokkos::Experimental::HPX::
+                           impl_decrement_active_parallel_region_count) |
+              ex::ensure_started();
+      } else {
+        sen = std::move(sen) |
+              ex::transfer(
+                  ex::with_stacksize(ex::thread_pool_scheduler{}, stacksize)) |
+              ex::bulk(n, std::move(f)) |
+              ex::then(Kokkos::Experimental::HPX::
+                           impl_decrement_active_parallel_region_count) |
+              ex::ensure_started();
+      }
+    }
+
+#if defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+    if (force_synchronous)
+#endif
+    {
+      impl_instance_fence_locked(
+          "Kokkos::Experimental::HPX: fence due to forced synchronizations");
+    }
+  }
+
+  template <typename Functor, typename Index>
+  void impl_bulk_plain(bool force_synchronous, bool is_light_weight_policy,
+                       Functor const &functor, Index const n,
+                       hpx::threads::thread_stacksize stacksize =
+                           hpx::threads::thread_stacksize::default_) const {
+    impl_bulk_plain_erased(force_synchronous, is_light_weight_policy,
+                           {[functor](Index i) {
+                             impl_in_parallel_scope p;
+                             functor.execute_range(i);
+                           }},
+                           n, stacksize);
+  }
+
+  template <typename Index>
+  void impl_bulk_setup_finalize_erased(
+      [[maybe_unused]] bool force_synchronous, bool is_light_weight_policy,
+      std::function<void(Index)> &&f, std::function<void()> &&f_setup,
+      std::function<void()> &&f_finalize, Index const n,
+      hpx::threads::thread_stacksize stacksize =
+          hpx::threads::thread_stacksize::default_) const {
+    Kokkos::Experimental::HPX::impl_increment_active_parallel_region_count();
+
+    namespace ex = hpx::execution::experimental;
+    using hpx::threads::thread_stacksize;
+
+    auto &sen = impl_get_sender();
+    auto &mut = impl_get_sender_mutex();
+
+    std::lock_guard<hpx::spinlock> l(mut);
+    hpx::util::ignore_lock(&mut);
+
+    {
+      if (n == 1 && is_light_weight_policy &&
+          (hpx::threads::get_self_ptr() != nullptr)) {
+        sen = std::move(sen) | ex::then(std::move(f_setup)) |
+              ex::then(hpx::bind_front(std::move(f), 0)) |
+              ex::then(std::move(f_finalize)) |
+              ex::then(Kokkos::Experimental::HPX::
+                           impl_decrement_active_parallel_region_count) |
+              ex::ensure_started();
+      } else {
+        sen = std::move(sen) |
+              ex::transfer(
+                  ex::with_stacksize(ex::thread_pool_scheduler{}, stacksize)) |
+              ex::then(std::move(f_setup)) | ex::bulk(n, std::move(f)) |
+              ex::then(std::move(f_finalize)) |
+              ex::then(Kokkos::Experimental::HPX::
+                           impl_decrement_active_parallel_region_count) |
+              ex::ensure_started();
+      }
+    }
+
+#if defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+    if (force_synchronous)
+#endif
+    {
+      impl_instance_fence_locked(
+          "Kokkos::Experimental::HPX: fence due to forced syncronizations");
+    }
+  }
+
+  template <typename Functor, typename Index>
+  void impl_bulk_setup_finalize(
+      bool force_synchronous, bool is_light_weight_policy,
+      Functor const &functor, Index const n,
+      hpx::threads::thread_stacksize stacksize =
+          hpx::threads::thread_stacksize::default_) const {
+    impl_bulk_setup_finalize_erased(force_synchronous, is_light_weight_policy,
+                                    {[functor](Index i) {
+                                      impl_in_parallel_scope p;
+                                      functor.execute_range(i);
+                                    }},
+                                    {[functor]() {
+                                      impl_in_parallel_scope p;
+                                      functor.setup();
+                                    }},
+                                    {[functor]() {
+                                      impl_in_parallel_scope p;
+                                      functor.finalize();
+                                    }},
+                                    n, stacksize);
+  }
+
+  static constexpr const char *name() noexcept { return "HPX"; }
+
+ private:
+  friend bool operator==(HPX const &lhs, HPX const &rhs) {
+    return lhs.impl_instance_id() == rhs.impl_instance_id();
+  }
+  friend bool operator!=(HPX const &lhs, HPX const &rhs) {
+    return !(lhs == rhs);
+  }
+};
+
+extern template void HPX::impl_bulk_plain_erased<int>(
+    bool, bool, std::function<void(int)> &&, int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_plain_erased<unsigned int>(
+    bool, bool, std::function<void(unsigned int)> &&, unsigned int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_plain_erased<long>(
+    bool, bool, std::function<void(long)> &&, long const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_plain_erased<std::size_t>(
+    bool, bool, std::function<void(std::size_t)> &&, std::size_t const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_setup_finalize_erased<int>(
+    bool, bool, std::function<void(int)> &&, std::function<void()> &&,
+    std::function<void()> &&, int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_setup_finalize_erased<unsigned int>(
+    bool, bool, std::function<void(unsigned int)> &&, std::function<void()> &&,
+    std::function<void()> &&, unsigned int const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_setup_finalize_erased<long>(
+    bool, bool, std::function<void(long)> &&, std::function<void()> &&,
+    std::function<void()> &&, long const,
+    hpx::threads::thread_stacksize stacksize) const;
+
+extern template void HPX::impl_bulk_setup_finalize_erased<std::size_t>(
+    bool, bool, std::function<void(std::size_t)> &&, std::function<void()> &&,
+    std::function<void()> &&, std::size_t const,
+    hpx::threads::thread_stacksize stacksize) const;
+}  // namespace Experimental
+
+namespace Tools {
+namespace Experimental {
+template <>
+struct DeviceTypeTraits<Kokkos::Experimental::HPX> {
+  static constexpr DeviceType id = DeviceType::HPX;
+  static int device_id(const Kokkos::Experimental::HPX &) { return 0; }
+};
+}  // namespace Experimental
+}  // namespace Tools
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Impl {
+template <>
+struct MemorySpaceAccess<Kokkos::Experimental::HPX::memory_space,
+                         Kokkos::Experimental::HPX::scratch_memory_space> {
+  enum : bool { assignable = false };
+  enum : bool { accessible = true };
+  enum : bool { deepcopy = false };
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Experimental {
+template <>
+class UniqueToken<HPX, UniqueTokenScope::Instance> {
+ private:
+  using buffer_type = Kokkos::View<uint32_t *, Kokkos::HostSpace>;
+  int m_count;
+  buffer_type m_buffer_view;
+  uint32_t volatile *m_buffer;
+
+ public:
+  using execution_space = HPX;
+  using size_type       = int;
+
+  /// \brief create object size for concurrency on the given instance
+  ///
+  /// This object should not be shared between instances
+  UniqueToken(execution_space const & = execution_space()) noexcept
+      : m_count(execution_space::impl_max_hardware_threads()),
+        m_buffer_view(buffer_type()),
+        m_buffer(nullptr) {}
+
+  UniqueToken(size_type max_size, execution_space const & = execution_space())
+      : m_count(max_size > execution_space::impl_max_hardware_threads()
+                    ? execution_space::impl_max_hardware_threads()
+                    : max_size),
+        m_buffer_view(
+            max_size > execution_space::impl_max_hardware_threads()
+                ? buffer_type()
+                : buffer_type("UniqueToken::m_buffer_view",
+                              ::Kokkos::Impl::concurrent_bitset::buffer_bound(
+                                  m_count))),
+        m_buffer(m_buffer_view.data()) {}
+
+  /// \brief upper bound for acquired values, i.e. 0 <= value < size()
+  KOKKOS_INLINE_FUNCTION
+  int size() const noexcept { return m_count; }
+
+  /// \brief acquire value such that 0 <= value < size()
+  KOKKOS_INLINE_FUNCTION
+  int acquire() const noexcept {
+    KOKKOS_IF_ON_HOST((
+        if (m_buffer == nullptr) {
+          return execution_space::impl_hardware_thread_id();
+        } else {
+          const ::Kokkos::pair<int, int> result =
+              ::Kokkos::Impl::concurrent_bitset::acquire_bounded(
+                  m_buffer, m_count, ::Kokkos::Impl::clock_tic() % m_count);
+
+          if (result.first < 0) {
+            ::Kokkos::abort(
+                "UniqueToken<HPX> failure to acquire tokens, no tokens "
+                "available");
+          }
+          return result.first;
+        }))
+
+    KOKKOS_IF_ON_DEVICE((return 0;))
+  }
+
+  /// \brief release a value acquired by generate
+  KOKKOS_INLINE_FUNCTION
+  void release(int i) const noexcept {
+    KOKKOS_IF_ON_HOST((if (m_buffer != nullptr) {
+      ::Kokkos::Impl::concurrent_bitset::release(m_buffer, i);
+    }))
+
+    KOKKOS_IF_ON_DEVICE(((void)i;))
+  }
+};
+
+template <>
+class UniqueToken<HPX, UniqueTokenScope::Global> {
+ public:
+  using execution_space = HPX;
+  using size_type       = int;
+  UniqueToken(execution_space const & = execution_space()) noexcept {}
+
+  // NOTE: Currently this assumes that there is no oversubscription.
+  // hpx::get_num_worker_threads can't be used directly because it may yield
+  // it's task (problematic if called after hpx::get_worker_thread_num).
+  int size() const noexcept { return HPX::impl_max_hardware_threads(); }
+  int acquire() const noexcept { return HPX::impl_hardware_thread_id(); }
+  void release(int) const noexcept {}
+};
+}  // namespace Experimental
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Impl {
+
+struct HPXTeamMember {
+ public:
+  using execution_space = Kokkos::Experimental::HPX;
+  using scratch_memory_space =
+      Kokkos::ScratchMemorySpace<Kokkos::Experimental::HPX>;
+  using team_handle = HPXTeamMember;
+
+ private:
+  scratch_memory_space m_team_shared;
+
+  int m_league_size;
+  int m_league_rank;
+  int m_team_size;
+  int m_team_rank;
+
+ public:
+  KOKKOS_INLINE_FUNCTION
+  const scratch_memory_space &team_shmem() const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space &team_scratch(const int) const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space &thread_scratch(const int) const {
+    return m_team_shared.set_team_thread_mode(0, team_size(), team_rank());
+  }
+
+  KOKKOS_INLINE_FUNCTION int league_rank() const noexcept {
+    return m_league_rank;
+  }
+
+  KOKKOS_INLINE_FUNCTION int league_size() const noexcept {
+    return m_league_size;
+  }
+
+  KOKKOS_INLINE_FUNCTION int team_rank() const noexcept { return m_team_rank; }
+  KOKKOS_INLINE_FUNCTION int team_size() const noexcept { return m_team_size; }
+
+  template <class... Properties>
+  constexpr KOKKOS_INLINE_FUNCTION HPXTeamMember(
+      const TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>
+          &policy,
+      const int team_rank, const int league_rank, void *scratch,
+      size_t scratch_size) noexcept
+      : m_team_shared(scratch, scratch_size, scratch, scratch_size),
+        m_league_size(policy.league_size()),
+        m_league_rank(league_rank),
+        m_team_size(policy.team_size()),
+        m_team_rank(team_rank) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void team_barrier() const {}
+
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType &, const int &) const {}
+
+  template <class Closure, class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(const Closure &closure,
+                                             ValueType &value,
+                                             const int &) const {
+    closure(value);
+  }
+
+  template <class ValueType, class JoinOp>
+  KOKKOS_INLINE_FUNCTION ValueType team_reduce(const ValueType &value,
+                                               const JoinOp &) const {
+    return value;
+  }
+
+  template <class ReducerType>
+  KOKKOS_INLINE_FUNCTION std::enable_if_t<is_reducer<ReducerType>::value>
+  team_reduce(const ReducerType &) const {}
+
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type
+  team_scan(const Type &value, Type *const global_accum = nullptr) const {
+    if (global_accum) {
+      Kokkos::atomic_fetch_add(global_accum, value);
+    }
+
+    return 0;
+  }
+};
+
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
+  using traits = PolicyTraits<Properties...>;
+
+  //! Tag this class as a kokkos execution policy
+  using execution_policy = TeamPolicyInternal;
+
+  using member_type = HPXTeamMember;
+
+  //! Execution space of this execution policy:
+  using execution_space = Kokkos::Experimental::HPX;
+
+ private:
+  typename traits::execution_space m_space{};
+  int m_league_size;
+  int m_team_size;
+  std::size_t m_team_scratch_size[2];
+  std::size_t m_thread_scratch_size[2];
+  int m_chunk_size;
+
+ public:
+  // NOTE: Max size is 1 for simplicity. In most cases more than 1 is not
+  // necessary on CPU. Implement later if there is a need.
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType &) {
+    return 1;
+  }
+
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType &) {
+    return 1;
+  }
+
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType &, const int &) {
+    return 1;
+  }
+
+  template <class FunctorType>
+  int team_size_max(const FunctorType &, const ParallelForTag &) const {
+    return 1;
+  }
+
+  template <class FunctorType>
+  int team_size_max(const FunctorType &, const ParallelReduceTag &) const {
+    return 1;
+  }
+
+  template <class FunctorType, class ReducerType>
+  int team_size_max(const FunctorType &, const ReducerType &,
+                    const ParallelReduceTag &) const {
+    return 1;
+  }
+
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType &, const ParallelForTag &) const {
+    return 1;
+  }
+
+  template <class FunctorType>
+  int team_size_recommended(const FunctorType &,
+                            const ParallelReduceTag &) const {
+    return 1;
+  }
+
+  template <class FunctorType, class ReducerType>
+  int team_size_recommended(const FunctorType &, const ReducerType &,
+                            const ParallelReduceTag &) const {
+    return 1;
+  }
+
+  static int vector_length_max() { return 1; }
+
+  inline int impl_vector_length() noexcept { return 1; }
+  inline bool impl_auto_team_size() noexcept { return false; }
+  inline bool impl_auto_vector_length() noexcept { return false; }
+  inline void impl_set_vector_length(int) noexcept {}
+  inline void impl_set_team_size(int) noexcept {}
+
+ private:
+  inline void init(const int league_size_request, const int team_size_request) {
+    m_league_size           = league_size_request;
+    const int max_team_size = 1;  // TODO: Can't use team_size_max(...) because
+                                  // it requires a functor as argument.
+    m_team_size =
+        team_size_request > max_team_size ? max_team_size : team_size_request;
+
+    if (m_chunk_size > 0) {
+      if (!Impl::is_integral_power_of_two(m_chunk_size))
+        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
+    } else {
+      int new_chunk_size = 1;
+      while (new_chunk_size * 4 * m_space.concurrency() < m_league_size) {
+        new_chunk_size *= 2;
+      }
+
+      if (new_chunk_size < 128) {
+        new_chunk_size = 1;
+        while ((new_chunk_size * m_space.concurrency() < m_league_size) &&
+               (new_chunk_size < 128))
+          new_chunk_size *= 2;
+      }
+
+      m_chunk_size = new_chunk_size;
+    }
+  }
+
+ public:
+  inline int team_size() const { return m_team_size; }
+  inline int league_size() const { return m_league_size; }
+
+  size_t scratch_size(const int &level, int team_size_ = -1) const {
+    if (team_size_ < 0) {
+      team_size_ = m_team_size;
+    }
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
+  }
+
+  inline static int scratch_size_max(int level) {
+    return (level == 0 ? 1024 * 32 :  // Roughly L1 size
+                20 * 1024 * 1024);    // Limit to keep compatibility with CUDA
+  }
+
+ public:
+  template <class ExecSpace, class... OtherProperties>
+  friend class TeamPolicyInternal;
+
+  const typename traits::execution_space &space() const { return m_space; }
+
+  template <class... OtherProperties>
+  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Experimental::HPX,
+                                              OtherProperties...> &p) {
+    m_space                  = p.m_space;
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
+    m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
+    m_chunk_size             = p.m_chunk_size;
+  }
+
+  TeamPolicyInternal(const typename traits::execution_space &space,
+                     int league_size_request, int team_size_request,
+                     int /* vector_length_request */ = 1)
+      : m_space{space},
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(const typename traits::execution_space &space,
+                     int league_size_request, const Kokkos::AUTO_t &,
+                     int /* vector_length_request */ = 1)
+      : m_space{space},
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, 1);
+  }
+
+  TeamPolicyInternal(const typename traits::execution_space &space,
+                     int league_size_request,
+                     const Kokkos::AUTO_t &, /* team_size_request */
+                     const Kokkos::AUTO_t & /* vector_length_request */)
+      : m_space{space},
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, 1);
+  }
+
+  TeamPolicyInternal(const typename traits::execution_space &space,
+                     int league_size_request, int team_size_request,
+                     const Kokkos::AUTO_t & /* vector_length_request */
+                     )
+      : m_space{space},
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t &, /* team_size_request */
+                     const Kokkos::AUTO_t & /* vector_length_request */)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, 1);
+  }
+
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     const Kokkos::AUTO_t & /* vector_length_request */
+                     )
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request);
+  }
+
+  TeamPolicyInternal(int league_size_request, const Kokkos::AUTO_t &,
+                     int /* vector_length_request */ = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(0) {
+    init(league_size_request, 1);
+  }
+
+  inline int chunk_size() const { return m_chunk_size; }
+
+  inline TeamPolicyInternal &set_chunk_size(
+      typename traits::index_type chunk_size_) {
+    m_chunk_size = chunk_size_;
+    return *this;
+  }
+
+  inline TeamPolicyInternal &set_scratch_size(const int &level,
+                                              const PerTeamValue &per_team) {
+    m_team_scratch_size[level] = per_team.value;
+    return *this;
+  }
+
+  inline TeamPolicyInternal &set_scratch_size(
+      const int &level, const PerThreadValue &per_thread) {
+    m_thread_scratch_size[level] = per_thread.value;
+    return *this;
+  }
+
+  inline TeamPolicyInternal &set_scratch_size(
+      const int &level, const PerTeamValue &per_team,
+      const PerThreadValue &per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
+    m_thread_scratch_size[level] = per_thread.value;
+    return *this;
+  }
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Experimental::HPX> {
+ private:
+  using Policy  = Kokkos::RangePolicy<Traits...>;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+ public:
+  void execute_range(const Member i_chunk) const {
+    const auto r = get_chunk_range(i_chunk, m_policy.begin(),
+                                   m_policy.chunk_size(), m_policy.end());
+    for (Member i = r.begin; i < r.end; ++i) {
+      if constexpr (std::is_same_v<WorkTag, void>) {
+        m_functor(i);
+      } else {
+        m_functor(WorkTag{}, i);
+      }
+    }
+  }
+
+  void execute() const {
+    const Member num_chunks =
+        get_num_chunks(m_policy.begin(), m_policy.chunk_size(), m_policy.end());
+    m_policy.space().impl_bulk_plain(false, is_light_weight_policy<Policy>(),
+                                     *this, num_chunks,
+                                     hpx::threads::thread_stacksize::nostack);
+  }
+
+  inline ParallelFor(const FunctorType &arg_functor, Policy arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+};
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::Experimental::HPX> {
+ private:
+  using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
+  using Policy        = typename MDRangePolicy::impl_range_policy;
+  using WorkTag       = typename MDRangePolicy::work_tag;
+  using Member        = typename Policy::member_type;
+  using iterate_type =
+      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
+                                             WorkTag, void>;
+
+  const iterate_type m_iter;
+  const Policy m_policy;
+
+ public:
+  void execute_range(const Member i_chunk) const {
+    const auto r = get_chunk_range(i_chunk, m_policy.begin(),
+                                   m_policy.chunk_size(), m_policy.end());
+    for (Member i = r.begin; i < r.end; ++i) {
+      m_iter(i);
+    }
+  }
+
+  void execute() const {
+    const Member num_chunks =
+        get_num_chunks(m_policy.begin(), m_policy.chunk_size(), m_policy.end());
+    m_iter.m_rp.space().impl_bulk_plain(
+        false, is_light_weight_policy<MDRangePolicy>(), *this, num_chunks,
+        hpx::threads::thread_stacksize::nostack);
+  }
+
+  inline ParallelFor(const FunctorType &arg_functor, MDRangePolicy arg_policy)
+      : m_iter(arg_policy, arg_functor),
+        m_policy(Policy(0, arg_policy.m_num_tiles).set_chunk_size(1)) {}
+  template <typename Policy, typename Functor>
+  static int max_tile_size_product(const Policy &, const Functor &) {
+    /**
+     * 1024 here is just our guess for a reasonable max tile size,
+     * it isn't a hardware constraint. If people see a use for larger
+     * tile size products, we're happy to change this.
+     */
+    return 1024;
+  }
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Impl {
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
+                     Kokkos::Experimental::HPX> {
+ private:
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+
+  using value_type     = typename ReducerType::value_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+
+  const CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const bool m_force_synchronous;
+
+ public:
+  void setup() const {
+    const ReducerType &reducer   = m_functor_reducer.get_reducer();
+    const std::size_t value_size = reducer.value_size();
+    const int num_worker_threads = m_policy.space().concurrency();
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    buffer.resize(num_worker_threads, value_size);
+
+    for (int t = 0; t < num_worker_threads; ++t) {
+      reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
+    }
+  }
+
+  void execute_range(const Member i_chunk) const {
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    reference_type update =
+        ReducerType::reference(reinterpret_cast<pointer_type>(
+            buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id())));
+    const auto r = get_chunk_range(i_chunk, m_policy.begin(),
+                                   m_policy.chunk_size(), m_policy.end());
+    for (Member i = r.begin; i < r.end; ++i) {
+      if constexpr (std::is_same_v<WorkTag, void>) {
+        m_functor_reducer.get_functor()(i, update);
+      } else {
+        m_functor_reducer.get_functor()(WorkTag{}, i, update);
+      }
+    }
+  }
+
+  void finalize() const {
+    hpx_thread_buffer &buffer    = m_policy.space().impl_get_buffer();
+    const ReducerType &reducer   = m_functor_reducer.get_reducer();
+    const int num_worker_threads = m_policy.space().concurrency();
+    for (int i = 1; i < num_worker_threads; ++i) {
+      reducer.join(reinterpret_cast<pointer_type>(buffer.get(0)),
+                   reinterpret_cast<pointer_type>(buffer.get(i)));
+    }
+
+    pointer_type final_value_ptr =
+        reinterpret_cast<pointer_type>(buffer.get(0));
+
+    reducer.final(final_value_ptr);
+
+    if (m_result_ptr != nullptr) {
+      const int n = reducer.value_count();
+
+      for (int j = 0; j < n; ++j) {
+        m_result_ptr[j] = final_value_ptr[j];
+      }
+    }
+  }
+
+  void execute() const {
+    if (m_policy.end() <= m_policy.begin()) {
+      if (m_result_ptr) {
+        const ReducerType &reducer = m_functor_reducer.get_reducer();
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
+      }
+      return;
+    }
+
+    const Member num_chunks =
+        get_num_chunks(m_policy.begin(), m_policy.chunk_size(), m_policy.end());
+    m_policy.space().impl_bulk_setup_finalize(
+        m_force_synchronous, is_light_weight_policy<Policy>(), *this,
+        num_chunks, hpx::threads::thread_stacksize::nostack);
+  }
+
+  template <class ViewType>
+  inline ParallelReduce(const CombinedFunctorReducerType &arg_functor_reducer,
+                        Policy arg_policy, const ViewType &arg_view)
+      : m_functor_reducer(arg_functor_reducer),
+        m_policy(arg_policy),
+        m_result_ptr(arg_view.data()),
+        m_force_synchronous(!arg_view.impl_track().has_record()) {
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "HPX reduce result must be a View accessible from HostSpace");
+  }
+};
+
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>,
+                     Kokkos::Experimental::HPX> {
+ private:
+  using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
+  using FunctorType   = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType   = typename CombinedFunctorReducerType::reducer_type;
+
+  using Policy  = typename MDRangePolicy::impl_range_policy;
+  using WorkTag = typename MDRangePolicy::work_tag;
+  using Member  = typename Policy::member_type;
+
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
+  using iterate_type   = typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, CombinedFunctorReducerType, WorkTag, reference_type>;
+
+  const iterate_type m_iter;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const bool m_force_synchronous;
+
+ public:
+  void setup() const {
+    const ReducerType &reducer   = m_iter.m_func.get_reducer();
+    const std::size_t value_size = reducer.value_size();
+    const int num_worker_threads = m_policy.space().concurrency();
+
+    hpx_thread_buffer &buffer = m_iter.m_rp.space().impl_get_buffer();
+    buffer.resize(num_worker_threads, value_size);
+
+    for (int t = 0; t < num_worker_threads; ++t) {
+      reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
+    }
+  }
+
+  void execute_range(const Member i_chunk) const {
+    hpx_thread_buffer &buffer = m_iter.m_rp.space().impl_get_buffer();
+    reference_type update =
+        ReducerType::reference(reinterpret_cast<pointer_type>(
+            buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id())));
+    const auto r = get_chunk_range(i_chunk, m_policy.begin(),
+                                   m_policy.chunk_size(), m_policy.end());
+    for (Member i = r.begin; i < r.end; ++i) {
+      m_iter(i, update);
+    }
+  }
+
+  void finalize() const {
+    hpx_thread_buffer &buffer    = m_iter.m_rp.space().impl_get_buffer();
+    ReducerType reducer          = m_iter.m_func.get_reducer();
+    const int num_worker_threads = m_policy.space().concurrency();
+    for (int i = 1; i < num_worker_threads; ++i) {
+      reducer.join(reinterpret_cast<pointer_type>(buffer.get(0)),
+                   reinterpret_cast<pointer_type>(buffer.get(i)));
+    }
+
+    pointer_type final_value_ptr =
+        reinterpret_cast<pointer_type>(buffer.get(0));
+
+    reducer.final(final_value_ptr);
+
+    if (m_result_ptr != nullptr) {
+      const int n = reducer.value_count();
+
+      for (int j = 0; j < n; ++j) {
+        m_result_ptr[j] = final_value_ptr[j];
+      }
+    }
+  }
+
+  void execute() const {
+    const Member num_chunks =
+        get_num_chunks(m_policy.begin(), m_policy.chunk_size(), m_policy.end());
+    m_iter.m_rp.space().impl_bulk_setup_finalize(
+        m_force_synchronous, is_light_weight_policy<MDRangePolicy>(), *this,
+        num_chunks, hpx::threads::thread_stacksize::nostack);
+  }
+
+  template <class ViewType>
+  inline ParallelReduce(const CombinedFunctorReducerType &arg_functor_reducer,
+                        MDRangePolicy arg_policy, const ViewType &arg_view)
+      : m_iter(arg_policy, arg_functor_reducer),
+        m_policy(Policy(0, arg_policy.m_num_tiles).set_chunk_size(1)),
+        m_result_ptr(arg_view.data()),
+        m_force_synchronous(!arg_view.impl_track().has_record()) {
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "HPX reduce result must be a View accessible from HostSpace");
+  }
+
+  template <typename Policy, typename Functor>
+  static int max_tile_size_product(const Policy &, const Functor &) {
+    /**
+     * 1024 here is just our guess for a reasonable max tile size,
+     * it isn't a hardware constraint. If people see a use for larger
+     * tile size products, we're happy to change this.
+     */
+    return 1024;
+  }
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Experimental::HPX> {
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkTag   = typename Policy::work_tag;
+  using WorkRange = typename Policy::WorkRange;
+  using Member    = typename Policy::member_type;
+  using Analysis =
+      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType, void>;
+  using pointer_type   = typename Analysis::pointer_type;
+  using reference_type = typename Analysis::reference_type;
+  using value_type     = typename Analysis::value_type;
+  using barrier_type   = hpx::barrier<>;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+ public:
+  void setup() const {
+    const int num_worker_threads = m_policy.space().concurrency();
+    const std::size_t value_size = Analysis::value_size(m_functor);
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    buffer.resize(num_worker_threads, 2 * value_size, sizeof(barrier_type));
+
+    new (buffer.get_extra_space()) barrier_type(num_worker_threads);
+  }
+
+  void execute_chunk(const Member i_begin, const Member i_end,
+                     reference_type update, const bool final) const {
+    for (Member i = i_begin; i < i_end; ++i) {
+      if constexpr (std::is_same_v<WorkTag, void>) {
+        m_functor(i, update, final);
+      } else {
+        m_functor(WorkTag{}, i, update, final);
+      }
+    }
+  }
+
+  void execute_range(int t) const {
+    const int num_worker_threads = m_policy.space().concurrency();
+    const int value_count        = Analysis::value_count(m_functor);
+    const std::size_t value_size = Analysis::value_size(m_functor);
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    typename Analysis::Reducer final_reducer(m_functor);
+    barrier_type &barrier =
+        *static_cast<barrier_type *>(buffer.get_extra_space());
+    reference_type update_sum =
+        final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
+
+    const WorkRange range(m_policy, t, num_worker_threads);
+    execute_chunk(range.begin(), range.end(), update_sum, false);
+
+    {
+      // Since arrive_and_wait may yield and resume on another worker thread we
+      // set in_parallel = false on the current thread before suspending and set
+      // it again to true when we resume.
+      Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
+      barrier.arrive_and_wait();
+    }
+
+    if (t == 0) {
+      final_reducer.init(reinterpret_cast<pointer_type>(
+          static_cast<char *>(buffer.get(0)) + value_size));
+
+      for (int i = 1; i < num_worker_threads; ++i) {
+        pointer_type ptr_1_prev =
+            reinterpret_cast<pointer_type>(buffer.get(i - 1));
+        pointer_type ptr_2_prev = reinterpret_cast<pointer_type>(
+            static_cast<char *>(buffer.get(i - 1)) + value_size);
+        pointer_type ptr_2 = reinterpret_cast<pointer_type>(
+            static_cast<char *>(buffer.get(i)) + value_size);
+
+        for (int j = 0; j < value_count; ++j) {
+          ptr_2[j] = ptr_2_prev[j];
+        }
+
+        final_reducer.join(ptr_2, ptr_1_prev);
+      }
+    }
+
+    {
+      // Since arrive_and_wait may yield and resume on another worker thread we
+      // set in_parallel = false on the current thread before suspending and set
+      // it again to true when we resume.
+      Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
+      barrier.arrive_and_wait();
+    }
+
+    reference_type update_base =
+        Analysis::Reducer::reference(reinterpret_cast<pointer_type>(
+            static_cast<char *>(buffer.get(t)) + value_size));
+
+    execute_chunk(range.begin(), range.end(), update_base, true);
+  }
+
+  void finalize() const {
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    static_cast<barrier_type *>(buffer.get_extra_space())->~barrier_type();
+  }
+
+  void execute() const {
+    const int num_worker_threads = m_policy.space().concurrency();
+    m_policy.space().impl_bulk_setup_finalize(
+        false, is_light_weight_policy<Policy>(), *this, num_worker_threads,
+        hpx::threads::thread_stacksize::small_);
+  }
+
+  inline ParallelScan(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+};
+
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::Experimental::HPX> {
+ private:
+  using Policy         = Kokkos::RangePolicy<Traits...>;
+  using WorkTag        = typename Policy::work_tag;
+  using WorkRange      = typename Policy::WorkRange;
+  using Member         = typename Policy::member_type;
+  using Analysis       = FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                   FunctorType, ReturnType>;
+  using pointer_type   = typename Analysis::pointer_type;
+  using reference_type = typename Analysis::reference_type;
+  using value_type     = typename Analysis::value_type;
+  using barrier_type   = hpx::barrier<>;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  pointer_type m_result_ptr;
+
+ public:
+  void setup() const {
+    const int num_worker_threads = m_policy.space().concurrency();
+    const std::size_t value_size = Analysis::value_size(m_functor);
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    buffer.resize(num_worker_threads, 2 * value_size, sizeof(barrier_type));
+
+    new (buffer.get_extra_space()) barrier_type(num_worker_threads);
+  }
+
+  void execute_chunk(const Member i_begin, const Member i_end,
+                     reference_type update, const bool final) const {
+    for (Member i = i_begin; i < i_end; ++i) {
+      if constexpr (std::is_same_v<WorkTag, void>) {
+        m_functor(i, update, final);
+      } else {
+        m_functor(WorkTag{}, i, update, final);
+      }
+    }
+  }
+
+  void execute_range(int t) const {
+    const int num_worker_threads = m_policy.space().concurrency();
+    const int value_count        = Analysis::value_count(m_functor);
+    const std::size_t value_size = Analysis::value_size(m_functor);
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    typename Analysis::Reducer final_reducer(m_functor);
+    barrier_type &barrier =
+        *static_cast<barrier_type *>(buffer.get_extra_space());
+    reference_type update_sum =
+        final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
+
+    const WorkRange range(m_policy, t, num_worker_threads);
+    execute_chunk(range.begin(), range.end(), update_sum, false);
+
+    {
+      // Since arrive_and_wait may yield and resume on another worker thread we
+      // set in_parallel = false on the current thread before suspending and set
+      // it again to true when we resume.
+      Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
+      barrier.arrive_and_wait();
+    }
+
+    if (t == 0) {
+      final_reducer.init(reinterpret_cast<pointer_type>(
+          static_cast<char *>(buffer.get(0)) + value_size));
+
+      for (int i = 1; i < num_worker_threads; ++i) {
+        pointer_type ptr_1_prev =
+            reinterpret_cast<pointer_type>(buffer.get(i - 1));
+        pointer_type ptr_2_prev = reinterpret_cast<pointer_type>(
+            static_cast<char *>(buffer.get(i - 1)) + value_size);
+        pointer_type ptr_2 = reinterpret_cast<pointer_type>(
+            static_cast<char *>(buffer.get(i)) + value_size);
+
+        for (int j = 0; j < value_count; ++j) {
+          ptr_2[j] = ptr_2_prev[j];
+        }
+
+        final_reducer.join(ptr_2, ptr_1_prev);
+      }
+    }
+
+    {
+      // Since arrive_and_wait may yield and resume on another worker thread we
+      // set in_parallel = false on the current thread before suspending and set
+      // it again to true when we resume.
+      Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
+      barrier.arrive_and_wait();
+    }
+
+    reference_type update_base =
+        Analysis::Reducer::reference(reinterpret_cast<pointer_type>(
+            static_cast<char *>(buffer.get(t)) + value_size));
+
+    execute_chunk(range.begin(), range.end(), update_base, true);
+
+    if (t == num_worker_threads - 1) {
+      *m_result_ptr = update_base;
+    }
+  }
+
+  void finalize() const {
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    static_cast<barrier_type *>(buffer.get_extra_space())->~barrier_type();
+  }
+
+  void execute() const {
+    const int num_worker_threads = m_policy.space().concurrency();
+    m_policy.space().impl_bulk_setup_finalize(
+        false, is_light_weight_policy<Policy>(), *this, num_worker_threads,
+        hpx::threads::thread_stacksize::small_);
+  }
+
+  template <class ViewType>
+  ParallelScanWithTotal(const FunctorType &arg_functor,
+                        const Policy &arg_policy,
+                        const ViewType &arg_result_view)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result_view.data()) {
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::HPX parallel_scan result must be host-accessible!");
+  }
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace Kokkos {
+namespace Impl {
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::Experimental::HPX> {
+ private:
+  using Policy  = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+  using memory_space = Kokkos::HostSpace;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const int m_league;
+  const std::size_t m_shared;
+
+ public:
+  void setup() const {
+    const int num_worker_threads = m_policy.space().concurrency();
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    buffer.resize(num_worker_threads, m_shared);
+  }
+
+  void execute_range(const int i) const {
+    const int t = Kokkos::Experimental::HPX::impl_hardware_thread_id();
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    const auto r =
+        get_chunk_range(i, 0, m_policy.chunk_size(), m_policy.league_size());
+    for (int league_rank = r.begin; league_rank < r.end; ++league_rank) {
+      if constexpr (std::is_same_v<WorkTag, void>) {
+        m_functor(Member(m_policy, 0, league_rank, buffer.get(t), m_shared));
+      } else {
+        m_functor(WorkTag{},
+                  Member(m_policy, 0, league_rank, buffer.get(t), m_shared));
+      }
+    }
+  }
+
+  void finalize() const {}
+
+  void execute() const {
+    const int num_chunks =
+        get_num_chunks(0, m_policy.chunk_size(), m_policy.league_size());
+    m_policy.space().impl_bulk_setup_finalize(
+        false, is_light_weight_policy<Policy>(), *this, num_chunks,
+        hpx::threads::thread_stacksize::nostack);
+  }
+
+  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_league(arg_policy.league_size()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     arg_functor, arg_policy.team_size())) {}
+};
+
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>,
+                     Kokkos::Experimental::HPX> {
+ private:
+  using Policy = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using Member  = typename Policy::member_type;
+  using WorkTag = typename Policy::work_tag;
+
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+  using value_type     = typename ReducerType::value_type;
+
+  const CombinedFunctorReducerType m_functor_reducer;
+  const int m_league;
+  const Policy m_policy;
+  pointer_type m_result_ptr;
+  const std::size_t m_shared;
+  const bool m_force_synchronous;
+
+ public:
+  void setup() const {
+    const ReducerType &reducer   = m_functor_reducer.get_reducer();
+    const std::size_t value_size = reducer.value_size();
+    const int num_worker_threads = m_policy.space().concurrency();
+
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    buffer.resize(num_worker_threads, value_size + m_shared);
+
+    for (int t = 0; t < num_worker_threads; ++t) {
+      reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
+    }
+  }
+
+  void execute_range(const int i) const {
+    const ReducerType &reducer   = m_functor_reducer.get_reducer();
+    const std::size_t value_size = reducer.value_size();
+    std::size_t t = Kokkos::Experimental::HPX::impl_hardware_thread_id();
+    hpx_thread_buffer &buffer = m_policy.space().impl_get_buffer();
+    reference_type update =
+        ReducerType::reference(reinterpret_cast<pointer_type>(buffer.get(t)));
+    const auto r =
+        get_chunk_range(i, 0, m_policy.chunk_size(), m_policy.league_size());
+    char *local_buffer = static_cast<char *>(buffer.get(t)) + value_size;
+    for (int league_rank = r.begin; league_rank < r.end; ++league_rank) {
+      if constexpr (std::is_same_v<WorkTag, void>) {
+        m_functor_reducer.get_functor()(
+            Member(m_policy, 0, league_rank, local_buffer, m_shared), update);
+      } else {
+        m_functor_reducer.get_functor()(
+            WorkTag{}, Member(m_policy, 0, league_rank, local_buffer, m_shared),
+            update);
+      }
+    }
+  }
+
+  void finalize() const {
+    hpx_thread_buffer &buffer    = m_policy.space().impl_get_buffer();
+    const ReducerType &reducer   = m_functor_reducer.get_reducer();
+    const int num_worker_threads = m_policy.space().concurrency();
+    const pointer_type ptr = reinterpret_cast<pointer_type>(buffer.get(0));
+    for (int t = 1; t < num_worker_threads; ++t) {
+      reducer.join(ptr, reinterpret_cast<pointer_type>(buffer.get(t)));
+    }
+
+    reducer.final(ptr);
+
+    if (m_result_ptr) {
+      const int n = reducer.value_count();
+
+      for (int j = 0; j < n; ++j) {
+        m_result_ptr[j] = ptr[j];
+      }
+    }
+  }
+
+  void execute() const {
+    if (m_policy.league_size() * m_policy.team_size() == 0) {
+      if (m_result_ptr) {
+        const ReducerType &reducer = m_functor_reducer.get_reducer();
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
+      }
+      return;
+    }
+
+    const int num_chunks =
+        get_num_chunks(0, m_policy.chunk_size(), m_policy.league_size());
+    m_policy.space().impl_bulk_setup_finalize(
+        m_force_synchronous, is_light_weight_policy<Policy>(), *this,
+        num_chunks, hpx::threads::thread_stacksize::nostack);
+  }
+
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType &arg_functor_reducer,
+                 const Policy &arg_policy, const ViewType &arg_result)
+      : m_functor_reducer(arg_functor_reducer),
+        m_league(arg_policy.league_size()),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result.data()),
+        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     m_functor_reducer.get_functor(), arg_policy.team_size())),
+        m_force_synchronous(!arg_result.impl_track().has_record()) {
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "HPX reduce result must be a View accessible from HostSpace");
+  }
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+namespace Kokkos {
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+    TeamThreadRange(const Impl::HPXTeamMember &thread, const iType &count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
+      thread, count);
+}
+
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    std::common_type_t<iType1, iType2>, Impl::HPXTeamMember>
+TeamThreadRange(const Impl::HPXTeamMember &thread, const iType1 &i_begin,
+                const iType2 &i_end) {
+  using iType = std::common_type_t<iType1, iType2>;
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
+      thread, iType(i_begin), iType(i_end));
+}
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+    TeamVectorRange(const Impl::HPXTeamMember &thread, const iType &count) {
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
+      thread, count);
+}
+
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    std::common_type_t<iType1, iType2>, Impl::HPXTeamMember>
+TeamVectorRange(const Impl::HPXTeamMember &thread, const iType1 &i_begin,
+                const iType2 &i_end) {
+  using iType = std::common_type_t<iType1, iType2>;
+  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
+      thread, iType(i_begin), iType(i_end));
+}
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION
+    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+    ThreadVectorRange(const Impl::HPXTeamMember &thread, const iType &count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
+      thread, count);
+}
+
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    std::common_type_t<iType1, iType2>, Impl::HPXTeamMember>
+ThreadVectorRange(const Impl::HPXTeamMember &thread, const iType1 &i_begin,
+                  const iType2 &i_end) {
+  using iType = std::common_type_t<iType1, iType2>;
+  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
+      thread, iType(i_begin), iType(i_end));
+}
+
+KOKKOS_INLINE_FUNCTION
+Impl::ThreadSingleStruct<Impl::HPXTeamMember> PerTeam(
+    const Impl::HPXTeamMember &thread) {
+  return Impl::ThreadSingleStruct<Impl::HPXTeamMember>(thread);
+}
+
+KOKKOS_INLINE_FUNCTION
+Impl::VectorSingleStruct<Impl::HPXTeamMember> PerThread(
+    const Impl::HPXTeamMember &thread) {
+  return Impl::VectorSingleStruct<Impl::HPXTeamMember>(thread);
+}
+
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team.
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const Lambda &lambda) {
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment)
+    lambda(i);
+}
+
+/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result.
+ */
+template <typename iType, class Lambda, typename ValueType,
+          typename = std::enable_if_t<!Kokkos::is_reducer<ValueType>::value>>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const Lambda &lambda, ValueType &result) {
+  result = ValueType();
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
+  }
+}
+
+/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const Lambda &lambda) {
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i);
+  }
+}
+
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result.
+ */
+template <typename iType, class Lambda, typename ValueType,
+          typename = std::enable_if_t<!Kokkos::is_reducer<ValueType>::value>>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const Lambda &lambda, ValueType &result) {
+  result = ValueType();
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, result);
+  }
+}
+
+template <typename iType, class Lambda, typename ReducerType,
+          typename = std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const Lambda &lambda, const ReducerType &reducer) {
+  reducer.init(reducer.reference());
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
+  }
+}
+
+template <typename iType, class Lambda, typename ReducerType,
+          typename = std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const Lambda &lambda, const ReducerType &reducer) {
+  reducer.init(reducer.reference());
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, reducer.reference());
+  }
+}
+
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember> const
+        &loop_boundaries,
+    const FunctorType &lambda) {
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+
+  value_type scan_val = value_type();
+
+  // Intra-member scan
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, false);
+  }
+
+  // 'scan_val' output is the exclusive prefix sum
+  scan_val = loop_boundaries.thread.team_scan(scan_val);
+
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, true);
+  }
+}
+
+/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
+ * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
+ * operation is performed. Depending on the target execution space the operator
+ * might be called twice: once with final=false and once with final=true. When
+ * final==true val contains the prefix sum value. The contribution of this "i"
+ * needs to be added to val no matter whether final==true or not. In a serial
+ * execution (i.e. team_size==1) the operator is only called once with
+ * final==true. Scan_val will be set to the final sum value over all vector
+ */
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const FunctorType &lambda) {
+  using value_type =
+      typename Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                                     TeamPolicy<Experimental::HPX>, FunctorType,
+                                     void>::value_type;
+
+  value_type scan_val = value_type();
+
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, true);
+  }
+}
+
+/** \brief  Intra-thread vector parallel scan with reducer
+ *
+ */
+template <typename iType, class FunctorType, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
+parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const FunctorType &lambda, const ReducerType &reducer) {
+  typename ReducerType::value_type scan_val;
+  reducer.init(scan_val);
+
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
+       i += loop_boundaries.increment) {
+    lambda(i, scan_val, true);
+  }
+}
+
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::HPXTeamMember> &,
+    const FunctorType &lambda) {
+  lambda();
+}
+
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &,
+    const FunctorType &lambda) {
+  lambda();
+}
+
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::HPXTeamMember> &,
+    const FunctorType &lambda, ValueType &val) {
+  lambda(val);
+}
+
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &,
+    const FunctorType &lambda, ValueType &val) {
+  lambda(val);
+}
+
+}  // namespace Kokkos
+
+#include <HPX/Kokkos_HPX_Task.hpp>
+
+#endif /* #if defined( KOKKOS_ENABLE_HPX ) */
+#endif /* #ifndef KOKKOS_HPX_HPP */
diff --git a/core/src/HPX/Kokkos_HPX_Task.hpp b/core/src/HPX/Kokkos_HPX_Task.hpp
index e75b7be49d..191e4cf9b3 100644
--- a/core/src/HPX/Kokkos_HPX_Task.hpp
+++ b/core/src/HPX/Kokkos_HPX_Task.hpp
@@ -22,7 +22,7 @@
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
-#include <Kokkos_HPX.hpp>
+#include <HPX/Kokkos_HPX.hpp>
 
 #include <hpx/local/execution.hpp>
 #include <hpx/local/future.hpp>
@@ -39,6 +39,51 @@ template <class QueueType>
 class TaskQueueSpecialization<
     SimpleTaskScheduler<Kokkos::Experimental::HPX, QueueType>> {
  public:
+  void setup() const {
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+
+    hpx_thread_buffer &buffer = Kokkos::Experimental::HPX().impl_get_buffer();
+    buffer.resize(num_worker_threads, 512);
+  }
+
+  void execute_range(int t) const {
+    // NOTE: This implementation has been simplified based on the
+    // assumption that team_size = 1. The HPX backend currently only
+    // supports a team size of 1.
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+
+    hpx_thread_buffer &buffer = Kokkos::Experimental::HPX().impl_get_buffer();
+
+    buffer.get(t);
+    HPXTeamMember member(
+        TeamPolicyInternal<Kokkos::Experimental::HPX>(
+            Kokkos::Experimental::HPX(), num_worker_threads, 1),
+        0, t, buffer.get(t), 512);
+
+    member_type single_exec(*scheduler, member);
+    member_type &team_exec = single_exec;
+
+    auto &queue          = scheduler->queue();
+    auto &team_scheduler = team_exec.scheduler();
+
+    using task_base_type = typename scheduler_type::task_base_type;
+    auto current_task    = OptionalRef<task_base_type>(nullptr);
+
+    while (!queue.is_done()) {
+      current_task = queue.pop_ready_task(team_scheduler.team_scheduler_info());
+
+      if (current_task) {
+        KOKKOS_EXPECTS(current_task->is_single_runnable() ||
+                       current_task->is_team_runnable());
+        current_task->as_runnable_task().run(single_exec);
+        queue.complete((*std::move(current_task)).as_runnable_task(),
+                       team_scheduler.team_scheduler_info());
+      }
+    }
+  }
+
+  void finalize() const {}
+
   using execution_space = Kokkos::Experimental::HPX;
   using scheduler_type =
       SimpleTaskScheduler<Kokkos::Experimental::HPX, QueueType>;
@@ -47,69 +92,14 @@ class TaskQueueSpecialization<
   using memory_space = Kokkos::HostSpace;
 
   static void execute(scheduler_type const &scheduler) {
-    // NOTE: We create an instance so that we can use dispatch_execute_task.
+    // NOTE: We create an instance so that we can use impl_bulk_setup_finalize.
     // This is not necessarily the most efficient, but can be improved later.
     TaskQueueSpecialization<scheduler_type> task_queue;
-    task_queue.scheduler = &scheduler;
-    Kokkos::Impl::dispatch_execute_task(&task_queue,
-                                        Kokkos::Experimental::HPX());
-    Kokkos::Experimental::HPX().fence(
-        "Kokkos::Impl::TaskQueueSpecialization<SimpleTask>::execute: fence "
-        "after task execution");
-  }
-
-  // Must provide task queue execution function
-  void execute_task() const {
-    // See [note 1] in Kokkos_HPX.hpp for an explanation. The work graph policy
-    // does not store an execution space instance, so we only need to reset the
-    // parallel region count here.
-    Kokkos::Experimental::HPX::reset_count_on_exit_parallel reset_count_on_exit;
-
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-    using task_base_type = typename scheduler_type::task_base_type;
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-
-    thread_buffer &buffer = Kokkos::Experimental::HPX().impl_get_buffer();
-    buffer.resize(num_worker_threads, 512);
-
-    auto &queue = scheduler->queue();
-
-    for_loop(par.with(static_chunk_size(1)), 0, num_worker_threads,
-             [this, &queue, &buffer, num_worker_threads](int) {
-               // NOTE: This implementation has been simplified based on the
-               // assumption that team_size = 1. The HPX backend currently only
-               // supports a team size of 1.
-               std::size_t t =
-                   Kokkos::Experimental::HPX::impl_hardware_thread_id();
-
-               buffer.get(t);
-               HPXTeamMember member(
-                   TeamPolicyInternal<Kokkos::Experimental::HPX>(
-                       Kokkos::Experimental::HPX(), num_worker_threads, 1),
-                   0, t, buffer.get(t), 512);
-
-               member_type single_exec(*scheduler, member);
-               member_type &team_exec = single_exec;
-
-               auto &team_scheduler = team_exec.scheduler();
-               auto current_task    = OptionalRef<task_base_type>(nullptr);
-
-               while (!queue.is_done()) {
-                 current_task =
-                     queue.pop_ready_task(team_scheduler.team_scheduler_info());
-
-                 if (current_task) {
-                   KOKKOS_ASSERT(current_task->is_single_runnable() ||
-                                 current_task->is_team_runnable());
-                   current_task->as_runnable_task().run(single_exec);
-                   queue.complete((*std::move(current_task)).as_runnable_task(),
-                                  team_scheduler.team_scheduler_info());
-                 }
-               }
-             });
+    task_queue.scheduler         = &scheduler;
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+    Kokkos::Experimental::HPX().impl_bulk_setup_finalize(
+        true, false, task_queue, num_worker_threads,
+        hpx::threads::thread_stacksize::nostack);
   }
 
   static uint32_t get_max_team_count(execution_space const &espace) {
@@ -133,6 +123,66 @@ class TaskQueueSpecializationConstrained<
     std::enable_if_t<std::is_same<typename Scheduler::execution_space,
                                   Kokkos::Experimental::HPX>::value>> {
  public:
+  void setup() const {
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+
+    hpx_thread_buffer &buffer = Kokkos::Experimental::HPX().impl_get_buffer();
+    buffer.resize(num_worker_threads, 512);
+
+    auto &queue = scheduler->queue();
+    queue.initialize_team_queues(num_worker_threads);
+  }
+
+  void execute_range(int t) const {
+    // NOTE: This implementation has been simplified based on the
+    // assumption that team_size = 1. The HPX backend currently only
+    // supports a team size of 1.
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+
+    hpx_thread_buffer &buffer = Kokkos::Experimental::HPX().impl_get_buffer();
+
+    buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id());
+    HPXTeamMember member(
+        TeamPolicyInternal<Kokkos::Experimental::HPX>(
+            Kokkos::Experimental::HPX(), num_worker_threads, 1),
+        0, t, buffer.get(t), 512);
+
+    using task_base_type = typename scheduler_type::task_base;
+    using queue_type     = typename scheduler_type::queue_type;
+
+    static task_base_type *const end = (task_base_type *)task_base_type::EndTag;
+    constexpr task_base_type *no_more_tasks_sentinel = nullptr;
+
+    member_type single_exec(*scheduler, member);
+    member_type &team_exec = single_exec;
+
+    auto &team_queue     = team_exec.scheduler().queue();
+    task_base_type *task = no_more_tasks_sentinel;
+
+    do {
+      if (task != no_more_tasks_sentinel && task != end) {
+        team_queue.complete(task);
+      }
+
+      if (*((volatile int *)&team_queue.m_ready_count) > 0) {
+        task = end;
+        for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
+          for (int j = 0; j < 2 && end == task; ++j) {
+            task = queue_type::pop_ready_task(&team_queue.m_ready[i][j]);
+          }
+        }
+      } else {
+        task = team_queue.attempt_to_steal_task();
+      }
+
+      if (task != no_more_tasks_sentinel && task != end) {
+        (*task->m_apply)(task, &single_exec);
+      }
+    } while (task != no_more_tasks_sentinel);
+  }
+
+  void finalize() const {}
+
   using execution_space = Kokkos::Experimental::HPX;
   using scheduler_type  = Scheduler;
   using member_type =
@@ -144,7 +194,7 @@ class TaskQueueSpecializationConstrained<
     using task_base_type = typename scheduler_type::task_base;
     using queue_type     = typename scheduler_type::queue_type;
 
-    if (1 == Kokkos::Experimental::HPX::concurrency()) {
+    if (1 == Kokkos::Experimental::HPX().concurrency()) {
       task_base_type *const end = (task_base_type *)task_base_type::EndTag;
       task_base_type *task      = end;
 
@@ -175,82 +225,14 @@ class TaskQueueSpecializationConstrained<
   }
 
   static void execute(scheduler_type const &scheduler) {
-    // NOTE: We create an instance so that we can use dispatch_execute_task.
+    // NOTE: We create an instance so that we can use impl_bulk_setup_finalize.
     // This is not necessarily the most efficient, but can be improved later.
     TaskQueueSpecializationConstrained<scheduler_type> task_queue;
-    task_queue.scheduler = &scheduler;
-    Kokkos::Impl::dispatch_execute_task(&task_queue,
-                                        Kokkos::Experimental::HPX());
-    Kokkos::Experimental::HPX().fence(
-        "Kokkos::Impl::TaskQueueSpecialization<SimpleTask>::execute: fence "
-        "after task execution");
-  }
-
-  // Must provide task queue execution function
-  void execute_task() const {
-    // See [note 1] in Kokkos_HPX.hpp for an explanation. The work graph policy
-    // does not store an execution space instance, so we only need to reset the
-    // parallel region count here.
-    Kokkos::Experimental::HPX::reset_count_on_exit_parallel reset_count_on_exit;
-
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-    using task_base_type = typename scheduler_type::task_base;
-    using queue_type     = typename scheduler_type::queue_type;
-
-    const int num_worker_threads     = Kokkos::Experimental::HPX::concurrency();
-    static task_base_type *const end = (task_base_type *)task_base_type::EndTag;
-    constexpr task_base_type *no_more_tasks_sentinel = nullptr;
-
-    thread_buffer &buffer = Kokkos::Experimental::HPX().impl_get_buffer();
-    buffer.resize(num_worker_threads, 512);
-
-    auto &queue = scheduler->queue();
-    queue.initialize_team_queues(num_worker_threads);
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [this, &buffer, num_worker_threads](int t) {
-          // NOTE: This implementation has been simplified based on the
-          // assumption that team_size = 1. The HPX backend currently only
-          // supports a team size of 1.
-          buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id());
-          HPXTeamMember member(
-              TeamPolicyInternal<Kokkos::Experimental::HPX>(
-                  Kokkos::Experimental::HPX(), num_worker_threads, 1),
-              0, t, buffer.get(t), 512);
-
-          member_type single_exec(*scheduler, member);
-          member_type &team_exec = single_exec;
-
-          auto &team_queue     = team_exec.scheduler().queue();
-          task_base_type *task = no_more_tasks_sentinel;
-
-          do {
-            if (task != no_more_tasks_sentinel && task != end) {
-              team_queue.complete(task);
-            }
-
-            if (*((volatile int *)&team_queue.m_ready_count) > 0) {
-              task = end;
-              for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
-                for (int j = 0; j < 2 && end == task; ++j) {
-                  task = queue_type::pop_ready_task(&team_queue.m_ready[i][j]);
-                }
-              }
-            } else {
-              task = team_queue.attempt_to_steal_task();
-            }
-
-            if (task != no_more_tasks_sentinel && task != end) {
-              (*task->m_apply)(task, &single_exec);
-            }
-          } while (task != no_more_tasks_sentinel);
-        });
+    task_queue.scheduler         = &scheduler;
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+    Kokkos::Experimental::HPX().impl_bulk_setup_finalize(
+        true, false, task_queue, num_worker_threads,
+        hpx::threads::thread_stacksize::nostack);
   }
 
   template <typename TaskType>
diff --git a/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp b/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
index 72a8019935..f3fabcfee3 100644
--- a/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
+++ b/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
@@ -17,7 +17,7 @@
 #ifndef KOKKOS_HPX_WORKGRAPHPOLICY_HPP
 #define KOKKOS_HPX_WORKGRAPHPOLICY_HPP
 
-#include <Kokkos_HPX.hpp>
+#include <HPX/Kokkos_HPX.hpp>
 
 #include <hpx/local/algorithm.hpp>
 #include <hpx/local/execution.hpp>
@@ -35,53 +35,28 @@ class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
   Policy m_policy;
   FunctorType m_functor;
 
-  template <class TagType>
-  std::enable_if_t<std::is_void<TagType>::value> execute_functor(
-      const std::int32_t w) const noexcept {
-    m_functor(w);
-  }
-
-  template <class TagType>
-  std::enable_if_t<!std::is_void<TagType>::value> execute_functor(
-      const std::int32_t w) const noexcept {
-    const TagType t{};
-    m_functor(t, w);
-  }
-
  public:
-  void execute() const {
-    dispatch_execute_task(this, m_policy.space());
-    m_policy.space().fence(
-        "Kokkos::Experimental::Impl::HPX::ParallelFor<WorkGraphPolicy>: fence "
-        "after kernel execution");
+  void execute_range(int) const {
+    std::int32_t w = m_policy.pop_work();
+    while (w != Policy::COMPLETED_TOKEN) {
+      if (w != Policy::END_TOKEN) {
+        if constexpr (std::is_same_v<WorkTag, void>) {
+          m_functor(w);
+        } else {
+          m_functor(WorkTag{}, w);
+        }
+        m_policy.completed_work(w);
+      }
+
+      w = m_policy.pop_work();
+    }
   }
 
-  void execute_task() const {
-    // See [note 1] in Kokkos_HPX.hpp for an explanation. The work graph policy
-    // does not store an execution space instance, so we only need to reset the
-    // parallel region count here.
-    Kokkos::Experimental::HPX::reset_count_on_exit_parallel reset_count_on_exit;
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    for_loop(par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-             [this](int) {
-               std::int32_t w = m_policy.pop_work();
-               while (w != Policy::COMPLETED_TOKEN) {
-                 if (w != Policy::END_TOKEN) {
-                   execute_functor<WorkTag>(w);
-                   m_policy.completed_work(w);
-                 }
-
-                 w = m_policy.pop_work();
-               }
-             });
+  void execute() const {
+    const int num_worker_threads = Kokkos::Experimental::HPX().concurrency();
+    Kokkos::Experimental::HPX().impl_bulk_plain(
+        true, is_light_weight_policy<Policy>(), *this, num_worker_threads,
+        hpx::threads::thread_stacksize::nostack);
   }
 
   inline ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
diff --git a/core/src/Kokkos_Atomic.hpp b/core/src/Kokkos_Atomic.hpp
index 1347e09ebd..6fc903f274 100644
--- a/core/src/Kokkos_Atomic.hpp
+++ b/core/src/Kokkos_Atomic.hpp
@@ -46,350 +46,9 @@
 
 #include <Kokkos_Macros.hpp>
 
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 #include <Kokkos_Atomics_Desul_Wrapper.hpp>
 #include <Kokkos_Atomics_Desul_Volatile_Wrapper.hpp>
-#include <impl/Kokkos_Utilities.hpp>
 
-// Helper functions for places where we really should have called SeqCst atomics
-// anyway These can go away when we call desul unconditionally Non-Desul
-// versions are below
-namespace Kokkos {
-namespace Impl {
-using desul::MemoryOrderSeqCst;
-using desul::MemoryScopeDevice;
-
-template <class T>
-KOKKOS_INLINE_FUNCTION void desul_atomic_dec(T* dest, MemoryOrderSeqCst,
-                                             MemoryScopeDevice) {
-  return desul::atomic_dec(const_cast<T*>(dest), desul::MemoryOrderSeqCst(),
-                           desul::MemoryScopeDevice());
-}
-
-template <class T>
-KOKKOS_INLINE_FUNCTION void desul_atomic_inc(T* dest, MemoryOrderSeqCst,
-                                             MemoryScopeDevice) {
-  return desul::atomic_inc(const_cast<T*>(dest), desul::MemoryOrderSeqCst(),
-                           desul::MemoryScopeDevice());
-}
-
-template <class T>
-KOKKOS_INLINE_FUNCTION T
-desul_atomic_exchange(T* dest, const Kokkos::Impl::type_identity_t<T> val,
-                      MemoryOrderSeqCst, MemoryScopeDevice) {
-  return desul::atomic_exchange(const_cast<T*>(dest), val,
-                                desul::MemoryOrderSeqCst(),
-                                desul::MemoryScopeDevice());
-}
-
-template <class T>
-KOKKOS_INLINE_FUNCTION T desul_atomic_compare_exchange(
-    T* dest, Kokkos::Impl::type_identity_t<const T> compare,
-    Kokkos::Impl::type_identity_t<const T> val, MemoryOrderSeqCst,
-    MemoryScopeDevice) {
-  return desul::atomic_compare_exchange(dest, compare, val,
-                                        desul::MemoryOrderSeqCst(),
-                                        desul::MemoryScopeDevice());
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-#else
-
-#include <Kokkos_HostSpace.hpp>
-#include <impl/Kokkos_Traits.hpp>
-
-//----------------------------------------------------------------------------
-
-// Need to fix this for pure clang on windows
-#if defined(_WIN32)
-#define KOKKOS_ENABLE_WINDOWS_ATOMICS
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#define KOKKOS_ENABLE_CUDA_ATOMICS
-#if defined(KOKKOS_COMPILER_CLANG)
-#define KOKKOS_ENABLE_GNU_ATOMICS
-#endif
-#endif
-
-#else  // _WIN32
-#if defined(KOKKOS_ENABLE_CUDA)
-
-// Compiling NVIDIA device code, must use Cuda atomics:
-
-#define KOKKOS_ENABLE_CUDA_ATOMICS
-
-#elif defined(KOKKOS_ENABLE_HIP)
-
-#define KOKKOS_ENABLE_HIP_ATOMICS
-
-#endif
-
-#if !defined(KOKKOS_ENABLE_GNU_ATOMICS) &&    \
-    !defined(KOKKOS_ENABLE_INTEL_ATOMICS) &&  \
-    !defined(KOKKOS_ENABLE_OPENMP_ATOMICS) && \
-    !defined(KOKKOS_ENABLE_STD_ATOMICS) &&    \
-    !defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-// Compiling for non-Cuda atomic implementation has not been pre-selected.
-// Choose the best implementation for the detected compiler.
-// Preference: GCC, INTEL, OMP31
-
-#if defined(KOKKOS_INTERNAL_NOT_PARALLEL)
-
-#define KOKKOS_ENABLE_SERIAL_ATOMICS
-
-#elif defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) || \
-    defined(KOKKOS_COMPILER_NVCC)
-
-#define KOKKOS_ENABLE_GNU_ATOMICS
-
-#elif defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_CRAYC)
-
-#define KOKKOS_ENABLE_INTEL_ATOMICS
-
-#elif defined(_OPENMP) && (201107 <= _OPENMP)
-
-#define KOKKOS_ENABLE_OPENMP_ATOMICS
-
-#else
-
-#error "KOKKOS_ATOMICS_USE : Unsupported compiler"
-
-#endif
-
-#endif /* Not pre-selected atomic implementation */
-#endif
-
-#ifdef KOKKOS_ENABLE_CUDA
-#include <Cuda/Kokkos_Cuda_Locks.hpp>
-#endif
-
-namespace Kokkos {
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_add(volatile T* const dest, const T src);
-
-// Atomic increment
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_increment(volatile T* a);
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_decrement(volatile T* a);
-}  // namespace Kokkos
-
-namespace Kokkos {
-
-inline const char* atomic_query_version() {
-#if defined(KOKKOS_ENABLE_CUDA_ATOMICS)
-  return "KOKKOS_ENABLE_CUDA_ATOMICS";
-#elif defined(KOKKOS_ENABLE_GNU_ATOMICS)
-  return "KOKKOS_ENABLE_GNU_ATOMICS";
-#elif defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-  return "KOKKOS_ENABLE_INTEL_ATOMICS";
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-  return "KOKKOS_ENABLE_OPENMP_ATOMICS";
-#elif defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
-  return "KOKKOS_ENABLE_WINDOWS_ATOMICS";
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  return "KOKKOS_ENABLE_SERIAL_ATOMICS";
-#else
-#error "No valid response for atomic_query_version!"
-#endif
-}
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-// Atomic Memory Orders
-//
-// Implements Strongly-typed analogs of C++ standard memory orders
-#include "impl/Kokkos_Atomic_Memory_Order.hpp"
-
-#if defined(KOKKOS_ENABLE_HIP)
-#include <HIP/Kokkos_HIP_Atomic.hpp>
-#endif
-
-#if defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
-#include "impl/Kokkos_Atomic_Windows.hpp"
-#endif
-//----------------------------------------------------------------------------
-// Atomic Assembly
-//
-// Implements CAS128-bit in assembly
-
-#include "impl/Kokkos_Atomic_Assembly.hpp"
-
-//----------------------------------------------------------------------------
-// Memory fence
-//
-// All loads and stores from this thread will be globally consistent before
-// continuing
-//
-// void memory_fence() {...};
-#include "impl/Kokkos_Memory_Fence.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic exchange
-//
-// template< typename T >
-// T atomic_exchange( volatile T* const dest , const T val )
-// { T tmp = *dest ; *dest = val ; return tmp ; }
-
-#include "impl/Kokkos_Atomic_Exchange.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic compare-and-exchange
-//
-// template<class T>
-// bool atomic_compare_exchange_strong(volatile T* const dest, const T compare,
-// const T val) { bool equal = compare == *dest ; if ( equal ) { *dest = val ; }
-// return equal ; }
-
-#include "impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp"
-
-#include "impl/Kokkos_Atomic_Generic.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic fetch and add
-//
-// template<class T>
-// T atomic_fetch_add(volatile T* const dest, const T val)
-// { T tmp = *dest ; *dest += val ; return tmp ; }
-
-#include "impl/Kokkos_Atomic_Fetch_Add.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic increment
-//
-// template<class T>
-// T atomic_increment(volatile T* const dest)
-// { dest++; }
-
-#include "impl/Kokkos_Atomic_Increment.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic Decrement
-//
-// template<class T>
-// T atomic_decrement(volatile T* const dest)
-// { dest--; }
-
-#include "impl/Kokkos_Atomic_Decrement.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic fetch and sub
-//
-// template<class T>
-// T atomic_fetch_sub(volatile T* const dest, const T val)
-// { T tmp = *dest ; *dest -= val ; return tmp ; }
-
-#include "impl/Kokkos_Atomic_Fetch_Sub.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic fetch and or
-//
-// template<class T>
-// T atomic_fetch_or(volatile T* const dest, const T val)
-// { T tmp = *dest ; *dest = tmp | val ; return tmp ; }
-
-#include "impl/Kokkos_Atomic_Fetch_Or.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic fetch and and
-//
-// template<class T>
-// T atomic_fetch_and(volatile T* const dest, const T val)
-// { T tmp = *dest ; *dest = tmp & val ; return tmp ; }
-
-#include "impl/Kokkos_Atomic_Fetch_And.hpp"
-
-//----------------------------------------------------------------------------
-// Atomic MinMax
-//
-// template<class T>
-// T atomic_min(volatile T* const dest, const T val)
-// { T tmp = *dest ; *dest = min(*dest, val); return tmp ; }
-// template<class T>
-// T atomic_max(volatile T* const dest, const T val)
-// { T tmp = *dest ; *dest = max(*dest, val); return tmp ; }
-
-#include "impl/Kokkos_Atomic_MinMax.hpp"
-
-//----------------------------------------------------------------------------
-// Provide volatile_load and safe_load
-//
-// T volatile_load(T const volatile * const ptr);
-//
-// T const& safe_load(T const * const ptr);
-// XEON PHI
-// T safe_load(T const * const ptr
-
-#include "impl/Kokkos_Volatile_Load.hpp"
-
-//----------------------------------------------------------------------------
-// Provide atomic loads and stores with memory order semantics
-
-#include "impl/Kokkos_Atomic_Load.hpp"
-#include "impl/Kokkos_Atomic_Store.hpp"
-
-// Generic functions using the above defined functions
-#include "impl/Kokkos_Atomic_Generic_Secondary.hpp"
-//----------------------------------------------------------------------------
-// This atomic-style macro should be an inlined function, not a macro
-
-#if defined(KOKKOS_COMPILER_GNU) && !defined(__PGIC__) && \
-    !defined(__CUDA_ARCH__)
-
-#define KOKKOS_NONTEMPORAL_PREFETCH_LOAD(addr) __builtin_prefetch(addr, 0, 0)
-#define KOKKOS_NONTEMPORAL_PREFETCH_STORE(addr) __builtin_prefetch(addr, 1, 0)
-
-#else
-
-#define KOKKOS_NONTEMPORAL_PREFETCH_LOAD(addr) ((void)0)
-#define KOKKOS_NONTEMPORAL_PREFETCH_STORE(addr) ((void)0)
-
-#endif
-
-//----------------------------------------------------------------------------
-
-// Helper functions for places where we really should have called SeqCst atomics
-// anyway These can go away when we call desul unconditionally
-namespace Kokkos {
-namespace Impl {
-struct MemoryOrderSeqCst {};
-struct MemoryScopeDevice {};
-
-template <class T>
-KOKKOS_INLINE_FUNCTION void desul_atomic_dec(T* dest, MemoryOrderSeqCst,
-                                             MemoryScopeDevice) {
-  return Kokkos::atomic_decrement(dest);
-}
-
-template <class T>
-KOKKOS_INLINE_FUNCTION void desul_atomic_inc(T* dest, MemoryOrderSeqCst,
-                                             MemoryScopeDevice) {
-  return Kokkos::atomic_increment(dest);
-}
-
-template <class T>
-KOKKOS_INLINE_FUNCTION T
-desul_atomic_exchange(T* dest, Kokkos::Impl::type_identity_t<const T> val,
-                      MemoryOrderSeqCst, MemoryScopeDevice) {
-  return Kokkos::atomic_exchange(dest, val);
-}
-
-template <class T>
-KOKKOS_INLINE_FUNCTION T desul_atomic_compare_exchange(
-    T* dest, Kokkos::Impl::type_identity_t<const T> compare,
-    Kokkos::Impl::type_identity_t<const T> val, MemoryOrderSeqCst,
-    MemoryScopeDevice) {
-  return Kokkos::atomic_compare_exchange(dest, compare, val);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif /* !KOKKOS_ENABLE_IMPL_DESUL_ATOMICS */
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_ATOMIC
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_ATOMIC
diff --git a/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp b/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp
index 9da4b06110..1c43474632 100644
--- a/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp
+++ b/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp
@@ -22,7 +22,6 @@ static_assert(false,
 #ifndef KOKKOS_DESUL_ATOMICS_VOLATILE_WRAPPER_HPP_
 #define KOKKOS_DESUL_ATOMICS_VOLATILE_WRAPPER_HPP_
 #include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 #include <Kokkos_Atomics_Desul_Config.hpp>
 #include <desul/atomics.hpp>
 
@@ -195,5 +194,4 @@ T atomic_compare_exchange(volatile T* const dest, const T compare, const T desir
 #undef KOKKOS_DESUL_MEM_SCOPE
 
 // clang-format on
-#endif  // KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 #endif
diff --git a/core/src/Kokkos_Atomics_Desul_Wrapper.hpp b/core/src/Kokkos_Atomics_Desul_Wrapper.hpp
index fdc5e123f6..bda3783980 100644
--- a/core/src/Kokkos_Atomics_Desul_Wrapper.hpp
+++ b/core/src/Kokkos_Atomics_Desul_Wrapper.hpp
@@ -23,11 +23,9 @@ static_assert(false,
 #define KOKKOS_DESUL_ATOMICS_WRAPPER_HPP_
 #include <Kokkos_Macros.hpp>
 
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 #include <Kokkos_Atomics_Desul_Config.hpp>
 #include <desul/atomics.hpp>
 
-#include <impl/Kokkos_Atomic_Memory_Order.hpp>
 #include <impl/Kokkos_Volatile_Load.hpp>
 
 // clang-format off
@@ -229,54 +227,25 @@ T atomic_compare_exchange(T* const dest, desul::Impl::dont_deduce_this_parameter
 }
 
 namespace Impl {
-
-  template<class MemoryOrder>
-  struct KokkosToDesulMemoryOrder;
-
-  template<>
-  struct KokkosToDesulMemoryOrder<memory_order_seq_cst_t> {
-    using type = desul::MemoryOrderSeqCst;
-  };
-  template<>
-  struct KokkosToDesulMemoryOrder<memory_order_acquire_t> {
-    using type = desul::MemoryOrderAcquire;
-  };
-  template<>
-  struct KokkosToDesulMemoryOrder<memory_order_release_t> {
-    using type = desul::MemoryOrderRelease;
-  };
-  template<>
-  struct KokkosToDesulMemoryOrder<memory_order_acq_rel_t> {
-    using type = desul::MemoryOrderAcqRel;
-  };
-  template<>
-  struct KokkosToDesulMemoryOrder<memory_order_relaxed_t> {
-    using type = desul::MemoryOrderRelaxed;
-  };
   template<class T, class MemOrderSuccess, class MemOrderFailure> KOKKOS_INLINE_FUNCTION
-  bool atomic_compare_exchange_strong(T* const dest, T& expected, const T desired, MemOrderSuccess, MemOrderFailure) {
-    return desul::atomic_compare_exchange_strong(dest, expected, desired,
-                  typename KokkosToDesulMemoryOrder<MemOrderSuccess>::type(),
-                  typename KokkosToDesulMemoryOrder<MemOrderFailure>::type(),
-                  KOKKOS_DESUL_MEM_SCOPE);
-
+  bool atomic_compare_exchange_strong(T* const dest, T& expected, const T desired, MemOrderSuccess succ, MemOrderFailure fail) {
+    return desul::atomic_compare_exchange_strong(dest, expected, desired, succ, fail, KOKKOS_DESUL_MEM_SCOPE);
   }
   template<class T, class MemoryOrder>
   KOKKOS_INLINE_FUNCTION
-  T atomic_load(const T* const src, MemoryOrder) {
-    return desul::atomic_load(src, typename KokkosToDesulMemoryOrder<MemoryOrder>::type(), KOKKOS_DESUL_MEM_SCOPE);
+  T atomic_load(const T* const src, MemoryOrder order) {
+    return desul::atomic_load(src, order, KOKKOS_DESUL_MEM_SCOPE);
   }
   template<class T, class MemoryOrder>
   KOKKOS_INLINE_FUNCTION
-  void atomic_store(T* const src, const T val, MemoryOrder) {
-    return desul::atomic_store(src, val, typename KokkosToDesulMemoryOrder<MemoryOrder>::type(), KOKKOS_DESUL_MEM_SCOPE);
+  void atomic_store(T* const src, const T val, MemoryOrder order) {
+    return desul::atomic_store(src, val, order, KOKKOS_DESUL_MEM_SCOPE);
   }
-}
+}  // namespace Impl
 
-}
+}  // namespace Kokkos
 
 #undef KOKKOS_DESUL_MEM_SCOPE
 
 // clang-format on
-#endif  // KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 #endif
diff --git a/core/src/Kokkos_BitManipulation.hpp b/core/src/Kokkos_BitManipulation.hpp
new file mode 100644
index 0000000000..e541f179c8
--- /dev/null
+++ b/core/src/Kokkos_BitManipulation.hpp
@@ -0,0 +1,506 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_BIT_MANIPULATION_HPP
+#define KOKKOS_BIT_MANIPULATION_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <Kokkos_NumericTraits.hpp>
+#include <climits>  // CHAR_BIT
+#include <cstring>  //memcpy
+#include <type_traits>
+
+namespace Kokkos::Impl {
+
+template <class T>
+KOKKOS_FUNCTION constexpr T byteswap_fallback(T x) {
+  if constexpr (sizeof(T) > 1) {
+    using U = std::make_unsigned_t<T>;
+
+    size_t shift = CHAR_BIT * (sizeof(T) - 1);
+
+    U lo_mask = static_cast<unsigned char>(~0);
+    U hi_mask = lo_mask << shift;
+
+    U val = x;
+
+    for (size_t i = 0; i < sizeof(T) / 2; ++i) {
+      U lo_val = val & lo_mask;
+      U hi_val = val & hi_mask;
+
+      val = (val & ~lo_mask) | (hi_val >> shift);
+      val = (val & ~hi_mask) | (lo_val << shift);
+
+      lo_mask <<= CHAR_BIT;
+      hi_mask >>= CHAR_BIT;
+
+      shift -= 2 * CHAR_BIT;
+    }
+    return val;
+  }
+  // sizeof(T) == 1
+  return x;
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr int countl_zero_fallback(T x) {
+  // From Hacker's Delight (2nd edition) section 5-3
+  unsigned int y = 0;
+  using ::Kokkos::Experimental::digits_v;
+  int n = digits_v<T>;
+  int c = digits_v<T> / 2;
+  do {
+    y = x >> c;
+    if (y != 0) {
+      n -= c;
+      x = y;
+    }
+    c >>= 1;
+  } while (c != 0);
+  return n - static_cast<int>(x);
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr int countr_zero_fallback(T x) {
+  using ::Kokkos::Experimental::digits_v;
+  return digits_v<T> - countl_zero_fallback(static_cast<T>(
+                           static_cast<T>(~x) & static_cast<T>(x - 1)));
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr int popcount_fallback(T x) {
+  int c = 0;
+  for (; x != 0; x &= x - 1) {
+    ++c;
+  }
+  return c;
+}
+
+template <class T>
+inline constexpr bool is_standard_unsigned_integer_type_v =
+    std::is_same_v<T, unsigned char> || std::is_same_v<T, unsigned short> ||
+    std::is_same_v<T, unsigned int> || std::is_same_v<T, unsigned long> ||
+    std::is_same_v<T, unsigned long long>;
+
+}  // namespace Kokkos::Impl
+
+namespace Kokkos {
+
+//<editor-fold desc="[bit.cast], bit_cast">
+// FIXME_SYCL intel/llvm has unqualified calls to bit_cast which are ambiguous
+// if we declare our own bit_cast function
+#ifdef KOKKOS_ENABLE_SYCL
+using sycl::detail::bit_cast;
+#else
+template <class To, class From>
+KOKKOS_FUNCTION std::enable_if_t<sizeof(To) == sizeof(From) &&
+                                     std::is_trivially_copyable_v<To> &&
+                                     std::is_trivially_copyable_v<From>,
+                                 To>
+bit_cast(From const& from) noexcept {
+  To to;
+  memcpy(&to, &from, sizeof(To));
+  return to;
+}
+#endif
+//</editor-fold>
+
+//<editor-fold desc="[bit.byteswap], byteswap">
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<std::is_integral_v<T>, T> byteswap(
+    T value) noexcept {
+  return Impl::byteswap_fallback(value);
+}
+//</editor-fold>
+
+//<editor-fold desc="[bit.count], counting">
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, int>
+countl_zero(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  if (x == 0) return digits_v<T>;
+  // TODO use compiler intrinsics when available
+  return Impl::countl_zero_fallback(x);
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, int>
+countl_one(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  using ::Kokkos::Experimental::finite_max_v;
+  if (x == finite_max_v<T>) return digits_v<T>;
+  return countl_zero(static_cast<T>(~x));
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, int>
+countr_zero(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  if (x == 0) return digits_v<T>;
+  // TODO use compiler intrinsics when available
+  return Impl::countr_zero_fallback(x);
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, int>
+countr_one(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  using ::Kokkos::Experimental::finite_max_v;
+  if (x == finite_max_v<T>) return digits_v<T>;
+  return countr_zero(static_cast<T>(~x));
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, int>
+popcount(T x) noexcept {
+  if (x == 0) return 0;
+  // TODO use compiler intrinsics when available
+  return Impl::popcount_fallback(x);
+}
+//</editor-fold>
+
+//<editor-fold desc="[bit.pow.two], integral powers of 2">
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, bool>
+has_single_bit(T x) noexcept {
+  return x != 0 && (((x & (x - 1)) == 0));
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, T>
+bit_ceil(T x) noexcept {
+  if (x <= 1) return 1;
+  using ::Kokkos::Experimental::digits_v;
+  return T{1} << (digits_v<T> - countl_zero(static_cast<T>(x - 1)));
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, T>
+bit_floor(T x) noexcept {
+  if (x == 0) return 0;
+  using ::Kokkos::Experimental::digits_v;
+  return T{1} << (digits_v<T> - 1 - countl_zero(x));
+}
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, T>
+bit_width(T x) noexcept {
+  if (x == 0) return 0;
+  using ::Kokkos::Experimental::digits_v;
+  return digits_v<T> - countl_zero(x);
+}
+//</editor-fold>
+
+//<editor-fold desc="[bit.rotate], rotating">
+template <class T>
+[[nodiscard]] KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, T>
+rotl(T x, int s) noexcept {
+  using Experimental::digits_v;
+  constexpr auto dig = digits_v<T>;
+  int const rem      = s % dig;
+  if (rem == 0) return x;
+  if (rem > 0) return (x << rem) | (x >> ((dig - rem) % dig));
+  return (x >> -rem) | (x << ((dig + rem) % dig));  // rotr(x, -rem)
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FUNCTION constexpr std::enable_if_t<
+    Impl::is_standard_unsigned_integer_type_v<T>, T>
+rotr(T x, int s) noexcept {
+  using Experimental::digits_v;
+  constexpr auto dig = digits_v<T>;
+  int const rem      = s % dig;
+  if (rem == 0) return x;
+  if (rem > 0) return (x >> rem) | (x << ((dig - rem) % dig));
+  return (x << -rem) | (x >> ((dig + rem) % dig));  // rotl(x, -rem)
+}
+//</editor-fold>
+
+}  // namespace Kokkos
+
+namespace Kokkos::Impl {
+
+#if defined(KOKKOS_COMPILER_CLANG) || defined(KOKKOS_COMPILER_INTEL_LLVM) || \
+    defined(KOKKOS_COMPILER_GNU)
+#define KOKKOS_IMPL_USE_GCC_BUILT_IN_FUNCTIONS
+#endif
+
+template <class T>
+KOKKOS_IMPL_DEVICE_FUNCTION T byteswap_builtin_device(T x) noexcept {
+  return byteswap_fallback(x);
+}
+
+template <class T>
+KOKKOS_IMPL_HOST_FUNCTION T byteswap_builtin_host(T x) noexcept {
+#ifdef KOKKOS_IMPL_USE_GCC_BUILT_IN_FUNCTIONS
+  if constexpr (sizeof(T) == 1) {
+    return x;
+  } else if constexpr (sizeof(T) == 2) {
+    return __builtin_bswap16(x);
+  } else if constexpr (sizeof(T) == 4) {
+    return __builtin_bswap32(x);
+  } else if constexpr (sizeof(T) == 8) {
+    return __builtin_bswap64(x);
+  } else if constexpr (sizeof(T) == 16) {
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_bswap128)
+    return __builtin_bswap128(x);
+#endif
+#endif
+    return (__builtin_bswap64(x >> 64) |
+            (static_cast<T>(__builtin_bswap64(x)) << 64));
+  }
+#endif
+
+  return byteswap_fallback(x);
+}
+
+template <class T>
+KOKKOS_IMPL_DEVICE_FUNCTION
+    std::enable_if_t<is_standard_unsigned_integer_type_v<T>, int>
+    countl_zero_builtin_device(T x) noexcept {
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  if constexpr (sizeof(T) == sizeof(long long int)) {
+    return __clzll(reinterpret_cast<long long int&>(x));
+  } else if constexpr (sizeof(T) == sizeof(int)) {
+    return __clz(reinterpret_cast<int&>(x));
+  } else {
+    using ::Kokkos::Experimental::digits_v;
+    constexpr int shift = digits_v<unsigned int> - digits_v<T>;
+    return __clz(x) - shift;
+  }
+#elif defined(KOKKOS_ENABLE_SYCL)
+  return sycl::clz(x);
+#else
+  return countl_zero_fallback(x);
+#endif
+}
+
+template <class T>
+KOKKOS_IMPL_HOST_FUNCTION
+    std::enable_if_t<is_standard_unsigned_integer_type_v<T>, int>
+    countl_zero_builtin_host(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  if (x == 0) return digits_v<T>;
+#ifdef KOKKOS_IMPL_USE_GCC_BUILT_IN_FUNCTIONS
+  if constexpr (std::is_same_v<T, unsigned long long>) {
+    return __builtin_clzll(x);
+  } else if constexpr (std::is_same_v<T, unsigned long>) {
+    return __builtin_clzl(x);
+  } else if constexpr (std::is_same_v<T, unsigned int>) {
+    return __builtin_clz(x);
+  } else {
+    constexpr int shift = digits_v<unsigned int> - digits_v<T>;
+    return __builtin_clz(x) - shift;
+  }
+#else
+  return countl_zero_fallback(x);
+#endif
+}
+
+template <class T>
+KOKKOS_IMPL_DEVICE_FUNCTION
+    std::enable_if_t<is_standard_unsigned_integer_type_v<T>, int>
+    countr_zero_builtin_device(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  if (x == 0) return digits_v<T>;
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  if constexpr (sizeof(T) == sizeof(long long int)) {
+    return __ffsll(reinterpret_cast<long long int&>(x)) - 1;
+  } else {
+    return __ffs(reinterpret_cast<int&>(x)) - 1;
+  }
+#elif defined(KOKKOS_ENABLE_SYCL)
+  return sycl::ctz(x);
+#else
+  return countr_zero_fallback(x);
+#endif
+}
+
+template <class T>
+KOKKOS_IMPL_HOST_FUNCTION
+    std::enable_if_t<is_standard_unsigned_integer_type_v<T>, int>
+    countr_zero_builtin_host(T x) noexcept {
+  using ::Kokkos::Experimental::digits_v;
+  if (x == 0) return digits_v<T>;
+#ifdef KOKKOS_IMPL_USE_GCC_BUILT_IN_FUNCTIONS
+  if constexpr (std::is_same_v<T, unsigned long long>) {
+    return __builtin_ctzll(x);
+  } else if constexpr (std::is_same_v<T, unsigned long>) {
+    return __builtin_ctzl(x);
+  } else {
+    return __builtin_ctz(x);
+  }
+#else
+  return countr_zero_fallback(x);
+#endif
+}
+
+template <class T>
+KOKKOS_IMPL_DEVICE_FUNCTION
+    std::enable_if_t<is_standard_unsigned_integer_type_v<T>, int>
+    popcount_builtin_device(T x) noexcept {
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  if constexpr (sizeof(T) == sizeof(long long int)) {
+    return __popcll(x);
+  } else {
+    return __popc(x);
+  }
+#elif defined(KOKKOS_ENABLE_SYCL)
+  return sycl::popcount(x);
+#else
+  return popcount_fallback(x);
+#endif
+}
+
+template <class T>
+KOKKOS_IMPL_HOST_FUNCTION
+    std::enable_if_t<is_standard_unsigned_integer_type_v<T>, int>
+    popcount_builtin_host(T x) noexcept {
+#ifdef KOKKOS_IMPL_USE_GCC_BUILT_IN_FUNCTIONS
+  if constexpr (std::is_same_v<T, unsigned long long>) {
+    return __builtin_popcountll(x);
+  } else if constexpr (std::is_same_v<T, unsigned long>) {
+    return __builtin_popcountl(x);
+  } else {
+    return __builtin_popcount(x);
+  }
+#else
+  return popcount_fallback(x);
+#endif
+}
+
+#undef KOKKOS_IMPL_USE_GCC_BUILT_IN_FUNCTIONS
+
+}  // namespace Kokkos::Impl
+
+namespace Kokkos::Experimental {
+
+template <class To, class From>
+KOKKOS_FUNCTION std::enable_if_t<sizeof(To) == sizeof(From) &&
+                                     std::is_trivially_copyable_v<To> &&
+                                     std::is_trivially_copyable_v<From>,
+                                 To>
+bit_cast_builtin(From const& from) noexcept {
+  // qualify the call to avoid ADL
+  return Kokkos::bit_cast<To>(from);  // no benefit to call the _builtin variant
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<std::is_integral_v<T>, T> byteswap_builtin(
+    T x) noexcept {
+  KOKKOS_IF_ON_DEVICE((return ::Kokkos::Impl::byteswap_builtin_device(x);))
+  KOKKOS_IF_ON_HOST((return ::Kokkos::Impl::byteswap_builtin_host(x);))
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<
+    ::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, int>
+countl_zero_builtin(T x) noexcept {
+  KOKKOS_IF_ON_DEVICE((return ::Kokkos::Impl::countl_zero_builtin_device(x);))
+  KOKKOS_IF_ON_HOST((return ::Kokkos::Impl::countl_zero_builtin_host(x);))
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<
+    ::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, int>
+countl_one_builtin(T x) noexcept {
+  if (x == finite_max_v<T>) return digits_v<T>;
+  return countl_zero_builtin(static_cast<T>(~x));
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<
+    ::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, int>
+countr_zero_builtin(T x) noexcept {
+  KOKKOS_IF_ON_DEVICE((return ::Kokkos::Impl::countr_zero_builtin_device(x);))
+  KOKKOS_IF_ON_HOST((return ::Kokkos::Impl::countr_zero_builtin_host(x);))
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<
+    ::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, int>
+countr_one_builtin(T x) noexcept {
+  if (x == finite_max_v<T>) return digits_v<T>;
+  return countr_zero_builtin(static_cast<T>(~x));
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<
+    ::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, int>
+popcount_builtin(T x) noexcept {
+  KOKKOS_IF_ON_DEVICE((return ::Kokkos::Impl::popcount_builtin_device(x);))
+  KOKKOS_IF_ON_HOST((return ::Kokkos::Impl::popcount_builtin_host(x);))
+}
+
+template <class T>
+KOKKOS_FUNCTION std::enable_if_t<
+    ::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, bool>
+has_single_bit_builtin(T x) noexcept {
+  return has_single_bit(x);  // no benefit to call the _builtin variant
+}
+
+template <class T>
+KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, T>
+    bit_ceil_builtin(T x) noexcept {
+  if (x <= 1) return 1;
+  return T{1} << (digits_v<T> - countl_zero_builtin(static_cast<T>(x - 1)));
+}
+
+template <class T>
+KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, T>
+    bit_floor_builtin(T x) noexcept {
+  if (x == 0) return 0;
+  return T{1} << (digits_v<T> - 1 - countl_zero_builtin(x));
+}
+
+template <class T>
+KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, T>
+    bit_width_builtin(T x) noexcept {
+  if (x == 0) return 0;
+  return digits_v<T> - countl_zero_builtin(x);
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, T>
+    rotl_builtin(T x, int s) noexcept {
+  return rotl(x, s);  // no benefit to call the _builtin variant
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::Impl::is_standard_unsigned_integer_type_v<T>, T>
+    rotr_builtin(T x, int s) noexcept {
+  return rotr(x, s);  // no benefit to call the _builtin variant
+}
+
+}  // namespace Kokkos::Experimental
+
+#endif
diff --git a/core/src/Kokkos_CopyViews.hpp b/core/src/Kokkos_CopyViews.hpp
index 6d5d9548c7..02b9cc8bd1 100644
--- a/core/src/Kokkos_CopyViews.hpp
+++ b/core/src/Kokkos_CopyViews.hpp
@@ -25,6 +25,7 @@ static_assert(false,
 #include <Kokkos_Parallel.hpp>
 #include <KokkosExp_MDRangePolicy.hpp>
 #include <Kokkos_Layout.hpp>
+#include <impl/Kokkos_HostSpace_ZeroMemset.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -534,7 +535,7 @@ void view_copy(const ExecutionSpace& space, const DstType& dst,
         "Kokkos::Impl::view_copy called with invalid execution space");
   } else {
     // Figure out iteration order in case we need it
-    int64_t strides[DstType::Rank + 1];
+    int64_t strides[DstType::rank + 1];
     dst.stride(strides);
     Kokkos::Iterate iterate;
     if (Kokkos::is_layouttiled<typename DstType::array_layout>::value) {
@@ -548,7 +549,7 @@ void view_copy(const ExecutionSpace& space, const DstType& dst,
       iterate = Kokkos::Iterate::Left;
     } else if (std::is_same<typename DstType::array_layout,
                             Kokkos::LayoutStride>::value) {
-      if (strides[0] > strides[DstType::Rank - 1])
+      if (strides[0] > strides[DstType::rank - 1])
         iterate = Kokkos::Iterate::Right;
       else
         iterate = Kokkos::Iterate::Left;
@@ -566,26 +567,26 @@ void view_copy(const ExecutionSpace& space, const DstType& dst,
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutRight, ExecutionSpace, DstType::Rank, int64_t>(
+            Kokkos::LayoutRight, ExecutionSpace, DstType::rank, int64_t>(
             dst, src, space);
       else
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutLeft, ExecutionSpace, DstType::Rank, int64_t>(
+            Kokkos::LayoutLeft, ExecutionSpace, DstType::rank, int64_t>(
             dst, src, space);
     } else {
       if (iterate == Kokkos::Iterate::Right)
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutRight, ExecutionSpace, DstType::Rank, int>(dst, src,
+            Kokkos::LayoutRight, ExecutionSpace, DstType::rank, int>(dst, src,
                                                                      space);
       else
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutLeft, ExecutionSpace, DstType::Rank, int>(dst, src,
+            Kokkos::LayoutLeft, ExecutionSpace, DstType::rank, int>(dst, src,
                                                                     space);
     }
   }
@@ -620,7 +621,7 @@ void view_copy(const DstType& dst, const SrcType& src) {
   }
 
   // Figure out iteration order in case we need it
-  int64_t strides[DstType::Rank + 1];
+  int64_t strides[DstType::rank + 1];
   dst.stride(strides);
   Kokkos::Iterate iterate;
   if (Kokkos::is_layouttiled<typename DstType::array_layout>::value) {
@@ -634,7 +635,7 @@ void view_copy(const DstType& dst, const SrcType& src) {
     iterate = Kokkos::Iterate::Left;
   } else if (std::is_same<typename DstType::array_layout,
                           Kokkos::LayoutStride>::value) {
-    if (strides[0] > strides[DstType::Rank - 1])
+    if (strides[0] > strides[DstType::rank - 1])
       iterate = Kokkos::Iterate::Right;
     else
       iterate = Kokkos::Iterate::Left;
@@ -653,26 +654,26 @@ void view_copy(const DstType& dst, const SrcType& src) {
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutRight, dst_execution_space, DstType::Rank, int64_t>(
+            Kokkos::LayoutRight, dst_execution_space, DstType::rank, int64_t>(
             dst, src);
       else
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutLeft, dst_execution_space, DstType::Rank, int64_t>(
+            Kokkos::LayoutLeft, dst_execution_space, DstType::rank, int64_t>(
             dst, src);
     } else {
       if (iterate == Kokkos::Iterate::Right)
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutRight, src_execution_space, DstType::Rank, int64_t>(
+            Kokkos::LayoutRight, src_execution_space, DstType::rank, int64_t>(
             dst, src);
       else
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutLeft, src_execution_space, DstType::Rank, int64_t>(
+            Kokkos::LayoutLeft, src_execution_space, DstType::rank, int64_t>(
             dst, src);
     }
   } else {
@@ -681,26 +682,26 @@ void view_copy(const DstType& dst, const SrcType& src) {
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutRight, dst_execution_space, DstType::Rank, int>(dst,
+            Kokkos::LayoutRight, dst_execution_space, DstType::rank, int>(dst,
                                                                           src);
       else
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutLeft, dst_execution_space, DstType::Rank, int>(dst,
+            Kokkos::LayoutLeft, dst_execution_space, DstType::rank, int>(dst,
                                                                          src);
     } else {
       if (iterate == Kokkos::Iterate::Right)
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutRight, src_execution_space, DstType::Rank, int>(dst,
+            Kokkos::LayoutRight, src_execution_space, DstType::rank, int>(dst,
                                                                           src);
       else
         Kokkos::Impl::ViewCopy<
             typename DstType::uniform_runtime_nomemspace_type,
             typename SrcType::uniform_runtime_const_nomemspace_type,
-            Kokkos::LayoutLeft, src_execution_space, DstType::Rank, int>(dst,
+            Kokkos::LayoutLeft, src_execution_space, DstType::rank, int>(dst,
                                                                          src);
     }
   }
@@ -832,7 +833,7 @@ struct CommonSubview<DstType, SrcType, 8, Arg0, Arg1, Arg2, Arg3, Arg4, Arg5,
 
 template <class DstType, class SrcType,
           class ExecSpace = typename DstType::execution_space,
-          int Rank        = DstType::Rank>
+          int Rank        = DstType::rank>
 struct ViewRemap;
 
 template <class DstType, class SrcType, class ExecSpace>
@@ -874,7 +875,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 2> {
       } else {
         p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 2, Kokkos::Impl::ALL_t, p_type>;
+            CommonSubview<DstType, SrcType, 2, Kokkos::ALL_t, p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1);
         view_copy(exec_space..., common_subview.dst_sub,
                   common_subview.src_sub);
@@ -883,7 +884,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 2> {
       if (dst.extent(1) == src.extent(1)) {
         p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 2, p_type, Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 2, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
                   common_subview.src_sub);
@@ -915,8 +916,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 3> {
       if (dst.extent(2) == src.extent(2)) {
         p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 3, Kokkos::Impl::ALL_t, p_type,
-                          Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 3, Kokkos::ALL_t, p_type,
+                          Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1,
                                        Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -925,8 +926,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 3> {
         p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
         p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 3, Kokkos::Impl::ALL_t, p_type,
-                          p_type>;
+            CommonSubview<DstType, SrcType, 3, Kokkos::ALL_t, p_type, p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2);
         view_copy(exec_space..., common_subview.dst_sub,
                   common_subview.src_sub);
@@ -935,8 +935,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 3> {
       if (dst.extent(2) == src.extent(2)) {
         p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
         p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
-        using sv_adapter_type = CommonSubview<DstType, SrcType, 3, p_type,
-                                              p_type, Kokkos::Impl::ALL_t>;
+        using sv_adapter_type =
+            CommonSubview<DstType, SrcType, 3, p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, ext1, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
                   common_subview.src_sub);
@@ -970,8 +970,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 4> {
         p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
         p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 4, Kokkos::Impl::ALL_t, p_type,
-                          p_type, Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 4, Kokkos::ALL_t, p_type, p_type,
+                          Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2,
                                        Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -981,8 +981,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 4> {
         p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
         p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 4, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type>;
+            CommonSubview<DstType, SrcType, 4, Kokkos::ALL_t, p_type, p_type,
+                          p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3);
         view_copy(exec_space..., common_subview.dst_sub,
                   common_subview.src_sub);
@@ -992,9 +992,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 4> {
         p_type ext0(0, std::min(dst.extent(0), src.extent(0)));
         p_type ext1(0, std::min(dst.extent(1), src.extent(1)));
         p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
-        using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 4, p_type, p_type, p_type,
-                          Kokkos::Impl::ALL_t>;
+        using sv_adapter_type = CommonSubview<DstType, SrcType, 4, p_type,
+                                              p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
                   common_subview.src_sub);
@@ -1030,8 +1029,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 5> {
         p_type ext2(0, std::min(dst.extent(2), src.extent(2)));
         p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 5, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 5, Kokkos::ALL_t, p_type, p_type,
+                          p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1042,8 +1041,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 5> {
         p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
         p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 5, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type>;
+            CommonSubview<DstType, SrcType, 5, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1057,7 +1056,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 5> {
         p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
         using sv_adapter_type =
             CommonSubview<DstType, SrcType, 5, p_type, p_type, p_type, p_type,
-                          Kokkos::Impl::ALL_t>;
+                          Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3,
                                        Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1095,8 +1094,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 6> {
         p_type ext3(0, std::min(dst.extent(3), src.extent(3)));
         p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 6, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type, Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 6, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1108,8 +1107,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 6> {
         p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
         p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 6, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type, p_type>;
+            CommonSubview<DstType, SrcType, 6, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type, p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4, ext5);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1125,7 +1124,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 6> {
 
         using sv_adapter_type =
             CommonSubview<DstType, SrcType, 6, p_type, p_type, p_type, p_type,
-                          p_type, Kokkos::Impl::ALL_t>;
+                          p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
                                        Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1169,8 +1168,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 7> {
         p_type ext4(0, std::min(dst.extent(4), src.extent(4)));
         p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 7, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type, p_type, Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 7, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4, ext5, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1183,8 +1182,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 7> {
         p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
         p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 7, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type, p_type, p_type>;
+            CommonSubview<DstType, SrcType, 7, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type, p_type, p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4, ext5, ext6);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1200,7 +1199,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 7> {
         p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
         using sv_adapter_type =
             CommonSubview<DstType, SrcType, 7, p_type, p_type, p_type, p_type,
-                          p_type, p_type, Kokkos::Impl::ALL_t>;
+                          p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
                                        ext5, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1245,9 +1244,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 8> {
         p_type ext5(0, std::min(dst.extent(5), src.extent(5)));
         p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 8, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type, p_type, p_type,
-                          Kokkos::Impl::ALL_t>;
+            CommonSubview<DstType, SrcType, 8, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type, p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4, ext5, ext6, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1261,8 +1259,8 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 8> {
         p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
         p_type ext7(0, std::min(dst.extent(7), src.extent(7)));
         using sv_adapter_type =
-            CommonSubview<DstType, SrcType, 8, Kokkos::Impl::ALL_t, p_type,
-                          p_type, p_type, p_type, p_type, p_type, p_type>;
+            CommonSubview<DstType, SrcType, 8, Kokkos::ALL_t, p_type, p_type,
+                          p_type, p_type, p_type, p_type, p_type>;
         sv_adapter_type common_subview(dst, src, Kokkos::ALL, ext1, ext2, ext3,
                                        ext4, ext5, ext6, ext7);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1279,7 +1277,7 @@ struct ViewRemap<DstType, SrcType, ExecSpace, 8> {
         p_type ext6(0, std::min(dst.extent(6), src.extent(6)));
         using sv_adapter_type =
             CommonSubview<DstType, SrcType, 8, p_type, p_type, p_type, p_type,
-                          p_type, p_type, p_type, Kokkos::Impl::ALL_t>;
+                          p_type, p_type, p_type, Kokkos::ALL_t>;
         sv_adapter_type common_subview(dst, src, ext0, ext1, ext2, ext3, ext4,
                                        ext5, ext6, Kokkos::ALL);
         view_copy(exec_space..., common_subview.dst_sub,
@@ -1313,7 +1311,7 @@ inline void contiguous_fill(
   using ViewTypeFlat = Kokkos::View<
       typename ViewType::value_type*, Kokkos::LayoutRight,
       Kokkos::Device<typename ViewType::execution_space,
-                     std::conditional_t<ViewType::Rank == 0,
+                     std::conditional_t<ViewType::rank == 0,
                                         typename ViewType::memory_space,
                                         Kokkos::AnonymousSpace>>,
       Kokkos::MemoryTraits<0>>;
@@ -1321,23 +1319,23 @@ inline void contiguous_fill(
   ViewTypeFlat dst_flat(dst.data(), dst.size());
   if (dst.span() < static_cast<size_t>(std::numeric_limits<int>::max())) {
     Kokkos::Impl::ViewFill<ViewTypeFlat, Kokkos::LayoutRight, ExecutionSpace,
-                           ViewTypeFlat::Rank, int>(dst_flat, value,
+                           ViewTypeFlat::rank, int>(dst_flat, value,
                                                     exec_space);
   } else
     Kokkos::Impl::ViewFill<ViewTypeFlat, Kokkos::LayoutRight, ExecutionSpace,
-                           ViewTypeFlat::Rank, int64_t>(dst_flat, value,
+                           ViewTypeFlat::rank, int64_t>(dst_flat, value,
                                                         exec_space);
 }
 
-template <typename ExecutionSpace, class DT, class... DP>
+// Default implementation for execution spaces that don't provide a definition
+template <typename ExecutionSpace, class ViewType>
 struct ZeroMemset {
-  ZeroMemset(const ExecutionSpace& exec_space, const View<DT, DP...>& dst,
-             typename ViewTraits<DT, DP...>::const_value_type& value) {
+  ZeroMemset(const ExecutionSpace& exec_space, const ViewType& dst,
+             typename ViewType::const_value_type& value) {
     contiguous_fill(exec_space, dst, value);
   }
 
-  ZeroMemset(const View<DT, DP...>& dst,
-             typename ViewTraits<DT, DP...>::const_value_type& value) {
+  ZeroMemset(const ViewType& dst, typename ViewType::const_value_type& value) {
     contiguous_fill(ExecutionSpace(), dst, value);
   }
 };
@@ -1354,7 +1352,7 @@ contiguous_fill_or_memset(
 // leading to the significant performance issues
 #ifndef KOKKOS_ARCH_A64FX
   if (Impl::is_zero_byte(value))
-    ZeroMemset<ExecutionSpace, DT, DP...>(exec_space, dst, value);
+    ZeroMemset<ExecutionSpace, View<DT, DP...>>(exec_space, dst, value);
   else
 #endif
     contiguous_fill(exec_space, dst, value);
@@ -1386,7 +1384,7 @@ contiguous_fill_or_memset(
 // leading to the significant performance issues
 #ifndef KOKKOS_ARCH_A64FX
   if (Impl::is_zero_byte(value))
-    ZeroMemset<exec_space_type, DT, DP...>(dst, value);
+    ZeroMemset<exec_space_type, View<DT, DP...>>(dst, value);
   else
 #endif
     contiguous_fill(exec_space_type(), dst, value);
@@ -1450,7 +1448,7 @@ inline void deep_copy(
   }
 
   // Figure out iteration order to do the ViewFill
-  int64_t strides[ViewType::Rank + 1];
+  int64_t strides[ViewType::rank + 1];
   dst.stride(strides);
   Kokkos::Iterate iterate;
   if (std::is_same<typename ViewType::array_layout,
@@ -1461,7 +1459,7 @@ inline void deep_copy(
     iterate = Kokkos::Iterate::Left;
   } else if (std::is_same<typename ViewType::array_layout,
                           Kokkos::LayoutStride>::value) {
-    if (strides[0] > strides[ViewType::Rank > 0 ? ViewType::Rank - 1 : 0])
+    if (strides[0] > strides[ViewType::rank > 0 ? ViewType::rank - 1 : 0])
       iterate = Kokkos::Iterate::Right;
     else
       iterate = Kokkos::Iterate::Left;
@@ -1476,26 +1474,26 @@ inline void deep_copy(
   // Lets call the right ViewFill functor based on integer space needed and
   // iteration type
   using ViewTypeUniform =
-      std::conditional_t<ViewType::Rank == 0,
+      std::conditional_t<ViewType::rank == 0,
                          typename ViewType::uniform_runtime_type,
                          typename ViewType::uniform_runtime_nomemspace_type>;
   if (dst.span() > static_cast<size_t>(std::numeric_limits<int>::max())) {
     if (iterate == Kokkos::Iterate::Right)
       Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutRight,
-                             exec_space_type, ViewType::Rank, int64_t>(
+                             exec_space_type, ViewType::rank, int64_t>(
           dst, value, exec_space_type());
     else
       Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutLeft,
-                             exec_space_type, ViewType::Rank, int64_t>(
+                             exec_space_type, ViewType::rank, int64_t>(
           dst, value, exec_space_type());
   } else {
     if (iterate == Kokkos::Iterate::Right)
       Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutRight,
-                             exec_space_type, ViewType::Rank, int>(
+                             exec_space_type, ViewType::rank, int>(
           dst, value, exec_space_type());
     else
       Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutLeft,
-                             exec_space_type, ViewType::Rank, int>(
+                             exec_space_type, ViewType::rank, int>(
           dst, value, exec_space_type());
   }
   Kokkos::fence("Kokkos::deep_copy: scalar copy, post copy fence");
@@ -1639,19 +1637,19 @@ inline void deep_copy(
           "match: ");
       message += dst.label();
       message += "(";
-      for (int r = 0; r < dst_type::Rank - 1; r++) {
-        message += std::to_string(dst.extent(r));
+      message += std::to_string(dst.extent(0));
+      for (size_t r = 1; r < dst_type::rank; r++) {
         message += ",";
+        message += std::to_string(dst.extent(r));
       }
-      message += std::to_string(dst.extent(dst_type::Rank - 1));
       message += ") ";
       message += src.label();
       message += "(";
-      for (int r = 0; r < src_type::Rank - 1; r++) {
-        message += std::to_string(src.extent(r));
+      message += std::to_string(src.extent(0));
+      for (size_t r = 1; r < src_type::rank; r++) {
         message += ",";
+        message += std::to_string(src.extent(r));
       }
-      message += std::to_string(src.extent(src_type::Rank - 1));
       message += ") ";
 
       Kokkos::Impl::throw_runtime_exception(message);
@@ -1722,19 +1720,19 @@ inline void deep_copy(
         "Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
     message += dst.label();
     message += "(";
-    for (int r = 0; r < dst_type::Rank - 1; r++) {
-      message += std::to_string(dst.extent(r));
+    message += std::to_string(dst.extent(0));
+    for (size_t r = 1; r < dst_type::rank; r++) {
       message += ",";
+      message += std::to_string(dst.extent(r));
     }
-    message += std::to_string(dst.extent(dst_type::Rank - 1));
     message += ") ";
     message += src.label();
     message += "(";
-    for (int r = 0; r < src_type::Rank - 1; r++) {
-      message += std::to_string(src.extent(r));
+    message += std::to_string(src.extent(0));
+    for (size_t r = 1; r < src_type::rank; r++) {
       message += ",";
+      message += std::to_string(src.extent(r));
     }
-    message += std::to_string(src.extent(src_type::Rank - 1));
     message += ") ";
 
     Kokkos::Impl::throw_runtime_exception(message);
@@ -2562,7 +2560,7 @@ inline void deep_copy(
   } else {
     using ViewType = View<DT, DP...>;
     // Figure out iteration order to do the ViewFill
-    int64_t strides[ViewType::Rank + 1];
+    int64_t strides[ViewType::rank + 1];
     dst.stride(strides);
     Kokkos::Iterate iterate;
     if (std::is_same<typename ViewType::array_layout,
@@ -2573,7 +2571,7 @@ inline void deep_copy(
       iterate = Kokkos::Iterate::Left;
     } else if (std::is_same<typename ViewType::array_layout,
                             Kokkos::LayoutStride>::value) {
-      if (strides[0] > strides[ViewType::Rank > 0 ? ViewType::Rank - 1 : 0])
+      if (strides[0] > strides[ViewType::rank > 0 ? ViewType::rank - 1 : 0])
         iterate = Kokkos::Iterate::Right;
       else
         iterate = Kokkos::Iterate::Left;
@@ -2588,23 +2586,23 @@ inline void deep_copy(
     // Lets call the right ViewFill functor based on integer space needed and
     // iteration type
     using ViewTypeUniform =
-        std::conditional_t<ViewType::Rank == 0,
+        std::conditional_t<ViewType::rank == 0,
                            typename ViewType::uniform_runtime_type,
                            typename ViewType::uniform_runtime_nomemspace_type>;
     if (dst.span() > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
       if (iterate == Kokkos::Iterate::Right)
         Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutRight, ExecSpace,
-                               ViewType::Rank, int64_t>(dst, value, space);
+                               ViewType::rank, int64_t>(dst, value, space);
       else
         Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutLeft, ExecSpace,
-                               ViewType::Rank, int64_t>(dst, value, space);
+                               ViewType::rank, int64_t>(dst, value, space);
     } else {
       if (iterate == Kokkos::Iterate::Right)
         Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutRight, ExecSpace,
-                               ViewType::Rank, int32_t>(dst, value, space);
+                               ViewType::rank, int32_t>(dst, value, space);
       else
         Kokkos::Impl::ViewFill<ViewTypeUniform, Kokkos::LayoutLeft, ExecSpace,
-                               ViewType::Rank, int32_t>(dst, value, space);
+                               ViewType::rank, int32_t>(dst, value, space);
     }
   }
   if (Kokkos::Tools::Experimental::get_callbacks().end_deep_copy != nullptr) {
@@ -2646,7 +2644,7 @@ inline void deep_copy(
       Impl::contiguous_fill_or_memset(fill_exec_space(), dst, value);
     } else {
       using ViewTypeUniform = std::conditional_t<
-          View<DT, DP...>::Rank == 0,
+          View<DT, DP...>::rank == 0,
           typename View<DT, DP...>::uniform_runtime_type,
           typename View<DT, DP...>::uniform_runtime_nomemspace_type>;
       Kokkos::Impl::ViewFill<ViewTypeUniform, typename dst_traits::array_layout,
@@ -2803,19 +2801,19 @@ inline void deep_copy(
           "match: ");
       message += dst.label();
       message += "(";
-      for (int r = 0; r < dst_type::Rank - 1; r++) {
-        message += std::to_string(dst.extent(r));
+      message += std::to_string(dst.extent(0));
+      for (size_t r = 1; r < dst_type::rank; r++) {
         message += ",";
+        message += std::to_string(dst.extent(r));
       }
-      message += std::to_string(dst.extent(dst_type::Rank - 1));
       message += ") ";
       message += src.label();
       message += "(";
-      for (int r = 0; r < src_type::Rank - 1; r++) {
-        message += std::to_string(src.extent(r));
+      message += std::to_string(src.extent(0));
+      for (size_t r = 1; r < src_type::rank; r++) {
         message += ",";
+        message += std::to_string(src.extent(r));
       }
-      message += std::to_string(src.extent(src_type::Rank - 1));
       message += ") ";
 
       Kokkos::Impl::throw_runtime_exception(message);
@@ -2872,19 +2870,19 @@ inline void deep_copy(
         "Deprecation Error: Kokkos::deep_copy extents of views don't match: ");
     message += dst.label();
     message += "(";
-    for (int r = 0; r < dst_type::Rank - 1; r++) {
-      message += std::to_string(dst.extent(r));
+    message += std::to_string(dst.extent(0));
+    for (size_t r = 1; r < dst_type::rank; r++) {
       message += ",";
+      message += std::to_string(dst.extent(r));
     }
-    message += std::to_string(dst.extent(dst_type::Rank - 1));
     message += ") ";
     message += src.label();
     message += "(";
-    for (int r = 0; r < src_type::Rank - 1; r++) {
-      message += std::to_string(src.extent(r));
+    message += std::to_string(src.extent(0));
+    for (size_t r = 1; r < src_type::rank; r++) {
       message += ",";
+      message += std::to_string(src.extent(r));
     }
-    message += std::to_string(src.extent(src_type::Rank - 1));
     message += ") ";
 
     Kokkos::Impl::throw_runtime_exception(message);
diff --git a/core/src/Kokkos_Core.hpp b/core/src/Kokkos_Core.hpp
index cf898a71e7..805411a699 100644
--- a/core/src/Kokkos_Core.hpp
+++ b/core/src/Kokkos_Core.hpp
@@ -53,6 +53,7 @@
 #include <Kokkos_MathematicalFunctions.hpp>
 #include <Kokkos_MathematicalSpecialFunctions.hpp>
 #include <Kokkos_NumericTraits.hpp>
+#include <Kokkos_BitManipulation.hpp>
 #include <Kokkos_MemoryPool.hpp>
 #include <Kokkos_Array.hpp>
 #include <Kokkos_View.hpp>
@@ -99,6 +100,9 @@ void declare_configuration_metadata(const std::string& category,
 [[nodiscard]] bool is_initialized() noexcept;
 [[nodiscard]] bool is_finalized() noexcept;
 
+[[nodiscard]] int device_id() noexcept;
+[[nodiscard]] int num_threads() noexcept;
+
 bool show_warnings() noexcept;
 bool tune_internals() noexcept;
 
@@ -270,7 +274,7 @@ std::vector<ExecSpace> partition_space(ExecSpace const& space, Args...) {
 
 template <class ExecSpace, class T>
 std::vector<ExecSpace> partition_space(ExecSpace const& space,
-                                       std::vector<T>& weights) {
+                                       std::vector<T> const& weights) {
   static_assert(is_execution_space<ExecSpace>::value,
                 "Kokkos Error: partition_space expects an Execution Space as "
                 "first argument");
diff --git a/core/src/Kokkos_Core_fwd.hpp b/core/src/Kokkos_Core_fwd.hpp
index a0b4df0c4b..25f89ae3c7 100644
--- a/core/src/Kokkos_Core_fwd.hpp
+++ b/core/src/Kokkos_Core_fwd.hpp
@@ -34,11 +34,15 @@
 #endif
 
 //----------------------------------------------------------------------------
-// Have assumed a 64bit build (8byte pointers) throughout the code base.
-
+// Have assumed a 64-bit build (8-byte pointers) throughout the code base.
+// 32-bit build allowed but unsupported.
+#ifdef KOKKOS_IMPL_32BIT
+static_assert(sizeof(void *) == 4,
+              "Kokkos assumes 64-bit build; i.e., 4-byte pointers");
+#else
 static_assert(sizeof(void *) == 8,
               "Kokkos assumes 64-bit build; i.e., 8-byte pointers");
-
+#endif
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
@@ -293,12 +297,9 @@ template <class DstSpace, class SrcSpace,
           class Enable         = void>
 struct DeepCopy;
 
-template <typename ExecutionSpace, class DT, class... DP>
-struct ZeroMemset;
-
 template <class ViewType, class Layout = typename ViewType::array_layout,
           class ExecSpace = typename ViewType::execution_space,
-          int Rank = ViewType::Rank, typename iType = int64_t>
+          int Rank = ViewType::rank, typename iType = int64_t>
 struct ViewFill;
 
 template <class ViewTypeA, class ViewTypeB, class Layout, class ExecSpace,
@@ -325,11 +326,14 @@ class ParallelFor;
 ///
 /// This is an implementation detail of parallel_reduce.  Users should
 /// skip this and go directly to the nonmember function parallel_reduce.
-template <class FunctorType, class ExecPolicy, class ReducerType = InvalidType,
-          class ExecutionSpace = typename Impl::FunctorPolicyExecutionSpace<
-              FunctorType, ExecPolicy>::execution_space>
+template <typename CombinedFunctorReducerType, typename PolicyType,
+          typename ExecutionSpaceType>
 class ParallelReduce;
 
+template <typename FunctorType, typename FunctorAnalysisReducerType,
+          typename Enable = void>
+class CombinedFunctorReducer;
+
 /// \class ParallelScan
 /// \brief Implementation detail of parallel_scan.
 ///
diff --git a/core/src/Kokkos_ExecPolicy.hpp b/core/src/Kokkos_ExecPolicy.hpp
index 357c2572a5..ae1585a498 100644
--- a/core/src/Kokkos_ExecPolicy.hpp
+++ b/core/src/Kokkos_ExecPolicy.hpp
@@ -738,20 +738,11 @@ struct ThreadVectorRangeBoundariesStruct {
                                               const index_type& count) noexcept
       : start(static_cast<index_type>(0)), end(count) {}
 
-  KOKKOS_INLINE_FUNCTION
-  constexpr ThreadVectorRangeBoundariesStruct(const index_type& count) noexcept
-      : start(static_cast<index_type>(0)), end(count) {}
-
   KOKKOS_INLINE_FUNCTION
   constexpr ThreadVectorRangeBoundariesStruct(
       const TeamMemberType, const index_type& arg_begin,
       const index_type& arg_end) noexcept
       : start(static_cast<index_type>(arg_begin)), end(arg_end) {}
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr ThreadVectorRangeBoundariesStruct(
-      const index_type& arg_begin, const index_type& arg_end) noexcept
-      : start(static_cast<index_type>(arg_begin)), end(arg_end) {}
 };
 
 template <class TeamMemberType>
diff --git a/core/src/Kokkos_GraphNode.hpp b/core/src/Kokkos_GraphNode.hpp
index 1cfd2b382b..2a4e2cf641 100644
--- a/core/src/Kokkos_GraphNode.hpp
+++ b/core/src/Kokkos_GraphNode.hpp
@@ -376,14 +376,30 @@ class GraphNodeRef {
     auto policy = Experimental::require((Policy &&) arg_policy,
                                         Kokkos::Impl::KernelInGraphProperty{});
 
+    using passed_reducer_type = typename return_value_adapter::reducer_type;
+
+    using reducer_selector = Kokkos::Impl::if_c<
+        std::is_same<InvalidType, passed_reducer_type>::value, functor_type,
+        passed_reducer_type>;
+    using analysis = Kokkos::Impl::FunctorAnalysis<
+        Kokkos::Impl::FunctorPatternInterface::REDUCE, Policy,
+        typename reducer_selector::type,
+        typename return_value_adapter::value_type>;
+    typename analysis::Reducer final_reducer(
+        reducer_selector::select(functor, return_value));
+    Kokkos::Impl::CombinedFunctorReducer<functor_type,
+                                         typename analysis::Reducer>
+        functor_reducer(functor, final_reducer);
+
     using next_policy_t = decltype(policy);
-    using next_kernel_t = Kokkos::Impl::GraphNodeKernelImpl<
-        ExecutionSpace, next_policy_t, functor_type, Kokkos::ParallelReduceTag,
-        typename return_value_adapter::reducer_type>;
+    using next_kernel_t =
+        Kokkos::Impl::GraphNodeKernelImpl<ExecutionSpace, next_policy_t,
+                                          decltype(functor_reducer),
+                                          Kokkos::ParallelReduceTag>;
 
     return this->_then_kernel(next_kernel_t{
         std::move(arg_name), graph_impl_ptr->get_execution_space(),
-        (Functor &&) functor, (Policy &&) policy,
+        functor_reducer, (Policy &&) policy,
         return_value_adapter::return_value(return_value, functor)});
   }
 
diff --git a/core/src/Kokkos_HBWSpace.hpp b/core/src/Kokkos_HBWSpace.hpp
index d9064a2983..369b7bafb7 100644
--- a/core/src/Kokkos_HBWSpace.hpp
+++ b/core/src/Kokkos_HBWSpace.hpp
@@ -31,41 +31,6 @@ namespace Kokkos {
 
 namespace Experimental {
 
-namespace Impl {
-
-/// \brief Initialize lock array for arbitrary size atomics.
-///
-/// Arbitrary atomics are implemented using a hash table of locks
-/// where the hash value is derived from the address of the
-/// object for which an atomic operation is performed.
-/// This function initializes the locks to zero (unset).
-void init_lock_array_hbw_space();
-
-/// \brief Acquire a lock for the address
-///
-/// This function tries to acquire the lock for the hash value derived
-/// from the provided ptr. If the lock is successfully acquired the
-/// function returns true. Otherwise it returns false.
-bool lock_address_hbw_space(void* ptr);
-
-/// \brief Release lock for the address
-///
-/// This function releases the lock for the hash value derived
-/// from the provided ptr. This function should only be called
-/// after previously successfully acquiring a lock with
-/// lock_address.
-void unlock_address_hbw_space(void* ptr);
-
-}  // namespace Impl
-
-}  // namespace Experimental
-
-}  // namespace Kokkos
-
-namespace Kokkos {
-
-namespace Experimental {
-
 /// \class HBWSpace
 /// \brief Memory management for host memory.
 ///
diff --git a/core/src/Kokkos_HPX.hpp b/core/src/Kokkos_HPX.hpp
deleted file mode 100644
index 0669385262..0000000000
--- a/core/src/Kokkos_HPX.hpp
+++ /dev/null
@@ -1,2365 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
-#include <Kokkos_Macros.hpp>
-static_assert(false,
-              "Including non-public Kokkos header files is not allowed.");
-#endif
-#ifndef KOKKOS_HPX_HPP
-#define KOKKOS_HPX_HPP
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ENABLE_HPX)
-
-#include <Kokkos_Core_fwd.hpp>
-
-#include <Kokkos_HostSpace.hpp>
-#include <cstddef>
-#include <iosfwd>
-
-#ifdef KOKKOS_ENABLE_HBWSPACE
-#include <Kokkos_HBWSpace.hpp>
-#endif
-
-#include <Kokkos_HostSpace.hpp>
-#include <Kokkos_Layout.hpp>
-#include <Kokkos_MemoryTraits.hpp>
-#include <Kokkos_Parallel.hpp>
-#include <Kokkos_ScratchSpace.hpp>
-#include <Kokkos_TaskScheduler.hpp>
-#include <impl/Kokkos_ConcurrentBitset.hpp>
-#include <impl/Kokkos_FunctorAnalysis.hpp>
-#include <impl/Kokkos_Tools.hpp>
-#include <impl/Kokkos_TaskQueue.hpp>
-#include <impl/Kokkos_InitializationSettings.hpp>
-
-#include <KokkosExp_MDRangePolicy.hpp>
-
-#include <hpx/local/algorithm.hpp>
-#include <hpx/local/barrier.hpp>
-#include <hpx/local/condition_variable.hpp>
-#include <hpx/local/execution.hpp>
-#include <hpx/local/future.hpp>
-#include <hpx/local/init.hpp>
-#include <hpx/local/mutex.hpp>
-#include <hpx/local/runtime.hpp>
-#include <hpx/local/thread.hpp>
-
-#include <Kokkos_UniqueToken.hpp>
-
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <type_traits>
-#include <vector>
-
-// There are currently two different implementations for the parallel dispatch
-// functions:
-//
-// - 0: The HPX way. Unfortunately, this comes with unnecessary
-//      overheads at the moment, so there is
-// - 1: The manual way. This uses for_loop, but only spawns one task per worker
-//      thread. This is significantly faster in most cases.
-//
-// In the long run 0 should be the preferred implementation, but until HPX is
-// improved 1 will be the default.
-#ifndef KOKKOS_HPX_IMPLEMENTATION
-#define KOKKOS_HPX_IMPLEMENTATION 1
-#endif
-
-#if (KOKKOS_HPX_IMPLEMENTATION < 0) || (KOKKOS_HPX_IMPLEMENTATION > 1)
-#error "You have chosen an invalid value for KOKKOS_HPX_IMPLEMENTATION"
-#endif
-
-// [note 1]
-//
-// When using the asynchronous backend and independent instances, we explicitly
-// reset the shared data at the end of a parallel task (execute_task). We do
-// this to avoid circular references with shared pointers that would otherwise
-// never be released.
-//
-// The HPX instance holds shared data for the instance in a shared_ptr. One of
-// the pieces of shared data is the future that we use to sequence parallel
-// dispatches. When a parallel task is launched, a copy of the closure
-// (ParallelFor, ParallelReduce, etc.) is captured in the task. The closure
-// also holds the policy, the policy holds the HPX instance, the instance holds
-// the shared data (for use of buffers in the parallel task). When attaching a
-// continuation to a future, the continuation is stored in the future (shared
-// state). This means that there is a cycle future -> continuation -> closure
-// -> policy -> HPX -> shared data -> future. We break this by releasing the
-// shared data early, as (the pointer to) the shared data will not be used
-// anymore by the closure at the end of execute_task.
-//
-// We also mark the shared instance data as mutable so that we can reset it
-// from the const execute_task member function.
-
-namespace Kokkos {
-namespace Impl {
-class thread_buffer {
-  static constexpr std::size_t m_cache_line_size = 64;
-
-  std::size_t m_num_threads;
-  std::size_t m_size_per_thread;
-  std::size_t m_size_total;
-  char *m_data;
-
-  void pad_to_cache_line(std::size_t &size) {
-    size = ((size + m_cache_line_size - 1) / m_cache_line_size) *
-           m_cache_line_size;
-  }
-
- public:
-  thread_buffer()
-      : m_num_threads(0),
-        m_size_per_thread(0),
-        m_size_total(0),
-        m_data(nullptr) {}
-  thread_buffer(const std::size_t num_threads,
-                const std::size_t size_per_thread) {
-    resize(num_threads, size_per_thread);
-  }
-  ~thread_buffer() { delete[] m_data; }
-
-  thread_buffer(const thread_buffer &) = delete;
-  thread_buffer(thread_buffer &&)      = delete;
-  thread_buffer &operator=(const thread_buffer &) = delete;
-  thread_buffer &operator=(thread_buffer) = delete;
-
-  void resize(const std::size_t num_threads,
-              const std::size_t size_per_thread) {
-    m_num_threads     = num_threads;
-    m_size_per_thread = size_per_thread;
-
-    pad_to_cache_line(m_size_per_thread);
-
-    std::size_t size_total_new = m_num_threads * m_size_per_thread;
-
-    if (m_size_total < size_total_new) {
-      delete[] m_data;
-      m_data       = new char[size_total_new];
-      m_size_total = size_total_new;
-    }
-  }
-
-  char *get(std::size_t thread_num) {
-    assert(thread_num < m_num_threads);
-    if (m_data == nullptr) {
-      return nullptr;
-    }
-    return &m_data[thread_num * m_size_per_thread];
-  }
-
-  std::size_t size_per_thread() const noexcept { return m_size_per_thread; }
-  std::size_t size_total() const noexcept { return m_size_total; }
-};
-}  // namespace Impl
-
-namespace Experimental {
-class HPX {
- public:
-  static constexpr uint32_t impl_default_instance_id() { return 1; }
-
- private:
-  static bool m_hpx_initialized;
-  uint32_t m_instance_id = impl_default_instance_id();
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-  static std::atomic<uint32_t> m_next_instance_id;
-
- public:
-  enum class instance_mode { default_, independent };
-
- private:
-  static uint32_t m_active_parallel_region_count;
-  static hpx::spinlock m_active_parallel_region_count_mutex;
-  static hpx::condition_variable_any m_active_parallel_region_count_cond;
-
-  struct instance_data {
-    instance_data() = default;
-    instance_data(hpx::shared_future<void> future) : m_future(future) {}
-    Kokkos::Impl::thread_buffer m_buffer;
-    hpx::shared_future<void> m_future = hpx::make_ready_future<void>();
-    hpx::spinlock m_future_mutex;
-  };
-
-  mutable std::shared_ptr<instance_data> m_independent_instance_data;
-  static instance_data m_default_instance_data;
-
-  std::reference_wrapper<Kokkos::Impl::thread_buffer> m_buffer;
-  std::reference_wrapper<hpx::shared_future<void>> m_future;
-  std::reference_wrapper<hpx::spinlock> m_future_mutex;
-#else
-  static Kokkos::Impl::thread_buffer m_default_buffer;
-#endif
-
- public:
-  using execution_space      = HPX;
-  using memory_space         = HostSpace;
-  using device_type          = Kokkos::Device<execution_space, memory_space>;
-  using array_layout         = LayoutRight;
-  using size_type            = memory_space::size_type;
-  using scratch_memory_space = ScratchMemorySpace<HPX>;
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-  HPX()
-  noexcept
-      : m_instance_id(impl_default_instance_id()),
-        m_buffer(m_default_instance_data.m_buffer),
-        m_future(m_default_instance_data.m_future),
-        m_future_mutex(m_default_instance_data.m_future_mutex) {}
-
-  HPX(instance_mode mode)
-      : m_instance_id(mode == instance_mode::independent
-                          ? m_next_instance_id++
-                          : impl_default_instance_id()),
-        m_independent_instance_data(mode == instance_mode::independent
-                                        ? (new instance_data())
-                                        : nullptr),
-        m_buffer(mode == instance_mode::independent
-                     ? m_independent_instance_data->m_buffer
-                     : m_default_instance_data.m_buffer),
-        m_future(mode == instance_mode::independent
-                     ? m_independent_instance_data->m_future
-                     : m_default_instance_data.m_future),
-        m_future_mutex(mode == instance_mode::independent
-                           ? m_independent_instance_data->m_future_mutex
-                           : m_default_instance_data.m_future_mutex) {}
-
-  HPX(hpx::shared_future<void> future)
-      : m_instance_id(m_next_instance_id++),
-
-        m_independent_instance_data(new instance_data(future)),
-        m_buffer(m_independent_instance_data->m_buffer),
-        m_future(m_independent_instance_data->m_future),
-        m_future_mutex(m_independent_instance_data->m_future_mutex) {}
-
-  HPX(HPX &&other) = default;
-  HPX &operator=(HPX &&other) = default;
-  HPX(const HPX &other)       = default;
-  HPX &operator=(const HPX &other) = default;
-#else
-  HPX() noexcept {}
-#endif
-
-  void print_configuration(std::ostream &os, bool /*verbose*/ = false) const {
-    os << "HPX backend\n";
-    os << "HPX Execution Space:\n";
-    os << "  KOKKOS_ENABLE_HPX: yes\n";
-    os << "\nHPX Runtime Configuration:\n";
-  }
-  uint32_t impl_instance_id() const noexcept { return m_instance_id; }
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-  static bool in_parallel(HPX const &instance = HPX()) noexcept {
-    return !instance.impl_get_future().is_ready();
-  }
-#else
-  static bool in_parallel(HPX const & = HPX()) noexcept { return false; }
-#endif
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-  static void impl_decrement_active_parallel_region_count() {
-    std::unique_lock<hpx::spinlock> l(m_active_parallel_region_count_mutex);
-    if (--m_active_parallel_region_count == 0) {
-      l.unlock();
-      m_active_parallel_region_count_cond.notify_all();
-    };
-  }
-
-  static void impl_increment_active_parallel_region_count() {
-    std::unique_lock<hpx::spinlock> l(m_active_parallel_region_count_mutex);
-    ++m_active_parallel_region_count;
-  }
-#endif
-
-  void fence(
-      const std::string &name =
-          "Kokkos::Experimental::HPX::fence: Unnamed Instance Fence") const {
-    Kokkos::Tools::Experimental::Impl::profile_fence_event<
-        Kokkos::Experimental::HPX>(
-        name,
-        Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{
-            impl_instance_id()},
-        [&]() {
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-          impl_get_future().wait();
-          // Reset the future to free variables that may have been captured in
-          // parallel regions.
-          impl_get_future() = hpx::make_ready_future<void>();
-#endif
-        });
-  }
-
-  static void impl_static_fence(const std::string &name) {
-    Kokkos::Tools::Experimental::Impl::profile_fence_event<
-        Kokkos::Experimental::HPX>(
-        name,
-        Kokkos::Tools::Experimental::SpecialSynchronizationCases::
-            GlobalDeviceSynchronization,
-        [&]() {
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-          std::unique_lock<hpx::spinlock> l(
-              m_active_parallel_region_count_mutex);
-          m_active_parallel_region_count_cond.wait(
-              l, [&]() { return m_active_parallel_region_count == 0; });
-          // Reset the future to free variables that may have been captured in
-          // parallel regions (however, we don't have access to futures from
-          // instances other than the default instances, they will only be
-          // released by fence).
-          HPX().impl_get_future() = hpx::make_ready_future<void>();
-#endif
-        });
-  }
-
-  static hpx::execution::parallel_executor impl_get_executor() {
-    return hpx::execution::parallel_executor();
-  }
-
-  static bool is_asynchronous(HPX const & = HPX()) noexcept {
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-    return true;
-#else
-    return false;
-#endif
-  }
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-  template <typename F>
-  KOKKOS_DEPRECATED static void partition_master(
-      F const &, int requested_num_partitions = 0, int = 0) {
-    if (requested_num_partitions > 1) {
-      Kokkos::abort(
-          "Kokkos::Experimental::HPX::partition_master: can't partition an "
-          "HPX instance\n");
-    }
-  }
-#endif
-
-  static int concurrency();
-  static void impl_initialize(InitializationSettings const &);
-  static bool impl_is_initialized() noexcept;
-  static void impl_finalize();
-
-  static int impl_thread_pool_size() noexcept {
-    hpx::runtime *rt = hpx::get_runtime_ptr();
-    if (rt == nullptr) {
-      return 0;
-    } else {
-      if (hpx::threads::get_self_ptr() == nullptr) {
-        return hpx::resource::get_thread_pool(0).get_os_thread_count();
-      } else {
-        return hpx::this_thread::get_pool()->get_os_thread_count();
-      }
-    }
-  }
-
-  static int impl_thread_pool_rank() noexcept {
-    hpx::runtime *rt = hpx::get_runtime_ptr();
-    if (rt == nullptr) {
-      return 0;
-    } else {
-      if (hpx::threads::get_self_ptr() == nullptr) {
-        return 0;
-      } else {
-        return hpx::this_thread::get_pool()->get_pool_index();
-      }
-    }
-  }
-
-  static int impl_thread_pool_size(int depth) {
-    if (depth == 0) {
-      return impl_thread_pool_size();
-    } else {
-      return 1;
-    }
-  }
-
-  static int impl_max_hardware_threads() noexcept {
-    return hpx::threads::hardware_concurrency();
-  }
-
-  static int impl_hardware_thread_id() noexcept {
-    return hpx::get_worker_thread_num();
-  }
-
-  Kokkos::Impl::thread_buffer &impl_get_buffer() const noexcept {
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-    return m_buffer.get();
-#else
-    return m_default_buffer;
-#endif
-  }
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-  hpx::shared_future<void> &impl_get_future() const noexcept {
-    return m_future;
-  }
-
-  hpx::spinlock &impl_get_future_mutex() const noexcept {
-    return m_future_mutex;
-  }
-#endif
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-  struct [[nodiscard]] reset_on_exit_parallel {
-    HPX const &m_space;
-    reset_on_exit_parallel(HPX const &space) : m_space(space) {}
-    ~reset_on_exit_parallel() {
-      // See [note 1] for an explanation. m_independent_instance_data is
-      // marked mutable.
-      m_space.m_independent_instance_data.reset();
-
-      HPX::impl_decrement_active_parallel_region_count();
-    }
-  };
-
-  // This struct is identical to the above except it does not reset the shared
-  // data. It does, however, still decrement the parallel region count. It is
-  // meant for use in parallel regions which do not capture the execution space
-  // instance.
-  struct [[nodiscard]] reset_count_on_exit_parallel {
-    reset_count_on_exit_parallel() = default;
-    ~reset_count_on_exit_parallel() {
-      HPX::impl_decrement_active_parallel_region_count();
-    }
-  };
-#else
-  struct [[nodiscard]] reset_on_exit_parallel {
-    reset_on_exit_parallel(HPX const &) = default;
-    ~reset_on_exit_parallel()           = default;
-  };
-
-  struct [[nodiscard]] reset_count_on_exit_parallel {
-    reset_count_on_exit_parallel()  = default;
-    ~reset_count_on_exit_parallel() = default;
-  };
-#endif
-
-  static constexpr const char *name() noexcept { return "HPX"; }
-
- private:
-  friend bool operator==(HPX const &lhs, HPX const &rhs) {
-    return lhs.m_instance_id == rhs.m_instance_id;
-  }
-  friend bool operator!=(HPX const &lhs, HPX const &rhs) {
-    return !(lhs == rhs);
-  }
-};
-}  // namespace Experimental
-
-namespace Tools {
-namespace Experimental {
-template <>
-struct DeviceTypeTraits<Kokkos::Experimental::HPX> {
-  static constexpr DeviceType id = DeviceType::HPX;
-  static int device_id(const Kokkos::Experimental::HPX &) { return 0; }
-};
-}  // namespace Experimental
-}  // namespace Tools
-
-namespace Impl {
-
-#if defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH)
-template <typename Closure>
-inline void dispatch_execute_task(Closure *closure,
-                                  Kokkos::Experimental::HPX const &instance,
-                                  bool force_synchronous = false) {
-  Kokkos::Experimental::HPX::impl_increment_active_parallel_region_count();
-
-  Closure closure_copy = *closure;
-
-  {
-    std::unique_lock<hpx::spinlock> l(instance.impl_get_future_mutex());
-    hpx::util::ignore_lock(&instance.impl_get_future_mutex());
-    hpx::shared_future<void> &fut = instance.impl_get_future();
-
-    fut = fut.then(hpx::execution::parallel_executor(
-                       hpx::threads::thread_schedule_hint(0)),
-                   [closure_copy](hpx::shared_future<void> &&) {
-                     return closure_copy.execute_task();
-                   });
-  }
-
-  if (force_synchronous) {
-    instance.fence(
-        "Kokkos::Experimental::Impl::HPX::dispatch_execute_task: fence due to "
-        "forced syncronizations");
-  }
-}
-#else
-template <typename Closure>
-inline void dispatch_execute_task(Closure *closure,
-                                  Kokkos::Experimental::HPX const &,
-                                  bool = false) {
-  closure->execute_task();
-}
-#endif
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-template <>
-struct MemorySpaceAccess<Kokkos::Experimental::HPX::memory_space,
-                         Kokkos::Experimental::HPX::scratch_memory_space> {
-  enum : bool { assignable = false };
-  enum : bool { accessible = true };
-  enum : bool { deepcopy = false };
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Experimental {
-template <>
-class UniqueToken<HPX, UniqueTokenScope::Instance> {
- private:
-  using buffer_type = Kokkos::View<uint32_t *, Kokkos::HostSpace>;
-  int m_count;
-  buffer_type m_buffer_view;
-  uint32_t volatile *m_buffer;
-
- public:
-  using execution_space = HPX;
-  using size_type       = int;
-
-  /// \brief create object size for concurrency on the given instance
-  ///
-  /// This object should not be shared between instances
-  UniqueToken(execution_space const & = execution_space()) noexcept
-      : m_count(execution_space::impl_max_hardware_threads()),
-        m_buffer_view(buffer_type()),
-        m_buffer(nullptr) {}
-
-  UniqueToken(size_type max_size, execution_space const & = execution_space())
-      : m_count(max_size > execution_space::impl_max_hardware_threads()
-                    ? execution_space::impl_max_hardware_threads()
-                    : max_size),
-        m_buffer_view(
-            max_size > execution_space::impl_max_hardware_threads()
-                ? buffer_type()
-                : buffer_type("UniqueToken::m_buffer_view",
-                              ::Kokkos::Impl::concurrent_bitset::buffer_bound(
-                                  m_count))),
-        m_buffer(m_buffer_view.data()) {}
-
-  /// \brief upper bound for acquired values, i.e. 0 <= value < size()
-  KOKKOS_INLINE_FUNCTION
-  int size() const noexcept { return m_count; }
-
-  /// \brief acquire value such that 0 <= value < size()
-  KOKKOS_INLINE_FUNCTION
-  int acquire() const noexcept {
-    KOKKOS_IF_ON_HOST((
-        if (m_buffer == nullptr) {
-          return execution_space::impl_hardware_thread_id();
-        } else {
-          const ::Kokkos::pair<int, int> result =
-              ::Kokkos::Impl::concurrent_bitset::acquire_bounded(
-                  m_buffer, m_count, ::Kokkos::Impl::clock_tic() % m_count);
-
-          if (result.first < 0) {
-            ::Kokkos::abort(
-                "UniqueToken<HPX> failure to acquire tokens, no tokens "
-                "available");
-          }
-          return result.first;
-        }))
-
-    KOKKOS_IF_ON_DEVICE((return 0;))
-  }
-
-  /// \brief release a value acquired by generate
-  KOKKOS_INLINE_FUNCTION
-  void release(int i) const noexcept {
-    KOKKOS_IF_ON_HOST((if (m_buffer != nullptr) {
-      ::Kokkos::Impl::concurrent_bitset::release(m_buffer, i);
-    }))
-
-    KOKKOS_IF_ON_DEVICE(((void)i;))
-  }
-};
-
-template <>
-class UniqueToken<HPX, UniqueTokenScope::Global> {
- public:
-  using execution_space = HPX;
-  using size_type       = int;
-  UniqueToken(execution_space const & = execution_space()) noexcept {}
-
-  // NOTE: Currently this assumes that there is no oversubscription.
-  // hpx::get_num_worker_threads can't be used directly because it may yield
-  // it's task (problematic if called after hpx::get_worker_thread_num).
-  int size() const noexcept { return HPX::impl_max_hardware_threads(); }
-  int acquire() const noexcept { return HPX::impl_hardware_thread_id(); }
-  void release(int) const noexcept {}
-};
-}  // namespace Experimental
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-
-struct HPXTeamMember {
- public:
-  using execution_space = Kokkos::Experimental::HPX;
-  using scratch_memory_space =
-      Kokkos::ScratchMemorySpace<Kokkos::Experimental::HPX>;
-  using team_handle = HPXTeamMember;
-
- private:
-  scratch_memory_space m_team_shared;
-
-  int m_league_size;
-  int m_league_rank;
-  int m_team_size;
-  int m_team_rank;
-
- public:
-  KOKKOS_INLINE_FUNCTION
-  const scratch_memory_space &team_shmem() const {
-    return m_team_shared.set_team_thread_mode(0, 1, 0);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space &team_scratch(const int) const {
-    return m_team_shared.set_team_thread_mode(0, 1, 0);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space &thread_scratch(const int) const {
-    return m_team_shared.set_team_thread_mode(0, team_size(), team_rank());
-  }
-
-  KOKKOS_INLINE_FUNCTION int league_rank() const noexcept {
-    return m_league_rank;
-  }
-
-  KOKKOS_INLINE_FUNCTION int league_size() const noexcept {
-    return m_league_size;
-  }
-
-  KOKKOS_INLINE_FUNCTION int team_rank() const noexcept { return m_team_rank; }
-  KOKKOS_INLINE_FUNCTION int team_size() const noexcept { return m_team_size; }
-
-  template <class... Properties>
-  constexpr KOKKOS_INLINE_FUNCTION HPXTeamMember(
-      const TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>
-          &policy,
-      const int team_rank, const int league_rank, void *scratch,
-      size_t scratch_size) noexcept
-      : m_team_shared(scratch, scratch_size, scratch, scratch_size),
-        m_league_size(policy.league_size()),
-        m_league_rank(league_rank),
-        m_team_size(policy.team_size()),
-        m_team_rank(team_rank) {}
-
-  KOKKOS_INLINE_FUNCTION
-  void team_barrier() const {}
-
-  template <class ValueType>
-  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType &, const int &) const {}
-
-  template <class Closure, class ValueType>
-  KOKKOS_INLINE_FUNCTION void team_broadcast(const Closure &closure,
-                                             ValueType &value,
-                                             const int &) const {
-    closure(value);
-  }
-
-  template <class ValueType, class JoinOp>
-  KOKKOS_INLINE_FUNCTION ValueType team_reduce(const ValueType &value,
-                                               const JoinOp &) const {
-    return value;
-  }
-
-  template <class ReducerType>
-  KOKKOS_INLINE_FUNCTION std::enable_if_t<is_reducer<ReducerType>::value>
-  team_reduce(const ReducerType &) const {}
-
-  template <typename Type>
-  KOKKOS_INLINE_FUNCTION Type
-  team_scan(const Type &value, Type *const global_accum = nullptr) const {
-    if (global_accum) {
-      Kokkos::atomic_fetch_add(global_accum, value);
-    }
-
-    return 0;
-  }
-};
-
-template <class... Properties>
-class TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>
-    : public PolicyTraits<Properties...> {
-  int m_league_size;
-  int m_team_size;
-  std::size_t m_team_scratch_size[2];
-  std::size_t m_thread_scratch_size[2];
-  int m_chunk_size;
-
- public:
-  using traits = PolicyTraits<Properties...>;
-
-  //! Tag this class as a kokkos execution policy
-  using execution_policy = TeamPolicyInternal;
-
-  using member_type = HPXTeamMember;
-
-  //! Execution space of this execution policy:
-  using execution_space = Kokkos::Experimental::HPX;
-
-  // NOTE: Max size is 1 for simplicity. In most cases more than 1 is not
-  // necessary on CPU. Implement later if there is a need.
-  template <class FunctorType>
-  inline static int team_size_max(const FunctorType &) {
-    return 1;
-  }
-
-  template <class FunctorType>
-  inline static int team_size_recommended(const FunctorType &) {
-    return 1;
-  }
-
-  template <class FunctorType>
-  inline static int team_size_recommended(const FunctorType &, const int &) {
-    return 1;
-  }
-
-  template <class FunctorType>
-  int team_size_max(const FunctorType &, const ParallelForTag &) const {
-    return 1;
-  }
-
-  template <class FunctorType>
-  int team_size_max(const FunctorType &, const ParallelReduceTag &) const {
-    return 1;
-  }
-
-  template <class FunctorType, class ReducerType>
-  int team_size_max(const FunctorType &, const ReducerType &,
-                    const ParallelReduceTag &) const {
-    return 1;
-  }
-
-  template <class FunctorType>
-  int team_size_recommended(const FunctorType &, const ParallelForTag &) const {
-    return 1;
-  }
-
-  template <class FunctorType>
-  int team_size_recommended(const FunctorType &,
-                            const ParallelReduceTag &) const {
-    return 1;
-  }
-
-  template <class FunctorType, class ReducerType>
-  int team_size_recommended(const FunctorType &, const ReducerType &,
-                            const ParallelReduceTag &) const {
-    return 1;
-  }
-
-  static int vector_length_max() { return 1; }
-
-  inline int impl_vector_length() noexcept { return 1; }
-  inline bool impl_auto_team_size() noexcept { return false; }
-  inline bool impl_auto_vector_length() noexcept { return false; }
-  inline void impl_set_vector_length(int) noexcept {}
-  inline void impl_set_team_size(int) noexcept {}
-
- private:
-  inline void init(const int league_size_request, const int team_size_request) {
-    m_league_size           = league_size_request;
-    const int max_team_size = 1;  // TODO: Can't use team_size_max(...) because
-                                  // it requires a functor as argument.
-    m_team_size =
-        team_size_request > max_team_size ? max_team_size : team_size_request;
-
-    if (m_chunk_size > 0) {
-      if (!Impl::is_integral_power_of_two(m_chunk_size))
-        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
-    } else {
-      int new_chunk_size = 1;
-      while (new_chunk_size * 4 * Kokkos::Experimental::HPX::concurrency() <
-             m_league_size) {
-        new_chunk_size *= 2;
-      }
-
-      if (new_chunk_size < 128) {
-        new_chunk_size = 1;
-        while ((new_chunk_size * Kokkos::Experimental::HPX::concurrency() <
-                m_league_size) &&
-               (new_chunk_size < 128))
-          new_chunk_size *= 2;
-      }
-
-      m_chunk_size = new_chunk_size;
-    }
-  }
-
- public:
-  inline int team_size() const { return m_team_size; }
-  inline int league_size() const { return m_league_size; }
-
-  size_t scratch_size(const int &level, int team_size_ = -1) const {
-    if (team_size_ < 0) {
-      team_size_ = m_team_size;
-    }
-    return m_team_scratch_size[level] +
-           team_size_ * m_thread_scratch_size[level];
-  }
-
-  inline static int scratch_size_max(int level) {
-    return (level == 0 ? 1024 * 32 :  // Roughly L1 size
-                20 * 1024 * 1024);    // Limit to keep compatibility with CUDA
-  }
-
- public:
-  template <class ExecSpace, class... OtherProperties>
-  friend class TeamPolicyInternal;
-
-  const typename traits::execution_space &space() const {
-    static typename traits::execution_space m_space;
-    return m_space;
-  }
-
-  template <class... OtherProperties>
-  TeamPolicyInternal(const TeamPolicyInternal<Kokkos::Experimental::HPX,
-                                              OtherProperties...> &p) {
-    m_league_size            = p.m_league_size;
-    m_team_size              = p.m_team_size;
-    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
-    m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
-    m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size             = p.m_chunk_size;
-  }
-
-  TeamPolicyInternal(const typename traits::execution_space &,
-                     int league_size_request, int team_size_request,
-                     int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request);
-  }
-
-  TeamPolicyInternal(const typename traits::execution_space &,
-                     int league_size_request, const Kokkos::AUTO_t &,
-                     int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, 1);
-  }
-
-  TeamPolicyInternal(const typename traits::execution_space &,
-                     int league_size_request,
-                     const Kokkos::AUTO_t &, /* team_size_request */
-                     const Kokkos::AUTO_t & /* vector_length_request */)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, 1);
-  }
-
-  TeamPolicyInternal(const typename traits::execution_space &,
-                     int league_size_request, int team_size_request,
-                     const Kokkos::AUTO_t & /* vector_length_request */
-                     )
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request);
-  }
-
-  TeamPolicyInternal(int league_size_request,
-                     const Kokkos::AUTO_t &, /* team_size_request */
-                     const Kokkos::AUTO_t & /* vector_length_request */)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, 1);
-  }
-
-  TeamPolicyInternal(int league_size_request, int team_size_request,
-                     const Kokkos::AUTO_t & /* vector_length_request */
-                     )
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request);
-  }
-
-  TeamPolicyInternal(int league_size_request, int team_size_request,
-                     int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request);
-  }
-
-  TeamPolicyInternal(int league_size_request, const Kokkos::AUTO_t &,
-                     int /* vector_length_request */ = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(0) {
-    init(league_size_request, 1);
-  }
-
-  inline int chunk_size() const { return m_chunk_size; }
-
-  inline TeamPolicyInternal &set_chunk_size(
-      typename traits::index_type chunk_size_) {
-    m_chunk_size = chunk_size_;
-    return *this;
-  }
-
-  inline TeamPolicyInternal &set_scratch_size(const int &level,
-                                              const PerTeamValue &per_team) {
-    m_team_scratch_size[level] = per_team.value;
-    return *this;
-  }
-
-  inline TeamPolicyInternal &set_scratch_size(
-      const int &level, const PerThreadValue &per_thread) {
-    m_thread_scratch_size[level] = per_thread.value;
-    return *this;
-  }
-
-  inline TeamPolicyInternal &set_scratch_size(
-      const int &level, const PerTeamValue &per_team,
-      const PerThreadValue &per_thread) {
-    m_team_scratch_size[level]   = per_team.value;
-    m_thread_scratch_size[level] = per_thread.value;
-    return *this;
-  }
-};
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-
-template <typename Policy>
-typename Policy::member_type get_hpx_adjusted_chunk_size(Policy const &policy) {
-  const int concurrency = Kokkos::Experimental::HPX::concurrency();
-  const typename Policy::member_type n        = policy.end() - policy.begin();
-  typename Policy::member_type new_chunk_size = policy.chunk_size();
-
-  while (n >= 4 * concurrency * new_chunk_size) {
-    new_chunk_size *= 2;
-  }
-
-  return new_chunk_size;
-}
-
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
-                  Kokkos::Experimental::HPX> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  template <class TagType>
-  static std::enable_if_t<std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Member i) {
-    functor(i);
-  }
-
-  template <class TagType>
-  static std::enable_if_t<!std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Member i) {
-    const TagType t{};
-    functor(t, i);
-  }
-
-  template <class TagType>
-  static std::enable_if_t<std::is_void<TagType>::value> execute_functor_range(
-      const FunctorType &functor, const Member i_begin, const Member i_end) {
-    for (Member i = i_begin; i < i_end; ++i) {
-      functor(i);
-    }
-  }
-
-  template <class TagType>
-  static std::enable_if_t<!std::is_void<TagType>::value> execute_functor_range(
-      const FunctorType &functor, const Member i_begin, const Member i_end) {
-    const TagType t{};
-    for (Member i = i_begin; i < i_end; ++i) {
-      functor(t, i);
-    }
-  }
-
- public:
-  void execute() const {
-    Kokkos::Impl::dispatch_execute_task(this, m_policy.space());
-  }
-
-  void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_policy.space());
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-    using hpx::for_loop;
-
-    for_loop(par.on(exec).with(static_chunk_size(m_policy.chunk_size())),
-             m_policy.begin(), m_policy.end(), [this](const Member i) {
-               execute_functor<WorkTag>(m_functor, i);
-             });
-
-#elif KOKKOS_HPX_IMPLEMENTATION == 1
-    using hpx::for_loop_strided;
-
-    const Member chunk_size = get_hpx_adjusted_chunk_size(m_policy);
-
-    for_loop_strided(
-        par.on(exec), m_policy.begin(), m_policy.end(), chunk_size,
-        [this, chunk_size](const Member i_begin) {
-          const Member i_end = (std::min)(i_begin + chunk_size, m_policy.end());
-          execute_functor_range<WorkTag>(m_functor, i_begin, i_end);
-        });
-#endif
-  }
-
-  inline ParallelFor(const FunctorType &arg_functor, Policy arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-};
-
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
-                  Kokkos::Experimental::HPX> {
- private:
-  using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
-  using Policy        = typename MDRangePolicy::impl_range_policy;
-  using WorkTag       = typename MDRangePolicy::work_tag;
-  using WorkRange     = typename Policy::WorkRange;
-  using Member        = typename Policy::member_type;
-  using iterate_type =
-      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
-                                             WorkTag, void>;
-
-  const iterate_type m_iter;
-  const Policy m_policy;
-
- public:
-  void execute() const { dispatch_execute_task(this, m_iter.m_rp.space()); }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_iter.m_rp.space());
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-    using hpx::for_loop;
-
-    for_loop(par.on(exec).with(
-                 static_chunk_size(get_hpx_adjusted_chunk_size(m_policy))),
-             m_policy.begin(), m_policy.end(),
-             [this](const Member i) { iterate_type(i); });
-
-#elif KOKKOS_HPX_IMPLEMENTATION == 1
-    using hpx::for_loop_strided;
-
-    const Member chunk_size = get_hpx_adjusted_chunk_size(m_policy);
-
-    for_loop_strided(par.on(exec), m_policy.begin(), m_policy.end(), chunk_size,
-                     [this, chunk_size](const Member i_begin) {
-                       const Member i_end =
-                           (std::min)(i_begin + chunk_size, m_policy.end());
-                       for (Member i = i_begin; i < i_end; ++i) {
-                         m_iter(i);
-                       }
-                     });
-#endif
-  }
-
-  inline ParallelFor(const FunctorType &arg_functor, MDRangePolicy arg_policy)
-      : m_iter(arg_policy, arg_functor),
-        m_policy(Policy(0, arg_policy.m_num_tiles).set_chunk_size(1)) {}
-  template <typename Policy, typename Functor>
-  static int max_tile_size_product(const Policy &, const Functor &) {
-    /**
-     * 1024 here is just our guess for a reasonable max tile size,
-     * it isn't a hardware constraint. If people see a use for larger
-     * tile size products, we're happy to change this.
-     */
-    return 1024;
-  }
-};
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
-                     Kokkos::Experimental::HPX> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-  using value_type     = typename Analysis::value_type;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const ReducerType m_reducer;
-  const pointer_type m_result_ptr;
-
-  bool m_force_synchronous;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Member i, reference_type update) {
-    functor(i, update);
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Member i, reference_type update) {
-    const TagType t{};
-    functor(t, i, update);
-  }
-
-  template <class TagType>
-  inline std::enable_if_t<std::is_void<TagType>::value> execute_functor_range(
-      reference_type update, const Member i_begin, const Member i_end) const {
-    for (Member i = i_begin; i < i_end; ++i) {
-      m_functor(i, update);
-    }
-  }
-
-  template <class TagType>
-  inline std::enable_if_t<!std::is_void<TagType>::value> execute_functor_range(
-      reference_type update, const Member i_begin, const Member i_end) const {
-    const TagType t{};
-
-    for (Member i = i_begin; i < i_end; ++i) {
-      m_functor(t, i, update);
-    }
-  }
-
-  class value_type_wrapper {
-   private:
-    std::size_t m_value_size;
-    char *m_value_buffer;
-
-   public:
-    value_type_wrapper() : m_value_size(0), m_value_buffer(nullptr) {}
-
-    value_type_wrapper(const std::size_t value_size)
-        : m_value_size(value_size), m_value_buffer(new char[m_value_size]) {}
-
-    value_type_wrapper(const value_type_wrapper &other)
-        : m_value_size(0), m_value_buffer(nullptr) {
-      if (this != &other) {
-        m_value_buffer = new char[other.m_value_size];
-        m_value_size   = other.m_value_size;
-
-        std::copy(other.m_value_buffer, other.m_value_buffer + m_value_size,
-                  m_value_buffer);
-      }
-    }
-
-    ~value_type_wrapper() { delete[] m_value_buffer; }
-
-    value_type_wrapper(value_type_wrapper &&other)
-        : m_value_size(0), m_value_buffer(nullptr) {
-      if (this != &other) {
-        m_value_buffer = other.m_value_buffer;
-        m_value_size   = other.m_value_size;
-
-        other.m_value_buffer = nullptr;
-        other.m_value_size   = 0;
-      }
-    }
-
-    value_type_wrapper &operator=(const value_type_wrapper &other) {
-      if (this != &other) {
-        delete[] m_value_buffer;
-        m_value_buffer = new char[other.m_value_size];
-        m_value_size   = other.m_value_size;
-
-        std::copy(other.m_value_buffer, other.m_value_buffer + m_value_size,
-                  m_value_buffer);
-      }
-
-      return *this;
-    }
-
-    value_type_wrapper &operator=(value_type_wrapper &&other) {
-      if (this != &other) {
-        delete[] m_value_buffer;
-        m_value_buffer = other.m_value_buffer;
-        m_value_size   = other.m_value_size;
-
-        other.m_value_buffer = nullptr;
-        other.m_value_size   = 0;
-      }
-
-      return *this;
-    }
-
-    pointer_type pointer() const {
-      return reinterpret_cast<pointer_type>(m_value_buffer);
-    }
-
-    reference_type reference() const {
-      return Analysis::Reducer::reference(
-          reinterpret_cast<pointer_type>(m_value_buffer));
-    }
-  };
-
- public:
-  void execute() const {
-    if (m_policy.end() <= m_policy.begin()) {
-      if (m_result_ptr) {
-        typename Analysis::Reducer final_reducer(
-            &ReducerConditional::select(m_functor, m_reducer));
-
-        final_reducer.init(m_result_ptr);
-        final_reducer.final(m_result_ptr);
-      }
-      return;
-    }
-    dispatch_execute_task(this, m_policy.space(), m_force_synchronous);
-  }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_policy.space());
-
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
-    const std::size_t value_size =
-        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-    // NOTE: This version makes the most use of HPX functionality, but
-    // requires the struct value_type_wrapper to handle different
-    // reference_types. It is also significantly slower than the version
-    // below due to not reusing the buffer used by other functions.
-    using hpx::parallel::reduction;
-
-    value_type_wrapper final_value(value_size);
-    value_type_wrapper identity(value_size);
-
-    final_reducer.init(final_value.pointer());
-    final_reducer.init(identity.pointer());
-
-    for_loop(par.on(exec).with(
-                 static_chunk_size(get_hpx_adjusted_chunk_size(m_policy))),
-             m_policy.begin(), m_policy.end(),
-             reduction(final_value, identity,
-                       [final_reducer](
-                           value_type_wrapper &a,
-                           value_type_wrapper &b) -> value_type_wrapper & {
-                         final_reducer.join(a.pointer(), b.pointer());
-                         return a;
-                       }),
-             [this](Member i, value_type_wrapper &update) {
-               execute_functor<WorkTag>(m_functor, i, update.reference());
-             });
-
-    pointer_type final_value_ptr = final_value.pointer();
-
-#elif KOKKOS_HPX_IMPLEMENTATION == 1
-    using hpx::for_loop_strided;
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-
-    thread_buffer &buffer = m_policy.space().impl_get_buffer();
-    buffer.resize(num_worker_threads, value_size);
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [&buffer, final_reducer ](const int t) noexcept {
-          final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-        });
-
-    const Member chunk_size = get_hpx_adjusted_chunk_size(m_policy);
-
-    for_loop_strided(
-        par.on(exec), m_policy.begin(), m_policy.end(), chunk_size,
-        [this, &buffer, chunk_size](const Member i_begin) {
-          reference_type update = Analysis::Reducer::reference(
-              reinterpret_cast<pointer_type>(buffer.get(
-                  Kokkos::Experimental::HPX::impl_hardware_thread_id())));
-          const Member i_end = (std::min)(i_begin + chunk_size, m_policy.end());
-          execute_functor_range<WorkTag>(update, i_begin, i_end);
-        });
-
-    for (int i = 1; i < num_worker_threads; ++i) {
-      final_reducer.join(reinterpret_cast<pointer_type>(buffer.get(0)),
-                         reinterpret_cast<pointer_type>(buffer.get(i)));
-    }
-
-    pointer_type final_value_ptr =
-        reinterpret_cast<pointer_type>(buffer.get(0));
-#endif
-
-    final_reducer.final(final_value_ptr);
-
-    if (m_result_ptr != nullptr) {
-      const int n = Analysis::value_count(
-          ReducerConditional::select(m_functor, m_reducer));
-
-      for (int j = 0; j < n; ++j) {
-        m_result_ptr[j] = final_value_ptr[j];
-      }
-    }
-  }
-
-  template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType &arg_functor, Policy arg_policy,
-      const ViewType &arg_view,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void *> = nullptr)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(InvalidType()),
-        m_result_ptr(arg_view.data()),
-        m_force_synchronous(!arg_view.impl_track().has_record()) {}
-
-  inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
-                        const ReducerType &reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_force_synchronous(!reducer.view().impl_track().has_record()) {}
-};
-
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
-                     Kokkos::Experimental::HPX> {
- private:
-  using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
-  using Policy        = typename MDRangePolicy::impl_range_policy;
-  using WorkTag       = typename MDRangePolicy::work_tag;
-  using WorkRange     = typename Policy::WorkRange;
-  using Member        = typename Policy::member_type;
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis       = FunctorAnalysis<FunctorPatternInterface::REDUCE,
-                                   MDRangePolicy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
-  using iterate_type =
-      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
-                                             WorkTag, reference_type>;
-
-  const iterate_type m_iter;
-  const Policy m_policy;
-  const ReducerType m_reducer;
-  const pointer_type m_result_ptr;
-
-  bool m_force_synchronous;
-
- public:
-  void execute() const {
-    dispatch_execute_task(this, m_iter.m_rp.space(), m_force_synchronous);
-  }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_iter.m_rp.space());
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-    const std::size_t value_size = Analysis::value_size(
-        ReducerConditional::select(m_iter.m_func, m_reducer));
-
-    thread_buffer &buffer = m_iter.m_rp.space().impl_get_buffer();
-    buffer.resize(num_worker_threads, value_size);
-
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_iter.m_func, m_reducer));
-
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [&buffer, final_reducer](std::size_t t) {
-          final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-        });
-
-    for_loop(par.on(exec).with(
-                 static_chunk_size(get_hpx_adjusted_chunk_size(m_policy))),
-             m_policy.begin(), m_policy.end(), [this, &buffer](const Member i) {
-               reference_type update = Analysis::Reducer::reference(
-                   reinterpret_cast<pointer_type>(buffer.get(
-                       Kokkos::Experimental::HPX::impl_hardware_thread_id())));
-               m_iter(i, update);
-             });
-
-#elif KOKKOS_HPX_IMPLEMENTATION == 1
-    using hpx::for_loop_strided;
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), std::size_t(0),
-        num_worker_threads, [&buffer, final_reducer](const std::size_t t) {
-          final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-        });
-
-    const Member chunk_size = get_hpx_adjusted_chunk_size(m_policy);
-
-    for_loop_strided(
-        par.on(exec), m_policy.begin(), m_policy.end(), chunk_size,
-        [this, &buffer, chunk_size](const Member i_begin) {
-          reference_type update = Analysis::Reducer::reference(
-              reinterpret_cast<pointer_type>(buffer.get(
-                  Kokkos::Experimental::HPX::impl_hardware_thread_id())));
-          const Member i_end = (std::min)(i_begin + chunk_size, m_policy.end());
-
-          for (Member i = i_begin; i < i_end; ++i) {
-            m_iter(i, update);
-          }
-        });
-#endif
-
-    for (int i = 1; i < num_worker_threads; ++i) {
-      final_reducer.join(reinterpret_cast<pointer_type>(buffer.get(0)),
-                         reinterpret_cast<pointer_type>(buffer.get(i)));
-    }
-
-    final_reducer.final(reinterpret_cast<pointer_type>(buffer.get(0)));
-
-    if (m_result_ptr != nullptr) {
-      const int n = Analysis::value_count(
-          ReducerConditional::select(m_iter.m_func, m_reducer));
-
-      for (int j = 0; j < n; ++j) {
-        m_result_ptr[j] = reinterpret_cast<pointer_type>(buffer.get(0))[j];
-      }
-    }
-  }
-
-  template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType &arg_functor, MDRangePolicy arg_policy,
-      const ViewType &arg_view,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void *> = nullptr)
-      : m_iter(arg_policy, arg_functor),
-        m_policy(Policy(0, arg_policy.m_num_tiles).set_chunk_size(1)),
-        m_reducer(InvalidType()),
-        m_result_ptr(arg_view.data()),
-        m_force_synchronous(!arg_view.impl_track().has_record()) {}
-
-  inline ParallelReduce(const FunctorType &arg_functor,
-                        MDRangePolicy arg_policy, const ReducerType &reducer)
-      : m_iter(arg_policy, arg_functor),
-        m_policy(Policy(0, arg_policy.m_num_tiles).set_chunk_size(1)),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_force_synchronous(!reducer.view().impl_track().has_record()) {}
-  template <typename Policy, typename Functor>
-  static int max_tile_size_product(const Policy &, const Functor &) {
-    /**
-     * 1024 here is just our guess for a reasonable max tile size,
-     * it isn't a hardware constraint. If people see a use for larger
-     * tile size products, we're happy to change this.
-     */
-    return 1024;
-  }
-};
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-
-template <class FunctorType, class... Traits>
-class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
-                   Kokkos::Experimental::HPX> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-  using value_type     = typename Analysis::value_type;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Member i_begin,
-                        const Member i_end, reference_type update,
-                        const bool final) {
-    for (Member i = i_begin; i < i_end; ++i) {
-      functor(i, update, final);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Member i_begin,
-                        const Member i_end, reference_type update,
-                        const bool final) {
-    const TagType t{};
-    for (Member i = i_begin; i < i_end; ++i) {
-      functor(t, i, update, final);
-    }
-  }
-
- public:
-  void execute() const { dispatch_execute_task(this, m_policy.space()); }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_policy.space());
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-    const int value_count        = Analysis::value_count(m_functor);
-    const std::size_t value_size = Analysis::value_size(m_functor);
-
-    thread_buffer &buffer = m_policy.space().impl_get_buffer();
-    buffer.resize(num_worker_threads, 2 * value_size);
-
-    using hpx::barrier;
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-    barrier<> bar(num_worker_threads);
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    typename Analysis::Reducer final_reducer(&m_functor);
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [this, &bar, &buffer, num_worker_threads, value_count, value_size,
-         final_reducer](int t) {
-          reference_type update_sum =
-              final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-
-          const WorkRange range(m_policy, t, num_worker_threads);
-          execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
-                                         update_sum, false);
-
-          bar.arrive_and_wait();
-
-          if (t == 0) {
-            final_reducer.init(
-                reinterpret_cast<pointer_type>(buffer.get(0) + value_size));
-
-            for (int i = 1; i < num_worker_threads; ++i) {
-              pointer_type ptr_1_prev =
-                  reinterpret_cast<pointer_type>(buffer.get(i - 1));
-              pointer_type ptr_2_prev = reinterpret_cast<pointer_type>(
-                  buffer.get(i - 1) + value_size);
-              pointer_type ptr_2 =
-                  reinterpret_cast<pointer_type>(buffer.get(i) + value_size);
-
-              for (int j = 0; j < value_count; ++j) {
-                ptr_2[j] = ptr_2_prev[j];
-              }
-
-              final_reducer.join(ptr_2, ptr_1_prev);
-            }
-          }
-
-          bar.arrive_and_wait();
-
-          reference_type update_base = Analysis::Reducer::reference(
-              reinterpret_cast<pointer_type>(buffer.get(t) + value_size));
-
-          execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
-                                         update_base, true);
-        });
-  }
-
-  inline ParallelScan(const FunctorType &arg_functor, const Policy &arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-};
-
-template <class FunctorType, class ReturnType, class... Traits>
-class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
-                            ReturnType, Kokkos::Experimental::HPX> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-  using value_type     = typename Analysis::value_type;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-  pointer_type m_result_ptr;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Member i_begin,
-                        const Member i_end, reference_type update,
-                        const bool final) {
-    for (Member i = i_begin; i < i_end; ++i) {
-      functor(i, update, final);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Member i_begin,
-                        const Member i_end, reference_type update,
-                        const bool final) {
-    const TagType t{};
-    for (Member i = i_begin; i < i_end; ++i) {
-      functor(t, i, update, final);
-    }
-  }
-
- public:
-  void execute() const { dispatch_execute_task(this, m_policy.space()); }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_policy.space());
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-    const int value_count        = Analysis::value_count(m_functor);
-    const std::size_t value_size = Analysis::value_size(m_functor);
-
-    thread_buffer &buffer = m_policy.space().impl_get_buffer();
-    buffer.resize(num_worker_threads, 2 * value_size);
-
-    using hpx::barrier;
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-    barrier<> bar(num_worker_threads);
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    typename Analysis::Reducer final_reducer(&m_functor);
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [this, &bar, &buffer, num_worker_threads, value_count, value_size,
-         final_reducer](int t) {
-          reference_type update_sum =
-              final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-
-          const WorkRange range(m_policy, t, num_worker_threads);
-          execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
-                                         update_sum, false);
-
-          bar.arrive_and_wait();
-
-          if (t == 0) {
-            final_reducer.init(
-                reinterpret_cast<pointer_type>(buffer.get(0) + value_size));
-
-            for (int i = 1; i < num_worker_threads; ++i) {
-              pointer_type ptr_1_prev =
-                  reinterpret_cast<pointer_type>(buffer.get(i - 1));
-              pointer_type ptr_2_prev = reinterpret_cast<pointer_type>(
-                  buffer.get(i - 1) + value_size);
-              pointer_type ptr_2 =
-                  reinterpret_cast<pointer_type>(buffer.get(i) + value_size);
-
-              for (int j = 0; j < value_count; ++j) {
-                ptr_2[j] = ptr_2_prev[j];
-              }
-
-              final_reducer.join(ptr_2, ptr_1_prev);
-            }
-          }
-
-          bar.arrive_and_wait();
-
-          reference_type update_base = Analysis::Reducer::reference(
-              reinterpret_cast<pointer_type>(buffer.get(t) + value_size));
-
-          execute_functor_range<WorkTag>(m_functor, range.begin(), range.end(),
-                                         update_base, true);
-
-          if (t == num_worker_threads - 1) {
-            *m_result_ptr = update_base;
-          }
-        });
-  }
-
-  template <class ViewType>
-  ParallelScanWithTotal(const FunctorType &arg_functor,
-                        const Policy &arg_policy,
-                        const ViewType &arg_result_view)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_result_ptr(arg_result_view.data()) {
-    static_assert(
-        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
-                                        Kokkos::HostSpace>::accessible,
-        "Kokkos::HPX parallel_scan result must be host-accessible!");
-  }
-};
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-template <class FunctorType, class... Properties>
-class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                  Kokkos::Experimental::HPX> {
- private:
-  using Policy  = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
-  using WorkTag = typename Policy::work_tag;
-  using Member  = typename Policy::member_type;
-  using memory_space = Kokkos::HostSpace;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const int m_league;
-  const std::size_t m_shared;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Policy &policy, const int league_rank,
-      char *local_buffer, const std::size_t local_buffer_size) {
-    functor(Member(policy, 0, league_rank, local_buffer, local_buffer_size));
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Policy &policy, const int league_rank,
-      char *local_buffer, const std::size_t local_buffer_size) {
-    const TagType t{};
-    functor(t, Member(policy, 0, league_rank, local_buffer, local_buffer_size));
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Policy &policy,
-                        const int league_rank_begin, const int league_rank_end,
-                        char *local_buffer,
-                        const std::size_t local_buffer_size) {
-    for (int league_rank = league_rank_begin; league_rank < league_rank_end;
-         ++league_rank) {
-      functor(Member(policy, 0, league_rank, local_buffer, local_buffer_size));
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Policy &policy,
-                        const int league_rank_begin, const int league_rank_end,
-                        char *local_buffer,
-                        const std::size_t local_buffer_size) {
-    const TagType t{};
-    for (int league_rank = league_rank_begin; league_rank < league_rank_end;
-         ++league_rank) {
-      functor(t,
-              Member(policy, 0, league_rank, local_buffer, local_buffer_size));
-    }
-  }
-
- public:
-  void execute() const { dispatch_execute_task(this, m_policy.space()); }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_policy.space());
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-
-    thread_buffer &buffer = m_policy.space().impl_get_buffer();
-    buffer.resize(num_worker_threads, m_shared);
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-    using hpx::for_loop;
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(m_policy.chunk_size())), 0,
-        m_policy.league_size(), [this, &buffer](const int league_rank) {
-          execute_functor<WorkTag>(
-              m_functor, m_policy, league_rank,
-              buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()),
-              m_shared);
-        });
-
-#elif KOKKOS_HPX_IMPLEMENTATION == 1
-    using hpx::for_loop_strided;
-
-    for_loop_strided(
-        par.on(exec), 0, m_policy.league_size(), m_policy.chunk_size(),
-        [this, &buffer](const int league_rank_begin) {
-          const int league_rank_end =
-              (std::min)(league_rank_begin + m_policy.chunk_size(),
-                         m_policy.league_size());
-          execute_functor_range<WorkTag>(
-              m_functor, m_policy, league_rank_begin, league_rank_end,
-              buffer.get(Kokkos::Experimental::HPX::impl_hardware_thread_id()),
-              m_shared);
-        });
-#endif
-  }
-
-  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_league(arg_policy.league_size()),
-        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(
-                     arg_functor, arg_policy.team_size())) {}
-};
-
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::Experimental::HPX> {
- private:
-  using Policy  = TeamPolicyInternal<Kokkos::Experimental::HPX, Properties...>;
-  using Member  = typename Policy::member_type;
-  using WorkTag = typename Policy::work_tag;
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-  using value_type     = typename Analysis::value_type;
-
-  const FunctorType m_functor;
-  const int m_league;
-  const Policy m_policy;
-  const ReducerType m_reducer;
-  pointer_type m_result_ptr;
-  const std::size_t m_shared;
-
-  bool m_force_synchronous;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Policy &policy, const int league_rank,
-      char *local_buffer, const std::size_t local_buffer_size,
-      reference_type update) {
-    functor(Member(policy, 0, league_rank, local_buffer, local_buffer_size),
-            update);
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> execute_functor(
-      const FunctorType &functor, const Policy &policy, const int league_rank,
-      char *local_buffer, const std::size_t local_buffer_size,
-      reference_type update) {
-    const TagType t{};
-    functor(t, Member(policy, 0, league_rank, local_buffer, local_buffer_size),
-            update);
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Policy &policy,
-                        const int league_rank_begin, const int league_rank_end,
-                        char *local_buffer, const std::size_t local_buffer_size,
-                        reference_type update) {
-    for (int league_rank = league_rank_begin; league_rank < league_rank_end;
-         ++league_rank) {
-      functor(Member(policy, 0, league_rank, local_buffer, local_buffer_size),
-              update);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value>
-  execute_functor_range(const FunctorType &functor, const Policy &policy,
-                        const int league_rank_begin, const int league_rank_end,
-                        char *local_buffer, const std::size_t local_buffer_size,
-                        reference_type update) {
-    const TagType t{};
-    for (int league_rank = league_rank_begin; league_rank < league_rank_end;
-         ++league_rank) {
-      functor(t,
-              Member(policy, 0, league_rank, local_buffer, local_buffer_size),
-              update);
-    }
-  }
-
- public:
-  void execute() const {
-    if (m_policy.league_size() * m_policy.team_size() == 0) {
-      if (m_result_ptr) {
-        typename Analysis::Reducer final_reducer(
-            &ReducerConditional::select(m_functor, m_reducer));
-        final_reducer.init(m_result_ptr);
-        final_reducer.final(m_result_ptr);
-      }
-      return;
-    }
-    dispatch_execute_task(this, m_policy.space());
-  }
-
-  inline void execute_task() const {
-    // See [note 1] for an explanation.
-    Kokkos::Experimental::HPX::reset_on_exit_parallel reset_on_exit(
-        m_policy.space());
-
-    const int num_worker_threads = Kokkos::Experimental::HPX::concurrency();
-    const std::size_t value_size =
-        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
-
-    thread_buffer &buffer = m_policy.space().impl_get_buffer();
-    buffer.resize(num_worker_threads, value_size + m_shared);
-
-    auto exec = Kokkos::Experimental::HPX::impl_get_executor();
-
-    using hpx::for_loop;
-    using hpx::execution::par;
-    using hpx::execution::static_chunk_size;
-
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
-#if KOKKOS_HPX_IMPLEMENTATION == 0
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [&buffer, final_reducer](const std::size_t t) {
-          final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-        });
-
-    for_loop(par.on(exec).with(static_chunk_size(m_policy.chunk_size())), 0,
-             m_policy.league_size(),
-             [this, &buffer, value_size](const int league_rank) {
-               std::size_t t =
-                   Kokkos::Experimental::HPX::impl_hardware_thread_id();
-               reference_type update = Analysis::Reducer::reference(
-                   reinterpret_cast<pointer_type>(buffer.get(t)));
-
-               execute_functor<WorkTag>(m_functor, m_policy, league_rank,
-                                        buffer.get(t) + value_size, m_shared,
-                                        update);
-             });
-
-#elif KOKKOS_HPX_IMPLEMENTATION == 1
-    using hpx::for_loop_strided;
-
-    for_loop(
-        par.on(exec).with(static_chunk_size(1)), 0, num_worker_threads,
-        [&buffer, final_reducer](std::size_t const t) {
-          final_reducer.init(reinterpret_cast<pointer_type>(buffer.get(t)));
-        });
-
-    for_loop_strided(
-        par.on(exec), 0, m_policy.league_size(), m_policy.chunk_size(),
-        [this, &buffer, value_size](int const league_rank_begin) {
-          std::size_t t = Kokkos::Experimental::HPX::impl_hardware_thread_id();
-          reference_type update = Analysis::Reducer::reference(
-              reinterpret_cast<pointer_type>(buffer.get(t)));
-          const int league_rank_end =
-              (std::min)(league_rank_begin + m_policy.chunk_size(),
-                         m_policy.league_size());
-          execute_functor_range<WorkTag>(
-              m_functor, m_policy, league_rank_begin, league_rank_end,
-              buffer.get(t) + value_size, m_shared, update);
-        });
-#endif
-
-    const pointer_type ptr = reinterpret_cast<pointer_type>(buffer.get(0));
-    for (int t = 1; t < num_worker_threads; ++t) {
-      final_reducer.join(ptr, reinterpret_cast<pointer_type>(buffer.get(t)));
-    }
-
-    final_reducer.final(ptr);
-
-    if (m_result_ptr) {
-      const int n = Analysis::value_count(
-          ReducerConditional::select(m_functor, m_reducer));
-
-      for (int j = 0; j < n; ++j) {
-        m_result_ptr[j] = ptr[j];
-      }
-    }
-  }
-
-  template <class ViewType>
-  ParallelReduce(const FunctorType &arg_functor, const Policy &arg_policy,
-                 const ViewType &arg_result,
-                 std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void *> = nullptr)
-      : m_functor(arg_functor),
-        m_league(arg_policy.league_size()),
-        m_policy(arg_policy),
-        m_reducer(InvalidType()),
-        m_result_ptr(arg_result.data()),
-        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(
-                     m_functor, arg_policy.team_size())),
-        m_force_synchronous(!arg_result.impl_track().has_record()) {}
-
-  inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
-                        const ReducerType &reducer)
-      : m_functor(arg_functor),
-        m_league(arg_policy.league_size()),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(
-                     arg_functor, arg_policy.team_size())),
-        m_force_synchronous(!reducer.view().impl_track().has_record()) {}
-};
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-
-template <typename iType>
-KOKKOS_INLINE_FUNCTION
-    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-    TeamThreadRange(const Impl::HPXTeamMember &thread, const iType &count) {
-  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
-      thread, count);
-}
-
-template <typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
-    std::common_type_t<iType1, iType2>, Impl::HPXTeamMember>
-TeamThreadRange(const Impl::HPXTeamMember &thread, const iType1 &i_begin,
-                const iType2 &i_end) {
-  using iType = std::common_type_t<iType1, iType2>;
-  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
-      thread, iType(i_begin), iType(i_end));
-}
-
-template <typename iType>
-KOKKOS_INLINE_FUNCTION
-    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-    TeamVectorRange(const Impl::HPXTeamMember &thread, const iType &count) {
-  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
-      thread, count);
-}
-
-template <typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
-    std::common_type_t<iType1, iType2>, Impl::HPXTeamMember>
-TeamVectorRange(const Impl::HPXTeamMember &thread, const iType1 &i_begin,
-                const iType2 &i_end) {
-  using iType = std::common_type_t<iType1, iType2>;
-  return Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
-      thread, iType(i_begin), iType(i_end));
-}
-
-template <typename iType>
-KOKKOS_INLINE_FUNCTION
-    Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-    ThreadVectorRange(const Impl::HPXTeamMember &thread, const iType &count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
-      thread, count);
-}
-
-template <typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
-    std::common_type_t<iType1, iType2>, Impl::HPXTeamMember>
-ThreadVectorRange(const Impl::HPXTeamMember &thread, const iType1 &i_begin,
-                  const iType2 &i_end) {
-  using iType = std::common_type_t<iType1, iType2>;
-  return Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>(
-      thread, iType(i_begin), iType(i_end));
-}
-
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::HPXTeamMember> PerTeam(
-    const Impl::HPXTeamMember &thread) {
-  return Impl::ThreadSingleStruct<Impl::HPXTeamMember>(thread);
-}
-
-KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::HPXTeamMember> PerThread(
-    const Impl::HPXTeamMember &thread) {
-  return Impl::VectorSingleStruct<Impl::HPXTeamMember>(thread);
-}
-
-/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
- * i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team.
- */
-template <typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION void parallel_for(
-    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const Lambda &lambda) {
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment)
-    lambda(i);
-}
-
-/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team
- * and a summation of val is performed and put into result.
- */
-template <typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const Lambda &lambda, ValueType &result) {
-  result = ValueType();
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, result);
-  }
-}
-
-/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
- * i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
- */
-template <typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION void parallel_for(
-    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const Lambda &lambda) {
-#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-#pragma ivdep
-#endif
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i);
-  }
-}
-
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
- * and a summation of val is performed and put into result.
- */
-template <typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const Lambda &lambda, ValueType &result) {
-  result = ValueType();
-#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-#pragma ivdep
-#endif
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, result);
-  }
-}
-
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const Lambda &lambda, const ReducerType &reducer) {
-  reducer.init(reducer.reference());
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, reducer.reference());
-  }
-}
-
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const Lambda &lambda, const ReducerType &reducer) {
-  reducer.init(reducer.reference());
-#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-#pragma ivdep
-#endif
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, reducer.reference());
-  }
-}
-
-template <typename iType, class FunctorType>
-KOKKOS_INLINE_FUNCTION void parallel_scan(
-    Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember> const
-        &loop_boundaries,
-    const FunctorType &lambda) {
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void,
-      FunctorType>::value_type;
-
-  value_type scan_val = value_type();
-
-  // Intra-member scan
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, scan_val, false);
-  }
-
-  // 'scan_val' output is the exclusive prefix sum
-  scan_val = loop_boundaries.thread.team_scan(scan_val);
-
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, scan_val, true);
-  }
-}
-
-/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
- * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
- * operation is performed. Depending on the target execution space the operator
- * might be called twice: once with final=false and once with final=true. When
- * final==true val contains the prefix sum value. The contribution of this "i"
- * needs to be added to val no matter whether final==true or not. In a serial
- * execution (i.e. team_size==1) the operator is only called once with
- * final==true. Scan_val will be set to the final sum value over all vector
- */
-template <typename iType, class FunctorType>
-KOKKOS_INLINE_FUNCTION void parallel_scan(
-    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const FunctorType &lambda) {
-  using value_type =
-      typename Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                     TeamPolicy<Experimental::HPX>,
-                                     FunctorType>::value_type;
-
-  value_type scan_val = value_type();
-
-#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-#pragma ivdep
-#endif
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, scan_val, true);
-  }
-}
-
-/** \brief  Intra-thread vector parallel scan with reducer
- *
- */
-template <typename iType, class FunctorType, typename ReducerType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
-parallel_scan(
-    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
-        &loop_boundaries,
-    const FunctorType &lambda, const ReducerType &reducer) {
-  typename ReducerType::value_type scan_val;
-  reducer.init(scan_val);
-
-#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-#pragma ivdep
-#endif
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end;
-       i += loop_boundaries.increment) {
-    lambda(i, scan_val, true);
-  }
-}
-
-template <class FunctorType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::VectorSingleStruct<Impl::HPXTeamMember> &,
-    const FunctorType &lambda) {
-  lambda();
-}
-
-template <class FunctorType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &,
-    const FunctorType &lambda) {
-  lambda();
-}
-
-template <class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::VectorSingleStruct<Impl::HPXTeamMember> &,
-    const FunctorType &lambda, ValueType &val) {
-  lambda(val);
-}
-
-template <class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::ThreadSingleStruct<Impl::HPXTeamMember> &,
-    const FunctorType &lambda, ValueType &val) {
-  lambda(val);
-}
-
-}  // namespace Kokkos
-
-#include <HPX/Kokkos_HPX_Task.hpp>
-
-#endif /* #if defined( KOKKOS_ENABLE_HPX ) */
-#endif /* #ifndef KOKKOS_HPX_HPP */
diff --git a/core/src/Kokkos_Half.hpp b/core/src/Kokkos_Half.hpp
index 9231fac5ff..91b94b4cfa 100644
--- a/core/src/Kokkos_Half.hpp
+++ b/core/src/Kokkos_Half.hpp
@@ -21,990 +21,9 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_HALF
 #endif
 
-#include <type_traits>
-#include <Kokkos_Macros.hpp>
-#include <iosfwd>  // istream & ostream for extraction and insertion ops
-#include <string>
+#include <impl/Kokkos_Half_FloatingPointWrapper.hpp>
+#include <impl/Kokkos_Half_NumericTraits.hpp>
 
-#ifdef KOKKOS_IMPL_HALF_TYPE_DEFINED
-
-// KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH: A macro to select which
-// floating_pointer_wrapper operator paths should be used. For CUDA, let the
-// compiler conditionally select when device ops are used For SYCL, we have a
-// full half type on both host and device
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_ENABLE_SYCL)
-#define KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-#endif
-
-/************************* BEGIN forward declarations *************************/
-namespace Kokkos {
-namespace Experimental {
-namespace Impl {
-template <class FloatType>
-class floating_point_wrapper;
-}
-
-// Declare half_t (binary16)
-using half_t = Kokkos::Experimental::Impl::floating_point_wrapper<
-    Kokkos::Impl::half_impl_t ::type>;
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(float val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(bool val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(double val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(short val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(int val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(long val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(long long val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned short val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned int val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned long val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned long long val);
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(half_t);
-
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, float>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, bool>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, double>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, short>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, int>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long long>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<std::is_same<T, unsigned short>::value, T>
-        cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, unsigned int>::value, T>
-    cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<std::is_same<T, unsigned long>::value, T>
-        cast_from_half(half_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<std::is_same<T, unsigned long long>::value, T>
-        cast_from_half(half_t);
-
-// declare bhalf_t
-#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
-using bhalf_t = Kokkos::Experimental::Impl::floating_point_wrapper<
-    Kokkos::Impl ::bhalf_impl_t ::type>;
-
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(float val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(bool val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(double val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(short val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(int val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(long val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(long long val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned short val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned int val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned long val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned long long val);
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(bhalf_t val);
-
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, float>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, bool>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, double>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, short>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, int>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long long>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<std::is_same<T, unsigned short>::value, T>
-        cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, unsigned int>::value, T>
-    cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<std::is_same<T, unsigned long>::value, T>
-        cast_from_bhalf(bhalf_t);
-template <class T>
-KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<std::is_same<T, unsigned long long>::value, T>
-        cast_from_bhalf(bhalf_t);
-#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
-
-template <class T>
-static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::half_t cast_to_wrapper(
-    T x, const volatile Kokkos::Impl::half_impl_t::type&);
-
-#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
-template <class T>
-static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::bhalf_t cast_to_wrapper(
-    T x, const volatile Kokkos::Impl::bhalf_impl_t::type&);
-#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
-
-template <class T>
-static KOKKOS_INLINE_FUNCTION T
-cast_from_wrapper(const Kokkos::Experimental::half_t& x);
-
-#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
-template <class T>
-static KOKKOS_INLINE_FUNCTION T
-cast_from_wrapper(const Kokkos::Experimental::bhalf_t& x);
-#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
-/************************** END forward declarations **************************/
-
-namespace Impl {
-template <class FloatType>
-class alignas(FloatType) floating_point_wrapper {
- public:
-  using impl_type = FloatType;
-
- private:
-  impl_type val;
-  using fixed_width_integer_type = std::conditional_t<
-      sizeof(impl_type) == 2, uint16_t,
-      std::conditional_t<
-          sizeof(impl_type) == 4, uint32_t,
-          std::conditional_t<sizeof(impl_type) == 8, uint64_t, void>>>;
-  static_assert(!std::is_void<fixed_width_integer_type>::value,
-                "Invalid impl_type");
-
- public:
-  // In-class initialization and defaulted default constructors not used
-  // since Cuda supports half precision initialization via the below constructor
-  KOKKOS_FUNCTION
-  floating_point_wrapper() : val(0.0F) {}
-
-// Copy constructors
-// Getting "C2580: multiple versions of a defaulted special
-// member function are not allowed" with VS 16.11.3 and CUDA 11.4.2
-#if defined(_WIN32) && defined(KOKKOS_ENABLE_CUDA)
-  KOKKOS_FUNCTION
-  floating_point_wrapper(const floating_point_wrapper& rhs) : val(rhs.val) {}
-#else
-  KOKKOS_DEFAULTED_FUNCTION
-  floating_point_wrapper(const floating_point_wrapper&) noexcept = default;
-#endif
-
-  KOKKOS_INLINE_FUNCTION
-  floating_point_wrapper(const volatile floating_point_wrapper& rhs) {
-#if defined(KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH) && !defined(KOKKOS_ENABLE_SYCL)
-    val = rhs.val;
-#else
-    const volatile fixed_width_integer_type* rv_ptr =
-        reinterpret_cast<const volatile fixed_width_integer_type*>(&rhs.val);
-    const fixed_width_integer_type rv_val = *rv_ptr;
-    val       = reinterpret_cast<const impl_type&>(rv_val);
-#endif  // KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-  }
-
-  // Don't support implicit conversion back to impl_type.
-  // impl_type is a storage only type on host.
-  KOKKOS_FUNCTION
-  explicit operator impl_type() const { return val; }
-  KOKKOS_FUNCTION
-  explicit operator float() const { return cast_from_wrapper<float>(*this); }
-  KOKKOS_FUNCTION
-  explicit operator bool() const { return cast_from_wrapper<bool>(*this); }
-  KOKKOS_FUNCTION
-  explicit operator double() const { return cast_from_wrapper<double>(*this); }
-  KOKKOS_FUNCTION
-  explicit operator short() const { return cast_from_wrapper<short>(*this); }
-  KOKKOS_FUNCTION
-  explicit operator int() const { return cast_from_wrapper<int>(*this); }
-  KOKKOS_FUNCTION
-  explicit operator long() const { return cast_from_wrapper<long>(*this); }
-  KOKKOS_FUNCTION
-  explicit operator long long() const {
-    return cast_from_wrapper<long long>(*this);
-  }
-  KOKKOS_FUNCTION
-  explicit operator unsigned short() const {
-    return cast_from_wrapper<unsigned short>(*this);
-  }
-  KOKKOS_FUNCTION
-  explicit operator unsigned int() const {
-    return cast_from_wrapper<unsigned int>(*this);
-  }
-  KOKKOS_FUNCTION
-  explicit operator unsigned long() const {
-    return cast_from_wrapper<unsigned long>(*this);
-  }
-  KOKKOS_FUNCTION
-  explicit operator unsigned long long() const {
-    return cast_from_wrapper<unsigned long long>(*this);
-  }
-
-  /**
-   * Conversion constructors.
-   *
-   * Support implicit conversions from impl_type, float, double ->
-   * floating_point_wrapper. Mixed precision expressions require upcasting which
-   * is done in the
-   * "// Binary Arithmetic" operator overloads below.
-   *
-   * Support implicit conversions from integral types -> floating_point_wrapper.
-   * Expressions involving floating_point_wrapper with integral types require
-   * downcasting the integral types to floating_point_wrapper. Existing operator
-   * overloads can handle this with the addition of the below implicit
-   * conversion constructors.
-   */
-  KOKKOS_FUNCTION
-  constexpr floating_point_wrapper(impl_type rhs) : val(rhs) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(float rhs) : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(double rhs) : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  explicit floating_point_wrapper(bool rhs)
-      : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(short rhs) : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(int rhs) : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(long rhs) : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(long long rhs) : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(unsigned short rhs)
-      : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(unsigned int rhs)
-      : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(unsigned long rhs)
-      : val(cast_to_wrapper(rhs, val).val) {}
-  KOKKOS_FUNCTION
-  floating_point_wrapper(unsigned long long rhs)
-      : val(cast_to_wrapper(rhs, val).val) {}
-
-  // Unary operators
-  KOKKOS_FUNCTION
-  floating_point_wrapper operator+() const {
-    floating_point_wrapper tmp = *this;
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    tmp.val = +tmp.val;
-#else
-    tmp.val   = cast_to_wrapper(+cast_from_wrapper<float>(tmp), val).val;
-#endif
-    return tmp;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper operator-() const {
-    floating_point_wrapper tmp = *this;
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    tmp.val = -tmp.val;
-#else
-    tmp.val   = cast_to_wrapper(-cast_from_wrapper<float>(tmp), val).val;
-#endif
-    return tmp;
-  }
-
-  // Prefix operators
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator++() {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    val = val + impl_type(1.0F);  // cuda has no operator++ for __nv_bfloat
-#else
-    float tmp = cast_from_wrapper<float>(*this);
-    ++tmp;
-    val       = cast_to_wrapper(tmp, val).val;
-#endif
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator--() {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    val = val - impl_type(1.0F);  // cuda has no operator-- for __nv_bfloat
-#else
-    float tmp = cast_from_wrapper<float>(*this);
-    --tmp;
-    val = cast_to_wrapper(tmp, val).val;
-#endif
-    return *this;
-  }
-
-  // Postfix operators
-  KOKKOS_FUNCTION
-  floating_point_wrapper operator++(int) {
-    floating_point_wrapper tmp = *this;
-    operator++();
-    return tmp;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper operator--(int) {
-    floating_point_wrapper tmp = *this;
-    operator--();
-    return tmp;
-  }
-
-  // Binary operators
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator=(impl_type rhs) {
-    val = rhs;
-    return *this;
-  }
-
-  template <class T>
-  KOKKOS_FUNCTION floating_point_wrapper& operator=(T rhs) {
-    val = cast_to_wrapper(rhs, val).val;
-    return *this;
-  }
-
-  template <class T>
-  KOKKOS_FUNCTION void operator=(T rhs) volatile {
-    impl_type new_val = cast_to_wrapper(rhs, val).val;
-    volatile fixed_width_integer_type* val_ptr =
-        reinterpret_cast<volatile fixed_width_integer_type*>(
-            const_cast<impl_type*>(&val));
-    *val_ptr = reinterpret_cast<fixed_width_integer_type&>(new_val);
-  }
-
-  // Compound operators
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator+=(floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    val = val + rhs.val;  // cuda has no operator+= for __nv_bfloat
-#else
-    val = cast_to_wrapper(
-              cast_from_wrapper<float>(*this) + cast_from_wrapper<float>(rhs),
-              val)
-              .val;
-#endif
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  void operator+=(const volatile floating_point_wrapper& rhs) volatile {
-    floating_point_wrapper tmp_rhs = rhs;
-    floating_point_wrapper tmp_lhs = *this;
-
-    tmp_lhs += tmp_rhs;
-    *this = tmp_lhs;
-  }
-
-  // Compound operators: upcast overloads for +=
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator+=(T& lhs, floating_point_wrapper rhs) {
-    lhs += static_cast<T>(rhs);
-    return lhs;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator+=(float rhs) {
-    float result = static_cast<float>(val) + rhs;
-    val          = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator+=(double rhs) {
-    double result = static_cast<double>(val) + rhs;
-    val           = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator-=(floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    val = val - rhs.val;  // cuda has no operator-= for __nv_bfloat
-#else
-    val = cast_to_wrapper(
-              cast_from_wrapper<float>(*this) - cast_from_wrapper<float>(rhs),
-              val)
-              .val;
-#endif
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  void operator-=(const volatile floating_point_wrapper& rhs) volatile {
-    floating_point_wrapper tmp_rhs = rhs;
-    floating_point_wrapper tmp_lhs = *this;
-
-    tmp_lhs -= tmp_rhs;
-    *this = tmp_lhs;
-  }
-
-  // Compund operators: upcast overloads for -=
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator-=(T& lhs, floating_point_wrapper rhs) {
-    lhs -= static_cast<T>(rhs);
-    return lhs;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator-=(float rhs) {
-    float result = static_cast<float>(val) - rhs;
-    val          = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator-=(double rhs) {
-    double result = static_cast<double>(val) - rhs;
-    val           = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator*=(floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    val = val * rhs.val;  // cuda has no operator*= for __nv_bfloat
-#else
-    val = cast_to_wrapper(
-              cast_from_wrapper<float>(*this) * cast_from_wrapper<float>(rhs),
-              val)
-              .val;
-#endif
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  void operator*=(const volatile floating_point_wrapper& rhs) volatile {
-    floating_point_wrapper tmp_rhs = rhs;
-    floating_point_wrapper tmp_lhs = *this;
-
-    tmp_lhs *= tmp_rhs;
-    *this = tmp_lhs;
-  }
-
-  // Compund operators: upcast overloads for *=
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator*=(T& lhs, floating_point_wrapper rhs) {
-    lhs *= static_cast<T>(rhs);
-    return lhs;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator*=(float rhs) {
-    float result = static_cast<float>(val) * rhs;
-    val          = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator*=(double rhs) {
-    double result = static_cast<double>(val) * rhs;
-    val           = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator/=(floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    val = val / rhs.val;  // cuda has no operator/= for __nv_bfloat
-#else
-    val = cast_to_wrapper(
-              cast_from_wrapper<float>(*this) / cast_from_wrapper<float>(rhs),
-              val)
-              .val;
-#endif
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  void operator/=(const volatile floating_point_wrapper& rhs) volatile {
-    floating_point_wrapper tmp_rhs = rhs;
-    floating_point_wrapper tmp_lhs = *this;
-
-    tmp_lhs /= tmp_rhs;
-    *this = tmp_lhs;
-  }
-
-  // Compund operators: upcast overloads for /=
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator/=(T& lhs, floating_point_wrapper rhs) {
-    lhs /= static_cast<T>(rhs);
-    return lhs;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator/=(float rhs) {
-    float result = static_cast<float>(val) / rhs;
-    val          = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  KOKKOS_FUNCTION
-  floating_point_wrapper& operator/=(double rhs) {
-    double result = static_cast<double>(val) / rhs;
-    val           = static_cast<impl_type>(result);
-    return *this;
-  }
-
-  // Binary Arithmetic
-  KOKKOS_FUNCTION
-  friend floating_point_wrapper operator+(floating_point_wrapper lhs,
-                                          floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    lhs += rhs;
-#else
-    lhs.val = cast_to_wrapper(
-                  cast_from_wrapper<float>(lhs) + cast_from_wrapper<float>(rhs),
-                  lhs.val)
-                  .val;
-#endif
-    return lhs;
-  }
-
-  // Binary Arithmetic upcast operators for +
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator+(floating_point_wrapper lhs, T rhs) {
-    return T(lhs) + rhs;
-  }
-
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator+(T lhs, floating_point_wrapper rhs) {
-    return lhs + T(rhs);
-  }
-
-  KOKKOS_FUNCTION
-  friend floating_point_wrapper operator-(floating_point_wrapper lhs,
-                                          floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    lhs -= rhs;
-#else
-    lhs.val = cast_to_wrapper(
-                  cast_from_wrapper<float>(lhs) - cast_from_wrapper<float>(rhs),
-                  lhs.val)
-                  .val;
-#endif
-    return lhs;
-  }
-
-  // Binary Arithmetic upcast operators for -
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator-(floating_point_wrapper lhs, T rhs) {
-    return T(lhs) - rhs;
-  }
-
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator-(T lhs, floating_point_wrapper rhs) {
-    return lhs - T(rhs);
-  }
-
-  KOKKOS_FUNCTION
-  friend floating_point_wrapper operator*(floating_point_wrapper lhs,
-                                          floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    lhs *= rhs;
-#else
-    lhs.val = cast_to_wrapper(
-                  cast_from_wrapper<float>(lhs) * cast_from_wrapper<float>(rhs),
-                  lhs.val)
-                  .val;
-#endif
-    return lhs;
-  }
-
-  // Binary Arithmetic upcast operators for *
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator*(floating_point_wrapper lhs, T rhs) {
-    return T(lhs) * rhs;
-  }
-
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator*(T lhs, floating_point_wrapper rhs) {
-    return lhs * T(rhs);
-  }
-
-  KOKKOS_FUNCTION
-  friend floating_point_wrapper operator/(floating_point_wrapper lhs,
-                                          floating_point_wrapper rhs) {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    lhs /= rhs;
-#else
-    lhs.val = cast_to_wrapper(
-                  cast_from_wrapper<float>(lhs) / cast_from_wrapper<float>(rhs),
-                  lhs.val)
-                  .val;
-#endif
-    return lhs;
-  }
-
-  // Binary Arithmetic upcast operators for /
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator/(floating_point_wrapper lhs, T rhs) {
-    return T(lhs) / rhs;
-  }
-
-  template <class T>
-  KOKKOS_FUNCTION friend std::enable_if_t<
-      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
-  operator/(T lhs, floating_point_wrapper rhs) {
-    return lhs / T(rhs);
-  }
-
-  // Logical operators
-  KOKKOS_FUNCTION
-  bool operator!() const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(!val);
-#else
-    return !cast_from_wrapper<float>(*this);
-#endif
-  }
-
-  // NOTE: Loses short-circuit evaluation
-  KOKKOS_FUNCTION
-  bool operator&&(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val && rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) && cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  // NOTE: Loses short-circuit evaluation
-  KOKKOS_FUNCTION
-  bool operator||(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val || rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) || cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  // Comparison operators
-  KOKKOS_FUNCTION
-  bool operator==(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val == rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) == cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  KOKKOS_FUNCTION
-  bool operator!=(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val != rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) != cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  KOKKOS_FUNCTION
-  bool operator<(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val < rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) < cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  KOKKOS_FUNCTION
-  bool operator>(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val > rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) > cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  KOKKOS_FUNCTION
-  bool operator<=(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val <= rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) <= cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  KOKKOS_FUNCTION
-  bool operator>=(floating_point_wrapper rhs) const {
-#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
-    return static_cast<bool>(val >= rhs.val);
-#else
-    return cast_from_wrapper<float>(*this) >= cast_from_wrapper<float>(rhs);
-#endif
-  }
-
-  KOKKOS_FUNCTION
-  friend bool operator==(const volatile floating_point_wrapper& lhs,
-                         const volatile floating_point_wrapper& rhs) {
-    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
-    return tmp_lhs == tmp_rhs;
-  }
-
-  KOKKOS_FUNCTION
-  friend bool operator!=(const volatile floating_point_wrapper& lhs,
-                         const volatile floating_point_wrapper& rhs) {
-    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
-    return tmp_lhs != tmp_rhs;
-  }
-
-  KOKKOS_FUNCTION
-  friend bool operator<(const volatile floating_point_wrapper& lhs,
-                        const volatile floating_point_wrapper& rhs) {
-    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
-    return tmp_lhs < tmp_rhs;
-  }
-
-  KOKKOS_FUNCTION
-  friend bool operator>(const volatile floating_point_wrapper& lhs,
-                        const volatile floating_point_wrapper& rhs) {
-    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
-    return tmp_lhs > tmp_rhs;
-  }
-
-  KOKKOS_FUNCTION
-  friend bool operator<=(const volatile floating_point_wrapper& lhs,
-                         const volatile floating_point_wrapper& rhs) {
-    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
-    return tmp_lhs <= tmp_rhs;
-  }
-
-  KOKKOS_FUNCTION
-  friend bool operator>=(const volatile floating_point_wrapper& lhs,
-                         const volatile floating_point_wrapper& rhs) {
-    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
-    return tmp_lhs >= tmp_rhs;
-  }
-
-  // Insertion and extraction operators
-  friend std::ostream& operator<<(std::ostream& os,
-                                  const floating_point_wrapper& x) {
-    const std::string out = std::to_string(static_cast<double>(x));
-    os << out;
-    return os;
-  }
-
-  friend std::istream& operator>>(std::istream& is, floating_point_wrapper& x) {
-    std::string in;
-    is >> in;
-    x = std::stod(in);
-    return is;
-  }
-};
-}  // namespace Impl
-
-// Declare wrapper overloads now that floating_point_wrapper is declared
-template <class T>
-static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::half_t cast_to_wrapper(
-    T x, const volatile Kokkos::Impl::half_impl_t::type&) {
-  return Kokkos::Experimental::cast_to_half(x);
-}
-
-#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
-template <class T>
-static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::bhalf_t cast_to_wrapper(
-    T x, const volatile Kokkos::Impl::bhalf_impl_t::type&) {
-  return Kokkos::Experimental::cast_to_bhalf(x);
-}
-#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
-
-template <class T>
-static KOKKOS_INLINE_FUNCTION T
-cast_from_wrapper(const Kokkos::Experimental::half_t& x) {
-  return Kokkos::Experimental::cast_from_half<T>(x);
-}
-
-#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
-template <class T>
-static KOKKOS_INLINE_FUNCTION T
-cast_from_wrapper(const Kokkos::Experimental::bhalf_t& x) {
-  return Kokkos::Experimental::cast_from_bhalf<T>(x);
-}
-#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
-
-}  // namespace Experimental
-}  // namespace Kokkos
-
-#endif  // KOKKOS_IMPL_HALF_TYPE_DEFINED
-
-// If none of the above actually did anything and defined a half precision type
-// define a fallback implementation here using float
-#ifndef KOKKOS_IMPL_HALF_TYPE_DEFINED
-#define KOKKOS_IMPL_HALF_TYPE_DEFINED
-#define KOKKOS_HALF_T_IS_FLOAT true
-namespace Kokkos {
-namespace Impl {
-struct half_impl_t {
-  using type = float;
-};
-}  // namespace Impl
-namespace Experimental {
-
-using half_t = Kokkos::Impl::half_impl_t::type;
-
-// cast_to_half
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(float val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(bool val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(double val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(short val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned short val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(int val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned int val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(long val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned long val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(long long val) { return half_t(val); }
-KOKKOS_INLINE_FUNCTION
-half_t cast_to_half(unsigned long long val) { return half_t(val); }
-
-// cast_from_half
-// Using an explicit list here too, since the other ones are explicit and for
-// example don't include char
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<
-    std::is_same<T, float>::value || std::is_same<T, bool>::value ||
-        std::is_same<T, double>::value || std::is_same<T, short>::value ||
-        std::is_same<T, unsigned short>::value || std::is_same<T, int>::value ||
-        std::is_same<T, unsigned int>::value || std::is_same<T, long>::value ||
-        std::is_same<T, unsigned long>::value ||
-        std::is_same<T, long long>::value ||
-        std::is_same<T, unsigned long long>::value,
-    T>
-cast_from_half(half_t val) {
-  return T(val);
-}
-
-}  // namespace Experimental
-}  // namespace Kokkos
-
-#else
-#define KOKKOS_HALF_T_IS_FLOAT false
-#endif  // KOKKOS_IMPL_HALF_TYPE_DEFINED
-
-#ifndef KOKKOS_IMPL_BHALF_TYPE_DEFINED
-#define KOKKOS_IMPL_BHALF_TYPE_DEFINED
-#define KOKKOS_BHALF_T_IS_FLOAT true
-namespace Kokkos {
-namespace Impl {
-struct bhalf_impl_t {
-  using type = float;
-};
-}  // namespace Impl
-
-namespace Experimental {
-
-using bhalf_t = Kokkos::Impl::bhalf_impl_t::type;
-
-// cast_to_bhalf
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(float val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(bool val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(double val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(short val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned short val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(int val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned int val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(long val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned long val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(long long val) { return bhalf_t(val); }
-KOKKOS_INLINE_FUNCTION
-bhalf_t cast_to_bhalf(unsigned long long val) { return bhalf_t(val); }
-
-// cast_from_bhalf
-template <class T>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<
-    std::is_same<T, float>::value || std::is_same<T, bool>::value ||
-        std::is_same<T, double>::value || std::is_same<T, short>::value ||
-        std::is_same<T, unsigned short>::value || std::is_same<T, int>::value ||
-        std::is_same<T, unsigned int>::value || std::is_same<T, long>::value ||
-        std::is_same<T, unsigned long>::value ||
-        std::is_same<T, long long>::value ||
-        std::is_same<T, unsigned long long>::value,
-    T>
-cast_from_bhalf(bhalf_t val) {
-  return T(val);
-}
-}  // namespace Experimental
-}  // namespace Kokkos
-#else
-#define KOKKOS_BHALF_T_IS_FLOAT false
-#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_HALF
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_HALF
diff --git a/core/src/Kokkos_HostSpace.hpp b/core/src/Kokkos_HostSpace.hpp
index 4b839aca05..4990337ab9 100644
--- a/core/src/Kokkos_HostSpace.hpp
+++ b/core/src/Kokkos_HostSpace.hpp
@@ -41,37 +41,6 @@ static_assert(false,
 
 /*--------------------------------------------------------------------------*/
 
-namespace Kokkos {
-
-namespace Impl {
-
-/// \brief Initialize lock array for arbitrary size atomics.
-///
-/// Arbitrary atomics are implemented using a hash table of locks
-/// where the hash value is derived from the address of the
-/// object for which an atomic operation is performed.
-/// This function initializes the locks to zero (unset).
-void init_lock_array_host_space();
-
-/// \brief Acquire a lock for the address
-///
-/// This function tries to acquire the lock for the hash value derived
-/// from the provided ptr. If the lock is successfully acquired the
-/// function returns true. Otherwise it returns false.
-bool lock_address_host_space(void* ptr);
-
-/// \brief Release lock for the address
-///
-/// This function releases the lock for the hash value derived
-/// from the provided ptr. This function should only be called
-/// after previously successfully acquiring a lock with
-/// lock_address.
-void unlock_address_host_space(void* ptr);
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
 namespace Kokkos {
 /// \class HostSpace
 /// \brief Memory management for host memory.
@@ -272,27 +241,6 @@ namespace Kokkos {
 
 namespace Impl {
 
-template <class DT, class... DP>
-struct ZeroMemset<typename HostSpace::execution_space, DT, DP...> {
-  ZeroMemset(const typename HostSpace::execution_space& exec,
-             const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    // Host spaces, except for HPX, are synchronous and we need to fence for HPX
-    // since we can't properly enqueue a std::memset otherwise.
-    // We can't use exec.fence() directly since we don't have a full definition
-    // of HostSpace here.
-    hostspace_fence(exec);
-    using ValueType = typename View<DT, DP...>::value_type;
-    std::memset(dst.data(), 0, sizeof(ValueType) * dst.size());
-  }
-
-  ZeroMemset(const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    using ValueType = typename View<DT, DP...>::value_type;
-    std::memset(dst.data(), 0, sizeof(ValueType) * dst.size());
-  }
-};
-
 template <>
 struct DeepCopy<HostSpace, HostSpace, DefaultHostExecutionSpace> {
   DeepCopy(void* dst, const void* src, size_t n) {
diff --git a/core/src/Kokkos_Macros.hpp b/core/src/Kokkos_Macros.hpp
index 289bfd7dda..3e10690c1e 100644
--- a/core/src/Kokkos_Macros.hpp
+++ b/core/src/Kokkos_Macros.hpp
@@ -55,6 +55,7 @@
 
 #ifndef KOKKOS_DONT_INCLUDE_CORE_CONFIG_H
 #include <KokkosCore_config.h>
+#include <impl/Kokkos_NvidiaGpuArchitectures.hpp>
 #endif
 
 //----------------------------------------------------------------------------
@@ -65,19 +66,13 @@
  *  KOKKOS_COMPILER_NVCC
  *  KOKKOS_COMPILER_GNU
  *  KOKKOS_COMPILER_INTEL
+ *  KOKKOS_COMPILER_INTEL_LLVM
  *  KOKKOS_COMPILER_CRAYC
  *  KOKKOS_COMPILER_APPLECC
  *  KOKKOS_COMPILER_CLANG
  *  KOKKOS_COMPILER_NVHPC
  *  KOKKOS_COMPILER_MSVC
  *
- *  Macros for which compiler extension to use for atomics on intrinsic types
- *
- *  KOKKOS_ENABLE_CUDA_ATOMICS
- *  KOKKOS_ENABLE_GNU_ATOMICS
- *  KOKKOS_ENABLE_INTEL_ATOMICS
- *  KOKKOS_ENABLE_OPENMP_ATOMICS
- *
  *  A suite of 'KOKKOS_ENABLE_PRAGMA_...' are defined for internal use.
  *
  *  Macros for marking functions to run in an execution space:
@@ -129,46 +124,46 @@
 
 #if defined(__INTEL_COMPILER)
 #define KOKKOS_COMPILER_INTEL __INTEL_COMPILER
+
 #elif defined(__INTEL_LLVM_COMPILER)
-#define KOKKOS_COMPILER_INTEL __INTEL_LLVM_COMPILER
-#elif defined(__ICC)
-// Old define
-#define KOKKOS_COMPILER_INTEL __ICC
-#elif defined(__ECC)
-// Very old define
-#define KOKKOS_COMPILER_INTEL __ECC
-#endif
+#define KOKKOS_COMPILER_INTEL_LLVM __INTEL_LLVM_COMPILER
+
+// Cray compiler for device offload code
+#elif defined(__cray__) && defined(__clang__)
+#define KOKKOS_COMPILER_CRAY_LLVM \
+  __cray_major__ * 100 + __cray_minor__ * 10 + __cray_patchlevel__
 
+#elif defined(_CRAYC)
 // CRAY compiler for host code
-#if defined(_CRAYC)
 #define KOKKOS_COMPILER_CRAYC _CRAYC
-#endif
 
-#if defined(__APPLE_CC__)
+#elif defined(__APPLE_CC__)
 #define KOKKOS_COMPILER_APPLECC __APPLE_CC__
-#endif
 
-#if defined(__clang__) && !defined(KOKKOS_COMPILER_INTEL)
+#elif defined(__NVCOMPILER)
+#define KOKKOS_COMPILER_NVHPC                                 \
+  __NVCOMPILER_MAJOR__ * 10000 + __NVCOMPILER_MINOR__ * 100 + \
+      __NVCOMPILER_PATCHLEVEL__
+
+#elif defined(__clang__)
+// Check this after the Clang-based proprietary compilers which will also define
+// __clang__
 #define KOKKOS_COMPILER_CLANG \
   __clang_major__ * 100 + __clang_minor__ * 10 + __clang_patchlevel__
-#endif
 
-#if !defined(__clang__) && !defined(KOKKOS_COMPILER_INTEL) && defined(__GNUC__)
+#elif defined(__GNUC__)
+// Check this here because many compilers (at least Clang variants and Intel
+// classic) define `__GNUC__` for compatibility
 #define KOKKOS_COMPILER_GNU \
   __GNUC__ * 100 + __GNUC_MINOR__ * 10 + __GNUC_PATCHLEVEL__
 
-#if (530 > KOKKOS_COMPILER_GNU)
-#error "Compiling with GCC version earlier than 5.3.0 is not supported."
-#endif
+#if (820 > KOKKOS_COMPILER_GNU)
+#error "Compiling with GCC version earlier than 8.2.0 is not supported."
 #endif
 
-#if defined(__NVCOMPILER)
-#define KOKKOS_COMPILER_NVHPC                              \
-  __NVCOMPILER_MAJOR__ * 100 + __NVCOMPILER_MINOR__ * 10 + \
-      __NVCOMPILER_PATCHLEVEL__
-#endif
-
-#if defined(_MSC_VER) && !defined(KOKKOS_COMPILER_INTEL)
+#elif defined(_MSC_VER)
+// Check this after Intel and Clang because those define _MSC_VER for
+// compatibility
 #define KOKKOS_COMPILER_MSVC _MSC_VER
 #endif
 
@@ -182,16 +177,13 @@
 //----------------------------------------------------------------------------
 // Intel compiler macros
 
-#if defined(KOKKOS_COMPILER_INTEL)
-// FIXME_SYCL
-#if !defined(KOKKOS_ENABLE_SYCL)
+#if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
+#if defined(KOKKOS_COMPILER_INTEL_LLVM) && \
+    KOKKOS_COMPILER_INTEL_LLVM >= 20230100
 #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
 #define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
 #define KOKKOS_ENABLE_PRAGMA_VECTOR 1
-#endif
 
-// FIXME_SYCL
-#if !defined(KOKKOS_ENABLE_SYCL)
 #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
 #endif
 
@@ -213,7 +205,7 @@
 #endif
 #endif
 
-#if (1900 > KOKKOS_COMPILER_INTEL)
+#if defined(KOKKOS_COMPILER_INTEL) && (1900 > KOKKOS_COMPILER_INTEL)
 #error "Compiling with Intel version earlier than 19.0.5 is not supported."
 #endif
 
@@ -231,10 +223,6 @@
 #endif
 #endif
 
-#if defined(KOKKOS_ARCH_AVX512MIC)
-#define KOKKOS_ENABLE_RFO_PREFETCH 1
-#endif
-
 #if defined(__MIC__)
 // Compiling for Xeon Phi
 #endif
@@ -276,10 +264,6 @@
 //#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
 //#define KOKKOS_ENABLE_PRAGMA_VECTOR 1
 
-#if defined(KOKKOS_ARCH_AVX512MIC)
-#define KOKKOS_ENABLE_RFO_PREFETCH 1
-#endif
-
 #if !defined(KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION)
 #define KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION \
   inline __attribute__((always_inline))
@@ -297,7 +281,7 @@
 
 //----------------------------------------------------------------------------
 
-#if defined(KOKKOS_COMPILER_PGI)
+#if defined(KOKKOS_COMPILER_NVHPC)
 #define KOKKOS_ENABLE_PRAGMA_UNROLL 1
 #define KOKKOS_ENABLE_PRAGMA_IVDEP 1
 //#define KOKKOS_ENABLE_PRAGMA_LOOPCOUNT 1
@@ -524,6 +508,7 @@ static constexpr bool kokkos_omp_on_host() { return false; }
     KOKKOS_IMPL_STRIP_PARENS(CODE)   \
   }
 #else
+#include <openacc.h>
 // FIXME_OPENACC acc_on_device is a non-constexpr function
 #define KOKKOS_IF_ON_DEVICE(CODE)                     \
   if constexpr (acc_on_device(acc_device_not_host)) { \
@@ -600,8 +585,9 @@ static constexpr bool kokkos_omp_on_host() { return false; }
 
 #define KOKKOS_ATTRIBUTE_NODISCARD [[nodiscard]]
 
-#if (defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) ||  \
-     defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_PGI)) && \
+#if (defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) ||        \
+     defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM) || \
+     defined(KOKKOS_COMPILER_NVHPC)) &&                                       \
     !defined(_WIN32) && !defined(__ANDROID__)
 #if __has_include(<execinfo.h>)
 #define KOKKOS_IMPL_ENABLE_STACKTRACE
diff --git a/core/src/Kokkos_MathematicalFunctions.hpp b/core/src/Kokkos_MathematicalFunctions.hpp
index 5016249edc..a795f700fa 100644
--- a/core/src/Kokkos_MathematicalFunctions.hpp
+++ b/core/src/Kokkos_MathematicalFunctions.hpp
@@ -485,6 +485,38 @@ KOKKOS_IMPL_MATH_UNARY_PREDICATE(signbit)
 #undef KOKKOS_IMPL_MATH_BINARY_FUNCTION
 #undef KOKKOS_IMPL_MATH_TERNARY_FUNCTION
 
+// non-standard math functions provided by CUDA/HIP/SYCL
+KOKKOS_INLINE_FUNCTION float rsqrt(float val) {
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  KOKKOS_IF_ON_DEVICE(return ::rsqrtf(val);)
+  KOKKOS_IF_ON_HOST(return 1.0f / Kokkos::sqrt(val);)
+#elif defined(KOKKOS_ENABLE_SYCL)
+  KOKKOS_IF_ON_DEVICE(return sycl::rsqrt(val);)
+  KOKKOS_IF_ON_HOST(return 1.0f / Kokkos::sqrt(val);)
+#else
+  return 1.0f / Kokkos::sqrt(val);
+#endif
+}
+KOKKOS_INLINE_FUNCTION double rsqrt(double val) {
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
+  KOKKOS_IF_ON_DEVICE(return ::rsqrt(val);)
+  KOKKOS_IF_ON_HOST(return 1.0 / Kokkos::sqrt(val);)
+#elif defined(KOKKOS_ENABLE_SYCL)
+  KOKKOS_IF_ON_DEVICE(return sycl::rsqrt(val);)
+  KOKKOS_IF_ON_HOST(return 1.0 / Kokkos::sqrt(val);)
+#else
+  return 1.0 / Kokkos::sqrt(val);
+#endif
+}
+inline long double rsqrt(long double val) { return 1.0l / Kokkos::sqrt(val); }
+KOKKOS_INLINE_FUNCTION float rsqrtf(float x) { return Kokkos::rsqrt(x); }
+inline long double rsqrtl(long double x) { return Kokkos::rsqrt(x); }
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_integral_v<T>, double> rsqrt(
+    T x) {
+  return Kokkos::rsqrt(static_cast<double>(x));
+}
+
 }  // namespace Kokkos
 
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_MATHFUNCTIONS
diff --git a/core/src/Kokkos_MemoryTraits.hpp b/core/src/Kokkos_MemoryTraits.hpp
index 762e1a4a5d..c145d04a42 100644
--- a/core/src/Kokkos_MemoryTraits.hpp
+++ b/core/src/Kokkos_MemoryTraits.hpp
@@ -48,17 +48,19 @@ template <unsigned T>
 struct MemoryTraits {
   //! Tag this class as a kokkos memory traits:
   using memory_traits = MemoryTraits<T>;
-  enum : bool {
-    is_unmanaged = (unsigned(0) != (T & unsigned(Kokkos::Unmanaged)))
-  };
-  enum : bool {
-    is_random_access = (unsigned(0) != (T & unsigned(Kokkos::RandomAccess)))
-  };
-  enum : bool { is_atomic = (unsigned(0) != (T & unsigned(Kokkos::Atomic))) };
-  enum : bool {
-    is_restrict = (unsigned(0) != (T & unsigned(Kokkos::Restrict)))
-  };
-  enum : bool { is_aligned = (unsigned(0) != (T & unsigned(Kokkos::Aligned))) };
+
+  static constexpr unsigned impl_value = T;
+
+  static constexpr bool is_unmanaged =
+      (unsigned(0) != (T & unsigned(Kokkos::Unmanaged)));
+  static constexpr bool is_random_access =
+      (unsigned(0) != (T & unsigned(Kokkos::RandomAccess)));
+  static constexpr bool is_atomic =
+      (unsigned(0) != (T & unsigned(Kokkos::Atomic)));
+  static constexpr bool is_restrict =
+      (unsigned(0) != (T & unsigned(Kokkos::Restrict)));
+  static constexpr bool is_aligned =
+      (unsigned(0) != (T & unsigned(Kokkos::Aligned)));
 };
 
 }  // namespace Kokkos
diff --git a/core/src/Kokkos_Parallel.hpp b/core/src/Kokkos_Parallel.hpp
index 7c42072226..484f6c0d5f 100644
--- a/core/src/Kokkos_Parallel.hpp
+++ b/core/src/Kokkos_Parallel.hpp
@@ -399,7 +399,8 @@ inline void parallel_scan(const std::string& str, const ExecutionPolicy& policy,
 
   if constexpr (Kokkos::is_view<ReturnType>::value) {
     Kokkos::Impl::shared_allocation_tracking_disable();
-    Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy, ReturnType>
+    Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy,
+                                typename ReturnType::value_type>
         closure(functor, inner_policy, return_value);
     Kokkos::Impl::shared_allocation_tracking_enable();
     closure.execute();
diff --git a/core/src/Kokkos_Parallel_Reduce.hpp b/core/src/Kokkos_Parallel_Reduce.hpp
index d44bd89a9b..34897ab1ee 100644
--- a/core/src/Kokkos_Parallel_Reduce.hpp
+++ b/core/src/Kokkos_Parallel_Reduce.hpp
@@ -37,6 +37,7 @@ struct Sum {
   // Required
   using reducer    = Sum<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -81,6 +82,7 @@ struct Prod {
   // Required
   using reducer    = Prod<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -125,6 +127,7 @@ struct Min {
   // Required
   using reducer    = Min<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -171,6 +174,7 @@ struct Max {
   // Required
   using reducer    = Max<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -218,6 +222,7 @@ struct LAnd {
   // Required
   using reducer    = LAnd<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -263,6 +268,7 @@ struct LOr {
   // Required
   using reducer    = LOr<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -309,6 +315,7 @@ struct BAnd {
   // Required
   using reducer    = BAnd<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -355,6 +362,7 @@ struct BOr {
   // Required
   using reducer    = BOr<Scalar, Space>;
   using value_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<value_type> && !std::is_array_v<value_type>);
 
   using result_view_type = Kokkos::View<value_type, Space>;
 
@@ -399,12 +407,6 @@ template <class Scalar, class Index>
 struct ValLocScalar {
   Scalar val;
   Index loc;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const ValLocScalar& rhs) {
-    val = rhs.val;
-    loc = rhs.loc;
-  }
 };
 
 template <class Scalar, class Index, class Space>
@@ -412,6 +414,8 @@ struct MinLoc {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
 
  public:
   // Required
@@ -465,6 +469,8 @@ struct MaxLoc {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
 
  public:
   // Required
@@ -516,18 +522,14 @@ MaxLoc(View<ValLocScalar<Scalar, Index>, Properties...> const&)
 template <class Scalar>
 struct MinMaxScalar {
   Scalar min_val, max_val;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const MinMaxScalar& rhs) {
-    min_val = rhs.min_val;
-    max_val = rhs.max_val;
-  }
 };
 
 template <class Scalar, class Space>
 struct MinMax {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
 
  public:
   // Required
@@ -584,14 +586,6 @@ template <class Scalar, class Index>
 struct MinMaxLocScalar {
   Scalar min_val, max_val;
   Index min_loc, max_loc;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const MinMaxLocScalar& rhs) {
-    min_val = rhs.min_val;
-    min_loc = rhs.min_loc;
-    max_val = rhs.max_val;
-    max_loc = rhs.max_loc;
-  }
 };
 
 template <class Scalar, class Index, class Space>
@@ -599,6 +593,8 @@ struct MinMaxLoc {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
 
  public:
   // Required
@@ -668,6 +664,9 @@ struct MaxFirstLoc {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -729,6 +728,9 @@ struct MaxFirstLocCustomComparator {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -795,6 +797,9 @@ struct MinFirstLoc {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -856,6 +861,9 @@ struct MinFirstLocCustomComparator {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -922,6 +930,9 @@ struct MinMaxFirstLastLoc {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -994,6 +1005,9 @@ struct MinMaxFirstLastLocCustomComparator {
  private:
   using scalar_type = std::remove_cv_t<Scalar>;
   using index_type  = std::remove_cv_t<Index>;
+  static_assert(!std::is_pointer_v<scalar_type> &&
+                !std::is_array_v<scalar_type>);
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -1069,15 +1083,13 @@ MinMaxFirstLastLocCustomComparator(
 template <class Index>
 struct FirstLocScalar {
   Index min_loc_true;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const FirstLocScalar& rhs) { min_loc_true = rhs.min_loc_true; }
 };
 
 template <class Index, class Space>
 struct FirstLoc {
  private:
   using index_type = std::remove_cv_t<Index>;
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -1132,15 +1144,13 @@ FirstLoc(View<FirstLocScalar<Index>, Properties...> const&)
 template <class Index>
 struct LastLocScalar {
   Index max_loc_true;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const LastLocScalar& rhs) { max_loc_true = rhs.max_loc_true; }
 };
 
 template <class Index, class Space>
 struct LastLoc {
  private:
   using index_type = std::remove_cv_t<Index>;
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -1192,12 +1202,6 @@ LastLoc(View<LastLocScalar<Index>, Properties...> const&)
 template <class Index>
 struct StdIsPartScalar {
   Index max_loc_true, min_loc_false;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const StdIsPartScalar& rhs) {
-    min_loc_false = rhs.min_loc_false;
-    max_loc_true  = rhs.max_loc_true;
-  }
 };
 
 //
@@ -1207,6 +1211,7 @@ template <class Index, class Space>
 struct StdIsPartitioned {
  private:
   using index_type = std::remove_cv_t<Index>;
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -1264,11 +1269,6 @@ StdIsPartitioned(View<StdIsPartScalar<Index>, Properties...> const&)
 template <class Index>
 struct StdPartPointScalar {
   Index min_loc_false;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const StdPartPointScalar& rhs) {
-    min_loc_false = rhs.min_loc_false;
-  }
 };
 
 //
@@ -1278,6 +1278,7 @@ template <class Index, class Space>
 struct StdPartitionPoint {
  private:
   using index_type = std::remove_cv_t<Index>;
+  static_assert(std::is_integral_v<index_type>);
 
  public:
   // Required
@@ -1331,6 +1332,46 @@ StdPartitionPoint(View<StdPartPointScalar<Index>, Properties...> const&)
 namespace Kokkos {
 namespace Impl {
 
+template <typename FunctorType, typename FunctorAnalysisReducerType,
+          typename Enable>
+class CombinedFunctorReducer {
+ public:
+  using functor_type = FunctorType;
+  using reducer_type = FunctorAnalysisReducerType;
+  CombinedFunctorReducer(const FunctorType& functor,
+                         const FunctorAnalysisReducerType& reducer)
+      : m_functor(functor), m_reducer(reducer) {}
+  KOKKOS_FUNCTION const FunctorType& get_functor() const { return m_functor; }
+  KOKKOS_FUNCTION const FunctorAnalysisReducerType& get_reducer() const {
+    return m_reducer;
+  }
+
+ private:
+  FunctorType m_functor;
+  FunctorAnalysisReducerType m_reducer;
+};
+template <typename FunctorType, typename FunctorAnalysisReducerType>
+class CombinedFunctorReducer<
+    FunctorType, FunctorAnalysisReducerType,
+    std::enable_if_t<std::is_same_v<
+        FunctorType, typename FunctorAnalysisReducerType::functor_type>>> {
+ public:
+  using functor_type = FunctorType;
+  using reducer_type = FunctorAnalysisReducerType;
+  CombinedFunctorReducer(const FunctorType& functor,
+                         const FunctorAnalysisReducerType&)
+      : m_reducer(functor) {}
+  KOKKOS_FUNCTION const FunctorType& get_functor() const {
+    return m_reducer.get_functor();
+  }
+  KOKKOS_FUNCTION const FunctorAnalysisReducerType& get_reducer() const {
+    return m_reducer;
+  }
+
+ private:
+  FunctorAnalysisReducerType m_reducer;
+};
+
 template <class T, class ReturnType, class ValueTraits>
 struct ParallelReduceReturnValue;
 
@@ -1396,12 +1437,12 @@ template <class ReturnType, class FunctorType>
 struct ParallelReduceReturnValue<
     std::enable_if_t<Kokkos::is_reducer<ReturnType>::value>, ReturnType,
     FunctorType> {
-  using return_type  = ReturnType;
+  using return_type  = typename ReturnType::result_view_type;
   using reducer_type = ReturnType;
   using value_type   = typename return_type::value_type;
 
-  static return_type return_value(ReturnType& return_val, const FunctorType&) {
-    return return_val;
+  static auto return_value(ReturnType& return_val, const FunctorType&) {
+    return return_val.view();
   }
 };
 
@@ -1449,29 +1490,41 @@ struct ParallelReduceAdaptor {
                                   const PolicyType& policy,
                                   const FunctorType& functor,
                                   ReturnType& return_value) {
-    uint64_t kpID = 0;
+    using PassedReducerType = typename return_value_adapter::reducer_type;
+    uint64_t kpID           = 0;
 
     PolicyType inner_policy = policy;
-    Kokkos::Tools::Impl::begin_parallel_reduce<
-        typename return_value_adapter::reducer_type>(inner_policy, functor,
-                                                     label, kpID);
-
+    Kokkos::Tools::Impl::begin_parallel_reduce<PassedReducerType>(
+        inner_policy, functor, label, kpID);
+
+    using ReducerSelector =
+        Kokkos::Impl::if_c<std::is_same<InvalidType, PassedReducerType>::value,
+                           FunctorType, PassedReducerType>;
+    using Analysis = FunctorAnalysis<FunctorPatternInterface::REDUCE,
+                                     PolicyType, typename ReducerSelector::type,
+                                     typename return_value_adapter::value_type>;
     Kokkos::Impl::shared_allocation_tracking_disable();
-    Impl::ParallelReduce<FunctorType, PolicyType,
-                         typename return_value_adapter::reducer_type>
-        closure(functor, inner_policy,
+    CombinedFunctorReducer functor_reducer(
+        functor, typename Analysis::Reducer(
+                     ReducerSelector::select(functor, return_value)));
+
+    // FIXME Remove "Wrapper" once all backends implement the new interface
+    Impl::ParallelReduce<decltype(functor_reducer), PolicyType,
+                         typename Impl::FunctorPolicyExecutionSpace<
+                             FunctorType, PolicyType>::execution_space>
+        closure(functor_reducer, inner_policy,
                 return_value_adapter::return_value(return_value, functor));
     Kokkos::Impl::shared_allocation_tracking_enable();
     closure.execute();
 
-    Kokkos::Tools::Impl::end_parallel_reduce<
-        typename return_value_adapter::reducer_type>(inner_policy, functor,
-                                                     label, kpID);
+    Kokkos::Tools::Impl::end_parallel_reduce<PassedReducerType>(
+        inner_policy, functor, label, kpID);
   }
 
   static constexpr bool is_array_reduction =
-      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
-                            FunctorType>::StaticValueSize == 0;
+      Impl::FunctorAnalysis<
+          Impl::FunctorPatternInterface::REDUCE, PolicyType, FunctorType,
+          typename return_value_adapter::value_type>::StaticValueSize == 0;
 
   template <typename Dummy = ReturnType>
   static inline std::enable_if_t<!(is_array_reduction &&
@@ -1771,7 +1824,7 @@ inline void parallel_reduce(
         nullptr) {
   using FunctorAnalysis =
       Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
-                            FunctorType>;
+                            FunctorType, void>;
   using value_type = std::conditional_t<(FunctorAnalysis::StaticValueSize != 0),
                                         typename FunctorAnalysis::value_type,
                                         typename FunctorAnalysis::pointer_type>;
@@ -1796,7 +1849,7 @@ inline void parallel_reduce(
         nullptr) {
   using FunctorAnalysis =
       Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
-                            FunctorType>;
+                            FunctorType, void>;
   using value_type = std::conditional_t<(FunctorAnalysis::StaticValueSize != 0),
                                         typename FunctorAnalysis::value_type,
                                         typename FunctorAnalysis::pointer_type>;
@@ -1821,7 +1874,7 @@ inline void parallel_reduce(const size_t& policy, const FunctorType& functor) {
                                               FunctorType>::policy_type;
   using FunctorAnalysis =
       Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, policy_type,
-                            FunctorType>;
+                            FunctorType, void>;
   using value_type = std::conditional_t<(FunctorAnalysis::StaticValueSize != 0),
                                         typename FunctorAnalysis::value_type,
                                         typename FunctorAnalysis::pointer_type>;
@@ -1848,7 +1901,7 @@ inline void parallel_reduce(const std::string& label, const size_t& policy,
                                               FunctorType>::policy_type;
   using FunctorAnalysis =
       Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, policy_type,
-                            FunctorType>;
+                            FunctorType, void>;
   using value_type = std::conditional_t<(FunctorAnalysis::StaticValueSize != 0),
                                         typename FunctorAnalysis::value_type,
                                         typename FunctorAnalysis::pointer_type>;
diff --git a/core/src/Kokkos_Profiling_ScopedRegion.hpp b/core/src/Kokkos_Profiling_ScopedRegion.hpp
new file mode 100644
index 0000000000..f45dfa324e
--- /dev/null
+++ b/core/src/Kokkos_Profiling_ScopedRegion.hpp
@@ -0,0 +1,51 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOSP_SCOPED_REGION_HPP
+#define KOKKOSP_SCOPED_REGION_HPP
+#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
+#define KOKKOS_IMPL_PUBLIC_INCLUDE
+#define KOKKOS_IMPL_PUBLIC_INCLUDE_PROFILING_SCOPEDREGION
+#endif
+
+#include <Kokkos_Macros.hpp>
+#include <impl/Kokkos_Profiling.hpp>
+
+#include <string>
+
+namespace Kokkos::Profiling {
+
+class [[nodiscard]] ScopedRegion {
+ public:
+  ScopedRegion(ScopedRegion const &) = delete;
+  ScopedRegion &operator=(ScopedRegion const &) = delete;
+
+#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard) >= 201907
+  [[nodiscard]]
+#endif
+  explicit ScopedRegion(std::string const &name) {
+    Kokkos::Profiling::pushRegion(name);
+  }
+  ~ScopedRegion() { Kokkos::Profiling::popRegion(); }
+};
+
+}  // namespace Kokkos::Profiling
+
+#ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
+#undef KOKKOS_IMPL_PUBLIC_INCLUDE
+#undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_PROFILING_SCOPEDREGION
+#endif
+#endif
diff --git a/core/src/Kokkos_TaskScheduler.hpp b/core/src/Kokkos_TaskScheduler.hpp
index 690c845b30..869a5f8ec2 100644
--- a/core/src/Kokkos_TaskScheduler.hpp
+++ b/core/src/Kokkos_TaskScheduler.hpp
@@ -347,9 +347,8 @@ class BasicTaskScheduler : public Impl::TaskSchedulerBase {
         if (nullptr != t) {
           // Increment reference count to track subsequent assignment.
           // This likely has to be SeqCst
-          Kokkos::Impl::desul_atomic_inc(&(t->m_ref_count),
-                                         Kokkos::Impl::MemoryOrderSeqCst(),
-                                         Kokkos::Impl::MemoryScopeDevice());
+          desul::atomic_inc(&(t->m_ref_count), desul::MemoryOrderSeqCst(),
+                            desul::MemoryScopeDevice());
           if (q != static_cast<queue_type const*>(t->m_queue)) {
             Kokkos::abort(
                 "Kokkos when_all Futures must be in the same scheduler");
@@ -445,9 +444,9 @@ class BasicTaskScheduler : public Impl::TaskSchedulerBase {
           //}
           // Increment reference count to track subsequent assignment.
           // This increment likely has to be SeqCst
-          Kokkos::Impl::desul_atomic_inc(&(arg_f.m_task->m_ref_count),
-                                         Kokkos::Impl::MemoryOrderSeqCst(),
-                                         Kokkos::Impl::MemoryScopeDevice());
+          desul::atomic_inc(&(arg_f.m_task->m_ref_count),
+                            desul::MemoryOrderSeqCst(),
+                            desul::MemoryScopeDevice());
           dep[i] = arg_f.m_task;
         }
       }
diff --git a/core/src/Kokkos_View.hpp b/core/src/Kokkos_View.hpp
index 85957ba8fa..bcbb28014c 100644
--- a/core/src/Kokkos_View.hpp
+++ b/core/src/Kokkos_View.hpp
@@ -34,6 +34,7 @@ static_assert(false,
 #include <View/Hooks/Kokkos_ViewHooks.hpp>
 
 #include <impl/Kokkos_Tools.hpp>
+#include <impl/Kokkos_Utilities.hpp>
 
 #ifdef KOKKOS_ENABLE_IMPL_MDSPAN
 #include <View/MDSpan/Kokkos_MDSpan_Extents.hpp>
@@ -315,8 +316,8 @@ struct ViewTraits {
       typename prop::specialize,
       typename data_analysis::specialize>; /* mapping specialization tag */
 
-  enum { rank = dimension::rank };
-  enum { rank_dynamic = dimension::rank_dynamic };
+  static constexpr unsigned rank         = dimension::rank;
+  static constexpr unsigned rank_dynamic = dimension::rank_dynamic;
 
   //------------------------------------
   // Execution space, memory space, memory access traits, and host mirror space.
@@ -494,17 +495,21 @@ constexpr bool is_assignable(const Kokkos::View<ViewTDst...>& dst,
 
 namespace Kokkos {
 
-namespace {
+// FIXME_OPENMPTARGET - The `declare target` is needed for the Intel GPUs with
+// the OpenMPTarget backend
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_COMPILER_INTEL_LLVM)
+#pragma omp declare target
+#endif
 
-constexpr Kokkos::Impl::ALL_t ALL = Kokkos::Impl::ALL_t();
+inline constexpr Kokkos::ALL_t ALL{};
 
-constexpr Kokkos::Impl::WithoutInitializing_t WithoutInitializing =
-    Kokkos::Impl::WithoutInitializing_t();
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_COMPILER_INTEL_LLVM)
+#pragma omp end declare target
+#endif
 
-constexpr Kokkos::Impl::AllowPadding_t AllowPadding =
-    Kokkos::Impl::AllowPadding_t();
+inline constexpr Kokkos::Impl::WithoutInitializing_t WithoutInitializing{};
 
-}  // namespace
+inline constexpr Kokkos::Impl::AllowPadding_t AllowPadding{};
 
 /** \brief  Create View allocation parameter bundle from argument list.
  *
@@ -640,13 +645,15 @@ class View : public ViewTraits<DataType, Properties...> {
   //----------------------------------------
   // Domain rank and extents
 
-  enum { Rank = map_type::Rank };
-
-  /** \brief rank() to be implemented
-   */
-  // KOKKOS_INLINE_FUNCTION
-  // static
-  // constexpr unsigned rank() { return map_type::Rank; }
+  static constexpr Impl::integral_constant<size_t, traits::dimension::rank>
+      rank = {};
+  static constexpr Impl::integral_constant<size_t,
+                                           traits::dimension::rank_dynamic>
+      rank_dynamic = {};
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  enum {Rank KOKKOS_DEPRECATED_WITH_COMMENT("Use rank instead.") =
+            map_type::Rank};
+#endif
 
   template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr std::enable_if_t<
@@ -807,14 +814,14 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename... Is>
   static KOKKOS_FUNCTION void check_access_member_function_valid_args(Is...) {
-    static_assert(Rank <= sizeof...(Is), "");
+    static_assert(rank <= sizeof...(Is), "");
     static_assert(sizeof...(Is) <= 8, "");
     static_assert(Kokkos::Impl::are_integral<Is...>::value, "");
   }
 
   template <typename... Is>
   static KOKKOS_FUNCTION void check_operator_parens_valid_args(Is...) {
-    static_assert(Rank == sizeof...(Is), "");
+    static_assert(rank == sizeof...(Is), "");
     static_assert(Kokkos::Impl::are_integral<Is...>::value, "");
   }
 
@@ -825,7 +832,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0>::value &&  //
-                        (1 == Rank) && is_default_map && !is_layout_stride),
+                        (1 == rank) && is_default_map && !is_layout_stride),
                        reference_type>
       operator()(I0 i0) const {
     check_operator_parens_valid_args(i0);
@@ -836,7 +843,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0>::value &&  //
-                        (1 == Rank) && is_default_map && is_layout_stride),
+                        (1 == rank) && is_default_map && is_layout_stride),
                        reference_type>
       operator()(I0 i0) const {
     check_operator_parens_valid_args(i0);
@@ -849,7 +856,7 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      ((1 == Rank) && Kokkos::Impl::are_integral<I0>::value && !is_default_map),
+      ((1 == rank) && Kokkos::Impl::are_integral<I0>::value && !is_default_map),
       reference_type>
   operator[](I0 i0) const {
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0)
@@ -858,7 +865,7 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<((1 == Rank) && Kokkos::Impl::are_integral<I0>::value &&
+      std::enable_if_t<((1 == rank) && Kokkos::Impl::are_integral<I0>::value &&
                         is_default_map && !is_layout_stride),
                        reference_type>
       operator[](I0 i0) const {
@@ -868,7 +875,7 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0>
   KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<((1 == Rank) && Kokkos::Impl::are_integral<I0>::value &&
+      std::enable_if_t<((1 == rank) && Kokkos::Impl::are_integral<I0>::value &&
                         is_default_map && is_layout_stride),
                        reference_type>
       operator[](I0 i0) const {
@@ -880,48 +887,44 @@ class View : public ViewTraits<DataType, Properties...> {
   // Rank 2 default map operator()
 
   template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&  //
-                        (2 == Rank) && is_default_map && is_layout_left &&
-                        (traits::rank_dynamic == 0)),
-                       reference_type>
-      operator()(I0 i0, I1 i1) const {
+  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
+      (Kokkos::Impl::always_true<I0, I1>::value &&  //
+       (2 == rank) && is_default_map && is_layout_left && (rank_dynamic == 0)),
+      reference_type>
+  operator()(I0 i0, I1 i1) const {
     check_operator_parens_valid_args(i0, i1);
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
     return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
   }
 
   template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&  //
-                        (2 == Rank) && is_default_map && is_layout_left &&
-                        (traits::rank_dynamic != 0)),
-                       reference_type>
-      operator()(I0 i0, I1 i1) const {
+  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
+      (Kokkos::Impl::always_true<I0, I1>::value &&  //
+       (2 == rank) && is_default_map && is_layout_left && (rank_dynamic != 0)),
+      reference_type>
+  operator()(I0 i0, I1 i1) const {
     check_operator_parens_valid_args(i0, i1);
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
     return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
   }
 
   template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&  //
-                        (2 == Rank) && is_default_map && is_layout_right &&
-                        (traits::rank_dynamic == 0)),
-                       reference_type>
-      operator()(I0 i0, I1 i1) const {
+  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
+      (Kokkos::Impl::always_true<I0, I1>::value &&  //
+       (2 == rank) && is_default_map && is_layout_right && (rank_dynamic == 0)),
+      reference_type>
+  operator()(I0 i0, I1 i1) const {
     check_operator_parens_valid_args(i0, i1);
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
     return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
   }
 
   template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&  //
-                        (2 == Rank) && is_default_map && is_layout_right &&
-                        (traits::rank_dynamic != 0)),
-                       reference_type>
-      operator()(I0 i0, I1 i1) const {
+  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
+      (Kokkos::Impl::always_true<I0, I1>::value &&  //
+       (2 == rank) && is_default_map && is_layout_right && (rank_dynamic != 0)),
+      reference_type>
+  operator()(I0 i0, I1 i1) const {
     check_operator_parens_valid_args(i0, i1);
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1)
     return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
@@ -930,7 +933,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1>::value &&  //
-                        (2 == Rank) && is_default_map && is_layout_stride),
+                        (2 == rank) && is_default_map && is_layout_stride),
                        reference_type>
       operator()(I0 i0, I1 i1) const {
     check_operator_parens_valid_args(i0, i1);
@@ -945,7 +948,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<Is...>::value &&  //
-       (2 != Rank) && (1 != Rank) && (0 != Rank) && is_default_map),
+       (2 != rank) && (1 != rank) && (0 != rank) && is_default_map),
       reference_type>
   operator()(Is... indices) const {
     check_operator_parens_valid_args(indices...);
@@ -956,7 +959,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<Is...>::value &&  //
-                        ((0 == Rank) || !is_default_map)),
+                        ((0 == rank) || !is_default_map)),
                        reference_type>
       operator()(Is... indices) const {
     check_operator_parens_valid_args(indices...);
@@ -969,7 +972,7 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<Is...>::value && (0 == Rank)), reference_type>
+      (Kokkos::Impl::always_true<Is...>::value && (0 == rank)), reference_type>
   access(Is... extra) const {
     check_access_member_function_valid_args(extra...);
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, extra...)
@@ -982,7 +985,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, Is...>::value &&
-                        (1 == Rank) && !is_default_map),
+                        (1 == rank) && !is_default_map),
                        reference_type>
       access(I0 i0, Is... extra) const {
     check_access_member_function_valid_args(i0, extra...);
@@ -993,7 +996,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, Is...>::value &&
-                        (1 == Rank) && is_default_map && !is_layout_stride),
+                        (1 == rank) && is_default_map && !is_layout_stride),
                        reference_type>
       access(I0 i0, Is... extra) const {
     check_access_member_function_valid_args(i0, extra...);
@@ -1004,7 +1007,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, Is...>::value &&
-                        (1 == Rank) && is_default_map && is_layout_stride),
+                        (1 == rank) && is_default_map && is_layout_stride),
                        reference_type>
       access(I0 i0, Is... extra) const {
     check_access_member_function_valid_args(i0, extra...);
@@ -1018,7 +1021,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename I1, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, Is...>::value &&
-                        (2 == Rank) && !is_default_map),
+                        (2 == rank) && !is_default_map),
                        reference_type>
       access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
@@ -1028,8 +1031,8 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0, typename I1, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
-       is_default_map && is_layout_left && (traits::rank_dynamic == 0)),
+      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == rank) &&
+       is_default_map && is_layout_left && (rank_dynamic == 0)),
       reference_type>
   access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
@@ -1039,8 +1042,8 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0, typename I1, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
-       is_default_map && is_layout_left && (traits::rank_dynamic != 0)),
+      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == rank) &&
+       is_default_map && is_layout_left && (rank_dynamic != 0)),
       reference_type>
   access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
@@ -1050,8 +1053,8 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0, typename I1, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
-       is_default_map && is_layout_right && (traits::rank_dynamic == 0)),
+      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == rank) &&
+       is_default_map && is_layout_right && (rank_dynamic == 0)),
       reference_type>
   access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
@@ -1061,8 +1064,8 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0, typename I1, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == Rank) &&
-       is_default_map && is_layout_right && (traits::rank_dynamic != 0)),
+      (Kokkos::Impl::always_true<I0, I1, Is...>::value && (2 == rank) &&
+       is_default_map && is_layout_right && (rank_dynamic != 0)),
       reference_type>
   access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
@@ -1073,7 +1076,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename I1, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, Is...>::value &&
-                        (2 == Rank) && is_default_map && is_layout_stride),
+                        (2 == rank) && is_default_map && is_layout_stride),
                        reference_type>
       access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
@@ -1088,7 +1091,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename I1, typename I2, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, Is...>::value &&
-                        (3 == Rank) && is_default_map),
+                        (3 == rank) && is_default_map),
                        reference_type>
       access(I0 i0, I1 i1, I2 i2, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, extra...);
@@ -1099,7 +1102,7 @@ class View : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename I1, typename I2, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, Is...>::value &&
-                        (3 == Rank) && !is_default_map),
+                        (3 == rank) && !is_default_map),
                        reference_type>
       access(I0 i0, I1 i1, I2 i2, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, extra...);
@@ -1112,7 +1115,7 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0, typename I1, typename I2, typename I3, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<I0, I1, I2, I3, Is...>::value && (4 == Rank) &&
+      (Kokkos::Impl::always_true<I0, I1, I2, I3, Is...>::value && (4 == rank) &&
        is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, Is... extra) const {
@@ -1123,7 +1126,7 @@ class View : public ViewTraits<DataType, Properties...> {
 
   template <typename I0, typename I1, typename I2, typename I3, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::always_true<I0, I1, I2, I3, Is...>::value && (4 == Rank) &&
+      (Kokkos::Impl::always_true<I0, I1, I2, I3, Is...>::value && (4 == rank) &&
        !is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, Is... extra) const {
@@ -1139,7 +1142,7 @@ class View : public ViewTraits<DataType, Properties...> {
             typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, Is...>::value &&
-       (5 == Rank) && is_default_map),
+       (5 == rank) && is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, i3, i4, extra...);
@@ -1152,7 +1155,7 @@ class View : public ViewTraits<DataType, Properties...> {
             typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, Is...>::value &&
-       (5 == Rank) && !is_default_map),
+       (5 == rank) && !is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, i3, i4, extra...);
@@ -1168,7 +1171,7 @@ class View : public ViewTraits<DataType, Properties...> {
             typename I5, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, Is...>::value &&
-       (6 == Rank) && is_default_map),
+       (6 == rank) && is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, extra...);
@@ -1181,7 +1184,7 @@ class View : public ViewTraits<DataType, Properties...> {
             typename I5, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, Is...>::value &&
-       (6 == Rank) && !is_default_map),
+       (6 == rank) && !is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, extra...);
@@ -1197,7 +1200,7 @@ class View : public ViewTraits<DataType, Properties...> {
             typename I5, typename I6, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6, Is...>::value &&
-       (7 == Rank) && is_default_map),
+       (7 == rank) && is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, i6,
@@ -1211,7 +1214,7 @@ class View : public ViewTraits<DataType, Properties...> {
             typename I5, typename I6, typename... Is>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6, Is...>::value &&
-       (7 == Rank) && !is_default_map),
+       (7 == rank) && !is_default_map),
       reference_type>
   access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, i2, i3, i4, i5, i6,
@@ -1229,7 +1232,7 @@ class View : public ViewTraits<DataType, Properties...> {
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6,
                                                   I7, Is...>::value &&
-                        (8 == Rank) && is_default_map),
+                        (8 == rank) && is_default_map),
                        reference_type>
       access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, I7 i7,
              Is... extra) const {
@@ -1246,7 +1249,7 @@ class View : public ViewTraits<DataType, Properties...> {
   KOKKOS_FORCEINLINE_FUNCTION
       std::enable_if_t<(Kokkos::Impl::always_true<I0, I1, I2, I3, I4, I5, I6,
                                                   I7, Is...>::value &&
-                        (8 == Rank) && !is_default_map),
+                        (8 == rank) && !is_default_map),
                        reference_type>
       access(I0 i0, I1 i1, I2 i2, I3 i3, I4 i4, I5 i5, I6 i6, I7 i7,
              Is... extra) const {
@@ -1411,38 +1414,13 @@ class View : public ViewTraits<DataType, Properties...> {
     const std::string& alloc_name =
         Impl::get_property<Impl::LabelTag>(prop_copy);
     Impl::runtime_check_rank(
-        traits::rank, traits::rank_dynamic,
+        rank, rank_dynamic,
         std::is_same<typename traits::specialize, void>::value, i0, i1, i2, i3,
         i4, i5, i6, i7, alloc_name);
 
-//------------------------------------------------------------
-#if defined(KOKKOS_ENABLE_CUDA)
-    // If allocating in CudaUVMSpace must fence before and after
-    // the allocation to protect against possible concurrent access
-    // on the CPU and the GPU.
-    // Fence using the trait's execution space (which will be Kokkos::Cuda)
-    // to avoid incomplete type errors from using Kokkos::Cuda directly.
-    if (std::is_same<Kokkos::CudaUVMSpace,
-                     typename traits::device_type::memory_space>::value) {
-      typename traits::device_type::memory_space::execution_space().fence(
-          "Kokkos::View<...>::View: fence before allocating UVM");
-    }
-#endif
-    //------------------------------------------------------------
-
     Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
         prop_copy, arg_layout, Impl::ViewCtorProp<P...>::has_execution_space);
 
-//------------------------------------------------------------
-#if defined(KOKKOS_ENABLE_CUDA)
-    if (std::is_same<Kokkos::CudaUVMSpace,
-                     typename traits::device_type::memory_space>::value) {
-      typename traits::device_type::memory_space::execution_space().fence(
-          "Kokkos::View<...>::View: fence after allocating UVM");
-    }
-#endif
-    //------------------------------------------------------------
-
     // Setup and initialization complete, start tracking
     m_track.m_tracker.assign_allocated_record_to_uninitialized(record);
   }
@@ -1627,7 +1605,7 @@ class View : public ViewTraits<DataType, Properties...> {
         arg_N0, arg_N1, arg_N2, arg_N3, arg_N4, arg_N5, arg_N6, arg_N7);
 
     if (std::is_void<typename traits::specialize>::value &&
-        num_passed_args != traits::rank_dynamic) {
+        num_passed_args != rank_dynamic) {
       Kokkos::abort(
           "Kokkos::View::shmem_size() rank_dynamic != number of arguments.\n");
     }
@@ -1683,14 +1661,10 @@ class View : public ViewTraits<DataType, Properties...> {
   }
 };
 
-/** \brief Temporary free function rank()
- *         until rank() is implemented
- *         in the View
- */
 template <typename D, class... P>
-KOKKOS_INLINE_FUNCTION constexpr unsigned rank(const View<D, P...>& V) {
-  return V.Rank;
-}  // Temporary until added to view
+KOKKOS_INLINE_FUNCTION constexpr unsigned rank(const View<D, P...>&) {
+  return View<D, P...>::rank();
+}
 
 namespace Impl {
 
@@ -1706,7 +1680,7 @@ struct RankDataType<ValueType, 0> {
 
 template <unsigned N, typename... Args>
 KOKKOS_FUNCTION std::enable_if_t<
-    N == View<Args...>::Rank &&
+    N == View<Args...>::rank() &&
         std::is_same<typename ViewTraits<Args...>::specialize, void>::value,
     View<Args...>>
 as_view_of_rank_n(View<Args...> v) {
@@ -1717,7 +1691,7 @@ as_view_of_rank_n(View<Args...> v) {
 // never be called
 template <unsigned N, typename T, typename... Args>
 KOKKOS_FUNCTION std::enable_if_t<
-    N != View<T, Args...>::Rank &&
+    N != View<T, Args...>::rank() &&
         std::is_same<typename ViewTraits<T, Args...>::specialize, void>::value,
     View<typename RankDataType<typename View<T, Args...>::value_type, N>::type,
          Args...>>
@@ -1735,44 +1709,66 @@ void apply_to_view_of_static_rank(Function&& f, View<Args...> a) {
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <class V, class... Args>
-using Subview =
-    typename Kokkos::Impl::ViewMapping<void /* deduce subview type from source
-                                               view traits */
-                                       ,
-                                       typename V::traits, Args...>::type;
+namespace Impl {
+template <class ValueType, class TypeList>
+struct TypeListToViewTraits;
+
+template <class ValueType, class... Properties>
+struct TypeListToViewTraits<ValueType, Kokkos::Impl::type_list<Properties...>> {
+  using type = ViewTraits<ValueType, Properties...>;
+};
+
+// It is not safe to assume that subviews of views with the Aligned memory trait
+// are also aligned. Hence, just remove that attribute for subviews.
+template <class D, class... P>
+struct RemoveAlignedMemoryTrait {
+ private:
+  using type_list_in  = Kokkos::Impl::type_list<P...>;
+  using memory_traits = typename ViewTraits<D, P...>::memory_traits;
+  using type_list_in_wo_memory_traits =
+      typename Kokkos::Impl::type_list_remove_first<memory_traits,
+                                                    type_list_in>::type;
+  using new_memory_traits =
+      Kokkos::MemoryTraits<memory_traits::impl_value & ~Kokkos::Aligned>;
+  using new_type_list = typename Kokkos::Impl::concat_type_list<
+      type_list_in_wo_memory_traits,
+      Kokkos::Impl::type_list<new_memory_traits>>::type;
+
+ public:
+  using type = typename TypeListToViewTraits<D, new_type_list>::type;
+};
+}  // namespace Impl
 
 template <class D, class... P, class... Args>
-KOKKOS_INLINE_FUNCTION
-    typename Kokkos::Impl::ViewMapping<void /* deduce subview type from source
-                                               view traits */
-                                       ,
-                                       ViewTraits<D, P...>, Args...>::type
-    subview(const View<D, P...>& src, Args... args) {
-  static_assert(View<D, P...>::Rank == sizeof...(Args),
+KOKKOS_INLINE_FUNCTION auto subview(const View<D, P...>& src, Args... args) {
+  static_assert(View<D, P...>::rank == sizeof...(Args),
                 "subview requires one argument for each source View rank");
 
   return typename Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>, Args...>::type(src, args...);
+      typename Impl::RemoveAlignedMemoryTrait<D, P...>::type,
+      Args...>::type(src, args...);
 }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 template <class MemoryTraits, class D, class... P, class... Args>
-KOKKOS_INLINE_FUNCTION typename Kokkos::Impl::ViewMapping<
-    void /* deduce subview type from source view traits */
-    ,
-    ViewTraits<D, P...>, Args...>::template apply<MemoryTraits>::type
-subview(const View<D, P...>& src, Args... args) {
-  static_assert(View<D, P...>::Rank == sizeof...(Args),
+KOKKOS_DEPRECATED KOKKOS_INLINE_FUNCTION auto subview(const View<D, P...>& src,
+                                                      Args... args) {
+  static_assert(View<D, P...>::rank == sizeof...(Args),
                 "subview requires one argument for each source View rank");
+  static_assert(Kokkos::is_memory_traits<MemoryTraits>::value);
 
   return typename Kokkos::Impl::ViewMapping<
       void /* deduce subview type from source view traits */
       ,
-      ViewTraits<D, P...>,
-      Args...>::template apply<MemoryTraits>::type(src, args...);
+      typename Impl::RemoveAlignedMemoryTrait<D, P..., MemoryTraits>::type,
+      Args...>::type(src, args...);
 }
+#endif
+
+template <class V, class... Args>
+using Subview = decltype(subview(std::declval<V>(), std::declval<Args>()...));
 
 } /* namespace Kokkos */
 
@@ -1794,7 +1790,7 @@ KOKKOS_INLINE_FUNCTION bool operator==(const View<LT, LP...>& lhs,
                       typename rhs_traits::array_layout>::value &&
          std::is_same<typename lhs_traits::memory_space,
                       typename rhs_traits::memory_space>::value &&
-         unsigned(lhs_traits::rank) == unsigned(rhs_traits::rank) &&
+         View<LT, LP...>::rank() == View<RT, RP...>::rank() &&
          lhs.data() == rhs.data() && lhs.span() == rhs.span() &&
          lhs.extent(0) == rhs.extent(0) && lhs.extent(1) == rhs.extent(1) &&
          lhs.extent(2) == rhs.extent(2) && lhs.extent(3) == rhs.extent(3) &&
diff --git a/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp b/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp
index 1325e61e1d..f2fd1a3619 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp
@@ -17,27 +17,40 @@
 #ifndef KOKKOS_OPENACC_FUNCTOR_ADAPTER_HPP
 #define KOKKOS_OPENACC_FUNCTOR_ADAPTER_HPP
 
+#include <OpenACC/Kokkos_OpenACC_Macros.hpp>
 #include <type_traits>
 
 namespace Kokkos::Experimental::Impl {
 
-template <class Functor, class Policy>
-class FunctorAdapter {
-  Functor m_functor;
-  using WorkTag = typename Policy::work_tag;
-
- public:
-  FunctorAdapter(Functor const &functor) : m_functor(functor) {}
-
-  template <class... Args>
-  KOKKOS_FUNCTION void operator()(Args &&... args) const {
-    if constexpr (std::is_void_v<WorkTag>) {
-      m_functor(static_cast<Args &&>(args)...);
-    } else {
-      m_functor(WorkTag(), static_cast<Args &&>(args)...);
-    }
+enum class RoutineClause { worker, seq };
+
+template <class Functor, class Policy, RoutineClause>
+class FunctorAdapter;
+
+#define KOKKOS_IMPL_ACC_FUNCTOR_ADAPTER(CLAUSE)                    \
+  template <class Functor, class Policy>                           \
+  class FunctorAdapter<Functor, Policy, RoutineClause::CLAUSE> {   \
+    Functor m_functor;                                             \
+    using WorkTag = typename Policy::work_tag;                     \
+                                                                   \
+   public:                                                         \
+    FunctorAdapter(Functor const &functor) : m_functor(functor) {} \
+                                                                   \
+    KOKKOS_IMPL_ACC_PRAGMA_HELPER(routine CLAUSE)                  \
+    template <class... Args>                                       \
+    KOKKOS_FUNCTION void operator()(Args &&... args) const {       \
+      if constexpr (std::is_void_v<WorkTag>) {                     \
+        m_functor(static_cast<Args &&>(args)...);                  \
+      } else {                                                     \
+        m_functor(WorkTag(), static_cast<Args &&>(args)...);       \
+      }                                                            \
+    }                                                              \
   }
-};
+
+KOKKOS_IMPL_ACC_FUNCTOR_ADAPTER(worker);
+KOKKOS_IMPL_ACC_FUNCTOR_ADAPTER(seq);
+
+#undef KOKKOS_IMPL_ACC_FUNCTOR_ADAPTER
 
 }  // namespace Kokkos::Experimental::Impl
 
diff --git a/core/src/OpenACC/Kokkos_OpenACC_MDRangePolicy.hpp b/core/src/OpenACC/Kokkos_OpenACC_MDRangePolicy.hpp
index 4525f37a61..9c58dd6fa6 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_MDRangePolicy.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_MDRangePolicy.hpp
@@ -42,4 +42,19 @@ struct ThreadAndVectorNestLevel<Rank, Kokkos::Experimental::OpenACC,
 }  // namespace Impl
 }  // namespace Kokkos
 
+namespace Kokkos::Experimental::Impl {
+
+struct OpenACCCollapse {};
+struct OpenACCTile {};
+using OpenACCIterateLeft  = std::integral_constant<Iterate, Iterate::Left>;
+using OpenACCIterateRight = std::integral_constant<Iterate, Iterate::Right>;
+template <int N>
+using OpenACCMDRangeBegin = decltype(MDRangePolicy<OpenACC, Rank<N>>::m_lower);
+template <int N>
+using OpenACCMDRangeEnd = decltype(MDRangePolicy<OpenACC, Rank<N>>::m_upper);
+template <int N>
+using OpenACCMDRangeTile = decltype(MDRangePolicy<OpenACC, Rank<N>>::m_tile);
+
+}  // namespace Kokkos::Experimental::Impl
+
 #endif
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_MDRange.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_MDRange.hpp
index ac219527c6..550436fe7b 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_MDRange.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_MDRange.hpp
@@ -24,17 +24,6 @@
 
 namespace Kokkos::Experimental::Impl {
 
-struct OpenACCCollapse {};
-struct OpenACCTile {};
-using OpenACCIterateLeft  = std::integral_constant<Iterate, Iterate::Left>;
-using OpenACCIterateRight = std::integral_constant<Iterate, Iterate::Right>;
-template <int N>
-using OpenACCMDRangeBegin = decltype(MDRangePolicy<OpenACC, Rank<N>>::m_lower);
-template <int N>
-using OpenACCMDRangeEnd = decltype(MDRangePolicy<OpenACC, Rank<N>>::m_upper);
-template <int N>
-using OpenACCMDRangeTile = decltype(MDRangePolicy<OpenACC, Rank<N>>::m_tile);
-
 template <class Functor>
 void OpenACCParallelForMDRangePolicy(OpenACCCollapse, OpenACCIterateLeft,
                                      Functor const& functor,
@@ -651,7 +640,9 @@ template <class Functor, class... Traits>
 class Kokkos::Impl::ParallelFor<Functor, Kokkos::MDRangePolicy<Traits...>,
                                 Kokkos::Experimental::OpenACC> {
   using Policy = MDRangePolicy<Traits...>;
-  Kokkos::Experimental::Impl::FunctorAdapter<Functor, Policy> m_functor;
+  Kokkos::Experimental::Impl::FunctorAdapter<
+      Functor, Policy, Kokkos::Experimental::Impl::RoutineClause::seq>
+      m_functor;
   Policy m_policy;
 
  public:
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Range.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Range.hpp
index ede93ec19e..6ddfc352fc 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Range.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Range.hpp
@@ -78,7 +78,9 @@ template <class Functor, class... Traits>
 class Kokkos::Impl::ParallelFor<Functor, Kokkos::RangePolicy<Traits...>,
                                 Kokkos::Experimental::OpenACC> {
   using Policy = Kokkos::RangePolicy<Traits...>;
-  Kokkos::Experimental::Impl::FunctorAdapter<Functor, Policy> m_functor;
+  Kokkos::Experimental::Impl::FunctorAdapter<
+      Functor, Policy, Kokkos::Experimental::Impl::RoutineClause::seq>
+      m_functor;
   Policy m_policy;
   using ScheduleType = Kokkos::Experimental::Impl::OpenACCScheduleType<Policy>;
 
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp
index c08c15879c..b5cf670791 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp
@@ -17,7 +17,6 @@
 #ifndef KOKKOS_OPENACC_PARALLEL_FOR_TEAM_HPP
 #define KOKKOS_OPENACC_PARALLEL_FOR_TEAM_HPP
 
-#include <openacc.h>
 #include <OpenACC/Kokkos_OpenACC_Team.hpp>
 #include <OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp>
 
@@ -32,7 +31,9 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
  private:
   using Policy = Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenACC,
                                                   Properties...>;
-  Kokkos::Experimental::Impl::FunctorAdapter<FunctorType, Policy> m_functor;
+  Kokkos::Experimental::Impl::FunctorAdapter<
+      FunctorType, Policy, Kokkos::Experimental::Impl::RoutineClause::seq>
+      m_functor;
   using Member = typename Policy::member_type;
 
   const Policy m_policy;
@@ -131,7 +132,8 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
  private:
   using Policy = Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenACC,
                                                   Properties...>;
-  Kokkos::Experimental::Impl::FunctorAdapter<FunctorType, Policy> m_functor;
+  Kokkos::Experimental::Impl::FunctorAdapter<FunctorType, Policy, worker>
+      m_functor;
   using Member = typename Policy::member_type;
 
   const Policy m_policy;
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp
new file mode 100644
index 0000000000..2c7793dc11
--- /dev/null
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp
@@ -0,0 +1,472 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENACC_PARALLEL_REDUCE_MDRANGE_HPP
+#define KOKKOS_OPENACC_PARALLEL_REDUCE_MDRANGE_HPP
+
+#include <OpenACC/Kokkos_OpenACC.hpp>
+#include <OpenACC/Kokkos_OpenACC_Macros.hpp>
+#include <OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp>
+#include <OpenACC/Kokkos_OpenACC_MDRangePolicy.hpp>
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos::Experimental::Impl {
+
+// primary template: catch-all non-implemented custom reducers
+template <class Functor, class Reducer, class Policy,
+          bool = std::is_arithmetic_v<typename Reducer::value_type>>
+struct OpenACCParallelReduceMDRangeHelper {
+  OpenACCParallelReduceMDRangeHelper(Functor const&, Reducer const&,
+                                     Policy const&) {
+    static_assert(!Kokkos::Impl::always_true<Functor>::value,
+                  "not implemented");
+  }
+};
+}  // namespace Kokkos::Experimental::Impl
+
+template <class CombinedFunctorReducerType, class... Traits>
+class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
+                                   Kokkos::MDRangePolicy<Traits...>,
+                                   Kokkos::Experimental::OpenACC> {
+  using Policy      = MDRangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using Pointer   = typename ReducerType::pointer_type;
+  using ValueType = typename ReducerType::value_type;
+
+  CombinedFunctorReducerType m_functor_reducer;
+  Policy m_policy;
+  Pointer m_result_ptr;
+  bool m_result_ptr_on_device;
+
+ public:
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& functor_reducer,
+                 const Policy& policy, const ViewType& result)
+      : m_functor_reducer(functor_reducer),
+        m_policy(policy),
+        m_result_ptr(result.data()),
+        m_result_ptr_on_device(
+            MemorySpaceAccess<Kokkos::Experimental::OpenACCSpace,
+                              typename ViewType::memory_space>::accessible) {}
+
+  void execute() const {
+    static_assert(1 < Policy::rank && Policy::rank < 7);
+    static_assert(Policy::inner_direction == Iterate::Left ||
+                  Policy::inner_direction == Iterate::Right);
+    constexpr int rank = Policy::rank;
+    ValueType val;
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+    reducer.init(&val);
+
+    for (int i = 0; i < rank; ++i) {
+      if (m_policy.m_lower[i] >= m_policy.m_upper[i]) {
+        if (m_result_ptr_on_device) {
+          acc_memcpy_to_device(m_result_ptr, &val, sizeof(ValueType));
+        } else {
+          *m_result_ptr = val;
+        }
+        return;
+      }
+    }
+
+    int const async_arg = m_policy.space().acc_async_queue();
+
+    Kokkos::Experimental::Impl::OpenACCParallelReduceMDRangeHelper(
+        Kokkos::Experimental::Impl::FunctorAdapter<
+            FunctorType, Policy,
+            Kokkos::Experimental::Impl::RoutineClause::seq>(
+            m_functor_reducer.get_functor()),
+        std::conditional_t<
+            std::is_same_v<FunctorType, typename ReducerType::functor_type>,
+            Sum<ValueType>, typename ReducerType::functor_type>(val),
+        m_policy);
+
+    // OpenACC backend supports only built-in Reducer types; thus
+    // reducer.final() below is a no-op.
+    reducer.final(&val);
+    // acc_wait(async_arg) in the below if-else statements is needed because the
+    // above OpenACC compute kernel can be executed asynchronously and val is a
+    // local host variable.
+    if (m_result_ptr_on_device) {
+      acc_memcpy_to_device_async(m_result_ptr, &val, sizeof(ValueType),
+                                 async_arg);
+      acc_wait(async_arg);
+    } else {
+      acc_wait(async_arg);
+      *m_result_ptr = val;
+    }
+  }
+};
+
+#define KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_DISPATCH_ITERATE(REDUCER,         \
+                                                             OPERATOR)        \
+  namespace Kokkos::Experimental::Impl {                                      \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateLeft, ValueType& aval,    \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<2> const& begin,    \
+                                      OpenACCMDRangeEnd<2> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(2) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i1 = begin1; i1 < end1; ++i1) {                                 \
+      for (auto i0 = begin0; i0 < end0; ++i0) {                               \
+        functor(i0, i1, val);                                                 \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateRight, ValueType& aval,   \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<2> const& begin,    \
+                                      OpenACCMDRangeEnd<2> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(2) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i0 = begin0; i0 < end0; ++i0) {                                 \
+      for (auto i1 = begin1; i1 < end1; ++i1) {                               \
+        functor(i0, i1, val);                                                 \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateLeft, ValueType& aval,    \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<3> const& begin,    \
+                                      OpenACCMDRangeEnd<3> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    /* clang-format off */                                                  \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(3) reduction( \
+        OPERATOR                                                            \
+        : val) copyin(functor) async(async_arg)) \
+    /* clang-format on */                                                     \
+    for (auto i2 = begin2; i2 < end2; ++i2) {                                 \
+      for (auto i1 = begin1; i1 < end1; ++i1) {                               \
+        for (auto i0 = begin0; i0 < end0; ++i0) {                             \
+          functor(i0, i1, i2, val);                                           \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateRight, ValueType& aval,   \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<3> const& begin,    \
+                                      OpenACCMDRangeEnd<3> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    /* clang-format off */                                                  \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(3) reduction( \
+        OPERATOR                                                            \
+        : val) copyin(functor) async(async_arg)) \
+    /* clang-format on */                                                     \
+    for (auto i0 = begin0; i0 < end0; ++i0) {                                 \
+      for (auto i1 = begin1; i1 < end1; ++i1) {                               \
+        for (auto i2 = begin2; i2 < end2; ++i2) {                             \
+          functor(i0, i1, i2, val);                                           \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateLeft, ValueType& aval,    \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<4> const& begin,    \
+                                      OpenACCMDRangeEnd<4> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin3 = begin[3];                                                    \
+    int end3   = end[3];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(4) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i3 = begin3; i3 < end3; ++i3) {                                 \
+      for (auto i2 = begin2; i2 < end2; ++i2) {                               \
+        for (auto i1 = begin1; i1 < end1; ++i1) {                             \
+          for (auto i0 = begin0; i0 < end0; ++i0) {                           \
+            functor(i0, i1, i2, i3, val);                                     \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateRight, ValueType& aval,   \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<4> const& begin,    \
+                                      OpenACCMDRangeEnd<4> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin3 = begin[3];                                                    \
+    int end3   = end[3];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(4) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i0 = begin0; i0 < end0; ++i0) {                                 \
+      for (auto i1 = begin1; i1 < end1; ++i1) {                               \
+        for (auto i2 = begin2; i2 < end2; ++i2) {                             \
+          for (auto i3 = begin3; i3 < end3; ++i3) {                           \
+            functor(i0, i1, i2, i3, val);                                     \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateLeft, ValueType& aval,    \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<5> const& begin,    \
+                                      OpenACCMDRangeEnd<5> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin4 = begin[4];                                                    \
+    int end4   = end[4];                                                      \
+    int begin3 = begin[3];                                                    \
+    int end3   = end[3];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(5) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i4 = begin4; i4 < end4; ++i4) {                                 \
+      for (auto i3 = begin3; i3 < end3; ++i3) {                               \
+        for (auto i2 = begin2; i2 < end2; ++i2) {                             \
+          for (auto i1 = begin1; i1 < end1; ++i1) {                           \
+            for (auto i0 = begin0; i0 < end0; ++i0) {                         \
+              functor(i0, i1, i2, i3, i4, val);                               \
+            }                                                                 \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateRight, ValueType& aval,   \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<5> const& begin,    \
+                                      OpenACCMDRangeEnd<5> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin3 = begin[3];                                                    \
+    int end3   = end[3];                                                      \
+    int begin4 = begin[4];                                                    \
+    int end4   = end[4];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(5) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i0 = begin0; i0 < end0; ++i0) {                                 \
+      for (auto i1 = begin1; i1 < end1; ++i1) {                               \
+        for (auto i2 = begin2; i2 < end2; ++i2) {                             \
+          for (auto i3 = begin3; i3 < end3; ++i3) {                           \
+            for (auto i4 = begin4; i4 < end4; ++i4) {                         \
+              functor(i0, i1, i2, i3, i4, val);                               \
+            }                                                                 \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateLeft, ValueType& aval,    \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<6> const& begin,    \
+                                      OpenACCMDRangeEnd<6> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin5 = begin[5];                                                    \
+    int end5   = end[5];                                                      \
+    int begin4 = begin[4];                                                    \
+    int end4   = end[4];                                                      \
+    int begin3 = begin[3];                                                    \
+    int end3   = end[3];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(6) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i5 = begin5; i5 < end5; ++i5) {                                 \
+      for (auto i4 = begin4; i4 < end4; ++i4) {                               \
+        for (auto i3 = begin3; i3 < end3; ++i3) {                             \
+          for (auto i2 = begin2; i2 < end2; ++i2) {                           \
+            for (auto i1 = begin1; i1 < end1; ++i1) {                         \
+              for (auto i0 = begin0; i0 < end0; ++i0) {                       \
+                functor(i0, i1, i2, i3, i4, i5, val);                         \
+              }                                                               \
+            }                                                                 \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+                                                                              \
+  template <class ValueType, class Functor>                                   \
+  void OpenACCParallelReduce##REDUCER(OpenACCIterateRight, ValueType& aval,   \
+                                      Functor const& afunctor,                \
+                                      OpenACCMDRangeBegin<6> const& begin,    \
+                                      OpenACCMDRangeEnd<6> const& end,        \
+                                      int async_arg) {                        \
+    auto val = aval;                                                          \
+    auto const functor(afunctor);                                             \
+    int begin0 = begin[0];                                                    \
+    int end0   = end[0];                                                      \
+    int begin1 = begin[1];                                                    \
+    int end1   = end[1];                                                      \
+    int begin2 = begin[2];                                                    \
+    int end2   = end[2];                                                      \
+    int begin3 = begin[3];                                                    \
+    int end3   = end[3];                                                      \
+    int begin4 = begin[4];                                                    \
+    int end4   = end[4];                                                      \
+    int begin5 = begin[5];                                                    \
+    int end5   = end[5];                                                      \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector collapse(6) reduction(OPERATOR:val) copyin(functor) async(async_arg))                                                  \
+    /* clang-format on */                                                     \
+    for (auto i0 = begin0; i0 < end0; ++i0) {                                 \
+      for (auto i1 = begin1; i1 < end1; ++i1) {                               \
+        for (auto i2 = begin2; i2 < end2; ++i2) {                             \
+          for (auto i3 = begin3; i3 < end3; ++i3) {                           \
+            for (auto i4 = begin4; i4 < end4; ++i4) {                         \
+              for (auto i5 = begin5; i5 < end5; ++i5) {                       \
+                functor(i0, i1, i2, i3, i4, i5, val);                         \
+              }                                                               \
+            }                                                                 \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    aval = val;                                                               \
+  }                                                                           \
+  }  // namespace Kokkos::Experimental::Impl
+
+#define KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(REDUCER, OPERATOR) \
+  KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_DISPATCH_ITERATE(REDUCER, OPERATOR)     \
+  template <class Functor, class Scalar, class Space, class... Traits>        \
+  struct Kokkos::Experimental::Impl::OpenACCParallelReduceMDRangeHelper<      \
+      Functor, Kokkos::REDUCER<Scalar, Space>,                                \
+      Kokkos::MDRangePolicy<Traits...>, true> {                               \
+    using Policy    = MDRangePolicy<Traits...>;                               \
+    using Reducer   = REDUCER<Scalar, Space>;                                 \
+    using ValueType = typename Reducer::value_type;                           \
+                                                                              \
+    OpenACCParallelReduceMDRangeHelper(Functor const& functor,                \
+                                       Reducer const& reducer,                \
+                                       Policy const& policy) {                \
+      ValueType val;                                                          \
+      reducer.init(val);                                                      \
+                                                                              \
+      int const async_arg = policy.space().acc_async_queue();                 \
+                                                                              \
+      OpenACCParallelReduce##REDUCER(                                         \
+          std::integral_constant<Iterate, Policy::inner_direction>(), val,    \
+          functor, policy.m_lower, policy.m_upper, async_arg);                \
+                                                                              \
+      reducer.reference() = val;                                              \
+    }                                                                         \
+  }
+
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(Sum, +);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(Prod, *);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(Min, min);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(Max, max);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(LAnd, &&);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(LOr, ||);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(BAnd, &);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER(BOr, |);
+
+#undef KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_MDRANGE_HELPER
+#undef KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_DISPATCH_ITERATE
+
+#endif
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp
index 278d9c1d5a..b61a05a8ee 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp
@@ -38,62 +38,76 @@ struct OpenACCParallelReduceHelper {
 
 }  // namespace Kokkos::Experimental::Impl
 
-template <class Functor, class ReducerType, class... Traits>
-class Kokkos::Impl::ParallelReduce<Functor, Kokkos::RangePolicy<Traits...>,
-                                   ReducerType, Kokkos::Experimental::OpenACC> {
-  using Policy = RangePolicy<Traits...>;
-
-  using ReducerConditional =
-      if_c<std::is_same_v<InvalidType, ReducerType>, Functor, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-
-  using Pointer   = typename Analysis::pointer_type;
-  using ValueType = typename Analysis::value_type;
-
-  Functor m_functor;
+template <class CombinedFunctorReducerType, class... Traits>
+class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
+                                   Kokkos::RangePolicy<Traits...>,
+                                   Kokkos::Experimental::OpenACC> {
+  using Policy      = RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using Pointer   = typename ReducerType::pointer_type;
+  using ValueType = typename ReducerType::value_type;
+
+  CombinedFunctorReducerType m_functor_reducer;
   Policy m_policy;
-  ReducerType m_reducer;
   Pointer m_result_ptr;
+  bool m_result_ptr_on_device;
 
  public:
-  ParallelReduce(Functor const& functor, Policy const& policy,
-                 ReducerType const& reducer)
-      : m_functor(functor),
-        m_policy(policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {}
-
   template <class ViewType>
-  ParallelReduce(
-      const Functor& functor, const Policy& policy, const ViewType& result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(functor),
+  ParallelReduce(CombinedFunctorReducerType const& functor_reducer,
+                 Policy const& policy, ViewType const& result)
+      : m_functor_reducer(functor_reducer),
         m_policy(policy),
-        m_reducer(InvalidType()),
-        m_result_ptr(result.data()) {}
+        m_result_ptr(result.data()),
+        m_result_ptr_on_device(
+            MemorySpaceAccess<Kokkos::Experimental::OpenACCSpace,
+                              typename ViewType::memory_space>::accessible) {}
 
   void execute() const {
     auto const begin = m_policy.begin();
     auto const end   = m_policy.end();
 
+    ValueType val;
+    ReducerType const& reducer = m_functor_reducer.get_reducer();
+    reducer.init(&val);
+
     if (end <= begin) {
+      if (m_result_ptr_on_device == false) {
+        *m_result_ptr = val;
+      } else {
+        acc_memcpy_to_device(m_result_ptr, &val, sizeof(ValueType));
+      }
       return;
     }
 
-    ValueType val;
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-    final_reducer.init(&val);
+    int const async_arg = m_policy.space().acc_async_queue();
 
     Kokkos::Experimental::Impl::OpenACCParallelReduceHelper(
-        Kokkos::Experimental::Impl::FunctorAdapter<Functor, Policy>(m_functor),
-        std::conditional_t<is_reducer_v<ReducerType>, ReducerType,
-                           Sum<ValueType>>(val),
+        Kokkos::Experimental::Impl::FunctorAdapter<
+            FunctorType, Policy,
+            Kokkos::Experimental::Impl::RoutineClause::seq>(
+            m_functor_reducer.get_functor()),
+        std::conditional_t<
+            std::is_same_v<FunctorType, typename ReducerType::functor_type>,
+            Sum<ValueType>, typename ReducerType::functor_type>(val),
         m_policy);
 
-    *m_result_ptr = val;
+    // OpenACC backend supports only built-in Reducer types; thus
+    // reducer.final() below is a no-op.
+    reducer.final(&val);
+    // acc_wait(async_arg) in the below if-else statements is needed because the
+    // above OpenACC compute kernel can be executed asynchronously and val is a
+    // local host variable.
+    if (m_result_ptr_on_device == false) {
+      acc_wait(async_arg);
+      *m_result_ptr = val;
+    } else {
+      acc_memcpy_to_device_async(m_result_ptr, &val, sizeof(ValueType),
+                                 async_arg);
+      acc_wait(async_arg);
+    }
   }
 };
 
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp
new file mode 100644
index 0000000000..3223ce3f9a
--- /dev/null
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp
@@ -0,0 +1,449 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENACC_PARALLEL_REDUCE_TEAM_HPP
+#define KOKKOS_OPENACC_PARALLEL_REDUCE_TEAM_HPP
+
+#include <OpenACC/Kokkos_OpenACC_Team.hpp>
+#include <OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp>
+#include <OpenACC/Kokkos_OpenACC_Macros.hpp>
+
+#ifdef KOKKOS_ENABLE_OPENACC_COLLAPSE_HIERARCHICAL_CONSTRUCTS
+#define KOKKOS_IMPL_OPENACC_LOOP_CLAUSE \
+  Kokkos::Experimental::Impl::RoutineClause::seq
+#else
+#define KOKKOS_IMPL_OPENACC_LOOP_CLAUSE \
+  Kokkos::Experimental::Impl::RoutineClause::worker
+#endif
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+// Hierarchical Parallelism -> Team level implementation
+namespace Kokkos::Experimental::Impl {
+
+// primary template: catch-all non-implemented custom reducers
+template <class Functor, class Reducer, class Policy,
+          bool = std::is_arithmetic_v<typename Reducer::value_type>>
+struct OpenACCParallelReduceTeamHelper {
+  OpenACCParallelReduceTeamHelper(Functor const&, Reducer const&,
+                                  Policy const&) {
+    static_assert(!Kokkos::Impl::always_true<Functor>::value,
+                  "not implemented");
+  }
+};
+
+}  // namespace Kokkos::Experimental::Impl
+
+template <class CombinedFunctorReducerType, class... Properties>
+class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
+                                   Kokkos::TeamPolicy<Properties...>,
+                                   Kokkos::Experimental::OpenACC> {
+ private:
+  using Policy =
+      TeamPolicyInternal<Kokkos::Experimental::OpenACC, Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using value_type   = typename ReducerType::value_type;
+  using pointer_type = typename ReducerType::pointer_type;
+
+  CombinedFunctorReducerType m_functor_reducer;
+  Policy m_policy;
+  pointer_type m_result_ptr;
+  bool m_result_ptr_on_device;
+
+ public:
+  void execute() const {
+    auto league_size   = m_policy.league_size();
+    auto team_size     = m_policy.team_size();
+    auto vector_length = m_policy.impl_vector_length();
+
+    int const async_arg = m_policy.space().acc_async_queue();
+    value_type val;
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+    reducer.init(&val);
+    if (league_size <= 0) {
+      if (m_result_ptr_on_device == false) {
+        *m_result_ptr = val;
+      } else {
+        acc_memcpy_to_device(m_result_ptr, &val, sizeof(value_type));
+      }
+      return;
+    }
+
+    Kokkos::Experimental::Impl::OpenACCParallelReduceTeamHelper(
+        Kokkos::Experimental::Impl::FunctorAdapter<
+            FunctorType, Policy, KOKKOS_IMPL_OPENACC_LOOP_CLAUSE>(
+            m_functor_reducer.get_functor()),
+        std::conditional_t<
+            std::is_same_v<FunctorType, typename ReducerType::functor_type>,
+            Sum<value_type>, typename ReducerType::functor_type>(val),
+        m_policy);
+
+    // OpenACC backend supports only built-in Reducer types; thus
+    // reducer.final() below is a no-op.
+    reducer.final(&val);
+    // acc_wait(async_arg) in the below if-else statements is needed because the
+    // above OpenACC compute kernel can be executed asynchronously and val is a
+    // local host variable.
+    if (m_result_ptr_on_device == false) {
+      acc_wait(async_arg);
+      *m_result_ptr = val;
+    } else {
+      acc_memcpy_to_device_async(m_result_ptr, &val, sizeof(value_type),
+                                 async_arg);
+      acc_wait(async_arg);
+    }
+  }
+
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result_view)
+      : m_functor_reducer(arg_functor_reducer),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result_view.data()),
+        m_result_ptr_on_device(
+            MemorySpaceAccess<Kokkos::Experimental::OpenACCSpace,
+                              typename ViewType::memory_space>::accessible) {}
+};
+
+namespace Kokkos {
+
+// Hierarchical Parallelism -> Team thread level implementation
+// FIXME_OPENACC: custom reduction is not implemented.
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::OpenACCTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
+  static_assert(!Kokkos::Impl::always_true<Lambda>::value,
+                "custom reduction is not implemented");
+}
+
+// Hierarchical Parallelism -> Thread vector level implementation
+// FIXME_OPENACC: custom reduction is not implemented.
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenACCTeamMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
+  static_assert(!Kokkos::Impl::always_true<Lambda>::value,
+                "custom reduction is not implemented");
+}
+
+}  // namespace Kokkos
+
+#ifdef KOKKOS_ENABLE_OPENACC_COLLAPSE_HIERARCHICAL_CONSTRUCTS
+
+#define KOKKOS_IMPL_ACC_REDUCE_TEAM_PRAGMA \
+  vector vector_length(team_size* vector_length)
+#define KOKKOS_IMPL_ACC_REDUCE_TEAM_ITRS league_size* team_size* vector_length
+#define KOKKOS_IMPL_ACC_REDUCE_TEAM_LEAGUE_ID_INIT \
+  i / (team_size * vector_length)
+
+namespace Kokkos {
+
+// Hierarchical Parallelism -> Team thread level implementation
+#pragma acc routine seq
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<!Kokkos::is_reducer_v<ValueType>>
+parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                    iType, Impl::OpenACCTeamMember>& loop_boundaries,
+                const Lambda& lambda, ValueType& result) {
+  ValueType tmp = ValueType();
+  iType j_start =
+      loop_boundaries.team.team_rank() / loop_boundaries.team.vector_length();
+  if (j_start == 0) {
+#pragma acc loop seq
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++)
+      lambda(i, tmp);
+    result = tmp;
+  }
+}
+
+#pragma acc routine seq
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer_v<ReducerType>>
+parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                    iType, Impl::OpenACCTeamMember>& loop_boundaries,
+                const Lambda& lambda, const ReducerType& reducer) {
+  using ValueType = typename ReducerType::value_type;
+  ValueType tmp;
+  reducer.init(tmp);
+  iType j_start =
+      loop_boundaries.team.team_rank() / loop_boundaries.team.vector_length();
+  if (j_start == 0) {
+#pragma acc loop seq
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++)
+      lambda(i, tmp);
+    reducer.reference() = tmp;
+  }
+}
+
+// Hierarchical Parallelism -> Thread vector level implementation
+#pragma acc routine seq
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<!Kokkos::is_reducer_v<ValueType>>
+parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                    iType, Impl::OpenACCTeamMember>& loop_boundaries,
+                const Lambda& lambda, ValueType& result) {
+  ValueType tmp = ValueType();
+  iType j_start =
+      loop_boundaries.team.team_rank() % loop_boundaries.team.vector_length();
+  if (j_start == 0) {
+#pragma acc loop seq
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      lambda(i, tmp);
+    }
+    result = tmp;
+  }
+}
+
+#pragma acc routine seq
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer_v<ReducerType>>
+parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                    iType, Impl::OpenACCTeamMember>& loop_boundaries,
+                const Lambda& lambda, const ReducerType& reducer) {
+  using ValueType = typename ReducerType::value_type;
+  ValueType tmp;
+  reducer.init(tmp);
+  iType j_start =
+      loop_boundaries.team.team_rank() % loop_boundaries.team.vector_length();
+  if (j_start == 0) {
+#pragma acc loop seq
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      lambda(i, tmp);
+    }
+    reducer.reference() = tmp;
+  }
+}
+
+// Hierarchical Parallelism -> Team vector level implementation
+#pragma acc routine seq
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamVectorRangeBoundariesStruct<iType, Impl::OpenACCTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
+  ValueType tmp = ValueType();
+  iType j_start =
+      loop_boundaries.team.team_rank() % loop_boundaries.team.vector_length();
+  if (j_start == 0) {
+#pragma acc loop seq
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      lambda(i, tmp);
+    }
+    result = tmp;
+  }
+}
+
+}  // namespace Kokkos
+
+#else /* #ifdef KOKKOS_ENABLE_OPENACC_COLLAPSE_HIERARCHICAL_CONSTRUCTS */
+
+#define KOKKOS_IMPL_ACC_REDUCE_TEAM_PRAGMA \
+  num_workers(team_size) vector_length(vector_length)
+#define KOKKOS_IMPL_ACC_REDUCE_TEAM_ITRS league_size
+#define KOKKOS_IMPL_ACC_REDUCE_TEAM_LEAGUE_ID_INIT i
+
+// FIXME_OPENACC: below implementation conforms to the OpenACC standard, but
+// the NVHPC compiler (V22.11) fails due to the lack of support for lambda
+// expressions containing parallel loops.
+
+namespace Kokkos {
+
+// Hierarchical Parallelism -> Team thread level implementation
+#pragma acc routine worker
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<!Kokkos::is_reducer_v<ValueType>>
+parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                    iType, Impl::OpenACCTeamMember>& loop_boundaries,
+                const Lambda& lambda, ValueType& result) {
+  ValueType tmp = ValueType();
+#pragma acc loop worker reduction(+ : tmp)
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++)
+    lambda(i, tmp);
+  result = tmp;
+}
+
+#define KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(REDUCER, OPERATOR)   \
+  KOKKOS_IMPL_ACC_PRAGMA(routine worker)                                     \
+  template <typename iType, class Lambda, class Scalar, class Space>         \
+  KOKKOS_INLINE_FUNCTION                                                     \
+      std::enable_if_t<Kokkos::is_reducer_v<Kokkos::REDUCER<Scalar, Space>>> \
+      parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<           \
+                          iType, Impl::OpenACCTeamMember>& loop_boundaries,  \
+                      const Lambda& lambda,                                  \
+                      const Kokkos::REDUCER<Scalar, Space>& reducer) {       \
+    using ValueType = typename Kokkos::REDUCER<Scalar, Space>::value_type;   \
+    ValueType tmp   = ValueType();                                           \
+    reducer.init(tmp);                                                       \
+    KOKKOS_IMPL_ACC_PRAGMA(loop worker reduction(OPERATOR : tmp))            \
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++)      \
+      lambda(i, tmp);                                                        \
+    reducer.reference() = tmp;                                               \
+  }
+
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(Sum, +);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(Prod, *);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(Min, min);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(Max, max);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(LAnd, &&);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(LOr, ||);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(BAnd, &);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD(BOr, |);
+
+// Hierarchical Parallelism -> Thread vector level implementation
+#pragma acc routine vector
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<!Kokkos::is_reducer_v<ValueType>>
+parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                    iType, Impl::OpenACCTeamMember>& loop_boundaries,
+                const Lambda& lambda, ValueType& result) {
+  ValueType tmp = ValueType();
+#pragma acc loop vector reduction(+ : tmp)
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    lambda(i, tmp);
+  }
+  result = tmp;
+}
+
+#define KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(REDUCER, OPERATOR) \
+  KOKKOS_IMPL_ACC_PRAGMA(routine vector)                                     \
+  template <typename iType, class Lambda, class Scalar, class Space>         \
+  KOKKOS_INLINE_FUNCTION                                                     \
+      std::enable_if_t<Kokkos::is_reducer_v<Kokkos::REDUCER<Scalar, Space>>> \
+      parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<         \
+                          iType, Impl::OpenACCTeamMember>& loop_boundaries,  \
+                      const Lambda& lambda,                                  \
+                      const Kokkos::REDUCER<Scalar, Space>& reducer) {       \
+    using ValueType = typename Kokkos::REDUCER<Scalar, Space>::value_type;   \
+    ValueType tmp;                                                           \
+    reducer.init(tmp);                                                       \
+    KOKKOS_IMPL_ACC_PRAGMA(loop vector reduction(OPERATOR : tmp))            \
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {    \
+      lambda(i, tmp);                                                        \
+    }                                                                        \
+    reducer.reference() = tmp;                                               \
+  }
+
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(Sum, +);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(Prod, *);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(Min, min);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(Max, max);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(LAnd, &&);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(LOr, ||);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(BAnd, &);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR(BOr, |);
+
+// Hierarchical Parallelism -> Team vector level implementation
+#pragma acc routine vector
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamVectorRangeBoundariesStruct<iType, Impl::OpenACCTeamMember>&
+        loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
+  ValueType tmp = ValueType();
+#pragma acc loop vector reduction(+ : tmp)
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    lambda(i, tmp);
+  }
+  result = tmp;
+}
+
+}  // namespace Kokkos
+
+#undef KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_THREAD
+#undef KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_THREAD_VECTOR
+
+#endif /* #ifdef KOKKOS_ENABLE_OPENACC_COLLAPSE_HIERARCHICAL_CONSTRUCTS */
+
+#define KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_DISPATCH_SCHEDULE(REDUCER,     \
+                                                              OPERATOR)    \
+  namespace Kokkos::Experimental::Impl {                                   \
+  template <class Policy, class ValueType, class Functor>                  \
+  void OpenACCParallelReduceTeam##REDUCER(Policy const policy,             \
+                                          ValueType& aval,                 \
+                                          Functor const& afunctor,         \
+                                          int async_arg) {                 \
+    auto const functor       = afunctor;                                   \
+    auto val                 = aval;                                       \
+    auto const league_size   = policy.league_size();                       \
+    auto const team_size     = policy.team_size();                         \
+    auto const vector_length = policy.impl_vector_length();                \
+    /* clang-format off */ \
+    KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang num_gangs(league_size) KOKKOS_IMPL_ACC_REDUCE_TEAM_PRAGMA reduction(OPERATOR : val) copyin(functor) async(async_arg))                                               \
+    /* clang-format on */                                                  \
+    for (int i = 0; i < KOKKOS_IMPL_ACC_REDUCE_TEAM_ITRS; i++) {           \
+      int league_id = KOKKOS_IMPL_ACC_REDUCE_TEAM_LEAGUE_ID_INIT;          \
+      typename Policy::member_type team(league_id, league_size, team_size, \
+                                        vector_length);                    \
+      functor(team, val);                                                  \
+    }                                                                      \
+    aval = val;                                                            \
+  }                                                                        \
+  }  // namespace Kokkos::Experimental::Impl
+
+#define KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(REDUCER, OPERATOR) \
+  KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_DISPATCH_SCHEDULE(REDUCER, OPERATOR) \
+                                                                           \
+  template <class Functor, class Scalar, class Space, class... Traits>     \
+  struct Kokkos::Experimental::Impl::OpenACCParallelReduceTeamHelper<      \
+      Functor, Kokkos::REDUCER<Scalar, Space>,                             \
+      Kokkos::Impl::TeamPolicyInternal<Traits...>, true> {                 \
+    using Policy    = Kokkos::Impl::TeamPolicyInternal<Traits...>;         \
+    using Reducer   = REDUCER<Scalar, Space>;                              \
+    using ValueType = typename Reducer::value_type;                        \
+                                                                           \
+    OpenACCParallelReduceTeamHelper(Functor const& functor,                \
+                                    Reducer const& reducer,                \
+                                    Policy const& policy) {                \
+      auto league_size   = policy.league_size();                           \
+      auto team_size     = policy.team_size();                             \
+      auto vector_length = policy.impl_vector_length();                    \
+                                                                           \
+      if (league_size <= 0) {                                              \
+        return;                                                            \
+      }                                                                    \
+                                                                           \
+      ValueType val;                                                       \
+      reducer.init(val);                                                   \
+                                                                           \
+      int const async_arg = policy.space().acc_async_queue();              \
+                                                                           \
+      OpenACCParallelReduceTeam##REDUCER(policy, val, functor, async_arg); \
+                                                                           \
+      reducer.reference() = val;                                           \
+    }                                                                      \
+  }
+
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(Sum, +);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(Prod, *);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(Min, min);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(Max, max);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(LAnd, &&);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(LOr, ||);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(BAnd, &);
+KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER(BOr, |);
+
+#undef KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_TEAM_HELPER
+#undef KOKKOS_IMPL_OPENACC_PARALLEL_REDUCE_DISPATCH_SCHEDULE
+#undef KOKKOS_IMPL_ACC_REDUCE_TEAM_PRAGMA
+#undef KOKKOS_IMPL_ACC_REDUCE_TEAM_ITRS
+#undef KOKKOS_IMPL_ACC_REDUCE_TEAM_LEAGUE_ID_INIT
+
+#endif /* #ifndef KOKKOS_OPENACC_PARALLEL_REDUCE_TEAM_HPP */
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp
new file mode 100644
index 0000000000..00b0a5d25c
--- /dev/null
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp
@@ -0,0 +1,288 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENACC_PARALLEL_SCAN_RANGE_HPP
+#define KOKKOS_OPENACC_PARALLEL_SCAN_RANGE_HPP
+
+#include <OpenACC/Kokkos_OpenACC.hpp>
+#include <OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp>
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos::Impl {
+
+template <class Functor, class GivenValueType, class... Traits>
+class ParallelScanOpenACCBase {
+ protected:
+  using Policy = Kokkos::RangePolicy<Traits...>;
+  using Analysis =
+      Kokkos::Impl::FunctorAnalysis<Kokkos::Impl::FunctorPatternInterface::SCAN,
+                                    Policy, Functor, GivenValueType>;
+  using PointerType = typename Analysis::pointer_type;
+  using ValueType   = typename Analysis::value_type;
+  using MemberType  = typename Policy::member_type;
+  using IndexType   = typename Policy::index_type;
+  Functor m_functor;
+  Policy m_policy;
+  ValueType* m_result_ptr;
+  bool m_result_ptr_device_accessible;
+  static constexpr MemberType default_scan_chunk_size = 128;
+
+ public:
+  ParallelScanOpenACCBase(Functor const& arg_functor, Policy const& arg_policy,
+                          ValueType* arg_result_ptr,
+                          bool arg_result_ptr_device_accessible)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result_ptr),
+        m_result_ptr_device_accessible(arg_result_ptr_device_accessible) {}
+
+  // This function implements the parallel scan alogithm based on the parallel
+  // prefix sum algorithm proposed by Hillis and Steele (doi:10.1145/7902.7903),
+  // which offers a shorter span and more parallelism but may not be
+  // work-efficient.
+  void OpenACCParallelScanRangePolicy(const IndexType begin,
+                                      const IndexType end, IndexType chunk_size,
+                                      const int async_arg) const {
+    if (chunk_size > 1) {
+      if (!Impl::is_integral_power_of_two(chunk_size))
+        Kokkos::abort(
+            "RangePolicy blocking granularity must be power of two to be used "
+            "with OpenACC parallel_scan()");
+    } else {
+      chunk_size = default_scan_chunk_size;
+    }
+    const Kokkos::Experimental::Impl::FunctorAdapter<
+        Functor, Policy, Kokkos::Experimental::Impl::RoutineClause::seq>
+        functor(m_functor);
+    const IndexType N        = end - begin;
+    const IndexType n_chunks = (N + chunk_size - 1) / chunk_size;
+    Kokkos::View<ValueType*, Kokkos::Experimental::OpenACCSpace> chunk_values(
+        "Kokkos::OpenACCParallelScan::chunk_values", n_chunks);
+    Kokkos::View<ValueType*, Kokkos::Experimental::OpenACCSpace> offset_values(
+        "Kokkos::OpenACCParallelScan::offset_values", n_chunks);
+    Kokkos::View<ValueType, Kokkos::Experimental::OpenACCSpace> m_result_total(
+        "Kokkos::OpenACCParallelScan::m_result_total");
+    std::unique_ptr<ValueType[]> element_values_owner(
+        new ValueType[2 * chunk_size]);
+    ValueType* element_values = element_values_owner.get();
+    typename Analysis::Reducer final_reducer(m_functor);
+
+#pragma acc enter data copyin(functor, final_reducer) \
+    copyin(chunk_values, offset_values) async(async_arg)
+
+#pragma acc parallel loop gang vector_length(chunk_size) private( \
+    element_values [0:2 * chunk_size])                            \
+    present(functor, chunk_values, final_reducer) async(async_arg)
+    for (IndexType team_id = 0; team_id < n_chunks; ++team_id) {
+      IndexType current_step = 0;
+      IndexType next_step    = 1;
+      IndexType temp;
+#pragma acc loop vector
+      for (IndexType thread_id = 0; thread_id < chunk_size; ++thread_id) {
+        const IndexType local_offset = team_id * chunk_size;
+        const IndexType idx          = local_offset + thread_id;
+        ValueType update;
+        final_reducer.init(&update);
+        if ((idx > 0) && (idx < N)) functor(idx - 1, update, false);
+        element_values[thread_id] = update;
+      }
+      for (IndexType step_size = 1; step_size < chunk_size; step_size *= 2) {
+#pragma acc loop vector
+        for (IndexType thread_id = 0; thread_id < chunk_size; ++thread_id) {
+          if (thread_id < step_size) {
+            element_values[next_step * chunk_size + thread_id] =
+                element_values[current_step * chunk_size + thread_id];
+          } else {
+            ValueType localValue =
+                element_values[current_step * chunk_size + thread_id];
+            final_reducer.join(&localValue,
+                               &element_values[current_step * chunk_size +
+                                               thread_id - step_size]);
+            element_values[next_step * chunk_size + thread_id] = localValue;
+          }
+        }
+        temp         = current_step;
+        current_step = next_step;
+        next_step    = temp;
+      }
+      chunk_values(team_id) =
+          element_values[current_step * chunk_size + chunk_size - 1];
+    }
+
+    ValueType tempValue;
+#pragma acc serial loop present(chunk_values, offset_values, final_reducer) \
+    async(async_arg)
+    for (IndexType team_id = 0; team_id < n_chunks; ++team_id) {
+      if (team_id == 0) {
+        final_reducer.init(&offset_values(0));
+        final_reducer.init(&tempValue);
+      } else {
+        final_reducer.join(&tempValue, &chunk_values(team_id - 1));
+        offset_values(team_id) = tempValue;
+      }
+    }
+
+#pragma acc parallel loop gang vector_length(chunk_size) private(         \
+    element_values [0:2 * chunk_size])                                    \
+    present(functor, offset_values, final_reducer) copyin(m_result_total) \
+        async(async_arg)
+    for (IndexType team_id = 0; team_id < n_chunks; ++team_id) {
+      IndexType current_step = 0;
+      IndexType next_step    = 1;
+      IndexType temp;
+#pragma acc loop vector
+      for (IndexType thread_id = 0; thread_id < chunk_size; ++thread_id) {
+        const IndexType local_offset = team_id * chunk_size;
+        const IndexType idx          = local_offset + thread_id;
+        ValueType update;
+        final_reducer.init(&update);
+        if (thread_id == 0) {
+          final_reducer.join(&update, &offset_values(team_id));
+        }
+        if ((idx > 0) && (idx < N)) functor(idx - 1, update, false);
+        element_values[thread_id] = update;
+      }
+      for (IndexType step_size = 1; step_size < chunk_size; step_size *= 2) {
+#pragma acc loop vector
+        for (IndexType thread_id = 0; thread_id < chunk_size; ++thread_id) {
+          if (thread_id < step_size) {
+            element_values[next_step * chunk_size + thread_id] =
+                element_values[current_step * chunk_size + thread_id];
+          } else {
+            ValueType localValue =
+                element_values[current_step * chunk_size + thread_id];
+            final_reducer.join(&localValue,
+                               &element_values[current_step * chunk_size +
+                                               thread_id - step_size]);
+            element_values[next_step * chunk_size + thread_id] = localValue;
+          }
+        }
+        temp         = current_step;
+        current_step = next_step;
+        next_step    = temp;
+      }
+#pragma acc loop vector
+      for (IndexType thread_id = 0; thread_id < chunk_size; ++thread_id) {
+        const IndexType local_offset = team_id * chunk_size;
+        const IndexType idx          = local_offset + thread_id;
+        ValueType update =
+            element_values[current_step * chunk_size + thread_id];
+        if (idx < N) functor(idx, update, true);
+        if (idx == N - 1) {
+          if (m_result_ptr_device_accessible) {
+            *m_result_ptr = update;
+          } else {
+            m_result_total() = update;
+          }
+        }
+      }
+    }
+    if (!m_result_ptr_device_accessible && m_result_ptr != nullptr) {
+      DeepCopy<HostSpace, Kokkos::Experimental::OpenACCSpace,
+               Kokkos::Experimental::OpenACC>(m_policy.space(), m_result_ptr,
+                                              m_result_total.data(),
+                                              sizeof(ValueType));
+    }
+
+#pragma acc exit data delete (functor, chunk_values, offset_values, \
+                              final_reducer)async(async_arg)
+    acc_wait(async_arg);
+  }
+
+  void execute() const {
+    const IndexType begin = m_policy.begin();
+    const IndexType end   = m_policy.end();
+    IndexType chunk_size  = m_policy.chunk_size();
+
+    if (end <= begin) {
+      if (!m_result_ptr_device_accessible && m_result_ptr != nullptr) {
+        *m_result_ptr = 0;
+      }
+      return;
+    }
+
+    int const async_arg = m_policy.space().acc_async_queue();
+
+    OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
+  }
+};
+
+}  // namespace Kokkos::Impl
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+template <class Functor, class... Traits>
+class Kokkos::Impl::ParallelScan<Functor, Kokkos::RangePolicy<Traits...>,
+                                 Kokkos::Experimental::OpenACC>
+    : public ParallelScanOpenACCBase<Functor, void, Traits...> {
+  using base_t    = ParallelScanOpenACCBase<Functor, void, Traits...>;
+  using IndexType = typename base_t::IndexType;
+
+ public:
+  void execute() const {
+    const IndexType begin = base_t::m_policy.begin();
+    const IndexType end   = base_t::m_policy.end();
+    IndexType chunk_size  = base_t::m_policy.chunk_size();
+
+    int const async_arg = base_t::m_policy.space().acc_async_queue();
+
+    OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
+  }
+
+  ParallelScan(const Functor& arg_functor,
+               const typename base_t::Policy& arg_policy)
+      : base_t(arg_functor, arg_policy, nullptr, false) {}
+};
+
+template <class FunctorType, class ReturnType, class... Traits>
+class Kokkos::Impl::ParallelScanWithTotal<
+    FunctorType, Kokkos::RangePolicy<Traits...>, ReturnType,
+    Kokkos::Experimental::OpenACC>
+    : public ParallelScanOpenACCBase<FunctorType, ReturnType, Traits...> {
+  using base_t    = ParallelScanOpenACCBase<FunctorType, ReturnType, Traits...>;
+  using IndexType = typename base_t::IndexType;
+
+ public:
+  void execute() const {
+    const IndexType begin = base_t::m_policy.begin();
+    const IndexType end   = base_t::m_policy.end();
+    IndexType chunk_size  = base_t::m_policy.chunk_size();
+
+    if (end <= begin) {
+      if (!base_t::m_result_ptr_device_accessible &&
+          base_t::m_result_ptr != nullptr) {
+        *base_t::m_result_ptr = 0;
+      }
+      return;
+    }
+
+    int const async_arg = base_t::m_policy.space().acc_async_queue();
+
+    OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
+  }
+
+  template <class ViewType>
+  ParallelScanWithTotal(const FunctorType& arg_functor,
+                        const typename base_t::Policy& arg_policy,
+                        const ViewType& arg_result_view)
+      : base_t(arg_functor, arg_policy, arg_result_view.data(),
+               MemorySpaceAccess<Kokkos::Experimental::OpenACCSpace,
+                                 typename ViewType::memory_space>::accessible) {
+  }
+};
+
+#endif
diff --git a/core/src/OpenACC/Kokkos_OpenACC_Team.hpp b/core/src/OpenACC/Kokkos_OpenACC_Team.hpp
index 3a46f2c483..4ec71f56ef 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_Team.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_Team.hpp
@@ -82,7 +82,7 @@ class OpenACCTeamMember {
   // FIXME_OPENACC: team_broadcast() is not implemented.
   template <class ValueType>
   KOKKOS_FUNCTION void team_broadcast(ValueType& value, int thread_id) const {
-    static_assert(Kokkos::Impl::always_false<ValueType>::value,
+    static_assert(!Kokkos::Impl::always_true<ValueType>::value,
                   "Kokkos Error: team_broadcast() is not implemented for the "
                   "OpenACC backend");
     return ValueType();
@@ -99,7 +99,7 @@ class OpenACCTeamMember {
   template <class ValueType, class JoinOp>
   KOKKOS_FUNCTION ValueType team_reduce(const ValueType& value,
                                         const JoinOp& op_in) const {
-    static_assert(Kokkos::Impl::always_false<ValueType>::value,
+    static_assert(!Kokkos::Impl::always_true<ValueType>::value,
                   "Kokkos Error: team_reduce() is not implemented for the "
                   "OpenACC backend");
     return ValueType();
@@ -110,7 +110,7 @@ class OpenACCTeamMember {
   KOKKOS_FUNCTION ArgType team_scan(const ArgType& /*value*/,
                                     ArgType* const /*global_accum*/) const {
     static_assert(
-        Kokkos::Impl::always_false<ArgType>::value,
+        !Kokkos::Impl::always_true<ArgType>::value,
         "Kokkos Error: team_scan() is not implemented for the OpenACC backend");
     return ArgType();
   }
@@ -163,37 +163,37 @@ class TeamPolicyInternal<Kokkos::Experimental::OpenACC, Properties...>
   // implementations.
   template <class FunctorType>
   static int team_size_max(const FunctorType&, const ParallelForTag&) {
-    return DEFAULT_TEAM_SIZE_MAX;
+    return default_team_size_max;
   }
 
   template <class FunctorType>
   static int team_size_max(const FunctorType&, const ParallelReduceTag&) {
-    return DEFAULT_TEAM_SIZE_MAX;
+    return default_team_size_max;
   }
 
   template <class FunctorType, class ReducerType>
   static int team_size_max(const FunctorType&, const ReducerType&,
                            const ParallelReduceTag&) {
-    return DEFAULT_TEAM_SIZE_MAX;
+    return default_team_size_max;
   }
 
   // FIXME_OPENACC: update team_size_recommended() APIs with realistic
   // implementations.
   template <class FunctorType>
   static int team_size_recommended(const FunctorType&, const ParallelForTag&) {
-    return DEFAULT_TEAM_SIZE_REC;
+    return default_team_size;
   }
 
   template <class FunctorType>
   static int team_size_recommended(const FunctorType&,
                                    const ParallelReduceTag&) {
-    return DEFAULT_TEAM_SIZE_REC;
+    return default_team_size;
   }
 
   template <class FunctorType, class ReducerType>
   static int team_size_recommended(const FunctorType&, const ReducerType&,
                                    const ParallelReduceTag&) {
-    return DEFAULT_TEAM_SIZE_REC;
+    return default_team_size;
   }
 
   //----------------------------------------
@@ -208,7 +208,9 @@ class TeamPolicyInternal<Kokkos::Experimental::OpenACC, Properties...>
   std::array<size_t, 2> m_thread_scratch_size;
   bool m_tune_team_size;
   bool m_tune_vector_length;
-  constexpr static const size_t default_team_size =
+  constexpr static int default_team_size_max =
+      OpenACCTeamMember::DEFAULT_TEAM_SIZE_MAX;
+  constexpr static int default_team_size =
       OpenACCTeamMember::DEFAULT_TEAM_SIZE_REC;
   int m_chunk_size;
 
@@ -226,8 +228,8 @@ class TeamPolicyInternal<Kokkos::Experimental::OpenACC, Properties...>
  public:
   bool impl_auto_team_size() const { return m_tune_team_size; }
   bool impl_auto_vector_length() const { return m_tune_vector_length; }
-  void impl_set_team_size(const size_t size) { m_team_size = size; }
-  void impl_set_vector_length(const size_t length) {
+  void impl_set_team_size(const int size) { m_team_size = size; }
+  void impl_set_vector_length(const int length) {
     m_tune_vector_length = length;
   }
   int impl_vector_length() const { return m_vector_length; }
@@ -348,7 +350,7 @@ class TeamPolicyInternal<Kokkos::Experimental::OpenACC, Properties...>
         m_chunk_size(0) {
     init(league_size_request, team_size_request, 1);
   }
-  static size_t vector_length_max() {
+  static int vector_length_max() {
     return 32; /* TODO: this is bad. Need logic that is compiler and backend
                   aware */
   }
diff --git a/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp b/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp
index c8a6dfec6f..88140a7647 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp
@@ -22,8 +22,7 @@
 namespace Kokkos::Experimental::Impl {
 
 struct OpenACC_Traits {
-#if defined(KOKKOS_ARCH_PASCAL) || defined(KOKKOS_ARCH_VOLTA) || \
-    defined(KOKKOS_ARCH_AMPERE) || defined(KOKKOS_ARCH_HOPPER)
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
   static constexpr acc_device_t dev_type     = acc_device_nvidia;
   static constexpr bool may_fallback_to_host = false;
 #else
diff --git a/core/src/OpenMP/Kokkos_OpenMP.cpp b/core/src/OpenMP/Kokkos_OpenMP.cpp
new file mode 100644
index 0000000000..aa185a0bc0
--- /dev/null
+++ b/core/src/OpenMP/Kokkos_OpenMP.cpp
@@ -0,0 +1,118 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
+#define KOKKOS_IMPL_PUBLIC_INCLUDE
+#endif
+
+#include <OpenMP/Kokkos_OpenMP.hpp>
+#include <OpenMP/Kokkos_OpenMP_Instance.hpp>
+
+#include <impl/Kokkos_ExecSpaceManager.hpp>
+
+namespace Kokkos {
+
+OpenMP::OpenMP()
+    : m_space_instance(&Impl::OpenMPInternal::singleton(),
+                       [](Impl::OpenMPInternal *) {}) {
+  Impl::OpenMPInternal::singleton().verify_is_initialized(
+      "OpenMP instance constructor");
+}
+
+OpenMP::OpenMP(int pool_size)
+    : m_space_instance(new Impl::OpenMPInternal(pool_size),
+                       [](Impl::OpenMPInternal *ptr) {
+                         ptr->finalize();
+                         delete ptr;
+                       }) {
+  Impl::OpenMPInternal::singleton().verify_is_initialized(
+      "OpenMP instance constructor");
+}
+
+int OpenMP::impl_get_current_max_threads() noexcept {
+  return Impl::OpenMPInternal::get_current_max_threads();
+}
+
+void OpenMP::impl_initialize(InitializationSettings const &settings) {
+  Impl::OpenMPInternal::singleton().initialize(
+      settings.has_num_threads() ? settings.get_num_threads() : -1);
+}
+
+void OpenMP::impl_finalize() { Impl::OpenMPInternal::singleton().finalize(); }
+
+void OpenMP::print_configuration(std::ostream &os, bool /*verbose*/) const {
+  os << "Host Parallel Execution Space:\n";
+  os << "  KOKKOS_ENABLE_OPENMP: yes\n";
+
+  os << "\nOpenMP Runtime Configuration:\n";
+
+  m_space_instance->print_configuration(os);
+}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+int OpenMP::concurrency(OpenMP const &instance) {
+  return instance.impl_thread_pool_size();
+}
+#else
+int OpenMP::concurrency() const { return impl_thread_pool_size(); }
+#endif
+
+void OpenMP::fence(const std::string &name) const {
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::OpenMP>(
+      name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1}, []() {});
+}
+
+bool OpenMP::impl_is_initialized() noexcept {
+  return Impl::OpenMPInternal::singleton().is_initialized();
+}
+
+bool OpenMP::in_parallel(OpenMP const &exec_space) noexcept {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
+  return (
+      (exec_space.impl_internal_space_instance()->m_level < omp_get_level()) &&
+      (!Impl::t_openmp_instance ||
+       Impl::t_openmp_instance->m_level < omp_get_level()));
+#else
+  return exec_space.impl_internal_space_instance()->m_level < omp_get_level();
+#endif
+}
+
+int OpenMP::impl_thread_pool_size() const noexcept {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
+  return OpenMP::in_parallel(*this)
+             ? omp_get_num_threads()
+             : (Impl::t_openmp_instance
+                    ? Impl::t_openmp_instance->m_pool_size
+                    : impl_internal_space_instance()->m_pool_size);
+#else
+  return OpenMP::in_parallel(*this)
+             ? omp_get_num_threads()
+             : impl_internal_space_instance()->m_pool_size;
+#endif
+}
+
+int OpenMP::impl_max_hardware_threads() noexcept {
+  return Impl::g_openmp_hardware_max_threads;
+}
+
+namespace Impl {
+
+int g_openmp_space_factory_initialized =
+    initialize_space_factory<OpenMP>("050_OpenMP");
+
+}  // namespace Impl
+
+}  // namespace Kokkos
diff --git a/core/src/Kokkos_OpenMP.hpp b/core/src/OpenMP/Kokkos_OpenMP.hpp
similarity index 78%
rename from core/src/Kokkos_OpenMP.hpp
rename to core/src/OpenMP/Kokkos_OpenMP.hpp
index bbe008afd9..56937f32f5 100644
--- a/core/src/Kokkos_OpenMP.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP.hpp
@@ -43,6 +43,8 @@ static_assert(false,
 #include <impl/Kokkos_Profiling_Interface.hpp>
 #include <impl/Kokkos_InitializationSettings.hpp>
 
+#include <omp.h>
+
 #include <vector>
 
 /*--------------------------------------------------------------------------*/
@@ -51,7 +53,12 @@ namespace Kokkos {
 
 namespace Impl {
 class OpenMPInternal;
-}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
+// FIXME_OPENMP we can remove this after we remove partition_master
+inline thread_local OpenMPInternal* t_openmp_instance = nullptr;
+#endif
+}  // namespace Impl
 
 /// \class OpenMP
 /// \brief Kokkos device for multicore processors in the host memory space.
@@ -81,7 +88,7 @@ class OpenMP {
   void print_configuration(std::ostream& os, bool verbose = false) const;
 
   /// \brief is the instance running a parallel algorithm
-  inline static bool in_parallel(OpenMP const& = OpenMP()) noexcept;
+  static bool in_parallel(OpenMP const& = OpenMP()) noexcept;
 
   /// \brief Wait until all dispatched functors complete on the given instance
   ///
@@ -109,7 +116,11 @@ class OpenMP {
       int requested_partition_size = 0);
 #endif
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   static int concurrency(OpenMP const& = OpenMP());
+#else
+  int concurrency() const;
+#endif
 
   static void impl_initialize(InitializationSettings const&);
 
@@ -120,15 +131,15 @@ class OpenMP {
   /// \brief Free any resources being consumed by the default execution space
   static void impl_finalize();
 
-  inline static int impl_thread_pool_size(OpenMP const& = OpenMP()) noexcept;
+  int impl_thread_pool_size() const noexcept;
+
+  int impl_thread_pool_size(int depth) const;
 
   /** \brief  The rank of the executing thread in this thread pool */
   inline static int impl_thread_pool_rank() noexcept;
 
-  inline static int impl_thread_pool_size(int depth, OpenMP const& = OpenMP());
-
   // use UniqueToken
-  inline static int impl_max_hardware_threads() noexcept;
+  static int impl_max_hardware_threads() noexcept;
 
   // use UniqueToken
   KOKKOS_INLINE_FUNCTION
@@ -154,6 +165,42 @@ class OpenMP {
   Kokkos::Impl::HostSharedPtr<Impl::OpenMPInternal> m_space_instance;
 };
 
+inline int OpenMP::impl_thread_pool_rank() noexcept {
+  // FIXME_OPENMP Can we remove this when removing partition_master? It's only
+  // used in one partition_master test
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
+  KOKKOS_IF_ON_HOST(
+      (return Impl::t_openmp_instance ? 0 : omp_get_thread_num();))
+#else
+  KOKKOS_IF_ON_HOST((return omp_get_thread_num();))
+#endif
+
+  KOKKOS_IF_ON_DEVICE((return -1;))
+}
+
+inline void OpenMP::impl_static_fence(std::string const& name) {
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::OpenMP>(
+      name,
+      Kokkos::Tools::Experimental::SpecialSynchronizationCases::
+          GlobalDeviceSynchronization,
+      []() {});
+}
+
+inline bool OpenMP::is_asynchronous(OpenMP const& /*instance*/) noexcept {
+  return false;
+}
+
+inline int OpenMP::impl_thread_pool_size(int depth) const {
+  return depth < 2 ? impl_thread_pool_size() : 1;
+}
+
+KOKKOS_INLINE_FUNCTION
+int OpenMP::impl_hardware_thread_id() noexcept {
+  KOKKOS_IF_ON_HOST((return omp_get_thread_num();))
+
+  KOKKOS_IF_ON_DEVICE((return -1;))
+}
+
 namespace Tools {
 namespace Experimental {
 template <>
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp b/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
index b1ccac5156..57f2d82194 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
@@ -241,13 +241,19 @@ void OpenMPInternal::initialize(int thread_count) {
   }
 
   {
-    if (Kokkos::show_warnings() && nullptr == std::getenv("OMP_PROC_BIND")) {
+    if (Kokkos::show_warnings() && !std::getenv("OMP_PROC_BIND")) {
       std::cerr
           << R"WARNING(Kokkos::OpenMP::initialize WARNING: OMP_PROC_BIND environment variable not set
   In general, for best performance with OpenMP 4.0 or better set OMP_PROC_BIND=spread and OMP_PLACES=threads
   For best performance with OpenMP 3.1 set OMP_PROC_BIND=true
   For unit testing set OMP_PROC_BIND=false
 )WARNING" << std::endl;
+
+      if (mpi_detected()) {
+        std::cerr
+            << R"WARNING(MPI detected: For OpenMP binding to work as intended, MPI ranks must be bound to exclusive CPU sets.
+)WARNING" << std::endl;
+      }
     }
 
     OpenMP::memory_space space;
@@ -324,8 +330,6 @@ void OpenMPInternal::initialize(int thread_count) {
     std::cerr << "                                    Requested: "
               << thread_count << " threads per process." << std::endl;
   }
-  // Init the array used for arbitrarily sized atomics
-  init_lock_array_host_space();
 
   m_initialized = true;
 }
@@ -384,68 +388,4 @@ bool OpenMPInternal::verify_is_initialized(const char *const label) const {
   return m_initialized;
 }
 }  // namespace Impl
-
-//----------------------------------------------------------------------------
-
-OpenMP::OpenMP()
-    : m_space_instance(&Impl::OpenMPInternal::singleton(),
-                       [](Impl::OpenMPInternal *) {}) {
-  Impl::OpenMPInternal::singleton().verify_is_initialized(
-      "OpenMP instance constructor");
-}
-
-OpenMP::OpenMP(int pool_size)
-    : m_space_instance(new Impl::OpenMPInternal(pool_size),
-                       [](Impl::OpenMPInternal *ptr) {
-                         ptr->finalize();
-                         delete ptr;
-                       }) {
-  Impl::OpenMPInternal::singleton().verify_is_initialized(
-      "OpenMP instance constructor");
-}
-
-int OpenMP::impl_get_current_max_threads() noexcept {
-  return Impl::OpenMPInternal::get_current_max_threads();
-}
-
-void OpenMP::impl_initialize(InitializationSettings const &settings) {
-  Impl::OpenMPInternal::singleton().initialize(
-      settings.has_num_threads() ? settings.get_num_threads() : -1);
-}
-
-void OpenMP::impl_finalize() { Impl::OpenMPInternal::singleton().finalize(); }
-
-void OpenMP::print_configuration(std::ostream &os, bool /*verbose*/) const {
-  os << "Host Parallel Execution Space:\n";
-  os << "  KOKKOS_ENABLE_OPENMP: yes\n";
-
-  os << "OpenMP Atomics:\n";
-  os << "  KOKKOS_ENABLE_OPENMP_ATOMICS: ";
-#ifdef KOKKOS_ENABLE_OPENMP_ATOMICS
-  os << "yes\n";
-#else
-  os << "no\n";
-#endif
-
-  os << "\nOpenMP Runtime Configuration:\n";
-
-  m_space_instance->print_configuration(os);
-}
-
-int OpenMP::concurrency(OpenMP const &instance) {
-  return impl_thread_pool_size(instance);
-}
-
-void OpenMP::fence(const std::string &name) const {
-  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::OpenMP>(
-      name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1}, []() {});
-}
-
-namespace Impl {
-
-int g_openmp_space_factory_initialized =
-    initialize_space_factory<OpenMP>("050_OpenMP");
-
-}  // namespace Impl
-
 }  // namespace Kokkos
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp b/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp
index e2d52a141a..f8b55fda41 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp
@@ -24,14 +24,13 @@
     "You enabled Kokkos OpenMP support without enabling OpenMP in the compiler!"
 #endif
 
-#include <Kokkos_OpenMP.hpp>
+#include <OpenMP/Kokkos_OpenMP.hpp>
 
 #include <impl/Kokkos_Traits.hpp>
 #include <impl/Kokkos_HostThreadTeam.hpp>
 
 #include <Kokkos_Atomic.hpp>
 
-#include <Kokkos_UniqueToken.hpp>
 #include <impl/Kokkos_ConcurrentBitset.hpp>
 
 #include <omp.h>
@@ -48,11 +47,6 @@ class OpenMPInternal;
 
 inline int g_openmp_hardware_max_threads = 1;
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-// FIXME_OPENMP we can remove this after we remove partition_master
-inline thread_local OpenMPInternal* t_openmp_instance = nullptr;
-#endif
-
 struct OpenMPTraits {
   static int constexpr MAX_THREAD_COUNT = 512;
 };
@@ -117,102 +111,6 @@ class OpenMPInternal {
 };
 
 }  // namespace Impl
-inline bool OpenMP::impl_is_initialized() noexcept {
-  return Impl::OpenMPInternal::singleton().is_initialized();
-}
-
-inline bool OpenMP::in_parallel(OpenMP const& exec_space) noexcept {
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-  return (
-      (exec_space.impl_internal_space_instance()->m_level < omp_get_level()) &&
-      (!Impl::t_openmp_instance ||
-       Impl::t_openmp_instance->m_level < omp_get_level()));
-#else
-  return exec_space.impl_internal_space_instance()->m_level < omp_get_level();
-#endif
-}
-
-inline int OpenMP::impl_thread_pool_size(OpenMP const& exec_space) noexcept {
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-  return OpenMP::in_parallel(exec_space)
-             ? omp_get_num_threads()
-             : (Impl::t_openmp_instance
-                    ? Impl::t_openmp_instance->m_pool_size
-                    : exec_space.impl_internal_space_instance()->m_pool_size);
-#else
-  return OpenMP::in_parallel(exec_space)
-             ? omp_get_num_threads()
-             : exec_space.impl_internal_space_instance()->m_pool_size;
-#endif
-}
-
-inline int OpenMP::impl_thread_pool_rank() noexcept {
-  // FIXME_OPENMP Can we remove this when removing partition_master? It's only
-  // used in one partition_master test
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-  KOKKOS_IF_ON_HOST(
-      (return Impl::t_openmp_instance ? 0 : omp_get_thread_num();))
-#else
-  KOKKOS_IF_ON_HOST((return omp_get_thread_num();))
-#endif
-
-  KOKKOS_IF_ON_DEVICE((return -1;))
-}
-
-inline void OpenMP::impl_static_fence(std::string const& name) {
-  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::OpenMP>(
-      name,
-      Kokkos::Tools::Experimental::SpecialSynchronizationCases::
-          GlobalDeviceSynchronization,
-      []() {});
-}
-
-inline bool OpenMP::is_asynchronous(OpenMP const& /*instance*/) noexcept {
-  return false;
-}
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-template <typename F>
-KOKKOS_DEPRECATED void OpenMP::partition_master(F const& f, int num_partitions,
-                                                int partition_size) {
-#if _OPENMP >= 201511
-  if (omp_get_max_active_levels() > 1) {
-#else
-  if (omp_get_nested()) {
-#endif
-    using Exec = Impl::OpenMPInternal;
-
-    Exec* prev_instance = &Impl::OpenMPInternal::singleton();
-
-    Exec::validate_partition_impl(prev_instance->m_pool_size, num_partitions,
-                                  partition_size);
-
-    OpenMP::memory_space space;
-
-#pragma omp parallel num_threads(num_partitions)
-    {
-      Exec thread_local_instance(partition_size);
-      Impl::t_openmp_instance = &thread_local_instance;
-
-      size_t pool_reduce_bytes  = 32 * partition_size;
-      size_t team_reduce_bytes  = 32 * partition_size;
-      size_t team_shared_bytes  = 1024 * partition_size;
-      size_t thread_local_bytes = 1024;
-
-      thread_local_instance.resize_thread_data(
-          pool_reduce_bytes, team_reduce_bytes, team_shared_bytes,
-          thread_local_bytes);
-
-      omp_set_num_threads(partition_size);
-      f(omp_get_thread_num(), omp_get_num_threads());
-      Impl::t_openmp_instance = nullptr;
-    }
-  } else {
-    // nested openmp not enabled
-    f(0, 1);
-  }
-}
-#endif
 
 namespace Experimental {
 
@@ -237,124 +135,8 @@ class MasterLock<OpenMP> {
 };
 #endif
 
-template <>
-class UniqueToken<OpenMP, UniqueTokenScope::Instance> {
- private:
-  using buffer_type = Kokkos::View<uint32_t*, Kokkos::HostSpace>;
-  int m_count;
-  buffer_type m_buffer_view;
-  uint32_t volatile* m_buffer;
-
- public:
-  using execution_space = OpenMP;
-  using size_type       = int;
-
-  /// \brief create object size for concurrency on the given instance
-  ///
-  /// This object should not be shared between instances
-  UniqueToken(execution_space const& = execution_space()) noexcept
-      : m_count(::Kokkos::OpenMP::impl_thread_pool_size()),
-        m_buffer_view(buffer_type()),
-        m_buffer(nullptr) {}
-
-  UniqueToken(size_type max_size, execution_space const& = execution_space())
-      : m_count(max_size),
-        m_buffer_view("UniqueToken::m_buffer_view",
-                      ::Kokkos::Impl::concurrent_bitset::buffer_bound(m_count)),
-        m_buffer(m_buffer_view.data()) {}
-
-  /// \brief upper bound for acquired values, i.e. 0 <= value < size()
-  KOKKOS_INLINE_FUNCTION
-  int size() const noexcept {
-    KOKKOS_IF_ON_HOST((return m_count;))
-
-    KOKKOS_IF_ON_DEVICE((return 0;))
-  }
-
-  /// \brief acquire value such that 0 <= value < size()
-  KOKKOS_INLINE_FUNCTION
-  int acquire() const noexcept {
-    KOKKOS_IF_ON_HOST(
-        (if (m_count >= ::Kokkos::OpenMP::impl_thread_pool_size()) return ::
-             Kokkos::OpenMP::impl_thread_pool_rank();
-         const ::Kokkos::pair<int, int> result =
-             ::Kokkos::Impl::concurrent_bitset::acquire_bounded(
-                 m_buffer, m_count, ::Kokkos::Impl::clock_tic() % m_count);
-
-         if (result.first < 0) {
-           ::Kokkos::abort(
-               "UniqueToken<OpenMP> failure to acquire tokens, no tokens "
-               "available");
-         }
-
-         return result.first;))
-
-    KOKKOS_IF_ON_DEVICE((return 0;))
-  }
-
-  /// \brief release a value acquired by generate
-  KOKKOS_INLINE_FUNCTION
-  void release(int i) const noexcept {
-    KOKKOS_IF_ON_HOST(
-        (if (m_count < ::Kokkos::OpenMP::impl_thread_pool_size()) {
-          ::Kokkos::Impl::concurrent_bitset::release(m_buffer, i);
-        }))
-
-    KOKKOS_IF_ON_DEVICE(((void)i;))
-  }
-};
-
-template <>
-class UniqueToken<OpenMP, UniqueTokenScope::Global> {
- public:
-  using execution_space = OpenMP;
-  using size_type       = int;
-
-  /// \brief create object size for concurrency on the given instance
-  ///
-  /// This object should not be shared between instances
-  UniqueToken(execution_space const& = execution_space()) noexcept {}
-
-  /// \brief upper bound for acquired values, i.e. 0 <= value < size()
-  KOKKOS_INLINE_FUNCTION
-  int size() const noexcept {
-    KOKKOS_IF_ON_HOST((return Kokkos::Impl::g_openmp_hardware_max_threads;))
-
-    KOKKOS_IF_ON_DEVICE((return 0;))
-  }
-
-  /// \brief acquire value such that 0 <= value < size()
-  // FIXME this is wrong when using nested parallelism. In that case multiple
-  // threads have the same thread ID.
-  KOKKOS_INLINE_FUNCTION
-  int acquire() const noexcept {
-    KOKKOS_IF_ON_HOST((return omp_get_thread_num();))
-
-    KOKKOS_IF_ON_DEVICE((return 0;))
-  }
-
-  /// \brief release a value acquired by generate
-  KOKKOS_INLINE_FUNCTION
-  void release(int) const noexcept {}
-};
-
 }  // namespace Experimental
 
-inline int OpenMP::impl_thread_pool_size(int depth, OpenMP const& exec_space) {
-  return depth < 2 ? impl_thread_pool_size(exec_space) : 1;
-}
-
-KOKKOS_INLINE_FUNCTION
-int OpenMP::impl_hardware_thread_id() noexcept {
-  KOKKOS_IF_ON_HOST((return omp_get_thread_num();))
-
-  KOKKOS_IF_ON_DEVICE((return -1;))
-}
-
-inline int OpenMP::impl_max_hardware_threads() noexcept {
-  return Impl::g_openmp_hardware_max_threads;
-}
-
 namespace Experimental {
 namespace Impl {
 // Partitioning an Execution Space: expects space and integer arguments for
@@ -404,10 +186,54 @@ std::vector<OpenMP> partition_space(OpenMP const& main_instance, Args... args) {
 
 template <typename T>
 std::vector<OpenMP> partition_space(OpenMP const& main_instance,
-                                    std::vector<T>& weights) {
+                                    std::vector<T> const& weights) {
   return Impl::create_OpenMP_instances(main_instance, weights);
 }
 }  // namespace Experimental
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
+template <typename F>
+KOKKOS_DEPRECATED void OpenMP::partition_master(F const& f, int num_partitions,
+                                                int partition_size) {
+#if _OPENMP >= 201511
+  if (omp_get_max_active_levels() > 1) {
+#else
+  if (omp_get_nested()) {
+#endif
+    using Exec = Impl::OpenMPInternal;
+
+    Exec* prev_instance = &Impl::OpenMPInternal::singleton();
+
+    Exec::validate_partition_impl(prev_instance->m_pool_size, num_partitions,
+                                  partition_size);
+
+    OpenMP::memory_space space;
+
+#pragma omp parallel num_threads(num_partitions)
+    {
+      Exec thread_local_instance(partition_size);
+      Impl::t_openmp_instance = &thread_local_instance;
+
+      size_t pool_reduce_bytes  = 32 * partition_size;
+      size_t team_reduce_bytes  = 32 * partition_size;
+      size_t team_shared_bytes  = 1024 * partition_size;
+      size_t thread_local_bytes = 1024;
+
+      thread_local_instance.resize_thread_data(
+          pool_reduce_bytes, team_reduce_bytes, team_shared_bytes,
+          thread_local_bytes);
+
+      omp_set_num_threads(partition_size);
+      f(omp_get_thread_num(), omp_get_num_threads());
+      Impl::t_openmp_instance = nullptr;
+    }
+  } else {
+    // nested openmp not enabled
+    f(0, 1);
+  }
+}
+#endif
+
 }  // namespace Kokkos
 
 #endif
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp b/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
index cbd687bec5..3bfd6dea50 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
@@ -52,10 +52,9 @@ inline bool execute_in_serial(OpenMP const& space = OpenMP()) {
 template <class FunctorType, class... Traits>
 class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::OpenMP> {
  private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
+  using Policy  = Kokkos::RangePolicy<Traits...>;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
 
   OpenMPInternal* m_instance;
   const FunctorType m_functor;
@@ -178,8 +177,7 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
   using Policy        = typename MDRangePolicy::impl_range_policy;
   using WorkTag       = typename MDRangePolicy::work_tag;
 
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
+  using Member = typename Policy::member_type;
 
   using index_type   = typename Policy::index_type;
   using iterate_type = typename Kokkos::Impl::HostIterateTile<
@@ -292,35 +290,23 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
                      Kokkos::OpenMP> {
  private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
-
-  // Static Assert WorkTag void if ReducerType not InvalidType
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
   OpenMPInternal* m_instance;
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
 
   template <class TagType>
@@ -344,13 +330,12 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
 
  public:
   inline void execute() const {
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
     if (m_policy.end() <= m_policy.begin()) {
       if (m_result_ptr) {
-        final_reducer.init(m_result_ptr);
-        final_reducer.final(m_result_ptr);
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
       }
       return;
     }
@@ -359,8 +344,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                                 Kokkos::Dynamic>::value
     };
 
-    const size_t pool_reduce_bytes =
-        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
+    const size_t pool_reduce_bytes = reducer.value_size();
 
     m_instance->acquire_lock();
 
@@ -378,12 +362,13 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
               : pointer_type(
                     m_instance->get_thread_data(0)->pool_reduce_local());
 
-      reference_type update = final_reducer.init(ptr);
+      reference_type update = reducer.init(ptr);
 
-      ParallelReduce::template exec_range<WorkTag>(m_functor, m_policy.begin(),
-                                                   m_policy.end(), update);
+      ParallelReduce::template exec_range<WorkTag>(
+          m_functor_reducer.get_functor(), m_policy.begin(), m_policy.end(),
+          update);
 
-      final_reducer.final(ptr);
+      reducer.final(ptr);
       return;
     }
     const int pool_size = m_instance->thread_pool_size();
@@ -399,7 +384,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         if (data.pool_rendezvous()) data.pool_rendezvous_release();
       }
 
-      reference_type update = final_reducer.init(
+      reference_type update = reducer.init(
           reinterpret_cast<pointer_type>(data.pool_reduce_local()));
 
       std::pair<int64_t, int64_t> range(0, 0);
@@ -409,7 +394,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                            : data.get_work_partition();
 
         ParallelReduce::template exec_range<WorkTag>(
-            m_functor, range.first + m_policy.begin(),
+            m_functor_reducer.get_functor(), range.first + m_policy.begin(),
             range.second + m_policy.begin(), update);
 
       } while (is_dynamic && 0 <= range.first);
@@ -421,16 +406,15 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
 
     for (int i = 1; i < pool_size; ++i) {
-      final_reducer.join(
-          ptr, reinterpret_cast<pointer_type>(
-                   m_instance->get_thread_data(i)->pool_reduce_local()));
+      reducer.join(ptr,
+                   reinterpret_cast<pointer_type>(
+                       m_instance->get_thread_data(i)->pool_reduce_local()));
     }
 
-    final_reducer.final(ptr);
+    reducer.final(ptr);
 
     if (m_result_ptr) {
-      const int n = Analysis::value_count(
-          ReducerConditional::select(m_functor, m_reducer));
+      const int n = reducer.value_count();
 
       for (int j = 0; j < n; ++j) {
         m_result_ptr[j] = ptr[j];
@@ -443,16 +427,11 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   //----------------------------------------
 
   template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType& arg_functor, Policy arg_policy,
-      const ViewType& arg_view,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void*> = nullptr)
+  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                        Policy arg_policy, const ViewType& arg_view)
       : m_instance(nullptr),
-        m_functor(arg_functor),
+        m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_view.data()) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
     if (t_openmp_instance) {
@@ -463,69 +442,36 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
 #else
     m_instance = arg_policy.space().impl_internal_space_instance();
 #endif
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
-  }
-
-  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
-                        const ReducerType& reducer)
-      : m_instance(nullptr),
-        m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-    if (t_openmp_instance) {
-      m_instance = t_openmp_instance;
-    } else {
-      m_instance = arg_policy.space().impl_internal_space_instance();
-    }
-#else
-    m_instance = arg_policy.space().impl_internal_space_instance();
-#endif
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::OpenMP reduce result must be a View accessible from "
+        "HostSpace");
   }
 };
 
 // MDRangePolicy impl
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
-                     Kokkos::OpenMP> {
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>, Kokkos::OpenMP> {
  private:
   using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
   using Policy        = typename MDRangePolicy::impl_range_policy;
+  using FunctorType   = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType   = typename CombinedFunctorReducerType::reducer_type;
 
-  using WorkTag   = typename MDRangePolicy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
+  using WorkTag = typename MDRangePolicy::work_tag;
+  using Member  = typename Policy::member_type;
 
-  using Analysis = FunctorAnalysis<FunctorPatternInterface::REDUCE,
-                                   MDRangePolicy, ReducerTypeFwd>;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
-
-  using iterate_type =
-      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
-                                             WorkTag, reference_type>;
+  using iterate_type = typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, CombinedFunctorReducerType, WorkTag, reference_type>;
 
   OpenMPInternal* m_instance;
   const iterate_type m_iter;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
 
   inline void exec_range(const Member ibeg, const Member iend,
@@ -537,8 +483,8 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
 
  public:
   inline void execute() const {
-    const size_t pool_reduce_bytes = Analysis::value_size(
-        ReducerConditional::select(m_iter.m_func, m_reducer));
+    const ReducerType& reducer     = m_iter.m_func.get_reducer();
+    const size_t pool_reduce_bytes = reducer.value_size();
 
     m_instance->acquire_lock();
 
@@ -549,9 +495,6 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
                                    0  // thread_local_bytes
     );
 
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_iter.m_func, m_reducer));
-
 #ifndef KOKKOS_COMPILER_INTEL
     if (execute_in_serial(m_iter.m_rp.space())) {
       const pointer_type ptr =
@@ -560,11 +503,11 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
               : pointer_type(
                     m_instance->get_thread_data(0)->pool_reduce_local());
 
-      reference_type update = final_reducer.init(ptr);
+      reference_type update = reducer.init(ptr);
 
       ParallelReduce::exec_range(0, m_iter.m_rp.m_num_tiles, update);
 
-      final_reducer.final(ptr);
+      reducer.final(ptr);
 
       m_instance->release_lock();
 
@@ -589,7 +532,7 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
         if (data.pool_rendezvous()) data.pool_rendezvous_release();
       }
 
-      reference_type update = final_reducer.init(
+      reference_type update = reducer.init(
           reinterpret_cast<pointer_type>(data.pool_reduce_local()));
 
       std::pair<int64_t, int64_t> range(0, 0);
@@ -610,16 +553,15 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
         pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
 
     for (int i = 1; i < pool_size; ++i) {
-      final_reducer.join(
-          ptr, reinterpret_cast<pointer_type>(
-                   m_instance->get_thread_data(i)->pool_reduce_local()));
+      reducer.join(ptr,
+                   reinterpret_cast<pointer_type>(
+                       m_instance->get_thread_data(i)->pool_reduce_local()));
     }
 
-    final_reducer.final(ptr);
+    reducer.final(ptr);
 
     if (m_result_ptr) {
-      const int n = Analysis::value_count(
-          ReducerConditional::select(m_iter.m_func, m_reducer));
+      const int n = reducer.value_count();
 
       for (int j = 0; j < n; ++j) {
         m_result_ptr[j] = ptr[j];
@@ -632,15 +574,10 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
   //----------------------------------------
 
   template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType& arg_functor, MDRangePolicy arg_policy,
-      const ViewType& arg_view,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void*> = nullptr)
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 MDRangePolicy arg_policy, const ViewType& arg_view)
       : m_instance(nullptr),
-        m_iter(arg_policy, arg_functor),
-        m_reducer(InvalidType()),
+        m_iter(arg_policy, arg_functor_reducer),
         m_result_ptr(arg_view.data()) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
     if (t_openmp_instance) {
@@ -651,32 +588,13 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
 #else
     m_instance = arg_policy.space().impl_internal_space_instance();
 #endif
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::OpenMP reduce result must be a View accessible from "
+        "HostSpace");
   }
 
-  inline ParallelReduce(const FunctorType& arg_functor,
-                        MDRangePolicy arg_policy, const ReducerType& reducer)
-      : m_instance(nullptr),
-        m_iter(arg_policy, arg_functor),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-    if (t_openmp_instance) {
-      m_instance = t_openmp_instance;
-    } else {
-      m_instance = arg_policy.space().impl_internal_space_instance();
-    }
-#else
-    m_instance = arg_policy.space().impl_internal_space_instance();
-#endif
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
-  }
   template <typename Policy, typename Functor>
   static int max_tile_size_product(const Policy&, const Functor&) {
     /**
@@ -704,7 +622,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
   using Policy = Kokkos::RangePolicy<Traits...>;
 
   using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
+      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType, void>;
 
   using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
@@ -749,7 +667,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
     );
 
     if (execute_in_serial(m_policy.space())) {
-      typename Analysis::Reducer final_reducer(&m_functor);
+      typename Analysis::Reducer final_reducer(m_functor);
 
       reference_type update = final_reducer.init(
           pointer_type(m_instance->get_thread_data(0)->pool_reduce_local()));
@@ -763,7 +681,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
 #pragma omp parallel num_threads(m_instance->thread_pool_size())
     {
       HostThreadTeamData& data = *(m_instance->get_thread_data());
-      typename Analysis::Reducer final_reducer(&m_functor);
+      typename Analysis::Reducer final_reducer(m_functor);
 
       const WorkRange range(m_policy, omp_get_thread_num(),
                             omp_get_num_threads());
@@ -831,8 +749,8 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
  private:
   using Policy = Kokkos::RangePolicy<Traits...>;
 
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
+  using Analysis = FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                   FunctorType, ReturnType>;
 
   using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
@@ -881,7 +799,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     );
 
     if (execute_in_serial(m_policy.space())) {
-      typename Analysis::Reducer final_reducer(&m_functor);
+      typename Analysis::Reducer final_reducer(m_functor);
 
       reference_type update = final_reducer.init(
           pointer_type(m_instance->get_thread_data(0)->pool_reduce_local()));
@@ -899,7 +817,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
 #pragma omp parallel num_threads(m_instance->thread_pool_size())
     {
       HostThreadTeamData& data = *(m_instance->get_thread_data());
-      typename Analysis::Reducer final_reducer(&m_functor);
+      typename Analysis::Reducer final_reducer(m_functor);
 
       const WorkRange range(m_policy, omp_get_thread_num(),
                             omp_get_num_threads());
@@ -1124,38 +1042,27 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
 //----------------------------------------------------------------------------
 
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::OpenMP> {
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>, Kokkos::OpenMP> {
  private:
   enum { TEAM_REDUCE_SIZE = 512 };
 
   using Policy =
       Kokkos::Impl::TeamPolicyInternal<Kokkos::OpenMP, Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
   using WorkTag  = typename Policy::work_tag;
   using SchedTag = typename Policy::schedule_type::type;
   using Member   = typename Policy::member_type;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
-
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
   OpenMPInternal* m_instance;
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const int m_shmem_size;
 
@@ -1201,19 +1108,17 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   inline void execute() const {
     enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
 
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
 
     if (m_policy.league_size() == 0 || m_policy.team_size() == 0) {
       if (m_result_ptr) {
-        final_reducer.init(m_result_ptr);
-        final_reducer.final(m_result_ptr);
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
       }
       return;
     }
 
-    const size_t pool_reduce_size =
-        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
+    const size_t pool_reduce_size = reducer.value_size();
 
     const size_t team_reduce_size  = TEAM_REDUCE_SIZE * m_policy.team_size();
     const size_t team_shared_size  = m_shmem_size + m_policy.scratch_size(1);
@@ -1228,14 +1133,14 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
       HostThreadTeamData& data = *(m_instance->get_thread_data());
       pointer_type ptr =
           m_result_ptr ? m_result_ptr : pointer_type(data.pool_reduce_local());
-      reference_type update       = final_reducer.init(ptr);
+      reference_type update       = reducer.init(ptr);
       const int league_rank_begin = 0;
       const int league_rank_end   = m_policy.league_size();
       ParallelReduce::template exec_team<WorkTag>(
-          m_functor, data, update, league_rank_begin, league_rank_end,
-          m_policy.league_size());
+          m_functor_reducer.get_functor(), data, update, league_rank_begin,
+          league_rank_end, m_policy.league_size());
 
-      final_reducer.final(ptr);
+      reducer.final(ptr);
 
       m_instance->release_lock();
 
@@ -1263,7 +1168,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
       }
 
       if (active) {
-        reference_type update = final_reducer.init(
+        reference_type update = reducer.init(
             reinterpret_cast<pointer_type>(data.pool_reduce_local()));
 
         std::pair<int64_t, int64_t> range(0, 0);
@@ -1272,14 +1177,13 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
           range = is_dynamic ? data.get_work_stealing_chunk()
                              : data.get_work_partition();
 
-          ParallelReduce::template exec_team<WorkTag>(m_functor, data, update,
-                                                      range.first, range.second,
-                                                      m_policy.league_size());
+          ParallelReduce::template exec_team<WorkTag>(
+              m_functor_reducer.get_functor(), data, update, range.first,
+              range.second, m_policy.league_size());
 
         } while (is_dynamic && 0 <= range.first);
       } else {
-        final_reducer.init(
-            reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+        reducer.init(reinterpret_cast<pointer_type>(data.pool_reduce_local()));
       }
 
       data.disband_team();
@@ -1301,16 +1205,15 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
 
     for (int i = 1; i < pool_size; ++i) {
-      final_reducer.join(
-          ptr, reinterpret_cast<pointer_type>(
-                   m_instance->get_thread_data(i)->pool_reduce_local()));
+      reducer.join(ptr,
+                   reinterpret_cast<pointer_type>(
+                       m_instance->get_thread_data(i)->pool_reduce_local()));
     }
 
-    final_reducer.final(ptr);
+    reducer.final(ptr);
 
     if (m_result_ptr) {
-      const int n = Analysis::value_count(
-          ReducerConditional::select(m_functor, m_reducer));
+      const int n = reducer.value_count();
 
       for (int j = 0; j < n; ++j) {
         m_result_ptr[j] = ptr[j];
@@ -1323,20 +1226,16 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   //----------------------------------------
 
   template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType& arg_functor, const Policy& arg_policy,
-      const ViewType& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void*> = nullptr)
+  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                        const Policy& arg_policy, const ViewType& arg_result)
       : m_instance(nullptr),
-        m_functor(arg_functor),
+        m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
-        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                     FunctorTeamShmemSize<FunctorType>::value(
-                         arg_functor, arg_policy.team_size())) {
+        m_shmem_size(
+            arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+            FunctorTeamShmemSize<FunctorType>::value(
+                arg_functor_reducer.get_functor(), arg_policy.team_size())) {
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
     if (t_openmp_instance) {
       m_instance = t_openmp_instance;
@@ -1346,31 +1245,12 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
 #else
     m_instance = arg_policy.space().impl_internal_space_instance();
 #endif
-  }
 
-  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
-                        const ReducerType& reducer)
-      : m_instance(nullptr),
-        m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                     FunctorTeamShmemSize<FunctorType>::value(
-                         arg_functor, arg_policy.team_size())) {
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-    if (t_openmp_instance) {
-      m_instance = t_openmp_instance;
-    } else {
-      m_instance = arg_policy.space().impl_internal_space_instance();
-    }
-#else
-    m_instance = arg_policy.space().impl_internal_space_instance();
-#endif
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                            , Kokkos::HostSpace >::value
-    , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-    );*/
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::OpenMP reduce result must be a View accessible from "
+        "HostSpace");
   }
 };
 
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Task.hpp b/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
index d6fd45ae9a..669607392b 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
@@ -23,7 +23,7 @@
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
 #include <impl/Kokkos_HostThreadTeam.hpp>
-#include <Kokkos_OpenMP.hpp>
+#include <OpenMP/Kokkos_OpenMP.hpp>
 
 #include <type_traits>
 #include <cassert>
@@ -156,7 +156,7 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::OpenMP, QueueType>> {
   }
 
   static uint32_t get_max_team_count(execution_space const& espace) {
-    return static_cast<uint32_t>(OpenMP::impl_thread_pool_size(espace));
+    return static_cast<uint32_t>(espace.impl_thread_pool_size());
   }
 
   // TODO @tasking @optimization DSH specialize this for trivially destructible
@@ -189,7 +189,8 @@ class TaskQueueSpecializationConstrained<
     using task_base_type = typename scheduler_type::task_base;
     using queue_type     = typename scheduler_type::queue_type;
 
-    if (1 == OpenMP::impl_thread_pool_size()) {
+    execution_space exec;
+    if (1 == exec.impl_thread_pool_size()) {
       task_base_type* const end = (task_base_type*)task_base_type::EndTag;
 
       HostThreadTeamData& team_data_single =
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Team.hpp b/core/src/OpenMP/Kokkos_OpenMP_Team.hpp
index 280b1701ad..dbc30c5d02 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Team.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Team.hpp
@@ -59,7 +59,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
 
   template <class FunctorType>
   int team_size_max(const FunctorType&, const ParallelForTag&) const {
-    int pool_size = traits::execution_space::impl_thread_pool_size(1, m_space);
+    int pool_size          = m_space.impl_thread_pool_size(1);
     int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
     return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
@@ -68,7 +68,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
 
   template <class FunctorType>
   int team_size_max(const FunctorType&, const ParallelReduceTag&) const {
-    int pool_size = traits::execution_space::impl_thread_pool_size(1, m_space);
+    int pool_size          = m_space.impl_thread_pool_size(1);
     int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
     return pool_size < max_host_team_size ? pool_size : max_host_team_size;
   }
@@ -79,12 +79,12 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
   }
   template <class FunctorType>
   int team_size_recommended(const FunctorType&, const ParallelForTag&) const {
-    return traits::execution_space::impl_thread_pool_size(2, m_space);
+    return m_space.impl_thread_pool_size(2);
   }
   template <class FunctorType>
   int team_size_recommended(const FunctorType&,
                             const ParallelReduceTag&) const {
-    return traits::execution_space::impl_thread_pool_size(2, m_space);
+    return m_space.impl_thread_pool_size(2);
   }
   template <class FunctorType, class ReducerType>
   inline int team_size_recommended(const FunctorType& f, const ReducerType&,
@@ -120,10 +120,8 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
   typename traits::execution_space m_space;
 
   inline void init(const int league_size_request, const int team_size_request) {
-    const int pool_size =
-        traits::execution_space::impl_thread_pool_size(0, m_space);
-    const int team_grain =
-        traits::execution_space::impl_thread_pool_size(2, m_space);
+    const int pool_size          = m_space.impl_thread_pool_size(0);
+    const int team_grain         = m_space.impl_thread_pool_size(2);
     const int max_host_team_size = Impl::HostThreadTeamData::max_team_members;
     const int team_max =
         ((pool_size < max_host_team_size) ? pool_size : max_host_team_size);
@@ -192,8 +190,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
         m_tune_team(true),
         m_tune_vector(false),
         m_space(space) {
-    init(league_size_request,
-         traits::execution_space::impl_thread_pool_size(2, m_space));
+    init(league_size_request, m_space.impl_thread_pool_size(2));
   }
 
   TeamPolicyInternal(const typename traits::execution_space& space,
@@ -207,8 +204,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
         m_tune_team(true),
         m_tune_vector(true),
         m_space(space) {
-    init(league_size_request,
-         traits::execution_space::impl_thread_pool_size(2, m_space));
+    init(league_size_request, m_space.impl_thread_pool_size(2));
   }
 
   TeamPolicyInternal(const typename traits::execution_space& space,
@@ -242,8 +238,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
         m_chunk_size(0),
         m_tune_team(true),
         m_tune_vector(false) {
-    init(league_size_request,
-         traits::execution_space::impl_thread_pool_size(2, m_space));
+    init(league_size_request, m_space.impl_thread_pool_size(2));
   }
 
   TeamPolicyInternal(int league_size_request,
@@ -255,8 +250,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
         m_chunk_size(0),
         m_tune_team(true),
         m_tune_vector(true) {
-    init(league_size_request,
-         traits::execution_space::impl_thread_pool_size(2, m_space));
+    init(league_size_request, m_space.impl_thread_pool_size(2));
   }
 
   TeamPolicyInternal(int league_size_request, int team_size_request,
@@ -310,9 +304,7 @@ class TeamPolicyInternal<Kokkos::OpenMP, Properties...>
  private:
   /** \brief finalize chunk_size if it was set to AUTO*/
   inline void set_auto_chunk_size() {
-    int concurrency =
-        traits::execution_space::impl_thread_pool_size(0, m_space) /
-        m_team_alloc;
+    int concurrency = m_space.impl_thread_pool_size(0) / m_team_alloc;
     if (concurrency == 0) concurrency = 1;
 
     if (m_chunk_size > 0) {
diff --git a/core/src/OpenMP/Kokkos_OpenMP_UniqueToken.hpp b/core/src/OpenMP/Kokkos_OpenMP_UniqueToken.hpp
new file mode 100644
index 0000000000..a37e1758a2
--- /dev/null
+++ b/core/src/OpenMP/Kokkos_OpenMP_UniqueToken.hpp
@@ -0,0 +1,129 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMP_UNIQUE_TOKEN_HPP
+#define KOKKOS_OPENMP_UNIQUE_TOKEN_HPP
+
+#include <Kokkos_UniqueToken.hpp>
+
+namespace Kokkos::Experimental {
+template <>
+class UniqueToken<OpenMP, UniqueTokenScope::Instance> {
+ public:
+  using execution_space = OpenMP;
+  using size_type       = int;
+
+ private:
+  using buffer_type = Kokkos::View<uint32_t*, Kokkos::HostSpace>;
+  execution_space m_exec;
+  size_type m_count;
+  buffer_type m_buffer_view;
+  uint32_t volatile* m_buffer;
+
+ public:
+  /// \brief create object size for concurrency on the given instance
+  ///
+  /// This object should not be shared between instances
+  UniqueToken(execution_space const& exec = execution_space()) noexcept
+      : m_exec(exec),
+        m_count(m_exec.impl_thread_pool_size()),
+        m_buffer_view(buffer_type()),
+        m_buffer(nullptr) {}
+
+  UniqueToken(size_type max_size,
+              execution_space const& exec = execution_space())
+      : m_exec(exec),
+        m_count(max_size),
+        m_buffer_view("UniqueToken::m_buffer_view",
+                      ::Kokkos::Impl::concurrent_bitset::buffer_bound(m_count)),
+        m_buffer(m_buffer_view.data()) {}
+
+  /// \brief upper bound for acquired values, i.e. 0 <= value < size()
+  KOKKOS_INLINE_FUNCTION
+  int size() const noexcept {
+    KOKKOS_IF_ON_HOST((return m_count;))
+
+    KOKKOS_IF_ON_DEVICE((return 0;))
+  }
+
+  /// \brief acquire value such that 0 <= value < size()
+  KOKKOS_INLINE_FUNCTION
+  int acquire() const noexcept {
+    KOKKOS_IF_ON_HOST(
+        (if (m_count >= m_exec.impl_thread_pool_size()) return m_exec
+             .impl_thread_pool_rank();
+         const ::Kokkos::pair<int, int> result =
+             ::Kokkos::Impl::concurrent_bitset::acquire_bounded(
+                 m_buffer, m_count, ::Kokkos::Impl::clock_tic() % m_count);
+
+         if (result.first < 0) {
+           ::Kokkos::abort(
+               "UniqueToken<OpenMP> failure to acquire tokens, no tokens "
+               "available");
+         }
+
+         return result.first;))
+
+    KOKKOS_IF_ON_DEVICE((return 0;))
+  }
+
+  /// \brief release a value acquired by generate
+  KOKKOS_INLINE_FUNCTION
+  void release(int i) const noexcept {
+    KOKKOS_IF_ON_HOST((if (m_count < m_exec.impl_thread_pool_size()) {
+      ::Kokkos::Impl::concurrent_bitset::release(m_buffer, i);
+    }))
+
+    KOKKOS_IF_ON_DEVICE(((void)i;))
+  }
+};
+
+template <>
+class UniqueToken<OpenMP, UniqueTokenScope::Global> {
+ public:
+  using execution_space = OpenMP;
+  using size_type       = int;
+
+  /// \brief create object size for concurrency on the given instance
+  ///
+  /// This object should not be shared between instances
+  UniqueToken(execution_space const& = execution_space()) noexcept {}
+
+  /// \brief upper bound for acquired values, i.e. 0 <= value < size()
+  KOKKOS_INLINE_FUNCTION
+  int size() const noexcept {
+    KOKKOS_IF_ON_HOST((return Kokkos::Impl::g_openmp_hardware_max_threads;))
+
+    KOKKOS_IF_ON_DEVICE((return 0;))
+  }
+
+  /// \brief acquire value such that 0 <= value < size()
+  // FIXME this is wrong when using nested parallelism. In that case multiple
+  // threads have the same thread ID.
+  KOKKOS_INLINE_FUNCTION
+  int acquire() const noexcept {
+    KOKKOS_IF_ON_HOST((return omp_get_thread_num();))
+
+    KOKKOS_IF_ON_DEVICE((return 0;))
+  }
+
+  /// \brief release a value acquired by generate
+  KOKKOS_INLINE_FUNCTION
+  void release(int) const noexcept {}
+};
+}  // namespace Kokkos::Experimental
+
+#endif
diff --git a/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp b/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp
index 6cc52815de..a030a2b706 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_WorkGraphPolicy.hpp
@@ -17,7 +17,7 @@
 #ifndef KOKKOS_OPENMP_WORKGRAPHPOLICY_HPP
 #define KOKKOS_OPENMP_WORKGRAPHPOLICY_HPP
 
-#include <Kokkos_OpenMP.hpp>
+#include <OpenMP/Kokkos_OpenMP.hpp>
 
 namespace Kokkos {
 namespace Impl {
@@ -49,7 +49,8 @@ class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
     // We need to introduce pool_size to work around NVHPC 22.5 ICE
     // We need to use [[maybe_unused]] to work around an unused-variable warning
     // from HIP
-    [[maybe_unused]] int pool_size = OpenMP::impl_thread_pool_size();
+    OpenMP exec;
+    [[maybe_unused]] int pool_size = exec.impl_thread_pool_size();
 #pragma omp parallel num_threads(pool_size)
     {
       // Spin until COMPLETED_TOKEN.
diff --git a/core/src/Kokkos_OpenMPTarget.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp
similarity index 98%
rename from core/src/Kokkos_OpenMPTarget.hpp
rename to core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp
index 4bcfed90e3..adf972dd08 100644
--- a/core/src/Kokkos_OpenMPTarget.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp
@@ -30,7 +30,7 @@ static_assert(false,
 
 #include <cstddef>
 #include <iosfwd>
-#include <Kokkos_OpenMPTargetSpace.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp>
 #include <Kokkos_ScratchSpace.hpp>
 #include <Kokkos_Parallel.hpp>
 #include <Kokkos_TaskScheduler.hpp>
@@ -141,7 +141,6 @@ struct DeviceTypeTraits<::Kokkos::Experimental::OpenMPTarget> {
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
 
-#include <OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Task.hpp>
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
index f30abb0c87..81fbc56de0 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
@@ -33,8 +33,8 @@
 #include <sstream>
 #include <cstring>
 
-#include <Kokkos_OpenMPTarget.hpp>
-#include <Kokkos_OpenMPTargetSpace.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <Kokkos_Atomic.hpp>
 #include <impl/Kokkos_MemorySpace.hpp>
@@ -165,39 +165,6 @@ SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::
 }  // namespace Impl
 }  // namespace Kokkos
 
-/*--------------------------------------------------------------------------*/
-/*--------------------------------------------------------------------------*/
-/*
-namespace Kokkos {
-namespace {
-  const unsigned HOST_SPACE_ATOMIC_MASK = 0xFFFF;
-  const unsigned HOST_SPACE_ATOMIC_XOR_MASK = 0x5A39;
-  static int HOST_SPACE_ATOMIC_LOCKS[HOST_SPACE_ATOMIC_MASK+1];
-}
-
-namespace Impl {
-void init_lock_array_host_space() {
-  static int is_initialized = 0;
-  if(! is_initialized)
-    for(int i = 0; i < static_cast<int> (HOST_SPACE_ATOMIC_MASK+1); i++)
-      HOST_SPACE_ATOMIC_LOCKS[i] = 0;
-}
-
-bool lock_address_host_space(void* ptr) {
-  return 0 == atomic_compare_exchange( &HOST_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^
-HOST_SPACE_ATOMIC_XOR_MASK] , 0 , 1);
-}
-
-void unlock_address_host_space(void* ptr) {
-   atomic_exchange( &HOST_SPACE_ATOMIC_LOCKS[
-      (( size_t(ptr) >> 2 ) & HOST_SPACE_ATOMIC_MASK) ^
-HOST_SPACE_ATOMIC_XOR_MASK] , 0);
-}
-
-}
-}*/
-
 //==============================================================================
 // <editor-fold desc="Explicit instantiations of CRTP Base classes"> {{{1
 
diff --git a/core/src/Kokkos_OpenMPTargetSpace.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp
similarity index 89%
rename from core/src/Kokkos_OpenMPTargetSpace.hpp
rename to core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp
index ca015da379..e5b33d0982 100644
--- a/core/src/Kokkos_OpenMPTargetSpace.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp
@@ -35,37 +35,6 @@ static_assert(false,
 #include <Kokkos_HostSpace.hpp>
 #include <omp.h>
 
-/*--------------------------------------------------------------------------*/
-
-namespace Kokkos {
-namespace Impl {
-
-/// \brief Initialize lock array for arbitrary size atomics.
-///
-/// Arbitrary atomics are implemented using a hash table of locks
-/// where the hash value is derived from the address of the
-/// object for which an atomic operation is performed.
-/// This function initializes the locks to zero (unset).
-// void init_lock_array_host_space();
-
-/// \brief Acquire a lock for the address
-///
-/// This function tries to acquire the lock for the hash value derived
-/// from the provided ptr. If the lock is successfully acquired the
-/// function returns true. Otherwise it returns false.
-// bool lock_address_host_space(void* ptr);
-
-/// \brief Release lock for the address
-///
-/// This function releases the lock for the hash value derived
-/// from the provided ptr. This function should only be called
-/// after previously successfully acquiring a lock with
-/// lock_address.
-// void unlock_address_host_space(void* ptr);
-
-}  // namespace Impl
-}  // namespace Kokkos
-
 namespace Kokkos {
 namespace Impl {
 
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
index 40da73ebc6..f794f2fc52 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
@@ -67,13 +67,16 @@ void OpenMPTargetExec::verify_initialized(const char* const label) {
     msg.append(" ERROR: not initialized");
     Kokkos::Impl::throw_runtime_exception(msg);
   }
+  OpenMPTargetExec::MAX_ACTIVE_THREADS =
+      Kokkos::Experimental::OpenMPTarget().concurrency();
 }
 
 void* OpenMPTargetExec::m_scratch_ptr         = nullptr;
 int64_t OpenMPTargetExec::m_scratch_size      = 0;
 int* OpenMPTargetExec::m_lock_array           = nullptr;
-int64_t OpenMPTargetExec::m_lock_size         = 0;
+uint64_t OpenMPTargetExec::m_lock_size        = 0;
 uint32_t* OpenMPTargetExec::m_uniquetoken_ptr = nullptr;
+int OpenMPTargetExec::MAX_ACTIVE_THREADS      = 0;
 
 void OpenMPTargetExec::clear_scratch() {
   Kokkos::Experimental::OpenMPTargetSpace space;
@@ -100,11 +103,26 @@ void OpenMPTargetExec::resize_scratch(int64_t team_size, int64_t shmem_size_L0,
   const int64_t shmem_size =
       shmem_size_L0 + shmem_size_L1;  // L0 + L1 scratch memory per team.
   const int64_t padding = shmem_size * 10 / 100;  // Padding per team.
+
+  // Maximum active teams possible.
+  // The number should not exceed the maximum in-flight teams possible or the
+  // league_size.
+  int max_active_teams =
+      std::min(OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size, league_size);
+
+  // max_active_teams is the number of active teams on the given hardware.
+  // We set the number of teams to be twice the number of max_active_teams for
+  // the compiler to pick the right number in its case.
+  // FIXME_OPENMPTARGET: Cray compiler did not yet implement omp_set_num_teams.
+#if !defined(KOKKOS_COMPILER_CRAY_LLVM)
+  omp_set_num_teams(max_active_teams * 2);
+#endif
+
   // Total amount of scratch memory allocated is depenedent
   // on the maximum number of in-flight teams possible.
   int64_t total_size =
       (shmem_size + OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE + padding) *
-      std::min(MAX_ACTIVE_THREADS / team_size, league_size);
+      max_active_teams * 2;
 
   if (total_size > m_scratch_size) {
     space.deallocate(m_scratch_ptr, m_scratch_size);
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp
deleted file mode 100644
index 6d62a3c7e4..0000000000
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp
+++ /dev/null
@@ -1,1929 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_OPENMPTARGETEXEC_HPP
-#define KOKKOS_OPENMPTARGETEXEC_HPP
-
-#include <impl/Kokkos_Traits.hpp>
-#include <impl/Kokkos_Spinwait.hpp>
-
-#include <Kokkos_Atomic.hpp>
-#include "Kokkos_OpenMPTarget_Abort.hpp"
-
-// FIXME_OPENMPTARGET - Using this macro to implement a workaround for
-// hierarchical reducers. It avoids hitting the code path which we wanted to
-// write but doesn't work. undef'ed at the end.
-// Intel compilers prefer the non-workaround version.
-#ifndef KOKKOS_ARCH_INTEL_GPU
-#define KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
-#endif
-
-// FIXME_OPENMPTARGET - Using this macro to implement a workaround for
-// hierarchical scan. It avoids hitting the code path which we wanted to
-// write but doesn't work. undef'ed at the end.
-#ifndef KOKKOS_ARCH_INTEL_GPU
-#define KOKKOS_IMPL_TEAM_SCAN_WORKAROUND
-#endif
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template <class Reducer>
-struct OpenMPTargetReducerWrapper {
-  using value_type = typename Reducer::value_type;
-
-  // Using a generic unknown Reducer for the OpenMPTarget backend is not
-  // implemented.
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type&, const value_type&) = delete;
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type&, const volatile value_type&) = delete;
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type&) = delete;
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<Sum<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) { dest += src; }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest += src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::sum();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<Prod<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) { dest *= src; }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest *= src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::prod();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<Min<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src < dest) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src < dest) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::min();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<Max<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src > dest) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src > dest) dest = src;
-  }
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::max();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<LAnd<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest = dest && src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest = dest && src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::land();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<LOr<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  using result_view_type = Kokkos::View<value_type, Space>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest = dest || src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest = dest || src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::lor();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<BAnd<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest = dest & src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest = dest & src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::band();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<BOr<Scalar, Space>> {
- public:
-  // Required
-  using value_type = std::remove_cv_t<Scalar>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest = dest | src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest = dest | src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val = reduction_identity<value_type>::bor();
-  }
-};
-
-template <class Scalar, class Index, class Space>
-struct OpenMPTargetReducerWrapper<MinLoc<Scalar, Index, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-  using index_type  = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = ValLocScalar<scalar_type, index_type>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src.val < dest.val) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src.val < dest.val) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.val = reduction_identity<scalar_type>::min();
-    val.loc = reduction_identity<index_type>::min();
-  }
-};
-
-template <class Scalar, class Index, class Space>
-struct OpenMPTargetReducerWrapper<MaxLoc<Scalar, Index, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-  using index_type  = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = ValLocScalar<scalar_type, index_type>;
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src.val > dest.val) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src.val > dest.val) dest = src;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.val = reduction_identity<scalar_type>::max();
-    val.loc = reduction_identity<index_type>::min();
-  }
-};
-
-template <class Scalar, class Space>
-struct OpenMPTargetReducerWrapper<MinMax<Scalar, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-
- public:
-  // Required
-  using value_type = MinMaxScalar<scalar_type>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src.min_val < dest.min_val) {
-      dest.min_val = src.min_val;
-    }
-    if (src.max_val > dest.max_val) {
-      dest.max_val = src.max_val;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src.min_val < dest.min_val) {
-      dest.min_val = src.min_val;
-    }
-    if (src.max_val > dest.max_val) {
-      dest.max_val = src.max_val;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.max_val = reduction_identity<scalar_type>::max();
-    val.min_val = reduction_identity<scalar_type>::min();
-  }
-};
-
-template <class Scalar, class Index, class Space>
-struct OpenMPTargetReducerWrapper<MinMaxLoc<Scalar, Index, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-  using index_type  = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = MinMaxLocScalar<scalar_type, index_type>;
-
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src.min_val < dest.min_val) {
-      dest.min_val = src.min_val;
-      dest.min_loc = src.min_loc;
-    }
-    if (src.max_val > dest.max_val) {
-      dest.max_val = src.max_val;
-      dest.max_loc = src.max_loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src.min_val < dest.min_val) {
-      dest.min_val = src.min_val;
-      dest.min_loc = src.min_loc;
-    }
-    if (src.max_val > dest.max_val) {
-      dest.max_val = src.max_val;
-      dest.max_loc = src.max_loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.max_val = reduction_identity<scalar_type>::max();
-    val.min_val = reduction_identity<scalar_type>::min();
-    val.max_loc = reduction_identity<index_type>::min();
-    val.min_loc = reduction_identity<index_type>::min();
-  }
-};
-
-//
-// specialize for MaxFirstLoc
-//
-template <class Scalar, class Index, class Space>
-struct OpenMPTargetReducerWrapper<MaxFirstLoc<Scalar, Index, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-  using index_type  = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = ValLocScalar<scalar_type, index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (dest.val < src.val) {
-      dest = src;
-    } else if (!(src.val < dest.val)) {
-      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (dest.val < src.val) {
-      dest = src;
-    } else if (!(src.val < dest.val)) {
-      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.val = reduction_identity<scalar_type>::max();
-    val.loc = reduction_identity<index_type>::min();
-  }
-#pragma omp end declare target
-};
-
-//
-// specialize for MinFirstLoc
-//
-template <class Scalar, class Index, class Space>
-struct OpenMPTargetReducerWrapper<MinFirstLoc<Scalar, Index, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-  using index_type  = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = ValLocScalar<scalar_type, index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src.val < dest.val) {
-      dest = src;
-    } else if (!(dest.val < src.val)) {
-      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src.val < dest.val) {
-      dest = src;
-    } else if (!(dest.val < src.val)) {
-      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.val = reduction_identity<scalar_type>::min();
-    val.loc = reduction_identity<index_type>::min();
-  }
-#pragma omp end declare target
-};
-
-//
-// specialize for MinMaxFirstLastLoc
-//
-template <class Scalar, class Index, class Space>
-struct OpenMPTargetReducerWrapper<MinMaxFirstLastLoc<Scalar, Index, Space>> {
- private:
-  using scalar_type = std::remove_cv_t<Scalar>;
-  using index_type  = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = MinMaxLocScalar<scalar_type, index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    if (src.min_val < dest.min_val) {
-      dest.min_val = src.min_val;
-      dest.min_loc = src.min_loc;
-    } else if (!(dest.min_val < src.min_val)) {
-      dest.min_loc = (src.min_loc < dest.min_loc) ? src.min_loc : dest.min_loc;
-    }
-
-    if (dest.max_val < src.max_val) {
-      dest.max_val = src.max_val;
-      dest.max_loc = src.max_loc;
-    } else if (!(src.max_val < dest.max_val)) {
-      dest.max_loc = (src.max_loc > dest.max_loc) ? src.max_loc : dest.max_loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    if (src.min_val < dest.min_val) {
-      dest.min_val = src.min_val;
-      dest.min_loc = src.min_loc;
-    } else if (!(dest.min_val < src.min_val)) {
-      dest.min_loc = (src.min_loc < dest.min_loc) ? src.min_loc : dest.min_loc;
-    }
-
-    if (dest.max_val < src.max_val) {
-      dest.max_val = src.max_val;
-      dest.max_loc = src.max_loc;
-    } else if (!(src.max_val < dest.max_val)) {
-      dest.max_loc = (src.max_loc > dest.max_loc) ? src.max_loc : dest.max_loc;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.max_val = reduction_identity<scalar_type>::max();
-    val.min_val = reduction_identity<scalar_type>::min();
-    val.max_loc = reduction_identity<index_type>::max();
-    val.min_loc = reduction_identity<index_type>::min();
-  }
-#pragma omp end declare target
-};
-
-//
-// specialize for FirstLoc
-//
-template <class Index, class Space>
-struct OpenMPTargetReducerWrapper<FirstLoc<Index, Space>> {
- private:
-  using index_type = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = FirstLocScalar<index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest.min_loc_true = (src.min_loc_true < dest.min_loc_true)
-                            ? src.min_loc_true
-                            : dest.min_loc_true;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest.min_loc_true = (src.min_loc_true < dest.min_loc_true)
-                            ? src.min_loc_true
-                            : dest.min_loc_true;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.min_loc_true = reduction_identity<index_type>::min();
-  }
-#pragma omp end declare target
-};
-
-//
-// specialize for LastLoc
-//
-template <class Index, class Space>
-struct OpenMPTargetReducerWrapper<LastLoc<Index, Space>> {
- private:
-  using index_type = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = LastLocScalar<index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest.max_loc_true = (src.max_loc_true > dest.max_loc_true)
-                            ? src.max_loc_true
-                            : dest.max_loc_true;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest.max_loc_true = (src.max_loc_true > dest.max_loc_true)
-                            ? src.max_loc_true
-                            : dest.max_loc_true;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.max_loc_true = reduction_identity<index_type>::max();
-  }
-#pragma omp end declare target
-};
-
-//
-// specialize for StdIsPartitioned
-//
-template <class Index, class Space>
-struct OpenMPTargetReducerWrapper<StdIsPartitioned<Index, Space>> {
- private:
-  using index_type = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = StdIsPartScalar<index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest.max_loc_true = (dest.max_loc_true < src.max_loc_true)
-                            ? src.max_loc_true
-                            : dest.max_loc_true;
-
-    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
-                             ? dest.min_loc_false
-                             : src.min_loc_false;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest.max_loc_true = (dest.max_loc_true < src.max_loc_true)
-                            ? src.max_loc_true
-                            : dest.max_loc_true;
-
-    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
-                             ? dest.min_loc_false
-                             : src.min_loc_false;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.max_loc_true  = ::Kokkos::reduction_identity<index_type>::max();
-    val.min_loc_false = ::Kokkos::reduction_identity<index_type>::min();
-  }
-#pragma omp end declare target
-};
-
-//
-// specialize for StdPartitionPoint
-//
-template <class Index, class Space>
-struct OpenMPTargetReducerWrapper<StdPartitionPoint<Index, Space>> {
- private:
-  using index_type = std::remove_cv_t<Index>;
-
- public:
-  // Required
-  using value_type = StdPartPointScalar<index_type>;
-
-// WORKAROUND OPENMPTARGET
-// This pragma omp declare target should not be necessary, but Intel compiler
-// fails without it
-#pragma omp declare target
-  // Required
-  KOKKOS_INLINE_FUNCTION
-  static void join(value_type& dest, const value_type& src) {
-    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
-                             ? dest.min_loc_false
-                             : src.min_loc_false;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void join(volatile value_type& dest, const volatile value_type& src) {
-    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
-                             ? dest.min_loc_false
-                             : src.min_loc_false;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  static void init(value_type& val) {
-    val.min_loc_false = ::Kokkos::reduction_identity<index_type>::min();
-  }
-#pragma omp end declare target
-};
-
-/*
-template<class ReducerType>
-class OpenMPTargetReducerWrapper {
-  public:
-    const ReducerType& reducer;
-    using value_type = typename ReducerType::value_type;
-    value_type& value;
-
-    KOKKOS_INLINE_FUNCTION
-    void join(const value_type& upd) {
-      reducer.join(value,upd);
-    }
-
-    KOKKOS_INLINE_FUNCTION
-    void init(const value_type& upd) {
-      reducer.init(value,upd);
-    }
-};*/
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-namespace Impl {
-
-//----------------------------------------------------------------------------
-/** \brief  Data for OpenMPTarget thread execution */
-
-class OpenMPTargetExec {
- public:
-  // FIXME_OPENMPTARGET - Currently the maximum number of
-  // teams possible is calculated based on NVIDIA's Volta GPU. In
-  // future this value should be based on the chosen architecture for the
-  // OpenMPTarget backend.
-  static constexpr int MAX_ACTIVE_THREADS = 2080 * 80;
-  static constexpr int MAX_ACTIVE_TEAMS   = MAX_ACTIVE_THREADS / 32;
-
- private:
-  static void* scratch_ptr;
-
- public:
-  static void verify_is_process(const char* const);
-  static void verify_initialized(const char* const);
-
-  static int* get_lock_array(int num_teams);
-  static void* get_scratch_ptr();
-  static void clear_scratch();
-  static void clear_lock_array();
-  static void resize_scratch(int64_t team_reduce_bytes,
-                             int64_t team_shared_bytes,
-                             int64_t thread_local_bytes, int64_t league_size);
-
-  static void* m_scratch_ptr;
-  static int64_t m_scratch_size;
-  static int* m_lock_array;
-  static int64_t m_lock_size;
-  static uint32_t* m_uniquetoken_ptr;
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-class OpenMPTargetExecTeamMember {
- public:
-  static constexpr int TEAM_REDUCE_SIZE = 512;
-
-  using execution_space      = Kokkos::Experimental::OpenMPTarget;
-  using scratch_memory_space = execution_space::scratch_memory_space;
-  using team_handle          = OpenMPTargetExecTeamMember;
-
-  scratch_memory_space m_team_shared;
-  size_t m_team_scratch_size[2];
-  int m_team_rank;
-  int m_team_size;
-  int m_league_rank;
-  int m_league_size;
-  int m_vector_length;
-  int m_vector_lane;
-  int m_shmem_block_index;
-  void* m_glb_scratch;
-  void* m_reduce_scratch;
-
- public:
-  KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space& team_shmem() const {
-    return m_team_shared.set_team_thread_mode(0, 1, 0);
-  }
-
-  // set_team_thread_mode routine parameters for future understanding:
-  // first parameter - scratch level.
-  // second parameter - size multiplier for advancing scratch ptr after a
-  // request was serviced. third parameter - offset size multiplier from current
-  // scratch ptr when returning a ptr for a request.
-  KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space& team_scratch(int level) const {
-    return m_team_shared.set_team_thread_mode(level, 1, 0);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  const execution_space::scratch_memory_space& thread_scratch(int level) const {
-    return m_team_shared.set_team_thread_mode(level, team_size(), team_rank());
-  }
-
-  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank; }
-  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
-  KOKKOS_INLINE_FUNCTION int team_rank() const { return m_team_rank; }
-  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
-  KOKKOS_INLINE_FUNCTION void* impl_reduce_scratch() const {
-    return m_reduce_scratch;
-  }
-
-  KOKKOS_INLINE_FUNCTION void team_barrier() const {
-#pragma omp barrier
-  }
-
-  template <class ValueType>
-  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType& value,
-                                             int thread_id) const {
-    // Make sure there is enough scratch space:
-    using type = std::conditional_t<(sizeof(ValueType) < TEAM_REDUCE_SIZE),
-                                    ValueType, void>;
-    type* team_scratch =
-        reinterpret_cast<type*>(static_cast<char*>(m_glb_scratch) +
-                                TEAM_REDUCE_SIZE * omp_get_team_num());
-#pragma omp barrier
-    if (team_rank() == thread_id) *team_scratch = value;
-#pragma omp barrier
-    value = *team_scratch;
-  }
-
-  template <class Closure, class ValueType>
-  KOKKOS_INLINE_FUNCTION void team_broadcast(const Closure& f, ValueType& value,
-                                             const int& thread_id) const {
-    f(value);
-    team_broadcast(value, thread_id);
-  }
-
-  // FIXME_OPENMPTARGET this function has the wrong interface and currently
-  // ignores the reducer passed.
-  template <class ValueType, class JoinOp>
-  KOKKOS_INLINE_FUNCTION ValueType team_reduce(const ValueType& value,
-                                               const JoinOp&) const {
-#pragma omp barrier
-
-    using value_type = ValueType;
-    //    const JoinLambdaAdapter<value_type, JoinOp> op(op_in);
-
-    // Make sure there is enough scratch space:
-    using type = std::conditional_t<(sizeof(value_type) < TEAM_REDUCE_SIZE),
-                                    value_type, void>;
-
-    const int n_values = TEAM_REDUCE_SIZE / sizeof(value_type);
-    type* team_scratch =
-        reinterpret_cast<type*>(static_cast<char*>(m_glb_scratch) +
-                                TEAM_REDUCE_SIZE * omp_get_team_num());
-    for (int i = m_team_rank; i < n_values; i += m_team_size) {
-      team_scratch[i] = value_type();
-    }
-
-#pragma omp barrier
-
-    for (int k = 0; k < m_team_size; k += n_values) {
-      if ((k <= m_team_rank) && (k + n_values > m_team_rank))
-        team_scratch[m_team_rank % n_values] += value;
-#pragma omp barrier
-    }
-
-    for (int d = 1; d < n_values; d *= 2) {
-      if ((m_team_rank + d < n_values) && (m_team_rank % (2 * d) == 0)) {
-        team_scratch[m_team_rank] += team_scratch[m_team_rank + d];
-      }
-#pragma omp barrier
-    }
-    return team_scratch[0];
-  }
-  /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
-   *          with intra-team non-deterministic ordering accumulation.
-   *
-   *  The global inter-team accumulation value will, at the end of the
-   *  league's parallel execution, be the scan's total.
-   *  Parallel execution ordering of the league's teams is non-deterministic.
-   *  As such the base value for each team's scan operation is similarly
-   *  non-deterministic.
-   */
-  template <typename ArgType>
-  KOKKOS_INLINE_FUNCTION ArgType
-  team_scan(const ArgType& /*value*/, ArgType* const /*global_accum*/) const {
-    // FIXME_OPENMPTARGET
-    /*  // Make sure there is enough scratch space:
-      using type =
-        std::conditional_t<(sizeof(ArgType) < TEAM_REDUCE_SIZE), ArgType, void>;
-
-      volatile type * const work_value  = ((type*) m_exec.scratch_thread());
-
-      *work_value = value ;
-
-      memory_fence();
-
-      if ( team_fan_in() ) {
-        // The last thread to synchronize returns true, all other threads wait
-      for team_fan_out()
-        // m_team_base[0]                 == highest ranking team member
-        // m_team_base[ m_team_size - 1 ] == lowest ranking team member
-        //
-        // 1) copy from lower to higher rank, initialize lowest rank to zero
-        // 2) prefix sum from lowest to highest rank, skipping lowest rank
-
-        type accum = 0 ;
-
-        if ( global_accum ) {
-          for ( int i = m_team_size ; i-- ; ) {
-            type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i
-      )->scratch_thread()); accum += val ;
-          }
-          accum = atomic_fetch_add( global_accum , accum );
-        }
-
-        for ( int i = m_team_size ; i-- ; ) {
-          type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i
-      )->scratch_thread()); const type offset = accum ; accum += val ; val =
-      offset ;
-        }
-
-        memory_fence();
-      }
-
-      team_fan_out();
-
-      return *work_value ;*/
-    return ArgType();
-  }
-
-  /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
-   *
-   *  The highest rank thread can compute the reduction total as
-   *    reduction_total = dev.team_scan( value ) + value ;
-   */
-  template <typename Type>
-  KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value) const {
-    return this->template team_scan<Type>(value, 0);
-  }
-
-  //----------------------------------------
-  // Private for the driver
-
- private:
-  using space = execution_space::scratch_memory_space;
-
- public:
-  // FIXME_OPENMPTARGET - 512(16*32) bytes at the begining of the scratch space
-  // for each league is saved for reduction. It should actually be based on the
-  // ValueType of the reduction variable.
-  inline OpenMPTargetExecTeamMember(
-      const int league_rank, const int league_size, const int team_size,
-      const int vector_length  // const TeamPolicyInternal< OpenMPTarget,
-                               // Properties ...> & team
-      ,
-      void* const glb_scratch, const int shmem_block_index,
-      const size_t shmem_size_L0, const size_t shmem_size_L1)
-      : m_team_scratch_size{shmem_size_L0, shmem_size_L1},
-        m_team_rank(0),
-        m_team_size(team_size),
-        m_league_rank(league_rank),
-        m_league_size(league_size),
-        m_vector_length(vector_length),
-        m_shmem_block_index(shmem_block_index),
-        m_glb_scratch(glb_scratch) {
-    const int omp_tid = omp_get_thread_num();
-
-    // The scratch memory allocated is a sum of TEAM_REDUCE_SIZE, L0 shmem size
-    // and L1 shmem size. TEAM_REDUCE_SIZE = 512 bytes saved per team for
-    // hierarchical reduction. There is an additional 10% of the requested
-    // scratch memory allocated per team as padding. Hence the product with 0.1.
-    const int reduce_offset =
-        m_shmem_block_index *
-        (shmem_size_L0 + shmem_size_L1 +
-         ((shmem_size_L0 + shmem_size_L1) * 0.1) + TEAM_REDUCE_SIZE);
-    const int l0_offset = reduce_offset + TEAM_REDUCE_SIZE;
-    const int l1_offset = l0_offset + shmem_size_L0;
-    m_team_shared       = scratch_memory_space(
-        (static_cast<char*>(glb_scratch) + l0_offset), shmem_size_L0,
-        static_cast<char*>(glb_scratch) + l1_offset, shmem_size_L1);
-    m_reduce_scratch = static_cast<char*>(glb_scratch) + reduce_offset;
-    m_league_rank    = league_rank;
-    m_team_rank      = omp_tid;
-    m_vector_lane    = 0;
-  }
-
-  static inline int team_reduce_size() { return TEAM_REDUCE_SIZE; }
-};
-
-template <class... Properties>
-class TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget, Properties...>
-    : public PolicyTraits<Properties...> {
- public:
-  //! Tag this class as a kokkos execution policy
-  using execution_policy = TeamPolicyInternal;
-
-  using traits = PolicyTraits<Properties...>;
-
-  //----------------------------------------
-
-  template <class FunctorType>
-  inline static int team_size_max(const FunctorType&, const ParallelForTag&) {
-    return 256;
-  }
-
-  template <class FunctorType>
-  inline static int team_size_max(const FunctorType&,
-                                  const ParallelReduceTag&) {
-    return 256;
-  }
-
-  template <class FunctorType, class ReducerType>
-  inline static int team_size_max(const FunctorType&, const ReducerType&,
-                                  const ParallelReduceTag&) {
-    return 256;
-  }
-
-  template <class FunctorType>
-  inline static int team_size_recommended(const FunctorType&,
-                                          const ParallelForTag&) {
-    return 128;
-  }
-
-  template <class FunctorType>
-  inline static int team_size_recommended(const FunctorType&,
-                                          const ParallelReduceTag&) {
-    return 128;
-  }
-
-  template <class FunctorType, class ReducerType>
-  inline static int team_size_recommended(const FunctorType&,
-                                          const ReducerType&,
-                                          const ParallelReduceTag&) {
-    return 128;
-  }
-
-  //----------------------------------------
-
- private:
-  int m_league_size;
-  int m_team_size;
-  int m_vector_length;
-  int m_team_alloc;
-  int m_team_iter;
-  std::array<size_t, 2> m_team_scratch_size;
-  std::array<size_t, 2> m_thread_scratch_size;
-  bool m_tune_team_size;
-  bool m_tune_vector_length;
-  constexpr const static size_t default_team_size = 256;
-  int m_chunk_size;
-
-  inline void init(const int league_size_request, const int team_size_request,
-                   const int vector_length_request) {
-    m_league_size = league_size_request;
-
-    // Minimum team size should be 32 for OpenMPTarget backend.
-    if (team_size_request < 32) {
-      Kokkos::Impl::OpenMPTarget_abort(
-          "OpenMPTarget backend requires a minimum of 32 threads per team.\n");
-    } else
-      m_team_size = team_size_request;
-
-    m_vector_length = vector_length_request;
-    set_auto_chunk_size();
-  }
-
-  template <typename ExecSpace, typename... OtherProperties>
-  friend class TeamPolicyInternal;
-
- public:
-  // FIXME_OPENMPTARGET : Currently this routine is a copy of the Cuda
-  // implementation, but this has to be tailored to be architecture specific.
-  inline static int scratch_size_max(int level) {
-    return (
-        level == 0 ? 1024 * 40 :  // 48kB is the max for CUDA, but we need some
-                                  // for team_member.reduce etc.
-            20 * 1024 *
-                1024);  // arbitrarily setting this to 20MB, for a Volta V100
-                        // that would give us about 3.2GB for 2 teams per SM
-  }
-  inline bool impl_auto_team_size() const { return m_tune_team_size; }
-  inline bool impl_auto_vector_length() const { return m_tune_vector_length; }
-  inline void impl_set_team_size(const size_t size) { m_team_size = size; }
-  inline void impl_set_vector_length(const size_t length) {
-    m_tune_vector_length = length;
-  }
-  inline int impl_vector_length() const { return m_vector_length; }
-  inline int team_size() const { return m_team_size; }
-  inline int league_size() const { return m_league_size; }
-  inline size_t scratch_size(const int& level, int team_size_ = -1) const {
-    if (team_size_ < 0) team_size_ = m_team_size;
-    return m_team_scratch_size[level] +
-           team_size_ * m_thread_scratch_size[level];
-  }
-
-  inline Kokkos::Experimental::OpenMPTarget space() const {
-    return Kokkos::Experimental::OpenMPTarget();
-  }
-
-  template <class... OtherProperties>
-  TeamPolicyInternal(const TeamPolicyInternal<OtherProperties...>& p)
-      : m_league_size(p.m_league_size),
-        m_team_size(p.m_team_size),
-        m_vector_length(p.m_vector_length),
-        m_team_alloc(p.m_team_alloc),
-        m_team_iter(p.m_team_iter),
-        m_team_scratch_size(p.m_team_scratch_size),
-        m_thread_scratch_size(p.m_thread_scratch_size),
-        m_tune_team_size(p.m_tune_team_size),
-        m_tune_vector_length(p.m_tune_vector_length),
-        m_chunk_size(p.m_chunk_size) {}
-
-  /** \brief  Specify league size, request team size */
-  TeamPolicyInternal(const typename traits::execution_space&,
-                     int league_size_request, int team_size_request,
-                     int vector_length_request = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(false),
-        m_tune_vector_length(false),
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request, vector_length_request);
-  }
-
-  TeamPolicyInternal(const typename traits::execution_space&,
-                     int league_size_request,
-                     const Kokkos::AUTO_t& /* team_size_request */
-                     ,
-                     int vector_length_request = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(true),
-        m_tune_vector_length(false),
-        m_chunk_size(0) {
-    init(league_size_request, default_team_size / vector_length_request,
-         vector_length_request);
-  }
-
-  TeamPolicyInternal(const typename traits::execution_space&,
-                     int league_size_request,
-                     const Kokkos::AUTO_t& /* team_size_request */
-                     ,
-                     const Kokkos::AUTO_t& /* vector_length_request */)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(true),
-        m_tune_vector_length(true),
-        m_chunk_size(0) {
-    init(league_size_request, default_team_size, 1);
-  }
-  TeamPolicyInternal(const typename traits::execution_space&,
-                     int league_size_request, int team_size_request,
-                     const Kokkos::AUTO_t& /* vector_length_request */)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(false),
-        m_tune_vector_length(true),
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request, 1);
-  }
-
-  TeamPolicyInternal(int league_size_request, int team_size_request,
-                     int vector_length_request = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(false),
-        m_tune_vector_length(false),
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request, vector_length_request);
-  }
-
-  TeamPolicyInternal(int league_size_request,
-                     const Kokkos::AUTO_t& /* team_size_request */
-                     ,
-                     int vector_length_request = 1)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(true),
-        m_tune_vector_length(false),
-        m_chunk_size(0) {
-    init(league_size_request, default_team_size / vector_length_request,
-         vector_length_request);
-  }
-
-  TeamPolicyInternal(int league_size_request,
-                     const Kokkos::AUTO_t& /* team_size_request */
-                     ,
-                     const Kokkos::AUTO_t& /* vector_length_request */)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(true),
-        m_tune_vector_length(true),
-        m_chunk_size(0) {
-    init(league_size_request, default_team_size, 1);
-  }
-  TeamPolicyInternal(int league_size_request, int team_size_request,
-                     const Kokkos::AUTO_t& /* vector_length_request */)
-      : m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_tune_team_size(false),
-        m_tune_vector_length(true),
-        m_chunk_size(0) {
-    init(league_size_request, team_size_request, 1);
-  }
-  inline static size_t vector_length_max() {
-    return 32; /* TODO: this is bad. Need logic that is compiler and backend
-                  aware */
-  }
-  inline int team_alloc() const { return m_team_alloc; }
-  inline int team_iter() const { return m_team_iter; }
-
-  inline int chunk_size() const { return m_chunk_size; }
-
-  /** \brief set chunk_size to a discrete value*/
-  inline TeamPolicyInternal& set_chunk_size(
-      typename traits::index_type chunk_size_) {
-    m_chunk_size = chunk_size_;
-    return *this;
-  }
-
-  /** \brief set per team scratch size for a specific level of the scratch
-   * hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(const int& level,
-                                              const PerTeamValue& per_team) {
-    m_team_scratch_size[level] = per_team.value;
-    return *this;
-  }
-
-  /** \brief set per thread scratch size for a specific level of the scratch
-   * hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(
-      const int& level, const PerThreadValue& per_thread) {
-    m_thread_scratch_size[level] = per_thread.value;
-    return *this;
-  }
-
-  /** \brief set per thread and per team scratch size for a specific level of
-   * the scratch hierarchy */
-  inline TeamPolicyInternal& set_scratch_size(
-      const int& level, const PerTeamValue& per_team,
-      const PerThreadValue& per_thread) {
-    m_team_scratch_size[level]   = per_team.value;
-    m_thread_scratch_size[level] = per_thread.value;
-    return *this;
-  }
-
- private:
-  /** \brief finalize chunk_size if it was set to AUTO*/
-  inline void set_auto_chunk_size() {
-    int concurrency = 2048 * 128;
-
-    if (concurrency == 0) concurrency = 1;
-
-    if (m_chunk_size > 0) {
-      if (!Impl::is_integral_power_of_two(m_chunk_size))
-        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
-    }
-
-    int new_chunk_size = 1;
-    while (new_chunk_size * 100 * concurrency < m_league_size)
-      new_chunk_size *= 2;
-    if (new_chunk_size < 128) {
-      new_chunk_size = 1;
-      while ((new_chunk_size * 40 * concurrency < m_league_size) &&
-             (new_chunk_size < 128))
-        new_chunk_size *= 2;
-    }
-    m_chunk_size = new_chunk_size;
-  }
-
- public:
-  using member_type = Impl::OpenMPTargetExecTeamMember;
-};
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-namespace Kokkos {
-
-template <typename iType>
-KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
-    iType, Impl::OpenMPTargetExecTeamMember>
-TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread,
-                const iType& count) {
-  return Impl::TeamThreadRangeBoundariesStruct<
-      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
-}
-
-template <typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
-    std::common_type_t<iType1, iType2>, Impl::OpenMPTargetExecTeamMember>
-TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread,
-                const iType1& begin, const iType2& end) {
-  using iType = std::common_type_t<iType1, iType2>;
-  return Impl::TeamThreadRangeBoundariesStruct<
-      iType, Impl::OpenMPTargetExecTeamMember>(thread, iType(begin),
-                                               iType(end));
-}
-
-template <typename iType>
-KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
-    iType, Impl::OpenMPTargetExecTeamMember>
-ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
-                  const iType& count) {
-  return Impl::ThreadVectorRangeBoundariesStruct<
-      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
-}
-
-template <typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
-    std::common_type_t<iType1, iType2>, Impl::OpenMPTargetExecTeamMember>
-ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
-                  const iType1& arg_begin, const iType2& arg_end) {
-  using iType = std::common_type_t<iType1, iType2>;
-  return Impl::ThreadVectorRangeBoundariesStruct<
-      iType, Impl::OpenMPTargetExecTeamMember>(thread, iType(arg_begin),
-                                               iType(arg_end));
-}
-
-template <typename iType>
-KOKKOS_INLINE_FUNCTION Impl::TeamVectorRangeBoundariesStruct<
-    iType, Impl::OpenMPTargetExecTeamMember>
-TeamVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
-                const iType& count) {
-  return Impl::TeamVectorRangeBoundariesStruct<
-      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
-}
-
-template <typename iType1, typename iType2>
-KOKKOS_INLINE_FUNCTION Impl::TeamVectorRangeBoundariesStruct<
-    std::common_type_t<iType1, iType2>, Impl::OpenMPTargetExecTeamMember>
-TeamVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
-                const iType1& arg_begin, const iType2& arg_end) {
-  using iType = std::common_type_t<iType1, iType2>;
-  return Impl::TeamVectorRangeBoundariesStruct<
-      iType, Impl::OpenMPTargetExecTeamMember>(thread, iType(arg_begin),
-                                               iType(arg_end));
-}
-
-KOKKOS_INLINE_FUNCTION
-Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember> PerTeam(
-    const Impl::OpenMPTargetExecTeamMember& thread) {
-  return Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>(thread);
-}
-
-KOKKOS_INLINE_FUNCTION
-Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember> PerThread(
-    const Impl::OpenMPTargetExecTeamMember& thread) {
-  return Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>(thread);
-}
-}  // namespace Kokkos
-
-namespace Kokkos {
-
-/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
- * i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team.
- */
-template <typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION void parallel_for(
-    const Impl::TeamThreadRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda) {
-#pragma omp for nowait schedule(static, 1)
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) lambda(i);
-}
-
-/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all threads of the the calling thread team
- * and a summation of val is performed and put into result.
- */
-
-template <typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<!Kokkos::is_reducer<ValueType>::value>
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
-                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                const Lambda& lambda, ValueType& result) {
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-  ValueType* TeamThread_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-#pragma omp barrier
-  TeamThread_scratch[0] = ValueType();
-#pragma omp barrier
-
-  if constexpr (std::is_arithmetic<ValueType>::value) {
-#pragma omp for reduction(+ : TeamThread_scratch[:1])
-    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-      ValueType tmp = ValueType();
-      lambda(i, tmp);
-      TeamThread_scratch[0] += tmp;
-    }
-  } else {
-#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
-
-#pragma omp for reduction(custom : TeamThread_scratch[:1])
-    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-      ValueType tmp = ValueType();
-      lambda(i, tmp);
-      TeamThread_scratch[0] += tmp;
-    }
-  }
-
-  result = TeamThread_scratch[0];
-}
-
-#if !defined(KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND)
-// For some reason the actual version we wanted to write doesn't work
-// and crashes. We should try this with every new compiler
-// This is the variant we actually wanted to write
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
-                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                const Lambda& lambda, ReducerType result) {
-  using ValueType = typename ReducerType::value_type;
-
-#pragma omp declare reduction(                                               \
-    custominner:ValueType                                                    \
-    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(                                                             \
-        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-  ValueType* TeamThread_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-#pragma omp barrier
-  Impl::OpenMPTargetReducerWrapper<ReducerType>::init(TeamThread_scratch[0]);
-#pragma omp barrier
-
-#pragma omp for reduction(custominner : TeamThread_scratch[:1])
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-    lambda(i, TeamThread_scratch[0]);
-  }
-  result.reference() = TeamThread_scratch[0];
-}
-#else
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
-parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
-                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                const Lambda& lambda, ReducerType result) {
-  using ValueType = typename ReducerType::value_type;
-
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-  ValueType* TeamThread_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-#pragma omp declare reduction(                                               \
-    omp_red_teamthread_reducer:ValueType                                     \
-    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(                                                             \
-        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-#pragma omp barrier
-  ValueType tmp;
-  result.init(tmp);
-  TeamThread_scratch[0] = tmp;
-#pragma omp barrier
-
-  iType team_size = iType(omp_get_num_threads());
-#pragma omp for reduction(omp_red_teamthread_reducer \
-                          : TeamThread_scratch[:1]) schedule(static, 1)
-  for (iType t = 0; t < team_size; t++) {
-    ValueType tmp2;
-    result.init(tmp2);
-
-    for (iType i = loop_boundaries.start + t; i < loop_boundaries.end;
-         i += team_size) {
-      lambda(i, tmp2);
-    }
-
-    // FIXME_OPENMPTARGET: Join should work but doesn't. Every threads gets a
-    // private TeamThread_scratch[0] and at the end of the for-loop the `join`
-    // operation is performed by OpenMP itself and hence the simple assignment
-    // works.
-    //    result.join(TeamThread_scratch[0], tmp2);
-    TeamThread_scratch[0] = tmp2;
-  }
-
-  result.reference() = TeamThread_scratch[0];
-}
-#endif  // KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
-
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
- * and a reduction of val is performed using JoinType(ValueType& val, const
- * ValueType& update) and put into init_result. The input value of init_result
- * is used as initializer for temporary variables of ValueType. Therefore the
- * input value should be the neutral element with respect to the join operation
- * (e.g. '0 for +-' or '1 for *').
- */
-template <typename iType, class Lambda, typename ValueType, class JoinType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::TeamThreadRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
-  ValueType* TeamThread_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-  // FIXME_OPENMPTARGET: Still need to figure out how to get value_count here.
-  const int value_count = 1;
-
-#pragma omp barrier
-  TeamThread_scratch[0] = init_result;
-#pragma omp barrier
-
-#pragma omp for
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-    lambda(i, TeamThread_scratch[omp_get_num_threads() * value_count]);
-  }
-
-  // Reduce all partial results within a team.
-  const int team_size      = omp_get_num_threads();
-  int tree_neighbor_offset = 1;
-  do {
-#pragma omp for
-    for (int i = 0; i < team_size - tree_neighbor_offset;
-         i += 2 * tree_neighbor_offset) {
-      const int neighbor = i + tree_neighbor_offset;
-      join(lambda, &TeamThread_scratch[i * value_count],
-           &TeamThread_scratch[neighbor * value_count]);
-    }
-    tree_neighbor_offset *= 2;
-  } while (tree_neighbor_offset < team_size);
-  init_result = TeamThread_scratch[0];
-}
-
-// This is largely the same code as in HIP and CUDA except for the member name
-template <typename iType, class FunctorType>
-KOKKOS_INLINE_FUNCTION void parallel_scan(
-    const Impl::TeamThreadRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_bounds,
-    const FunctorType& lambda) {
-  using Analysis   = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         TeamPolicy<Experimental::OpenMPTarget>,
-                                         FunctorType>;
-  using value_type = typename Analysis::value_type;
-
-  const auto start = loop_bounds.start;
-  const auto end   = loop_bounds.end;
-  //   Note this thing is called .member in the CUDA specialization of
-  //   TeamThreadRangeBoundariesStruct
-  auto& member         = loop_bounds.team;
-  const auto team_rank = member.team_rank();
-
-#if defined(KOKKOS_IMPL_TEAM_SCAN_WORKAROUND)
-  value_type scan_val = value_type();
-
-  if (team_rank == 0) {
-    for (iType i = start; i < end; ++i) {
-      lambda(i, scan_val, true);
-    }
-  }
-#pragma omp barrier
-#else
-  const auto team_size = member.team_size();
-  const auto nchunk    = (end - start + team_size - 1) / team_size;
-  value_type accum     = 0;
-  // each team has to process one or
-  //      more chunks of the prefix scan
-  for (iType i = 0; i < nchunk; ++i) {
-    auto ii = start + i * team_size + team_rank;
-    // local accumulation for this chunk
-    value_type local_accum = 0;
-    // user updates value with prefix value
-    if (ii < loop_bounds.end) lambda(ii, local_accum, false);
-    // perform team scan
-    local_accum = member.team_scan(local_accum);
-    // add this blocks accum to total accumulation
-    auto val = accum + local_accum;
-    // user updates their data with total accumulation
-    if (ii < loop_bounds.end) lambda(ii, val, true);
-    // the last value needs to be propogated to next chunk
-    if (team_rank == team_size - 1) accum = val;
-    // broadcast last value to rest of the team
-    member.team_broadcast(accum, team_size - 1);
-  }
-#endif
-}
-
-}  // namespace Kokkos
-
-namespace Kokkos {
-/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
- * i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
- */
-template <typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION void parallel_for(
-    const Impl::ThreadVectorRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda) {
-#pragma omp simd
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) lambda(i);
-}
-
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
- * and a summation of val is performed and put into result.
- */
-template <typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::ThreadVectorRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda, ValueType& result) {
-  ValueType vector_reduce = ValueType();
-
-  if constexpr (std::is_arithmetic<ValueType>::value) {
-#pragma omp simd reduction(+ : vector_reduce)
-    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-      ValueType tmp = ValueType();
-      lambda(i, tmp);
-      vector_reduce += tmp;
-    }
-  } else {
-#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
-
-#pragma omp simd reduction(custom : vector_reduce)
-    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-      lambda(i, vector_reduce);
-    }
-  }
-
-  result = vector_reduce;
-}
-
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
-parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
-                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                const Lambda& lambda, ReducerType const& result) {
-  using ValueType = typename ReducerType::value_type;
-
-#pragma omp declare reduction(                                               \
-    custom:ValueType                                                         \
-    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(                                                             \
-        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-  ValueType vector_reduce;
-  Impl::OpenMPTargetReducerWrapper<ReducerType>::init(vector_reduce);
-
-#pragma omp simd reduction(custom : vector_reduce)
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-    lambda(i, vector_reduce);
-  }
-
-  result.reference() = vector_reduce;
-}
-
-/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
- * and a reduction of val is performed using JoinType(ValueType& val, const
- * ValueType& update) and put into init_result. The input value of init_result
- * is used as initializer for temporary variables of ValueType. Therefore the
- * input value should be the neutral element with respect to the join operation
- * (e.g. '0 for +-' or '1 for *').
- */
-template <typename iType, class Lambda, typename ValueType, class JoinType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::ThreadVectorRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
-  ValueType result = init_result;
-
-  // FIXME_OPENMPTARGET think about omp simd
-  // join does not work with omp reduction clause
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-    ValueType tmp = ValueType();
-    lambda(i, tmp);
-    join(result, tmp);
-  }
-
-  init_result = result;
-}
-
-/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
- * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
- * operation is performed. Depending on the target execution space the operator
- * might be called twice: once with final=false and once with final=true. When
- * final==true val contains the prefix sum value. The contribution of this "i"
- * needs to be added to val no matter whether final==true or not. In a serial
- * execution (i.e. team_size==1) the operator is only called once with
- * final==true. Scan_val will be set to the final sum value over all vector
- * lanes.
- */
-template <typename iType, class FunctorType>
-KOKKOS_INLINE_FUNCTION void parallel_scan(
-    const Impl::ThreadVectorRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const FunctorType& lambda) {
-  using Analysis   = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         TeamPolicy<Experimental::OpenMPTarget>,
-                                         FunctorType>;
-  using value_type = typename Analysis::value_type;
-
-  value_type scan_val = value_type();
-
-#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
-#pragma ivdep
-#endif
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; ++i) {
-    lambda(i, scan_val, true);
-  }
-}
-
-}  // namespace Kokkos
-
-#ifdef KOKKOS_IMPL_TEAM_SCAN_WORKAROUND
-#undef KOKKOS_IMPL_TEAM_SCAN_WORKAROUND
-#endif
-
-namespace Kokkos {
-/** \brief  Intra-team vector parallel_for. Executes lambda(iType i) for each
- * i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling team.
- */
-template <typename iType, class Lambda>
-KOKKOS_INLINE_FUNCTION void parallel_for(
-    const Impl::TeamVectorRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda) {
-#pragma omp for simd nowait schedule(static, 1)
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) lambda(i);
-}
-
-/** \brief  Intra-team vector parallel_reduce. Executes lambda(iType i,
- * ValueType & val) for each i=0..N-1.
- *
- * The range i=0..N-1 is mapped to all vector lanes of the the calling team
- * and a summation of val is performed and put into result.
- */
-template <typename iType, class Lambda, typename ValueType>
-KOKKOS_INLINE_FUNCTION void parallel_reduce(
-    const Impl::TeamVectorRangeBoundariesStruct<
-        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const Lambda& lambda, ValueType& result) {
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-  ValueType* TeamVector_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-#pragma omp barrier
-  TeamVector_scratch[0] = ValueType();
-#pragma omp barrier
-
-  if constexpr (std::is_arithmetic<ValueType>::value) {
-#pragma omp for simd reduction(+ : TeamVector_scratch[:1])
-    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-      ValueType tmp = ValueType();
-      lambda(i, tmp);
-      TeamVector_scratch[0] += tmp;
-    }
-  } else {
-#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
-
-#pragma omp for simd reduction(custom : TeamVector_scratch[:1])
-    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-      ValueType tmp = ValueType();
-      lambda(i, tmp);
-      TeamVector_scratch[0] += tmp;
-    }
-  }
-
-  result = TeamVector_scratch[0];
-}
-
-#if !defined(KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND)
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
-parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
-                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                const Lambda& lambda, ReducerType const& result) {
-  using ValueType = typename ReducerType::value_type;
-
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-#pragma omp declare reduction(                                               \
-    custom:ValueType                                                         \
-    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(                                                             \
-        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-  ValueType* TeamVector_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-#pragma omp barrier
-  Impl::OpenMPTargetReducerWrapper<ReducerType>::init(TeamVector_scratch[0]);
-#pragma omp barrier
-
-#pragma omp for simd reduction(custom : TeamVector_scratch[:1])
-  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
-    lambda(i, TeamVector_scratch[0]);
-  }
-
-  result.reference() = TeamVector_scratch[0];
-}
-#else
-template <typename iType, class Lambda, typename ReducerType>
-KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
-parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
-                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-                const Lambda& lambda, ReducerType const& result) {
-  using ValueType = typename ReducerType::value_type;
-
-  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
-  // elements in the array <= 32. For reduction we allocate, 16 bytes per
-  // element in the scratch space, hence, 16*32 = 512.
-  static_assert(sizeof(ValueType) <=
-                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
-
-  ValueType* TeamVector_scratch =
-      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
-
-#pragma omp declare reduction(                                               \
-    omp_red_teamthread_reducer:ValueType                                     \
-    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(                                                             \
-        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-#pragma omp barrier
-  ValueType tmp;
-  result.init(tmp);
-  TeamVector_scratch[0] = tmp;
-#pragma omp barrier
-
-  iType team_size = iType(omp_get_num_threads());
-#pragma omp for simd reduction(omp_red_teamthread_reducer \
-                               : TeamVector_scratch[:1]) schedule(static, 1)
-  for (iType t = 0; t < team_size; t++) {
-    ValueType tmp2;
-    result.init(tmp2);
-
-    for (iType i = loop_boundaries.start + t; i < loop_boundaries.end;
-         i += team_size) {
-      lambda(i, tmp2);
-    }
-    TeamVector_scratch[0] = tmp2;
-  }
-
-  result.reference() = TeamVector_scratch[0];
-}
-#endif  // KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
-}  // namespace Kokkos
-
-#ifdef KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
-#undef KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
-#endif
-
-namespace Kokkos {
-
-template <class FunctorType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>&
-    /*single_struct*/,
-    const FunctorType& lambda) {
-  lambda();
-}
-
-template <class FunctorType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>&
-        single_struct,
-    const FunctorType& lambda) {
-  if (single_struct.team_member.team_rank() == 0) lambda();
-}
-
-template <class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>&
-    /*single_struct*/,
-    const FunctorType& lambda, ValueType& val) {
-  lambda(val);
-}
-
-template <class FunctorType, class ValueType>
-KOKKOS_INLINE_FUNCTION void single(
-    const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>&
-        single_struct,
-    const FunctorType& lambda, ValueType& val) {
-  if (single_struct.team_member.team_rank() == 0) {
-    lambda(val);
-  }
-  single_struct.team_member.team_broadcast(val, 0);
-}
-}  // namespace Kokkos
-
-#endif /* #ifndef KOKKOS_OPENMPTARGETEXEC_HPP */
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp
index 4a33961205..0846d570ae 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp
@@ -27,10 +27,11 @@
 // constructor. undef'ed at the end
 #define KOKKOS_IMPL_OPENMPTARGET_WORKAROUND
 
-#include <Kokkos_OpenMPTarget.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_UniqueToken.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Instance.hpp>
 #include <impl/Kokkos_ExecSpaceManager.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
 
 #include <sstream>
 
@@ -65,18 +66,41 @@ void OpenMPTargetInternal::fence(const std::string& name,
         [&]() {});
   }
 }
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
-int OpenMPTargetInternal::concurrency() {
-#else
 int OpenMPTargetInternal::concurrency() const {
+  int max_threads = 2048 * 80;
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  int max_threads_sm = 2048;
+#if defined(KOKKOS_ARCH_AMPERE86)
+  max_threads = max_threads_sm * 84;
+#elif defined(KOKKOS_ARCH_AMPERE80)
+  max_threads = max_threads_sm * 108;
+#elif defined(KOKKOS_ARCH_VOLTA72)
+  max_threads = max_threads_sm * 84;
+#elif defined(KOKKOS_ARCH_VOLTA70)
+  max_threads = max_threads_sm * 80;
+#elif defined(KOKKOS_ARCH_PASCAL60) || defined(KOKKOS_ARCH_PASCAL61)
+  max_threads = max_threads_sm * 60;
 #endif
-  return 128000;  // FIXME_OPENMPTARGET
+#elif defined(KOKKOS_ARCH_INTEL_GPU)
+#pragma omp target map(max_threads)
+  { max_threads = omp_get_num_procs(); }
+
+  // Multiply the number of processors with the SIMD length.
+  max_threads *= 32;
+#endif
+
+  return max_threads;
 }
 const char* OpenMPTargetInternal::name() { return "OpenMPTarget"; }
 void OpenMPTargetInternal::print_configuration(std::ostream& os,
                                                bool /*verbose*/) const {
   // FIXME_OPENMPTARGET
   os << "Using OpenMPTarget\n";
+#if defined(KOKKOS_IMPL_OPENMPTARGET_HIERARCHICAL_INTEL_GPU)
+  os << "Defined KOKKOS_IMPL_OPENMPTARGET_HIERARCHICAL_INTEL_GPU: Workaround "
+        "for "
+        "hierarchical parallelism for Intel GPUs.";
+#endif
 }
 
 void OpenMPTargetInternal::impl_finalize() {
@@ -93,10 +117,10 @@ void OpenMPTargetInternal::impl_initialize() {
 
   // FIXME_OPENMPTARGET:  Only fix the number of teams for NVIDIA architectures
   // from Pascal and upwards.
-#if defined(KOKKOS_ARCH_PASCAL) || defined(KOKKOS_ARCH_VOLTA) ||    \
-    defined(KOKKOS_ARCH_TURING75) || defined(KOKKOS_ARCH_AMPERE) || \
-    defined(KOKKOS_ARCH_HOPPER)
-#if defined(KOKKOS_COMPILER_CLANG) && (KOKKOS_COMPILER_CLANG >= 1300)
+  // FIXME_OPENMPTARGTE: Cray compiler did not yet implement omp_set_num_teams.
+#if !defined(KOKKOS_COMPILER_CRAY_LLVM)
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU) && defined(KOKKOS_COMPILER_CLANG) && \
+    (KOKKOS_COMPILER_CLANG >= 1300)
   omp_set_num_teams(512);
 #endif
 #endif
@@ -131,9 +155,15 @@ uint32_t OpenMPTarget::impl_instance_id() const noexcept {
   return m_space_instance->impl_get_instance_id();
 }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 int OpenMPTarget::concurrency() {
   return Impl::OpenMPTargetInternal::impl_singleton()->concurrency();
 }
+#else
+int OpenMPTarget::concurrency() const {
+  return m_space_instance->concurrency();
+}
+#endif
 
 void OpenMPTarget::fence(const std::string& name) {
   Impl::OpenMPTargetInternal::impl_singleton()->fence(name);
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.hpp
index 9f4349c00e..bea3bb3b12 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.hpp
@@ -37,7 +37,7 @@ class OpenMPTargetInternal {
              openmp_fence_is_static is_static = openmp_fence_is_static::no);
 
   /** \brief  Return the maximum amount of concurrency.  */
-  int concurrency();
+  int concurrency() const;
 
   //! Print configuration information to the given output stream.
   void print_configuration(std::ostream& os, bool verbose) const;
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
index 71ce4b18f2..9767d8e53e 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
@@ -20,1253 +20,654 @@
 #include <omp.h>
 #include <sstream>
 #include <Kokkos_Parallel.hpp>
-#include <OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp>
+#include <impl/Kokkos_Traits.hpp>
+#include <impl/Kokkos_Spinwait.hpp>
+
+#include <Kokkos_Atomic.hpp>
+#include "Kokkos_OpenMPTarget_Abort.hpp"
+
+// Intel architectures prefer the classical hierarchical parallelism that relies
+// on OpenMP.
+#if defined(KOKKOS_ARCH_INTEL_GPU)
+#define KOKKOS_IMPL_OPENMPTARGET_HIERARCHICAL_INTEL_GPU
+#endif
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
-                  Kokkos::Experimental::OpenMPTarget> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
+class OpenMPTargetExecTeamMember {
+ public:
+  static constexpr int TEAM_REDUCE_SIZE = 512;
+
+  using execution_space      = Kokkos::Experimental::OpenMPTarget;
+  using scratch_memory_space = execution_space::scratch_memory_space;
+  using team_handle          = OpenMPTargetExecTeamMember;
+
+  scratch_memory_space m_team_shared;
+  size_t m_team_scratch_size[2];
+  int m_team_rank;
+  int m_team_size;
+  int m_league_rank;
+  int m_league_size;
+  int m_vector_length;
+  int m_vector_lane;
+  int m_shmem_block_index;
+  void* m_glb_scratch;
+  void* m_reduce_scratch;
 
  public:
-  void execute() const { execute_impl<WorkTag>(); }
-
-  template <class TagType>
-  void execute_impl() const {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    const auto begin = m_policy.begin();
-    const auto end   = m_policy.end();
-
-    if (end <= begin) return;
-
-    FunctorType a_functor(m_functor);
-
-#pragma omp target teams distribute parallel for map(to : a_functor)
-    for (auto i = begin; i < end; ++i) {
-      if constexpr (std::is_void<TagType>::value) {
-        a_functor(i);
-      } else {
-        a_functor(TagType(), i);
-      }
-    }
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space& team_shmem() const {
+    return m_team_shared.set_team_thread_mode(0, 1, 0);
   }
 
-  ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-};
+  // set_team_thread_mode routine parameters for future understanding:
+  // first parameter - scratch level.
+  // second parameter - size multiplier for advancing scratch ptr after a
+  // request was serviced. third parameter - offset size multiplier from current
+  // scratch ptr when returning a ptr for a request.
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space& team_scratch(int level) const {
+    return m_team_shared.set_team_thread_mode(level, 1, 0);
+  }
 
-}  // namespace Impl
-}  // namespace Kokkos
+  KOKKOS_INLINE_FUNCTION
+  const execution_space::scratch_memory_space& thread_scratch(int level) const {
+    return m_team_shared.set_team_thread_mode(level, team_size(), team_rank());
+  }
 
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
+  KOKKOS_INLINE_FUNCTION int league_rank() const { return m_league_rank; }
+  KOKKOS_INLINE_FUNCTION int league_size() const { return m_league_size; }
+  KOKKOS_INLINE_FUNCTION int team_rank() const { return m_team_rank; }
+  KOKKOS_INLINE_FUNCTION int team_size() const { return m_team_size; }
+  KOKKOS_INLINE_FUNCTION void* impl_reduce_scratch() const {
+    return m_reduce_scratch;
+  }
 
-namespace Kokkos {
-namespace Impl {
+  KOKKOS_INLINE_FUNCTION void team_barrier() const {
+#pragma omp barrier
+  }
 
-// This class has the memcpy routine that is commonly used by ParallelReduce
-// over RangePolicy and TeamPolicy.
-template <class PointerType>
-struct ParallelReduceCommon {
-  // Copy the result back to device if the view is on the device.
-  static void memcpy_result(PointerType dest, PointerType src, size_t size,
-                            bool ptr_on_device) {
-    if (ptr_on_device) {
-      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(dest, src, size, 0, 0,
-                                                   omp_get_default_device(),
-                                                   omp_get_initial_device()));
-    } else {
-      *dest = *src;
-    }
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(ValueType& value,
+                                             int thread_id) const {
+    // Make sure there is enough scratch space:
+    using type = std::conditional_t<(sizeof(ValueType) < TEAM_REDUCE_SIZE),
+                                    ValueType, void>;
+    type* team_scratch =
+        reinterpret_cast<type*>(static_cast<char*>(m_glb_scratch) +
+                                TEAM_REDUCE_SIZE * omp_get_team_num());
+#pragma omp barrier
+    if (team_rank() == thread_id) *team_scratch = value;
+#pragma omp barrier
+    value = *team_scratch;
   }
-};
 
-template <class FunctorType, class PolicyType, class ReducerType,
-          class PointerType, class ValueType>
-struct ParallelReduceSpecialize {
-  inline static void execute(const FunctorType& /*f*/, const PolicyType& /*p*/,
-                             PointerType /*result_ptr*/) {
-    constexpr int FunctorHasJoin =
-        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
-                              FunctorType>::has_join_member_function;
-    constexpr int UseReducerType = is_reducer<ReducerType>::value;
-
-    std::stringstream error_message;
-    error_message << "Error: Invalid Specialization " << FunctorHasJoin << ' '
-                  << UseReducerType << '\n';
-    // FIXME_OPENMPTARGET
-    OpenMPTarget_abort(error_message.str().c_str());
+  template <class Closure, class ValueType>
+  KOKKOS_INLINE_FUNCTION void team_broadcast(const Closure& f, ValueType& value,
+                                             const int& thread_id) const {
+    f(value);
+    team_broadcast(value, thread_id);
   }
-};
 
-template <class FunctorType, class ReducerType, class PointerType,
-          class ValueType, class... PolicyArgs>
-struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
-                                ReducerType, PointerType, ValueType> {
-  using PolicyType = Kokkos::RangePolicy<PolicyArgs...>;
-  using TagType    = typename PolicyType::work_tag;
-  using ReducerTypeFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         PolicyType, ReducerTypeFwd>;
-  using ReferenceType = typename Analysis::reference_type;
-
-  using ParReduceCommon = ParallelReduceCommon<PointerType>;
-
-  static void execute_reducer(const FunctorType& f, const PolicyType& p,
-                              PointerType result_ptr, bool ptr_on_device) {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    const auto begin = p.begin();
-    const auto end   = p.end();
-
-    ValueType result;
-    OpenMPTargetReducerWrapper<ReducerType>::init(result);
-
-    // Initialize and copy back the result even if it is a zero length
-    // reduction.
-    if (end <= begin) {
-      ParReduceCommon::memcpy_result(result_ptr, &result, sizeof(ValueType),
-                                     ptr_on_device);
-      return;
-    }
+  // FIXME_OPENMPTARGET this function has the wrong interface and currently
+  // ignores the reducer passed.
+  template <class ValueType, class JoinOp>
+  KOKKOS_INLINE_FUNCTION ValueType team_reduce(const ValueType& value,
+                                               const JoinOp&) const {
+#pragma omp barrier
 
-#pragma omp declare reduction(                                         \
-    custom:ValueType                                                   \
-    : OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-#pragma omp target teams distribute parallel for map(to                    \
-                                                     : f) reduction(custom \
-                                                                    : result)
-    for (auto i = begin; i < end; ++i) {
-      if constexpr (std::is_void<TagType>::value) {
-        f(i, result);
-      } else {
-        f(TagType(), i, result);
-      }
+    using value_type = ValueType;
+    //    const JoinLambdaAdapter<value_type, JoinOp> op(op_in);
+
+    // Make sure there is enough scratch space:
+    using type = std::conditional_t<(sizeof(value_type) < TEAM_REDUCE_SIZE),
+                                    value_type, void>;
+
+    const int n_values = TEAM_REDUCE_SIZE / sizeof(value_type);
+    type* team_scratch =
+        reinterpret_cast<type*>(static_cast<char*>(m_glb_scratch) +
+                                TEAM_REDUCE_SIZE * omp_get_team_num());
+    for (int i = m_team_rank; i < n_values; i += m_team_size) {
+      team_scratch[i] = value_type();
     }
 
-    ParReduceCommon::memcpy_result(result_ptr, &result, sizeof(ValueType),
-                                   ptr_on_device);
-  }
+#pragma omp barrier
 
-  template <class TagType, int NumReductions>
-  static void execute_array(const FunctorType& f, const PolicyType& p,
-                            PointerType result_ptr, bool ptr_on_device) {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    const auto begin = p.begin();
-    const auto end   = p.end();
-
-    // Enter the loop if the reduction is on a scalar type.
-    if constexpr (NumReductions == 1) {
-      ValueType result = ValueType();
-
-      // Initialize and copy back the result even if it is a zero length
-      // reduction.
-      if (end <= begin) {
-        ParReduceCommon::memcpy_result(result_ptr, &result, sizeof(ValueType),
-                                       ptr_on_device);
-        return;
-      }
-      // Case where reduction is on a native data type.
-      if constexpr (std::is_arithmetic<ValueType>::value) {
-#pragma omp target teams distribute parallel for \
-         map(to:f) reduction(+: result)
-        for (auto i = begin; i < end; ++i)
-
-          if constexpr (std::is_void<TagType>::value) {
-            f(i, result);
-          } else {
-            f(TagType(), i, result);
-          }
-      } else {
-#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
-#pragma omp target teams distribute parallel for map(to                    \
-                                                     : f) reduction(custom \
-                                                                    : result)
-        for (auto i = begin; i < end; ++i)
-
-          if constexpr (std::is_void<TagType>::value) {
-            f(i, result);
-          } else {
-            f(TagType(), i, result);
-          }
-      }
+    for (int k = 0; k < m_team_size; k += n_values) {
+      if ((k <= m_team_rank) && (k + n_values > m_team_rank))
+        team_scratch[m_team_rank % n_values] += value;
+#pragma omp barrier
+    }
 
-      ParReduceCommon::memcpy_result(result_ptr, &result, sizeof(ValueType),
-                                     ptr_on_device);
-    } else {
-      ValueType result[NumReductions] = {};
-
-      // Initialize and copy back the result even if it is a zero length
-      // reduction.
-      if (end <= begin) {
-        ParReduceCommon::memcpy_result(result_ptr, result,
-                                       NumReductions * sizeof(ValueType),
-                                       ptr_on_device);
-        return;
+    for (int d = 1; d < n_values; d *= 2) {
+      if ((m_team_rank + d < n_values) && (m_team_rank % (2 * d) == 0)) {
+        team_scratch[m_team_rank] += team_scratch[m_team_rank + d];
       }
-#pragma omp target teams distribute parallel for map(to:f) reduction(+:result[:NumReductions])
-      for (auto i = begin; i < end; ++i) {
-        if constexpr (std::is_void<TagType>::value) {
-          f(i, result);
-        } else {
-          f(TagType(), i, result);
-        }
-      }
-
-      ParReduceCommon::memcpy_result(
-          result_ptr, result, NumReductions * sizeof(ValueType), ptr_on_device);
+#pragma omp barrier
     }
+    return team_scratch[0];
   }
+  /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
+   *          with intra-team non-deterministic ordering accumulation.
+   *
+   *  The global inter-team accumulation value will, at the end of the
+   *  league's parallel execution, be the scan's total.
+   *  Parallel execution ordering of the league's teams is non-deterministic.
+   *  As such the base value for each team's scan operation is similarly
+   *  non-deterministic.
+   */
+  template <typename ArgType>
+  KOKKOS_INLINE_FUNCTION ArgType
+  team_scan(const ArgType& /*value*/, ArgType* const /*global_accum*/) const {
+    // FIXME_OPENMPTARGET
+    /*  // Make sure there is enough scratch space:
+      using type =
+        std::conditional_t<(sizeof(ArgType) < TEAM_REDUCE_SIZE), ArgType, void>;
 
-  static void execute_init_join(const FunctorType& f, const PolicyType& p,
-                                PointerType ptr, const bool ptr_on_device) {
-    const auto begin = p.begin();
-    const auto end   = p.end();
-
-    using FunctorAnalysis =
-        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
-                              FunctorType>;
-    constexpr int HasInit = FunctorAnalysis::has_init_member_function;
-
-    // Initialize the result pointer.
-
-    const auto size = end - begin;
-
-    // FIXME_OPENMPTARGET: The team size and MAX_ACTIVE_THREADS are currently
-    // based on NVIDIA-V100 and should be modifid to be based on the
-    // architecture in the future.
-    const int max_team_threads = 32;
-    const int max_teams =
-        OpenMPTargetExec::MAX_ACTIVE_THREADS / max_team_threads;
-    // Number of elements in the reduction
-    const auto value_count = FunctorAnalysis::value_count(f);
-
-    // Allocate scratch per active thread. Achieved by setting the first
-    // parameter of `resize_scratch=1`.
-    OpenMPTargetExec::resize_scratch(1, 0, value_count * sizeof(ValueType),
-                                     std::numeric_limits<int64_t>::max());
-    ValueType* scratch_ptr =
-        static_cast<ValueType*>(OpenMPTargetExec::get_scratch_ptr());
-
-#pragma omp target map(to : f) is_device_ptr(scratch_ptr)
-    {
-      typename FunctorAnalysis::Reducer final_reducer(&f);
-      // Enter this loop if the functor has an `init`
-      if constexpr (HasInit) {
-        // The `init` routine needs to be called on the device since it might
-        // need device members.
-        final_reducer.init(scratch_ptr);
-        final_reducer.final(scratch_ptr);
-      } else {
-        for (int i = 0; i < value_count; ++i) {
-          static_cast<ValueType*>(scratch_ptr)[i] = ValueType();
-        }
+      volatile type * const work_value  = ((type*) m_exec.scratch_thread());
 
-        final_reducer.final(scratch_ptr);
-      }
-    }
+      *work_value = value ;
 
-    if (end <= begin) {
-      // If there is no work to be done, copy back the initialized values and
-      // exit.
-      if (!ptr_on_device)
-        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-            omp_get_initial_device(), omp_get_default_device()));
-      else
-        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-            omp_get_default_device(), omp_get_default_device()));
-
-      return;
-    }
+      memory_fence();
 
-#pragma omp target teams num_teams(max_teams) thread_limit(max_team_threads) \
-    map(to                                                                   \
-        : f) is_device_ptr(scratch_ptr)
-    {
-      typename FunctorAnalysis::Reducer final_reducer(&f);
-#pragma omp parallel
-      {
-        const int team_num    = omp_get_team_num();
-        const int num_teams   = omp_get_num_teams();
-        const auto chunk_size = size / num_teams;
-        const auto team_begin = begin + team_num * chunk_size;
-        const auto team_end =
-            (team_num == num_teams - 1) ? end : (team_begin + chunk_size);
-        ValueType* team_scratch =
-            scratch_ptr + team_num * max_team_threads * value_count;
-        ReferenceType result = final_reducer.init(
-            &team_scratch[omp_get_thread_num() * value_count]);
-
-        // Accumulate partial results in thread specific storage.
-#pragma omp for simd
-        for (auto i = team_begin; i < team_end; ++i) {
-          if constexpr (std::is_void<TagType>::value) {
-            f(i, result);
-          } else {
-            f(TagType(), i, result);
+      if ( team_fan_in() ) {
+        // The last thread to synchronize returns true, all other threads wait
+      for team_fan_out()
+        // m_team_base[0]                 == highest ranking team member
+        // m_team_base[ m_team_size - 1 ] == lowest ranking team member
+        //
+        // 1) copy from lower to higher rank, initialize lowest rank to zero
+        // 2) prefix sum from lowest to highest rank, skipping lowest rank
+
+        type accum = 0 ;
+
+        if ( global_accum ) {
+          for ( int i = m_team_size ; i-- ; ) {
+            type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i
+      )->scratch_thread()); accum += val ;
           }
+          accum = atomic_fetch_add( global_accum , accum );
         }
 
-        // Reduce all paritial results within a team.
-        const int team_size      = max_team_threads;
-        int tree_neighbor_offset = 1;
-        do {
-#pragma omp for simd
-          for (int i = 0; i < team_size - tree_neighbor_offset;
-               i += 2 * tree_neighbor_offset) {
-            const int neighbor = i + tree_neighbor_offset;
-            final_reducer.join(&team_scratch[i * value_count],
-                               &team_scratch[neighbor * value_count]);
-          }
-          tree_neighbor_offset *= 2;
-        } while (tree_neighbor_offset < team_size);
-      }  // end parallel
-    }    // end target
-
-    int tree_neighbor_offset = 1;
-    do {
-#pragma omp target teams distribute parallel for simd map(to   \
-                                                          : f) \
-    is_device_ptr(scratch_ptr)
-      for (int i = 0; i < max_teams - tree_neighbor_offset;
-           i += 2 * tree_neighbor_offset) {
-        typename FunctorAnalysis::Reducer final_reducer(&f);
-        ValueType* team_scratch = scratch_ptr;
-        const int team_offset   = max_team_threads * value_count;
-        final_reducer.join(
-            &team_scratch[i * team_offset],
-            &team_scratch[(i + tree_neighbor_offset) * team_offset]);
-
-        // If `final` is provided by the functor.
-        // Do the final only once at the end.
-        if (tree_neighbor_offset * 2 >= max_teams && omp_get_team_num() == 0 &&
-            omp_get_thread_num() == 0) {
-          final_reducer.final(scratch_ptr);
+        for ( int i = m_team_size ; i-- ; ) {
+          type & val = *((type*) m_exec.pool_rev( m_team_base_rev + i
+      )->scratch_thread()); const type offset = accum ; accum += val ; val =
+      offset ;
         }
+
+        memory_fence();
       }
-      tree_neighbor_offset *= 2;
-    } while (tree_neighbor_offset < max_teams);
-
-    // If the result view is on the host, copy back the values via memcpy.
-    if (!ptr_on_device)
-      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-          omp_get_initial_device(), omp_get_default_device()));
-    else
-      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-          omp_get_default_device(), omp_get_default_device()));
-  }
-};
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
-                     Kokkos::Experimental::OpenMPTarget> {
- private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-
-  using ReducerTypeFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         Policy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  static constexpr int HasJoin =
-      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, Policy,
-                            FunctorType>::has_join_member_function;
-  static constexpr int UseReducer = is_reducer<ReducerType>::value;
-  static constexpr int IsArray    = std::is_pointer<reference_type>::value;
-
-  using ParReduceSpecialize =
-      ParallelReduceSpecialize<FunctorType, Policy, ReducerType, pointer_type,
-                               typename Analysis::value_type>;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const ReducerType m_reducer;
-  const pointer_type m_result_ptr;
-  bool m_result_ptr_on_device;
-  const int m_result_ptr_num_elems;
-  using TagType = typename Policy::work_tag;
+      team_fan_out();
 
- public:
-  void execute() const {
-    if constexpr (HasJoin) {
-      // Enter this loop if the Functor has a init-join.
-      ParReduceSpecialize::execute_init_join(m_functor, m_policy, m_result_ptr,
-                                             m_result_ptr_on_device);
-    } else if constexpr (UseReducer) {
-      // Enter this loop if the Functor is a reducer type.
-      ParReduceSpecialize::execute_reducer(m_functor, m_policy, m_result_ptr,
-                                           m_result_ptr_on_device);
-    } else if constexpr (IsArray) {
-      // Enter this loop if the reduction is on an array and the routine is
-      // templated over the size of the array.
-      if (m_result_ptr_num_elems <= 2) {
-        ParReduceSpecialize::template execute_array<TagType, 2>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 4) {
-        ParReduceSpecialize::template execute_array<TagType, 4>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 8) {
-        ParReduceSpecialize::template execute_array<TagType, 8>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 16) {
-        ParReduceSpecialize::template execute_array<TagType, 16>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 32) {
-        ParReduceSpecialize::template execute_array<TagType, 32>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else {
-        Kokkos::abort("array reduction length must be <= 32");
-      }
-    } else {
-      // This loop handles the basic scalar reduction.
-      ParReduceSpecialize::template execute_array<TagType, 1>(
-          m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-    }
+      return *work_value ;*/
+    return ArgType();
   }
 
-  template <class ViewType>
-  ParallelReduce(const FunctorType& arg_functor, Policy& arg_policy,
-                 const ViewType& arg_result_view,
-                 std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void*> = nullptr)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(InvalidType()),
-        m_result_ptr(arg_result_view.data()),
-        m_result_ptr_on_device(
-            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                              typename ViewType::memory_space>::accessible),
-        m_result_ptr_num_elems(arg_result_view.size()) {}
-
-  ParallelReduce(const FunctorType& arg_functor, Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_on_device(
-            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_result_ptr_num_elems(reducer.view().size()) {}
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
+  /** \brief  Intra-team exclusive prefix sum with team_rank() ordering.
+   *
+   *  The highest rank thread can compute the reduction total as
+   *    reduction_total = dev.team_scan( value ) + value ;
+   */
+  template <typename Type>
+  KOKKOS_INLINE_FUNCTION Type team_scan(const Type& value) const {
+    return this->template team_scan<Type>(value, 0);
+  }
 
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
+  //----------------------------------------
+  // Private for the driver
 
-namespace Kokkos {
-namespace Impl {
+ private:
+  using space = execution_space::scratch_memory_space;
 
-template <class FunctorType, class... Traits>
-class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
-                   Kokkos::Experimental::OpenMPTarget> {
- protected:
-  using Policy = Kokkos::RangePolicy<Traits...>;
+ public:
+  // FIXME_OPENMPTARGET - 512(16*32) bytes at the begining of the scratch space
+  // for each league is saved for reduction. It should actually be based on the
+  // ValueType of the reduction variable.
+  inline OpenMPTargetExecTeamMember(
+      const int league_rank, const int league_size, const int team_size,
+      const int vector_length  // const TeamPolicyInternal< OpenMPTarget,
+                               // Properties ...> & team
+      ,
+      void* const glb_scratch, const int shmem_block_index,
+      const size_t shmem_size_L0, const size_t shmem_size_L1)
+      : m_team_scratch_size{shmem_size_L0, shmem_size_L1},
+        m_team_rank(0),
+        m_team_size(team_size),
+        m_league_rank(league_rank),
+        m_league_size(league_size),
+        m_vector_length(vector_length),
+        m_shmem_block_index(shmem_block_index),
+        m_glb_scratch(glb_scratch) {
+    const int omp_tid = omp_get_thread_num();
+
+    // The scratch memory allocated is a sum of TEAM_REDUCE_SIZE, L0 shmem size
+    // and L1 shmem size. TEAM_REDUCE_SIZE = 512 bytes saved per team for
+    // hierarchical reduction. There is an additional 10% of the requested
+    // scratch memory allocated per team as padding. Hence the product with 0.1.
+    const int reduce_offset =
+        m_shmem_block_index *
+        (shmem_size_L0 + shmem_size_L1 +
+         ((shmem_size_L0 + shmem_size_L1) * 0.1) + TEAM_REDUCE_SIZE);
+    const int l0_offset = reduce_offset + TEAM_REDUCE_SIZE;
+    const int l1_offset = l0_offset + shmem_size_L0;
+    m_team_shared       = scratch_memory_space(
+        (static_cast<char*>(glb_scratch) + l0_offset), shmem_size_L0,
+        static_cast<char*>(glb_scratch) + l1_offset, shmem_size_L1);
+    m_reduce_scratch = static_cast<char*>(glb_scratch) + reduce_offset;
+    m_league_rank    = league_rank;
+    m_team_rank      = omp_tid;
+    m_vector_lane    = 0;
+  }
 
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-  using idx_type  = typename Policy::index_type;
+  static inline int team_reduce_size() { return TEAM_REDUCE_SIZE; }
+};
 
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         Policy, FunctorType>;
+template <class... Properties>
+class TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget, Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
+  //! Tag this class as a kokkos execution policy
+  using execution_policy = TeamPolicyInternal;
 
-  using value_type     = typename Analysis::value_type;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
+  using traits = PolicyTraits<Properties...>;
 
-  const FunctorType m_functor;
-  const Policy m_policy;
+  //----------------------------------------
 
-  value_type* m_result_ptr;
-  const bool m_result_ptr_device_accessible;
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType&, const ParallelForTag&) {
+    return 256;
+  }
 
-  template <class TagType>
-  std::enable_if_t<std::is_void<TagType>::value> call_with_tag(
-      const FunctorType& f, const idx_type& idx, value_type& val,
-      const bool& is_final) const {
-    f(idx, val, is_final);
+  template <class FunctorType>
+  inline static int team_size_max(const FunctorType&,
+                                  const ParallelReduceTag&) {
+    return 256;
   }
-  template <class TagType>
-  std::enable_if_t<!std::is_void<TagType>::value> call_with_tag(
-      const FunctorType& f, const idx_type& idx, value_type& val,
-      const bool& is_final) const {
-    f(WorkTag(), idx, val, is_final);
+
+  template <class FunctorType, class ReducerType>
+  inline static int team_size_max(const FunctorType&, const ReducerType&,
+                                  const ParallelReduceTag&) {
+    return 256;
   }
 
- public:
-  void impl_execute(
-      Kokkos::View<value_type**, Kokkos::LayoutRight,
-                   Kokkos::Experimental::OpenMPTargetSpace>
-          element_values,
-      Kokkos::View<value_type*, Kokkos::Experimental::OpenMPTargetSpace>
-          chunk_values,
-      Kokkos::View<int64_t, Kokkos::Experimental::OpenMPTargetSpace> count)
-      const {
-    const idx_type N          = m_policy.end() - m_policy.begin();
-    const idx_type chunk_size = 128;
-    const idx_type n_chunks   = (N + chunk_size - 1) / chunk_size;
-    idx_type nteams           = n_chunks > 512 ? 512 : n_chunks;
-    idx_type team_size        = 128;
-
-    FunctorType a_functor(m_functor);
-#pragma omp target teams distribute map(to                             \
-                                        : a_functor) num_teams(nteams) \
-    thread_limit(team_size)
-    for (idx_type team_id = 0; team_id < n_chunks; ++team_id) {
-      typename Analysis::Reducer final_reducer(&a_functor);
-#pragma omp parallel num_threads(team_size)
-      {
-        const idx_type local_offset = team_id * chunk_size;
-
-#pragma omp for
-        for (idx_type i = 0; i < chunk_size; ++i) {
-          const idx_type idx = local_offset + i;
-          value_type val;
-          final_reducer.init(&val);
-          if (idx < N) call_with_tag<WorkTag>(a_functor, idx, val, false);
-          element_values(team_id, i) = val;
-        }
-#pragma omp barrier
-        if (omp_get_thread_num() == 0) {
-          value_type sum;
-          final_reducer.init(&sum);
-          for (idx_type i = 0; i < chunk_size; ++i) {
-            final_reducer.join(&sum, &element_values(team_id, i));
-            element_values(team_id, i) = sum;
-          }
-          chunk_values(team_id) = sum;
-        }
-#pragma omp barrier
-        if (omp_get_thread_num() == 0) {
-          if (Kokkos::atomic_fetch_add(&count(), 1) == n_chunks - 1) {
-            value_type sum;
-            final_reducer.init(&sum);
-            for (idx_type i = 0; i < n_chunks; ++i) {
-              final_reducer.join(&sum, &chunk_values(i));
-              chunk_values(i) = sum;
-            }
-          }
-        }
-      }
-    }
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&,
+                                          const ParallelForTag&) {
+    return 128;
+  }
 
-#pragma omp target teams distribute map(to                             \
-                                        : a_functor) num_teams(nteams) \
-    thread_limit(team_size)
-    for (idx_type team_id = 0; team_id < n_chunks; ++team_id) {
-      typename Analysis::Reducer final_reducer(&a_functor);
-#pragma omp parallel num_threads(team_size)
-      {
-        const idx_type local_offset = team_id * chunk_size;
-        value_type offset_value;
-        if (team_id > 0)
-          offset_value = chunk_values(team_id - 1);
-        else
-          final_reducer.init(&offset_value);
-
-#pragma omp for
-        for (idx_type i = 0; i < chunk_size; ++i) {
-          const idx_type idx = local_offset + i;
-          value_type local_offset_value;
-          if (i > 0) {
-            local_offset_value = element_values(team_id, i - 1);
-            // FIXME_OPENMPTARGET We seem to access memory illegaly on AMD GPUs
-#ifdef KOKKOS_ARCH_VEGA
-            if constexpr (Analysis::has_join_member_function) {
-              if constexpr (std::is_void_v<WorkTag>)
-                a_functor.join(local_offset_value, offset_value);
-              else
-                a_functor.join(WorkTag{}, local_offset_value, offset_value);
-            } else
-              local_offset_value += offset_value;
-#else
-            final_reducer.join(&local_offset_value, &offset_value);
-#endif
-          } else
-            local_offset_value = offset_value;
-          if (idx < N)
-            call_with_tag<WorkTag>(a_functor, idx, local_offset_value, true);
-          if (idx == N - 1 && m_result_ptr_device_accessible)
-            *m_result_ptr = local_offset_value;
-        }
-      }
-    }
+  template <class FunctorType>
+  inline static int team_size_recommended(const FunctorType&,
+                                          const ParallelReduceTag&) {
+    return 128;
   }
 
-  void execute() const {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    const idx_type N          = m_policy.end() - m_policy.begin();
-    const idx_type chunk_size = 128;
-    const idx_type n_chunks   = (N + chunk_size - 1) / chunk_size;
-
-    // This could be scratch memory per team
-    Kokkos::View<value_type**, Kokkos::LayoutRight,
-                 Kokkos::Experimental::OpenMPTargetSpace>
-        element_values("element_values", n_chunks, chunk_size);
-    Kokkos::View<value_type*, Kokkos::Experimental::OpenMPTargetSpace>
-        chunk_values("chunk_values", n_chunks);
-    Kokkos::View<int64_t, Kokkos::Experimental::OpenMPTargetSpace> count(
-        "Count");
-
-    impl_execute(element_values, chunk_values, count);
+  template <class FunctorType, class ReducerType>
+  inline static int team_size_recommended(const FunctorType&,
+                                          const ReducerType&,
+                                          const ParallelReduceTag&) {
+    return 128;
   }
 
   //----------------------------------------
 
-  ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy,
-               pointer_type arg_result_ptr           = nullptr,
-               bool arg_result_ptr_device_accessible = false)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_result_ptr(arg_result_ptr),
-        m_result_ptr_device_accessible(arg_result_ptr_device_accessible) {}
-
-  //----------------------------------------
-};
+ private:
+  int m_league_size;
+  int m_team_size;
+  int m_vector_length;
+  int m_team_alloc;
+  int m_team_iter;
+  std::array<size_t, 2> m_team_scratch_size;
+  std::array<size_t, 2> m_thread_scratch_size;
+  bool m_tune_team_size;
+  bool m_tune_vector_length;
+  constexpr const static size_t default_team_size = 256;
+  int m_chunk_size;
+
+  inline void init(const int league_size_request, const int team_size_request,
+                   const int vector_length_request) {
+    m_league_size = league_size_request;
+
+    // Minimum team size should be 32 for OpenMPTarget backend.
+    if (team_size_request < 32) {
+      Kokkos::Impl::OpenMPTarget_abort(
+          "OpenMPTarget backend requires a minimum of 32 threads per team.\n");
+    } else
+      m_team_size = team_size_request;
+
+    m_vector_length = vector_length_request;
+    set_auto_chunk_size();
+  }
 
-template <class FunctorType, class ReturnType, class... Traits>
-class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
-                            ReturnType, Kokkos::Experimental::OpenMPTarget>
-    : public ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
-                          Kokkos::Experimental::OpenMPTarget> {
-  using base_t     = ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
-                              Kokkos::Experimental::OpenMPTarget>;
-  using value_type = typename base_t::value_type;
+  template <typename ExecSpace, typename... OtherProperties>
+  friend class TeamPolicyInternal;
 
  public:
-  void execute() const {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    const int64_t N        = base_t::m_policy.end() - base_t::m_policy.begin();
-    const int chunk_size   = 128;
-    const int64_t n_chunks = (N + chunk_size - 1) / chunk_size;
-
-    if (N > 0) {
-      // This could be scratch memory per team
-      Kokkos::View<value_type**, Kokkos::LayoutRight,
-                   Kokkos::Experimental::OpenMPTargetSpace>
-          element_values("element_values", n_chunks, chunk_size);
-      Kokkos::View<value_type*, Kokkos::Experimental::OpenMPTargetSpace>
-          chunk_values("chunk_values", n_chunks);
-      Kokkos::View<int64_t, Kokkos::Experimental::OpenMPTargetSpace> count(
-          "Count");
-
-      base_t::impl_execute(element_values, chunk_values, count);
-
-      if (!base_t::m_result_ptr_device_accessible) {
-        const int size = base_t::Analysis::value_size(base_t::m_functor);
-        DeepCopy<HostSpace, Kokkos::Experimental::OpenMPTargetSpace>(
-            base_t::m_result_ptr, chunk_values.data() + (n_chunks - 1), size);
-      }
-    } else if (!base_t::m_result_ptr_device_accessible) {
-      *base_t::m_result_ptr = 0;
-    }
+  // FIXME_OPENMPTARGET : Currently this routine is a copy of the Cuda
+  // implementation, but this has to be tailored to be architecture specific.
+  inline static int scratch_size_max(int level) {
+    return (
+        level == 0 ? 1024 * 40 :  // 48kB is the max for CUDA, but we need some
+                                  // for team_member.reduce etc.
+            20 * 1024 *
+                1024);  // arbitrarily setting this to 20MB, for a Volta V100
+                        // that would give us about 3.2GB for 2 teams per SM
   }
-
-  template <class ViewType>
-  ParallelScanWithTotal(const FunctorType& arg_functor,
-                        const typename base_t::Policy& arg_policy,
-                        const ViewType& arg_result_view)
-      : base_t(arg_functor, arg_policy, arg_result_view.data(),
-               MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                                 typename ViewType::memory_space>::accessible) {
+  inline bool impl_auto_team_size() const { return m_tune_team_size; }
+  inline bool impl_auto_vector_length() const { return m_tune_vector_length; }
+  inline void impl_set_team_size(const size_t size) { m_team_size = size; }
+  inline void impl_set_vector_length(const size_t length) {
+    m_tune_vector_length = length;
+  }
+  inline int impl_vector_length() const { return m_vector_length; }
+  inline int team_size() const { return m_team_size; }
+  inline int league_size() const { return m_league_size; }
+  inline size_t scratch_size(const int& level, int team_size_ = -1) const {
+    if (team_size_ < 0) team_size_ = m_team_size;
+    return m_team_scratch_size[level] +
+           team_size_ * m_thread_scratch_size[level];
   }
-};
-}  // namespace Impl
-}  // namespace Kokkos
 
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
+  inline Kokkos::Experimental::OpenMPTarget space() const {
+    return Kokkos::Experimental::OpenMPTarget();
+  }
 
-namespace Kokkos {
-namespace Impl {
+  template <class... OtherProperties>
+  TeamPolicyInternal(const TeamPolicyInternal<OtherProperties...>& p)
+      : m_league_size(p.m_league_size),
+        m_team_size(p.m_team_size),
+        m_vector_length(p.m_vector_length),
+        m_team_alloc(p.m_team_alloc),
+        m_team_iter(p.m_team_iter),
+        m_team_scratch_size(p.m_team_scratch_size),
+        m_thread_scratch_size(p.m_thread_scratch_size),
+        m_tune_team_size(p.m_tune_team_size),
+        m_tune_vector_length(p.m_tune_vector_length),
+        m_chunk_size(p.m_chunk_size) {}
+
+  /** \brief  Specify league size, request team size */
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request, int team_size_request,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(false),
+        m_tune_vector_length(false),
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request, vector_length_request);
+  }
 
-template <class FunctorType, class... Properties>
-class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                  Kokkos::Experimental::OpenMPTarget> {
- private:
-  using Policy =
-      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget,
-                                       Properties...>;
-  using WorkTag = typename Policy::work_tag;
-  using Member  = typename Policy::member_type;
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(true),
+        m_tune_vector_length(false),
+        m_chunk_size(0) {
+    init(league_size_request, default_team_size / vector_length_request,
+         vector_length_request);
+  }
 
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const size_t m_shmem_size;
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     const Kokkos::AUTO_t& /* vector_length_request */)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(true),
+        m_tune_vector_length(true),
+        m_chunk_size(0) {
+    init(league_size_request, default_team_size, 1);
+  }
+  TeamPolicyInternal(const typename traits::execution_space&,
+                     int league_size_request, int team_size_request,
+                     const Kokkos::AUTO_t& /* vector_length_request */)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(false),
+        m_tune_vector_length(true),
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request, 1);
+  }
 
- public:
-  void execute() const {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    execute_impl<WorkTag>();
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(false),
+        m_tune_vector_length(false),
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request, vector_length_request);
   }
 
- private:
-  template <class TagType>
-  void execute_impl() const {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    const auto league_size   = m_policy.league_size();
-    const auto team_size     = m_policy.team_size();
-    const auto vector_length = m_policy.impl_vector_length();
-
-    const size_t shmem_size_L0 = m_policy.scratch_size(0, team_size);
-    const size_t shmem_size_L1 = m_policy.scratch_size(1, team_size);
-    OpenMPTargetExec::resize_scratch(team_size, shmem_size_L0, shmem_size_L1,
-                                     league_size);
-
-    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-    FunctorType a_functor(m_functor);
-
-    // FIXME_OPENMPTARGET - If the team_size is not a multiple of 32, the
-    // scratch implementation does not work in the Release or RelWithDebugInfo
-    // mode but works in the Debug mode.
-
-    // Maximum active teams possible.
-    int max_active_teams = OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size;
-    // nteams should not exceed the maximum in-flight teams possible.
-    const auto nteams =
-        league_size < max_active_teams ? league_size : max_active_teams;
-
-    // If the league size is <=0, do not launch the kernel.
-    if (nteams <= 0) return;
-
-// Performing our own scheduling of teams to avoid separation of code between
-// teams-distribute and parallel. Gave a 2x performance boost in test cases with
-// the clang compiler. atomic_compare_exchange can be avoided since the standard
-// guarantees that the number of teams specified in the `num_teams` clause is
-// always less than or equal to the maximum concurrently running teams.
-#pragma omp target teams num_teams(nteams) thread_limit(team_size) \
-    map(to                                                         \
-        : a_functor) is_device_ptr(scratch_ptr)
-#pragma omp parallel
-    {
-      const int blockIdx = omp_get_team_num();
-      const int gridDim  = omp_get_num_teams();
-
-      // Iterate through the number of teams until league_size and assign the
-      // league_id accordingly
-      // Guarantee that the compilers respect the `num_teams` clause
-      if (gridDim <= nteams) {
-        for (int league_id = blockIdx; league_id < league_size;
-             league_id += gridDim) {
-          typename Policy::member_type team(
-              league_id, league_size, team_size, vector_length, scratch_ptr,
-              blockIdx, shmem_size_L0, shmem_size_L1);
-          if constexpr (std::is_void<TagType>::value)
-            m_functor(team);
-          else
-            m_functor(TagType(), team);
-        }
-      } else
-        Kokkos::abort("`num_teams` clause was not respected.\n");
-    }
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     int vector_length_request = 1)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(true),
+        m_tune_vector_length(false),
+        m_chunk_size(0) {
+    init(league_size_request, default_team_size / vector_length_request,
+         vector_length_request);
   }
 
- public:
-  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                     FunctorTeamShmemSize<FunctorType>::value(
-                         arg_functor, arg_policy.team_size())) {}
-};
+  TeamPolicyInternal(int league_size_request,
+                     const Kokkos::AUTO_t& /* team_size_request */
+                     ,
+                     const Kokkos::AUTO_t& /* vector_length_request */)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(true),
+        m_tune_vector_length(true),
+        m_chunk_size(0) {
+    init(league_size_request, default_team_size, 1);
+  }
+  TeamPolicyInternal(int league_size_request, int team_size_request,
+                     const Kokkos::AUTO_t& /* vector_length_request */)
+      : m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_tune_team_size(false),
+        m_tune_vector_length(true),
+        m_chunk_size(0) {
+    init(league_size_request, team_size_request, 1);
+  }
+  inline static size_t vector_length_max() {
+    return 32; /* TODO: this is bad. Need logic that is compiler and backend
+                  aware */
+  }
+  inline int team_alloc() const { return m_team_alloc; }
+  inline int team_iter() const { return m_team_iter; }
 
-template <class FunctorType, class ReducerType, class PointerType,
-          class ValueType, class... PolicyArgs>
-struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
-                                ReducerType, PointerType, ValueType> {
-  using PolicyType = TeamPolicyInternal<PolicyArgs...>;
-  using TagType    = typename PolicyType::work_tag;
-  using ReducerTypeFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         PolicyType, ReducerTypeFwd>;
-
-  using ReferenceType = typename Analysis::reference_type;
-
-  using ParReduceCommon = ParallelReduceCommon<PointerType>;
-
-  static void execute_reducer(const FunctorType& f, const PolicyType& p,
-                              PointerType result_ptr, bool ptr_on_device) {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-
-    const int league_size   = p.league_size();
-    const int team_size     = p.team_size();
-    const int vector_length = p.impl_vector_length();
-
-    const size_t shmem_size_L0 = p.scratch_size(0, team_size);
-    const size_t shmem_size_L1 = p.scratch_size(1, team_size);
-    OpenMPTargetExec::resize_scratch(PolicyType::member_type::TEAM_REDUCE_SIZE,
-                                     shmem_size_L0, shmem_size_L1, league_size);
-    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-
-    ValueType result = ValueType();
-
-    // Maximum active teams possible.
-    int max_active_teams = OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size;
-    const auto nteams =
-        league_size < max_active_teams ? league_size : max_active_teams;
-
-    // If the league size is <=0, do not launch the kernel.
-    if (nteams <= 0) return;
-
-#pragma omp declare reduction(                                         \
-    custom:ValueType                                                   \
-    : OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
-
-#pragma omp target teams num_teams(nteams) thread_limit(team_size) map(to   \
-                                                                       : f) \
-    is_device_ptr(scratch_ptr) reduction(custom                             \
-                                         : result)
-#pragma omp parallel reduction(custom : result)
-    {
-      const int blockIdx = omp_get_team_num();
-      const int gridDim  = omp_get_num_teams();
-
-      // Guarantee that the compilers respect the `num_teams` clause
-      if (gridDim <= nteams) {
-        for (int league_id = blockIdx; league_id < league_size;
-             league_id += gridDim) {
-          typename PolicyType::member_type team(
-              league_id, league_size, team_size, vector_length, scratch_ptr,
-              blockIdx, shmem_size_L0, shmem_size_L1);
-          if constexpr (std::is_void<TagType>::value)
-            f(team, result);
-          else
-            f(TagType(), team, result);
-        }
-      } else
-        Kokkos::abort("`num_teams` clause was not respected.\n");
-    }
+  inline int chunk_size() const { return m_chunk_size; }
 
-    // Copy results back to device if `parallel_reduce` is on a device view.
-    ParReduceCommon::memcpy_result(result_ptr, &result, sizeof(ValueType),
-                                   ptr_on_device);
+  /** \brief set chunk_size to a discrete value*/
+  inline TeamPolicyInternal& set_chunk_size(
+      typename traits::index_type chunk_size_) {
+    m_chunk_size = chunk_size_;
+    return *this;
   }
 
-  template <int NumReductions>
-  static void execute_array(const FunctorType& f, const PolicyType& p,
-                            PointerType result_ptr, bool ptr_on_device) {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-
-    const int league_size   = p.league_size();
-    const int team_size     = p.team_size();
-    const int vector_length = p.impl_vector_length();
-
-    const size_t shmem_size_L0 = p.scratch_size(0, team_size);
-    const size_t shmem_size_L1 = p.scratch_size(1, team_size);
-    OpenMPTargetExec::resize_scratch(PolicyType::member_type::TEAM_REDUCE_SIZE,
-                                     shmem_size_L0, shmem_size_L1, league_size);
-    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-
-    // Maximum active teams possible.
-    int max_active_teams = OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size;
-    const auto nteams =
-        league_size < max_active_teams ? league_size : max_active_teams;
-
-    // If the league size is <=0, do not launch the kernel.
-    if (nteams <= 0) return;
-
-    // Case where the number of reduction items is 1.
-    if constexpr (NumReductions == 1) {
-      ValueType result = ValueType();
-
-      // Case where reduction is on a native data type.
-      if constexpr (std::is_arithmetic<ValueType>::value) {
-#pragma omp target teams num_teams(nteams) thread_limit(team_size) map(to   \
-                                                                       : f) \
-    is_device_ptr(scratch_ptr) reduction(+: result)
-#pragma omp parallel reduction(+ : result)
-        {
-          const int blockIdx = omp_get_team_num();
-          const int gridDim  = omp_get_num_teams();
-
-          // Guarantee that the compilers respect the `num_teams` clause
-          if (gridDim <= nteams) {
-            for (int league_id = blockIdx; league_id < league_size;
-                 league_id += gridDim) {
-              typename PolicyType::member_type team(
-                  league_id, league_size, team_size, vector_length, scratch_ptr,
-                  blockIdx, shmem_size_L0, shmem_size_L1);
-              if constexpr (std::is_void<TagType>::value)
-                f(team, result);
-              else
-                f(TagType(), team, result);
-            }
-          } else
-            Kokkos::abort("`num_teams` clause was not respected.\n");
-        }
-      } else {
-        // Case where the reduction is on a non-native data type.
-#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
-#pragma omp target teams num_teams(nteams) thread_limit(team_size) map(to   \
-                                                                       : f) \
-    is_device_ptr(scratch_ptr) reduction(custom                             \
-                                         : result)
-#pragma omp parallel reduction(custom : result)
-        {
-          const int blockIdx = omp_get_team_num();
-          const int gridDim  = omp_get_num_teams();
-
-          // Guarantee that the compilers respect the `num_teams` clause
-          if (gridDim <= nteams) {
-            for (int league_id = blockIdx; league_id < league_size;
-                 league_id += gridDim) {
-              typename PolicyType::member_type team(
-                  league_id, league_size, team_size, vector_length, scratch_ptr,
-                  blockIdx, shmem_size_L0, shmem_size_L1);
-              if constexpr (std::is_void<TagType>::value)
-                f(team, result);
-              else
-                f(TagType(), team, result);
-            }
-          } else
-            Kokkos::abort("`num_teams` clause was not respected.\n");
-        }
-      }
+  /** \brief set per team scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(const int& level,
+                                              const PerTeamValue& per_team) {
+    m_team_scratch_size[level] = per_team.value;
+    return *this;
+  }
 
-      // Copy results back to device if `parallel_reduce` is on a device view.
-      ParReduceCommon::memcpy_result(result_ptr, &result, sizeof(ValueType),
-                                     ptr_on_device);
-    } else {
-      ValueType result[NumReductions] = {};
-      // Case where the reduction is on an array.
-#pragma omp target teams num_teams(nteams) thread_limit(team_size) map(to   \
-                                                                       : f) \
-    is_device_ptr(scratch_ptr) reduction(+ : result[:NumReductions])
-#pragma omp parallel reduction(+ : result[:NumReductions])
-      {
-        const int blockIdx = omp_get_team_num();
-        const int gridDim  = omp_get_num_teams();
-
-        // Guarantee that the compilers respect the `num_teams` clause
-        if (gridDim <= nteams) {
-          for (int league_id = blockIdx; league_id < league_size;
-               league_id += gridDim) {
-            typename PolicyType::member_type team(
-                league_id, league_size, team_size, vector_length, scratch_ptr,
-                blockIdx, shmem_size_L0, shmem_size_L1);
-            if constexpr (std::is_void<TagType>::value)
-              f(team, result);
-            else
-              f(TagType(), team, result);
-          }
-        } else
-          Kokkos::abort("`num_teams` clause was not respected.\n");
-      }
+  /** \brief set per thread scratch size for a specific level of the scratch
+   * hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerThreadValue& per_thread) {
+    m_thread_scratch_size[level] = per_thread.value;
+    return *this;
+  }
 
-      // Copy results back to device if `parallel_reduce` is on a device view.
-      ParReduceCommon::memcpy_result(
-          result_ptr, result, NumReductions * sizeof(ValueType), ptr_on_device);
-    }
+  /** \brief set per thread and per team scratch size for a specific level of
+   * the scratch hierarchy */
+  inline TeamPolicyInternal& set_scratch_size(
+      const int& level, const PerTeamValue& per_team,
+      const PerThreadValue& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
+    m_thread_scratch_size[level] = per_thread.value;
+    return *this;
   }
 
-  // FIXME_OPENMPTARGET : This routine is a copy from `parallel_reduce` over
-  // RangePolicy. Need a new implementation.
-  static void execute_init_join(const FunctorType& f, const PolicyType& p,
-                                PointerType ptr, const bool ptr_on_device) {
-    using FunctorAnalysis =
-        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
-                              FunctorType>;
-    constexpr int HasInit = FunctorAnalysis::has_init_member_function;
-
-    const int league_size   = p.league_size();
-    const int team_size     = p.team_size();
-    const int vector_length = p.impl_vector_length();
-
-    auto begin = 0;
-    auto end   = league_size * team_size + team_size * vector_length;
-
-    const size_t shmem_size_L0 = p.scratch_size(0, team_size);
-    const size_t shmem_size_L1 = p.scratch_size(1, team_size);
-
-    // FIXME_OPENMPTARGET: This would oversubscribe scratch memory since we are
-    // already using the available scratch memory to create temporaries for each
-    // thread.
-    if ((shmem_size_L0 + shmem_size_L1) > 0) {
-      Kokkos::abort(
-          "OpenMPTarget: Scratch memory is not supported in `parallel_reduce` "
-          "over functors with init/join.");
-    }
+ private:
+  /** \brief finalize chunk_size if it was set to AUTO*/
+  inline void set_auto_chunk_size() {
+    int concurrency = 2048 * 128;
 
-    const auto nteams = league_size;
-
-    // Number of elements in the reduction
-    const auto value_count = FunctorAnalysis::value_count(f);
-
-    // Allocate scratch per active thread.
-    OpenMPTargetExec::resize_scratch(1, 0, value_count * sizeof(ValueType),
-                                     league_size);
-    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
-
-    // Enter this loop if the functor has an `init`
-    if constexpr (HasInit) {
-      // The `init` routine needs to be called on the device since it might need
-      // device members.
-#pragma omp target map(to : f) is_device_ptr(scratch_ptr)
-      {
-        typename FunctorAnalysis::Reducer final_reducer(&f);
-        final_reducer.init(scratch_ptr);
-        final_reducer.final(scratch_ptr);
-      }
-    } else {
-#pragma omp target map(to : f) is_device_ptr(scratch_ptr)
-      {
-        for (int i = 0; i < value_count; ++i) {
-          static_cast<ValueType*>(scratch_ptr)[i] = ValueType();
-        }
+    if (concurrency == 0) concurrency = 1;
 
-        typename FunctorAnalysis::Reducer final_reducer(&f);
-        final_reducer.final(static_cast<ValueType*>(scratch_ptr));
-      }
+    if (m_chunk_size > 0) {
+      if (!Impl::is_integral_power_of_two(m_chunk_size))
+        Kokkos::abort("TeamPolicy blocking granularity must be power of two");
     }
 
-    if (end <= begin) {
-      // If there is no work to be done, copy back the initialized values and
-      // exit.
-      if (!ptr_on_device)
-        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-            omp_get_initial_device(), omp_get_default_device()));
-      else
-        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-            omp_get_default_device(), omp_get_default_device()));
-
-      return;
+    int new_chunk_size = 1;
+    while (new_chunk_size * 100 * concurrency < m_league_size)
+      new_chunk_size *= 2;
+    if (new_chunk_size < 128) {
+      new_chunk_size = 1;
+      while ((new_chunk_size * 40 * concurrency < m_league_size) &&
+             (new_chunk_size < 128))
+        new_chunk_size *= 2;
     }
-
-#pragma omp target teams num_teams(nteams) thread_limit(team_size) map(to   \
-                                                                       : f) \
-    is_device_ptr(scratch_ptr)
-    {
-#pragma omp parallel
-      {
-        const int team_num      = omp_get_team_num();
-        const int num_teams     = omp_get_num_teams();
-        ValueType* team_scratch = static_cast<ValueType*>(scratch_ptr) +
-                                  team_num * team_size * value_count;
-        typename FunctorAnalysis::Reducer final_reducer(&f);
-        ReferenceType result = final_reducer.init(&team_scratch[0]);
-
-        for (int league_id = team_num; league_id < league_size;
-             league_id += num_teams) {
-          typename PolicyType::member_type team(
-              league_id, league_size, team_size, vector_length, scratch_ptr,
-              team_num, shmem_size_L0, shmem_size_L1);
-          if constexpr (std::is_void<TagType>::value) {
-            f(team, result);
-          } else {
-            f(TagType(), team, result);
-          }
-        }
-      }  // end parallel
-    }    // end target
-
-    int tree_neighbor_offset = 1;
-    do {
-#pragma omp target teams distribute parallel for simd map(to   \
-                                                          : f) \
-    is_device_ptr(scratch_ptr)
-      for (int i = 0; i < nteams - tree_neighbor_offset;
-           i += 2 * tree_neighbor_offset) {
-        ValueType* team_scratch = static_cast<ValueType*>(scratch_ptr);
-        const int team_offset   = team_size * value_count;
-        typename FunctorAnalysis::Reducer final_reducer(&f);
-        final_reducer.join(
-            &team_scratch[i * team_offset],
-            &team_scratch[(i + tree_neighbor_offset) * team_offset]);
-
-        // If `final` is provided by the functor.
-        // Do the final only once at the end.
-        if (tree_neighbor_offset * 2 >= nteams && omp_get_team_num() == 0 &&
-            omp_get_thread_num() == 0) {
-          final_reducer.final(scratch_ptr);
-        }
-      }
-      tree_neighbor_offset *= 2;
-    } while (tree_neighbor_offset < nteams);
-
-    // If the result view is on the host, copy back the values via memcpy.
-    if (!ptr_on_device)
-      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-          omp_get_initial_device(), omp_get_default_device()));
-    else
-      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
-          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
-          omp_get_default_device(), omp_get_default_device()));
+    m_chunk_size = new_chunk_size;
   }
-};
-
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::Experimental::OpenMPTarget> {
- private:
-  using Policy =
-      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget,
-                                       Properties...>;
-
-  using WorkTag = typename Policy::work_tag;
-  using Member  = typename Policy::member_type;
-  using ReducerTypeFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         Policy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-  using value_type     = typename Analysis::value_type;
-
-  bool m_result_ptr_on_device;
-  const int m_result_ptr_num_elems;
-
-  static constexpr int HasJoin =
-      Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, Policy,
-                            FunctorType>::has_join_member_function;
-  static constexpr int UseReducer = is_reducer<ReducerType>::value;
-  static constexpr int IsArray    = std::is_pointer<reference_type>::value;
-
-  using ParReduceSpecialize =
-      ParallelReduceSpecialize<FunctorType, Policy, ReducerType, pointer_type,
-                               typename Analysis::value_type>;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const ReducerType m_reducer;
-  const pointer_type m_result_ptr;
-  const size_t m_shmem_size;
 
  public:
-  void execute() const {
-    if constexpr (HasJoin) {
-      ParReduceSpecialize::execute_init_join(m_functor, m_policy, m_result_ptr,
-                                             m_result_ptr_on_device);
-    } else if constexpr (UseReducer) {
-      ParReduceSpecialize::execute_reducer(m_functor, m_policy, m_result_ptr,
-                                           m_result_ptr_on_device);
-    } else if constexpr (IsArray) {
-      if (m_result_ptr_num_elems <= 2) {
-        ParReduceSpecialize::template execute_array<2>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 4) {
-        ParReduceSpecialize::template execute_array<4>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 8) {
-        ParReduceSpecialize::template execute_array<8>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 16) {
-        ParReduceSpecialize::template execute_array<16>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else if (m_result_ptr_num_elems <= 32) {
-        ParReduceSpecialize::template execute_array<32>(
-            m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-      } else {
-        Kokkos::abort("array reduction length must be <= 32");
-      }
-    } else {
-      ParReduceSpecialize::template execute_array<1>(
-          m_functor, m_policy, m_result_ptr, m_result_ptr_on_device);
-    }
-  }
-
-  template <class ViewType>
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ViewType& arg_result,
-                 std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void*> = nullptr)
-      : m_result_ptr_on_device(
-            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                              typename ViewType::memory_space>::accessible),
-        m_result_ptr_num_elems(arg_result.size()),
-        m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(InvalidType()),
-        m_result_ptr(arg_result.data()),
-        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                     FunctorTeamShmemSize<FunctorType>::value(
-                         arg_functor, arg_policy.team_size())) {}
-
-  ParallelReduce(const FunctorType& arg_functor, Policy& arg_policy,
-                 const ReducerType& reducer)
-      : m_result_ptr_on_device(
-            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_result_ptr_num_elems(reducer.view().size()),
-        m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                     FunctorTeamShmemSize<FunctorType>::value(
-                         arg_functor, arg_policy.team_size())) {}
+  using member_type = Impl::OpenMPTargetExecTeamMember;
 };
 
 }  // namespace Impl
 }  // namespace Kokkos
 
+namespace Kokkos {
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                const iType& count) {
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
+}
+
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamThreadRangeBoundariesStruct<
+    std::common_type_t<iType1, iType2>, Impl::OpenMPTargetExecTeamMember>
+TeamThreadRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                const iType1& begin, const iType2& end) {
+  using iType = std::common_type_t<iType1, iType2>;
+  return Impl::TeamThreadRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, iType(begin),
+                                               iType(end));
+}
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                  const iType& count) {
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
+}
+
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::ThreadVectorRangeBoundariesStruct<
+    std::common_type_t<iType1, iType2>, Impl::OpenMPTargetExecTeamMember>
+ThreadVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                  const iType1& arg_begin, const iType2& arg_end) {
+  using iType = std::common_type_t<iType1, iType2>;
+  return Impl::ThreadVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, iType(arg_begin),
+                                               iType(arg_end));
+}
+
+template <typename iType>
+KOKKOS_INLINE_FUNCTION Impl::TeamVectorRangeBoundariesStruct<
+    iType, Impl::OpenMPTargetExecTeamMember>
+TeamVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                const iType& count) {
+  return Impl::TeamVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, count);
+}
+
+template <typename iType1, typename iType2>
+KOKKOS_INLINE_FUNCTION Impl::TeamVectorRangeBoundariesStruct<
+    std::common_type_t<iType1, iType2>, Impl::OpenMPTargetExecTeamMember>
+TeamVectorRange(const Impl::OpenMPTargetExecTeamMember& thread,
+                const iType1& arg_begin, const iType2& arg_end) {
+  using iType = std::common_type_t<iType1, iType2>;
+  return Impl::TeamVectorRangeBoundariesStruct<
+      iType, Impl::OpenMPTargetExecTeamMember>(thread, iType(arg_begin),
+                                               iType(arg_end));
+}
+
+KOKKOS_INLINE_FUNCTION
+Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember> PerTeam(
+    const Impl::OpenMPTargetExecTeamMember& thread) {
+  return Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>(thread);
+}
+
+KOKKOS_INLINE_FUNCTION
+Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember> PerThread(
+    const Impl::OpenMPTargetExecTeamMember& thread) {
+  return Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>(thread);
+}
+}  // namespace Kokkos
+
+namespace Kokkos {
+
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+    /*single_struct*/,
+    const FunctorType& lambda) {
+  lambda();
+}
+
+template <class FunctorType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+        single_struct,
+    const FunctorType& lambda) {
+  if (single_struct.team_member.team_rank() == 0) lambda();
+}
+
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::VectorSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+    /*single_struct*/,
+    const FunctorType& lambda, ValueType& val) {
+  lambda(val);
+}
+
+template <class FunctorType, class ValueType>
+KOKKOS_INLINE_FUNCTION void single(
+    const Impl::ThreadSingleStruct<Impl::OpenMPTargetExecTeamMember>&
+        single_struct,
+    const FunctorType& lambda, ValueType& val) {
+  if (single_struct.team_member.team_rank() == 0) {
+    lambda(val);
+  }
+  single_struct.team_member.team_broadcast(val, 0);
+}
+}  // namespace Kokkos
+
 namespace Kokkos {
 namespace Impl {
 
@@ -1320,5 +721,43 @@ struct TeamVectorRangeBoundariesStruct<iType, OpenMPTargetExecTeamMember> {
 }  // namespace Kokkos
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
+namespace Kokkos {
+namespace Impl {
+
+//----------------------------------------------------------------------------
+/** \brief  Data for OpenMPTarget thread execution */
+
+class OpenMPTargetExec {
+ public:
+  // FIXME_OPENMPTARGET - Currently the maximum number of
+  // teams possible is calculated based on NVIDIA's Volta GPU. In
+  // future this value should be based on the chosen architecture for the
+  // OpenMPTarget backend.
+  static int MAX_ACTIVE_THREADS;
+
+ private:
+  static void* scratch_ptr;
+
+ public:
+  static void verify_is_process(const char* const);
+  static void verify_initialized(const char* const);
+
+  static int* get_lock_array(int num_teams);
+  static void* get_scratch_ptr();
+  static void clear_scratch();
+  static void clear_lock_array();
+  static void resize_scratch(int64_t team_reduce_bytes,
+                             int64_t team_shared_bytes,
+                             int64_t thread_local_bytes, int64_t league_size);
+
+  static void* m_scratch_ptr;
+  static int64_t m_scratch_size;
+  static int* m_lock_array;
+  static uint64_t m_lock_size;
+  static uint32_t* m_uniquetoken_ptr;
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
 
 #endif /* KOKKOS_OPENMPTARGET_PARALLEL_HPP */
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Range.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Range.hpp
new file mode 100644
index 0000000000..a674637a3b
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Range.hpp
@@ -0,0 +1,71 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLEL_FOR_RANGE_HPP
+#define KOKKOS_OPENMPTARGET_PARALLEL_FOR_RANGE_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Experimental::OpenMPTarget> {
+ private:
+  using Policy  = Kokkos::RangePolicy<Traits...>;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+ public:
+  void execute() const { execute_impl<WorkTag>(); }
+
+  template <class TagType>
+  void execute_impl() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const auto begin = m_policy.begin();
+    const auto end   = m_policy.end();
+
+    if (end <= begin) return;
+
+    FunctorType a_functor(m_functor);
+
+#pragma omp target teams distribute parallel for map(to : a_functor)
+    for (auto i = begin; i < end; ++i) {
+      if constexpr (std::is_void<TagType>::value) {
+        a_functor(i);
+      } else {
+        a_functor(TagType(), i);
+      }
+    }
+  }
+
+  ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp
new file mode 100644
index 0000000000..1abc925cae
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp
@@ -0,0 +1,201 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLEL_FOR_TEAM_HPP
+#define KOKKOS_OPENMPTARGET_PARALLEL_FOR_TEAM_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
+
+namespace Kokkos {
+
+/** \brief  Inter-thread parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team.
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+#pragma omp for nowait schedule(static, 1)
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) lambda(i);
+}
+
+/** \brief  Intra-thread vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread.
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+#pragma omp simd
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) lambda(i);
+}
+
+/** \brief  Intra-team vector parallel_for. Executes lambda(iType i) for each
+ * i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling team.
+ */
+template <typename iType, class Lambda>
+KOKKOS_INLINE_FUNCTION void parallel_for(
+    const Impl::TeamVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda) {
+#pragma omp for simd nowait schedule(static, 1)
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) lambda(i);
+}
+
+namespace Impl {
+
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::Experimental::OpenMPTarget> {
+ private:
+  using Policy =
+      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget,
+                                       Properties...>;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const size_t m_shmem_size;
+
+ public:
+  void execute() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    execute_impl<WorkTag>();
+  }
+
+ private:
+  template <class TagType>
+  void execute_impl() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const auto league_size   = m_policy.league_size();
+    const auto team_size     = m_policy.team_size();
+    const auto vector_length = m_policy.impl_vector_length();
+
+    const size_t shmem_size_L0 = m_policy.scratch_size(0, team_size);
+    const size_t shmem_size_L1 = m_policy.scratch_size(1, team_size);
+    OpenMPTargetExec::resize_scratch(team_size, shmem_size_L0, shmem_size_L1,
+                                     league_size);
+
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+    FunctorType a_functor(m_functor);
+
+    // FIXME_OPENMPTARGET - If the team_size is not a multiple of 32, the
+    // scratch implementation does not work in the Release or RelWithDebugInfo
+    // mode but works in the Debug mode.
+
+    // Maximum active teams possible.
+    // FIXME_OPENMPTARGET: Cray compiler did not yet implement
+    // omp_get_max_teams.
+#if !defined(KOKKOS_COMPILER_CRAY_LLVM)
+    int max_active_teams = omp_get_max_teams();
+#else
+    int max_active_teams =
+        std::min(OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size, league_size);
+#endif
+
+    // FIXME_OPENMPTARGET: Although the maximum number of teams is set using the
+    // omp_set_num_teams in the resize_scratch routine, the call is not
+    // respected. Hence we need to use `num_teams` routine to restrict the
+    // number of teams generated to max_active_teams. Hopefully we can avoid the
+    // num_teams clause in the future and let compiler pick the right number of
+    // teams. This is not true for Intel architectures.
+
+    // If the league size is <=0, do not launch the kernel.
+    if (max_active_teams <= 0) return;
+
+// Performing our own scheduling of teams to avoid separation of code between
+// teams-distribute and parallel. Gave a 2x performance boost in test cases with
+// the clang compiler. atomic_compare_exchange can be avoided since the standard
+// guarantees that the number of teams specified in the `num_teams` clause is
+// always less than or equal to the maximum concurrently running teams.
+#if !defined(KOKKOS_IMPL_OPENMPTARGET_HIERARCHICAL_INTEL_GPU)
+#pragma omp target teams thread_limit(team_size) firstprivate(a_functor) \
+    num_teams(max_active_teams) is_device_ptr(scratch_ptr)
+#pragma omp parallel
+    {
+      if (omp_get_num_teams() > max_active_teams)
+        Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+      const int blockIdx = omp_get_team_num();
+      const int gridDim  = omp_get_num_teams();
+
+      // Iterate through the number of teams until league_size and assign the
+      // league_id accordingly
+      // Guarantee that the compilers respect the `num_teams` clause
+      for (int league_id = blockIdx; league_id < league_size;
+           league_id += gridDim) {
+        typename Policy::member_type team(league_id, league_size, team_size,
+                                          vector_length, scratch_ptr, blockIdx,
+                                          shmem_size_L0, shmem_size_L1);
+        if constexpr (std::is_void_v<TagType>)
+          m_functor(team);
+        else
+          m_functor(TagType(), team);
+      }
+    }
+#else
+#pragma omp target teams distribute firstprivate(a_functor) \
+    is_device_ptr(scratch_ptr) num_teams(max_active_teams)  \
+        thread_limit(team_size)
+    for (int i = 0; i < league_size; i++) {
+#pragma omp parallel
+      {
+        if (omp_get_num_teams() > max_active_teams)
+          Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+        typename Policy::member_type team(i, league_size, team_size,
+                                          vector_length, scratch_ptr, i,
+                                          shmem_size_L0, shmem_size_L1);
+        if constexpr (std::is_void_v<TagType>)
+          m_functor(team);
+        else
+          m_functor(TagType(), team);
+      }
+    }
+#endif
+  }
+
+ public:
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_shmem_size(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+                     FunctorTeamShmemSize<FunctorType>::value(
+                         arg_functor, arg_policy.team_size())) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp
new file mode 100644
index 0000000000..4452af3846
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp
@@ -0,0 +1,114 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLELREDUCE_RANGE_HPP
+#define KOKKOS_OPENMPTARGET_PARALLELREDUCE_RANGE_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
+                     Kokkos::Experimental::OpenMPTarget> {
+ private:
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using WorkTag = typename Policy::work_tag;
+
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+
+  static constexpr bool FunctorHasJoin = Impl::FunctorAnalysis<
+      Impl::FunctorPatternInterface::REDUCE, Policy, FunctorType,
+      typename ReducerType::value_type>::Reducer::has_join_member_function();
+  static constexpr bool UseReducer =
+      !std::is_same_v<FunctorType, typename ReducerType::functor_type>;
+  static constexpr bool IsArray = std::is_pointer_v<reference_type>;
+
+  using ParReduceSpecialize =
+      ParallelReduceSpecialize<FunctorType, Policy,
+                               typename ReducerType::functor_type, pointer_type,
+                               typename ReducerType::value_type>;
+
+  const CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  bool m_result_ptr_on_device;
+  const int m_result_ptr_num_elems;
+  using TagType = typename Policy::work_tag;
+
+ public:
+  void execute() const {
+    const FunctorType& functor = m_functor_reducer.get_functor();
+    if constexpr (FunctorHasJoin) {
+      // Enter this loop if the Functor has a init-join.
+      ParReduceSpecialize::execute_init_join(functor, m_policy, m_result_ptr,
+                                             m_result_ptr_on_device);
+    } else if constexpr (UseReducer) {
+      // Enter this loop if the Functor is a reducer type.
+      ParReduceSpecialize::execute_reducer(functor, m_policy, m_result_ptr,
+                                           m_result_ptr_on_device);
+    } else if constexpr (IsArray) {
+      // Enter this loop if the reduction is on an array and the routine is
+      // templated over the size of the array.
+      if (m_result_ptr_num_elems <= 2) {
+        ParReduceSpecialize::template execute_array<TagType, 2>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 4) {
+        ParReduceSpecialize::template execute_array<TagType, 4>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 8) {
+        ParReduceSpecialize::template execute_array<TagType, 8>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 16) {
+        ParReduceSpecialize::template execute_array<TagType, 16>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 32) {
+        ParReduceSpecialize::template execute_array<TagType, 32>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else {
+        Kokkos::abort("array reduction length must be <= 32");
+      }
+    } else {
+      // This loop handles the basic scalar reduction.
+      ParReduceSpecialize::template execute_array<TagType, 1>(
+          functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+    }
+  }
+
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result_view)
+      : m_functor_reducer(arg_functor_reducer),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result_view.data()),
+        m_result_ptr_on_device(
+            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_result_ptr_num_elems(arg_result_view.size()) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp
new file mode 100644
index 0000000000..a302fa7151
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp
@@ -0,0 +1,530 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLELREDUCE_TEAM_HPP
+#define KOKKOS_OPENMPTARGET_PARALLELREDUCE_TEAM_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp>
+
+// FIXME_OPENMPTARGET - Using this macro to implement a workaround for
+// hierarchical reducers. It avoids hitting the code path which we wanted to
+// write but doesn't work. undef'ed at the end.
+// Intel compilers prefer the non-workaround version.
+#ifndef KOKKOS_ARCH_INTEL_GPU
+#define KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
+#endif
+
+namespace Kokkos {
+
+/** \brief  Inter-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all threads of the the calling thread team
+ * and a summation of val is performed and put into result.
+ */
+
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<!Kokkos::is_reducer<ValueType>::value>
+parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+                const Lambda& lambda, ValueType& result) {
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+  ValueType* TeamThread_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+#pragma omp barrier
+  TeamThread_scratch[0] = ValueType();
+#pragma omp barrier
+
+  if constexpr (std::is_arithmetic<ValueType>::value) {
+#pragma omp for reduction(+ : TeamThread_scratch[:1])
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      ValueType tmp = ValueType();
+      lambda(i, tmp);
+      TeamThread_scratch[0] += tmp;
+    }
+  } else {
+#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
+
+#pragma omp for reduction(custom : TeamThread_scratch[:1])
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      ValueType tmp = ValueType();
+      lambda(i, tmp);
+      TeamThread_scratch[0] += tmp;
+    }
+  }
+
+  result = TeamThread_scratch[0];
+}
+
+#if !defined(KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND)
+// For some reason the actual version we wanted to write doesn't work
+// and crashes. We should try this with every new compiler
+// This is the variant we actually wanted to write
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
+parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+                const Lambda& lambda, ReducerType result) {
+  using ValueType = typename ReducerType::value_type;
+
+#pragma omp declare reduction(                                               \
+    custominner:ValueType                                                    \
+    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(                                                             \
+        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+  ValueType* TeamThread_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+#pragma omp barrier
+  Impl::OpenMPTargetReducerWrapper<ReducerType>::init(TeamThread_scratch[0]);
+#pragma omp barrier
+
+#pragma omp for reduction(custominner : TeamThread_scratch[:1])
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    lambda(i, TeamThread_scratch[0]);
+  }
+  result.reference() = TeamThread_scratch[0];
+}
+#else
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
+parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
+                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+                const Lambda& lambda, ReducerType result) {
+  using ValueType = typename ReducerType::value_type;
+
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+  ValueType* TeamThread_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+#pragma omp declare reduction(                                               \
+    omp_red_teamthread_reducer:ValueType                                     \
+    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(                                                             \
+        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+#pragma omp barrier
+  ValueType tmp;
+  result.init(tmp);
+  TeamThread_scratch[0] = tmp;
+#pragma omp barrier
+
+  iType team_size = iType(omp_get_num_threads());
+#pragma omp for reduction(omp_red_teamthread_reducer \
+                          : TeamThread_scratch[:1]) schedule(static, 1)
+  for (iType t = 0; t < team_size; t++) {
+    ValueType tmp2;
+    result.init(tmp2);
+
+    for (iType i = loop_boundaries.start + t; i < loop_boundaries.end;
+         i += team_size) {
+      lambda(i, tmp2);
+    }
+
+    // FIXME_OPENMPTARGET: Join should work but doesn't. Every threads gets a
+    // private TeamThread_scratch[0] and at the end of the for-loop the `join`
+    // operation is performed by OpenMP itself and hence the simple assignment
+    // works.
+    //    result.join(TeamThread_scratch[0], tmp2);
+    TeamThread_scratch[0] = tmp2;
+  }
+
+  result.reference() = TeamThread_scratch[0];
+}
+#endif  // KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
+
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *').
+ */
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
+  ValueType* TeamThread_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+  // FIXME_OPENMPTARGET: Still need to figure out how to get value_count here.
+  const int value_count = 1;
+
+#pragma omp barrier
+  TeamThread_scratch[0] = init_result;
+#pragma omp barrier
+
+#pragma omp for
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    lambda(i, TeamThread_scratch[omp_get_num_threads() * value_count]);
+  }
+
+  // Reduce all partial results within a team.
+  const int team_size      = omp_get_num_threads();
+  int tree_neighbor_offset = 1;
+  do {
+#pragma omp for
+    for (int i = 0; i < team_size - tree_neighbor_offset;
+         i += 2 * tree_neighbor_offset) {
+      const int neighbor = i + tree_neighbor_offset;
+      join(lambda, &TeamThread_scratch[i * value_count],
+           &TeamThread_scratch[neighbor * value_count]);
+    }
+    tree_neighbor_offset *= 2;
+  } while (tree_neighbor_offset < team_size);
+  init_result = TeamThread_scratch[0];
+}
+
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a summation of val is performed and put into result.
+ */
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
+  ValueType vector_reduce = ValueType();
+
+  if constexpr (std::is_arithmetic<ValueType>::value) {
+#pragma omp simd reduction(+ : vector_reduce)
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      ValueType tmp = ValueType();
+      lambda(i, tmp);
+      vector_reduce += tmp;
+    }
+  } else {
+#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
+
+#pragma omp simd reduction(custom : vector_reduce)
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      lambda(i, vector_reduce);
+    }
+  }
+
+  result = vector_reduce;
+}
+
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
+parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
+                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+                const Lambda& lambda, ReducerType const& result) {
+  using ValueType = typename ReducerType::value_type;
+
+#pragma omp declare reduction(                                               \
+    custom:ValueType                                                         \
+    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(                                                             \
+        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+  ValueType vector_reduce;
+  Impl::OpenMPTargetReducerWrapper<ReducerType>::init(vector_reduce);
+
+#pragma omp simd reduction(custom : vector_reduce)
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    lambda(i, vector_reduce);
+  }
+
+  result.reference() = vector_reduce;
+}
+
+/** \brief  Intra-thread vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling thread
+ * and a reduction of val is performed using JoinType(ValueType& val, const
+ * ValueType& update) and put into init_result. The input value of init_result
+ * is used as initializer for temporary variables of ValueType. Therefore the
+ * input value should be the neutral element with respect to the join operation
+ * (e.g. '0 for +-' or '1 for *').
+ */
+template <typename iType, class Lambda, typename ValueType, class JoinType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, const JoinType& join, ValueType& init_result) {
+  ValueType result = init_result;
+
+  // FIXME_OPENMPTARGET think about omp simd
+  // join does not work with omp reduction clause
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    ValueType tmp = ValueType();
+    lambda(i, tmp);
+    join(result, tmp);
+  }
+
+  init_result = result;
+}
+
+/** \brief  Intra-team vector parallel_reduce. Executes lambda(iType i,
+ * ValueType & val) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes of the the calling team
+ * and a summation of val is performed and put into result.
+ */
+template <typename iType, class Lambda, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    const Impl::TeamVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const Lambda& lambda, ValueType& result) {
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+  ValueType* TeamVector_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+#pragma omp barrier
+  TeamVector_scratch[0] = ValueType();
+#pragma omp barrier
+
+  if constexpr (std::is_arithmetic<ValueType>::value) {
+#pragma omp for simd reduction(+ : TeamVector_scratch[:1])
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      ValueType tmp = ValueType();
+      lambda(i, tmp);
+      TeamVector_scratch[0] += tmp;
+    }
+  } else {
+#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
+
+#pragma omp for simd reduction(custom : TeamVector_scratch[:1])
+    for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+      ValueType tmp = ValueType();
+      lambda(i, tmp);
+      TeamVector_scratch[0] += tmp;
+    }
+  }
+
+  result = TeamVector_scratch[0];
+}
+
+#if !defined(KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND)
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
+parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
+                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+                const Lambda& lambda, ReducerType const& result) {
+  using ValueType = typename ReducerType::value_type;
+
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+#pragma omp declare reduction(                                               \
+    custom:ValueType                                                         \
+    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(                                                             \
+        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+  ValueType* TeamVector_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+#pragma omp barrier
+  Impl::OpenMPTargetReducerWrapper<ReducerType>::init(TeamVector_scratch[0]);
+#pragma omp barrier
+
+#pragma omp for simd reduction(custom : TeamVector_scratch[:1])
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; i++) {
+    lambda(i, TeamVector_scratch[0]);
+  }
+
+  result.reference() = TeamVector_scratch[0];
+}
+#else
+template <typename iType, class Lambda, typename ReducerType>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<Kokkos::is_reducer<ReducerType>::value>
+parallel_reduce(const Impl::TeamVectorRangeBoundariesStruct<
+                    iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+                const Lambda& lambda, ReducerType const& result) {
+  using ValueType = typename ReducerType::value_type;
+
+  // FIXME_OPENMPTARGET - Make sure that if its an array reduction, number of
+  // elements in the array <= 32. For reduction we allocate, 16 bytes per
+  // element in the scratch space, hence, 16*32 = 512.
+  static_assert(sizeof(ValueType) <=
+                Impl::OpenMPTargetExecTeamMember::TEAM_REDUCE_SIZE);
+
+  ValueType* TeamVector_scratch =
+      static_cast<ValueType*>(loop_boundaries.team.impl_reduce_scratch());
+
+#pragma omp declare reduction(                                               \
+    omp_red_teamthread_reducer:ValueType                                     \
+    : Impl::OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(                                                             \
+        Impl::OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+#pragma omp barrier
+  ValueType tmp;
+  result.init(tmp);
+  TeamVector_scratch[0] = tmp;
+#pragma omp barrier
+
+  iType team_size = iType(omp_get_num_threads());
+#pragma omp for simd reduction(omp_red_teamthread_reducer \
+                               : TeamVector_scratch[:1]) schedule(static, 1)
+  for (iType t = 0; t < team_size; t++) {
+    ValueType tmp2;
+    result.init(tmp2);
+
+    for (iType i = loop_boundaries.start + t; i < loop_boundaries.end;
+         i += team_size) {
+      lambda(i, tmp2);
+    }
+    TeamVector_scratch[0] = tmp2;
+  }
+
+  result.reference() = TeamVector_scratch[0];
+}
+#endif  // KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
+
+namespace Impl {
+
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>,
+                     Kokkos::Experimental::OpenMPTarget> {
+ private:
+  using Policy =
+      Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::OpenMPTarget,
+                                       Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+  using value_type     = typename ReducerType::value_type;
+
+  bool m_result_ptr_on_device;
+  const int m_result_ptr_num_elems;
+
+  static constexpr bool FunctorHasJoin = Impl::FunctorAnalysis<
+      Impl::FunctorPatternInterface::REDUCE, Policy, FunctorType,
+      typename ReducerType::value_type>::Reducer::has_join_member_function();
+  static constexpr bool UseReducer =
+      !std::is_same_v<FunctorType, typename ReducerType::functor_type>;
+  static constexpr bool IsArray = std::is_pointer_v<reference_type>;
+
+  using ParReduceSpecialize =
+      ParallelReduceSpecialize<FunctorType, Policy,
+                               typename ReducerType::functor_type, pointer_type,
+                               typename ReducerType::value_type>;
+
+  const CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const size_t m_shmem_size;
+
+ public:
+  void execute() const {
+    const FunctorType& functor = m_functor_reducer.get_functor();
+    if constexpr (FunctorHasJoin) {
+      ParReduceSpecialize::execute_init_join(functor, m_policy, m_result_ptr,
+                                             m_result_ptr_on_device);
+    } else if constexpr (UseReducer) {
+      ParReduceSpecialize::execute_reducer(functor, m_policy, m_result_ptr,
+                                           m_result_ptr_on_device);
+    } else if constexpr (IsArray) {
+      if (m_result_ptr_num_elems <= 2) {
+        ParReduceSpecialize::template execute_array<2>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 4) {
+        ParReduceSpecialize::template execute_array<4>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 8) {
+        ParReduceSpecialize::template execute_array<8>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 16) {
+        ParReduceSpecialize::template execute_array<16>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else if (m_result_ptr_num_elems <= 32) {
+        ParReduceSpecialize::template execute_array<32>(
+            functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+      } else {
+        Kokkos::abort("array reduction length must be <= 32");
+      }
+    } else {
+      ParReduceSpecialize::template execute_array<1>(
+          functor, m_policy, m_result_ptr, m_result_ptr_on_device);
+    }
+  }
+
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_result_ptr_on_device(
+            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_result_ptr_num_elems(arg_result.size()),
+        m_functor_reducer(arg_functor_reducer),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result.data()),
+        m_shmem_size(
+            arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
+            FunctorTeamShmemSize<FunctorType>::value(
+                arg_functor_reducer.get_functor(), arg_policy.team_size())) {}
+};
+
+}  // namespace Impl
+
+#ifdef KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
+#undef KOKKOS_IMPL_HIERARCHICAL_REDUCERS_WORKAROUND
+#endif
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp
new file mode 100644
index 0000000000..22acb7e3c5
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp
@@ -0,0 +1,260 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLELSCAN_RANGE_HPP
+#define KOKKOS_OPENMPTARGET_PARALLELSCAN_RANGE_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Experimental::OpenMPTarget> {
+ protected:
+  using Policy = Kokkos::RangePolicy<Traits...>;
+
+  using WorkTag  = typename Policy::work_tag;
+  using Member   = typename Policy::member_type;
+  using idx_type = typename Policy::index_type;
+
+  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                                         Policy, FunctorType, void>;
+
+  using value_type     = typename Analysis::value_type;
+  using pointer_type   = typename Analysis::pointer_type;
+  using reference_type = typename Analysis::reference_type;
+
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
+  const Policy m_policy;
+
+  value_type* m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+
+  template <class TagType>
+  std::enable_if_t<std::is_void<TagType>::value> call_with_tag(
+      const FunctorType& f, const idx_type& idx, value_type& val,
+      const bool& is_final) const {
+    f(idx, val, is_final);
+  }
+  template <class TagType>
+  std::enable_if_t<!std::is_void<TagType>::value> call_with_tag(
+      const FunctorType& f, const idx_type& idx, value_type& val,
+      const bool& is_final) const {
+    f(WorkTag(), idx, val, is_final);
+  }
+
+ public:
+  void impl_execute(
+      Kokkos::View<value_type**, Kokkos::LayoutRight,
+                   Kokkos::Experimental::OpenMPTargetSpace>
+          element_values,
+      Kokkos::View<value_type*, Kokkos::Experimental::OpenMPTargetSpace>
+          chunk_values,
+      Kokkos::View<int64_t, Kokkos::Experimental::OpenMPTargetSpace> count)
+      const {
+    const idx_type N          = m_policy.end() - m_policy.begin();
+    const idx_type chunk_size = 128;
+    const idx_type n_chunks   = (N + chunk_size - 1) / chunk_size;
+    idx_type nteams           = n_chunks > 512 ? 512 : n_chunks;
+    idx_type team_size        = 128;
+
+    auto a_functor_reducer = m_functor_reducer;
+#pragma omp target teams distribute map(to \
+                                        : a_functor_reducer) num_teams(nteams)
+    for (idx_type team_id = 0; team_id < n_chunks; ++team_id) {
+      const typename Analysis::Reducer& reducer =
+          a_functor_reducer.get_reducer();
+#pragma omp parallel num_threads(team_size)
+      {
+        const idx_type local_offset = team_id * chunk_size;
+
+#pragma omp for
+        for (idx_type i = 0; i < chunk_size; ++i) {
+          const idx_type idx = local_offset + i;
+          value_type val;
+          reducer.init(&val);
+          if (idx < N)
+            call_with_tag<WorkTag>(a_functor_reducer.get_functor(), idx, val,
+                                   false);
+          element_values(team_id, i) = val;
+        }
+#pragma omp barrier
+        if (omp_get_thread_num() == 0) {
+          value_type sum;
+          reducer.init(&sum);
+          for (idx_type i = 0; i < chunk_size; ++i) {
+            reducer.join(&sum, &element_values(team_id, i));
+            element_values(team_id, i) = sum;
+          }
+          chunk_values(team_id) = sum;
+        }
+#pragma omp barrier
+        if (omp_get_thread_num() == 0) {
+          if (Kokkos::atomic_fetch_add(&count(), 1) == n_chunks - 1) {
+            value_type sum;
+            reducer.init(&sum);
+            for (idx_type i = 0; i < n_chunks; ++i) {
+              reducer.join(&sum, &chunk_values(i));
+              chunk_values(i) = sum;
+            }
+          }
+        }
+      }
+    }
+
+#pragma omp target teams distribute map(to                                     \
+                                        : a_functor_reducer) num_teams(nteams) \
+    thread_limit(team_size)
+    for (idx_type team_id = 0; team_id < n_chunks; ++team_id) {
+      const typename Analysis::Reducer& reducer =
+          a_functor_reducer.get_reducer();
+#pragma omp parallel num_threads(team_size)
+      {
+        const idx_type local_offset = team_id * chunk_size;
+        value_type offset_value;
+        if (team_id > 0)
+          offset_value = chunk_values(team_id - 1);
+        else
+          reducer.init(&offset_value);
+
+#pragma omp for
+        for (idx_type i = 0; i < chunk_size; ++i) {
+          const idx_type idx = local_offset + i;
+          value_type local_offset_value;
+          if (i > 0) {
+            local_offset_value = element_values(team_id, i - 1);
+            // FIXME_OPENMPTARGET We seem to access memory illegaly on AMD GPUs
+#ifdef KOKKOS_ARCH_VEGA
+            if constexpr (Analysis::Reducer::has_join_member_function()) {
+              if constexpr (std::is_void_v<WorkTag>)
+                a_functor_reducer.get_functor().join(local_offset_value,
+                                                     offset_value);
+              else
+                a_functor_reducer.get_functor().join(
+                    WorkTag{}, local_offset_value, offset_value);
+            } else
+              local_offset_value += offset_value;
+#else
+            reducer.join(&local_offset_value, &offset_value);
+#endif
+          } else
+            local_offset_value = offset_value;
+          if (idx < N)
+            call_with_tag<WorkTag>(a_functor_reducer.get_functor(), idx,
+                                   local_offset_value, true);
+          if (idx == N - 1 && m_result_ptr_device_accessible)
+            *m_result_ptr = local_offset_value;
+        }
+      }
+    }
+  }
+
+  void execute() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const idx_type N          = m_policy.end() - m_policy.begin();
+    const idx_type chunk_size = 128;
+    const idx_type n_chunks   = (N + chunk_size - 1) / chunk_size;
+
+    // This could be scratch memory per team
+    Kokkos::View<value_type**, Kokkos::LayoutRight,
+                 Kokkos::Experimental::OpenMPTargetSpace>
+        element_values("element_values", n_chunks, chunk_size);
+    Kokkos::View<value_type*, Kokkos::Experimental::OpenMPTargetSpace>
+        chunk_values("chunk_values", n_chunks);
+    Kokkos::View<int64_t, Kokkos::Experimental::OpenMPTargetSpace> count(
+        "Count");
+
+    impl_execute(element_values, chunk_values, count);
+  }
+
+  //----------------------------------------
+
+  ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy,
+               pointer_type arg_result_ptr           = nullptr,
+               bool arg_result_ptr_device_accessible = false)
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
+        m_policy(arg_policy),
+        m_result_ptr(arg_result_ptr),
+        m_result_ptr_device_accessible(arg_result_ptr_device_accessible) {}
+
+  //----------------------------------------
+};
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::Experimental::OpenMPTarget>
+    : public ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                          Kokkos::Experimental::OpenMPTarget> {
+  using base_t     = ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                              Kokkos::Experimental::OpenMPTarget>;
+  using value_type = typename base_t::value_type;
+
+ public:
+  void execute() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const int64_t N        = base_t::m_policy.end() - base_t::m_policy.begin();
+    const int chunk_size   = 128;
+    const int64_t n_chunks = (N + chunk_size - 1) / chunk_size;
+
+    if (N > 0) {
+      // This could be scratch memory per team
+      Kokkos::View<value_type**, Kokkos::LayoutRight,
+                   Kokkos::Experimental::OpenMPTargetSpace>
+          element_values("element_values", n_chunks, chunk_size);
+      Kokkos::View<value_type*, Kokkos::Experimental::OpenMPTargetSpace>
+          chunk_values("chunk_values", n_chunks);
+      Kokkos::View<int64_t, Kokkos::Experimental::OpenMPTargetSpace> count(
+          "Count");
+
+      base_t::impl_execute(element_values, chunk_values, count);
+
+      if (!base_t::m_result_ptr_device_accessible) {
+        const int size = base_t::m_functor_reducer.get_reducer().value_size();
+        DeepCopy<HostSpace, Kokkos::Experimental::OpenMPTargetSpace>(
+            base_t::m_result_ptr, chunk_values.data() + (n_chunks - 1), size);
+      }
+    } else if (!base_t::m_result_ptr_device_accessible) {
+      base_t::m_functor_reducer.get_reducer().init(base_t::m_result_ptr);
+    }
+  }
+
+  template <class ViewType>
+  ParallelScanWithTotal(const FunctorType& arg_functor,
+                        const typename base_t::Policy& arg_policy,
+                        const ViewType& arg_result_view)
+      : base_t(arg_functor, arg_policy, arg_result_view.data(),
+               MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
+                                 typename ViewType::memory_space>::accessible) {
+  }
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp
new file mode 100644
index 0000000000..a9e24994e0
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp
@@ -0,0 +1,129 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLELSCAN_TEAM_HPP
+#define KOKKOS_OPENMPTARGET_PARALLELSCAN_TEAM_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
+
+// FIXME_OPENMPTARGET - Using this macro to implement a workaround for
+// hierarchical scan. It avoids hitting the code path which we wanted to
+// write but doesn't work. undef'ed at the end.
+#ifndef KOKKOS_ARCH_INTEL_GPU
+#define KOKKOS_IMPL_TEAM_SCAN_WORKAROUND
+#endif
+
+namespace Kokkos {
+
+// This is largely the same code as in HIP and CUDA except for the member name
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_bounds,
+    const FunctorType& lambda) {
+  using Analysis   = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                                         TeamPolicy<Experimental::OpenMPTarget>,
+                                         FunctorType, void>;
+  using value_type = typename Analysis::value_type;
+
+  const auto start = loop_bounds.start;
+  const auto end   = loop_bounds.end;
+  //   Note this thing is called .member in the CUDA specialization of
+  //   TeamThreadRangeBoundariesStruct
+  auto& member         = loop_bounds.team;
+  const auto team_rank = member.team_rank();
+
+#if defined(KOKKOS_IMPL_TEAM_SCAN_WORKAROUND)
+  value_type scan_val = value_type();
+
+  if (team_rank == 0) {
+    for (iType i = start; i < end; ++i) {
+      lambda(i, scan_val, true);
+    }
+  }
+#pragma omp barrier
+#else
+  const auto team_size = member.team_size();
+  const auto nchunk    = (end - start + team_size - 1) / team_size;
+  value_type accum     = 0;
+  // each team has to process one or
+  //      more chunks of the prefix scan
+  for (iType i = 0; i < nchunk; ++i) {
+    auto ii = start + i * team_size + team_rank;
+    // local accumulation for this chunk
+    value_type local_accum = 0;
+    // user updates value with prefix value
+    if (ii < loop_bounds.end) lambda(ii, local_accum, false);
+    // perform team scan
+    local_accum = member.team_scan(local_accum);
+    // add this blocks accum to total accumulation
+    auto val = accum + local_accum;
+    // user updates their data with total accumulation
+    if (ii < loop_bounds.end) lambda(ii, val, true);
+    // the last value needs to be propogated to next chunk
+    if (team_rank == team_size - 1) accum = val;
+    // broadcast last value to rest of the team
+    member.team_broadcast(accum, team_size - 1);
+  }
+#endif
+}
+
+}  // namespace Kokkos
+
+namespace Kokkos {
+
+/** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
+ * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
+ *
+ * The range i=0..N-1 is mapped to all vector lanes in the thread and a scan
+ * operation is performed. Depending on the target execution space the operator
+ * might be called twice: once with final=false and once with final=true. When
+ * final==true val contains the prefix sum value. The contribution of this "i"
+ * needs to be added to val no matter whether final==true or not. In a serial
+ * execution (i.e. team_size==1) the operator is only called once with
+ * final==true. Scan_val will be set to the final sum value over all vector
+ * lanes.
+ */
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
+    const FunctorType& lambda) {
+  using Analysis   = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                                         TeamPolicy<Experimental::OpenMPTarget>,
+                                         FunctorType, void>;
+  using value_type = typename Analysis::value_type;
+
+  value_type scan_val = value_type();
+
+#ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
+#pragma ivdep
+#endif
+  for (iType i = loop_boundaries.start; i < loop_boundaries.end; ++i) {
+    lambda(i, scan_val, true);
+  }
+}
+
+}  // namespace Kokkos
+
+#ifdef KOKKOS_IMPL_TEAM_SCAN_WORKAROUND
+#undef KOKKOS_IMPL_TEAM_SCAN_WORKAROUND
+#endif
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp
new file mode 100644
index 0000000000..4206c3b557
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp
@@ -0,0 +1,675 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGET_PARALLEL_COMMON_HPP
+#define KOKKOS_OPENMPTARGET_PARALLEL_COMMON_HPP
+
+#include <omp.h>
+#include <sstream>
+#include <Kokkos_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+// This class has the memcpy routine that is commonly used by ParallelReduce
+// over RangePolicy and TeamPolicy.
+template <class PointerType>
+struct ParallelReduceCopy {
+  // Copy the result back to device if the view is on the device.
+  static void memcpy_result(PointerType dest, PointerType src, size_t size,
+                            bool ptr_on_device) {
+    if (ptr_on_device) {
+      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(dest, src, size, 0, 0,
+                                                   omp_get_default_device(),
+                                                   omp_get_initial_device()));
+    } else {
+      *dest = *src;
+    }
+  }
+};
+
+// template <class FunctorType, class PolicyType, class ReducerType,
+// class PointerType, class ValueType>
+template <class FunctorType, class ReducerType, class PointerType,
+          class ValueType, class PolicyType>
+struct ParallelReduceSpecialize {
+  inline static void execute(const FunctorType& /*f*/, const PolicyType& /*p*/,
+                             PointerType /*result_ptr*/) {
+    constexpr int FunctorHasJoin =
+        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
+                              FunctorType,
+                              ValueType>::Reducer::has_join_member_function();
+    constexpr int UseReducerType = is_reducer_v<ReducerType>;
+
+    std::stringstream error_message;
+    error_message << "Error: Invalid Specialization " << FunctorHasJoin << ' '
+                  << UseReducerType << '\n';
+    // FIXME_OPENMPTARGET
+    OpenMPTarget_abort(error_message.str().c_str());
+  }
+};
+
+template <class FunctorType, class ReducerType, class PointerType,
+          class ValueType, class... PolicyArgs>
+struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
+                                ReducerType, PointerType, ValueType> {
+  using PolicyType = Kokkos::RangePolicy<PolicyArgs...>;
+  using TagType    = typename PolicyType::work_tag;
+  using ReducerTypeFwd =
+      std::conditional_t<std::is_same<InvalidType, ReducerType>::value,
+                         FunctorType, ReducerType>;
+  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                                         PolicyType, ReducerTypeFwd, ValueType>;
+  using ReferenceType = typename Analysis::reference_type;
+
+  using ParReduceCopy = ParallelReduceCopy<PointerType>;
+
+  static void execute_reducer(const FunctorType& f, const PolicyType& p,
+                              PointerType result_ptr, bool ptr_on_device) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const auto begin = p.begin();
+    const auto end   = p.end();
+
+    ValueType result;
+    OpenMPTargetReducerWrapper<ReducerType>::init(result);
+
+    // Initialize and copy back the result even if it is a zero length
+    // reduction.
+    if (end <= begin) {
+      ParReduceCopy::memcpy_result(result_ptr, &result, sizeof(ValueType),
+                                   ptr_on_device);
+      return;
+    }
+
+#pragma omp declare reduction(                                         \
+    custom:ValueType                                                   \
+    : OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+#pragma omp target teams distribute parallel for map(to                    \
+                                                     : f) reduction(custom \
+                                                                    : result)
+    for (auto i = begin; i < end; ++i) {
+      if constexpr (std::is_void_v<TagType>) {
+        f(i, result);
+      } else {
+        f(TagType(), i, result);
+      }
+    }
+
+    ParReduceCopy::memcpy_result(result_ptr, &result, sizeof(ValueType),
+                                 ptr_on_device);
+  }
+
+  template <class TagType, int NumReductions>
+  static void execute_array(const FunctorType& f, const PolicyType& p,
+                            PointerType result_ptr, bool ptr_on_device) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    const auto begin = p.begin();
+    const auto end   = p.end();
+
+    // Enter the loop if the reduction is on a scalar type.
+    if constexpr (NumReductions == 1) {
+      ValueType result = ValueType();
+
+      // Initialize and copy back the result even if it is a zero length
+      // reduction.
+      if (end <= begin) {
+        ParReduceCopy::memcpy_result(result_ptr, &result, sizeof(ValueType),
+                                     ptr_on_device);
+        return;
+      }
+
+      // Case where reduction is on a native data type.
+      if constexpr (std::is_arithmetic<ValueType>::value) {
+#pragma omp target teams distribute parallel for \
+         map(to:f) reduction(+: result)
+        for (auto i = begin; i < end; ++i)
+
+          if constexpr (std::is_void_v<TagType>) {
+            f(i, result);
+          } else {
+            f(TagType(), i, result);
+          }
+      } else {
+#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
+#pragma omp target teams distribute parallel for map(to                    \
+                                                     : f) reduction(custom \
+                                                                    : result)
+        for (auto i = begin; i < end; ++i)
+
+          if constexpr (std::is_void_v<TagType>) {
+            f(i, result);
+          } else {
+            f(TagType(), i, result);
+          }
+      }
+
+      ParReduceCopy::memcpy_result(result_ptr, &result, sizeof(ValueType),
+                                   ptr_on_device);
+    } else {
+      ValueType result[NumReductions] = {};
+
+      // Initialize and copy back the result even if it is a zero length
+      // reduction.
+      if (end <= begin) {
+        ParReduceCopy::memcpy_result(result_ptr, result,
+                                     NumReductions * sizeof(ValueType),
+                                     ptr_on_device);
+        return;
+      }
+#pragma omp target teams distribute parallel for map(to:f) reduction(+:result[:NumReductions])
+      for (auto i = begin; i < end; ++i) {
+        if constexpr (std::is_void_v<TagType>) {
+          f(i, result);
+        } else {
+          f(TagType(), i, result);
+        }
+      }
+
+      ParReduceCopy::memcpy_result(
+          result_ptr, result, NumReductions * sizeof(ValueType), ptr_on_device);
+    }
+  }
+
+  static void execute_init_join(const FunctorType& f, const PolicyType& p,
+                                PointerType ptr, const bool ptr_on_device) {
+    const auto begin = p.begin();
+    const auto end   = p.end();
+
+    using FunctorAnalysis =
+        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
+                              FunctorType, ValueType>;
+
+    // Initialize the result pointer.
+
+    const auto size = end - begin;
+
+    // FIXME_OPENMPTARGET: The team size and MAX_ACTIVE_THREADS are currently
+    // based on NVIDIA-V100 and should be modifid to be based on the
+    // architecture in the future.
+    const int max_team_threads = 32;
+    const int max_teams =
+        OpenMPTargetExec::MAX_ACTIVE_THREADS / max_team_threads;
+    // Number of elements in the reduction
+    const auto value_count = FunctorAnalysis::value_count(f);
+
+    // Allocate scratch per active thread. Achieved by setting the first
+    // parameter of `resize_scratch=1`.
+    OpenMPTargetExec::resize_scratch(1, 0, value_count * sizeof(ValueType),
+                                     std::numeric_limits<int64_t>::max());
+    ValueType* scratch_ptr =
+        static_cast<ValueType*>(OpenMPTargetExec::get_scratch_ptr());
+
+    typename FunctorAnalysis::Reducer final_reducer(f);
+
+    if (end <= begin) {
+#pragma omp target map(to : final_reducer) is_device_ptr(scratch_ptr)
+      {
+        // If there is no work to be done, copy back the initialized values and
+        // exit.
+        final_reducer.init(scratch_ptr);
+        final_reducer.final(scratch_ptr);
+      }
+      if (!ptr_on_device)
+        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+            omp_get_initial_device(), omp_get_default_device()));
+      else
+        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+            omp_get_default_device(), omp_get_default_device()));
+
+      return;
+    }
+
+#pragma omp target teams num_teams(max_teams) thread_limit(max_team_threads) \
+    map(to                                                                   \
+        : final_reducer) is_device_ptr(scratch_ptr)
+    {
+#pragma omp parallel
+      {
+        const int team_num    = omp_get_team_num();
+        const int num_teams   = omp_get_num_teams();
+        const auto chunk_size = size / num_teams;
+        const auto team_begin = begin + team_num * chunk_size;
+        const auto team_end =
+            (team_num == num_teams - 1) ? end : (team_begin + chunk_size);
+        ValueType* team_scratch =
+            scratch_ptr + team_num * max_team_threads * value_count;
+        ReferenceType result = final_reducer.init(
+            &team_scratch[omp_get_thread_num() * value_count]);
+
+        // Accumulate partial results in thread specific storage.
+#pragma omp for simd
+        for (auto i = team_begin; i < team_end; ++i) {
+          if constexpr (std::is_void_v<TagType>) {
+            f(i, result);
+          } else {
+            f(TagType(), i, result);
+          }
+        }
+
+        // Reduce all paritial results within a team.
+        const int team_size      = max_team_threads;
+        int tree_neighbor_offset = 1;
+        do {
+#pragma omp for simd
+          for (int i = 0; i < team_size - tree_neighbor_offset;
+               i += 2 * tree_neighbor_offset) {
+            const int neighbor = i + tree_neighbor_offset;
+            final_reducer.join(&team_scratch[i * value_count],
+                               &team_scratch[neighbor * value_count]);
+          }
+          tree_neighbor_offset *= 2;
+        } while (tree_neighbor_offset < team_size);
+      }  // end parallel
+    }    // end target
+
+    int tree_neighbor_offset = 1;
+    do {
+#pragma omp target teams distribute parallel for simd map(to   \
+                                                          : f) \
+    is_device_ptr(scratch_ptr)
+      for (int i = 0; i < max_teams - tree_neighbor_offset;
+           i += 2 * tree_neighbor_offset) {
+        ValueType* team_scratch = scratch_ptr;
+        const int team_offset   = max_team_threads * value_count;
+        final_reducer.join(
+            &team_scratch[i * team_offset],
+            &team_scratch[(i + tree_neighbor_offset) * team_offset]);
+
+        // If `final` is provided by the functor.
+        // Do the final only once at the end.
+        if (tree_neighbor_offset * 2 >= max_teams && omp_get_team_num() == 0 &&
+            omp_get_thread_num() == 0) {
+          final_reducer.final(scratch_ptr);
+        }
+      }
+      tree_neighbor_offset *= 2;
+    } while (tree_neighbor_offset < max_teams);
+
+    // If the result view is on the host, copy back the values via memcpy.
+    if (!ptr_on_device)
+      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+          omp_get_initial_device(), omp_get_default_device()));
+    else
+      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+          omp_get_default_device(), omp_get_default_device()));
+  }
+};
+
+template <class FunctorType, class ReducerType, class PointerType,
+          class ValueType, class... PolicyArgs>
+struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
+                                ReducerType, PointerType, ValueType> {
+  using PolicyType = TeamPolicyInternal<PolicyArgs...>;
+  using TagType    = typename PolicyType::work_tag;
+  using ReducerTypeFwd =
+      std::conditional_t<std::is_same<InvalidType, ReducerType>::value,
+                         FunctorType, ReducerType>;
+  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                                         PolicyType, ReducerTypeFwd, ValueType>;
+
+  using ReferenceType = typename Analysis::reference_type;
+
+  using ParReduceCopy = ParallelReduceCopy<PointerType>;
+
+  static void execute_reducer(const FunctorType& f, const PolicyType& p,
+                              PointerType result_ptr, bool ptr_on_device) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+
+    const int league_size   = p.league_size();
+    const int team_size     = p.team_size();
+    const int vector_length = p.impl_vector_length();
+
+    const size_t shmem_size_L0 = p.scratch_size(0, team_size);
+    const size_t shmem_size_L1 = p.scratch_size(1, team_size);
+    OpenMPTargetExec::resize_scratch(PolicyType::member_type::TEAM_REDUCE_SIZE,
+                                     shmem_size_L0, shmem_size_L1, league_size);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+
+    ValueType result = ValueType();
+
+    // Maximum active teams possible.
+    // FIXME_OPENMPTARGET: Cray compiler did not yet implement
+    // omp_get_max_teams.
+#if !defined(KOKKOS_COMPILER_CRAY_LLVM)
+    int max_active_teams = omp_get_max_teams();
+#else
+    int max_active_teams =
+        std::min(OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size, league_size);
+#endif
+
+    // If the league size is <=0, do not launch the kernel.
+    if (max_active_teams <= 0) return;
+
+#pragma omp declare reduction(                                         \
+    custom:ValueType                                                   \
+    : OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
+    initializer(OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+
+#if !defined(KOKKOS_IMPL_OPENMPTARGET_HIERARCHICAL_INTEL_GPU)
+#pragma omp target teams num_teams(max_active_teams) thread_limit(team_size) \
+    firstprivate(f) is_device_ptr(scratch_ptr) reduction(custom              \
+                                                         : result)
+#pragma omp parallel reduction(custom : result)
+    {
+      if (omp_get_num_teams() > max_active_teams)
+        Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+      const int blockIdx = omp_get_team_num();
+      const int gridDim  = omp_get_num_teams();
+
+      // Guarantee that the compilers respect the `num_teams` clause
+      for (int league_id = blockIdx; league_id < league_size;
+           league_id += gridDim) {
+        typename PolicyType::member_type team(
+            league_id, league_size, team_size, vector_length, scratch_ptr,
+            blockIdx, shmem_size_L0, shmem_size_L1);
+        if constexpr (std::is_void_v<TagType>)
+          f(team, result);
+        else
+          f(TagType(), team, result);
+      }
+    }
+#else
+#pragma omp target teams distribute firstprivate(f) is_device_ptr(scratch_ptr) \
+    num_teams(max_active_teams) thread_limit(team_size) reduction(custom       \
+                                                                  : result)
+    for (int i = 0; i < league_size; i++) {
+#pragma omp parallel reduction(custom : result)
+      {
+        if (omp_get_num_teams() > max_active_teams)
+          Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+        typename PolicyType::member_type team(i, league_size, team_size,
+                                              vector_length, scratch_ptr, i,
+                                              shmem_size_L0, shmem_size_L1);
+        if constexpr (std::is_void_v<TagType>)
+          f(team, result);
+        else
+          f(TagType(), team, result);
+      }
+    }
+#endif
+
+    // Copy results back to device if `parallel_reduce` is on a device view.
+    ParReduceCopy::memcpy_result(result_ptr, &result, sizeof(ValueType),
+                                 ptr_on_device);
+  }
+
+  template <int NumReductions>
+  static void execute_array(const FunctorType& f, const PolicyType& p,
+                            PointerType result_ptr, bool ptr_on_device) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+
+    const int league_size   = p.league_size();
+    const int team_size     = p.team_size();
+    const int vector_length = p.impl_vector_length();
+
+    const size_t shmem_size_L0 = p.scratch_size(0, team_size);
+    const size_t shmem_size_L1 = p.scratch_size(1, team_size);
+    OpenMPTargetExec::resize_scratch(PolicyType::member_type::TEAM_REDUCE_SIZE,
+                                     shmem_size_L0, shmem_size_L1, league_size);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+
+    // Maximum active teams possible.
+    // FIXME_OPENMPTARGET: Cray compiler did not yet implement
+    // omp_get_max_teams.
+#if !defined(KOKKOS_COMPILER_CRAY_LLVM)
+    int max_active_teams = omp_get_max_teams();
+#else
+    int max_active_teams =
+        std::min(OpenMPTargetExec::MAX_ACTIVE_THREADS / team_size, league_size);
+#endif
+
+    // If the league size is <=0, do not launch the kernel.
+    if (max_active_teams <= 0) return;
+
+    // Case where the number of reduction items is 1.
+    if constexpr (NumReductions == 1) {
+      ValueType result = ValueType();
+
+      // Case where reduction is on a native data type.
+      if constexpr (std::is_arithmetic<ValueType>::value) {
+#pragma omp target teams num_teams(max_active_teams) thread_limit(team_size) map(to   \
+                                                                       : f) \
+    is_device_ptr(scratch_ptr) reduction(+: result)
+#pragma omp parallel reduction(+ : result)
+        {
+          if (omp_get_num_teams() > max_active_teams)
+            Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+          const int blockIdx = omp_get_team_num();
+          const int gridDim  = omp_get_num_teams();
+
+          // Guarantee that the compilers respect the `num_teams` clause
+          for (int league_id = blockIdx; league_id < league_size;
+               league_id += gridDim) {
+            typename PolicyType::member_type team(
+                league_id, league_size, team_size, vector_length, scratch_ptr,
+                blockIdx, shmem_size_L0, shmem_size_L1);
+            if constexpr (std::is_void_v<TagType>)
+              f(team, result);
+            else
+              f(TagType(), team, result);
+          }
+        }
+      } else {
+        // Case where the reduction is on a non-native data type.
+#pragma omp declare reduction(custom:ValueType : omp_out += omp_in)
+#pragma omp target teams num_teams(max_active_teams) thread_limit(team_size) \
+    map(to                                                                   \
+        : f) is_device_ptr(scratch_ptr) reduction(custom                     \
+                                                  : result)
+#pragma omp parallel reduction(custom : result)
+        {
+          if (omp_get_num_teams() > max_active_teams)
+            Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+          const int blockIdx = omp_get_team_num();
+          const int gridDim  = omp_get_num_teams();
+
+          // Guarantee that the compilers respect the `num_teams` clause
+          for (int league_id = blockIdx; league_id < league_size;
+               league_id += gridDim) {
+            typename PolicyType::member_type team(
+                league_id, league_size, team_size, vector_length, scratch_ptr,
+                blockIdx, shmem_size_L0, shmem_size_L1);
+            if constexpr (std::is_void_v<TagType>)
+              f(team, result);
+            else
+              f(TagType(), team, result);
+          }
+        }
+      }
+
+      // Copy results back to device if `parallel_reduce` is on a device view.
+      ParReduceCopy::memcpy_result(result_ptr, &result, sizeof(ValueType),
+                                   ptr_on_device);
+    } else {
+      ValueType result[NumReductions] = {};
+      // Case where the reduction is on an array.
+#pragma omp target teams num_teams(max_active_teams) thread_limit(team_size) map(to   \
+                                                                       : f) \
+    is_device_ptr(scratch_ptr) reduction(+ : result[:NumReductions])
+#pragma omp parallel reduction(+ : result[:NumReductions])
+      {
+        if (omp_get_num_teams() > max_active_teams)
+          Kokkos::abort("`omp_set_num_teams` call was not respected.\n");
+
+        const int blockIdx = omp_get_team_num();
+        const int gridDim  = omp_get_num_teams();
+
+        // Guarantee that the compilers respect the `num_teams` clause
+        for (int league_id = blockIdx; league_id < league_size;
+             league_id += gridDim) {
+          typename PolicyType::member_type team(
+              league_id, league_size, team_size, vector_length, scratch_ptr,
+              blockIdx, shmem_size_L0, shmem_size_L1);
+          if constexpr (std::is_void_v<TagType>)
+            f(team, result);
+          else
+            f(TagType(), team, result);
+        }
+      }
+
+      // Copy results back to device if `parallel_reduce` is on a device view.
+      ParReduceCopy::memcpy_result(
+          result_ptr, result, NumReductions * sizeof(ValueType), ptr_on_device);
+    }
+  }
+
+  // FIXME_OPENMPTARGET : This routine is a copy from `parallel_reduce` over
+  // RangePolicy. Need a new implementation.
+  static void execute_init_join(const FunctorType& f, const PolicyType& p,
+                                PointerType ptr, const bool ptr_on_device) {
+    using FunctorAnalysis =
+        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
+                              FunctorType, ValueType>;
+
+    const int league_size   = p.league_size();
+    const int team_size     = p.team_size();
+    const int vector_length = p.impl_vector_length();
+
+    auto begin = 0;
+    auto end   = league_size * team_size + team_size * vector_length;
+
+    const size_t shmem_size_L0 = p.scratch_size(0, team_size);
+    const size_t shmem_size_L1 = p.scratch_size(1, team_size);
+
+    // FIXME_OPENMPTARGET: This would oversubscribe scratch memory since we are
+    // already using the available scratch memory to create temporaries for each
+    // thread.
+    if ((shmem_size_L0 + shmem_size_L1) > 0) {
+      Kokkos::abort(
+          "OpenMPTarget: Scratch memory is not supported in `parallel_reduce` "
+          "over functors with init/join.");
+    }
+
+    const auto nteams = league_size;
+
+    // Number of elements in the reduction
+    const auto value_count = FunctorAnalysis::value_count(f);
+
+    // Allocate scratch per active thread.
+    OpenMPTargetExec::resize_scratch(1, 0, value_count * sizeof(ValueType),
+                                     league_size);
+    void* scratch_ptr = OpenMPTargetExec::get_scratch_ptr();
+    typename FunctorAnalysis::Reducer final_reducer(f);
+
+    if (end <= begin) {
+// If there is no work to be done, copy back the initialized values and
+// exit.
+#pragma omp target map(to : final_reducer) is_device_ptr(scratch_ptr)
+      {
+        final_reducer.init(scratch_ptr);
+        final_reducer.final(scratch_ptr);
+      }
+
+      if (!ptr_on_device)
+        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+            omp_get_initial_device(), omp_get_default_device()));
+      else
+        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+            ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+            omp_get_default_device(), omp_get_default_device()));
+
+      return;
+    }
+
+#pragma omp target teams num_teams(nteams) thread_limit(team_size) map(to   \
+                                                                       : f) \
+    is_device_ptr(scratch_ptr)
+    {
+#pragma omp parallel
+      {
+        const int team_num      = omp_get_team_num();
+        const int num_teams     = omp_get_num_teams();
+        ValueType* team_scratch = static_cast<ValueType*>(scratch_ptr) +
+                                  team_num * team_size * value_count;
+        ReferenceType result = final_reducer.init(&team_scratch[0]);
+
+        for (int league_id = team_num; league_id < league_size;
+             league_id += num_teams) {
+          typename PolicyType::member_type team(
+              league_id, league_size, team_size, vector_length, scratch_ptr,
+              team_num, shmem_size_L0, shmem_size_L1);
+          if constexpr (std::is_void_v<TagType>) {
+            f(team, result);
+          } else {
+            f(TagType(), team, result);
+          }
+        }
+      }  // end parallel
+    }    // end target
+
+    int tree_neighbor_offset = 1;
+    do {
+#pragma omp target teams distribute parallel for simd map(to               \
+                                                          : final_reducer) \
+    is_device_ptr(scratch_ptr)
+      for (int i = 0; i < nteams - tree_neighbor_offset;
+           i += 2 * tree_neighbor_offset) {
+        ValueType* team_scratch = static_cast<ValueType*>(scratch_ptr);
+        const int team_offset   = team_size * value_count;
+        final_reducer.join(
+            &team_scratch[i * team_offset],
+            &team_scratch[(i + tree_neighbor_offset) * team_offset]);
+
+        // If `final` is provided by the functor.
+        // Do the final only once at the end.
+        if (tree_neighbor_offset * 2 >= nteams && omp_get_team_num() == 0 &&
+            omp_get_thread_num() == 0) {
+          final_reducer.final(scratch_ptr);
+        }
+      }
+      tree_neighbor_offset *= 2;
+    } while (tree_neighbor_offset < nteams);
+
+    // If the result view is on the host, copy back the values via memcpy.
+    if (!ptr_on_device)
+      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+          omp_get_initial_device(), omp_get_default_device()));
+    else
+      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(
+          ptr, scratch_ptr, value_count * sizeof(ValueType), 0, 0,
+          omp_get_default_device(), omp_get_default_device()));
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp
index 21bdb67e34..41e62ce6e6 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp
@@ -19,7 +19,8 @@
 
 #include <omp.h>
 #include <Kokkos_Parallel.hpp>
-#include <OpenMPTarget/Kokkos_OpenMPTarget_Exec.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp>
 
 // WORKAROUND OPENMPTARGET: sometimes tile sizes don't make it correctly,
 // this was tracked down to a bug in clang with regards of mapping structs
@@ -410,69 +411,49 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>,
                      Kokkos::Experimental::OpenMPTarget> {
  private:
-  using Policy = Kokkos::MDRangePolicy<Traits...>;
+  using Policy      = Kokkos::MDRangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
   using WorkTag = typename Policy::work_tag;
   using Member  = typename Policy::member_type;
   using Index   = typename Policy::index_type;
 
-  using ReducerConditional =
-      std::conditional<std::is_same<InvalidType, ReducerType>::value,
-                       FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         Policy, ReducerTypeFwd>;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  static constexpr bool UseReducer = is_reducer<ReducerType>::value;
+  static constexpr bool UseReducer =
+      !std::is_same_v<FunctorType, typename ReducerType::functor_type>;
 
   const pointer_type m_result_ptr;
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
 
-  using ParReduceCommon = ParallelReduceCommon<pointer_type>;
+  using ParReduceCopy = ParallelReduceCopy<pointer_type>;
 
   bool m_result_ptr_on_device;
 
  public:
   inline void execute() const {
-    execute_tile<Policy::rank, typename Analysis::value_type>(
-        m_functor, m_policy, m_result_ptr);
+    execute_tile<Policy::rank, typename ReducerType::value_type>(
+        m_functor_reducer.get_functor(), m_policy, m_result_ptr);
   }
 
   template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType& arg_functor, Policy arg_policy,
-      const ViewType& arg_result_view,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void*> = NULL)
+  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                        Policy arg_policy, const ViewType& arg_result_view)
       : m_result_ptr(arg_result_view.data()),
-        m_functor(arg_functor),
+        m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr_on_device(
             MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
                               typename ViewType::memory_space>::accessible) {}
 
-  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
-                        const ReducerType& reducer)
-      : m_result_ptr(reducer.view().data()),
-        m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr_on_device(
-            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible) {}
-
   template <int Rank, class ValueType>
   inline std::enable_if_t<Rank == 2> execute_tile(const FunctorType& functor,
                                                   const Policy& policy,
@@ -518,8 +499,8 @@ reduction(+:result)
       }
     }
 
-    ParReduceCommon::memcpy_result(ptr, &result, sizeof(ValueType),
-                                   m_result_ptr_on_device);
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
   template <int Rank, class ValueType>
@@ -539,10 +520,13 @@ reduction(+:result)
     // FIXME_OPENMPTARGET: Unable to separate directives and their companion
     // loops which leads to code duplication for different reduction types.
     if constexpr (UseReducer) {
-#pragma omp declare reduction(                                         \
-    custom:ValueType                                                   \
-    : OpenMPTargetReducerWrapper <ReducerType>::join(omp_out, omp_in)) \
-    initializer(OpenMPTargetReducerWrapper <ReducerType>::init(omp_priv))
+#pragma omp declare reduction(                                                 \
+    custom:ValueType                                                           \
+    : OpenMPTargetReducerWrapper <typename ReducerType::functor_type>::join(   \
+        omp_out, omp_in))                                                      \
+    initializer(                                                               \
+        OpenMPTargetReducerWrapper <typename ReducerType::functor_type>::init( \
+            omp_priv))
 
 #pragma omp target teams distribute parallel for collapse(3) map(to         \
                                                                  : functor) \
@@ -573,8 +557,8 @@ reduction(+:result)
       }
     }
 
-    ParReduceCommon::memcpy_result(ptr, &result, sizeof(ValueType),
-                                   m_result_ptr_on_device);
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
   template <int Rank, class ValueType>
@@ -636,8 +620,8 @@ reduction(+:result)
       }
     }
 
-    ParReduceCommon::memcpy_result(ptr, &result, sizeof(ValueType),
-                                   m_result_ptr_on_device);
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
   template <int Rank, class ValueType>
@@ -707,8 +691,8 @@ reduction(+:result)
       }
     }
 
-    ParReduceCommon::memcpy_result(ptr, &result, sizeof(ValueType),
-                                   m_result_ptr_on_device);
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
   template <int Rank, class ValueType>
@@ -784,8 +768,8 @@ reduction(+:result)
       }
     }
 
-    ParReduceCommon::memcpy_result(ptr, &result, sizeof(ValueType),
-                                   m_result_ptr_on_device);
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
   template <typename Policy, typename Functor>
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp
new file mode 100644
index 0000000000..672271ed6b
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp
@@ -0,0 +1,694 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_OPENMPTARGETREDUCER_HPP
+#define KOKKOS_OPENMPTARGETREDUCER_HPP
+
+#include <impl/Kokkos_Traits.hpp>
+#include <impl/Kokkos_Spinwait.hpp>
+
+#include <Kokkos_Atomic.hpp>
+#include "Kokkos_OpenMPTarget_Abort.hpp"
+
+namespace Kokkos {
+namespace Impl {
+
+template <class Reducer>
+struct OpenMPTargetReducerWrapper {
+  using value_type = typename Reducer::value_type;
+
+  // Using a generic unknown Reducer for the OpenMPTarget backend is not
+  // implemented.
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type&, const value_type&) = delete;
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type&, const volatile value_type&) = delete;
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type&) = delete;
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<Sum<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) { dest += src; }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest += src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::sum();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<Prod<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) { dest *= src; }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest *= src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::prod();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<Min<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src < dest) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src < dest) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::min();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<Max<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src > dest) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src > dest) dest = src;
+  }
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::max();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<LAnd<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest = dest && src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest = dest && src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::land();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<LOr<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  using result_view_type = Kokkos::View<value_type, Space>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest = dest || src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest = dest || src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::lor();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<BAnd<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest = dest & src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest = dest & src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::band();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<BOr<Scalar, Space>> {
+ public:
+  // Required
+  using value_type = std::remove_cv_t<Scalar>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest = dest | src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest = dest | src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val = reduction_identity<value_type>::bor();
+  }
+};
+
+template <class Scalar, class Index, class Space>
+struct OpenMPTargetReducerWrapper<MinLoc<Scalar, Index, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+  using index_type  = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = ValLocScalar<scalar_type, index_type>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src.val < dest.val) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src.val < dest.val) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.val = reduction_identity<scalar_type>::min();
+    val.loc = reduction_identity<index_type>::min();
+  }
+};
+
+template <class Scalar, class Index, class Space>
+struct OpenMPTargetReducerWrapper<MaxLoc<Scalar, Index, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+  using index_type  = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = ValLocScalar<scalar_type, index_type>;
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src.val > dest.val) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src.val > dest.val) dest = src;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.val = reduction_identity<scalar_type>::max();
+    val.loc = reduction_identity<index_type>::min();
+  }
+};
+
+template <class Scalar, class Space>
+struct OpenMPTargetReducerWrapper<MinMax<Scalar, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+
+ public:
+  // Required
+  using value_type = MinMaxScalar<scalar_type>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src.min_val < dest.min_val) {
+      dest.min_val = src.min_val;
+    }
+    if (src.max_val > dest.max_val) {
+      dest.max_val = src.max_val;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src.min_val < dest.min_val) {
+      dest.min_val = src.min_val;
+    }
+    if (src.max_val > dest.max_val) {
+      dest.max_val = src.max_val;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.max_val = reduction_identity<scalar_type>::max();
+    val.min_val = reduction_identity<scalar_type>::min();
+  }
+};
+
+template <class Scalar, class Index, class Space>
+struct OpenMPTargetReducerWrapper<MinMaxLoc<Scalar, Index, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+  using index_type  = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = MinMaxLocScalar<scalar_type, index_type>;
+
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src.min_val < dest.min_val) {
+      dest.min_val = src.min_val;
+      dest.min_loc = src.min_loc;
+    }
+    if (src.max_val > dest.max_val) {
+      dest.max_val = src.max_val;
+      dest.max_loc = src.max_loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src.min_val < dest.min_val) {
+      dest.min_val = src.min_val;
+      dest.min_loc = src.min_loc;
+    }
+    if (src.max_val > dest.max_val) {
+      dest.max_val = src.max_val;
+      dest.max_loc = src.max_loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.max_val = reduction_identity<scalar_type>::max();
+    val.min_val = reduction_identity<scalar_type>::min();
+    val.max_loc = reduction_identity<index_type>::min();
+    val.min_loc = reduction_identity<index_type>::min();
+  }
+};
+
+//
+// specialize for MaxFirstLoc
+//
+template <class Scalar, class Index, class Space>
+struct OpenMPTargetReducerWrapper<MaxFirstLoc<Scalar, Index, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+  using index_type  = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = ValLocScalar<scalar_type, index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (dest.val < src.val) {
+      dest = src;
+    } else if (!(src.val < dest.val)) {
+      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (dest.val < src.val) {
+      dest = src;
+    } else if (!(src.val < dest.val)) {
+      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.val = reduction_identity<scalar_type>::max();
+    val.loc = reduction_identity<index_type>::min();
+  }
+#pragma omp end declare target
+};
+
+//
+// specialize for MinFirstLoc
+//
+template <class Scalar, class Index, class Space>
+struct OpenMPTargetReducerWrapper<MinFirstLoc<Scalar, Index, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+  using index_type  = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = ValLocScalar<scalar_type, index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src.val < dest.val) {
+      dest = src;
+    } else if (!(dest.val < src.val)) {
+      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src.val < dest.val) {
+      dest = src;
+    } else if (!(dest.val < src.val)) {
+      dest.loc = (src.loc < dest.loc) ? src.loc : dest.loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.val = reduction_identity<scalar_type>::min();
+    val.loc = reduction_identity<index_type>::min();
+  }
+#pragma omp end declare target
+};
+
+//
+// specialize for MinMaxFirstLastLoc
+//
+template <class Scalar, class Index, class Space>
+struct OpenMPTargetReducerWrapper<MinMaxFirstLastLoc<Scalar, Index, Space>> {
+ private:
+  using scalar_type = std::remove_cv_t<Scalar>;
+  using index_type  = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = MinMaxLocScalar<scalar_type, index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    if (src.min_val < dest.min_val) {
+      dest.min_val = src.min_val;
+      dest.min_loc = src.min_loc;
+    } else if (!(dest.min_val < src.min_val)) {
+      dest.min_loc = (src.min_loc < dest.min_loc) ? src.min_loc : dest.min_loc;
+    }
+
+    if (dest.max_val < src.max_val) {
+      dest.max_val = src.max_val;
+      dest.max_loc = src.max_loc;
+    } else if (!(src.max_val < dest.max_val)) {
+      dest.max_loc = (src.max_loc > dest.max_loc) ? src.max_loc : dest.max_loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    if (src.min_val < dest.min_val) {
+      dest.min_val = src.min_val;
+      dest.min_loc = src.min_loc;
+    } else if (!(dest.min_val < src.min_val)) {
+      dest.min_loc = (src.min_loc < dest.min_loc) ? src.min_loc : dest.min_loc;
+    }
+
+    if (dest.max_val < src.max_val) {
+      dest.max_val = src.max_val;
+      dest.max_loc = src.max_loc;
+    } else if (!(src.max_val < dest.max_val)) {
+      dest.max_loc = (src.max_loc > dest.max_loc) ? src.max_loc : dest.max_loc;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.max_val = reduction_identity<scalar_type>::max();
+    val.min_val = reduction_identity<scalar_type>::min();
+    val.max_loc = reduction_identity<index_type>::max();
+    val.min_loc = reduction_identity<index_type>::min();
+  }
+#pragma omp end declare target
+};
+
+//
+// specialize for FirstLoc
+//
+template <class Index, class Space>
+struct OpenMPTargetReducerWrapper<FirstLoc<Index, Space>> {
+ private:
+  using index_type = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = FirstLocScalar<index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest.min_loc_true = (src.min_loc_true < dest.min_loc_true)
+                            ? src.min_loc_true
+                            : dest.min_loc_true;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest.min_loc_true = (src.min_loc_true < dest.min_loc_true)
+                            ? src.min_loc_true
+                            : dest.min_loc_true;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.min_loc_true = reduction_identity<index_type>::min();
+  }
+#pragma omp end declare target
+};
+
+//
+// specialize for LastLoc
+//
+template <class Index, class Space>
+struct OpenMPTargetReducerWrapper<LastLoc<Index, Space>> {
+ private:
+  using index_type = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = LastLocScalar<index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest.max_loc_true = (src.max_loc_true > dest.max_loc_true)
+                            ? src.max_loc_true
+                            : dest.max_loc_true;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest.max_loc_true = (src.max_loc_true > dest.max_loc_true)
+                            ? src.max_loc_true
+                            : dest.max_loc_true;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.max_loc_true = reduction_identity<index_type>::max();
+  }
+#pragma omp end declare target
+};
+
+//
+// specialize for StdIsPartitioned
+//
+template <class Index, class Space>
+struct OpenMPTargetReducerWrapper<StdIsPartitioned<Index, Space>> {
+ private:
+  using index_type = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = StdIsPartScalar<index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest.max_loc_true = (dest.max_loc_true < src.max_loc_true)
+                            ? src.max_loc_true
+                            : dest.max_loc_true;
+
+    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
+                             ? dest.min_loc_false
+                             : src.min_loc_false;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest.max_loc_true = (dest.max_loc_true < src.max_loc_true)
+                            ? src.max_loc_true
+                            : dest.max_loc_true;
+
+    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
+                             ? dest.min_loc_false
+                             : src.min_loc_false;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.max_loc_true  = ::Kokkos::reduction_identity<index_type>::max();
+    val.min_loc_false = ::Kokkos::reduction_identity<index_type>::min();
+  }
+#pragma omp end declare target
+};
+
+//
+// specialize for StdPartitionPoint
+//
+template <class Index, class Space>
+struct OpenMPTargetReducerWrapper<StdPartitionPoint<Index, Space>> {
+ private:
+  using index_type = std::remove_cv_t<Index>;
+
+ public:
+  // Required
+  using value_type = StdPartPointScalar<index_type>;
+
+// WORKAROUND OPENMPTARGET
+// This pragma omp declare target should not be necessary, but Intel compiler
+// fails without it
+#pragma omp declare target
+  // Required
+  KOKKOS_INLINE_FUNCTION
+  static void join(value_type& dest, const value_type& src) {
+    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
+                             ? dest.min_loc_false
+                             : src.min_loc_false;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void join(volatile value_type& dest, const volatile value_type& src) {
+    dest.min_loc_false = (dest.min_loc_false < src.min_loc_false)
+                             ? dest.min_loc_false
+                             : src.min_loc_false;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  static void init(value_type& val) {
+    val.min_loc_false = ::Kokkos::reduction_identity<index_type>::min();
+  }
+#pragma omp end declare target
+};
+
+/*
+template<class ReducerType>
+class OpenMPTargetReducerWrapper {
+  public:
+    const ReducerType& reducer;
+    using value_type = typename ReducerType::value_type;
+    value_type& value;
+
+    KOKKOS_INLINE_FUNCTION
+    void join(const value_type& upd) {
+      reducer.join(value,upd);
+    }
+
+    KOKKOS_INLINE_FUNCTION
+    void init(const value_type& upd) {
+      reducer.init(value,upd);
+    }
+};*/
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_UniqueToken.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_UniqueToken.hpp
index c7f146871b..d9ea555055 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_UniqueToken.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_UniqueToken.hpp
@@ -20,7 +20,7 @@
 #include <Kokkos_Macros.hpp>
 #ifdef KOKKOS_ENABLE_OPENMPTARGET
 
-#include <Kokkos_OpenMPTargetSpace.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp>
 #include <Kokkos_UniqueToken.hpp>
 #include <impl/Kokkos_SharedAlloc.hpp>
 #include <impl/Kokkos_ConcurrentBitset.hpp>
diff --git a/core/src/SYCL/Kokkos_SYCL.cpp b/core/src/SYCL/Kokkos_SYCL.cpp
index e38b011c89..f8a1efda8e 100644
--- a/core/src/SYCL/Kokkos_SYCL.cpp
+++ b/core/src/SYCL/Kokkos_SYCL.cpp
@@ -20,9 +20,8 @@
 
 #include <Kokkos_Concepts.hpp>
 #include <SYCL/Kokkos_SYCL_Instance.hpp>
-#include <Kokkos_SYCL.hpp>
+#include <SYCL/Kokkos_SYCL.hpp>
 #include <Kokkos_HostSpace.hpp>
-#include <Kokkos_Serial.hpp>
 #include <Kokkos_Core.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_DeviceManagement.hpp>
@@ -88,6 +87,11 @@ void SYCL::print_configuration(std::ostream& os, bool verbose) const {
   os << "\nRuntime Configuration:\n";
 
   os << "macro  KOKKOS_ENABLE_SYCL : defined\n";
+#ifdef KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED
+  os << "macro  KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED : defined\n";
+#else
+  os << "macro  KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED : undefined\n";
+#endif
   if (verbose)
     SYCL::impl_sycl_info(os, m_space_instance->m_queue->get_device());
 }
@@ -124,10 +128,7 @@ void SYCL::impl_initialize(InitializationSettings const& settings) {
   // If the device id is not specified and there are no GPUs, sidestep Kokkos
   // device selection and use whatever is available (if no GPU architecture is
   // specified).
-#if !defined(KOKKOS_ARCH_INTEL_GPU) && !defined(KOKKOS_ARCH_KEPLER) && \
-    !defined(KOKKOS_ARCH_MAXWELL) && !defined(KOKKOS_ARCH_PASCAL) &&   \
-    !defined(KOKKOS_ARCH_VOLTA) && !defined(KOKKOS_ARCH_TURING75) &&   \
-    !defined(KOKKOS_ARCH_AMPERE) && !defined(KOKKOS_ARCH_HOPPER)
+#if !defined(KOKKOS_ARCH_INTEL_GPU) && !defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
   if (!settings.has_device_id() && gpu_devices.empty()) {
     Impl::SYCLInternal::singleton().initialize(sycl::device());
     Impl::SYCLInternal::m_syclDev = 0;
@@ -144,7 +145,6 @@ std::ostream& SYCL::impl_sycl_info(std::ostream& os,
   using namespace sycl::info;
   return os << "Name: " << device.get_info<device::name>()
             << "\nDriver Version: " << device.get_info<device::driver_version>()
-            << "\nIs Host: " << device.is_host()
             << "\nIs CPU: " << device.is_cpu()
             << "\nIs GPU: " << device.is_gpu()
             << "\nIs Accelerator: " << device.is_accelerator()
@@ -184,7 +184,6 @@ std::ostream& SYCL::impl_sycl_info(std::ostream& os,
             << "\nNative Vector Width Half: "
             << device.get_info<device::native_vector_width_half>()
             << "\nAddress Bits: " << device.get_info<device::address_bits>()
-            << "\nImage Support: " << device.get_info<device::image_support>()
             << "\nMax Mem Alloc Size: "
             << device.get_info<device::max_mem_alloc_size>()
             << "\nMax Read Image Args: "
@@ -217,26 +216,11 @@ std::ostream& SYCL::impl_sycl_info(std::ostream& os,
             << "\nLocal Mem Size: " << device.get_info<device::local_mem_size>()
             << "\nError Correction Support: "
             << device.get_info<device::error_correction_support>()
-            << "\nHost Unified Memory: "
-            << device.get_info<device::host_unified_memory>()
             << "\nProfiling Timer Resolution: "
             << device.get_info<device::profiling_timer_resolution>()
-            << "\nIs Endian Little: "
-            << device.get_info<device::is_endian_little>()
             << "\nIs Available: " << device.get_info<device::is_available>()
-            << "\nIs Compiler Available: "
-            << device.get_info<device::is_compiler_available>()
-            << "\nIs Linker Available: "
-            << device.get_info<device::is_linker_available>()
-            << "\nQueue Profiling: "
-            << device.get_info<device::queue_profiling>()
             << "\nVendor: " << device.get_info<device::vendor>()
-            << "\nProfile: " << device.get_info<device::profile>()
             << "\nVersion: " << device.get_info<device::version>()
-            << "\nPrintf Buffer Size: "
-            << device.get_info<device::printf_buffer_size>()
-            << "\nPreferred Interop User Sync: "
-            << device.get_info<device::preferred_interop_user_sync>()
             << "\nPartition Max Sub Devices: "
             << device.get_info<device::partition_max_sub_devices>()
             << "\nReference Count: "
diff --git a/core/src/Kokkos_SYCL.hpp b/core/src/SYCL/Kokkos_SYCL.hpp
similarity index 96%
rename from core/src/Kokkos_SYCL.hpp
rename to core/src/SYCL/Kokkos_SYCL.hpp
index 0f8e744eb6..60d4197af7 100644
--- a/core/src/Kokkos_SYCL.hpp
+++ b/core/src/SYCL/Kokkos_SYCL.hpp
@@ -31,7 +31,7 @@ static_assert(false,
 #else
 #include <CL/sycl.hpp>
 #endif
-#include <Kokkos_SYCL_Space.hpp>
+#include <SYCL/Kokkos_SYCL_Space.hpp>
 #include <Kokkos_Layout.hpp>
 #include <Kokkos_ScratchSpace.hpp>
 #include <impl/Kokkos_Profiling_Interface.hpp>
@@ -169,7 +169,7 @@ std::vector<SYCL> partition_space(const SYCL& sycl_space, Args...) {
 
 template <class T>
 std::vector<SYCL> partition_space(const SYCL& sycl_space,
-                                  std::vector<T>& weights) {
+                                  std::vector<T> const& weights) {
   static_assert(
       std::is_arithmetic<T>::value,
       "Kokkos Error: partitioning arguments must be integers or floats");
@@ -178,6 +178,9 @@ std::vector<SYCL> partition_space(const SYCL& sycl_space,
   sycl::device device =
       sycl_space.impl_internal_space_instance()->m_queue->get_device();
   std::vector<SYCL> instances;
+
+  // We only care about the number of instances to create and ignore weights
+  // otherwise.
   instances.reserve(weights.size());
   for (unsigned int i = 0; i < weights.size(); ++i)
     instances.emplace_back(sycl::queue(context, device));
diff --git a/core/src/SYCL/Kokkos_SYCL_DeepCopy.hpp b/core/src/SYCL/Kokkos_SYCL_DeepCopy.hpp
index 62b7977fcc..afc7eebd38 100644
--- a/core/src/SYCL/Kokkos_SYCL_DeepCopy.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_DeepCopy.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_SYCLDEEPCOPY_HPP
 
 #include <Kokkos_Core_fwd.hpp>
-#include <Kokkos_SYCL.hpp>
+#include <SYCL/Kokkos_SYCL.hpp>
 
 #include <vector>
 
@@ -27,26 +27,6 @@
 namespace Kokkos {
 namespace Impl {
 
-template <class DT, class... DP>
-struct ZeroMemset<Kokkos::Experimental::SYCL, DT, DP...> {
-  ZeroMemset(const Kokkos::Experimental::SYCL& exec_space,
-             const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    auto event = exec_space.impl_internal_space_instance()->m_queue->memset(
-        dst.data(), 0,
-        dst.size() * sizeof(typename View<DT, DP...>::value_type));
-    exec_space.impl_internal_space_instance()
-        ->m_queue->ext_oneapi_submit_barrier(std::vector<sycl::event>{event});
-  }
-
-  ZeroMemset(const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type&) {
-    Experimental::Impl::SYCLInternal::singleton().m_queue->memset(
-        dst.data(), 0,
-        dst.size() * sizeof(typename View<DT, DP...>::value_type));
-  }
-};
-
 void DeepCopySYCL(void* dst, const void* src, size_t n);
 void DeepCopyAsyncSYCL(const Kokkos::Experimental::SYCL& instance, void* dst,
                        const void* src, size_t n);
diff --git a/core/src/SYCL/Kokkos_SYCL_Instance.cpp b/core/src/SYCL/Kokkos_SYCL_Instance.cpp
index 0e1738d6ac..472baed744 100644
--- a/core/src/SYCL/Kokkos_SYCL_Instance.cpp
+++ b/core/src/SYCL/Kokkos_SYCL_Instance.cpp
@@ -75,7 +75,14 @@ void SYCLInternal::initialize(const sycl::device& d) {
       Kokkos::Impl::throw_runtime_exception(
           "There was an asynchronous SYCL error!\n");
   };
+  // FIXME SYCL+Cuda Apparently, submit_barrier doesn't quite work as expected
+  // for oneAPI 2023.0.0 on NVIDIA GPUs.
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  initialize(
+      sycl::queue{d, exception_handler, sycl::property::queue::in_order()});
+#else
   initialize(sycl::queue{d, exception_handler});
+#endif
 }
 
 // FIXME_SYCL
@@ -127,27 +134,55 @@ void SYCLInternal::initialize(const sycl::queue& q) {
     Kokkos::Impl::throw_runtime_exception(msg.str());
   }
 
-  m_team_scratch_current_size = 0;
-  m_team_scratch_ptr          = nullptr;
+#ifdef KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED
+  // Init the array for used for arbitrarily sized atomics
+  if (this == &singleton()) {
+    desul::Impl::init_lock_arrays();
+    desul::Impl::init_lock_arrays_sycl(*m_queue);
+  }
+#endif
+}
+
+int SYCLInternal::acquire_team_scratch_space() {
+  // Grab the next scratch memory allocation. We must make sure that the last
+  // kernel using the allocation has completed, so we wait for the event that
+  // was registered with that kernel.
+  int current_team_scratch = desul::atomic_fetch_inc_mod(
+      &m_current_team_scratch, m_n_team_scratch - 1,
+      desul::MemoryOrderRelaxed(), desul::MemoryScopeDevice());
+
+  m_team_scratch_event[current_team_scratch].wait_and_throw();
+
+  return current_team_scratch;
 }
 
 sycl::device_ptr<void> SYCLInternal::resize_team_scratch_space(
-    std::int64_t bytes, bool force_shrink) {
-  if (m_team_scratch_current_size == 0) {
-    m_team_scratch_current_size = bytes;
-    m_team_scratch_ptr =
+    int scratch_pool_id, std::int64_t bytes, bool force_shrink) {
+  // Multiple ParallelFor/Reduce Teams can call this function at the same time
+  // and invalidate the m_team_scratch_ptr. We use a pool to avoid any race
+  // condition.
+  if (m_team_scratch_current_size[scratch_pool_id] == 0) {
+    m_team_scratch_current_size[scratch_pool_id] = bytes;
+    m_team_scratch_ptr[scratch_pool_id] =
         Kokkos::kokkos_malloc<Experimental::SYCLDeviceUSMSpace>(
             "Kokkos::Experimental::SYCLDeviceUSMSpace::TeamScratchMemory",
-            m_team_scratch_current_size);
+            m_team_scratch_current_size[scratch_pool_id]);
   }
-  if ((bytes > m_team_scratch_current_size) ||
-      ((bytes < m_team_scratch_current_size) && (force_shrink))) {
-    m_team_scratch_current_size = bytes;
-    m_team_scratch_ptr =
+  if ((bytes > m_team_scratch_current_size[scratch_pool_id]) ||
+      ((bytes < m_team_scratch_current_size[scratch_pool_id]) &&
+       (force_shrink))) {
+    m_team_scratch_current_size[scratch_pool_id] = bytes;
+    m_team_scratch_ptr[scratch_pool_id] =
         Kokkos::kokkos_realloc<Experimental::SYCLDeviceUSMSpace>(
-            m_team_scratch_ptr, m_team_scratch_current_size);
+            m_team_scratch_ptr[scratch_pool_id],
+            m_team_scratch_current_size[scratch_pool_id]);
   }
-  return m_team_scratch_ptr;
+  return m_team_scratch_ptr[scratch_pool_id];
+}
+
+void SYCLInternal::register_team_scratch_event(int scratch_pool_id,
+                                               sycl::event event) {
+  m_team_scratch_event[scratch_pool_id] = event;
 }
 
 uint32_t SYCLInternal::impl_get_instance_id() const { return m_instance_id; }
@@ -160,7 +195,13 @@ void SYCLInternal::finalize() {
 
   // The global_unique_token_locks array is static and should only be
   // deallocated once by the defualt instance
-  if (this == &singleton()) Impl::sycl_global_unique_token_locks(true);
+  if (this == &singleton()) {
+    Impl::sycl_global_unique_token_locks(true);
+#ifdef KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED
+    desul::Impl::finalize_lock_arrays();
+    desul::Impl::finalize_lock_arrays_sycl(*m_queue);
+#endif
+  }
 
   using RecordSYCL = Kokkos::Impl::SharedAllocationRecord<SYCLDeviceUSMSpace>;
   if (nullptr != m_scratchSpace)
@@ -173,11 +214,14 @@ void SYCLInternal::finalize() {
   m_scratchFlagsCount = 0;
   m_scratchFlags      = nullptr;
 
-  if (m_team_scratch_current_size > 0)
-    Kokkos::kokkos_free<Kokkos::Experimental::SYCLDeviceUSMSpace>(
-        m_team_scratch_ptr);
-  m_team_scratch_current_size = 0;
-  m_team_scratch_ptr          = nullptr;
+  for (int i = 0; i < m_n_team_scratch; ++i) {
+    if (m_team_scratch_current_size[i] > 0) {
+      Kokkos::kokkos_free<Kokkos::Experimental::SYCLDeviceUSMSpace>(
+          m_team_scratch_ptr[i]);
+      m_team_scratch_current_size[i] = 0;
+      m_team_scratch_ptr[i]          = nullptr;
+    }
+  }
 
   for (auto& usm_mem : m_indirectKernelMem) usm_mem.reset();
   // guard erasing from all_queues
@@ -236,11 +280,9 @@ sycl::device_ptr<void> SYCLInternal::scratch_flags(const std::size_t size) {
 
     m_scratchFlags = reinterpret_cast<size_type*>(r->data());
   }
-  m_queue->memset(m_scratchFlags, 0, m_scratchFlagsCount * sizeScratchGrain);
-  fence(*m_queue,
-        "Kokkos::Experimental::SYCLInternal::scratch_flags fence after "
-        "initializing m_scratchFlags",
-        m_instance_id);
+  auto memset_event = m_queue->memset(m_scratchFlags, 0,
+                                      m_scratchFlagsCount * sizeScratchGrain);
+  m_queue->ext_oneapi_submit_barrier(std::vector{memset_event});
 
   return m_scratchFlags;
 }
diff --git a/core/src/SYCL/Kokkos_SYCL_Instance.hpp b/core/src/SYCL/Kokkos_SYCL_Instance.hpp
index 58775647f0..51a617054d 100644
--- a/core/src/SYCL/Kokkos_SYCL_Instance.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Instance.hpp
@@ -45,8 +45,11 @@ class SYCLInternal {
 
   sycl::device_ptr<void> scratch_space(const std::size_t size);
   sycl::device_ptr<void> scratch_flags(const std::size_t size);
-  sycl::device_ptr<void> resize_team_scratch_space(std::int64_t bytes,
+  int acquire_team_scratch_space();
+  sycl::device_ptr<void> resize_team_scratch_space(int scratch_pool_id,
+                                                   std::int64_t bytes,
                                                    bool force_shrink = false);
+  void register_team_scratch_event(int scratch_pool_id, sycl::event event);
 
   uint32_t impl_get_instance_id() const;
   static int m_syclDev;
@@ -62,8 +65,12 @@ class SYCLInternal {
   // mutex to access shared memory
   mutable std::mutex m_mutexScratchSpace;
 
-  int64_t m_team_scratch_current_size       = 0;
-  sycl::device_ptr<void> m_team_scratch_ptr = nullptr;
+  // Team Scratch Level 1 Space
+  static constexpr int m_n_team_scratch                               = 10;
+  mutable int64_t m_team_scratch_current_size[m_n_team_scratch]       = {};
+  mutable sycl::device_ptr<void> m_team_scratch_ptr[m_n_team_scratch] = {};
+  mutable int m_current_team_scratch                                  = 0;
+  mutable sycl::event m_team_scratch_event[m_n_team_scratch]          = {};
   mutable std::mutex m_team_scratch_mutex;
 
   uint32_t m_instance_id = Kokkos::Tools::Experimental::Impl::idForInstance<
@@ -323,10 +330,29 @@ struct sycl::is_device_copyable<
     Kokkos::Experimental::Impl::SYCLFunctionWrapper<Functor, Storage, false>>
     : std::true_type {};
 
+// FIXME_SYCL Remove when this specialization when specializations for
+// sycl::device_copyable also apply to const-qualified types.
+template <typename>
+struct NonTriviallyCopyableAndDeviceCopyable {
+  NonTriviallyCopyableAndDeviceCopyable(
+      const NonTriviallyCopyableAndDeviceCopyable&) {}
+};
+
+template <typename T>
+struct sycl::is_device_copyable<NonTriviallyCopyableAndDeviceCopyable<T>>
+    : std::true_type {};
+
+static_assert(
+    !std::is_trivially_copyable_v<
+        NonTriviallyCopyableAndDeviceCopyable<void>> &&
+    sycl::is_device_copyable_v<NonTriviallyCopyableAndDeviceCopyable<void>>);
+
 template <typename Functor, typename Storage>
 struct sycl::is_device_copyable<
     const Kokkos::Experimental::Impl::SYCLFunctionWrapper<Functor, Storage,
-                                                          false>>
+                                                          false>,
+    std::enable_if_t<!sycl::is_device_copyable_v<
+        const NonTriviallyCopyableAndDeviceCopyable<Functor>>>>
     : std::true_type {};
 #endif
 #endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp b/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp
index c7959c1c1c..a29e8010d8 100644
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp
@@ -37,7 +37,7 @@ inline constexpr bool use_shuffle_based_algorithm =
 namespace SYCLReduction {
 template <typename ValueType, typename ReducerType, int dim>
 std::enable_if_t<!use_shuffle_based_algorithm<ReducerType>> workgroup_reduction(
-    sycl::nd_item<dim>& item, sycl::local_ptr<ValueType> local_mem,
+    sycl::nd_item<dim>& item, sycl::local_accessor<ValueType> local_mem,
     sycl::device_ptr<ValueType> results_ptr,
     sycl::global_ptr<ValueType> device_accessible_result_ptr,
     const unsigned int value_count, const ReducerType& final_reducer,
@@ -109,7 +109,7 @@ std::enable_if_t<!use_shuffle_based_algorithm<ReducerType>> workgroup_reduction(
 
 template <typename ValueType, typename ReducerType, int dim>
 std::enable_if_t<use_shuffle_based_algorithm<ReducerType>> workgroup_reduction(
-    sycl::nd_item<dim>& item, sycl::local_ptr<ValueType> local_mem,
+    sycl::nd_item<dim>& item, sycl::local_accessor<ValueType> local_mem,
     ValueType local_value, sycl::device_ptr<ValueType> results_ptr,
     sycl::global_ptr<ValueType> device_accessible_result_ptr,
     const ReducerType& final_reducer, bool final, unsigned int max_size) {
@@ -179,60 +179,41 @@ std::enable_if_t<use_shuffle_based_algorithm<ReducerType>> workgroup_reduction(
 
 }  // namespace SYCLReduction
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
                      Kokkos::Experimental::SYCL> {
  public:
-  using Policy = Kokkos::RangePolicy<Traits...>;
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-  using execution_space = typename Analysis::execution_space;
-  using value_type      = typename Analysis::value_type;
-  using pointer_type    = typename Analysis::pointer_type;
-  using reference_type  = typename Analysis::reference_type;
+  using value_type     = typename ReducerType::value_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
   using WorkTag = typename Policy::work_tag;
 
  public:
   // V - View
-  template <typename V>
-  ParallelReduce(const FunctorType& f, const Policy& p, const V& v,
-                 std::enable_if_t<Kokkos::is_view<V>::value, void*> = nullptr)
-      : m_functor(f),
+  template <typename View>
+  ParallelReduce(const CombinedFunctorReducerType& f, const Policy& p,
+                 const View& v)
+      : m_functor_reducer(f),
         m_policy(p),
         m_result_ptr(v.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                              typename V::memory_space>::accessible),
-        m_shared_memory_lock(
-            p.space().impl_internal_space_instance()->m_mutexScratchSpace) {}
-
-  ParallelReduce(const FunctorType& f, const Policy& p,
-                 const ReducerType& reducer)
-      : m_functor(f),
-        m_policy(p),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
+                              typename View::memory_space>::accessible),
         m_shared_memory_lock(
             p.space().impl_internal_space_instance()->m_mutexScratchSpace) {}
 
  private:
-  template <typename PolicyType, typename FunctorWrapper,
-            typename ReducerWrapper>
+  template <typename PolicyType, typename CombinedFunctorReducerWrapper>
   sycl::event sycl_direct_launch(
-      const PolicyType& policy, const FunctorWrapper& functor_wrapper,
-      const ReducerWrapper& reducer_wrapper,
-      const std::vector<sycl::event>& memcpy_events) const {
+      const PolicyType& policy,
+      const CombinedFunctorReducerWrapper& functor_reducer_wrapper,
+      const sycl::event& memcpy_event) const {
     // Convenience references
     const Kokkos::Experimental::SYCL& space = policy.space();
     Kokkos::Experimental::Impl::SYCLInternal& instance =
@@ -242,7 +223,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     constexpr size_t values_per_thread = 2;
     std::size_t size                   = policy.end() - policy.begin();
     const unsigned int value_count =
-        Analysis::value_count(ReducerConditional::select(m_functor, m_reducer));
+        m_functor_reducer.get_reducer().value_count();
     sycl::device_ptr<value_type> results_ptr = nullptr;
     sycl::global_ptr<value_type> device_accessible_result_ptr =
         m_result_ptr_device_accessible ? m_result_ptr : nullptr;
@@ -259,24 +240,22 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
 
       auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
         const auto begin = policy.begin();
-        cgh.depends_on(memcpy_events);
+        cgh.depends_on(memcpy_event);
         cgh.single_task([=]() {
-          const auto& functor          = functor_wrapper.get_functor();
-          const auto& selected_reducer = ReducerConditional::select(
-              static_cast<const FunctorType&>(functor),
-              static_cast<const ReducerType&>(reducer_wrapper.get_functor()));
-          typename Analysis::Reducer final_reducer(&selected_reducer);
-          reference_type update = final_reducer.init(results_ptr);
+          const CombinedFunctorReducerType& functor_reducer =
+              functor_reducer_wrapper.get_functor();
+          const FunctorType& functor = functor_reducer.get_functor();
+          const ReducerType& reducer = functor_reducer.get_reducer();
+          reference_type update      = reducer.init(results_ptr);
           if (size == 1) {
-            if constexpr (std::is_void<WorkTag>::value)
+            if constexpr (std::is_void_v<WorkTag>)
               functor(begin, update);
             else
               functor(WorkTag(), begin, update);
           }
-          final_reducer.final(results_ptr);
+          reducer.final(results_ptr);
           if (device_accessible_result_ptr != nullptr)
-            final_reducer.copy(device_accessible_result_ptr.get(),
-                               results_ptr.get());
+            reducer.copy(device_accessible_result_ptr.get(), results_ptr.get());
         });
       });
       q.ext_oneapi_submit_barrier(
@@ -293,12 +272,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
           instance.scratch_flags(sizeof(unsigned int)));
 
       auto reduction_lambda_factory =
-          [&](sycl::accessor<value_type, 1, sycl::access::mode::read_write,
-                             sycl::access::target::local>
-                  local_mem,
-              sycl::accessor<unsigned int, 1, sycl::access::mode::read_write,
-                             sycl::access::target::local>
-                  num_teams_done,
+          [&](sycl::local_accessor<value_type> local_mem,
+              sycl::local_accessor<unsigned int> num_teams_done,
               sycl::device_ptr<value_type> results_ptr) {
             const auto begin = policy.begin();
 
@@ -310,23 +285,21 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
               const auto global_id =
                   wgroup_size * item.get_group_linear_id() * values_per_thread +
                   local_id;
-              const auto& functor          = functor_wrapper.get_functor();
-              const auto& selected_reducer = ReducerConditional::select(
-                  static_cast<const FunctorType&>(functor),
-                  static_cast<const ReducerType&>(
-                      reducer_wrapper.get_functor()));
-              typename Analysis::Reducer final_reducer(&selected_reducer);
+              const CombinedFunctorReducerType& functor_reducer =
+                  functor_reducer_wrapper.get_functor();
+              const FunctorType& functor = functor_reducer.get_functor();
+              const ReducerType& reducer = functor_reducer.get_reducer();
 
               using index_type       = typename Policy::index_type;
               const auto upper_bound = std::min<index_type>(
                   global_id + values_per_thread * wgroup_size, size);
 
-              if constexpr (Analysis::StaticValueSize == 0) {
+              if constexpr (ReducerType::static_value_size() == 0) {
                 reference_type update =
-                    final_reducer.init(&local_mem[local_id * value_count]);
+                    reducer.init(&local_mem[local_id * value_count]);
                 for (index_type id = global_id; id < upper_bound;
                      id += wgroup_size) {
-                  if constexpr (std::is_void<WorkTag>::value)
+                  if constexpr (std::is_void_v<WorkTag>)
                     functor(id + begin, update);
                   else
                     functor(WorkTag(), id + begin, update);
@@ -334,9 +307,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                 item.barrier(sycl::access::fence_space::local_space);
 
                 SYCLReduction::workgroup_reduction<>(
-                    item, local_mem.get_pointer(), results_ptr,
-                    device_accessible_result_ptr, value_count, final_reducer,
-                    false, std::min(size, wgroup_size));
+                    item, local_mem, results_ptr, device_accessible_result_ptr,
+                    value_count, reducer, false, std::min(size, wgroup_size));
 
                 if (local_id == 0) {
                   sycl::atomic_ref<unsigned, sycl::memory_order::relaxed,
@@ -348,36 +320,36 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                 item.barrier(sycl::access::fence_space::local_space);
                 if (num_teams_done[0] == n_wgroups) {
                   if (local_id >= n_wgroups)
-                    final_reducer.init(&local_mem[local_id * value_count]);
+                    reducer.init(&local_mem[local_id * value_count]);
                   else {
-                    final_reducer.copy(&local_mem[local_id * value_count],
-                                       &results_ptr[local_id * value_count]);
+                    reducer.copy(&local_mem[local_id * value_count],
+                                 &results_ptr[local_id * value_count]);
                     for (unsigned int id = local_id + wgroup_size;
                          id < n_wgroups; id += wgroup_size) {
-                      final_reducer.join(&local_mem[local_id * value_count],
-                                         &results_ptr[id * value_count]);
+                      reducer.join(&local_mem[local_id * value_count],
+                                   &results_ptr[id * value_count]);
                     }
                   }
 
                   SYCLReduction::workgroup_reduction<>(
-                      item, local_mem.get_pointer(), results_ptr,
-                      device_accessible_result_ptr, value_count, final_reducer,
-                      true, std::min(n_wgroups, wgroup_size));
+                      item, local_mem, results_ptr,
+                      device_accessible_result_ptr, value_count, reducer, true,
+                      std::min(n_wgroups, wgroup_size));
                 }
               } else {
                 value_type local_value;
-                reference_type update = final_reducer.init(&local_value);
+                reference_type update = reducer.init(&local_value);
                 for (index_type id = global_id; id < upper_bound;
                      id += wgroup_size) {
-                  if constexpr (std::is_void<WorkTag>::value)
+                  if constexpr (std::is_void_v<WorkTag>)
                     functor(id + begin, update);
                   else
                     functor(WorkTag(), id + begin, update);
                 }
 
                 SYCLReduction::workgroup_reduction<>(
-                    item, local_mem.get_pointer(), local_value, results_ptr,
-                    device_accessible_result_ptr, final_reducer, false,
+                    item, local_mem, local_value, results_ptr,
+                    device_accessible_result_ptr, reducer, false,
                     std::min(size, wgroup_size));
 
                 if (local_id == 0) {
@@ -390,18 +362,18 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                 item.barrier(sycl::access::fence_space::local_space);
                 if (num_teams_done[0] == n_wgroups) {
                   if (local_id >= n_wgroups)
-                    final_reducer.init(&local_value);
+                    reducer.init(&local_value);
                   else {
                     local_value = results_ptr[local_id];
                     for (unsigned int id = local_id + wgroup_size;
                          id < n_wgroups; id += wgroup_size) {
-                      final_reducer.join(&local_value, &results_ptr[id]);
+                      reducer.join(&local_value, &results_ptr[id]);
                     }
                   }
 
                   SYCLReduction::workgroup_reduction<>(
-                      item, local_mem.get_pointer(), local_value, results_ptr,
-                      device_accessible_result_ptr, final_reducer, true,
+                      item, local_mem, local_value, results_ptr,
+                      device_accessible_result_ptr, reducer, true,
                       std::min(n_wgroups, wgroup_size));
                 }
               }
@@ -410,9 +382,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
           };
 
       auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        sycl::accessor<unsigned int, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            num_teams_done(1, cgh);
+        sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
 
         auto dummy_reduction_lambda =
             reduction_lambda_factory({1, cgh}, num_teams_done, nullptr);
@@ -453,12 +423,10 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
                           wgroup_size - 1) /
                          wgroup_size;
 
-        sycl::accessor<value_type, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            local_mem(sycl::range<1>(wgroup_size) * std::max(value_count, 1u),
-                      cgh);
+        sycl::local_accessor<value_type> local_mem(
+            sycl::range<1>(wgroup_size) * std::max(value_count, 1u), cgh);
 
-        cgh.depends_on(memcpy_events);
+        cgh.depends_on(memcpy_event);
 
         auto reduction_lambda =
             reduction_lambda_factory(local_mem, num_teams_done, results_ptr);
@@ -490,25 +458,21 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         *m_policy.space().impl_internal_space_instance();
     using IndirectKernelMem =
         Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
-    IndirectKernelMem& indirectKernelMem  = instance.get_indirect_kernel_mem();
-    IndirectKernelMem& indirectReducerMem = instance.get_indirect_kernel_mem();
-
-    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_functor, indirectKernelMem);
-    auto reducer_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_reducer, indirectReducerMem);
-
-    sycl::event event = sycl_direct_launch(
-        m_policy, functor_wrapper, reducer_wrapper,
-        {functor_wrapper.get_copy_event(), reducer_wrapper.get_copy_event()});
-    functor_wrapper.register_event(event);
-    reducer_wrapper.register_event(event);
+    IndirectKernelMem& indirectKernelMem = instance.get_indirect_kernel_mem();
+
+    auto functor_reducer_wrapper =
+        Experimental::Impl::make_sycl_function_wrapper(m_functor_reducer,
+                                                       indirectKernelMem);
+
+    sycl::event event =
+        sycl_direct_launch(m_policy, functor_reducer_wrapper,
+                           functor_reducer_wrapper.get_copy_event());
+    functor_reducer_wrapper.register_event(event);
   }
 
  private:
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
 
@@ -517,23 +481,19 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
   std::scoped_lock<std::mutex> m_shared_memory_lock;
 };
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>,
                      Kokkos::Experimental::SYCL> {
  public:
-  using Policy = Kokkos::MDRangePolicy<Traits...>;
+  using Policy      = Kokkos::MDRangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-  using execution_space = typename Analysis::execution_space;
-  using value_type      = typename Analysis::value_type;
-  using pointer_type    = typename Analysis::pointer_type;
-  using reference_type  = typename Analysis::reference_type;
+  using value_type     = typename ReducerType::value_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
   using WorkTag = typename Policy::work_tag;
 
@@ -562,40 +522,25 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
 
  public:
   // V - View
-  template <typename V>
-  ParallelReduce(const FunctorType& f, const Policy& p, const V& v,
-                 std::enable_if_t<Kokkos::is_view<V>::value, void*> = nullptr)
-      : m_functor(f),
+  template <typename View>
+  ParallelReduce(const CombinedFunctorReducerType& f, const Policy& p,
+                 const View& v)
+      : m_functor_reducer(f),
         m_policy(p),
         m_space(p.space()),
         m_result_ptr(v.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                              typename V::memory_space>::accessible),
-        m_shared_memory_lock(
-            m_space.impl_internal_space_instance()->m_mutexScratchSpace) {}
-
-  ParallelReduce(const FunctorType& f, const Policy& p,
-                 const ReducerType& reducer)
-      : m_functor(f),
-        m_policy(p),
-        m_space(p.space()),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
+                              typename View::memory_space>::accessible),
         m_shared_memory_lock(
             m_space.impl_internal_space_instance()->m_mutexScratchSpace) {}
 
  private:
-  template <typename PolicyType, typename FunctorWrapper,
-            typename ReducerWrapper>
+  template <typename PolicyType, typename CombinedFunctorReducerWrapper>
   sycl::event sycl_direct_launch(
-      const PolicyType& policy, const FunctorWrapper& functor_wrapper,
-      const ReducerWrapper& reducer_wrapper,
-      const std::vector<sycl::event>& memcpy_events) const {
+      const PolicyType& policy,
+      const CombinedFunctorReducerWrapper& functor_reducer_wrapper,
+      const sycl::event& memcpy_event) const {
     // Convenience references
     Kokkos::Experimental::Impl::SYCLInternal& instance =
         *m_space.impl_internal_space_instance();
@@ -615,7 +560,7 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     const auto init_size =
         std::max<std::size_t>((size + wgroup_size - 1) / wgroup_size, 1);
     const unsigned int value_count =
-        Analysis::value_count(ReducerConditional::select(m_functor, m_reducer));
+        m_functor_reducer.get_reducer().value_count();
     const auto results_ptr =
         static_cast<sycl::device_ptr<value_type>>(instance.scratch_space(
             sizeof(value_type) * std::max(value_count, 1u) * init_size));
@@ -631,15 +576,14 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     // m_result_ptr yet.
     if (size <= 1) {
       auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        cgh.depends_on(memcpy_events);
+        cgh.depends_on(memcpy_event);
         cgh.single_task([=]() {
-          const auto& functor          = functor_wrapper.get_functor();
-          const auto& selected_reducer = ReducerConditional::select(
-              static_cast<const FunctorType&>(functor),
-              static_cast<const ReducerType&>(reducer_wrapper.get_functor()));
-          typename Analysis::Reducer final_reducer(&selected_reducer);
+          const CombinedFunctorReducerType& functor_reducer =
+              functor_reducer_wrapper.get_functor();
+          const FunctorType& functor = functor_reducer.get_functor();
+          const ReducerType& reducer = functor_reducer.get_reducer();
 
-          reference_type update = final_reducer.init(results_ptr);
+          reference_type update = reducer.init(results_ptr);
           if (size == 1) {
             Kokkos::Impl::Reduce::DeviceIterateTile<
                 Policy::rank, BarePolicy, FunctorType,
@@ -647,10 +591,9 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
                 policy, functor, update, {1, 1, 1}, {0, 0, 0}, {0, 0, 0})
                 .exec_range();
           }
-          final_reducer.final(results_ptr);
+          reducer.final(results_ptr);
           if (device_accessible_result_ptr)
-            final_reducer.copy(device_accessible_result_ptr.get(),
-                               results_ptr.get());
+            reducer.copy(device_accessible_result_ptr.get(), results_ptr.get());
         });
       });
       q.ext_oneapi_submit_barrier(
@@ -665,25 +608,20 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     if (size > 1) {
       auto n_wgroups             = (size + wgroup_size - 1) / wgroup_size;
       auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        sycl::accessor<value_type, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            local_mem(sycl::range<1>(wgroup_size) * std::max(value_count, 1u),
-                      cgh);
-        sycl::accessor<unsigned int, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            num_teams_done(1, cgh);
+        sycl::local_accessor<value_type> local_mem(
+            sycl::range<1>(wgroup_size) * std::max(value_count, 1u), cgh);
+        sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
 
         const BarePolicy bare_policy = m_policy;
 
-        cgh.depends_on(memcpy_events);
+        cgh.depends_on(memcpy_event);
 
         cgh.parallel_for(range, [=](sycl::nd_item<1> item) {
-          const auto local_id          = item.get_local_linear_id();
-          const auto& functor          = functor_wrapper.get_functor();
-          const auto& selected_reducer = ReducerConditional::select(
-              static_cast<const FunctorType&>(functor),
-              static_cast<const ReducerType&>(reducer_wrapper.get_functor()));
-          typename Analysis::Reducer final_reducer(&selected_reducer);
+          const auto local_id = item.get_local_linear_id();
+          const CombinedFunctorReducerType& functor_reducer =
+              functor_reducer_wrapper.get_functor();
+          const FunctorType& functor = functor_reducer.get_functor();
+          const ReducerType& reducer = functor_reducer.get_reducer();
 
           // In the first iteration, we call functor to initialize the local
           // memory. Otherwise, the local memory is initialized with the
@@ -702,9 +640,9 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
           const index_type n_global_y = 1;
           const index_type n_global_z = 1;
 
-          if constexpr (Analysis::StaticValueSize == 0) {
+          if constexpr (ReducerType::static_value_size() == 0) {
             reference_type update =
-                final_reducer.init(&local_mem[local_id * value_count]);
+                reducer.init(&local_mem[local_id * value_count]);
 
             Kokkos::Impl::Reduce::DeviceIterateTile<
                 Policy::rank, BarePolicy, FunctorType,
@@ -716,9 +654,8 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
             item.barrier(sycl::access::fence_space::local_space);
 
             SYCLReduction::workgroup_reduction<>(
-                item, local_mem.get_pointer(), results_ptr,
-                device_accessible_result_ptr, value_count, final_reducer, false,
-                std::min(size, wgroup_size));
+                item, local_mem, results_ptr, device_accessible_result_ptr,
+                value_count, reducer, false, std::min(size, wgroup_size));
 
             if (local_id == 0) {
               sycl::atomic_ref<unsigned, sycl::memory_order::relaxed,
@@ -730,25 +667,24 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
             item.barrier(sycl::access::fence_space::local_space);
             if (num_teams_done[0] == n_wgroups) {
               if (local_id >= n_wgroups)
-                final_reducer.init(&local_mem[local_id * value_count]);
+                reducer.init(&local_mem[local_id * value_count]);
               else {
-                final_reducer.copy(&local_mem[local_id * value_count],
-                                   &results_ptr[local_id * value_count]);
+                reducer.copy(&local_mem[local_id * value_count],
+                             &results_ptr[local_id * value_count]);
                 for (unsigned int id = local_id + wgroup_size; id < n_wgroups;
                      id += wgroup_size) {
-                  final_reducer.join(&local_mem[local_id * value_count],
-                                     &results_ptr[id * value_count]);
+                  reducer.join(&local_mem[local_id * value_count],
+                               &results_ptr[id * value_count]);
                 }
               }
 
               SYCLReduction::workgroup_reduction<>(
-                  item, local_mem.get_pointer(), results_ptr,
-                  device_accessible_result_ptr, value_count, final_reducer,
-                  true, std::min(n_wgroups, wgroup_size));
+                  item, local_mem, results_ptr, device_accessible_result_ptr,
+                  value_count, reducer, true, std::min(n_wgroups, wgroup_size));
             }
           } else {
             value_type local_value;
-            reference_type update = final_reducer.init(&local_value);
+            reference_type update = reducer.init(&local_value);
 
             Kokkos::Impl::Reduce::DeviceIterateTile<
                 Policy::rank, BarePolicy, FunctorType,
@@ -759,8 +695,8 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
                 .exec_range();
 
             SYCLReduction::workgroup_reduction<>(
-                item, local_mem.get_pointer(), local_value, results_ptr,
-                device_accessible_result_ptr, final_reducer, false,
+                item, local_mem, local_value, results_ptr,
+                device_accessible_result_ptr, reducer, false,
                 std::min(size, wgroup_size));
 
             if (local_id == 0) {
@@ -773,18 +709,18 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
             item.barrier(sycl::access::fence_space::local_space);
             if (num_teams_done[0] == n_wgroups) {
               if (local_id >= n_wgroups)
-                final_reducer.init(&local_value);
+                reducer.init(&local_value);
               else {
                 local_value = results_ptr[local_id];
                 for (unsigned int id = local_id + wgroup_size; id < n_wgroups;
                      id += wgroup_size) {
-                  final_reducer.join(&local_value, &results_ptr[id]);
+                  reducer.join(&local_value, &results_ptr[id]);
                 }
               }
 
               SYCLReduction::workgroup_reduction<>(
-                  item, local_mem.get_pointer(), local_value, results_ptr,
-                  device_accessible_result_ptr, final_reducer, true,
+                  item, local_mem, local_value, results_ptr,
+                  device_accessible_result_ptr, reducer, true,
                   std::min(n_wgroups, wgroup_size));
             }
           }
@@ -818,26 +754,22 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
         *m_space.impl_internal_space_instance();
     using IndirectKernelMem =
         Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
-    IndirectKernelMem& indirectKernelMem  = instance.get_indirect_kernel_mem();
-    IndirectKernelMem& indirectReducerMem = instance.get_indirect_kernel_mem();
-
-    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_functor, indirectKernelMem);
-    auto reducer_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_reducer, indirectReducerMem);
-
-    sycl::event event = sycl_direct_launch(
-        m_policy, functor_wrapper, reducer_wrapper,
-        {functor_wrapper.get_copy_event(), reducer_wrapper.get_copy_event()});
-    functor_wrapper.register_event(event);
-    reducer_wrapper.register_event(event);
+    IndirectKernelMem& indirectKernelMem = instance.get_indirect_kernel_mem();
+
+    auto functor_reducer_wrapper =
+        Experimental::Impl::make_sycl_function_wrapper(m_functor_reducer,
+                                                       indirectKernelMem);
+
+    sycl::event event =
+        sycl_direct_launch(m_policy, functor_reducer_wrapper,
+                           functor_reducer_wrapper.get_copy_event());
+    functor_reducer_wrapper.register_event(event);
   }
 
  private:
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const BarePolicy m_policy;
   const Kokkos::Experimental::SYCL& m_space;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
 
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp b/core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp
index cf651ced95..f22c8ada02 100644
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp
@@ -31,22 +31,23 @@ namespace Impl {
 // total sum.
 template <int dim, typename ValueType, typename FunctorType>
 void workgroup_scan(sycl::nd_item<dim> item, const FunctorType& final_reducer,
-                    sycl::local_ptr<ValueType> local_mem,
-                    ValueType& local_value, unsigned int global_range) {
+                    sycl::local_accessor<ValueType> local_mem,
+                    ValueType& local_value, int global_range) {
   // subgroup scans
-  auto sg                = item.get_sub_group();
-  const auto sg_group_id = sg.get_group_id()[0];
-  const auto id_in_sg    = sg.get_local_id()[0];
-  for (unsigned int stride = 1; stride < global_range; stride <<= 1) {
+  auto sg               = item.get_sub_group();
+  const int sg_group_id = sg.get_group_id()[0];
+  const int id_in_sg    = sg.get_local_id()[0];
+
+  for (int stride = 1; stride < global_range; stride <<= 1) {
     auto tmp = sg.shuffle_up(local_value, stride);
     if (id_in_sg >= stride) final_reducer.join(&local_value, &tmp);
   }
 
-  const auto max_subgroup_size = sg.get_max_local_range()[0];
-  const auto n_active_subgroups =
+  const int max_subgroup_size = sg.get_max_local_range()[0];
+  const int n_active_subgroups =
       (global_range + max_subgroup_size - 1) / max_subgroup_size;
 
-  const auto local_range = sg.get_local_range()[0];
+  const int local_range = sg.get_local_range()[0];
   if (id_in_sg == local_range - 1 && sg_group_id < n_active_subgroups)
     local_mem[sg_group_id] = local_value;
   local_value = sg.shuffle_up(local_value, 1);
@@ -56,14 +57,13 @@ void workgroup_scan(sycl::nd_item<dim> item, const FunctorType& final_reducer,
   // scan subgroup results using the first subgroup
   if (n_active_subgroups > 1) {
     if (sg_group_id == 0) {
-      const auto n_rounds =
-          (n_active_subgroups + local_range - 1) / local_range;
-      for (unsigned int round = 0; round < n_rounds; ++round) {
-        const unsigned int idx = id_in_sg + round * local_range;
+      const int n_rounds = (n_active_subgroups + local_range - 1) / local_range;
+      for (int round = 0; round < n_rounds; ++round) {
+        const int idx = id_in_sg + round * local_range;
         const auto upper_bound =
             std::min(local_range, n_active_subgroups - round * local_range);
         auto local_sg_value = local_mem[idx < n_active_subgroups ? idx : 0];
-        for (unsigned int stride = 1; stride < upper_bound; stride <<= 1) {
+        for (int stride = 1; stride < upper_bound; stride <<= 1) {
           auto tmp = sg.shuffle_up(local_sg_value, stride);
           if (id_in_sg >= stride) {
             if (idx < n_active_subgroups)
@@ -89,7 +89,7 @@ void workgroup_scan(sycl::nd_item<dim> item, const FunctorType& final_reducer,
     final_reducer.join(&local_value, &local_mem[sg_group_id - 1]);
 }
 
-template <class FunctorType, class... Traits>
+template <class FunctorType, class ValueType, class... Traits>
 class ParallelScanSYCLBase {
  public:
   using Policy = Kokkos::RangePolicy<Traits...>;
@@ -97,12 +97,11 @@ class ParallelScanSYCLBase {
  protected:
   using Member       = typename Policy::member_type;
   using WorkTag      = typename Policy::work_tag;
-  using WorkRange    = typename Policy::WorkRange;
   using LaunchBounds = typename Policy::launch_bounds;
 
  public:
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
+  using Analysis       = FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                   FunctorType, ValueType>;
   using pointer_type   = typename Analysis::pointer_type;
   using value_type     = typename Analysis::value_type;
   using reference_type = typename Analysis::reference_type;
@@ -111,7 +110,8 @@ class ParallelScanSYCLBase {
   using index_type     = typename Policy::index_type;
 
  protected:
-  const FunctorType m_functor;
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
   const Policy m_policy;
   pointer_type m_scratch_space = nullptr;
   const pointer_type m_result_ptr;
@@ -123,128 +123,196 @@ class ParallelScanSYCLBase {
 
  private:
   template <typename FunctorWrapper>
-  void scan_internal(sycl::queue& q, const FunctorWrapper& functor_wrapper,
-                     pointer_type global_mem, std::size_t size) const {
-    // FIXME_SYCL optimize
-    constexpr size_t wgroup_size = 128;
-    auto n_wgroups               = (size + wgroup_size - 1) / wgroup_size;
-    pointer_type group_results   = global_mem + n_wgroups * wgroup_size;
-
-    auto local_scans = q.submit([&](sycl::handler& cgh) {
-      // Store subgroup totals
-      const auto min_subgroup_size =
-          q.get_device()
-              .template get_info<sycl::info::device::sub_group_sizes>()
-              .front();
-      sycl::accessor<value_type, 1, sycl::access::mode::read_write,
-                     sycl::access::target::local>
-          local_mem(sycl::range<1>((wgroup_size + min_subgroup_size - 1) /
-                                   min_subgroup_size),
-                    cgh);
+  sycl::event sycl_direct_launch(const FunctorWrapper& functor_wrapper,
+                                 sycl::event memcpy_event) {
+    // Convenience references
+    const Kokkos::Experimental::SYCL& space = m_policy.space();
+    Kokkos::Experimental::Impl::SYCLInternal& instance =
+        *space.impl_internal_space_instance();
+    sycl::queue& q = space.sycl_queue();
 
-      cgh.parallel_for(
-          sycl::nd_range<1>(n_wgroups * wgroup_size, wgroup_size),
-          [=](sycl::nd_item<1> item) {
-            const FunctorType& functor = functor_wrapper.get_functor();
-            typename Analysis::Reducer final_reducer(&functor);
+    const auto size = m_policy.end() - m_policy.begin();
 
-            const auto local_id  = item.get_local_linear_id();
-            const auto global_id = item.get_global_linear_id();
+    auto scratch_flags = static_cast<sycl::device_ptr<unsigned int>>(
+        instance.scratch_flags(sizeof(unsigned int)));
+
+    const auto begin = m_policy.begin();
+
+    // Initialize global memory
+    auto scan_lambda_factory =
+        [&](sycl::local_accessor<value_type> local_mem,
+            sycl::local_accessor<unsigned int> num_teams_done,
+            sycl::device_ptr<value_type> global_mem_,
+            sycl::device_ptr<value_type> group_results_) {
+          auto lambda = [=](sycl::nd_item<1> item) {
+            auto global_mem    = global_mem_;
+            auto group_results = group_results_;
+
+            const CombinedFunctorReducer<
+                FunctorType, typename Analysis::Reducer>& functor_reducer =
+                functor_wrapper.get_functor();
+            const FunctorType& functor = functor_reducer.get_functor();
+            const typename Analysis::Reducer& reducer =
+                functor_reducer.get_reducer();
+
+            const auto n_wgroups  = item.get_group_range()[0];
+            const int wgroup_size = item.get_local_range()[0];
+
+            const int local_id         = item.get_local_linear_id();
+            const index_type global_id = item.get_global_linear_id();
 
             // Initialize local memory
             value_type local_value;
-            if (global_id < size)
-              local_value = global_mem[global_id];
-            else
-              final_reducer.init(&local_value);
+            reducer.init(&local_value);
+            if (global_id < size) {
+              if constexpr (std::is_void<WorkTag>::value)
+                functor(global_id + begin, local_value, false);
+              else
+                functor(WorkTag(), global_id + begin, local_value, false);
+            }
 
-            workgroup_scan<>(item, final_reducer, local_mem.get_pointer(),
-                             local_value, wgroup_size);
-
-            if (n_wgroups > 1 && local_id == wgroup_size - 1)
-              group_results[item.get_group_linear_id()] =
-                  local_mem[item.get_sub_group().get_group_range()[0] - 1];
+            workgroup_scan<>(item, reducer, local_mem, local_value,
+                             wgroup_size);
 
             // Write results to global memory
             if (global_id < size) global_mem[global_id] = local_value;
-          });
-    });
-    q.ext_oneapi_submit_barrier(std::vector<sycl::event>{local_scans});
-
-    if (n_wgroups > 1) {
-      scan_internal(q, functor_wrapper, group_results, n_wgroups);
-      auto update_with_group_results = q.submit([&](sycl::handler& cgh) {
-        cgh.parallel_for(
-            sycl::nd_range<1>(n_wgroups * wgroup_size, wgroup_size),
-            [=](sycl::nd_item<1> item) {
-              const auto global_id       = item.get_global_linear_id();
-              const FunctorType& functor = functor_wrapper.get_functor();
-              typename Analysis::Reducer final_reducer(&functor);
-              if (global_id < size)
-                final_reducer.join(&global_mem[global_id],
-                                   &group_results[item.get_group_linear_id()]);
-            });
-      });
-      q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{update_with_group_results});
-    }
-  }
 
-  template <typename FunctorWrapper>
-  sycl::event sycl_direct_launch(const FunctorWrapper& functor_wrapper,
-                                 sycl::event memcpy_event) const {
-    // Convenience references
-    const Kokkos::Experimental::SYCL& space = m_policy.space();
-    sycl::queue& q                          = space.sycl_queue();
-
-    const std::size_t len = m_policy.end() - m_policy.begin();
+            if (local_id == wgroup_size - 1) {
+              group_results[item.get_group_linear_id()] =
+                  local_mem[item.get_sub_group().get_group_range()[0] - 1];
 
-    // Initialize global memory
-    auto initialize_global_memory = q.submit([&](sycl::handler& cgh) {
-      auto global_mem = m_scratch_space;
-      auto begin      = m_policy.begin();
+              sycl::atomic_ref<unsigned, sycl::memory_order::relaxed,
+                               sycl::memory_scope::device,
+                               sycl::access::address_space::global_space>
+                  scratch_flags_ref(*scratch_flags);
+              num_teams_done[0] = ++scratch_flags_ref;
+            }
+            item.barrier(sycl::access::fence_space::global_space);
+            if (num_teams_done[0] == n_wgroups) {
+              value_type total;
+              reducer.init(&total);
+
+              for (unsigned int offset = 0; offset < n_wgroups;
+                   offset += wgroup_size) {
+                index_type id = local_id + offset;
+                if (id < static_cast<index_type>(n_wgroups))
+                  local_value = group_results[id];
+                else
+                  reducer.init(&local_value);
+                workgroup_scan<>(
+                    item, reducer, local_mem, local_value,
+                    std::min<index_type>(n_wgroups - offset, wgroup_size));
+                if (id < static_cast<index_type>(n_wgroups)) {
+                  reducer.join(&local_value, &total);
+                  group_results[id] = local_value;
+                }
+                reducer.join(
+                    &total,
+                    &local_mem[item.get_sub_group().get_group_range()[0] - 1]);
+                if (offset + wgroup_size < n_wgroups)
+                  item.barrier(sycl::access::fence_space::global_space);
+              }
+            }
+          };
+          return lambda;
+        };
+
+    size_t wgroup_size;
+    size_t n_wgroups;
+    sycl::device_ptr<value_type> global_mem;
+    sycl::device_ptr<value_type> group_results;
+
+    auto perform_work_group_scans = q.submit([&](sycl::handler& cgh) {
+      sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
+
+      auto dummy_scan_lambda =
+          scan_lambda_factory({1, cgh}, num_teams_done, nullptr, nullptr);
+
+      static sycl::kernel kernel = [&] {
+        sycl::kernel_id functor_kernel_id =
+            sycl::get_kernel_id<decltype(dummy_scan_lambda)>();
+        auto kernel_bundle =
+            sycl::get_kernel_bundle<sycl::bundle_state::executable>(
+                q.get_context(), std::vector{functor_kernel_id});
+        return kernel_bundle.get_kernel(functor_kernel_id);
+      }();
+      auto multiple = kernel.get_info<sycl::info::kernel_device_specific::
+                                          preferred_work_group_size_multiple>(
+          q.get_device());
+      auto max =
+          kernel.get_info<sycl::info::kernel_device_specific::work_group_size>(
+              q.get_device());
+
+      wgroup_size = static_cast<size_t>(max / multiple) * multiple;
+      n_wgroups   = (size + wgroup_size - 1) / wgroup_size;
+
+      // Compute the total amount of memory we will need.
+      // We need to allocate memory for the whole range (rounded towards the
+      // next multiple of the workgroup size) and for one element per workgroup
+      // that will contain the sum of the previous workgroups totals.
+      // FIXME_SYCL consider only storing one value per block and recreate
+      // initial results in the end before doing the final pass
+      global_mem =
+          static_cast<sycl::device_ptr<value_type>>(instance.scratch_space(
+              n_wgroups * (wgroup_size + 1) * sizeof(value_type)));
+      m_scratch_space = global_mem;
+
+      group_results = global_mem + n_wgroups * wgroup_size;
+
+      // Store subgroup totals in local space
+      const auto min_subgroup_size =
+          q.get_device()
+              .template get_info<sycl::info::device::sub_group_sizes>()
+              .front();
+      sycl::local_accessor<value_type> local_mem(
+          sycl::range<1>((wgroup_size + min_subgroup_size - 1) /
+                         min_subgroup_size),
+          cgh);
 
       cgh.depends_on(memcpy_event);
-      cgh.parallel_for(sycl::range<1>(len), [=](sycl::item<1> item) {
-        const typename Policy::index_type id =
-            static_cast<typename Policy::index_type>(item.get_id()) + begin;
-        const FunctorType& functor = functor_wrapper.get_functor();
-        typename Analysis::Reducer final_reducer(&functor);
-
-        value_type update{};
-        final_reducer.init(&update);
-        if constexpr (std::is_void<WorkTag>::value)
-          functor_wrapper.get_functor()(id, update, false);
-        else
-          functor_wrapper.get_functor()(WorkTag(), id, update, false);
-        global_mem[id] = update;
-      });
-    });
-    q.ext_oneapi_submit_barrier(
-        std::vector<sycl::event>{initialize_global_memory});
 
-    // Perform the actual exclusive scan
-    scan_internal(q, functor_wrapper, m_scratch_space, len);
+      auto scan_lambda = scan_lambda_factory(local_mem, num_teams_done,
+                                             global_mem, group_results);
+      cgh.parallel_for(sycl::nd_range<1>(n_wgroups * wgroup_size, wgroup_size),
+                       scan_lambda);
+    });
 
     // Write results to global memory
     auto update_global_results = q.submit([&](sycl::handler& cgh) {
-      auto global_mem                   = m_scratch_space;
       auto result_ptr_device_accessible = m_result_ptr_device_accessible;
       // The compiler failed with CL_INVALID_ARG_VALUE if using m_result_ptr
       // directly.
       auto result_ptr = m_result_ptr_device_accessible ? m_result_ptr : nullptr;
-      cgh.parallel_for(sycl::range<1>(len), [=](sycl::item<1> item) {
-        auto global_id = item.get_id(0);
-
-        value_type update = global_mem[global_id];
-        if constexpr (std::is_void<WorkTag>::value)
-          functor_wrapper.get_functor()(global_id, update, true);
-        else
-          functor_wrapper.get_functor()(WorkTag(), global_id, update, true);
-        global_mem[global_id] = update;
-        if (global_id == len - 1 && result_ptr_device_accessible)
-          *result_ptr = update;
-      });
+
+      cgh.depends_on(perform_work_group_scans);
+
+      cgh.parallel_for(
+          sycl::nd_range<1>(n_wgroups * wgroup_size, wgroup_size),
+          [=](sycl::nd_item<1> item) {
+            auto global_mem_copy       = global_mem;
+            const index_type global_id = item.get_global_linear_id();
+            const CombinedFunctorReducer<
+                FunctorType, typename Analysis::Reducer>& functor_reducer =
+                functor_wrapper.get_functor();
+            const FunctorType& functor = functor_reducer.get_functor();
+            const typename Analysis::Reducer& reducer =
+                functor_reducer.get_reducer();
+
+            if (global_id < size) {
+              value_type update = global_mem[global_id];
+
+              reducer.join(&update, &group_results[item.get_group_linear_id()]);
+
+              if constexpr (std::is_void<WorkTag>::value)
+                functor(global_id + begin, update, true);
+              else
+                functor(WorkTag(), global_id + begin, update, true);
+
+              global_mem_copy[global_id] = update;
+              if (global_id == size - 1 && result_ptr_device_accessible)
+                *result_ptr = update;
+            }
+          });
     });
     q.ext_oneapi_submit_barrier(
         std::vector<sycl::event>{update_global_results});
@@ -256,36 +324,13 @@ class ParallelScanSYCLBase {
   void impl_execute(const PostFunctor& post_functor) {
     if (m_policy.begin() == m_policy.end()) return;
 
-    auto& instance        = *m_policy.space().impl_internal_space_instance();
-    const std::size_t len = m_policy.end() - m_policy.begin();
-
-    // Compute the total amount of memory we will need. We emulate the recursive
-    // structure that is used to do the actual scan. Essentially, we need to
-    // allocate memory for the whole range and then recursively for the reduced
-    // group results until only one group is left.
-    std::size_t total_memory = 0;
-    {
-      size_t wgroup_size   = 128;
-      size_t n_nested_size = len;
-      size_t n_nested_wgroups;
-      do {
-        n_nested_wgroups = (n_nested_size + wgroup_size - 1) / wgroup_size;
-        n_nested_size    = n_nested_wgroups;
-        total_memory += sizeof(value_type) * n_nested_wgroups * wgroup_size;
-      } while (n_nested_wgroups > 1);
-      total_memory += sizeof(value_type) * wgroup_size;
-    }
-
-    // FIXME_SYCL consider only storing one value per block and recreate initial
-    // results in the end before doing the final pass
-    m_scratch_space = static_cast<sycl::device_ptr<value_type>>(
-        instance.scratch_space(total_memory));
+    auto& instance = *m_policy.space().impl_internal_space_instance();
 
     Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem&
         indirectKernelMem = instance.get_indirect_kernel_mem();
 
     auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_functor, indirectKernelMem);
+        m_functor_reducer, indirectKernelMem);
 
     sycl::event event =
         sycl_direct_launch(functor_wrapper, functor_wrapper.get_copy_event());
@@ -296,7 +341,7 @@ class ParallelScanSYCLBase {
   ParallelScanSYCLBase(const FunctorType& arg_functor, const Policy& arg_policy,
                        pointer_type arg_result_ptr,
                        bool arg_result_ptr_device_accessible)
-      : m_functor(arg_functor),
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
         m_policy(arg_policy),
         m_result_ptr(arg_result_ptr),
         m_result_ptr_device_accessible(arg_result_ptr_device_accessible),
@@ -308,9 +353,9 @@ class ParallelScanSYCLBase {
 template <class FunctorType, class... Traits>
 class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
                    Kokkos::Experimental::SYCL>
-    : private ParallelScanSYCLBase<FunctorType, Traits...> {
+    : private ParallelScanSYCLBase<FunctorType, void, Traits...> {
  public:
-  using Base = ParallelScanSYCLBase<FunctorType, Traits...>;
+  using Base = ParallelScanSYCLBase<FunctorType, void, Traits...>;
 
   inline void execute() {
     Base::impl_execute([]() {});
@@ -326,9 +371,9 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
 template <class FunctorType, class ReturnType, class... Traits>
 class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
                             ReturnType, Kokkos::Experimental::SYCL>
-    : public ParallelScanSYCLBase<FunctorType, Traits...> {
+    : public ParallelScanSYCLBase<FunctorType, ReturnType, Traits...> {
  public:
-  using Base = ParallelScanSYCLBase<FunctorType, Traits...>;
+  using Base = ParallelScanSYCLBase<FunctorType, ReturnType, Traits...>;
 
   const Kokkos::Experimental::SYCL& m_exec;
 
@@ -336,7 +381,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     Base::impl_execute([&]() {
       const long long nwork = Base::m_policy.end() - Base::m_policy.begin();
       if (nwork > 0 && !Base::m_result_ptr_device_accessible) {
-        const int size = Base::Analysis::value_size(Base::m_functor);
+        const int size = Base::m_functor_reducer.get_reducer().value_size();
         DeepCopy<HostSpace, Kokkos::Experimental::SYCLDeviceUSMSpace,
                  Kokkos::Experimental::SYCL>(m_exec, Base::m_result_ptr,
                                              Base::m_scratch_space + nwork - 1,
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp b/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp
index 601580b2d8..e46b00f073 100644
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp
@@ -74,13 +74,13 @@ class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
   template <class FunctorType>
   inline int team_size_max(const FunctorType& f,
                            const ParallelReduceTag&) const {
-    return internal_team_size_max_reduce(f);
+    return internal_team_size_max_reduce<void>(f);
   }
 
   template <class FunctorType, class ReducerType>
   inline int team_size_max(const FunctorType& f, const ReducerType& /*r*/,
                            const ParallelReduceTag&) const {
-    return internal_team_size_max_reduce(f);
+    return internal_team_size_max_reduce<typename ReducerType::value_type>(f);
   }
 
   template <typename FunctorType>
@@ -91,13 +91,14 @@ class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
   template <typename FunctorType>
   inline int team_size_recommended(FunctorType const& f,
                                    ParallelReduceTag const&) const {
-    return internal_team_size_recommended_reduce(f);
+    return internal_team_size_recommended_reduce<void>(f);
   }
 
   template <class FunctorType, class ReducerType>
   int team_size_recommended(FunctorType const& f, ReducerType const&,
                             ParallelReduceTag const&) const {
-    return internal_team_size_recommended_reduce(f);
+    return internal_team_size_recommended_reduce<
+        typename ReducerType::value_type>(f);
   }
   inline bool impl_auto_vector_length() const { return m_tune_vector_length; }
   inline bool impl_auto_team_size() const { return m_tune_team_size; }
@@ -303,11 +304,8 @@ class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
         (sizeof(double) + m_thread_scratch_size[0]);
     return std::min({
              int(m_space.impl_internal_space_instance()->m_maxWorkgroupSize),
-      // FIXME_SYCL Avoid requesting to many registers on NVIDIA GPUs.
-#if defined(KOKKOS_ARCH_KEPLER) || defined(KOKKOS_ARCH_MAXWELL) ||  \
-    defined(KOKKOS_ARCH_PASCAL) || defined(KOKKOS_ARCH_VOLTA) ||    \
-    defined(KOKKOS_ARCH_TURING75) || defined(KOKKOS_ARCH_AMPERE) || \
-    defined(KOKKOS_ARCH_HOPPER)
+      // FIXME_SYCL Avoid requesting too many registers on NVIDIA GPUs.
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
                  256,
 #endif
                  max_threads_for_memory
@@ -315,10 +313,11 @@ class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
            impl_vector_length();
   }
 
-  template <class FunctorType>
+  template <class ValueType, class FunctorType>
   int internal_team_size_max_reduce(const FunctorType& f) const {
-    using Analysis        = FunctorAnalysis<FunctorPatternInterface::REDUCE,
-                                     TeamPolicyInternal, FunctorType>;
+    using Analysis =
+        FunctorAnalysis<FunctorPatternInterface::REDUCE, TeamPolicyInternal,
+                        FunctorType, ValueType>;
     using value_type      = typename Analysis::value_type;
     const int value_count = Analysis::value_count(f);
 
@@ -336,11 +335,8 @@ class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
          m_thread_scratch_size[0]);
     return std::min<int>({
              int(m_space.impl_internal_space_instance()->m_maxWorkgroupSize),
-      // FIXME_SYCL Avoid requesting to many registers on NVIDIA GPUs.
-#if defined(KOKKOS_ARCH_KEPLER) || defined(KOKKOS_ARCH_MAXWELL) ||  \
-    defined(KOKKOS_ARCH_PASCAL) || defined(KOKKOS_ARCH_VOLTA) ||    \
-    defined(KOKKOS_ARCH_TURING75) || defined(KOKKOS_ARCH_AMPERE) || \
-    defined(KOKKOS_ARCH_HOPPER)
+      // FIXME_SYCL Avoid requesting too many registers on NVIDIA GPUs.
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
                  256,
 #endif
                  max_threads_for_memory
@@ -354,10 +350,11 @@ class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
     return 1 << Kokkos::Impl::int_log2(internal_team_size_max_for(f));
   }
 
-  template <class FunctorType>
+  template <class ValueType, class FunctorType>
   int internal_team_size_recommended_reduce(const FunctorType& f) const {
     // FIXME_SYCL improve
-    return 1 << Kokkos::Impl::int_log2(internal_team_size_max_reduce(f));
+    return 1 << Kokkos::Impl::int_log2(
+               internal_team_size_max_reduce<ValueType>(f));
   }
 };
 
@@ -386,11 +383,12 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
   // Only let one ParallelFor/Reduce modify the team scratch memory. The
   // constructor acquires the mutex which is released in the destructor.
   std::scoped_lock<std::mutex> m_scratch_lock;
+  int m_scratch_pool_id = -1;
 
   template <typename FunctorWrapper>
   sycl::event sycl_direct_launch(const Policy& policy,
                                  const FunctorWrapper& functor_wrapper,
-                                 const sycl::event& memcpy_events) const {
+                                 const sycl::event& memcpy_event) const {
     // Convenience references
     const Kokkos::Experimental::SYCL& space = policy.space();
     sycl::queue& q                          = space.sycl_queue();
@@ -398,12 +396,10 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
     auto parallel_for_event = q.submit([&](sycl::handler& cgh) {
       // FIXME_SYCL accessors seem to need a size greater than zero at least for
       // host queues
-      sycl::accessor<char, 1, sycl::access::mode::read_write,
-                     sycl::access::target::local>
-          team_scratch_memory_L0(
-              sycl::range<1>(
-                  std::max(m_scratch_size[0] + m_shmem_begin, size_t(1))),
-              cgh);
+      sycl::local_accessor<char, 1> team_scratch_memory_L0(
+          sycl::range<1>(
+              std::max(m_scratch_size[0] + m_shmem_begin, size_t(1))),
+          cgh);
 
       // Avoid capturing *this since it might not be trivially copyable
       const auto shmem_begin       = m_shmem_begin;
@@ -432,14 +428,13 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
       auto max_sg_size =
           kernel
               .get_info<sycl::info::kernel_device_specific::max_sub_group_size>(
-                  q.get_device(),
-                  sycl::range<3>(m_team_size, m_vector_size, 1));
+                  q.get_device());
       auto final_vector_size = std::min<int>(m_vector_size, max_sg_size);
       // FIXME_SYCL For some reason, explicitly enforcing the kernel bundle to
       // be used gives a runtime error.
       // cgh.use_kernel_bundle(kernel_bundle);
 
-      cgh.depends_on(memcpy_events);
+      cgh.depends_on(memcpy_event);
       cgh.parallel_for(
           sycl::nd_range<2>(
               sycl::range<2>(m_team_size, m_league_size * final_vector_size),
@@ -454,10 +449,9 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
   inline void execute() const {
     if (m_league_size == 0) return;
 
+    auto& space = *m_policy.space().impl_internal_space_instance();
     Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem&
-        indirectKernelMem = m_policy.space()
-                                .impl_internal_space_instance()
-                                ->get_indirect_kernel_mem();
+        indirectKernelMem = space.get_indirect_kernel_mem();
 
     auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
         m_functor, indirectKernelMem);
@@ -465,6 +459,7 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
     sycl::event event = sycl_direct_launch(m_policy, functor_wrapper,
                                            functor_wrapper.get_copy_event());
     functor_wrapper.register_event(event);
+    space.register_team_scratch_event(m_scratch_pool_id, event);
   }
 
   ParallelFor(FunctorType const& arg_functor, Policy const& arg_policy)
@@ -490,9 +485,11 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
     // Functor's reduce memory, team scan memory, and team shared memory depend
     // upon team size.
-    auto& space = *m_policy.space().impl_internal_space_instance();
+    auto& space       = *m_policy.space().impl_internal_space_instance();
+    m_scratch_pool_id = space.acquire_team_scratch_space();
     m_global_scratch_ptr =
         static_cast<sycl::device_ptr<char>>(space.resize_team_scratch_space(
+            m_scratch_pool_id,
             static_cast<ptrdiff_t>(m_scratch_size[1]) * m_league_size));
 
     if (static_cast<int>(space.m_maxShmemPerBlock) <
@@ -518,35 +515,31 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::Experimental::SYCL> {
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>,
+                     Kokkos::Experimental::SYCL> {
  public:
   using Policy = TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
  private:
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
   using member_type   = typename Policy::member_type;
   using WorkTag       = typename Policy::work_tag;
   using launch_bounds = typename Policy::launch_bounds;
 
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-  using value_type     = typename Analysis::value_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+  using value_type     = typename ReducerType::value_type;
 
  public:
   using functor_type = FunctorType;
   using size_type    = Kokkos::Experimental::SYCL::size_type;
 
  private:
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
   size_type m_shmem_begin;
@@ -559,13 +552,13 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   // Only let one ParallelFor/Reduce modify the team scratch memory. The
   // constructor acquires the mutex which is released in the destructor.
   std::scoped_lock<std::mutex> m_scratch_lock;
+  int m_scratch_pool_id = -1;
 
-  template <typename PolicyType, typename FunctorWrapper,
-            typename ReducerWrapper>
+  template <typename PolicyType, typename CombinedFunctorReducerWrapper>
   sycl::event sycl_direct_launch(
-      const PolicyType& policy, const FunctorWrapper& functor_wrapper,
-      const ReducerWrapper& reducer_wrapper,
-      const std::vector<sycl::event>& memcpy_events) const {
+      const PolicyType& policy,
+      const CombinedFunctorReducerWrapper& functor_reducer_wrapper,
+      const sycl::event& memcpy_event) const {
     // Convenience references
     const Kokkos::Experimental::SYCL& space = policy.space();
     Kokkos::Experimental::Impl::SYCLInternal& instance =
@@ -573,7 +566,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     sycl::queue& q = space.sycl_queue();
 
     const unsigned int value_count =
-        Analysis::value_count(ReducerConditional::select(m_functor, m_reducer));
+        m_functor_reducer.get_reducer().value_count();
     std::size_t size = std::size_t(m_league_size) * m_team_size * m_vector_size;
     value_type* results_ptr = nullptr;
 
@@ -592,43 +585,38 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
       auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
         // FIXME_SYCL accessors seem to need a size greater than zero at least
         // for host queues
-        sycl::accessor<char, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            team_scratch_memory_L0(
-                sycl::range<1>(
-                    std::max(m_scratch_size[0] + m_shmem_begin, size_t(1))),
-                cgh);
+        sycl::local_accessor<char, 1> team_scratch_memory_L0(
+            sycl::range<1>(
+                std::max(m_scratch_size[0] + m_shmem_begin, size_t(1))),
+            cgh);
 
         // Avoid capturing *this since it might not be trivially copyable
         const auto shmem_begin       = m_shmem_begin;
         const size_t scratch_size[2] = {m_scratch_size[0], m_scratch_size[1]};
         sycl::device_ptr<char> const global_scratch_ptr = m_global_scratch_ptr;
 
-        cgh.depends_on(memcpy_events);
+        cgh.depends_on(memcpy_event);
         cgh.parallel_for(
             sycl::nd_range<2>(sycl::range<2>(1, 1), sycl::range<2>(1, 1)),
             [=](sycl::nd_item<2> item) {
-              const auto& functor          = functor_wrapper.get_functor();
-              const auto& selected_reducer = ReducerConditional::select(
-                  static_cast<const FunctorType&>(functor),
-                  static_cast<const ReducerType&>(
-                      reducer_wrapper.get_functor()));
-              typename Analysis::Reducer final_reducer(&selected_reducer);
-
-              reference_type update = final_reducer.init(results_ptr);
+              const CombinedFunctorReducerType& functor_reducer =
+                  functor_reducer_wrapper.get_functor();
+              const FunctorType& functor = functor_reducer.get_functor();
+              const ReducerType& reducer = functor_reducer.get_reducer();
+
+              reference_type update = reducer.init(results_ptr);
               if (size == 1) {
                 const member_type team_member(
                     team_scratch_memory_L0.get_pointer(), shmem_begin,
                     scratch_size[0], global_scratch_ptr, scratch_size[1], item);
-                if constexpr (std::is_void<WorkTag>::value)
+                if constexpr (std::is_void_v<WorkTag>)
                   functor(team_member, update);
                 else
                   functor(WorkTag(), team_member, update);
               }
-              final_reducer.final(results_ptr);
+              reducer.final(results_ptr);
               if (device_accessible_result_ptr)
-                final_reducer.copy(device_accessible_result_ptr,
-                                   &results_ptr[0]);
+                reducer.copy(device_accessible_result_ptr, &results_ptr[0]);
             });
       });
       q.ext_oneapi_submit_barrier(
@@ -645,12 +633,10 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
         // FIXME_SYCL accessors seem to need a size greater than zero at least
         // for host queues
-        sycl::accessor<char, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            team_scratch_memory_L0(
-                sycl::range<1>(
-                    std::max(m_scratch_size[0] + m_shmem_begin, size_t(1))),
-                cgh);
+        sycl::local_accessor<char, 1> team_scratch_memory_L0(
+            sycl::range<1>(
+                std::max(m_scratch_size[0] + m_shmem_begin, size_t(1))),
+            cgh);
 
         // Avoid capturing *this since it might not be trivially copyable
         const auto shmem_begin       = m_shmem_begin;
@@ -658,9 +644,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         sycl::device_ptr<char> const global_scratch_ptr = m_global_scratch_ptr;
 
         auto team_reduction_factory =
-            [&](sycl::accessor<value_type, 1, sycl::access::mode::read_write,
-                               sycl::access::target::local>
-                    local_mem,
+            [&](sycl::local_accessor<value_type, 1> local_mem,
                 sycl::device_ptr<value_type> results_ptr) {
               sycl::global_ptr<value_type> device_accessible_result_ptr =
                   m_result_ptr_device_accessible ? m_result_ptr : nullptr;
@@ -673,32 +657,29 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
                 auto& num_teams_done = reinterpret_cast<unsigned int&>(
                     local_mem[wgroup_size * std::max(value_count, 1u)]);
-                const auto local_id          = item.get_local_linear_id();
-                const auto& functor          = functor_wrapper.get_functor();
-                const auto& selected_reducer = ReducerConditional::select(
-                    static_cast<const FunctorType&>(functor),
-                    static_cast<const ReducerType&>(
-                        reducer_wrapper.get_functor()));
-                typename Analysis::Reducer final_reducer(&selected_reducer);
-
-                if constexpr (Analysis::StaticValueSize == 0) {
+                const auto local_id = item.get_local_linear_id();
+                const CombinedFunctorReducerType& functor_reducer =
+                    functor_reducer_wrapper.get_functor();
+                const FunctorType& functor = functor_reducer.get_functor();
+                const ReducerType& reducer = functor_reducer.get_reducer();
+
+                if constexpr (ReducerType::static_value_size() == 0) {
                   reference_type update =
-                      final_reducer.init(&local_mem[local_id * value_count]);
+                      reducer.init(&local_mem[local_id * value_count]);
                   const member_type team_member(
                       team_scratch_memory_L0.get_pointer(), shmem_begin,
                       scratch_size[0],
                       global_scratch_ptr + item.get_group(1) * scratch_size[1],
                       scratch_size[1], item);
-                  if constexpr (std::is_void<WorkTag>::value)
+                  if constexpr (std::is_void_v<WorkTag>)
                     functor(team_member, update);
                   else
                     functor(WorkTag(), team_member, update);
                   item.barrier(sycl::access::fence_space::local_space);
 
                   SYCLReduction::workgroup_reduction<>(
-                      item, local_mem.get_pointer(), results_ptr,
-                      device_accessible_result_ptr, value_count,
-                      selected_reducer, false,
+                      item, local_mem, results_ptr,
+                      device_accessible_result_ptr, value_count, reducer, false,
                       std::min<std::size_t>(size,
                                             item.get_local_range()[0] *
                                                 item.get_local_range()[1]));
@@ -713,40 +694,40 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                   sycl::group_barrier(item.get_group());
                   if (num_teams_done == n_wgroups) {
                     if (local_id >= n_wgroups)
-                      final_reducer.init(&local_mem[local_id * value_count]);
+                      reducer.init(&local_mem[local_id * value_count]);
                     else {
-                      final_reducer.copy(&local_mem[local_id * value_count],
-                                         &results_ptr[local_id * value_count]);
+                      reducer.copy(&local_mem[local_id * value_count],
+                                   &results_ptr[local_id * value_count]);
                       for (unsigned int id = local_id + wgroup_size;
                            id < n_wgroups; id += wgroup_size) {
-                        final_reducer.join(&local_mem[local_id * value_count],
-                                           &results_ptr[id * value_count]);
+                        reducer.join(&local_mem[local_id * value_count],
+                                     &results_ptr[id * value_count]);
                       }
                     }
 
                     SYCLReduction::workgroup_reduction<>(
-                        item, local_mem.get_pointer(), results_ptr,
-                        device_accessible_result_ptr, value_count,
-                        selected_reducer, true,
+                        item, local_mem, results_ptr,
+                        device_accessible_result_ptr, value_count, reducer,
+                        true,
                         std::min(n_wgroups, item.get_local_range()[0] *
                                                 item.get_local_range()[1]));
                   }
                 } else {
                   value_type local_value;
-                  reference_type update = final_reducer.init(&local_value);
+                  reference_type update = reducer.init(&local_value);
                   const member_type team_member(
                       team_scratch_memory_L0.get_pointer(), shmem_begin,
                       scratch_size[0],
                       global_scratch_ptr + item.get_group(1) * scratch_size[1],
                       scratch_size[1], item);
-                  if constexpr (std::is_void<WorkTag>::value)
+                  if constexpr (std::is_void_v<WorkTag>)
                     functor(team_member, update);
                   else
                     functor(WorkTag(), team_member, update);
 
                   SYCLReduction::workgroup_reduction<>(
-                      item, local_mem.get_pointer(), local_value, results_ptr,
-                      device_accessible_result_ptr, final_reducer, false,
+                      item, local_mem, local_value, results_ptr,
+                      device_accessible_result_ptr, reducer, false,
                       std::min<std::size_t>(size,
                                             item.get_local_range()[0] *
                                                 item.get_local_range()[1]));
@@ -761,18 +742,18 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                   item.barrier(sycl::access::fence_space::local_space);
                   if (num_teams_done == n_wgroups) {
                     if (local_id >= n_wgroups)
-                      final_reducer.init(&local_value);
+                      reducer.init(&local_value);
                     else {
                       local_value = results_ptr[local_id];
                       for (unsigned int id = local_id + wgroup_size;
                            id < n_wgroups; id += wgroup_size) {
-                        final_reducer.join(&local_value, &results_ptr[id]);
+                        reducer.join(&local_value, &results_ptr[id]);
                       }
                     }
 
                     SYCLReduction::workgroup_reduction<>(
-                        item, local_mem.get_pointer(), local_value, results_ptr,
-                        device_accessible_result_ptr, final_reducer, true,
+                        item, local_mem, local_value, results_ptr,
+                        device_accessible_result_ptr, reducer, true,
                         std::min(n_wgroups, item.get_local_range()[0] *
                                                 item.get_local_range()[1]));
                   }
@@ -793,7 +774,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         }();
         auto max_sg_size = kernel.get_info<
             sycl::info::kernel_device_specific::max_sub_group_size>(
-            q.get_device(), sycl::range<3>(m_team_size, m_vector_size, 1));
+            q.get_device());
         auto final_vector_size = std::min<int>(m_vector_size, max_sg_size);
         // FIXME_SYCL For some reason, explicitly enforcing the kernel bundle to
         // be used gives a runtime error.
@@ -802,12 +783,11 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
         auto wgroup_size = m_team_size * final_vector_size;
         std::size_t size = std::size_t(m_league_size) * wgroup_size;
-        sycl::accessor<value_type, 1, sycl::access::mode::read_write,
-                       sycl::access::target::local>
-            local_mem(sycl::range<1>(wgroup_size) * std::max(value_count, 1u) +
-                          (sizeof(unsigned int) + sizeof(value_type) - 1) /
-                              sizeof(value_type),
-                      cgh);
+        sycl::local_accessor<value_type, 1> local_mem(
+            sycl::range<1>(wgroup_size) * std::max(value_count, 1u) +
+                (sizeof(unsigned int) + sizeof(value_type) - 1) /
+                    sizeof(value_type),
+            cgh);
 
         const auto init_size =
             std::max<std::size_t>((size + wgroup_size - 1) / wgroup_size, 1);
@@ -817,7 +797,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
         auto reduction_lambda = team_reduction_factory(local_mem, results_ptr);
 
-        cgh.depends_on(memcpy_events);
+        cgh.depends_on(memcpy_event);
 
         cgh.parallel_for(
             sycl::nd_range<2>(
@@ -848,27 +828,26 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         *m_policy.space().impl_internal_space_instance();
     using IndirectKernelMem =
         Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
-    IndirectKernelMem& indirectKernelMem  = instance.get_indirect_kernel_mem();
-    IndirectKernelMem& indirectReducerMem = instance.get_indirect_kernel_mem();
+    IndirectKernelMem& indirectKernelMem = instance.get_indirect_kernel_mem();
 
-    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_functor, indirectKernelMem);
-    auto reducer_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_reducer, indirectReducerMem);
+    auto functor_reducer_wrapper =
+        Experimental::Impl::make_sycl_function_wrapper(m_functor_reducer,
+                                                       indirectKernelMem);
 
-    sycl::event event = sycl_direct_launch(
-        m_policy, functor_wrapper, reducer_wrapper,
-        {functor_wrapper.get_copy_event(), reducer_wrapper.get_copy_event()});
-    functor_wrapper.register_event(event);
-    reducer_wrapper.register_event(event);
+    sycl::event event =
+        sycl_direct_launch(m_policy, functor_reducer_wrapper,
+                           functor_reducer_wrapper.get_copy_event());
+    functor_reducer_wrapper.register_event(event);
+    instance.register_team_scratch_event(m_scratch_pool_id, event);
   }
 
  private:
   void initialize() {
     // FIXME_SYCL optimize
     if (m_team_size < 0)
-      m_team_size =
-          m_policy.team_size_recommended(m_functor, ParallelReduceTag{});
+      m_team_size = m_policy.team_size_recommended(
+          m_functor_reducer.get_functor(), m_functor_reducer.get_reducer(),
+          ParallelReduceTag{});
     // Must be a power of two greater than two, get the one not bigger than the
     // requested one.
     if ((m_team_size & m_team_size - 1) || m_team_size < 2) {
@@ -877,18 +856,20 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
       m_team_size = temp_team_size;
     }
 
-    m_shmem_begin = (sizeof(double) * (m_team_size + 2));
-    m_shmem_size =
-        (m_policy.scratch_size(0, m_team_size) +
-         FunctorTeamShmemSize<FunctorType>::value(m_functor, m_team_size));
+    m_shmem_begin     = (sizeof(double) * (m_team_size + 2));
+    m_shmem_size      = (m_policy.scratch_size(0, m_team_size) +
+                    FunctorTeamShmemSize<FunctorType>::value(
+                        m_functor_reducer.get_functor(), m_team_size));
     m_scratch_size[0] = m_shmem_size;
     m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
 
     // Functor's reduce memory, team scan memory, and team shared memory depend
     // upon team size.
-    auto& space = *m_policy.space().impl_internal_space_instance();
+    auto& space       = *m_policy.space().impl_internal_space_instance();
+    m_scratch_pool_id = space.acquire_team_scratch_space();
     m_global_scratch_ptr =
         static_cast<sycl::device_ptr<char>>(space.resize_team_scratch_space(
+            m_scratch_pool_id,
             static_cast<ptrdiff_t>(m_scratch_size[1]) * m_league_size));
 
     if (static_cast<int>(space.m_maxShmemPerBlock) <
@@ -901,20 +882,19 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
       Kokkos::Impl::throw_runtime_exception(out.str());
     }
 
-    if (m_team_size > m_policy.team_size_max(m_functor, ParallelReduceTag{}))
+    if (m_team_size > m_policy.team_size_max(m_functor_reducer.get_functor(),
+                                             m_functor_reducer.get_reducer(),
+                                             ParallelReduceTag{}))
       Kokkos::Impl::throw_runtime_exception(
           "Kokkos::Impl::ParallelFor<SYCL> requested too large team size.");
   }
 
  public:
   template <class ViewType>
-  ParallelReduce(
-      FunctorType const& arg_functor, Policy const& arg_policy,
-      ViewType const& arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value, void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(CombinedFunctorReducerType const& arg_functor_reducer,
+                 Policy const& arg_policy, ViewType const& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_result_ptr_device_accessible(
             MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
@@ -927,25 +907,6 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
                            ->m_team_scratch_mutex) {
     initialize();
   }
-
-  ParallelReduce(FunctorType const& arg_functor, Policy const& arg_policy,
-                 ReducerType const& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                              typename ReducerType::result_view_type::
-                                  memory_space>::accessible),
-        m_league_size(arg_policy.league_size()),
-        m_team_size(arg_policy.team_size()),
-        m_vector_size(arg_policy.impl_vector_length()),
-        m_scratch_lock(arg_policy.space()
-                           .impl_internal_space_instance()
-                           ->m_team_scratch_mutex) {
-    initialize();
-  }
 };
 }  // namespace Impl
 }  // namespace Kokkos
diff --git a/core/src/SYCL/Kokkos_SYCL_Space.cpp b/core/src/SYCL/Kokkos_SYCL_Space.cpp
index 6151b3eaaf..62af720b7c 100644
--- a/core/src/SYCL/Kokkos_SYCL_Space.cpp
+++ b/core/src/SYCL/Kokkos_SYCL_Space.cpp
@@ -21,8 +21,8 @@
 #include <Kokkos_Macros.hpp>
 
 #include <Kokkos_HostSpace.hpp>
-#include <Kokkos_SYCL.hpp>
-#include <Kokkos_SYCL_Space.hpp>
+#include <SYCL/Kokkos_SYCL.hpp>
+#include <SYCL/Kokkos_SYCL_Space.hpp>
 #include <SYCL/Kokkos_SYCL_DeepCopy.hpp>
 #include <SYCL/Kokkos_SYCL_Instance.hpp>
 #include <impl/Kokkos_MemorySpace.hpp>
@@ -39,12 +39,8 @@ void DeepCopySYCL(void* dst, const void* src, size_t n) {
 
 void DeepCopyAsyncSYCL(const Kokkos::Experimental::SYCL& instance, void* dst,
                        const void* src, size_t n) {
-  // FIXME_SYCL memcpy doesn't respect submit_barrier which means that we need
-  // to actually fence the execution space to make sure the memcpy is properly
-  // enqueued when using out-of-order queues.
   sycl::queue& q = *instance.impl_internal_space_instance()->m_queue;
-  q.wait_and_throw();
-  auto event = q.memcpy(dst, src, n);
+  auto event     = q.memcpy(dst, src, n);
   q.ext_oneapi_submit_barrier(std::vector<sycl::event>{event});
 }
 
diff --git a/core/src/Kokkos_SYCL_Space.hpp b/core/src/SYCL/Kokkos_SYCL_Space.hpp
similarity index 100%
rename from core/src/Kokkos_SYCL_Space.hpp
rename to core/src/SYCL/Kokkos_SYCL_Space.hpp
diff --git a/core/src/SYCL/Kokkos_SYCL_Team.hpp b/core/src/SYCL/Kokkos_SYCL_Team.hpp
index b01d06b928..797f3c752f 100644
--- a/core/src/SYCL/Kokkos_SYCL_Team.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Team.hpp
@@ -337,10 +337,11 @@ class SYCLTeamMember {
   // Private for the driver
 
   KOKKOS_INLINE_FUNCTION
-  SYCLTeamMember(sycl::local_ptr<void> shared, const int shared_begin,
-                 const int shared_size,
+  SYCLTeamMember(sycl::local_ptr<void> shared, const std::size_t shared_begin,
+                 const std::size_t shared_size,
                  sycl::device_ptr<void> scratch_level_1_ptr,
-                 const int scratch_level_1_size, const sycl::nd_item<2> item)
+                 const std::size_t scratch_level_1_size,
+                 const sycl::nd_item<2> item)
       : m_team_reduce(shared),
         m_team_shared(static_cast<sycl::local_ptr<char>>(shared) + shared_begin,
                       shared_size, scratch_level_1_ptr, scratch_level_1_size),
@@ -578,8 +579,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     const FunctorType& lambda) {
   // Extract value_type from lambda
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void,
-      FunctorType>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
 
   const auto start     = loop_bounds.start;
   const auto end       = loop_bounds.end;
@@ -774,7 +775,8 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
                   iType, Impl::SYCLTeamMember>& loop_boundaries,
               const Closure& closure, const ReducerType& reducer) {
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
 
   value_type accum;
   reducer.init(accum);
@@ -843,7 +845,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
         loop_boundaries,
     const Closure& closure) {
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
   value_type dummy;
   parallel_scan(loop_boundaries, closure, Kokkos::Sum<value_type>{dummy});
 }
diff --git a/core/src/SYCL/Kokkos_SYCL_UniqueToken.hpp b/core/src/SYCL/Kokkos_SYCL_UniqueToken.hpp
index 2f0a67b3dd..d55fc6a84b 100644
--- a/core/src/SYCL/Kokkos_SYCL_UniqueToken.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_UniqueToken.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_SYCL_UNIQUE_TOKEN_HPP
 
 #include <impl/Kokkos_ConcurrentBitset.hpp>
-#include <Kokkos_SYCL_Space.hpp>
+#include <SYCL/Kokkos_SYCL_Space.hpp>
 #include <Kokkos_UniqueToken.hpp>
 
 namespace Kokkos {
@@ -93,12 +93,8 @@ class UniqueToken<SYCL, UniqueTokenScope::Global> {
     }
 
     // Make sure that all writes in the previous lock owner are visible to me
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
     desul::atomic_thread_fence(desul::MemoryOrderAcquire(),
                                desul::MemoryScopeDevice());
-#else
-    Kokkos::memory_fence();
-#endif
     return idx;
   }
 
@@ -114,12 +110,8 @@ class UniqueToken<SYCL, UniqueTokenScope::Global> {
   KOKKOS_INLINE_FUNCTION
   void release(size_type idx) const noexcept {
     // Make sure my writes are visible to the next lock owner
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
     desul::atomic_thread_fence(desul::MemoryOrderRelease(),
                                desul::MemoryScopeDevice());
-#else
-    Kokkos::memory_fence();
-#endif
     (void)Kokkos::atomic_exchange(&m_locks(idx), 0);
   }
 };
diff --git a/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp b/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp
new file mode 100644
index 0000000000..883c323f2f
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp
@@ -0,0 +1,47 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_SYCL_ZEROMEMSET_HPP
+#define KOKKOS_SYCL_ZEROMEMSET_HPP
+
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
+#include <SYCL/Kokkos_SYCL.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class T, class... P>
+struct ZeroMemset<Kokkos::Experimental::SYCL, View<T, P...>> {
+  ZeroMemset(const Kokkos::Experimental::SYCL& exec_space,
+             const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    auto event = exec_space.impl_internal_space_instance()->m_queue->memset(
+        dst.data(), 0, dst.size() * sizeof(typename View<T, P...>::value_type));
+    exec_space.impl_internal_space_instance()
+        ->m_queue->ext_oneapi_submit_barrier(std::vector<sycl::event>{event});
+  }
+
+  ZeroMemset(const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    Experimental::Impl::SYCLInternal::singleton().m_queue->memset(
+        dst.data(), 0, dst.size() * sizeof(typename View<T, P...>::value_type));
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // !defined(KOKKOS_SYCL_ZEROMEMSET_HPP)
diff --git a/core/src/Serial/Kokkos_Serial.cpp b/core/src/Serial/Kokkos_Serial.cpp
index df91d8499a..6d55dffb7c 100644
--- a/core/src/Serial/Kokkos_Serial.cpp
+++ b/core/src/Serial/Kokkos_Serial.cpp
@@ -20,7 +20,7 @@
 
 #include <Kokkos_Core.hpp>
 
-#include <Kokkos_Serial.hpp>
+#include <Serial/Kokkos_Serial.hpp>
 #include <impl/Kokkos_Traits.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_ExecSpaceManager.hpp>
@@ -42,9 +42,6 @@ void SerialInternal::initialize() {
 
   Impl::SharedAllocationRecord<void, void>::tracking_enable();
 
-  // Init the array of locks used for arbitrarily sized atomics
-  Impl::init_lock_array_host_space();
-
   m_is_initialized = true;
 }
 
@@ -152,12 +149,8 @@ void Serial::print_configuration(std::ostream& os, bool /*verbose*/) const {
   os << "Host Serial Execution Space:\n";
   os << "  KOKKOS_ENABLE_SERIAL: yes\n";
 
-  os << "Serial Atomics:\n";
-  os << "  KOKKOS_ENABLE_SERIAL_ATOMICS: ";
-#ifdef KOKKOS_ENABLE_SERIAL_ATOMICS
-  os << "yes\n";
-#else
-  os << "no\n";
+#ifdef KOKKOS_INTERNAL_NOT_PARALLEL
+  os << "Kokkos atomics disabled\n";
 #endif
 
   os << "\nSerial Runtime Configuration:\n";
diff --git a/core/src/Kokkos_Serial.hpp b/core/src/Serial/Kokkos_Serial.hpp
similarity index 91%
rename from core/src/Kokkos_Serial.hpp
rename to core/src/Serial/Kokkos_Serial.hpp
index ede3c96b8b..2ade37705e 100644
--- a/core/src/Kokkos_Serial.hpp
+++ b/core/src/Serial/Kokkos_Serial.hpp
@@ -207,23 +207,6 @@ struct DeviceTypeTraits<Serial> {
 namespace Kokkos {
 namespace Impl {
 
-// We only need to provide a specialization for Serial if there is a host
-// parallel execution space since the specialization for
-// DefaultHostExecutionSpace is defined elsewhere.
-struct DummyExecutionSpace;
-template <class DT, class... DP>
-struct ZeroMemset<
-    std::conditional_t<!std::is_same<Serial, DefaultHostExecutionSpace>::value,
-                       Serial, DummyExecutionSpace>,
-    DT, DP...> : public ZeroMemset<DefaultHostExecutionSpace, DT, DP...> {
-  using Base = ZeroMemset<DefaultHostExecutionSpace, DT, DP...>;
-  using Base::Base;
-
-  ZeroMemset(const Serial&, const View<DT, DP...>& dst,
-             typename View<DT, DP...>::const_value_type& value)
-      : Base(dst, value) {}
-};
-
 template <>
 struct MemorySpaceAccess<Kokkos::Serial::memory_space,
                          Kokkos::Serial::scratch_memory_space> {
diff --git a/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp b/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp
index afdecd2f05..69787aa500 100644
--- a/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp
+++ b/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp
@@ -58,35 +58,24 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
       : m_iter(arg_policy, arg_functor) {}
 };
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
-                     Kokkos::Serial> {
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>, Kokkos::Serial> {
  private:
   using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
   using Policy        = typename MDRangePolicy::impl_range_policy;
+  using FunctorType   = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType   = typename CombinedFunctorReducerType::reducer_type;
 
   using WorkTag = typename MDRangePolicy::work_tag;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  using Analysis = FunctorAnalysis<FunctorPatternInterface::REDUCE,
-                                   MDRangePolicy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
-
-  using iterate_type =
-      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
-                                             WorkTag, reference_type>;
+  using iterate_type = typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, CombinedFunctorReducerType, WorkTag, reference_type>;
   const iterate_type m_iter;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
 
   inline void exec(reference_type update) const {
@@ -107,8 +96,8 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     return 1024;
   }
   inline void execute() const {
-    const size_t pool_reduce_size = Analysis::value_size(
-        ReducerConditional::select(m_iter.m_func, m_reducer));
+    const ReducerType& reducer     = m_iter.m_func.get_reducer();
+    const size_t pool_reduce_size  = reducer.value_size();
     const size_t team_reduce_size  = 0;  // Never shrinks
     const size_t team_shared_size  = 0;  // Never shrinks
     const size_t thread_local_size = 0;  // Never shrinks
@@ -128,44 +117,27 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
             : pointer_type(
                   internal_instance->m_thread_team_data.pool_reduce_local());
 
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_iter.m_func, m_reducer));
-
-    reference_type update = final_reducer.init(ptr);
+    reference_type update = reducer.init(ptr);
 
     this->exec(update);
 
-    final_reducer.final(ptr);
+    reducer.final(ptr);
   }
 
-  template <class HostViewType>
-  ParallelReduce(const FunctorType& arg_functor,
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
                  const MDRangePolicy& arg_policy,
-                 const HostViewType& arg_result_view,
-                 std::enable_if_t<Kokkos::is_view<HostViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void*> = nullptr)
-      : m_iter(arg_policy, arg_functor),
-        m_reducer(InvalidType()),
+                 const ViewType& arg_result_view)
+      : m_iter(arg_policy, arg_functor_reducer),
         m_result_ptr(arg_result_view.data()) {
-    static_assert(Kokkos::is_view<HostViewType>::value,
+    static_assert(Kokkos::is_view<ViewType>::value,
                   "Kokkos::Serial reduce result must be a View");
 
     static_assert(
-        Kokkos::Impl::MemorySpaceAccess<typename HostViewType::memory_space,
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
                                         Kokkos::HostSpace>::accessible,
-        "Kokkos::Serial reduce result must be a View in HostSpace");
-  }
-
-  inline ParallelReduce(const FunctorType& arg_functor,
-                        MDRangePolicy arg_policy, const ReducerType& reducer)
-      : m_iter(arg_policy, arg_functor),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
+        "Kokkos::Serial reduce result must be a View accessible from "
+        "HostSpace");
   }
 };
 
diff --git a/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp b/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp
index f35c13170b..56894716db 100644
--- a/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp
+++ b/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp
@@ -58,31 +58,20 @@ class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Serial> {
 
 /*--------------------------------------------------------------------------*/
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
                      Kokkos::Serial> {
  private:
-  using Policy  = Kokkos::RangePolicy<Traits...>;
-  using WorkTag = typename Policy::work_tag;
-
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
-
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using WorkTag     = typename Policy::work_tag;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
 
   template <class TagType>
@@ -90,7 +79,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
       reference_type update) const {
     const typename Policy::member_type e = m_policy.end();
     for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
-      m_functor(i, update);
+      m_functor_reducer.get_functor()(i, update);
     }
   }
 
@@ -101,14 +90,14 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
 
     const typename Policy::member_type e = m_policy.end();
     for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
-      m_functor(t, i, update);
+      m_functor_reducer.get_functor()(t, i, update);
     }
   }
 
  public:
   inline void execute() const {
     const size_t pool_reduce_size =
-        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
+        m_functor_reducer.get_reducer().value_size();
     const size_t team_reduce_size  = 0;  // Never shrinks
     const size_t team_shared_size  = 0;  // Never shrinks
     const size_t thread_local_size = 0;  // Never shrinks
@@ -127,45 +116,27 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
             : pointer_type(
                   internal_instance->m_thread_team_data.pool_reduce_local());
 
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
-    reference_type update = final_reducer.init(ptr);
+    reference_type update = m_functor_reducer.get_reducer().init(ptr);
 
     this->template exec<WorkTag>(update);
 
-    final_reducer.final(ptr);
+    m_functor_reducer.get_reducer().final(ptr);
   }
 
-  template <class HostViewType>
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const HostViewType& arg_result_view,
-                 std::enable_if_t<Kokkos::is_view<HostViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void*> = nullptr)
-      : m_functor(arg_functor),
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result_view)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result_view.data()) {
-    static_assert(Kokkos::is_view<HostViewType>::value,
+    static_assert(Kokkos::is_view<ViewType>::value,
                   "Kokkos::Serial reduce result must be a View");
 
     static_assert(
-        Kokkos::Impl::MemorySpaceAccess<typename HostViewType::memory_space,
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
                                         Kokkos::HostSpace>::accessible,
-        "Kokkos::Serial reduce result must be a View in HostSpace");
-  }
-
-  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
-                        const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
+        "Kokkos::Serial reduce result must be a View accessible from "
+        "HostSpace");
   }
 };
 
@@ -179,12 +150,13 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
   using WorkTag = typename Policy::work_tag;
 
   using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
+      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType, void>;
 
   using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
   const Policy m_policy;
 
   template <class TagType>
@@ -192,7 +164,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
       reference_type update) const {
     const typename Policy::member_type e = m_policy.end();
     for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
-      m_functor(i, update, true);
+      m_functor_reducer.get_functor()(i, update, true);
     }
   }
 
@@ -202,13 +174,15 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
     const TagType t{};
     const typename Policy::member_type e = m_policy.end();
     for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
-      m_functor(t, i, update, true);
+      m_functor_reducer.get_functor()(t, i, update, true);
     }
   }
 
  public:
   inline void execute() const {
-    const size_t pool_reduce_size  = Analysis::value_size(m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
+    const size_t pool_reduce_size  = final_reducer.value_size();
     const size_t team_reduce_size  = 0;  // Never shrinks
     const size_t team_shared_size  = 0;  // Never shrinks
     const size_t thread_local_size = 0;  // Never shrinks
@@ -221,8 +195,6 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
 
-    typename Analysis::Reducer final_reducer(&m_functor);
-
     reference_type update = final_reducer.init(pointer_type(
         internal_instance->m_thread_team_data.pool_reduce_local()));
 
@@ -230,7 +202,8 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
   }
 
   inline ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
+        m_policy(arg_policy) {}
 };
 
 /*--------------------------------------------------------------------------*/
@@ -241,14 +214,15 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   using Policy  = Kokkos::RangePolicy<Traits...>;
   using WorkTag = typename Policy::work_tag;
 
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType>;
+  using Analysis = FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                   FunctorType, ReturnType>;
 
   using value_type     = typename Analysis::value_type;
   using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>
+      m_functor_reducer;
   const Policy m_policy;
   const pointer_type m_result_ptr;
 
@@ -257,7 +231,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
       reference_type update) const {
     const typename Policy::member_type e = m_policy.end();
     for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
-      m_functor(i, update, true);
+      m_functor_reducer.get_functor()(i, update, true);
     }
   }
 
@@ -267,13 +241,14 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     const TagType t{};
     const typename Policy::member_type e = m_policy.end();
     for (typename Policy::member_type i = m_policy.begin(); i < e; ++i) {
-      m_functor(t, i, update, true);
+      m_functor_reducer.get_functor()(t, i, update, true);
     }
   }
 
  public:
   inline void execute() {
-    const size_t pool_reduce_size  = Analysis::value_size(m_functor);
+    const size_t pool_reduce_size =
+        m_functor_reducer.get_reducer().value_size();
     const size_t team_reduce_size  = 0;  // Never shrinks
     const size_t team_shared_size  = 0;  // Never shrinks
     const size_t thread_local_size = 0;  // Never shrinks
@@ -286,7 +261,8 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
 
-    typename Analysis::Reducer final_reducer(&m_functor);
+    const typename Analysis::Reducer& final_reducer =
+        m_functor_reducer.get_reducer();
 
     reference_type update = final_reducer.init(pointer_type(
         internal_instance->m_thread_team_data.pool_reduce_local()));
@@ -301,7 +277,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   ParallelScanWithTotal(const FunctorType& arg_functor,
                         const Policy& arg_policy,
                         const ViewType& arg_result_view)
-      : m_functor(arg_functor),
+      : m_functor_reducer(arg_functor, typename Analysis::Reducer{arg_functor}),
         m_policy(arg_policy),
         m_result_ptr(arg_result_view.data()) {
     static_assert(
diff --git a/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp b/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp
index c5156f1f7f..0876f1af22 100644
--- a/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp
+++ b/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp
@@ -268,35 +268,25 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
 
 /*--------------------------------------------------------------------------*/
 
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::Serial> {
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>, Kokkos::Serial> {
  private:
-  enum { TEAM_REDUCE_SIZE = 512 };
+  static constexpr int TEAM_REDUCE_SIZE = 512;
 
-  using Policy = TeamPolicyInternal<Kokkos::Serial, Properties...>;
+  using Policy      = TeamPolicyInternal<Kokkos::Serial, Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
   using Member  = typename Policy::member_type;
   using WorkTag = typename Policy::work_tag;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      std::conditional_t<std::is_same<InvalidType, ReducerType>::value, WorkTag,
-                         void>;
-
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::REDUCE, Policy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
   const int m_league;
-  const ReducerType m_reducer;
   pointer_type m_result_ptr;
   size_t m_shared;
 
@@ -304,7 +294,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   inline std::enable_if_t<std::is_void<TagType>::value> exec(
       HostThreadTeamData& data, reference_type update) const {
     for (int ileague = 0; ileague < m_league; ++ileague) {
-      m_functor(Member(data, ileague, m_league), update);
+      m_functor_reducer.get_functor()(Member(data, ileague, m_league), update);
     }
   }
 
@@ -314,14 +304,15 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     const TagType t{};
 
     for (int ileague = 0; ileague < m_league; ++ileague) {
-      m_functor(t, Member(data, ileague, m_league), update);
+      m_functor_reducer.get_functor()(t, Member(data, ileague, m_league),
+                                      update);
     }
   }
 
  public:
   inline void execute() const {
     const size_t pool_reduce_size =
-        Analysis::value_size(ReducerConditional::select(m_functor, m_reducer));
+        m_functor_reducer.get_reducer().value_size();
 
     const size_t team_reduce_size  = TEAM_REDUCE_SIZE;
     const size_t team_shared_size  = m_shared;
@@ -341,53 +332,32 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
             : pointer_type(
                   internal_instance->m_thread_team_data.pool_reduce_local());
 
-    typename Analysis::Reducer final_reducer(
-        &ReducerConditional::select(m_functor, m_reducer));
-
-    reference_type update = final_reducer.init(ptr);
+    reference_type update = m_functor_reducer.get_reducer().init(ptr);
 
     this->template exec<WorkTag>(internal_instance->m_thread_team_data, update);
 
-    final_reducer.final(ptr);
+    m_functor_reducer.get_reducer().final(ptr);
   }
 
   template <class ViewType>
-  ParallelReduce(const FunctorType& arg_functor, const Policy& arg_policy,
-                 const ViewType& arg_result,
-                 std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void*> = nullptr)
-      : m_functor(arg_functor),
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 const Policy& arg_policy, const ViewType& arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
         m_league(arg_policy.league_size()),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(m_functor, 1)) {
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     m_functor_reducer.get_functor(), 1)) {
     static_assert(Kokkos::is_view<ViewType>::value,
                   "Reduction result on Kokkos::Serial must be a Kokkos::View");
 
     static_assert(
         Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
                                         Kokkos::HostSpace>::accessible,
-        "Reduction result on Kokkos::Serial must be a Kokkos::View in "
+        "Kokkos::Serial reduce result must be a View accessible from "
         "HostSpace");
   }
-
-  inline ParallelReduce(const FunctorType& arg_functor, Policy arg_policy,
-                        const ReducerType& reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_league(arg_policy.league_size()),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_shared(arg_policy.scratch_size(0) + arg_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(arg_functor, 1)) {
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                            , Kokkos::HostSpace >::value
-    , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-    );*/
-  }
 };
 
 }  // namespace Impl
diff --git a/core/src/Serial/Kokkos_Serial_Task.hpp b/core/src/Serial/Kokkos_Serial_Task.hpp
index c744f34760..f9c86f55ce 100644
--- a/core/src/Serial/Kokkos_Serial_Task.hpp
+++ b/core/src/Serial/Kokkos_Serial_Task.hpp
@@ -22,9 +22,9 @@
 
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
-#include <impl/Kokkos_TaskQueue.hpp>
-#include <Kokkos_Serial.hpp>
+#include <Serial/Kokkos_Serial.hpp>
 #include <impl/Kokkos_HostThreadTeam.hpp>
+#include <impl/Kokkos_TaskQueue.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp b/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp
new file mode 100644
index 0000000000..3ec2dfbcfa
--- /dev/null
+++ b/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp
@@ -0,0 +1,50 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_SERIAL_ZEROMEMSET_HPP
+#define KOKKOS_SERIAL_ZEROMEMSET_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
+#include <Serial/Kokkos_Serial.hpp>
+
+#include <type_traits>
+
+namespace Kokkos {
+namespace Impl {
+
+// We only need to provide a specialization for Serial if there is a host
+// parallel execution space since the specialization for
+// DefaultHostExecutionSpace is defined elsewhere.
+struct DummyExecutionSpace;
+template <class T, class... P>
+struct ZeroMemset<
+    std::conditional_t<!std::is_same<Serial, DefaultHostExecutionSpace>::value,
+                       Serial, DummyExecutionSpace>,
+    View<T, P...>>
+    : public ZeroMemset<DefaultHostExecutionSpace, View<T, P...>> {
+  using Base = ZeroMemset<DefaultHostExecutionSpace, View<T, P...>>;
+  using Base::Base;
+
+  ZeroMemset(const Serial&, const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type& value)
+      : Base(dst, value) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // !defined(KOKKOS_SERIAL_ZEROMEMSET_HPP)
diff --git a/core/src/Kokkos_Threads.hpp b/core/src/Threads/Kokkos_Threads.hpp
similarity index 100%
rename from core/src/Kokkos_Threads.hpp
rename to core/src/Threads/Kokkos_Threads.hpp
diff --git a/core/src/Threads/Kokkos_ThreadsExec.cpp b/core/src/Threads/Kokkos_ThreadsExec.cpp
index 8f39c726c7..c754091e87 100644
--- a/core/src/Threads/Kokkos_ThreadsExec.cpp
+++ b/core/src/Threads/Kokkos_ThreadsExec.cpp
@@ -768,9 +768,6 @@ void ThreadsExec::initialize(int thread_count_arg) {
               << thread_count << " threads per process." << std::endl;
   }
 
-  // Init the array for used for arbitrarily sized atomics
-  Impl::init_lock_array_host_space();
-
   Impl::SharedAllocationRecord<void, void>::tracking_enable();
 }
 
diff --git a/core/src/Threads/Kokkos_ThreadsTeam.hpp b/core/src/Threads/Kokkos_ThreadsTeam.hpp
index 3f734f08d4..788b6366db 100644
--- a/core/src/Threads/Kokkos_ThreadsTeam.hpp
+++ b/core/src/Threads/Kokkos_ThreadsTeam.hpp
@@ -982,8 +982,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
         iType, Impl::ThreadsExecTeamMember>& loop_bounds,
     const FunctorType& lambda) {
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void,
-      FunctorType>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
 
   auto scan_val = value_type{};
 
@@ -1027,8 +1027,8 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     const FunctorType& lambda) {
   using value_type =
       typename Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                     TeamPolicy<Threads>,
-                                     FunctorType>::value_type;
+                                     TeamPolicy<Threads>, FunctorType,
+                                     void>::value_type;
 
   value_type scan_val = value_type();
 
diff --git a/core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp b/core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp
index 35392e3bfb..9d06249082 100644
--- a/core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp
+++ b/core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp
@@ -111,37 +111,27 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
   }
 };
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
-                     Kokkos::Threads> {
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::MDRangePolicy<Traits...>, Kokkos::Threads> {
  private:
   using MDRangePolicy = Kokkos::MDRangePolicy<Traits...>;
   using Policy        = typename MDRangePolicy::impl_range_policy;
+  using FunctorType   = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType   = typename CombinedFunctorReducerType::reducer_type;
 
   using WorkTag   = typename MDRangePolicy::work_tag;
   using WorkRange = typename Policy::WorkRange;
   using Member    = typename Policy::member_type;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using value_type     = typename ReducerType::value_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         MDRangePolicy, ReducerTypeFwd>;
-  using pointer_type   = typename Analysis::pointer_type;
-  using value_type     = typename Analysis::value_type;
-  using reference_type = typename Analysis::reference_type;
-
-  using iterate_type =
-      typename Kokkos::Impl::HostIterateTile<MDRangePolicy, FunctorType,
-                                             WorkTag, reference_type>;
+  using iterate_type = typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, CombinedFunctorReducerType, WorkTag, reference_type>;
 
   const iterate_type m_iter;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
 
   inline void exec_range(const Member &ibeg, const Member &iend,
@@ -164,9 +154,7 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     const WorkRange range(Policy(0, num_tiles).set_chunk_size(1),
                           exec.pool_rank(), exec.pool_size());
 
-    typename Analysis::Reducer reducer(
-        &ReducerConditional::select(self.m_iter.m_func, self.m_reducer));
-
+    const ReducerType &reducer = self.m_iter.m_func.get_reducer();
     self.exec_range(
         range.begin(), range.end(),
         reducer.init(static_cast<pointer_type>(exec.reduce_memory())));
@@ -188,11 +176,10 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
     exec.barrier();
 
     long work_index = exec.get_work_index();
-    typename Analysis::Reducer reducer(
-        &ReducerConditional::select(self.m_iter.m_func, self.m_reducer));
 
+    const ReducerType &reducer = self.m_iter.m_func.get_reducer();
     reference_type update =
-        reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
+        self.m_reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
     while (work_index != -1) {
       const Member begin = static_cast<Member>(work_index);
       const Member end   = begin + 1 < num_tiles ? begin + 1 : num_tiles;
@@ -200,14 +187,13 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
       work_index = exec.get_work_index();
     }
 
-    exec.fan_in_reduce(reducer);
+    exec.fan_in_reduce(self.m_reducer);
   }
 
  public:
   inline void execute() const {
-    ThreadsExec::resize_scratch(Analysis::value_size(ReducerConditional::select(
-                                    m_iter.m_func, m_reducer)),
-                                0);
+    const ReducerType &reducer = m_iter.m_func.get_reducer();
+    ThreadsExec::resize_scratch(reducer.value_size(), 0);
 
     ThreadsExec::start(&ParallelReduce::exec, this);
 
@@ -217,41 +203,27 @@ class ParallelReduce<FunctorType, Kokkos::MDRangePolicy<Traits...>, ReducerType,
       const pointer_type data =
           (pointer_type)ThreadsExec::root_reduce_scratch();
 
-      const unsigned n = Analysis::value_count(
-          ReducerConditional::select(m_iter.m_func, m_reducer));
+      const unsigned n = reducer.value_count();
       for (unsigned i = 0; i < n; ++i) {
         m_result_ptr[i] = data[i];
       }
     }
   }
 
-  template <class HostViewType>
-  ParallelReduce(const FunctorType &arg_functor,
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType &arg_functor_reducer,
                  const MDRangePolicy &arg_policy,
-                 const HostViewType &arg_result_view,
-                 std::enable_if_t<Kokkos::is_view<HostViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void *> = nullptr)
-      : m_iter(arg_policy, arg_functor),
-        m_reducer(InvalidType()),
+                 const ViewType &arg_result_view)
+      : m_iter(arg_policy, arg_functor_reducer),
         m_result_ptr(arg_result_view.data()) {
-    static_assert(Kokkos::is_view<HostViewType>::value,
+    static_assert(Kokkos::is_view<ViewType>::value,
                   "Kokkos::Threads reduce result must be a View");
 
     static_assert(
-        std::is_same<typename HostViewType::memory_space, HostSpace>::value,
-        "Kokkos::Threads reduce result must be a View in HostSpace");
-  }
-
-  inline ParallelReduce(const FunctorType &arg_functor,
-                        MDRangePolicy arg_policy, const ReducerType &reducer)
-      : m_iter(arg_policy, arg_functor),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::Threads reduce result must be a View accessible from "
+        "HostSpace");
   }
 
   template <typename Policy, typename Functor>
diff --git a/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp b/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp
index 7d3527facd..f8c2867739 100644
--- a/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp
+++ b/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp
@@ -116,33 +116,23 @@ class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
       : m_functor(arg_functor), m_policy(arg_policy) {}
 };
 
-template <class FunctorType, class ReducerType, class... Traits>
-class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
                      Kokkos::Threads> {
  private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
 
   using WorkTag   = typename Policy::work_tag;
   using WorkRange = typename Policy::WorkRange;
   using Member    = typename Policy::member_type;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         Policy, ReducerTypeFwd>;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
 
   template <class TagType>
@@ -182,11 +172,10 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     const ParallelReduce &self = *((const ParallelReduce *)arg);
     const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    typename Analysis::Reducer reducer(
-        &ReducerConditional::select(self.m_functor, self.m_reducer));
+    const ReducerType &reducer = self.m_functor_reducer.get_reducer();
 
     ParallelReduce::template exec_range<WorkTag>(
-        self.m_functor, range.begin(), range.end(),
+        self.m_functor_reducer.get_functor(), range.begin(), range.end(),
         reducer.init(static_cast<pointer_type>(exec.reduce_memory())));
 
     exec.fan_in_reduce(reducer);
@@ -204,9 +193,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     exec.reset_steal_target();
     exec.barrier();
 
-    long work_index = exec.get_work_index();
-    typename Analysis::Reducer reducer(
-        &ReducerConditional::select(self.m_functor, self.m_reducer));
+    long work_index            = exec.get_work_index();
+    const ReducerType &reducer = self.m_functor_reducer.get_reducer();
 
     reference_type update =
         reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
@@ -218,8 +206,8 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
           begin + self.m_policy.chunk_size() < self.m_policy.end()
               ? begin + self.m_policy.chunk_size()
               : self.m_policy.end();
-      ParallelReduce::template exec_range<WorkTag>(self.m_functor, begin, end,
-                                                   update);
+      ParallelReduce::template exec_range<WorkTag>(
+          self.m_functor_reducer.get_functor(), begin, end, update);
       work_index = exec.get_work_index();
     }
 
@@ -228,18 +216,15 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
 
  public:
   inline void execute() const {
+    const ReducerType &reducer = m_functor_reducer.get_reducer();
+
     if (m_policy.end() <= m_policy.begin()) {
       if (m_result_ptr) {
-        typename Analysis::Reducer final_reducer(
-            &ReducerConditional::select(m_functor, m_reducer));
-        final_reducer.init(m_result_ptr);
-        final_reducer.final(m_result_ptr);
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
       }
     } else {
-      ThreadsExec::resize_scratch(
-          Analysis::value_size(
-              ReducerConditional::select(m_functor, m_reducer)),
-          0);
+      ThreadsExec::resize_scratch(reducer.value_size(), 0);
 
       ThreadsExec::start(&ParallelReduce::exec, this);
 
@@ -249,8 +234,7 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
         const pointer_type data =
             (pointer_type)ThreadsExec::root_reduce_scratch();
 
-        const unsigned n = Analysis::value_count(
-            ReducerConditional::select(m_functor, m_reducer));
+        const unsigned n = reducer.value_count();
         for (unsigned i = 0; i < n; ++i) {
           m_result_ptr[i] = data[i];
         }
@@ -258,34 +242,20 @@ class ParallelReduce<FunctorType, Kokkos::RangePolicy<Traits...>, ReducerType,
     }
   }
 
-  template <class HostViewType>
-  ParallelReduce(const FunctorType &arg_functor, const Policy &arg_policy,
-                 const HostViewType &arg_result_view,
-                 std::enable_if_t<Kokkos::is_view<HostViewType>::value &&
-                                      !Kokkos::is_reducer<ReducerType>::value,
-                                  void *> = nullptr)
-      : m_functor(arg_functor),
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType &arg_functor_reducer,
+                 const Policy &arg_policy, const ViewType &arg_result_view)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(arg_policy),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result_view.data()) {
-    static_assert(Kokkos::is_view<HostViewType>::value,
+    static_assert(Kokkos::is_view<ViewType>::value,
                   "Kokkos::Threads reduce result must be a View");
 
     static_assert(
-        std::is_same<typename HostViewType::memory_space, HostSpace>::value,
-        "Kokkos::Threads reduce result must be a View in HostSpace");
-  }
-
-  inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
-                        const ReducerType &reducer)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()) {
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                                    , Kokkos::HostSpace >::value
-      , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-      );*/
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::Threads reduce result must be a View accessible from "
+        "HostSpace");
   }
 };
 
@@ -298,7 +268,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
   using WorkTag   = typename Policy::work_tag;
   using Member    = typename Policy::member_type;
   using Analysis  = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         Policy, FunctorType>;
+                                         Policy, FunctorType, void>;
   using pointer_type   = typename Analysis::pointer_type;
   using reference_type = typename Analysis::reference_type;
 
@@ -337,7 +307,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
 
     const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    typename Analysis::Reducer final_reducer(&self.m_functor);
+    typename Analysis::Reducer final_reducer(self.m_functor);
 
     reference_type update =
         final_reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
@@ -375,7 +345,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
   using Member    = typename Policy::member_type;
 
   using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         Policy, FunctorType>;
+                                         Policy, FunctorType, ReturnType>;
 
   using value_type     = typename Analysis::value_type;
   using pointer_type   = typename Analysis::pointer_type;
@@ -417,7 +387,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
 
     const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
 
-    typename Analysis::Reducer final_reducer(&self.m_functor);
+    typename Analysis::Reducer final_reducer(self.m_functor);
 
     reference_type update =
         final_reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
diff --git a/core/src/Threads/Kokkos_Threads_Parallel_Team.hpp b/core/src/Threads/Kokkos_Threads_Parallel_Team.hpp
index a602078c52..28efba5ed2 100644
--- a/core/src/Threads/Kokkos_Threads_Parallel_Team.hpp
+++ b/core/src/Threads/Kokkos_Threads_Parallel_Team.hpp
@@ -112,31 +112,22 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
                      arg_functor, m_policy.team_size())) {}
 };
 
-template <class FunctorType, class ReducerType, class... Properties>
-class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                     ReducerType, Kokkos::Threads> {
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>, Kokkos::Threads> {
  private:
   using Policy =
       Kokkos::Impl::TeamPolicyInternal<Kokkos::Threads, Properties...>;
-  using WorkTag = typename Policy::work_tag;
-  using Member  = typename Policy::member_type;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+  using WorkTag     = typename Policy::work_tag;
+  using Member      = typename Policy::member_type;
 
-  using ReducerConditional =
-      Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                         FunctorType, ReducerType>;
-  using ReducerTypeFwd = typename ReducerConditional::type;
-  using WorkTagFwd =
-      typename Kokkos::Impl::if_c<std::is_same<InvalidType, ReducerType>::value,
-                                  WorkTag, void>::type;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
 
-  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                                         Policy, ReducerTypeFwd>;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  const FunctorType m_functor;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
-  const ReducerType m_reducer;
   const pointer_type m_result_ptr;
   const size_t m_shared;
 
@@ -160,29 +151,27 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
   static void exec(ThreadsExec &exec, const void *arg) {
     const ParallelReduce &self = *((const ParallelReduce *)arg);
 
-    typename Analysis::Reducer reducer(
-        &ReducerConditional::select(self.m_functor, self.m_reducer));
-
     ParallelReduce::template exec_team<WorkTag>(
-        self.m_functor, Member(&exec, self.m_policy, self.m_shared),
-        reducer.init(static_cast<pointer_type>(exec.reduce_memory())));
+        self.m_functor_reducer.get_functor(),
+        Member(&exec, self.m_policy, self.m_shared),
+        self.m_functor_reducer.get_reducer().init(
+            static_cast<pointer_type>(exec.reduce_memory())));
 
-    exec.fan_in_reduce(reducer);
+    exec.fan_in_reduce(self.m_functor_reducer.get_reducer());
   }
 
  public:
   inline void execute() const {
+    const ReducerType &reducer = m_functor_reducer.get_reducer();
+
     if (m_policy.league_size() * m_policy.team_size() == 0) {
       if (m_result_ptr) {
-        typename Analysis::Reducer final_reducer(
-            &ReducerConditional::select(m_functor, m_reducer));
-        final_reducer.init(m_result_ptr);
-        final_reducer.final(m_result_ptr);
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
       }
     } else {
       ThreadsExec::resize_scratch(
-          Analysis::value_size(
-              ReducerConditional::select(m_functor, m_reducer)),
+          reducer.value_size(),
           Policy::member_type::team_reduce_size() + m_shared);
 
       ThreadsExec::start(&ParallelReduce::exec, this);
@@ -193,8 +182,7 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
         const pointer_type data =
             (pointer_type)ThreadsExec::root_reduce_scratch();
 
-        const unsigned n = Analysis::value_count(
-            ReducerConditional::select(m_functor, m_reducer));
+        const unsigned n = reducer.value_count();
         for (unsigned i = 0; i < n; ++i) {
           m_result_ptr[i] = data[i];
         }
@@ -209,39 +197,26 @@ class ParallelReduce<FunctorType, Kokkos::TeamPolicy<Properties...>,
     }
     if (policy.team_size() < 0) {
       policy.impl_set_team_size(policy.team_size_recommended(
-          m_functor, m_reducer, ParallelReduceTag{}));
+          m_functor_reducer.get_functor(), m_functor_reducer.get_reducer(),
+          ParallelReduceTag{}));
     }
     return policy;
   }
 
   template <class ViewType>
-  inline ParallelReduce(
-      const FunctorType &arg_functor, const Policy &arg_policy,
-      const ViewType &arg_result,
-      std::enable_if_t<Kokkos::is_view<ViewType>::value &&
-                           !Kokkos::is_reducer<ReducerType>::value,
-                       void *> = nullptr)
-      : m_functor(arg_functor),
+  inline ParallelReduce(const CombinedFunctorReducerType &arg_functor_reducer,
+                        const Policy &arg_policy, const ViewType &arg_result)
+      : m_functor_reducer(arg_functor_reducer),
         m_policy(fix_policy(arg_policy)),
-        m_reducer(InvalidType()),
         m_result_ptr(arg_result.data()),
         m_shared(m_policy.scratch_size(0) + m_policy.scratch_size(1) +
                  FunctorTeamShmemSize<FunctorType>::value(
-                     arg_functor, m_policy.team_size())) {}
-
-  inline ParallelReduce(const FunctorType &arg_functor, Policy arg_policy,
-                        const ReducerType &reducer)
-      : m_functor(arg_functor),
-        m_policy(fix_policy(arg_policy)),
-        m_reducer(reducer),
-        m_result_ptr(reducer.view().data()),
-        m_shared(m_policy.scratch_size(0) + m_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(
-                     arg_functor, m_policy.team_size())) {
-    /*static_assert( std::is_same< typename ViewType::memory_space
-                            , Kokkos::HostSpace >::value
-    , "Reduction result on Kokkos::OpenMP must be a Kokkos::View in HostSpace"
-    );*/
+                     arg_functor_reducer.get_functor(), m_policy.team_size())) {
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::Threads reduce result must be a View accessible from "
+        "HostSpace");
   }
 };
 
diff --git a/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp b/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
index 7c29ce5739..797044b117 100644
--- a/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
+++ b/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_THREADS_WORKGRAPHPOLICY_HPP
 
 #include <Kokkos_Core_fwd.hpp>
-#include <Kokkos_Threads.hpp>
+#include <Threads/Kokkos_Threads.hpp>
 
 namespace Kokkos {
 namespace Impl {
diff --git a/core/src/decl/Kokkos_Declare_CUDA.hpp b/core/src/decl/Kokkos_Declare_CUDA.hpp
index 215b18f221..ebdf2c8211 100644
--- a/core/src/decl/Kokkos_Declare_CUDA.hpp
+++ b/core/src/decl/Kokkos_Declare_CUDA.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_DECLARE_CUDA_HPP
 
 #if defined(KOKKOS_ENABLE_CUDA)
-#include <Kokkos_Cuda.hpp>
+#include <Cuda/Kokkos_Cuda.hpp>
 #include <Cuda/Kokkos_Cuda_Half_Impl_Type.hpp>
 #include <Cuda/Kokkos_Cuda_Half_Conversion.hpp>
 #include <Cuda/Kokkos_Cuda_Parallel_MDRange.hpp>
@@ -31,6 +31,7 @@
 #include <Cuda/Kokkos_Cuda_Task.hpp>
 #include <Cuda/Kokkos_Cuda_MDRangePolicy.hpp>
 #include <Cuda/Kokkos_Cuda_UniqueToken.hpp>
+#include <Cuda/Kokkos_Cuda_ZeroMemset.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_HIP.hpp b/core/src/decl/Kokkos_Declare_HIP.hpp
index 09ea882600..e115f7051f 100644
--- a/core/src/decl/Kokkos_Declare_HIP.hpp
+++ b/core/src/decl/Kokkos_Declare_HIP.hpp
@@ -30,6 +30,7 @@
 #include <HIP/Kokkos_HIP_Parallel_Team.hpp>
 #include <HIP/Kokkos_HIP_SharedAllocationRecord.hpp>
 #include <HIP/Kokkos_HIP_UniqueToken.hpp>
+#include <HIP/Kokkos_HIP_ZeroMemset.hpp>
 
 namespace Kokkos {
 namespace Experimental {
diff --git a/core/src/decl/Kokkos_Declare_HPX.hpp b/core/src/decl/Kokkos_Declare_HPX.hpp
index 73f94591f5..f901236246 100644
--- a/core/src/decl/Kokkos_Declare_HPX.hpp
+++ b/core/src/decl/Kokkos_Declare_HPX.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_DECLARE_HPX_HPP
 
 #if defined(KOKKOS_ENABLE_HPX)
-#include <Kokkos_HPX.hpp>
+#include <HPX/Kokkos_HPX.hpp>
 #include <HPX/Kokkos_HPX_MDRangePolicy.hpp>
 #endif
 
diff --git a/core/src/decl/Kokkos_Declare_OPENACC.hpp b/core/src/decl/Kokkos_Declare_OPENACC.hpp
index 137286c741..727e551cd8 100644
--- a/core/src/decl/Kokkos_Declare_OPENACC.hpp
+++ b/core/src/decl/Kokkos_Declare_OPENACC.hpp
@@ -24,9 +24,12 @@
 #include <OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp>
 #include <OpenACC/Kokkos_OpenACC_ParallelFor_Range.hpp>
 #include <OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp>
+#include <OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp>
 #include <OpenACC/Kokkos_OpenACC_MDRangePolicy.hpp>
 #include <OpenACC/Kokkos_OpenACC_ParallelFor_MDRange.hpp>
+#include <OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp>
 #include <OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp>
+#include <OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_OPENMP.hpp b/core/src/decl/Kokkos_Declare_OPENMP.hpp
index 1e1314145d..ef9d27108e 100644
--- a/core/src/decl/Kokkos_Declare_OPENMP.hpp
+++ b/core/src/decl/Kokkos_Declare_OPENMP.hpp
@@ -18,8 +18,9 @@
 #define KOKKOS_DECLARE_OPENMP_HPP
 
 #if defined(KOKKOS_ENABLE_OPENMP)
-#include <Kokkos_OpenMP.hpp>
+#include <OpenMP/Kokkos_OpenMP.hpp>
 #include <OpenMP/Kokkos_OpenMP_MDRangePolicy.hpp>
+#include <OpenMP/Kokkos_OpenMP_UniqueToken.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_OPENMPTARGET.hpp b/core/src/decl/Kokkos_Declare_OPENMPTARGET.hpp
index 0bd89ef4cf..6bde8f59d8 100644
--- a/core/src/decl/Kokkos_Declare_OPENMPTARGET.hpp
+++ b/core/src/decl/Kokkos_Declare_OPENMPTARGET.hpp
@@ -18,10 +18,17 @@
 #define KOKKOS_DECLARE_OPENMPTARGET_HPP
 
 #if defined(KOKKOS_ENABLE_OPENMPTARGET)
-#include <Kokkos_OpenMPTarget.hpp>
-#include <Kokkos_OpenMPTargetSpace.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_MDRangePolicy.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_UniqueToken.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Range.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_SERIAL.hpp b/core/src/decl/Kokkos_Declare_SERIAL.hpp
index bb59ae2ce8..86b044bee5 100644
--- a/core/src/decl/Kokkos_Declare_SERIAL.hpp
+++ b/core/src/decl/Kokkos_Declare_SERIAL.hpp
@@ -18,8 +18,9 @@
 #define KOKKOS_DECLARE_SERIAL_HPP
 
 #if defined(KOKKOS_ENABLE_SERIAL)
-#include <Kokkos_Serial.hpp>
+#include <Serial/Kokkos_Serial.hpp>
 #include <Serial/Kokkos_Serial_MDRangePolicy.hpp>
+#include <Serial/Kokkos_Serial_ZeroMemset.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_SYCL.hpp b/core/src/decl/Kokkos_Declare_SYCL.hpp
index 0c8dddbeb3..a810bb0c76 100644
--- a/core/src/decl/Kokkos_Declare_SYCL.hpp
+++ b/core/src/decl/Kokkos_Declare_SYCL.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_DECLARE_SYCL_HPP
 
 #if defined(KOKKOS_ENABLE_SYCL)
-#include <Kokkos_SYCL.hpp>
+#include <SYCL/Kokkos_SYCL.hpp>
 #include <SYCL/Kokkos_SYCL_Half_Impl_Type.hpp>
 #include <SYCL/Kokkos_SYCL_Half_Conversion.hpp>
 #include <SYCL/Kokkos_SYCL_DeepCopy.hpp>
@@ -28,6 +28,7 @@
 #include <SYCL/Kokkos_SYCL_Parallel_Scan.hpp>
 #include <SYCL/Kokkos_SYCL_Parallel_Team.hpp>
 #include <SYCL/Kokkos_SYCL_UniqueToken.hpp>
+#include <SYCL/Kokkos_SYCL_ZeroMemset.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_THREADS.hpp b/core/src/decl/Kokkos_Declare_THREADS.hpp
index b7af04be3c..16f134b6f2 100644
--- a/core/src/decl/Kokkos_Declare_THREADS.hpp
+++ b/core/src/decl/Kokkos_Declare_THREADS.hpp
@@ -18,7 +18,7 @@
 #define KOKKOS_DECLARE_THREADS_HPP
 
 #if defined(KOKKOS_ENABLE_THREADS)
-#include <Kokkos_Threads.hpp>
+#include <Threads/Kokkos_Threads.hpp>
 #include <Threads/Kokkos_Threads_MDRangePolicy.hpp>
 #endif
 
diff --git a/core/src/impl/CMakeLists.txt b/core/src/impl/CMakeLists.txt
deleted file mode 100644
index 203fd4a3a4..0000000000
--- a/core/src/impl/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-SET(HEADERS "")
-SET(SOURCES "")
-
-FILE(GLOB HEADERS *.hpp *.h)
-FILE(GLOB SOURCES *.cpp)
-
-TRIBITS_ADD_LIBRARY(
-    kokkoscore_impl
-    NOINSTALLHEADERS ${HEADERS}
-    SOURCES ${SOURCES}
-    DEPLIBS
-    )
-
-SET(TRILINOS_INCDIR ${${PROJECT_NAME}_INSTALL_INCLUDE_DIR})
-
-INSTALL(FILES ${HEADERS} DESTINATION ${TRILINOS_INCDIR}/impl/)
-
diff --git a/core/src/impl/KokkosExp_Host_IterateTile.hpp b/core/src/impl/KokkosExp_Host_IterateTile.hpp
index e2b606004f..a44ffefa6b 100644
--- a/core/src/impl/KokkosExp_Host_IterateTile.hpp
+++ b/core/src/impl/KokkosExp_Host_IterateTile.hpp
@@ -37,1167 +37,1278 @@ namespace Impl {
 // Temporary, for testing new loop macros
 #define KOKKOS_ENABLE_NEW_LOOP_MACROS 1
 
-#define LOOP_1L(type, tile)   \
-  KOKKOS_ENABLE_IVDEP_MDRANGE \
+#define KOKKOS_IMPL_LOOP_1L(type, tile) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE           \
   for (type i0 = 0; i0 < static_cast<type>(tile[0]); ++i0)
 
-#define LOOP_2L(type, tile) \
-  for (type i1 = 0; i1 < static_cast<type>(tile[1]); ++i1) LOOP_1L(type, tile)
+#define KOKKOS_IMPL_LOOP_2L(type, tile)                    \
+  for (type i1 = 0; i1 < static_cast<type>(tile[1]); ++i1) \
+  KOKKOS_IMPL_LOOP_1L(type, tile)
 
-#define LOOP_3L(type, tile) \
-  for (type i2 = 0; i2 < static_cast<type>(tile[2]); ++i2) LOOP_2L(type, tile)
+#define KOKKOS_IMPL_LOOP_3L(type, tile)                    \
+  for (type i2 = 0; i2 < static_cast<type>(tile[2]); ++i2) \
+  KOKKOS_IMPL_LOOP_2L(type, tile)
 
-#define LOOP_4L(type, tile) \
-  for (type i3 = 0; i3 < static_cast<type>(tile[3]); ++i3) LOOP_3L(type, tile)
+#define KOKKOS_IMPL_LOOP_4L(type, tile)                    \
+  for (type i3 = 0; i3 < static_cast<type>(tile[3]); ++i3) \
+  KOKKOS_IMPL_LOOP_3L(type, tile)
 
-#define LOOP_5L(type, tile) \
-  for (type i4 = 0; i4 < static_cast<type>(tile[4]); ++i4) LOOP_4L(type, tile)
+#define KOKKOS_IMPL_LOOP_5L(type, tile)                    \
+  for (type i4 = 0; i4 < static_cast<type>(tile[4]); ++i4) \
+  KOKKOS_IMPL_LOOP_4L(type, tile)
 
-#define LOOP_6L(type, tile) \
-  for (type i5 = 0; i5 < static_cast<type>(tile[5]); ++i5) LOOP_5L(type, tile)
+#define KOKKOS_IMPL_LOOP_6L(type, tile)                    \
+  for (type i5 = 0; i5 < static_cast<type>(tile[5]); ++i5) \
+  KOKKOS_IMPL_LOOP_5L(type, tile)
 
-#define LOOP_7L(type, tile) \
-  for (type i6 = 0; i6 < static_cast<type>(tile[6]); ++i6) LOOP_6L(type, tile)
+#define KOKKOS_IMPL_LOOP_7L(type, tile)                    \
+  for (type i6 = 0; i6 < static_cast<type>(tile[6]); ++i6) \
+  KOKKOS_IMPL_LOOP_6L(type, tile)
 
-#define LOOP_8L(type, tile) \
-  for (type i7 = 0; i7 < static_cast<type>(tile[7]); ++i7) LOOP_7L(type, tile)
+#define KOKKOS_IMPL_LOOP_8L(type, tile)                    \
+  for (type i7 = 0; i7 < static_cast<type>(tile[7]); ++i7) \
+  KOKKOS_IMPL_LOOP_7L(type, tile)
 
-#define LOOP_1R(type, tile)   \
-  KOKKOS_ENABLE_IVDEP_MDRANGE \
+#define KOKKOS_IMPL_LOOP_1R(type, tile) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE           \
   for (type i0 = 0; i0 < static_cast<type>(tile[0]); ++i0)
 
-#define LOOP_2R(type, tile) \
-  LOOP_1R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_2R(type, tile) \
+  KOKKOS_IMPL_LOOP_1R(type, tile)       \
   for (type i1 = 0; i1 < static_cast<type>(tile[1]); ++i1)
 
-#define LOOP_3R(type, tile) \
-  LOOP_2R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_3R(type, tile) \
+  KOKKOS_IMPL_LOOP_2R(type, tile)       \
   for (type i2 = 0; i2 < static_cast<type>(tile[2]); ++i2)
 
-#define LOOP_4R(type, tile) \
-  LOOP_3R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_4R(type, tile) \
+  KOKKOS_IMPL_LOOP_3R(type, tile)       \
   for (type i3 = 0; i3 < static_cast<type>(tile[3]); ++i3)
 
-#define LOOP_5R(type, tile) \
-  LOOP_4R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_5R(type, tile) \
+  KOKKOS_IMPL_LOOP_4R(type, tile)       \
   for (type i4 = 0; i4 < static_cast<type>(tile[4]); ++i4)
 
-#define LOOP_6R(type, tile) \
-  LOOP_5R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_6R(type, tile) \
+  KOKKOS_IMPL_LOOP_5R(type, tile)       \
   for (type i5 = 0; i5 < static_cast<type>(tile[5]); ++i5)
 
-#define LOOP_7R(type, tile) \
-  LOOP_6R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_7R(type, tile) \
+  KOKKOS_IMPL_LOOP_6R(type, tile)       \
   for (type i6 = 0; i6 < static_cast<type>(tile[6]); ++i6)
 
-#define LOOP_8R(type, tile) \
-  LOOP_7R(type, tile)       \
+#define KOKKOS_IMPL_LOOP_8R(type, tile) \
+  KOKKOS_IMPL_LOOP_7R(type, tile)       \
   for (type i7 = 0; i7 < static_cast<type>(tile[7]); ++i7)
 
-#define LOOP_ARGS_1 i0 + m_offset[0]
-#define LOOP_ARGS_2 LOOP_ARGS_1, i1 + m_offset[1]
-#define LOOP_ARGS_3 LOOP_ARGS_2, i2 + m_offset[2]
-#define LOOP_ARGS_4 LOOP_ARGS_3, i3 + m_offset[3]
-#define LOOP_ARGS_5 LOOP_ARGS_4, i4 + m_offset[4]
-#define LOOP_ARGS_6 LOOP_ARGS_5, i5 + m_offset[5]
-#define LOOP_ARGS_7 LOOP_ARGS_6, i6 + m_offset[6]
-#define LOOP_ARGS_8 LOOP_ARGS_7, i7 + m_offset[7]
+#define KOKKOS_IMPL_LOOP_ARGS_1 i0 + m_offset[0]
+#define KOKKOS_IMPL_LOOP_ARGS_2 KOKKOS_IMPL_LOOP_ARGS_1, i1 + m_offset[1]
+#define KOKKOS_IMPL_LOOP_ARGS_3 KOKKOS_IMPL_LOOP_ARGS_2, i2 + m_offset[2]
+#define KOKKOS_IMPL_LOOP_ARGS_4 KOKKOS_IMPL_LOOP_ARGS_3, i3 + m_offset[3]
+#define KOKKOS_IMPL_LOOP_ARGS_5 KOKKOS_IMPL_LOOP_ARGS_4, i4 + m_offset[4]
+#define KOKKOS_IMPL_LOOP_ARGS_6 KOKKOS_IMPL_LOOP_ARGS_5, i5 + m_offset[5]
+#define KOKKOS_IMPL_LOOP_ARGS_7 KOKKOS_IMPL_LOOP_ARGS_6, i6 + m_offset[6]
+#define KOKKOS_IMPL_LOOP_ARGS_8 KOKKOS_IMPL_LOOP_ARGS_7, i7 + m_offset[7]
 
 // New Loop Macros...
 // parallel_for, non-tagged
-#define APPLY(func, ...) func(__VA_ARGS__);
+#define KOKKOS_IMPL_APPLY(func, ...) func(__VA_ARGS__);
 
 // LayoutRight
 // d = 0 to start
-#define LOOP_R_1(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_R_1(func, type, m_offset, extent, d, ...)   \
   KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
   for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY(func, __VA_ARGS__, i0 + m_offset[d])                       \
+    KOKKOS_IMPL_APPLY(func, __VA_ARGS__, i0 + m_offset[d])           \
   }
 
-#define LOOP_R_2(func, type, m_offset, extent, d, ...)               \
-  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) { \
-    LOOP_R_1(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i1 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_2(func, type, m_offset, extent, d, ...)         \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {       \
+    KOKKOS_IMPL_LOOP_R_1(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i1 + m_offset[d])                                 \
   }
 
-#define LOOP_R_3(func, type, m_offset, extent, d, ...)               \
-  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) { \
-    LOOP_R_2(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i2 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_3(func, type, m_offset, extent, d, ...)         \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {       \
+    KOKKOS_IMPL_LOOP_R_2(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i2 + m_offset[d])                                 \
   }
 
-#define LOOP_R_4(func, type, m_offset, extent, d, ...)               \
-  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) { \
-    LOOP_R_3(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i3 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_4(func, type, m_offset, extent, d, ...)         \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {       \
+    KOKKOS_IMPL_LOOP_R_3(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i3 + m_offset[d])                                 \
   }
 
-#define LOOP_R_5(func, type, m_offset, extent, d, ...)               \
-  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) { \
-    LOOP_R_4(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i4 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_5(func, type, m_offset, extent, d, ...)         \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {       \
+    KOKKOS_IMPL_LOOP_R_4(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i4 + m_offset[d])                                 \
   }
 
-#define LOOP_R_6(func, type, m_offset, extent, d, ...)               \
-  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) { \
-    LOOP_R_5(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i5 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_6(func, type, m_offset, extent, d, ...)         \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {       \
+    KOKKOS_IMPL_LOOP_R_5(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i5 + m_offset[d])                                 \
   }
 
-#define LOOP_R_7(func, type, m_offset, extent, d, ...)               \
-  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) { \
-    LOOP_R_6(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i6 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_7(func, type, m_offset, extent, d, ...)         \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {       \
+    KOKKOS_IMPL_LOOP_R_6(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i6 + m_offset[d])                                 \
   }
 
-#define LOOP_R_8(func, type, m_offset, extent, d, ...)               \
-  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) { \
-    LOOP_R_7(func, type, m_offset, extent, d + 1, __VA_ARGS__,       \
-             i7 + m_offset[d])                                       \
+#define KOKKOS_IMPL_LOOP_R_8(func, type, m_offset, extent, d, ...)         \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {       \
+    KOKKOS_IMPL_LOOP_R_7(func, type, m_offset, extent, d + 1, __VA_ARGS__, \
+                         i7 + m_offset[d])                                 \
   }
 
 // LayoutLeft
 // d = rank-1 to start
-#define LOOP_L_1(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_1(func, type, m_offset, extent, d, ...)   \
   KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
   for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY(func, i0 + m_offset[d], __VA_ARGS__)                       \
+    KOKKOS_IMPL_APPLY(func, i0 + m_offset[d], __VA_ARGS__)           \
   }
 
-#define LOOP_L_2(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_2(func, type, m_offset, extent, d, ...)   \
   for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) { \
-    LOOP_L_1(func, type, m_offset, extent, d - 1, i1 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_1(func, type, m_offset, extent, d - 1,        \
+                         i1 + m_offset[d], __VA_ARGS__)              \
   }
 
-#define LOOP_L_3(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_3(func, type, m_offset, extent, d, ...)   \
   for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) { \
-    LOOP_L_2(func, type, m_offset, extent, d - 1, i2 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_2(func, type, m_offset, extent, d - 1,        \
+                         i2 + m_offset[d], __VA_ARGS__)              \
   }
 
-#define LOOP_L_4(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_4(func, type, m_offset, extent, d, ...)   \
   for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) { \
-    LOOP_L_3(func, type, m_offset, extent, d - 1, i3 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_3(func, type, m_offset, extent, d - 1,        \
+                         i3 + m_offset[d], __VA_ARGS__)              \
   }
 
-#define LOOP_L_5(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_5(func, type, m_offset, extent, d, ...)   \
   for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) { \
-    LOOP_L_4(func, type, m_offset, extent, d - 1, i4 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_4(func, type, m_offset, extent, d - 1,        \
+                         i4 + m_offset[d], __VA_ARGS__)              \
   }
 
-#define LOOP_L_6(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_6(func, type, m_offset, extent, d, ...)   \
   for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) { \
-    LOOP_L_5(func, type, m_offset, extent, d - 1, i5 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_5(func, type, m_offset, extent, d - 1,        \
+                         i5 + m_offset[d], __VA_ARGS__)              \
   }
 
-#define LOOP_L_7(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_7(func, type, m_offset, extent, d, ...)   \
   for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) { \
-    LOOP_L_6(func, type, m_offset, extent, d - 1, i6 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_6(func, type, m_offset, extent, d - 1,        \
+                         i6 + m_offset[d], __VA_ARGS__)              \
   }
 
-#define LOOP_L_8(func, type, m_offset, extent, d, ...)               \
+#define KOKKOS_IMPL_LOOP_L_8(func, type, m_offset, extent, d, ...)   \
   for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) { \
-    LOOP_L_7(func, type, m_offset, extent, d - 1, i7 + m_offset[d],  \
-             __VA_ARGS__)                                            \
+    KOKKOS_IMPL_LOOP_L_7(func, type, m_offset, extent, d - 1,        \
+                         i7 + m_offset[d], __VA_ARGS__)              \
   }
 
 // Left vs Right
 // TODO: rank not necessary to pass through, can hardcode the values
-#define LOOP_LAYOUT_1(func, type, is_left, m_offset, extent, rank)   \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) { \
-    APPLY(func, i0 + m_offset[0])                                    \
+#define KOKKOS_IMPL_LOOP_LAYOUT_1(func, type, is_left, m_offset, extent, rank) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                  \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {           \
+    KOKKOS_IMPL_APPLY(func, i0 + m_offset[0])                                  \
   }
 
-#define LOOP_LAYOUT_2(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) { \
-      LOOP_L_1(func, type, m_offset, extent, rank - 2,                        \
-               i1 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {        \
-      LOOP_R_1(func, type, m_offset, extent, 1, i1 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_2(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) {  \
+      KOKKOS_IMPL_LOOP_L_1(func, type, m_offset, extent, rank - 2,             \
+                           i1 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {         \
+      KOKKOS_IMPL_LOOP_R_1(func, type, m_offset, extent, 1, i1 + m_offset[0])  \
+    }                                                                          \
   }
 
-#define LOOP_LAYOUT_3(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) { \
-      LOOP_L_2(func, type, m_offset, extent, rank - 2,                        \
-               i2 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {        \
-      LOOP_R_2(func, type, m_offset, extent, 1, i2 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_3(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) {  \
+      KOKKOS_IMPL_LOOP_L_2(func, type, m_offset, extent, rank - 2,             \
+                           i2 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {         \
+      KOKKOS_IMPL_LOOP_R_2(func, type, m_offset, extent, 1, i2 + m_offset[0])  \
+    }                                                                          \
   }
 
-#define LOOP_LAYOUT_4(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) { \
-      LOOP_L_3(func, type, m_offset, extent, rank - 2,                        \
-               i3 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {        \
-      LOOP_R_3(func, type, m_offset, extent, 1, i3 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_4(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) {  \
+      KOKKOS_IMPL_LOOP_L_3(func, type, m_offset, extent, rank - 2,             \
+                           i3 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {         \
+      KOKKOS_IMPL_LOOP_R_3(func, type, m_offset, extent, 1, i3 + m_offset[0])  \
+    }                                                                          \
   }
 
-#define LOOP_LAYOUT_5(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) { \
-      LOOP_L_4(func, type, m_offset, extent, rank - 2,                        \
-               i4 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {        \
-      LOOP_R_4(func, type, m_offset, extent, 1, i4 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_5(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) {  \
+      KOKKOS_IMPL_LOOP_L_4(func, type, m_offset, extent, rank - 2,             \
+                           i4 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {         \
+      KOKKOS_IMPL_LOOP_R_4(func, type, m_offset, extent, 1, i4 + m_offset[0])  \
+    }                                                                          \
   }
 
-#define LOOP_LAYOUT_6(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) { \
-      LOOP_L_5(func, type, m_offset, extent, rank - 2,                        \
-               i5 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {        \
-      LOOP_R_5(func, type, m_offset, extent, 1, i5 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_6(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) {  \
+      KOKKOS_IMPL_LOOP_L_5(func, type, m_offset, extent, rank - 2,             \
+                           i5 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {         \
+      KOKKOS_IMPL_LOOP_R_5(func, type, m_offset, extent, 1, i5 + m_offset[0])  \
+    }                                                                          \
   }
 
-#define LOOP_LAYOUT_7(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) { \
-      LOOP_L_6(func, type, m_offset, extent, rank - 2,                        \
-               i6 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {        \
-      LOOP_R_6(func, type, m_offset, extent, 1, i6 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_7(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) {  \
+      KOKKOS_IMPL_LOOP_L_6(func, type, m_offset, extent, rank - 2,             \
+                           i6 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {         \
+      KOKKOS_IMPL_LOOP_R_6(func, type, m_offset, extent, 1, i6 + m_offset[0])  \
+    }                                                                          \
   }
 
-#define LOOP_LAYOUT_8(func, type, is_left, m_offset, extent, rank)            \
-  if (is_left) {                                                              \
-    for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) { \
-      LOOP_L_7(func, type, m_offset, extent, rank - 2,                        \
-               i7 + m_offset[rank - 1])                                       \
-    }                                                                         \
-  } else {                                                                    \
-    for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {        \
-      LOOP_R_7(func, type, m_offset, extent, 1, i7 + m_offset[0])             \
-    }                                                                         \
+#define KOKKOS_IMPL_LOOP_LAYOUT_8(func, type, is_left, m_offset, extent, rank) \
+  if (is_left) {                                                               \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) {  \
+      KOKKOS_IMPL_LOOP_L_7(func, type, m_offset, extent, rank - 2,             \
+                           i7 + m_offset[rank - 1])                            \
+    }                                                                          \
+  } else {                                                                     \
+    for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {         \
+      KOKKOS_IMPL_LOOP_R_7(func, type, m_offset, extent, 1, i7 + m_offset[0])  \
+    }                                                                          \
   }
 
 // Partial vs Full Tile
-#define TILE_LOOP_1(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_1(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_1(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_1(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_1(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_1(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_2(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_2(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_2(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_2(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_2(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_2(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_3(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_3(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_3(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_3(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_3(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_3(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_4(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_4(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_4(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_4(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_4(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_4(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_5(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_5(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_5(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_5(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_5(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_5(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_6(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_6(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_6(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_6(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_6(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_6(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_7(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_7(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_7(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_7(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_7(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_7(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
-#define TILE_LOOP_8(func, type, is_left, cond, m_offset, extent_full,  \
-                    extent_partial, rank)                              \
-  if (cond) {                                                          \
-    LOOP_LAYOUT_8(func, type, is_left, m_offset, extent_full, rank)    \
-  } else {                                                             \
-    LOOP_LAYOUT_8(func, type, is_left, m_offset, extent_partial, rank) \
+#define KOKKOS_IMPL_TILE_LOOP_8(func, type, is_left, cond, m_offset,         \
+                                extent_full, extent_partial, rank)           \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_8(func, type, is_left, m_offset, extent_full,    \
+                              rank)                                          \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_8(func, type, is_left, m_offset, extent_partial, \
+                              rank)                                          \
   }
 
 // parallel_reduce, non-tagged
 // Reduction version
-#define APPLY_REDUX(val, func, ...) func(__VA_ARGS__, val);
+#define KOKKOS_IMPL_APPLY_REDUX(val, func, ...) func(__VA_ARGS__, val);
 
 // LayoutRight
 // d = 0 to start
-#define LOOP_R_1_REDUX(val, func, type, m_offset, extent, d, ...)    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY_REDUX(val, func, __VA_ARGS__, i0 + m_offset[d])            \
+#define KOKKOS_IMPL_LOOP_R_1_REDUX(val, func, type, m_offset, extent, d, ...) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {          \
+    KOKKOS_IMPL_APPLY_REDUX(val, func, __VA_ARGS__, i0 + m_offset[d])         \
   }
 
-#define LOOP_R_2_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {      \
-    LOOP_R_1_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i1 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_2_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
+    KOKKOS_IMPL_LOOP_R_1_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i1 + m_offset[d])                 \
   }
 
-#define LOOP_R_3_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {      \
-    LOOP_R_2_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i2 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_3_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
+    KOKKOS_IMPL_LOOP_R_2_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i2 + m_offset[d])                 \
   }
 
-#define LOOP_R_4_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {      \
-    LOOP_R_3_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i3 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_4_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
+    KOKKOS_IMPL_LOOP_R_3_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i3 + m_offset[d])                 \
   }
 
-#define LOOP_R_5_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {      \
-    LOOP_R_4_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i4 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_5_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
+    KOKKOS_IMPL_LOOP_R_4_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i4 + m_offset[d])                 \
   }
 
-#define LOOP_R_6_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {      \
-    LOOP_R_5_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i5 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_6_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
+    KOKKOS_IMPL_LOOP_R_5_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i5 + m_offset[d])                 \
   }
 
-#define LOOP_R_7_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {      \
-    LOOP_R_6_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i6 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_7_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
+    KOKKOS_IMPL_LOOP_R_6_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i6 + m_offset[d])                 \
   }
 
-#define LOOP_R_8_REDUX(val, func, type, m_offset, extent, d, ...)         \
-  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {      \
-    LOOP_R_7_REDUX(val, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                   i7 + m_offset[d])                                      \
+#define KOKKOS_IMPL_LOOP_R_8_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
+    KOKKOS_IMPL_LOOP_R_7_REDUX(val, func, type, m_offset, extent, d + 1,      \
+                               __VA_ARGS__, i7 + m_offset[d])                 \
   }
 
 // LayoutLeft
 // d = rank-1 to start
-#define LOOP_L_1_REDUX(val, func, type, m_offset, extent, d, ...)    \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    APPLY_REDUX(val, func, i0 + m_offset[d], __VA_ARGS__)            \
+#define KOKKOS_IMPL_LOOP_L_1_REDUX(val, func, type, m_offset, extent, d, ...) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {          \
+    KOKKOS_IMPL_APPLY_REDUX(val, func, i0 + m_offset[d], __VA_ARGS__)         \
   }
 
-#define LOOP_L_2_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {           \
-    LOOP_L_1_REDUX(val, func, type, m_offset, extent, d - 1, i1 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_2_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
+    KOKKOS_IMPL_LOOP_L_1_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i1 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define LOOP_L_3_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {           \
-    LOOP_L_2_REDUX(val, func, type, m_offset, extent, d - 1, i2 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_3_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
+    KOKKOS_IMPL_LOOP_L_2_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i2 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define LOOP_L_4_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {           \
-    LOOP_L_3_REDUX(val, func, type, m_offset, extent, d - 1, i3 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_4_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
+    KOKKOS_IMPL_LOOP_L_3_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i3 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define LOOP_L_5_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {           \
-    LOOP_L_4_REDUX(val, func, type, m_offset, extent, d - 1, i4 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_5_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
+    KOKKOS_IMPL_LOOP_L_4_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i4 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define LOOP_L_6_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {           \
-    LOOP_L_5_REDUX(val, func, type, m_offset, extent, d - 1, i5 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_6_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
+    KOKKOS_IMPL_LOOP_L_5_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i5 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define LOOP_L_7_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {           \
-    LOOP_L_6_REDUX(val, func, type, m_offset, extent, d - 1, i6 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_7_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
+    KOKKOS_IMPL_LOOP_L_6_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i6 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define LOOP_L_8_REDUX(val, func, type, m_offset, extent, d, ...)              \
-  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {           \
-    LOOP_L_7_REDUX(val, func, type, m_offset, extent, d - 1, i7 + m_offset[d], \
-                   __VA_ARGS__)                                                \
+#define KOKKOS_IMPL_LOOP_L_8_REDUX(val, func, type, m_offset, extent, d, ...) \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
+    KOKKOS_IMPL_LOOP_L_7_REDUX(val, func, type, m_offset, extent, d - 1,      \
+                               i7 + m_offset[d], __VA_ARGS__)                 \
   }
 
 // Left vs Right
-#define LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, extent, rank) \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {          \
-    APPLY_REDUX(val, func, i0 + m_offset[0])                                  \
+#define KOKKOS_IMPL_LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, \
+                                        extent, rank)                       \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                               \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {        \
+    KOKKOS_IMPL_APPLY_REDUX(val, func, i0 + m_offset[0])                    \
   }
 
-#define LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) { \
-      LOOP_L_1_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i1 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_1_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i1 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {        \
-      LOOP_R_1_REDUX(val, func, type, m_offset, extent, 1, i1 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_1_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i1 + m_offset[0])                            \
     }                                                                         \
   }
 
-#define LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) { \
-      LOOP_L_2_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i2 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_2_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i2 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {        \
-      LOOP_R_2_REDUX(val, func, type, m_offset, extent, 1, i2 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_2_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i2 + m_offset[0])                            \
     }                                                                         \
   }
 
-#define LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) { \
-      LOOP_L_3_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i3 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_3_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i3 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {        \
-      LOOP_R_3_REDUX(val, func, type, m_offset, extent, 1, i3 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_3_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i3 + m_offset[0])                            \
     }                                                                         \
   }
 
-#define LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) { \
-      LOOP_L_4_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i4 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_4_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i4 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {        \
-      LOOP_R_4_REDUX(val, func, type, m_offset, extent, 1, i4 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_4_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i4 + m_offset[0])                            \
     }                                                                         \
   }
 
-#define LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) { \
-      LOOP_L_5_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i5 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_5_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i5 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {        \
-      LOOP_R_5_REDUX(val, func, type, m_offset, extent, 1, i5 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_5_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i5 + m_offset[0])                            \
     }                                                                         \
   }
 
-#define LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) { \
-      LOOP_L_6_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i6 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_6_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i6 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {        \
-      LOOP_R_6_REDUX(val, func, type, m_offset, extent, 1, i6 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_6_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i6 + m_offset[0])                            \
     }                                                                         \
   }
 
-#define LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset,   \
+                                        extent, rank)                         \
   if (is_left) {                                                              \
     for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) { \
-      LOOP_L_7_REDUX(val, func, type, m_offset, extent, rank - 2,             \
-                     i7 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_LOOP_L_7_REDUX(val, func, type, m_offset, extent, rank - 2, \
+                                 i7 + m_offset[rank - 1])                     \
     }                                                                         \
   } else {                                                                    \
     for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {        \
-      LOOP_R_7_REDUX(val, func, type, m_offset, extent, 1, i7 + m_offset[0])  \
+      KOKKOS_IMPL_LOOP_R_7_REDUX(val, func, type, m_offset, extent, 1,        \
+                                 i7 + m_offset[0])                            \
     }                                                                         \
   }
 
 // Partial vs Full Tile
-#define TILE_LOOP_1_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_1_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_1_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_2_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_2_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_2_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_3_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_3_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_3_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_4_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_4_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_4_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_5_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_5_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_5_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_6_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_6_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_6_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_7_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_7_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_7_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 
-#define TILE_LOOP_8_REDUX(val, func, type, is_left, cond, m_offset,            \
-                          extent_full, extent_partial, rank)                   \
-  if (cond) {                                                                  \
-    LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset, extent_full, rank) \
-  } else {                                                                     \
-    LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset, extent_partial,    \
-                        rank)                                                  \
+#define KOKKOS_IMPL_TILE_LOOP_8_REDUX(val, func, type, is_left, cond,        \
+                                      m_offset, extent_full, extent_partial, \
+                                      rank)                                  \
+  if (cond) {                                                                \
+    KOKKOS_IMPL_LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_full, rank)                       \
+  } else {                                                                   \
+    KOKKOS_IMPL_LOOP_LAYOUT_8_REDUX(val, func, type, is_left, m_offset,      \
+                                    extent_partial, rank)                    \
   }
 // end New Loop Macros
 
 // tagged macros
-#define TAGGED_APPLY(tag, func, ...) func(tag, __VA_ARGS__);
+#define KOKKOS_IMPL_TAGGED_APPLY(tag, func, ...) func(tag, __VA_ARGS__);
 
 // LayoutRight
 // d = 0 to start
-#define TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, d, ...)   \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    TAGGED_APPLY(tag, func, __VA_ARGS__, i0 + m_offset[d])           \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, d, ...) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                  \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {           \
+    KOKKOS_IMPL_TAGGED_APPLY(tag, func, __VA_ARGS__, i0 + m_offset[d])         \
   }
 
-#define TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {       \
-    TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i1 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, d, ...) \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i1 + m_offset[d])                 \
   }
 
-#define TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {       \
-    TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i2 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, d, ...) \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i2 + m_offset[d])                 \
   }
 
-#define TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {       \
-    TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i3 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, d, ...) \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i3 + m_offset[d])                 \
   }
 
-#define TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {       \
-    TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i4 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, d, ...) \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i4 + m_offset[d])                 \
   }
 
-#define TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {       \
-    TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i5 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, d, ...) \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i5 + m_offset[d])                 \
   }
 
-#define TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {       \
-    TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i6 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, d, ...) \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i6 + m_offset[d])                 \
   }
 
-#define TAGGED_LOOP_R_8(tag, func, type, m_offset, extent, d, ...)         \
-  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {       \
-    TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, d + 1, __VA_ARGS__, \
-                    i7 + m_offset[d])                                      \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_8(tag, func, type, m_offset, extent, d, ...) \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, d + 1,      \
+                                __VA_ARGS__, i7 + m_offset[d])                 \
   }
 
 // LayoutLeft
 // d = rank-1 to start
-#define TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, d, ...)   \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                        \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) { \
-    TAGGED_APPLY(tag, func, i0 + m_offset[d], __VA_ARGS__)           \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, d, ...) \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                  \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {           \
+    KOKKOS_IMPL_TAGGED_APPLY(tag, func, i0 + m_offset[d], __VA_ARGS__)         \
   }
 
-#define TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) { \
-    TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, d - 1,        \
-                    i1 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, d, ...) \
+  for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, d - 1,      \
+                                i1 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) { \
-    TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, d - 1,        \
-                    i2 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, d, ...) \
+  for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, d - 1,      \
+                                i2 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) { \
-    TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, d - 1,        \
-                    i3 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, d, ...) \
+  for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, d - 1,      \
+                                i3 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) { \
-    TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, d - 1,        \
-                    i4 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, d, ...) \
+  for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, d - 1,      \
+                                i4 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) { \
-    TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, d - 1,        \
-                    i5 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, d, ...) \
+  for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, d - 1,      \
+                                i5 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) { \
-    TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, d - 1,        \
-                    i6 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, d, ...) \
+  for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, d - 1,      \
+                                i6 + m_offset[d], __VA_ARGS__)                 \
   }
 
-#define TAGGED_LOOP_L_8(tag, func, type, m_offset, extent, d, ...)   \
-  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) { \
-    TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, d - 1,        \
-                    i7 + m_offset[d], __VA_ARGS__)                   \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_8(tag, func, type, m_offset, extent, d, ...) \
+  for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {           \
+    KOKKOS_IMPL_TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, d - 1,      \
+                                i7 + m_offset[d], __VA_ARGS__)                 \
   }
 
 // Left vs Right
 // TODO: rank not necessary to pass through, can hardcode the values
-#define TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, extent, rank) \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                                  \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {           \
-    TAGGED_APPLY(tag, func, i0 + m_offset[0])                                  \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, \
+                                         extent, rank)                       \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {         \
+    KOKKOS_IMPL_TAGGED_APPLY(tag, func, i0 + m_offset[0])                    \
   }
 
-#define TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) {  \
-      TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, rank - 2,             \
-                      i1 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_1(tag, func, type, m_offset, extent, rank - 2, \
+                                  i1 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {         \
-      TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, 1, i1 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_1(tag, func, type, m_offset, extent, 1,        \
+                                  i1 + m_offset[0])                            \
     }                                                                          \
   }
 
-#define TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) {  \
-      TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, rank - 2,             \
-                      i2 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_2(tag, func, type, m_offset, extent, rank - 2, \
+                                  i2 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {         \
-      TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, 1, i2 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_2(tag, func, type, m_offset, extent, 1,        \
+                                  i2 + m_offset[0])                            \
     }                                                                          \
   }
 
-#define TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) {  \
-      TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, rank - 2,             \
-                      i3 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_3(tag, func, type, m_offset, extent, rank - 2, \
+                                  i3 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {         \
-      TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, 1, i3 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_3(tag, func, type, m_offset, extent, 1,        \
+                                  i3 + m_offset[0])                            \
     }                                                                          \
   }
 
-#define TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) {  \
-      TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, rank - 2,             \
-                      i4 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_4(tag, func, type, m_offset, extent, rank - 2, \
+                                  i4 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {         \
-      TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, 1, i4 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_4(tag, func, type, m_offset, extent, 1,        \
+                                  i4 + m_offset[0])                            \
     }                                                                          \
   }
 
-#define TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) {  \
-      TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, rank - 2,             \
-                      i5 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_5(tag, func, type, m_offset, extent, rank - 2, \
+                                  i5 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {         \
-      TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, 1, i5 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_5(tag, func, type, m_offset, extent, 1,        \
+                                  i5 + m_offset[0])                            \
     }                                                                          \
   }
 
-#define TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) {  \
-      TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, rank - 2,             \
-                      i6 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_6(tag, func, type, m_offset, extent, rank - 2, \
+                                  i6 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {         \
-      TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, 1, i6 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_6(tag, func, type, m_offset, extent, 1,        \
+                                  i6 + m_offset[0])                            \
     }                                                                          \
   }
 
-#define TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset, extent, rank) \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset,   \
+                                         extent, rank)                         \
   if (is_left) {                                                               \
     for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) {  \
-      TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, rank - 2,             \
-                      i7 + m_offset[rank - 1])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_L_7(tag, func, type, m_offset, extent, rank - 2, \
+                                  i7 + m_offset[rank - 1])                     \
     }                                                                          \
   } else {                                                                     \
     for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {         \
-      TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, 1, i7 + m_offset[0])  \
+      KOKKOS_IMPL_TAGGED_LOOP_R_7(tag, func, type, m_offset, extent, 1,        \
+                                  i7 + m_offset[0])                            \
     }                                                                          \
   }
 
 // Partial vs Full Tile
-#define TAGGED_TILE_LOOP_1(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_1(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_2(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_2(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_3(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_3(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_4(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_4(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_5(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_5(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_6(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_6(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_7(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_7(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
-#define TAGGED_TILE_LOOP_8(tag, func, type, is_left, cond, m_offset,         \
-                           extent_full, extent_partial, rank)                \
-  if (cond) {                                                                \
-    TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset, extent_full,    \
-                         rank)                                               \
-  } else {                                                                   \
-    TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset, extent_partial, \
-                         rank)                                               \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_8(tag, func, type, is_left, cond,        \
+                                       m_offset, extent_full, extent_partial, \
+                                       rank)                                  \
+  if (cond) {                                                                 \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset,      \
+                                     extent_full, rank)                       \
+  } else {                                                                    \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8(tag, func, type, is_left, m_offset,      \
+                                     extent_partial, rank)                    \
   }
 
 // parallel_reduce, tagged
 // Reduction version
-#define TAGGED_APPLY_REDUX(val, tag, func, ...) func(tag, __VA_ARGS__, val);
+#define KOKKOS_IMPL_TAGGED_APPLY_REDUX(val, tag, func, ...) \
+  func(tag, __VA_ARGS__, val);
 
 // LayoutRight
 // d = 0 to start
-#define TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {          \
-    TAGGED_APPLY_REDUX(val, tag, func, __VA_ARGS__, i0 + m_offset[d])         \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, \
+                                          extent, d, ...)                 \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                             \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {      \
+    KOKKOS_IMPL_TAGGED_APPLY_REDUX(val, tag, func, __VA_ARGS__,           \
+                                   i0 + m_offset[d])                      \
   }
 
-#define TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i1 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i1 + m_offset[d])   \
   }
 
-#define TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i2 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i2 + m_offset[d])   \
   }
 
-#define TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i3 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i3 + m_offset[d])   \
   }
 
-#define TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i4 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i4 + m_offset[d])   \
   }
 
-#define TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i5 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i5 + m_offset[d])   \
   }
 
-#define TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i6 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i6 + m_offset[d])   \
   }
 
-#define TAGGED_LOOP_R_8_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_R_8_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, d + 1,      \
-                          __VA_ARGS__, i7 + m_offset[d])                      \
+    KOKKOS_IMPL_TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d + 1, __VA_ARGS__, i7 + m_offset[d])   \
   }
 
 // LayoutLeft
 // d = rank-1 to start
-#define TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {          \
-    TAGGED_APPLY_REDUX(val, tag, func, i0 + m_offset[d], __VA_ARGS__)         \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, \
+                                          extent, d, ...)                 \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                             \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[d]); ++i0) {      \
+    KOKKOS_IMPL_TAGGED_APPLY_REDUX(val, tag, func, i0 + m_offset[d],      \
+                                   __VA_ARGS__)                           \
   }
 
-#define TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i1 = (type)0; i1 < static_cast<type>(extent[d]); ++i1) {          \
-    TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i1 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i1 + m_offset[d], __VA_ARGS__)   \
   }
 
-#define TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i2 = (type)0; i2 < static_cast<type>(extent[d]); ++i2) {          \
-    TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i2 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i2 + m_offset[d], __VA_ARGS__)   \
   }
 
-#define TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i3 = (type)0; i3 < static_cast<type>(extent[d]); ++i3) {          \
-    TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i3 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i3 + m_offset[d], __VA_ARGS__)   \
   }
 
-#define TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i4 = (type)0; i4 < static_cast<type>(extent[d]); ++i4) {          \
-    TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i4 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i4 + m_offset[d], __VA_ARGS__)   \
   }
 
-#define TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i5 = (type)0; i5 < static_cast<type>(extent[d]); ++i5) {          \
-    TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i5 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i5 + m_offset[d], __VA_ARGS__)   \
   }
 
-#define TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i6 = (type)0; i6 < static_cast<type>(extent[d]); ++i6) {          \
-    TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i6 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i6 + m_offset[d], __VA_ARGS__)   \
   }
 
-#define TAGGED_LOOP_L_8_REDUX(val, tag, func, type, m_offset, extent, d, ...) \
+#define KOKKOS_IMPL_TAGGED_LOOP_L_8_REDUX(val, tag, func, type, m_offset,     \
+                                          extent, d, ...)                     \
   for (type i7 = (type)0; i7 < static_cast<type>(extent[d]); ++i7) {          \
-    TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, d - 1,      \
-                          i7 + m_offset[d], __VA_ARGS__)                      \
+    KOKKOS_IMPL_TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, \
+                                      d - 1, i7 + m_offset[d], __VA_ARGS__)   \
   }
 
 // Left vs Right
-#define TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, m_offset, \
-                                   extent, rank)                            \
-  KOKKOS_ENABLE_IVDEP_MDRANGE                                               \
-  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {        \
-    TAGGED_APPLY_REDUX(val, tag, func, i0 + m_offset[0])                    \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
+  KOKKOS_ENABLE_IVDEP_MDRANGE                                                 \
+  for (type i0 = (type)0; i0 < static_cast<type>(extent[0]); ++i0) {          \
+    KOKKOS_IMPL_TAGGED_APPLY_REDUX(val, tag, func, i0 + m_offset[0])          \
   }
 
-#define TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i1 = (type)0; i1 < static_cast<type>(extent[rank - 1]); ++i1) { \
-      TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i1 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_1_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i1 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i1 = (type)0; i1 < static_cast<type>(extent[0]); ++i1) {        \
-      TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i1 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_1_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i1 + m_offset[0])          \
     }                                                                         \
   }
 
-#define TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i2 = (type)0; i2 < static_cast<type>(extent[rank - 1]); ++i2) { \
-      TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i2 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_2_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i2 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i2 = (type)0; i2 < static_cast<type>(extent[0]); ++i2) {        \
-      TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i2 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_2_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i2 + m_offset[0])          \
     }                                                                         \
   }
 
-#define TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i3 = (type)0; i3 < static_cast<type>(extent[rank - 1]); ++i3) { \
-      TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i3 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_3_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i3 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i3 = (type)0; i3 < static_cast<type>(extent[0]); ++i3) {        \
-      TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i3 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_3_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i3 + m_offset[0])          \
     }                                                                         \
   }
 
-#define TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i4 = (type)0; i4 < static_cast<type>(extent[rank - 1]); ++i4) { \
-      TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i4 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_4_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i4 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i4 = (type)0; i4 < static_cast<type>(extent[0]); ++i4) {        \
-      TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i4 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_4_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i4 + m_offset[0])          \
     }                                                                         \
   }
 
-#define TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i5 = (type)0; i5 < static_cast<type>(extent[rank - 1]); ++i5) { \
-      TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i5 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_5_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i5 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i5 = (type)0; i5 < static_cast<type>(extent[0]); ++i5) {        \
-      TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i5 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_5_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i5 + m_offset[0])          \
     }                                                                         \
   }
 
-#define TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i6 = (type)0; i6 < static_cast<type>(extent[rank - 1]); ++i6) { \
-      TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i6 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_6_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i6 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i6 = (type)0; i6 < static_cast<type>(extent[0]); ++i6) {        \
-      TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i6 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_6_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i6 + m_offset[0])          \
     }                                                                         \
   }
 
-#define TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, m_offset,   \
-                                   extent, rank)                              \
+#define KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, \
+                                               m_offset, extent, rank)        \
   if (is_left) {                                                              \
     for (type i7 = (type)0; i7 < static_cast<type>(extent[rank - 1]); ++i7) { \
-      TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset, extent, rank - 2, \
-                            i7 + m_offset[rank - 1])                          \
+      KOKKOS_IMPL_TAGGED_LOOP_L_7_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, rank - 2,                     \
+                                        i7 + m_offset[rank - 1])              \
     }                                                                         \
   } else {                                                                    \
     for (type i7 = (type)0; i7 < static_cast<type>(extent[0]); ++i7) {        \
-      TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset, extent, 1,        \
-                            i7 + m_offset[0])                                 \
+      KOKKOS_IMPL_TAGGED_LOOP_R_7_REDUX(val, tag, func, type, m_offset,       \
+                                        extent, 1, i7 + m_offset[0])          \
     }                                                                         \
   }
 
 // Partial vs Full Tile
-#define TAGGED_TILE_LOOP_1_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_2_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_3_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_4_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_5_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_6_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_7_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
-  }
-
-#define TAGGED_TILE_LOOP_8_REDUX(val, tag, func, type, is_left, cond,         \
-                                 m_offset, extent_full, extent_partial, rank) \
-  if (cond) {                                                                 \
-    TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_full, rank)                             \
-  } else {                                                                    \
-    TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left, m_offset,       \
-                               extent_partial, rank)                          \
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_1_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_2_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_3_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_4_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_5_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_6_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_7_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
+  }
+
+#define KOKKOS_IMPL_TAGGED_TILE_LOOP_8_REDUX(val, tag, func, type, is_left, \
+                                             cond, m_offset, extent_full,   \
+                                             extent_partial, rank)          \
+  if (cond) {                                                               \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_full, rank)     \
+  } else {                                                                  \
+    KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8_REDUX(val, tag, func, type, is_left,   \
+                                           m_offset, extent_partial, rank)  \
   }
 
 // end tagged macros
@@ -1212,14 +1323,15 @@ struct Tile_Loop_Type<1, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_1(func, IType, IsLeft, cond, offset, a, b, 1);
+    KOKKOS_IMPL_TILE_LOOP_1(func, IType, IsLeft, cond, offset, a, b, 1);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_1_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 1);
+    KOKKOS_IMPL_TILE_LOOP_1_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 1);
   }
 };
 
@@ -1228,14 +1340,15 @@ struct Tile_Loop_Type<2, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_2(func, IType, IsLeft, cond, offset, a, b, 2);
+    KOKKOS_IMPL_TILE_LOOP_2(func, IType, IsLeft, cond, offset, a, b, 2);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_2_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 2);
+    KOKKOS_IMPL_TILE_LOOP_2_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 2);
   }
 };
 
@@ -1244,14 +1357,15 @@ struct Tile_Loop_Type<3, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_3(func, IType, IsLeft, cond, offset, a, b, 3);
+    KOKKOS_IMPL_TILE_LOOP_3(func, IType, IsLeft, cond, offset, a, b, 3);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_3_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 3);
+    KOKKOS_IMPL_TILE_LOOP_3_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 3);
   }
 };
 
@@ -1260,14 +1374,15 @@ struct Tile_Loop_Type<4, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_4(func, IType, IsLeft, cond, offset, a, b, 4);
+    KOKKOS_IMPL_TILE_LOOP_4(func, IType, IsLeft, cond, offset, a, b, 4);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_4_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 4);
+    KOKKOS_IMPL_TILE_LOOP_4_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 4);
   }
 };
 
@@ -1276,14 +1391,15 @@ struct Tile_Loop_Type<5, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_5(func, IType, IsLeft, cond, offset, a, b, 5);
+    KOKKOS_IMPL_TILE_LOOP_5(func, IType, IsLeft, cond, offset, a, b, 5);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_5_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 5);
+    KOKKOS_IMPL_TILE_LOOP_5_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 5);
   }
 };
 
@@ -1292,14 +1408,15 @@ struct Tile_Loop_Type<6, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_6(func, IType, IsLeft, cond, offset, a, b, 6);
+    KOKKOS_IMPL_TILE_LOOP_6(func, IType, IsLeft, cond, offset, a, b, 6);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_6_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 6);
+    KOKKOS_IMPL_TILE_LOOP_6_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 6);
   }
 };
 
@@ -1308,14 +1425,15 @@ struct Tile_Loop_Type<7, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_7(func, IType, IsLeft, cond, offset, a, b, 7);
+    KOKKOS_IMPL_TILE_LOOP_7(func, IType, IsLeft, cond, offset, a, b, 7);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_7_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 7);
+    KOKKOS_IMPL_TILE_LOOP_7_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 7);
   }
 };
 
@@ -1324,14 +1442,15 @@ struct Tile_Loop_Type<8, IsLeft, IType, void, void> {
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_8(func, IType, IsLeft, cond, offset, a, b, 8);
+    KOKKOS_IMPL_TILE_LOOP_8(func, IType, IsLeft, cond, offset, a, b, 8);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TILE_LOOP_8_REDUX(value, func, IType, IsLeft, cond, offset, a, b, 8);
+    KOKKOS_IMPL_TILE_LOOP_8_REDUX(value, func, IType, IsLeft, cond, offset, a,
+                                  b, 8);
   }
 };
 
@@ -1343,15 +1462,16 @@ struct Tile_Loop_Type<1, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_1(Tagged(), func, IType, IsLeft, cond, offset, a, b, 1);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_1(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 1);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_1_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 1);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_1_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 1);
   }
 };
 
@@ -1361,15 +1481,16 @@ struct Tile_Loop_Type<2, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_2(Tagged(), func, IType, IsLeft, cond, offset, a, b, 2);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_2(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 2);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_2_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 2);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_2_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 2);
   }
 };
 
@@ -1379,15 +1500,16 @@ struct Tile_Loop_Type<3, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_3(Tagged(), func, IType, IsLeft, cond, offset, a, b, 3);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_3(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 3);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_3_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 3);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_3_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 3);
   }
 };
 
@@ -1397,15 +1519,16 @@ struct Tile_Loop_Type<4, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_4(Tagged(), func, IType, IsLeft, cond, offset, a, b, 4);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_4(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 4);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_4_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 4);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_4_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 4);
   }
 };
 
@@ -1415,15 +1538,16 @@ struct Tile_Loop_Type<5, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_5(Tagged(), func, IType, IsLeft, cond, offset, a, b, 5);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_5(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 5);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_5_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 5);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_5_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 5);
   }
 };
 
@@ -1433,15 +1557,16 @@ struct Tile_Loop_Type<6, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_6(Tagged(), func, IType, IsLeft, cond, offset, a, b, 6);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_6(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 6);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_6_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 6);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_6_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 6);
   }
 };
 
@@ -1451,15 +1576,16 @@ struct Tile_Loop_Type<7, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_7(Tagged(), func, IType, IsLeft, cond, offset, a, b, 7);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_7(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 7);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_7_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 7);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_7_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 7);
   }
 };
 
@@ -1469,15 +1595,16 @@ struct Tile_Loop_Type<8, IsLeft, IType, Tagged,
   template <typename Func, typename Offset, typename ExtentA, typename ExtentB>
   static void apply(Func const& func, bool cond, Offset const& offset,
                     ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_8(Tagged(), func, IType, IsLeft, cond, offset, a, b, 8);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_8(Tagged(), func, IType, IsLeft, cond, offset,
+                                   a, b, 8);
   }
 
   template <typename ValType, typename Func, typename Offset, typename ExtentA,
             typename ExtentB>
   static void apply(ValType& value, Func const& func, bool cond,
                     Offset const& offset, ExtentA const& a, ExtentB const& b) {
-    TAGGED_TILE_LOOP_8_REDUX(value, Tagged(), func, IType, IsLeft, cond, offset,
-                             a, b, 8);
+    KOKKOS_IMPL_TAGGED_TILE_LOOP_8_REDUX(value, Tagged(), func, IType, IsLeft,
+                                         cond, offset, a, b, 8);
   }
 };
 // end Structs for calling loops
@@ -1589,19 +1716,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
         //      #pragma simd
-        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
         //      #pragma simd
-        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
     }  // end Iterate::Right
 
@@ -1633,19 +1760,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
         //      #pragma simd
-        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
         //      #pragma simd
-        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
     }  // end Iterate::Right
 
@@ -1677,19 +1804,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
         //      #pragma simd
-        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
         //      #pragma simd
-        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
     }  // end Iterate::Right
 
@@ -1721,19 +1848,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
         //      #pragma simd
-        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
         //      #pragma simd
-        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
     }  // end Iterate::Right
 
@@ -1765,19 +1892,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
         //      #pragma simd
-        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
         //      #pragma simd
-        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
     }  // end Iterate::Right
 
@@ -1809,19 +1936,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
         //      #pragma simd
-        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
         //      #pragma simd
-        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
     }  // end Iterate::Right
 
@@ -1853,19 +1980,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
         //      #pragma simd
-        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
         //      #pragma simd
-        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
     }  // end Iterate::Right
 
@@ -1966,8 +2093,8 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     const bool full_tile = check_iteration_bounds(m_tiledims, m_offset);
 
     Tile_Loop_Type<RP::rank, (RP::inner_direction == Iterate::Left), index_type,
-                   Tag>::apply(val, m_func, full_tile, m_offset, m_rp.m_tile,
-                               m_tiledims);
+                   Tag>::apply(val, m_func.get_functor(), full_tile, m_offset,
+                               m_rp.m_tile, m_tiledims);
   }
 
 #else
@@ -2004,19 +2131,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
         //      #pragma simd
-        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
         //      #pragma simd
-        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
     }  // end Iterate::Right
 
@@ -2048,19 +2175,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
         //      #pragma simd
-        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
         //      #pragma simd
-        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
     }  // end Iterate::Right
 
@@ -2092,19 +2219,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
         //      #pragma simd
-        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
         //      #pragma simd
-        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
     }  // end Iterate::Right
 
@@ -2136,19 +2263,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
         //      #pragma simd
-        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
         //      #pragma simd
-        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
     }  // end Iterate::Right
 
@@ -2180,19 +2307,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
         //      #pragma simd
-        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
         //      #pragma simd
-        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
     }  // end Iterate::Right
 
@@ -2224,19 +2351,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
         //      #pragma simd
-        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
         //      #pragma simd
-        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
     }  // end Iterate::Right
 
@@ -2268,19 +2395,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
         //      #pragma simd
-        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
         //      #pragma simd
-        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
     }  // end Iterate::Right
 
@@ -2417,19 +2544,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
         //      #pragma simd
-        LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2L(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       } else {
         //      #pragma simd
-        LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
+        KOKKOS_IMPL_LOOP_2R(index_type, m_tiledims) { apply(LOOP_ARGS_2); }
       }
     }  // end Iterate::Right
 
@@ -2461,19 +2588,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
         //      #pragma simd
-        LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3L(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       } else {
         //      #pragma simd
-        LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
+        KOKKOS_IMPL_LOOP_3R(index_type, m_tiledims) { apply(LOOP_ARGS_3); }
       }
     }  // end Iterate::Right
 
@@ -2505,19 +2632,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
         //      #pragma simd
-        LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4L(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       } else {
         //      #pragma simd
-        LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
+        KOKKOS_IMPL_LOOP_4R(index_type, m_tiledims) { apply(LOOP_ARGS_4); }
       }
     }  // end Iterate::Right
 
@@ -2549,19 +2676,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
         //      #pragma simd
-        LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5L(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       } else {
         //      #pragma simd
-        LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
+        KOKKOS_IMPL_LOOP_5R(index_type, m_tiledims) { apply(LOOP_ARGS_5); }
       }
     }  // end Iterate::Right
 
@@ -2593,19 +2720,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
         //      #pragma simd
-        LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6L(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       } else {
         //      #pragma simd
-        LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
+        KOKKOS_IMPL_LOOP_6R(index_type, m_tiledims) { apply(LOOP_ARGS_6); }
       }
     }  // end Iterate::Right
 
@@ -2637,19 +2764,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
         //      #pragma simd
-        LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7L(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       } else {
         //      #pragma simd
-        LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
+        KOKKOS_IMPL_LOOP_7R(index_type, m_tiledims) { apply(LOOP_ARGS_7); }
       }
     }  // end Iterate::Right
 
@@ -2681,19 +2808,19 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
     if (RP::inner_direction == Iterate::Left) {
       if (full_tile) {
         //      #pragma simd
-        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
         //      #pragma simd
-        LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8L(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
     }  // end Iterate::Left
     else {
       if (full_tile) {
         //      #pragma simd
-        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       } else {
         //      #pragma simd
-        LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
+        KOKKOS_IMPL_LOOP_8R(index_type, m_tiledims) { apply(LOOP_ARGS_8); }
       }
     }  // end Iterate::Right
 
@@ -2721,6 +2848,162 @@ struct HostIterateTile<RP, Functor, Tag, ValueType,
 // ------------------------------------------------------------------ //
 
 #undef KOKKOS_ENABLE_NEW_LOOP_MACROS
+#undef KOKKOS_IMPL_LOOP_1L
+#undef KOKKOS_IMPL_LOOP_2L
+#undef KOKKOS_IMPL_LOOP_3L
+#undef KOKKOS_IMPL_LOOP_4L
+#undef KOKKOS_IMPL_LOOP_5L
+#undef KOKKOS_IMPL_LOOP_6L
+#undef KOKKOS_IMPL_LOOP_7L
+#undef KOKKOS_IMPL_LOOP_8L
+#undef KOKKOS_IMPL_LOOP_1R
+#undef KOKKOS_IMPL_LOOP_2R
+#undef KOKKOS_IMPL_LOOP_3R
+#undef KOKKOS_IMPL_LOOP_4R
+#undef KOKKOS_IMPL_LOOP_5R
+#undef KOKKOS_IMPL_LOOP_6R
+#undef KOKKOS_IMPL_LOOP_7R
+#undef KOKKOS_IMPL_LOOP_8R
+#undef KOKKOS_IMPL_LOOP_ARGS_1
+#undef KOKKOS_IMPL_LOOP_ARGS_2
+#undef KOKKOS_IMPL_LOOP_ARGS_3
+#undef KOKKOS_IMPL_LOOP_ARGS_4
+#undef KOKKOS_IMPL_LOOP_ARGS_5
+#undef KOKKOS_IMPL_LOOP_ARGS_6
+#undef KOKKOS_IMPL_LOOP_ARGS_7
+#undef KOKKOS_IMPL_LOOP_ARGS_8
+#undef KOKKOS_IMPL_APPLY
+#undef KOKKOS_IMPL_LOOP_R_1
+#undef KOKKOS_IMPL_LOOP_R_2
+#undef KOKKOS_IMPL_LOOP_R_3
+#undef KOKKOS_IMPL_LOOP_R_4
+#undef KOKKOS_IMPL_LOOP_R_5
+#undef KOKKOS_IMPL_LOOP_R_6
+#undef KOKKOS_IMPL_LOOP_R_7
+#undef KOKKOS_IMPL_LOOP_R_8
+#undef KOKKOS_IMPL_LOOP_L_1
+#undef KOKKOS_IMPL_LOOP_L_2
+#undef KOKKOS_IMPL_LOOP_L_3
+#undef KOKKOS_IMPL_LOOP_L_4
+#undef KOKKOS_IMPL_LOOP_L_5
+#undef KOKKOS_IMPL_LOOP_L_6
+#undef KOKKOS_IMPL_LOOP_L_7
+#undef KOKKOS_IMPL_LOOP_L_8
+#undef KOKKOS_IMPL_LOOP_LAYOUT_1
+#undef KOKKOS_IMPL_LOOP_LAYOUT_2
+#undef KOKKOS_IMPL_LOOP_LAYOUT_3
+#undef KOKKOS_IMPL_LOOP_LAYOUT_4
+#undef KOKKOS_IMPL_LOOP_LAYOUT_5
+#undef KOKKOS_IMPL_LOOP_LAYOUT_6
+#undef KOKKOS_IMPL_LOOP_LAYOUT_7
+#undef KOKKOS_IMPL_LOOP_LAYOUT_8
+#undef KOKKOS_IMPL_TILE_LOOP_1
+#undef KOKKOS_IMPL_TILE_LOOP_2
+#undef KOKKOS_IMPL_TILE_LOOP_3
+#undef KOKKOS_IMPL_TILE_LOOP_4
+#undef KOKKOS_IMPL_TILE_LOOP_5
+#undef KOKKOS_IMPL_TILE_LOOP_6
+#undef KOKKOS_IMPL_TILE_LOOP_7
+#undef KOKKOS_IMPL_TILE_LOOP_8
+#undef KOKKOS_IMPL_APPLY_REDUX
+#undef KOKKOS_IMPL_LOOP_R_1_REDUX
+#undef KOKKOS_IMPL_LOOP_R_2_REDUX
+#undef KOKKOS_IMPL_LOOP_R_3_REDUX
+#undef KOKKOS_IMPL_LOOP_R_4_REDUX
+#undef KOKKOS_IMPL_LOOP_R_5_REDUX
+#undef KOKKOS_IMPL_LOOP_R_6_REDUX
+#undef KOKKOS_IMPL_LOOP_R_7_REDUX
+#undef KOKKOS_IMPL_LOOP_R_8_REDUX
+#undef KOKKOS_IMPL_LOOP_L_1_REDUX
+#undef KOKKOS_IMPL_LOOP_L_2_REDUX
+#undef KOKKOS_IMPL_LOOP_L_3_REDUX
+#undef KOKKOS_IMPL_LOOP_L_4_REDUX
+#undef KOKKOS_IMPL_LOOP_L_5_REDUX
+#undef KOKKOS_IMPL_LOOP_L_6_REDUX
+#undef KOKKOS_IMPL_LOOP_L_7_REDUX
+#undef KOKKOS_IMPL_LOOP_L_8_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_1_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_2_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_3_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_4_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_5_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_6_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_7_REDUX
+#undef KOKKOS_IMPL_LOOP_LAYOUT_8_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_1_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_2_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_3_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_4_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_5_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_6_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_7_REDUX
+#undef KOKKOS_IMPL_TILE_LOOP_8_REDUX
+#undef KOKKOS_IMPL_TAGGED_APPLY
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_1
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_2
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_3
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_4
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_5
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_6
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_7
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_8
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_1
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_2
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_3
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_4
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_5
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_6
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_7
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_8
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_1
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_2
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_3
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_4
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_5
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_6
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_7
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_8
+#undef KOKKOS_IMPL_TAGGED_APPLY_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_1_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_2_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_3_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_4_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_5_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_6_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_7_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_R_8_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_1_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_2_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_3_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_4_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_5_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_6_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_7_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_L_8_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_1_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_2_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_3_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_4_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_5_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_6_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_7_REDUX
+#undef KOKKOS_IMPL_TAGGED_LOOP_LAYOUT_8_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_1_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_2_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_3_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_4_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_5_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_6_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_7_REDUX
+#undef KOKKOS_IMPL_TAGGED_TILE_LOOP_8_REDUX
 
 }  // namespace Impl
 }  // namespace Kokkos
diff --git a/core/src/impl/Kokkos_Atomic_Assembly.hpp b/core/src/impl/Kokkos_Atomic_Assembly.hpp
deleted file mode 100644
index 59d70e7f7c..0000000000
--- a/core/src/impl/Kokkos_Atomic_Assembly.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_ASSEMBLY_HPP)
-#define KOKKOS_ATOMIC_ASSEMBLY_HPP
-namespace Kokkos {
-
-namespace Impl {
-
-#if !defined(_WIN32)
-struct cas128_t {
-  uint64_t lower;
-  uint64_t upper;
-
-  KOKKOS_INLINE_FUNCTION
-  cas128_t() {
-    lower = 0;
-    upper = 0;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  cas128_t(const cas128_t& a) {
-    lower = a.lower;
-    upper = a.upper;
-  }
-  KOKKOS_INLINE_FUNCTION
-  cas128_t(volatile cas128_t* a) {
-    lower = a->lower;
-    upper = a->upper;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  bool operator!=(const cas128_t& a) const {
-    return (lower != a.lower) || upper != a.upper;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const cas128_t& a) {
-    lower = a.lower;
-    upper = a.upper;
-  }
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const cas128_t& a) volatile {
-    lower = a.lower;
-    upper = a.upper;
-  }
-} __attribute__((__aligned__(16)));
-#endif
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-inline cas128_t cas128(volatile cas128_t* ptr, cas128_t cmp, cas128_t swap) {
-  bool swapped = false;
-  __asm__ __volatile__(
-      "lock cmpxchg16b %1\n\t"
-      "setz %0"
-      : "=q"(swapped), "+m"(*ptr), "+d"(cmp.upper), "+a"(cmp.lower)
-      : "c"(swap.upper), "b"(swap.lower), "q"(swapped));
-  return cmp;
-}
-#endif
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp b/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp
deleted file mode 100644
index 08091ab9ce..0000000000
--- a/core/src/impl/Kokkos_Atomic_Compare_Exchange_Strong.hpp
+++ /dev/null
@@ -1,409 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && \
-    !defined(KOKKOS_ATOMIC_COMPARE_EXCHANGE_STRONG_HPP)
-#define KOKKOS_ATOMIC_COMPARE_EXCHANGE_STRONG_HPP
-
-#include <impl/Kokkos_Atomic_Memory_Order.hpp>
-#include <impl/Kokkos_Memory_Fence.hpp>
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp>
-#endif
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-// Cuda native CAS supports int, unsigned int, and unsigned long long int
-// (non-standard type). Must cast-away 'volatile' for the CAS call.
-
-#if defined(KOKKOS_ENABLE_CUDA)
-
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-__inline__ __device__ int atomic_compare_exchange(volatile int* const dest,
-                                                  const int compare,
-                                                  const int val) {
-  return atomicCAS((int*)dest, compare, val);
-}
-
-__inline__ __device__ unsigned int atomic_compare_exchange(
-    volatile unsigned int* const dest, const unsigned int compare,
-    const unsigned int val) {
-  return atomicCAS((unsigned int*)dest, compare, val);
-}
-
-__inline__ __device__ unsigned long long int atomic_compare_exchange(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int compare, const unsigned long long int val) {
-  return atomicCAS((unsigned long long int*)dest, compare, val);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T&> val) {
-  const int tmp = atomicCAS((int*)dest, *((int*)&compare), *((int*)&val));
-  return *((T*)&tmp);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T&>
-        val) {
-  using type     = unsigned long long int;
-  const type tmp = atomicCAS((type*)dest, *((type*)&compare), *((type*)&val));
-  return *((T*)&tmp);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8), const T>& val) {
-  T return_val;
-  // This is a way to (hopefully) avoid dead lock in a warp
-  int done                 = 0;
-  unsigned int mask        = __activemask();
-  unsigned int active      = __ballot_sync(mask, 1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_cuda_space((void*)dest)) {
-        Kokkos::memory_fence();
-        return_val = *dest;
-        if (return_val == compare) *dest = val;
-        Kokkos::memory_fence();
-        Impl::unlock_address_cuda_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot_sync(mask, done);
-  }
-  return return_val;
-}
-#endif
-#endif
-
-//----------------------------------------------------------------------------
-// GCC native CAS supports int, long, unsigned int, unsigned long.
-// Intel native CAS support int and long with the same interface as GCC.
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
-// atomic_compare_exchange are already defined in Kokkos_Atomic_Windows.hpp
-#elif defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-inline int atomic_compare_exchange(volatile int* const dest, const int compare,
-                                   const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-inline long atomic_compare_exchange(volatile long* const dest,
-                                    const long compare, const long val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
-
-// GCC supports unsigned
-
-inline unsigned int atomic_compare_exchange(volatile unsigned int* const dest,
-                                            const unsigned int compare,
-                                            const unsigned int val) {
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-inline unsigned long atomic_compare_exchange(volatile unsigned long* const dest,
-                                             const unsigned long compare,
-                                             const unsigned long val) {
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-inline unsigned long long atomic_compare_exchange(
-    volatile unsigned long long* const dest, const unsigned long long compare,
-    const unsigned long long val) {
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-#endif
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T&> val) {
-  union U {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  tmp.i =
-      __sync_val_compare_and_swap((int*)dest, *((int*)&compare), *((int*)&val));
-  return tmp.t;
-}
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(long),
-                     const T&>
-        val) {
-  union U {
-    long i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  tmp.i = __sync_val_compare_and_swap((long*)dest, *((long*)&compare),
-                                      *((long*)&val));
-  return tmp.t;
-}
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long) &&
-                         sizeof(T) == sizeof(Impl::cas128_t),
-                     const T&>
-        val) {
-  union U {
-    Impl::cas128_t i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  tmp.i = Impl::cas128((Impl::cas128_t*)dest, *((Impl::cas128_t*)&compare),
-                       *((Impl::cas128_t*)&val));
-  return tmp.t;
-}
-#endif
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T compare,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8)
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-                         && (sizeof(T) != 16)
-#endif
-                         ,
-                     const T>& val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = *dest;
-  if (return_val == compare) {
-    // Don't use the following line of code here:
-    //
-    // const T tmp = *dest = val;
-    //
-    // Instead, put each assignment in its own statement.  This is
-    // because the overload of T::operator= for volatile *this should
-    // return void, not volatile T&.  See Kokkos #177:
-    //
-    // https://github.com/kokkos/kokkos/issues/177
-    *dest       = val;
-    const T tmp = *dest;
-#ifndef KOKKOS_COMPILER_CLANG
-    (void)tmp;
-#endif
-    Kokkos::memory_fence();
-  }
-  Impl::unlock_address_host_space((void*)dest);
-  return return_val;
-}
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest,
-                                                 const T compare, const T val) {
-  T retval;
-#pragma omp critical
-  {
-    retval = dest[0];
-    if (retval == compare) dest[0] = val;
-  }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest_v,
-                                                 const T compare, const T val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  if (retval == compare) *dest = val;
-  return retval;
-}
-
-#endif
-#endif
-
-// dummy for non-CUDA Kokkos headers being processed by NVCC
-#if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template <typename T>
-__inline__ __device__ T atomic_compare_exchange(
-    volatile T* const, const Kokkos::Impl::type_identity_t<T>,
-    const Kokkos::Impl::type_identity_t<T>) {
-  return T();
-}
-#endif
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION bool atomic_compare_exchange_strong(
-    volatile T* const dest, const T compare, const T val) {
-  return compare == atomic_compare_exchange(dest, compare, val);
-}
-//----------------------------------------------------------------------------
-
-namespace Impl {
-// memory-ordered versions are in the Impl namespace
-
-template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
-    T* dest, T compare, T val, memory_order_seq_cst_t, MemoryOrderFailure) {
-  Kokkos::memory_fence();
-  auto rv = Kokkos::atomic_compare_exchange_strong(dest, compare, val);
-  Kokkos::memory_fence();
-  return rv;
-}
-
-template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
-    T* dest, T compare, T val, memory_order_acquire_t, MemoryOrderFailure) {
-  auto rv = Kokkos::atomic_compare_exchange_strong(dest, compare, val);
-  Kokkos::memory_fence();
-  return rv;
-}
-
-template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
-    T* dest, T compare, T val, memory_order_release_t, MemoryOrderFailure) {
-  Kokkos::memory_fence();
-  return Kokkos::atomic_compare_exchange_strong(dest, compare, val);
-}
-
-template <class T, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong_fallback(
-    T* dest, T compare, T val, memory_order_relaxed_t, MemoryOrderFailure) {
-  return Kokkos::atomic_compare_exchange_strong(dest, compare, val);
-}
-
-#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) ||   \
-    (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-
-#if defined(__CUDA_ARCH__)
-#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
-#else
-#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
-#endif
-
-template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH bool _atomic_compare_exchange_strong(
-    T* dest, T compare, T val, MemoryOrderSuccess, MemoryOrderFailure,
-    std::enable_if_t<
-        (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8 ||
-         sizeof(T) == 16) &&
-            std::is_same<typename MemoryOrderSuccess::memory_order,
-                         std::remove_cv_t<MemoryOrderSuccess>>::value &&
-            std::is_same<typename MemoryOrderFailure::memory_order,
-                         std::remove_cv_t<MemoryOrderFailure>>::value,
-        void const**> = nullptr) {
-  return __atomic_compare_exchange_n(dest, &compare, val, /* weak = */ false,
-                                     MemoryOrderSuccess::gnu_constant,
-                                     MemoryOrderFailure::gnu_constant);
-}
-
-template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH bool _atomic_compare_exchange_strong(
-    T* dest, T compare, T val, MemoryOrderSuccess order_success,
-    MemoryOrderFailure order_failure,
-    std::enable_if_t<
-        !(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-          sizeof(T) == 8 || sizeof(T) == 16) &&
-            std::is_same<typename MemoryOrderSuccess::memory_order,
-                         std::remove_cv_t<MemoryOrderSuccess>>::value &&
-            std::is_same<typename MemoryOrderFailure::memory_order,
-                         std::remove_cv_t<MemoryOrderFailure>>::value,
-        void const**> = nullptr) {
-  return _atomic_compare_exchange_fallback(dest, compare, val, order_success,
-                                           order_failure);
-}
-
-#else
-
-template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_INLINE_FUNCTION bool _atomic_compare_exchange_strong(
-    T* dest, T compare, T val, MemoryOrderSuccess order_success,
-    MemoryOrderFailure order_failure) {
-  return _atomic_compare_exchange_strong_fallback(dest, compare, val,
-                                                  order_success, order_failure);
-}
-
-#endif
-
-// TODO static asserts in overloads that don't make sense (as listed in
-// https://gcc.gnu.org/onlinedocs/gcc-5.2.0/gcc/_005f_005fatomic-Builtins.html)
-template <class T, class MemoryOrderSuccess, class MemoryOrderFailure>
-KOKKOS_FORCEINLINE_FUNCTION bool atomic_compare_exchange_strong(
-    T* dest, T compare, T val, MemoryOrderSuccess order_success,
-    MemoryOrderFailure order_failure) {
-  return _atomic_compare_exchange_strong(dest, compare, val, order_success,
-                                         order_failure);
-}
-
-}  // end namespace Impl
-
-}  // namespace Kokkos
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp>
-#endif
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp b/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp
deleted file mode 100644
index 8849277836..0000000000
--- a/core/src/impl/Kokkos_Atomic_Compare_Exchange_Weak.hpp
+++ /dev/null
@@ -1,380 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#include <Kokkos_Atomic.hpp>
-#ifndef KOKKOS_ATOMIC_COMPARE_EXCHANGE_WEAK_HPP
-#define KOKKOS_ATOMIC_COMPARE_EXCHANGE_WEAK_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-// Cuda sm_70 or greater supports C++-like semantics directly
-
-#if defined(KOKKOS_ENABLE_CUDA)
-
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-#if __CUDA_ARCH__ >= 700
-// See: https://github.com/ogiroux/freestanding
-#define kokkos_cuda_internal_cas_release_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.release.sys.b32 %0, [%1], %2, %3;"              \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define kokkos_cuda_internal_cas_acquire_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.acquire.sys.b32 %0, [%1], %2, %3;"              \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define kokkos_cuda_internal_cas_acq_rel_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.acq_rel.sys.b32 %0, [%1], %2, %3;"              \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define kokkos_cuda_internal_cas_relaxed_32(ptr, old, expected, desired) \
-  asm volatile("atom.cas.relaxed.sys.b32 %0, [%1], %2, %3;"              \
-               : "=r"(old)                                               \
-               : "l"(ptr), "r"(expected), "r"(desired)                   \
-               : "memory")
-#define kokkos_cuda_internal_fence_seq_cst() \
-  asm volatile("fence.sc.sys;" : : : "memory")
-#define kokkos_cuda_internal_fence_acq_rel() \
-  asm volatile("fence.acq_rel.sys;" : : : "memory")
-#else
-#define kokkos_cuda_internal_fence_acq_rel() \
-  asm volatile("membar.sys;" : : : "memory")
-#define kokkos_cuda_internal_fence_seq_cst() \
-  asm volatile("membar.sys;" : : : "memory")
-#endif
-
-// 32-bit version
-template <class T, std::enable_if_t<sizeof(T) == 4, int> = 0>
-__inline__ __device__ bool atomic_compare_exchange_weak(
-    T volatile* const dest, T* const expected, T const desired,
-    std::memory_order success_order = std::memory_order_seq_cst,
-    std::memory_order failure_order = std::memory_order_seq_cst) {
-  // TODO assert that success_order >= failure_order
-  // See: https://github.com/ogiroux/freestanding
-  int32_t tmp = 0;
-  int32_t old = 0;
-  memcpy(&tmp, &desired, sizeof(T));
-  memcpy(&old, expected, sizeof(T));
-  int32_t old_tmp = old;
-#if __CUDA_ARCH__ >= 700
-  switch (success_order) {
-    case std::memory_order_seq_cst:
-      // sequentially consistent is just an acquire with a seq_cst fence
-      kokkos_cuda_internal_fence_seq_cst();
-      kokkos_cuda_internal_cas_acquire_32((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_acquire:
-      kokkos_cuda_internal_cas_acquire_32((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_consume:
-      // same as acquire on PTX compatible platforms
-      kokkos_cuda_internal_cas_acquire_32((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_acq_rel:
-      kokkos_cuda_internal_cas_acq_rel_32((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_release:
-      kokkos_cuda_internal_cas_release_32((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_relaxed:
-      kokkos_cuda_internal_cas_relaxed_32((T*)dest, old, old_tmp, tmp);
-      break;
-  };
-#else
-  // All of the orders that require a fence before the relaxed atomic operation:
-  if (success_order == std::memory_order_release ||
-      success_order == std::memory_order_acq_rel) {
-    kokkos_cuda_internal_fence_acq_rel();
-  } else if (success_order == std::memory_order_seq_cst) {
-    kokkos_cuda_internal_fence_seq_cst();
-  }
-  // This is relaxed:
-  // Cuda API requires casting away volatile
-  atomicCAS((T*)dest, old_tmp, tmp);
-#endif
-  bool const rv = (old == old_tmp);
-#if __CUDA_ARCH__ < 700
-  if (rv) {
-    if (success_order == std::memory_order_acquire ||
-        success_order == std::memory_order_consume ||
-        success_order == std::memory_order_acq_rel) {
-      kokkos_cuda_internal_fence_acq_rel();
-    } else if (success_order == std::memory_order_seq_cst) {
-      kokkos_cuda_internal_fence_seq_cst();
-    }
-  } else {
-    if (failure_order == std::memory_order_acquire ||
-        failure_order == std::memory_order_consume ||
-        failure_order == std::memory_order_acq_rel) {
-      kokkos_cuda_internal_fence_acq_rel();
-    } else if (failure_order == std::memory_order_seq_cst) {
-      kokkos_cuda_internal_fence_seq_cst();
-    }
-  }
-#endif
-  memcpy(expected, &old, sizeof(T));
-  return rv;
-}
-
-// 64-bit version
-template <class T, std::enable_if_t<sizeof(T) == 8, int> = 0>
-bool atomic_compare_exchange_weak(
-    T volatile* const dest, T* const expected, T const desired,
-    std::memory_order success_order = std::memory_order_seq_cst,
-    std::memory_order failure_order = std::memory_order_seq_cst) {
-  // TODO assert that success_order >= failure_order
-  // See: https://github.com/ogiroux/freestanding
-  int64_t tmp = 0;
-  int64_t old = 0;
-  memcpy(&tmp, &desired, sizeof(T));
-  memcpy(&old, expected, sizeof(T));
-  int64_t old_tmp = old;
-#if __CUDA_ARCH__ >= 700
-  switch (success_order) {
-    case std::memory_order_seq_cst:
-      // sequentially consistent is just an acquire with a seq_cst fence
-      kokkos_cuda_internal_fence_seq_cst();
-      kokkos_cuda_internal_cas_acquire_64((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_acquire:
-      kokkos_cuda_internal_cas_acquire_64((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_consume:
-      // same as acquire on PTX compatible platforms
-      kokkos_cuda_internal_cas_acquire_64((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_acq_rel:
-      kokkos_cuda_internal_cas_acq_rel_64((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_release:
-      kokkos_cuda_internal_cas_release_64((T*)dest, old, old_tmp, tmp);
-      break;
-    case std::memory_order_relaxed:
-      kokkos_cuda_internal_cas_relaxed_64((T*)dest, old, old_tmp, tmp);
-      break;
-  };
-#else
-  // Cuda API requires casting away volatile
-  atomicCAS((T*)dest, old_tmp, tmp);
-#endif
-  bool const rv = (old == old_tmp);
-  memcpy(expected, &old, sizeof(T));
-  return rv;
-}
-
-#endif  // defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-#endif  // defined( KOKKOS_ENABLE_CUDA )
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-// GCC native CAS supports int, long, unsigned int, unsigned long.
-// Intel native CAS support int and long with the same interface as GCC.
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-inline int atomic_compare_exchange(volatile int* const dest, const int compare,
-                                   const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-inline long atomic_compare_exchange(volatile long* const dest,
-                                    const long compare, const long val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
-
-// GCC supports unsigned
-
-inline unsigned int atomic_compare_exchange(volatile unsigned int* const dest,
-                                            const unsigned int compare,
-                                            const unsigned int val) {
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-inline unsigned long atomic_compare_exchange(volatile unsigned long* const dest,
-                                             const unsigned long compare,
-                                             const unsigned long val) {
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-inline unsigned long long atomic_compare_exchange(
-    volatile unsigned long long* const dest, const unsigned long long compare,
-    const unsigned long long val) {
-  return __sync_val_compare_and_swap(dest, compare, val);
-}
-
-#endif
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T&> val) {
-  union U {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  tmp.i =
-      __sync_val_compare_and_swap((int*)dest, *((int*)&compare), *((int*)&val));
-  return tmp.t;
-}
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(long),
-                     const T&>
-        val) {
-  union U {
-    long i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  tmp.i = __sync_val_compare_and_swap((long*)dest, *((long*)&compare),
-                                      *((long*)&val));
-  return tmp.t;
-}
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long) &&
-                         sizeof(T) == sizeof(Impl::cas128_t),
-                     const T&>
-        val) {
-  union U {
-    Impl::cas128_t i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  tmp.i = Impl::cas128((Impl::cas128_t*)dest, *((Impl::cas128_t*)&compare),
-                       *((Impl::cas128_t*)&val));
-  return tmp.t;
-}
-#endif
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T compare,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8)
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-                         && (sizeof(T) != 16)
-#endif
-                         ,
-                     const T>& val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = *dest;
-  if (return_val == compare) {
-    // Don't use the following line of code here:
-    //
-    // const T tmp = *dest = val;
-    //
-    // Instead, put each assignment in its own statement.  This is
-    // because the overload of T::operator= for volatile *this should
-    // return void, not volatile T&.  See Kokkos #177:
-    //
-    // https://github.com/kokkos/kokkos/issues/177
-    *dest       = val;
-    const T tmp = *dest;
-#ifndef KOKKOS_COMPILER_CLANG
-    (void)tmp;
-#endif
-    Kokkos::memory_fence();
-  }
-  Impl::unlock_address_host_space((void*)dest);
-  return return_val;
-}
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest,
-                                                 const T compare, const T val) {
-  T retval;
-#pragma omp critical
-  {
-    retval = dest[0];
-    if (retval == compare) dest[0] = val;
-  }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_compare_exchange(volatile T* const dest_v,
-                                                 const T compare, const T val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  if (retval == compare) *dest = val;
-  return retval;
-}
-
-#endif
-#endif
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION bool atomic_compare_exchange_strong(
-    volatile T* const dest, const T compare, const T val) {
-  return compare == atomic_compare_exchange(dest, compare, val);
-}
-//----------------------------------------------------------------------------
-
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Decrement.hpp b/core/src/impl/Kokkos_Atomic_Decrement.hpp
deleted file mode 100644
index aac5233b3a..0000000000
--- a/core/src/impl/Kokkos_Atomic_Decrement.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_DECREMENT_HPP)
-#define KOKKOS_ATOMIC_DECREMENT_HPP
-
-#include "impl/Kokkos_Atomic_Fetch_Sub.hpp"
-
-namespace Kokkos {
-
-// Atomic decrement
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_decrement<char>(volatile char* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock decb %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  char* a_nv = const_cast<char*>(a);
-  --(*a_nv);
-#else
-  Kokkos::atomic_fetch_sub(a, char(1));
-#endif
-}
-
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_decrement<short>(volatile short* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock decw %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  short* a_nv = const_cast<short*>(a);
-  --(*a_nv);
-#else
-  Kokkos::atomic_fetch_sub(a, short(1));
-#endif
-}
-
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_decrement<int>(volatile int* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock decl %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  int* a_nv = const_cast<int*>(a);
-  --(*a_nv);
-#else
-  Kokkos::atomic_fetch_sub(a, int(1));
-#endif
-}
-
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_decrement<long long int>(
-    volatile long long int* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock decq %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  long long int* a_nv = const_cast<long long int*>(a);
-  --(*a_nv);
-#else
-  using T = long long int;
-  Kokkos::atomic_fetch_sub(a, T(1));
-#endif
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_decrement(volatile T* a) {
-#if defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  T* a_nv = const_cast<T*>(a);
-  --(*a_nv);
-#else
-  Kokkos::atomic_fetch_sub(a, T(1));
-#endif
-}
-
-}  // End of namespace Kokkos
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Exchange.hpp b/core/src/impl/Kokkos_Atomic_Exchange.hpp
deleted file mode 100644
index abfc1f631a..0000000000
--- a/core/src/impl/Kokkos_Atomic_Exchange.hpp
+++ /dev/null
@@ -1,376 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_EXCHANGE_HPP)
-#define KOKKOS_ATOMIC_EXCHANGE_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-__inline__ __device__ int atomic_exchange(volatile int* const dest,
-                                          const int val) {
-  // return __iAtomicExch( (int*) dest , val );
-  return atomicExch((int*)dest, val);
-}
-
-__inline__ __device__ unsigned int atomic_exchange(
-    volatile unsigned int* const dest, const unsigned int val) {
-  // return __uAtomicExch( (unsigned int*) dest , val );
-  return atomicExch((unsigned int*)dest, val);
-}
-
-__inline__ __device__ unsigned long long int atomic_exchange(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  // return __ullAtomicExch( (unsigned long long*) dest , val );
-  return atomicExch((unsigned long long*)dest, val);
-}
-
-/** \brief  Atomic exchange for any type with compatible size */
-template <typename T>
-__inline__ __device__ T
-atomic_exchange(volatile T* const dest,
-                std::enable_if_t<sizeof(T) == sizeof(int), const T&> val) {
-  // int tmp = __ullAtomicExch( (int*) dest , *((int*)&val) );
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  int tmp = atomicExch(((int*)dest), *((int*)&val));
-  return *((T*)&tmp);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_exchange(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T&>
-        val) {
-  using type = unsigned long long int;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  // type tmp = __ullAtomicExch( (type*) dest , *((type*)&val) );
-  type tmp = atomicExch(((type*)dest), *((type*)&val));
-  return *((T*)&tmp);
-}
-
-template <typename T>
-__inline__ __device__ T atomic_exchange(
-    volatile T* const dest,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8), const T>& val) {
-  T return_val;
-  // This is a way to (hopefully) avoid dead lock in a warp
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  int done                 = 0;
-  unsigned int mask        = __activemask();
-  unsigned int active      = __ballot_sync(mask, 1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_cuda_space((void*)dest)) {
-        Kokkos::memory_fence();
-        return_val = *dest;
-        *dest      = val;
-        Kokkos::memory_fence();
-        Impl::unlock_address_cuda_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot_sync(mask, done);
-  }
-  return return_val;
-}
-/** \brief  Atomic exchange for any type with compatible size */
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T&> val) {
-  // (void) __ullAtomicExch( (int*) dest , *((int*)&val) );
-  (void)atomicExch(((int*)dest), *((int*)&val));
-}
-
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T&>
-        val) {
-  using type = unsigned long long int;
-  // (void) __ullAtomicExch( (type*) dest , *((type*)&val) );
-  (void)atomicExch(((type*)dest), *((type*)&val));
-}
-
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) != sizeof(unsigned long long int),
-                     const T&>
-        val) {
-  (void)atomic_exchange(dest, val);
-}
-
-#endif
-#endif
-
-//----------------------------------------------------------------------------
-
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-template <typename T>
-inline T atomic_exchange(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(int) || sizeof(T) == sizeof(long),
-                     const T&>
-        val) {
-  using type = std::conditional_t<sizeof(T) == sizeof(int), int, long>;
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  const type v = *((type*)&val);  // Extract to be sure the value doesn't change
-
-  type assumed;
-
-  union U {
-    T val_T;
-    type val_type;
-    inline U() {}
-  } old;
-
-  old.val_T = *dest;
-
-  do {
-    assumed = old.val_type;
-    old.val_type =
-        __sync_val_compare_and_swap((volatile type*)dest, assumed, v);
-  } while (assumed != old.val_type);
-
-  return old.val_T;
-}
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-template <typename T>
-inline T atomic_exchange(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(Impl::cas128_t), const T&> val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  union U {
-    Impl::cas128_t i;
-    T t;
-    inline U() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-  newval.t = val;
-
-  do {
-    assume.i = oldval.i;
-    oldval.i = Impl::cas128((volatile Impl::cas128_t*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-#endif
-
-//----------------------------------------------------------------------------
-
-template <typename T>
-inline T atomic_exchange(volatile T* const dest,
-                         std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8)
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-                                              && (sizeof(T) != 16)
-#endif
-                                              ,
-                                          const T>& val) {
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = *dest;
-  // Don't use the following line of code here:
-  //
-  // const T tmp = *dest = val;
-  //
-  // Instead, put each assignment in its own statement.  This is
-  // because the overload of T::operator= for volatile *this should
-  // return void, not volatile T&.  See Kokkos #177:
-  //
-  // https://github.com/kokkos/kokkos/issues/177
-  *dest       = val;
-  const T tmp = *dest;
-#ifndef KOKKOS_COMPILER_CLANG
-  (void)tmp;
-#endif
-  Kokkos::memory_fence();
-  Impl::unlock_address_host_space((void*)dest);
-  return return_val;
-}
-
-template <typename T>
-inline void atomic_assign(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(int) || sizeof(T) == sizeof(long),
-                     const T&>
-        val) {
-  using type = std::conditional_t<sizeof(T) == sizeof(int), int, long>;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  const type v = *((type*)&val);  // Extract to be sure the value doesn't change
-
-  type assumed;
-
-  union U {
-    T val_T;
-    type val_type;
-    inline U() {}
-  } old;
-
-  old.val_T = *dest;
-
-  do {
-    assumed = old.val_type;
-    old.val_type =
-        __sync_val_compare_and_swap((volatile type*)dest, assumed, v);
-  } while (assumed != old.val_type);
-}
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-template <typename T>
-inline void atomic_assign(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(Impl::cas128_t), const T&> val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  union U {
-    Impl::cas128_t i;
-    T t;
-    inline U() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-  newval.t = val;
-  do {
-    assume.i = oldval.i;
-    oldval.i = Impl::cas128((volatile Impl::cas128_t*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-}
-#endif
-
-template <typename T>
-inline void atomic_assign(volatile T* const dest,
-                          std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8)
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-                                               && (sizeof(T) != 16)
-#endif
-                                               ,
-                                           const T>& val) {
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  // This is likely an aggregate type with a defined
-  // 'volatile T & operator = ( const T & ) volatile'
-  // member.  The volatile return value implicitly defines a
-  // dereference that some compilers (gcc 4.7.2) warn is being ignored.
-  // Suppress warning by casting return to void.
-  //(void)( *dest = val );
-  *dest = val;
-  Kokkos::memory_fence();
-  Impl::unlock_address_host_space((void*)dest);
-}
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-inline T atomic_exchange(volatile T* const dest, const T val) {
-  T retval;
-  //#pragma omp atomic capture
-#pragma omp critical
-  {
-    retval  = dest[0];
-    dest[0] = val;
-  }
-  return retval;
-}
-
-template <typename T>
-inline void atomic_assign(volatile T* const dest, const T val) {
-  //#pragma omp atomic
-#pragma omp critical
-  { dest[0] = val; }
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-inline T atomic_exchange(volatile T* const dest_v, const T val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  *dest    = val;
-  return retval;
-}
-
-template <typename T>
-inline void atomic_assign(volatile T* const dest_v, const T val) {
-  T* dest = const_cast<T*>(dest_v);
-  *dest   = val;
-}
-
-#endif
-#endif
-
-// dummy for non-CUDA Kokkos headers being processed by NVCC
-#if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template <typename T>
-__inline__ __device__ T
-atomic_exchange(volatile T* const, const Kokkos::Impl::type_identity_t<T>) {
-  return T();
-}
-
-template <typename T>
-__inline__ __device__ void atomic_assign(
-    volatile T* const, const Kokkos::Impl::type_identity_t<T>) {}
-#endif
-
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp b/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp
deleted file mode 100644
index a8c421fbdb..0000000000
--- a/core/src/impl/Kokkos_Atomic_Fetch_Add.hpp
+++ /dev/null
@@ -1,360 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_ADD_HPP)
-#define KOKKOS_ATOMIC_FETCH_ADD_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-// Support for int, unsigned int, unsigned long long int, and float
-
-__inline__ __device__ int atomic_fetch_add(volatile int* const dest,
-                                           const int val) {
-  return atomicAdd((int*)dest, val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_add(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return atomicAdd((unsigned int*)dest, val);
-}
-
-__inline__ __device__ unsigned long long int atomic_fetch_add(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return atomicAdd((unsigned long long int*)dest, val);
-}
-
-__inline__ __device__ float atomic_fetch_add(volatile float* const dest,
-                                             const float val) {
-  return atomicAdd((float*)dest, val);
-}
-
-#if (600 <= __CUDA_ARCH__)
-__inline__ __device__ double atomic_fetch_add(volatile double* const dest,
-                                              const double val) {
-  return atomicAdd((double*)dest, val);
-}
-#endif
-
-template <typename T>
-__inline__ __device__ T
-atomic_fetch_add(volatile T* const dest,
-                 std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  // to work around a bug in the clang cuda compiler, the name here needs to be
-  // different from the one internal to the other overloads
-  union U1 {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U1() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = atomicCAS((int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <typename T>
-__inline__ __device__ T atomic_fetch_add(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T>
-        val) {
-  // to work around a bug in the clang cuda compiler, the name here needs to be
-  // different from the one internal to the other overloads
-  union U2 {
-    unsigned long long int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U2() {}
-  } assume, oldval, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = atomicCAS((unsigned long long int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-//----------------------------------------------------------------------------
-
-template <typename T>
-__inline__ __device__ T atomic_fetch_add(
-    volatile T* const dest,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8), const T>& val) {
-  T return_val;
-  // This is a way to (hopefully) avoid dead lock in a warp
-  int done                 = 0;
-  unsigned int mask        = __activemask();
-  unsigned int active      = __ballot_sync(mask, 1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      bool locked = Impl::lock_address_cuda_space((void*)dest);
-      if (locked) {
-        Kokkos::memory_fence();
-        return_val = *dest;
-        *dest      = return_val + val;
-        Kokkos::memory_fence();
-        Impl::unlock_address_cuda_space((void*)dest);
-        done = 1;
-      }
-    }
-
-    done_active = __ballot_sync(mask, done);
-  }
-  return return_val;
-}
-#endif
-#endif
-//----------------------------------------------------------------------------
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-inline int atomic_fetch_add(volatile int* dest, const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  int original = val;
-
-  __asm__ __volatile__("lock xadd %1, %0"
-                       : "+m"(*dest), "+r"(original)
-                       : "m"(*dest), "r"(original)
-                       : "memory");
-
-  return original;
-}
-#else
-inline int atomic_fetch_add(volatile int* const dest, const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_add(dest, val);
-}
-#endif
-
-inline long int atomic_fetch_add(volatile long int* const dest,
-                                 const long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_add(dest, val);
-}
-
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
-
-inline unsigned int atomic_fetch_add(volatile unsigned int* const dest,
-                                     const unsigned int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_add(dest, val);
-}
-
-inline unsigned long int atomic_fetch_add(
-    volatile unsigned long int* const dest, const unsigned long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_add(dest, val);
-}
-
-inline unsigned long long int atomic_fetch_add(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_add(dest, val);
-}
-
-#endif
-
-template <typename T>
-inline T atomic_fetch_add(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  union U {
-    int i;
-    T t;
-    inline U() {}
-  } assume, oldval, newval;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = __sync_val_compare_and_swap((int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <typename T>
-inline T atomic_fetch_add(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(long),
-                     const T>
-        val) {
-  union U {
-    long i;
-    T t;
-    inline U() {}
-  } assume, oldval, newval;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = __sync_val_compare_and_swap((long*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-template <typename T>
-inline T atomic_fetch_add(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) != sizeof(long) &&
-                         sizeof(T) == sizeof(Impl::cas128_t),
-                     const T>
-        val) {
-  union U {
-    Impl::cas128_t i;
-    T t;
-    inline U() {}
-  } assume, oldval, newval;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t + val;
-    oldval.i = Impl::cas128((volatile Impl::cas128_t*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-#endif
-
-//----------------------------------------------------------------------------
-
-template <typename T>
-inline T atomic_fetch_add(volatile T* const dest,
-                          std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8)
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-                                               && (sizeof(T) != 16)
-#endif
-                                               ,
-                                           const T>& val) {
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = *dest;
-
-  // Don't use the following line of code here:
-  //
-  // const T tmp = *dest = return_val + val;
-  //
-  // Instead, put each assignment in its own statement.  This is
-  // because the overload of T::operator= for volatile *this should
-  // return void, not volatile T&.  See Kokkos #177:
-  //
-  // https://github.com/kokkos/kokkos/issues/177
-  *dest       = return_val + val;
-  const T tmp = *dest;
-  (void)tmp;
-  Kokkos::memory_fence();
-  Impl::unlock_address_host_space((void*)dest);
-
-  return return_val;
-}
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-T atomic_fetch_add(volatile T* const dest, const T val) {
-  T retval;
-#pragma omp atomic capture
-  {
-    retval = dest[0];
-    dest[0] += val;
-  }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-T atomic_fetch_add(volatile T* const dest_v, std::add_const_t<T> val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  *dest += val;
-  return retval;
-}
-
-#endif
-#endif
-//----------------------------------------------------------------------------
-
-// dummy for non-CUDA Kokkos headers being processed by NVCC
-#if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template <typename T>
-__inline__ __device__ T atomic_fetch_add(volatile T* const,
-                                         Kokkos::Impl::type_identity_t<T>) {
-  return T();
-}
-#endif
-
-}  // namespace Kokkos
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Fetch_And.hpp b/core/src/impl/Kokkos_Atomic_Fetch_And.hpp
deleted file mode 100644
index 25049db8f0..0000000000
--- a/core/src/impl/Kokkos_Atomic_Fetch_And.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_AND_HPP)
-#define KOKKOS_ATOMIC_FETCH_AND_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-// Support for int, unsigned int, unsigned long long int, and float
-
-__inline__ __device__ int atomic_fetch_and(volatile int* const dest,
-                                           const int val) {
-  return atomicAnd((int*)dest, val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_and(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return atomicAnd((unsigned int*)dest, val);
-}
-
-#if defined(__CUDA_ARCH__) && (350 <= __CUDA_ARCH__)
-__inline__ __device__ unsigned long long int atomic_fetch_and(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return atomicAnd((unsigned long long int*)dest, val);
-}
-#endif
-#endif
-#endif
-
-// 08/05/20 Overload to work around https://bugs.llvm.org/show_bug.cgi?id=46922
-
-#if (defined(KOKKOS_ENABLE_CUDA) &&                   \
-     (defined(__CUDA_ARCH__) ||                       \
-      defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND))) || \
-    (defined(KOKKOS_ENABLE_HIP))
-__inline__ __device__ unsigned long atomic_fetch_and(
-    volatile unsigned long* const dest, const unsigned long val) {
-  return atomic_fetch_and<unsigned long>(dest, val);
-}
-__inline__ __device__ long atomic_fetch_and(volatile long* const dest,
-                                            long val) {
-  return atomic_fetch_and<long>(dest, val);
-}
-#endif
-
-//----------------------------------------------------------------------------
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-inline int atomic_fetch_and(volatile int* const dest, const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_and(dest, val);
-}
-
-inline long int atomic_fetch_and(volatile long int* const dest,
-                                 const long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_and(dest, val);
-}
-
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
-
-inline unsigned int atomic_fetch_and(volatile unsigned int* const dest,
-                                     const unsigned int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_and(dest, val);
-}
-
-inline unsigned long int atomic_fetch_and(
-    volatile unsigned long int* const dest, const unsigned long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_and(dest, val);
-}
-
-inline unsigned long long int atomic_fetch_and(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_and(dest, val);
-}
-
-#endif
-
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-T atomic_fetch_and(volatile T* const dest, const T val) {
-  T retval;
-#pragma omp atomic capture
-  {
-    retval = dest[0];
-    dest[0] &= val;
-  }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-T atomic_fetch_and(volatile T* const dest_v, const T val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  *dest &= val;
-  return retval;
-}
-
-#endif
-#endif
-//----------------------------------------------------------------------------
-
-// dummy for non-CUDA Kokkos headers being processed by NVCC
-#if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template <typename T>
-__inline__ __device__ T atomic_fetch_and(volatile T* const,
-                                         Kokkos::Impl::type_identity_t<T>) {
-  return T();
-}
-#endif
-
-// Simpler version of atomic_fetch_and without the fetch
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_and(volatile T* const dest, const T src) {
-  (void)atomic_fetch_and(dest, src);
-}
-
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp b/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp
deleted file mode 100644
index fa581bc155..0000000000
--- a/core/src/impl/Kokkos_Atomic_Fetch_Or.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_OR_HPP)
-#define KOKKOS_ATOMIC_FETCH_OR_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-// Support for int, unsigned int, unsigned long long int, and float
-
-__inline__ __device__ int atomic_fetch_or(volatile int* const dest,
-                                          const int val) {
-  return atomicOr((int*)dest, val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_or(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return atomicOr((unsigned int*)dest, val);
-}
-
-#if defined(__CUDA_ARCH__) && (350 <= __CUDA_ARCH__)
-__inline__ __device__ unsigned long long int atomic_fetch_or(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return atomicOr((unsigned long long int*)dest, val);
-}
-#endif
-#endif
-#endif
-
-// 08/05/20 Overload to work around https://bugs.llvm.org/show_bug.cgi?id=46922
-
-#if (defined(KOKKOS_ENABLE_CUDA) &&                   \
-     (defined(__CUDA_ARCH__) ||                       \
-      defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND))) || \
-    (defined(KOKKOS_ENABLE_HIP))
-__inline__ __device__ unsigned long atomic_fetch_or(
-    volatile unsigned long* const dest, const unsigned long val) {
-  return atomic_fetch_or<unsigned long>(dest, val);
-}
-
-__inline__ __device__ long atomic_fetch_or(volatile long* const dest,
-                                           long val) {
-  return atomic_fetch_or<long>(dest, val);
-}
-#endif
-
-//----------------------------------------------------------------------------
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-inline int atomic_fetch_or(volatile int* const dest, const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_or(dest, val);
-}
-
-inline long int atomic_fetch_or(volatile long int* const dest,
-                                const long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_or(dest, val);
-}
-
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
-
-inline unsigned int atomic_fetch_or(volatile unsigned int* const dest,
-                                    const unsigned int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_or(dest, val);
-}
-
-inline unsigned long int atomic_fetch_or(volatile unsigned long int* const dest,
-                                         const unsigned long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_or(dest, val);
-}
-
-inline unsigned long long int atomic_fetch_or(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_or(dest, val);
-}
-
-#endif
-
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-T atomic_fetch_or(volatile T* const dest, const T val) {
-  T retval;
-#pragma omp atomic capture
-  {
-    retval = dest[0];
-    dest[0] |= val;
-  }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-T atomic_fetch_or(volatile T* const dest_v, const T val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  *dest |= val;
-  return retval;
-}
-
-#endif
-#endif
-//----------------------------------------------------------------------------
-
-// dummy for non-CUDA Kokkos headers being processed by NVCC
-#if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template <typename T>
-__inline__ __device__ T atomic_fetch_or(volatile T* const,
-                                        Kokkos::Impl::type_identity_t<T>) {
-  return T();
-}
-#endif
-
-// Simpler version of atomic_fetch_or without the fetch
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_or(volatile T* const dest, const T src) {
-  (void)atomic_fetch_or(dest, src);
-}
-
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp b/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp
deleted file mode 100644
index a4db7d7cf4..0000000000
--- a/core/src/impl/Kokkos_Atomic_Fetch_Sub.hpp
+++ /dev/null
@@ -1,295 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_FETCH_SUB_HPP)
-#define KOKKOS_ATOMIC_FETCH_SUB_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-// Support for int, unsigned int, unsigned long long int, and float
-
-__inline__ __device__ int atomic_fetch_sub(volatile int* const dest,
-                                           const int val) {
-  return atomicSub((int*)dest, val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_sub(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return atomicSub((unsigned int*)dest, val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_sub(
-    volatile int64_t* const dest, const int64_t val) {
-  return atomic_fetch_add(dest, -val);
-}
-
-__inline__ __device__ unsigned int atomic_fetch_sub(volatile float* const dest,
-                                                    const float val) {
-  return atomicAdd((float*)dest, -val);
-}
-
-#if (600 <= __CUDA_ARCH__)
-__inline__ __device__ unsigned int atomic_fetch_sub(volatile double* const dest,
-                                                    const double val) {
-  return atomicAdd((double*)dest, -val);
-}
-#endif
-
-template <typename T>
-__inline__ __device__ T
-atomic_fetch_sub(volatile T* const dest,
-                 std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  union U {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t - val;
-    oldval.i = atomicCAS((int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <typename T>
-__inline__ __device__ T atomic_fetch_sub(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T>
-        val) {
-  union U {
-    unsigned long long int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t - val;
-    oldval.i = atomicCAS((unsigned long long int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-//----------------------------------------------------------------------------
-
-template <typename T>
-__inline__ __device__ T atomic_fetch_sub(
-    volatile T* const dest,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8), const T>& val) {
-  T return_val;
-  // This is a way to (hopefully) avoid dead lock in a warp
-  int done                 = 0;
-  unsigned int mask        = __activemask();
-  unsigned int active      = __ballot_sync(mask, 1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_cuda_space((void*)dest)) {
-        Kokkos::memory_fence();
-        return_val = *dest;
-        *dest      = return_val - val;
-        Kokkos::memory_fence();
-        Impl::unlock_address_cuda_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot_sync(mask, done);
-  }
-  return return_val;
-}
-#endif
-#endif
-//----------------------------------------------------------------------------
-#if !defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) || defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-
-inline int atomic_fetch_sub(volatile int* const dest, const int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_sub(dest, val);
-}
-
-inline long int atomic_fetch_sub(volatile long int* const dest,
-                                 const long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_sub(dest, val);
-}
-
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS)
-
-inline unsigned int atomic_fetch_sub(volatile unsigned int* const dest,
-                                     const unsigned int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_sub(dest, val);
-}
-
-inline unsigned long int atomic_fetch_sub(
-    volatile unsigned long int* const dest, const unsigned long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_sub(dest, val);
-}
-
-inline unsigned long long int atomic_fetch_sub(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-  return __sync_fetch_and_sub(dest, val);
-}
-
-#endif
-
-template <typename T>
-inline T atomic_fetch_sub(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  union U {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t - val;
-    oldval.i = __sync_val_compare_and_swap((int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <typename T>
-inline T atomic_fetch_sub(
-    volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) && sizeof(T) == sizeof(long),
-                     const T>
-        val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  union U {
-    long i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    assume.i = oldval.i;
-    newval.t = assume.t - val;
-    oldval.i = __sync_val_compare_and_swap((long*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-//----------------------------------------------------------------------------
-
-template <typename T>
-inline T atomic_fetch_sub(
-    volatile T* const dest,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8), const T>& val) {
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)dest, _MM_HINT_ET0);
-#endif
-
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = *dest;
-  *dest        = return_val - val;
-  Kokkos::memory_fence();
-  Impl::unlock_address_host_space((void*)dest);
-  return return_val;
-}
-
-//----------------------------------------------------------------------------
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <typename T>
-T atomic_fetch_sub(volatile T* const dest, const T val) {
-  T retval;
-#pragma omp atomic capture
-  {
-    retval = dest[0];
-    dest[0] -= val;
-  }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-T atomic_fetch_sub(volatile T* const dest_v, const T val) {
-  T* dest  = const_cast<T*>(dest_v);
-  T retval = *dest;
-  *dest -= val;
-  return retval;
-}
-
-#endif
-#endif
-
-// dummy for non-CUDA Kokkos headers being processed by NVCC
-#if defined(__CUDA_ARCH__) && !defined(KOKKOS_ENABLE_CUDA)
-template <typename T>
-__inline__ __device__ T atomic_fetch_sub(volatile T* const,
-                                         Kokkos::Impl::type_identity_t<T>) {
-  return T();
-}
-#endif
-
-}  // namespace Kokkos
-
-#include <impl/Kokkos_Atomic_Assembly.hpp>
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Generic.hpp b/core/src/impl/Kokkos_Atomic_Generic.hpp
deleted file mode 100644
index 69d101fb8e..0000000000
--- a/core/src/impl/Kokkos_Atomic_Generic.hpp
+++ /dev/null
@@ -1,527 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_GENERIC_HPP)
-#define KOKKOS_ATOMIC_GENERIC_HPP
-#include <Kokkos_Macros.hpp>
-
-// Combination operands to be used in an Compare and Exchange based atomic
-// operation
-namespace Kokkos {
-namespace Impl {
-
-template <class Op, class Scalar1, class Scalar2, class Enable = bool>
-struct _check_early_exit_impl {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static constexpr bool check(Op const&, Scalar1 const&,
-                              Scalar2 const&) noexcept {
-    return false;
-  }
-};
-
-template <class Op, class Scalar1, class Scalar2>
-struct _check_early_exit_impl<
-    Op, Scalar1, Scalar2,
-    decltype(std::declval<Op const&>().check_early_exit(
-        std::declval<Scalar1 const&>(), std::declval<Scalar2 const&>()))> {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static constexpr bool check(Op const& op, Scalar1 const& v1,
-                              Scalar2 const& v2) {
-    return op.check_early_exit(v1, v2);
-  }
-};
-
-template <class Op, class Scalar1, class Scalar2>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool check_early_exit(
-    Op const& op, Scalar1 const& v1, Scalar2 const& v2) noexcept {
-  return _check_early_exit_impl<Op, Scalar1, Scalar2>::check(op, v1, v2);
-}
-
-template <class Scalar1, class Scalar2>
-struct MaxOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return (val1 > val2 ? val1 : val2);
-  }
-  KOKKOS_FORCEINLINE_FUNCTION
-  static constexpr bool check_early_exit(Scalar1 const& val1,
-                                         Scalar2 const& val2) noexcept {
-    return (val1 > val2);
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct MinOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return (val1 < val2 ? val1 : val2);
-  }
-  KOKKOS_FORCEINLINE_FUNCTION
-  static constexpr bool check_early_exit(Scalar1 const& val1,
-                                         Scalar2 const& val2) noexcept {
-    return (val1 < val2);
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct AddOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 + val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct SubOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 - val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct MulOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 * val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct DivOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 / val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct ModOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 % val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct AndOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 & val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct OrOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 | val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct XorOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 ^ val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct LShiftOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 << val2;
-  }
-};
-
-template <class Scalar1, class Scalar2>
-struct RShiftOper {
-  KOKKOS_FORCEINLINE_FUNCTION
-  static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
-    return val1 >> val2;
-  }
-};
-
-template <class Oper, typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_oper(
-    const Oper& op, volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T>
-        val) {
-  union U {
-    unsigned long long int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    if (check_early_exit(op, oldval.t, val)) return oldval.t;
-    assume.i = oldval.i;
-    newval.t = op.apply(assume.t, val);
-    oldval.i = Kokkos::atomic_compare_exchange((unsigned long long int*)dest,
-                                               assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <class Oper, typename T>
-KOKKOS_INLINE_FUNCTION T atomic_oper_fetch(
-    const Oper& op, volatile T* const dest,
-    std::enable_if_t<sizeof(T) != sizeof(int) &&
-                         sizeof(T) == sizeof(unsigned long long int),
-                     const T>
-        val) {
-  union U {
-    unsigned long long int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    if (check_early_exit(op, oldval.t, val)) return oldval.t;
-    assume.i = oldval.i;
-    newval.t = op.apply(assume.t, val);
-    oldval.i = Kokkos::atomic_compare_exchange((unsigned long long int*)dest,
-                                               assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return newval.t;
-}
-
-template <class Oper, typename T>
-KOKKOS_INLINE_FUNCTION T
-atomic_fetch_oper(const Oper& op, volatile T* const dest,
-                  std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  union U {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    if (check_early_exit(op, oldval.t, val)) return oldval.t;
-    assume.i = oldval.i;
-    newval.t = op.apply(assume.t, val);
-    oldval.i = Kokkos::atomic_compare_exchange((int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return oldval.t;
-}
-
-template <class Oper, typename T>
-KOKKOS_INLINE_FUNCTION T
-atomic_oper_fetch(const Oper& op, volatile T* const dest,
-                  std::enable_if_t<sizeof(T) == sizeof(int), const T> val) {
-  union U {
-    int i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } oldval, assume, newval;
-
-  oldval.t = *dest;
-
-  do {
-    if (check_early_exit(op, oldval.t, val)) return oldval.t;
-    assume.i = oldval.i;
-    newval.t = op.apply(assume.t, val);
-    oldval.i = Kokkos::atomic_compare_exchange((int*)dest, assume.i, newval.i);
-  } while (assume.i != oldval.i);
-
-  return newval.t;
-}
-
-template <class Oper, typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_oper(
-    const Oper& op, volatile T* const dest,
-    std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8), const T> val) {
-#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = *dest;
-  *dest        = op.apply(return_val, val);
-  Kokkos::memory_fence();
-  Impl::unlock_address_host_space((void*)dest);
-  return return_val;
-#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
-  // This is a way to (hopefully) avoid dead lock in a warp
-  T return_val;
-  int done                 = 0;
-  unsigned int mask        = __activemask();
-  unsigned int active      = __ballot_sync(mask, 1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_cuda_space((void*)dest)) {
-        Kokkos::memory_fence();
-        return_val = *dest;
-        *dest      = op.apply(return_val, val);
-        Kokkos::memory_fence();
-        Impl::unlock_address_cuda_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot_sync(mask, done);
-  }
-  return return_val;
-#elif defined(__HIP_DEVICE_COMPILE__)
-  T return_val             = *dest;
-  int done                 = 0;
-  unsigned int active      = __ballot(1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_hip_space((void*)dest)) {
-        return_val = *dest;
-        *dest      = op.apply(return_val, val);
-        Impl::unlock_address_hip_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot(done);
-  }
-  return return_val;
-#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_SYCL)
-  // FIXME_SYCL
-  Kokkos::abort("Not implemented!");
-  (void)op;
-  (void)dest;
-  (void)val;
-  return 0;
-#endif
-}
-
-template <class Oper, typename T>
-KOKKOS_INLINE_FUNCTION T
-atomic_oper_fetch(const Oper& op, volatile T* const dest,
-                  std::enable_if_t<(sizeof(T) != 4) && (sizeof(T) != 8)
-#if defined(KOKKOS_ENABLE_ASM) && \
-    defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST)
-                                       && (sizeof(T) != 16)
-#endif
-                                       ,
-                                   const T>& val) {
-
-#ifdef KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-  while (!Impl::lock_address_host_space((void*)dest))
-    ;
-  Kokkos::memory_fence();
-  T return_val = op.apply(*dest, val);
-  *dest        = return_val;
-  Kokkos::memory_fence();
-  Impl::unlock_address_host_space((void*)dest);
-  return return_val;
-#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA)
-  T return_val;
-  // This is a way to (hopefully) avoid dead lock in a warp
-  int done                 = 0;
-  unsigned int mask        = __activemask();
-  unsigned int active      = __ballot_sync(mask, 1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_cuda_space((void*)dest)) {
-        Kokkos::memory_fence();
-        return_val = op.apply(*dest, val);
-        *dest      = return_val;
-        Kokkos::memory_fence();
-        Impl::unlock_address_cuda_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot_sync(mask, done);
-  }
-  return return_val;
-#elif defined(__HIP_DEVICE_COMPILE__)
-  T return_val;
-  int done                 = 0;
-  unsigned int active      = __ballot(1);
-  unsigned int done_active = 0;
-  while (active != done_active) {
-    if (!done) {
-      if (Impl::lock_address_hip_space((void*)dest)) {
-        return_val = op.apply(*dest, val);
-        *dest      = return_val;
-        Impl::unlock_address_hip_space((void*)dest);
-        done = 1;
-      }
-    }
-    done_active = __ballot(done);
-  }
-  return return_val;
-#elif defined(KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_SYCL)
-  // FIXME_SYCL
-  std::abort();
-  (void)op;
-  (void)dest;
-  (void)val;
-  return 0;
-#endif
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-namespace Kokkos {
-
-// Fetch_Oper atomics: return value before operation
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_max(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::MaxOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_min(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::MinOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_mul(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::MulOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_div(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::DivOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_mod(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::ModOper<T, const T>(), dest, val);
-}
-
-#if !defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_and(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::AndOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_or(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::OrOper<T, const T>(), dest, val);
-}
-
-#endif
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_xor(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::XorOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_lshift(volatile T* const dest,
-                                             const unsigned int val) {
-  return Impl::atomic_fetch_oper(Impl::LShiftOper<T, const unsigned int>(),
-                                 dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_rshift(volatile T* const dest,
-                                             const unsigned int val) {
-  return Impl::atomic_fetch_oper(Impl::RShiftOper<T, const unsigned int>(),
-                                 dest, val);
-}
-
-// Oper Fetch atomics: return value after operation
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_max_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::MaxOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_min_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::MinOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_mul_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::MulOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_div_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::DivOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_mod_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::ModOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_and_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::AndOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_or_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::OrOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_xor_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::XorOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_lshift_fetch(volatile T* const dest,
-                                             const unsigned int val) {
-  return Impl::atomic_oper_fetch(Impl::LShiftOper<T, const unsigned int>(),
-                                 dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_rshift_fetch(volatile T* const dest,
-                                             const unsigned int val) {
-  return Impl::atomic_oper_fetch(Impl::RShiftOper<T, const unsigned int>(),
-                                 dest, val);
-}
-
-#ifdef _WIN32
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_add_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::AddOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_sub_fetch(volatile T* const dest, const T val) {
-  return Impl::atomic_oper_fetch(Impl::SubOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_add(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::AddOper<T, const T>(), dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_fetch_sub(volatile T* const dest, const T val) {
-  return Impl::atomic_fetch_oper(Impl::SubOper<T, const T>(), dest, val);
-}
-#endif
-
-}  // namespace Kokkos
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Generic_Secondary.hpp b/core/src/impl/Kokkos_Atomic_Generic_Secondary.hpp
deleted file mode 100644
index af43bf6679..0000000000
--- a/core/src/impl/Kokkos_Atomic_Generic_Secondary.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_GENERIC_SECONDARY_HPP)
-#define KOKKOS_ATOMIC_GENERIC_SECONDARY_HPP
-#include <Kokkos_Macros.hpp>
-
-namespace Kokkos {
-
-#ifndef KOKKOS_ENABLE_SERIAL_ATOMICS
-template <typename T>
-KOKKOS_INLINE_FUNCTION T atomic_exchange(volatile T* const dest, const T val) {
-  T oldval = *dest;
-  T assume;
-  do {
-    assume = oldval;
-    oldval = atomic_compare_exchange(dest, assume, val);
-  } while (assume != oldval);
-
-  return oldval;
-}
-#endif
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_add(volatile T* const dest, const T val) {
-  (void)atomic_fetch_add(dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_sub(volatile T* const dest, const T val) {
-  (void)atomic_fetch_sub(dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_mul(volatile T* const dest, const T val) {
-  (void)atomic_fetch_mul(dest, val);
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_div(volatile T* const dest, const T val) {
-  (void)atomic_fetch_div(dest, val);
-}
-
-}  // namespace Kokkos
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Increment.hpp b/core/src/impl/Kokkos_Atomic_Increment.hpp
deleted file mode 100644
index b40e7dfecb..0000000000
--- a/core/src/impl/Kokkos_Atomic_Increment.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-#include <xmmintrin.h>
-#endif
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_INCREMENT_HPP)
-#define KOKKOS_ATOMIC_INCREMENT_HPP
-
-namespace Kokkos {
-
-// Atomic increment
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_increment<char>(volatile char* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock incb %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  char* a_nv = const_cast<char*>(a);
-  ++(*a_nv);
-#else
-  Kokkos::atomic_fetch_add(a, char(1));
-#endif
-}
-
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_increment<short>(volatile short* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock incw %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  short* a_nv = const_cast<short*>(a);
-  ++(*a_nv);
-#else
-  Kokkos::atomic_fetch_add(a, short(1));
-#endif
-}
-
-#ifndef _WIN32
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_increment<int>(volatile int* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock incl %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  int* a_nv = const_cast<int*>(a);
-  ++(*a_nv);
-#else
-  Kokkos::atomic_fetch_add(a, int(1));
-#endif
-}
-#endif
-
-template <>
-KOKKOS_INLINE_FUNCTION void atomic_increment<long long int>(
-    volatile long long int* a) {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64) && \
-    !defined(_WIN32) && !defined(__CUDA_ARCH__)
-#if defined(KOKKOS_ENABLE_RFO_PREFETCH)
-  _mm_prefetch((const char*)a, _MM_HINT_ET0);
-#endif
-  __asm__ __volatile__("lock incq %0"
-                       : /* no output registers */
-                       : "m"(a[0])
-                       : "memory");
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  long long int* a_nv = const_cast<long long int*>(a);
-  ++(*a_nv);
-#else
-  using T = long long int;
-  Kokkos::atomic_fetch_add(a, T(1));
-#endif
-}
-
-template <typename T>
-KOKKOS_INLINE_FUNCTION void atomic_increment(volatile T* a) {
-#if defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-  T* a_nv = const_cast<T*>(a);
-  ++(*a_nv);
-#else
-  Kokkos::atomic_fetch_add(a, T(1));
-#endif
-}
-
-}  // End of namespace Kokkos
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Load.hpp b/core/src/impl/Kokkos_Atomic_Load.hpp
deleted file mode 100644
index fc4a04b501..0000000000
--- a/core/src/impl/Kokkos_Atomic_Load.hpp
+++ /dev/null
@@ -1,201 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_IMPL_KOKKOS_ATOMIC_LOAD_HPP
-#define KOKKOS_IMPL_KOKKOS_ATOMIC_LOAD_HPP
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP)
-
-#include <impl/Kokkos_Atomic_Memory_Order.hpp>
-#include <impl/Kokkos_Atomic_Generic.hpp>
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp>
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-// Olivier's implementation helpfully binds to the same builtins as GNU, so
-// we make this code common across multiple options
-#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) ||   \
-    (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-
-#if defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
-#else
-#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
-#endif
-
-template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH T _atomic_load(
-    T* ptr, MemoryOrder,
-    std::enable_if_t<(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-                      sizeof(T) == 8) &&
-                         std::is_same<typename MemoryOrder::memory_order,
-                                      std::remove_cv_t<MemoryOrder>>::value,
-                     void const**> = nullptr) {
-  return __atomic_load_n(ptr, MemoryOrder::gnu_constant);
-}
-
-template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH T _atomic_load(
-    T* ptr, MemoryOrder,
-    std::enable_if_t<!(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-                       sizeof(T) == 8) &&
-                         std::is_default_constructible<T>::value &&
-                         std::is_same<typename MemoryOrder::memory_order,
-                                      std::remove_cv_t<MemoryOrder>>::value,
-                     void const**> = nullptr) {
-  T rv{};
-  __atomic_load(ptr, &rv, MemoryOrder::gnu_constant);
-  return rv;
-}
-
-#undef KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-
-#elif defined(__CUDA_ARCH__)
-
-// Not compiling for Volta or later, or Cuda ASM atomics were manually disabled
-
-template <class T>
-__device__ __inline__ T _relaxed_atomic_load_impl(
-    T* ptr, std::enable_if_t<(sizeof(T) == 1 || sizeof(T) == 2 ||
-                              sizeof(T) == 4 || sizeof(T) == 8),
-                             void const**> = nullptr) {
-  return *ptr;
-}
-
-template <class T>
-struct NoOpOper {
-  __device__ __inline__ static constexpr T apply(T const& t,
-                                                 T const&) noexcept {
-    return t;
-  }
-};
-
-template <class T>
-__device__ __inline__ T _relaxed_atomic_load_impl(
-    T* ptr, std::enable_if_t<!(sizeof(T) == 1 || sizeof(T) == 2 ||
-                               sizeof(T) == 4 || sizeof(T) == 8),
-                             void const**> = nullptr) {
-  T rv{};
-  // TODO remove a copy operation here?
-  return Kokkos::Impl::atomic_oper_fetch(NoOpOper<T>{}, ptr, rv);
-}
-
-template <class T>
-__device__ __inline__ T _atomic_load(T* ptr, memory_order_seq_cst_t) {
-  Kokkos::memory_fence();
-  T rv = Impl::_relaxed_atomic_load_impl(ptr);
-  Kokkos::memory_fence();
-  return rv;
-}
-
-template <class T>
-__device__ __inline__ T _atomic_load(T* ptr, memory_order_acquire_t) {
-  T rv = Impl::_relaxed_atomic_load_impl(ptr);
-  Kokkos::memory_fence();
-  return rv;
-}
-
-template <class T>
-__device__ __inline__ T _atomic_load(T* ptr, memory_order_relaxed_t) {
-  return _relaxed_atomic_load_impl(ptr);
-}
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <class T, class MemoryOrder>
-inline T _atomic_load(T* ptr, MemoryOrder) {
-  // AFAICT, all OpenMP atomics are sequentially consistent, so memory order
-  // doesn't matter
-  T retval{};
-#pragma omp atomic read
-  { retval = *ptr; }
-  return retval;
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <class T, class MemoryOrder>
-inline T _atomic_load(T* ptr, MemoryOrder) {
-  return *ptr;
-}
-
-#elif defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
-
-template <class T, class MemoryOrder>
-inline T _atomic_load(T* ptr, MemoryOrder) {
-  atomic_compare_exchange(ptr, 0, 0);
-  return *ptr;
-}
-
-#endif  // end of all atomic implementations
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
-                                          Impl::memory_order_seq_cst_t) {
-  return _atomic_load(ptr, Impl::memory_order_seq_cst);
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
-                                          Impl::memory_order_acquire_t) {
-  return _atomic_load(ptr, Impl::memory_order_acquire);
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr,
-                                          Impl::memory_order_relaxed_t) {
-  return _atomic_load(ptr, Impl::memory_order_relaxed);
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* /*ptr*/,
-                                          Impl::memory_order_release_t) {
-  static_assert(
-      sizeof(T) == 0,  // just something that will always be false, but only on
-                       // instantiation
-      "atomic_load with memory order release doesn't make any sense!");
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* /*ptr*/,
-                                          Impl::memory_order_acq_rel_t) {
-  static_assert(
-      sizeof(T) == 0,  // just something that will always be false, but only on
-                       // instantiation
-      "atomic_load with memory order acq_rel doesn't make any sense!");
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION T atomic_load(T* ptr) {
-  // relaxed by default!
-  return _atomic_load(ptr, Impl::memory_order_relaxed);
-}
-
-}  // end namespace Impl
-}  // end namespace Kokkos
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp>
-#endif
-
-#endif  // defined(KOKKOS_ATOMIC_HPP)
-#endif  // KOKKOS_IMPL_KOKKOS_ATOMIC_LOAD_HPP
diff --git a/core/src/impl/Kokkos_Atomic_Memory_Order.hpp b/core/src/impl/Kokkos_Atomic_Memory_Order.hpp
deleted file mode 100644
index d8c6821267..0000000000
--- a/core/src/impl/Kokkos_Atomic_Memory_Order.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_KOKKOS_ATOMIC_MEMORY_ORDER_HPP
-#define KOKKOS_KOKKOS_ATOMIC_MEMORY_ORDER_HPP
-
-#include <Kokkos_Macros.hpp>
-
-#include <atomic>
-
-namespace Kokkos {
-namespace Impl {
-
-/** @file
- * Provides strongly-typed analogs of the standard memory order enumerators.
- * In addition to (very slightly) reducing the constant propagation burden on
- * the compiler, this allows us to give compile-time errors for things that
- * don't make sense, like atomic_load with memory order release.
- */
-
-struct memory_order_seq_cst_t {
-  using memory_order = memory_order_seq_cst_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
-    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  static constexpr auto gnu_constant = __ATOMIC_SEQ_CST;
-#endif
-  static constexpr auto std_constant = std::memory_order_seq_cst;
-};
-constexpr memory_order_seq_cst_t memory_order_seq_cst = {};
-
-struct memory_order_relaxed_t {
-  using memory_order = memory_order_relaxed_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
-    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  static constexpr auto gnu_constant = __ATOMIC_RELAXED;
-#endif
-  static constexpr auto std_constant = std::memory_order_relaxed;
-};
-constexpr memory_order_relaxed_t memory_order_relaxed = {};
-
-struct memory_order_acquire_t {
-  using memory_order = memory_order_acquire_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
-    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  static constexpr auto gnu_constant = __ATOMIC_ACQUIRE;
-#endif
-  static constexpr auto std_constant = std::memory_order_acquire;
-};
-constexpr memory_order_acquire_t memory_order_acquire = {};
-
-struct memory_order_release_t {
-  using memory_order = memory_order_release_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
-    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  static constexpr auto gnu_constant = __ATOMIC_RELEASE;
-#endif
-  static constexpr auto std_constant = std::memory_order_release;
-};
-constexpr memory_order_release_t memory_order_release = {};
-
-struct memory_order_acq_rel_t {
-  using memory_order = memory_order_acq_rel_t;
-#if defined(KOKKOS_ENABLE_GNU_ATOMICS) ||   \
-    defined(KOKKOS_ENABLE_INTEL_ATOMICS) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-  static constexpr auto gnu_constant = __ATOMIC_ACQ_REL;
-#endif
-  static constexpr auto std_constant = std::memory_order_acq_rel;
-};
-constexpr memory_order_acq_rel_t memory_order_acq_rel = {};
-
-// Intentionally omit consume (for now)
-
-}  // end namespace Impl
-}  // end namespace Kokkos
-
-#endif  // KOKKOS_KOKKOS_ATOMIC_MEMORY_ORDER_HPP
diff --git a/core/src/impl/Kokkos_Atomic_MinMax.hpp b/core/src/impl/Kokkos_Atomic_MinMax.hpp
deleted file mode 100644
index 42898c82a4..0000000000
--- a/core/src/impl/Kokkos_Atomic_MinMax.hpp
+++ /dev/null
@@ -1,291 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP) && !defined(KOKKOS_ATOMIC_MINMAX_HPP)
-#define KOKKOS_ATOMIC_MINMAX_HPP
-
-namespace Kokkos {
-
-//----------------------------------------------------------------------------
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#if defined(__CUDA_ARCH__) || defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
-
-// Support for int, unsigned int, unsigned long long int, and float
-
-// Atomic_fetch_{min,max}
-
-#ifdef KOKKOS_IMPL_CUDA_CLANG_WORKAROUND
-
-// Host implementations for CLANG compiler
-
-inline __host__ int atomic_fetch_min(volatile int* const dest, const int val) {
-  return Impl::atomic_fetch_oper(Impl::MinOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __host__ unsigned int atomic_fetch_min(volatile unsigned int* const dest,
-                                              const unsigned int val) {
-  return Impl::atomic_fetch_oper(
-      Impl::MinOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __host__ unsigned long long int atomic_fetch_min(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_fetch_oper(Impl::MinOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-inline __host__ int atomic_fetch_max(volatile int* const dest, const int val) {
-  return Impl::atomic_fetch_oper(Impl::MaxOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __host__ unsigned int atomic_fetch_max(volatile unsigned int* const dest,
-                                              const unsigned int val) {
-  return Impl::atomic_fetch_oper(
-      Impl::MaxOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __host__ unsigned long long int atomic_fetch_max(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_fetch_oper(Impl::MaxOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-#endif
-
-#if (350 > __CUDA_ARCH__)
-
-// Fallback for atomic{Min,Max} for Kepler
-
-inline __device__ int atomic_fetch_min(volatile int* const dest,
-                                       const int val) {
-  return Impl::atomic_fetch_oper(Impl::MinOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __device__ unsigned int atomic_fetch_min(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return Impl::atomic_fetch_oper(
-      Impl::MinOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __device__ unsigned long long int atomic_fetch_min(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_fetch_oper(Impl::MinOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-inline __device__ int atomic_fetch_max(volatile int* const dest,
-                                       const int val) {
-  return Impl::atomic_fetch_oper(Impl::MaxOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __device__ unsigned int atomic_fetch_max(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return Impl::atomic_fetch_oper(
-      Impl::MaxOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __device__ unsigned long long int atomic_fetch_max(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_fetch_oper(Impl::MaxOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-#else  // Supported by devices of compute capability 3.5 and higher
-
-inline __device__ int atomic_fetch_min(volatile int* const dest,
-                                       const int val) {
-  return atomicMin((int*)dest, val);
-}
-
-inline __device__ unsigned int atomic_fetch_min(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return atomicMin((unsigned int*)dest, val);
-}
-
-inline __device__ unsigned long long int atomic_fetch_min(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return atomicMin((unsigned long long int*)dest, val);
-}
-
-inline __device__ int atomic_fetch_max(volatile int* const dest,
-                                       const int val) {
-  return atomicMax((int*)dest, val);
-}
-
-inline __device__ unsigned int atomic_fetch_max(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return atomicMax((unsigned int*)dest, val);
-}
-
-inline __device__ unsigned long long int atomic_fetch_max(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return atomicMax((unsigned long long int*)dest, val);
-}
-
-#endif
-
-// Atomic_{min,max}_fetch
-
-#ifdef KOKKOS_IMPL_CUDA_CLANG_WORKAROUND
-
-// Host implementations for CLANG compiler
-
-inline __host__ int atomic_min_fetch(volatile int* const dest, const int val) {
-  return Impl::atomic_oper_fetch(Impl::MinOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __host__ unsigned int atomic_min_fetch(volatile unsigned int* const dest,
-                                              const unsigned int val) {
-  return Impl::atomic_oper_fetch(
-      Impl::MinOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __host__ unsigned long long int atomic_min_fetch(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_oper_fetch(Impl::MinOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-inline __host__ int atomic_max_fetch(volatile int* const dest, const int val) {
-  return Impl::atomic_oper_fetch(Impl::MaxOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __host__ unsigned int atomic_max_fetch(volatile unsigned int* const dest,
-                                              const unsigned int val) {
-  return Impl::atomic_oper_fetch(
-      Impl::MaxOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __host__ unsigned long long int atomic_max_fetch(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_oper_fetch(Impl::MaxOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-#endif
-
-#if (350 > __CUDA_ARCH__)
-
-// Fallback for atomic{Min,Max} for Kepler
-
-inline __device__ int atomic_min_fetch(volatile int* const dest,
-                                       const int val) {
-  return Impl::atomic_oper_fetch(Impl::MinOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __device__ unsigned int atomic_min_fetch(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return Impl::atomic_oper_fetch(
-      Impl::MinOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __device__ unsigned long long int atomic_min_fetch(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_oper_fetch(Impl::MinOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-inline __device__ int atomic_max_fetch(volatile int* const dest,
-                                       const int val) {
-  return Impl::atomic_oper_fetch(Impl::MaxOper<const int, const int>(), dest,
-                                 val);
-}
-
-inline __device__ unsigned int atomic_max_fetch(
-    volatile unsigned int* const dest, const unsigned int val) {
-  return Impl::atomic_oper_fetch(
-      Impl::MaxOper<const unsigned int, const unsigned int>(), dest, val);
-}
-
-inline __device__ unsigned long long int atomic_max_fetch(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  return Impl::atomic_oper_fetch(Impl::MaxOper<const unsigned long long int,
-                                               const unsigned long long int>(),
-                                 dest, val);
-}
-
-#else  // Supported by devices of compute capability 3.5 and higher
-
-inline __device__ int atomic_min_fetch(volatile int* const dest,
-                                       const int val) {
-  const int old = atomicMin((int*)dest, val);
-  return old < val ? old : val;
-}
-
-inline __device__ unsigned int atomic_min_fetch(
-    volatile unsigned int* const dest, const unsigned int val) {
-  const unsigned int old = atomicMin((unsigned int*)dest, val);
-  return old < val ? old : val;
-}
-
-inline __device__ unsigned long long int atomic_min_fetch(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  const unsigned long long old = atomicMin((unsigned long long*)dest, val);
-  return old < val ? old : val;
-}
-
-inline __device__ int atomic_max_fetch(volatile int* const dest,
-                                       const int val) {
-  const int old = atomicMax((int*)dest, val);
-  return old >= val ? old : val;
-}
-
-inline __device__ unsigned int atomic_max_fetch(
-    volatile unsigned int* const dest, const unsigned int val) {
-  const unsigned int old = atomicMax((unsigned int*)dest, val);
-  return old >= val ? old : val;
-}
-
-inline __device__ unsigned long long int atomic_max_fetch(
-    volatile unsigned long long int* const dest,
-    const unsigned long long int val) {
-  const unsigned long long old = atomicMax((unsigned long long*)dest, val);
-  return old >= val ? old : val;
-}
-
-#endif
-
-#endif
-#endif
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Atomic_Store.hpp b/core/src/impl/Kokkos_Atomic_Store.hpp
deleted file mode 100644
index 3c82e0e3dd..0000000000
--- a/core/src/impl/Kokkos_Atomic_Store.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_IMPL_KOKKOS_ATOMIC_STORE_HPP
-#define KOKKOS_IMPL_KOKKOS_ATOMIC_STORE_HPP
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ATOMIC_HPP)
-
-#include <impl/Kokkos_Atomic_Memory_Order.hpp>
-#include <impl/Kokkos_Atomic_Generic.hpp>
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp>
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-// Olivier's implementation helpfully binds to the same builtins as GNU, so
-// we make this code common across multiple options
-#if (defined(KOKKOS_ENABLE_GNU_ATOMICS) && !defined(__CUDA_ARCH__)) ||   \
-    (defined(KOKKOS_ENABLE_INTEL_ATOMICS) && !defined(__CUDA_ARCH__)) || \
-    defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-
-#if defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA_ASM_ATOMICS)
-#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH __inline__ __device__
-#else
-#define KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH inline
-#endif
-
-template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH void _atomic_store(
-    T* ptr, T val, MemoryOrder,
-    std::enable_if_t<(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-                      sizeof(T) == 8) &&
-                         std::is_same<typename MemoryOrder::memory_order,
-                                      std::remove_cv_t<MemoryOrder>>::value,
-                     void const**> = nullptr) {
-  __atomic_store_n(ptr, val, MemoryOrder::gnu_constant);
-}
-
-template <class T, class MemoryOrder>
-KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH void _atomic_store(
-    T* ptr, T val, MemoryOrder,
-    std::enable_if_t<!(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-                       sizeof(T) == 8) &&
-                         std::is_default_constructible<T>::value &&
-                         std::is_same<typename MemoryOrder::memory_order,
-                                      std::remove_cv_t<MemoryOrder>>::value,
-                     void const**> = nullptr) {
-  __atomic_store(ptr, &val, MemoryOrder::gnu_constant);
-}
-
-#undef KOKKOS_INTERNAL_INLINE_DEVICE_IF_CUDA_ARCH
-
-#elif defined(__CUDA_ARCH__)
-
-// Not compiling for Volta or later, or Cuda ASM atomics were manually disabled
-
-template <class T>
-__device__ __inline__ void _relaxed_atomic_store_impl(
-    T* ptr, T val,
-    std::enable_if_t<(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-                      sizeof(T) == 8),
-                     void const**> = nullptr) {
-  *ptr = val;
-}
-
-template <class T>
-struct StoreOper {
-  __device__ __inline__ static constexpr T apply(T const&,
-                                                 T const& val) noexcept {
-    return val;
-  }
-};
-
-template <class T>
-__device__ __inline__ void _relaxed_atomic_store_impl(
-    T* ptr, T val,
-    std::enable_if_t<!(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
-                       sizeof(T) == 8),
-                     void const**> = nullptr) {
-  Kokkos::Impl::atomic_oper_fetch(StoreOper<T>{}, ptr, (T &&) val);
-}
-
-template <class T>
-__device__ __inline__ void _atomic_store(T* ptr, T val,
-                                         memory_order_seq_cst_t) {
-  Kokkos::memory_fence();
-  Impl::_relaxed_atomic_store_impl(ptr, val);
-  Kokkos::memory_fence();
-}
-
-template <class T>
-__device__ __inline__ void _atomic_store(T* ptr, T val,
-                                         memory_order_release_t) {
-  Kokkos::memory_fence();
-  _relaxed_atomic_store_impl(ptr, val);
-}
-
-template <class T>
-__device__ __inline__ void _atomic_store(T* ptr, T val,
-                                         memory_order_relaxed_t) {
-  _relaxed_atomic_store_impl(ptr, val);
-}
-
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-
-template <class T, class MemoryOrder>
-inline void _atomic_store(T* ptr, T val, MemoryOrder) {
-  // AFAICT, all OpenMP atomics are sequentially consistent, so memory order
-  // doesn't matter
-#pragma omp atomic write
-  { *ptr = val; }
-}
-
-#elif defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-
-template <class T, class MemoryOrder>
-inline void _atomic_store(T* ptr, T val, MemoryOrder) {
-  *ptr = val;
-}
-
-#elif defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
-
-template <class T, class MemoryOrder>
-inline void _atomic_store(T* ptr, T val, MemoryOrder) {
-  atomic_exchange(ptr, val);
-}
-
-#endif  // end of all atomic implementations
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
-                                              Impl::memory_order_seq_cst_t) {
-  _atomic_store(ptr, val, Impl::memory_order_seq_cst);
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
-                                              Impl::memory_order_release_t) {
-  _atomic_store(ptr, val, Impl::memory_order_release);
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val,
-                                              Impl::memory_order_relaxed_t) {
-  _atomic_store(ptr, val, Impl::memory_order_relaxed);
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* /*ptr*/, T /*val*/,
-                                              Impl::memory_order_acquire_t) {
-  static_assert(
-      sizeof(T) == 0,  // just something that will always be false, but only on
-                       // instantiation
-      "atomic_store with memory order acquire doesn't make any sense!");
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* /*ptr*/, T /*val*/,
-                                              Impl::memory_order_acq_rel_t) {
-  static_assert(
-      sizeof(T) == 0,  // just something that will always be false, but only on
-                       // instantiation
-      "atomic_store with memory order acq_rel doesn't make any sense!");
-}
-
-template <class T>
-KOKKOS_FORCEINLINE_FUNCTION void atomic_store(T* ptr, T val) {
-  // relaxed by default!
-  _atomic_store(ptr, val, Impl::memory_order_relaxed);
-}
-
-}  // end namespace Impl
-}  // end namespace Kokkos
-
-#if defined(KOKKOS_ENABLE_CUDA)
-#include <Cuda/Kokkos_Cuda_Atomic_Intrinsics_Restore_Builtins.hpp>
-#endif
-
-#endif  // defined(KOKKOS_ATOMIC_HPP)
-#endif  // KOKKOS_IMPL_KOKKOS_ATOMIC_STORE_HPP
diff --git a/core/src/impl/Kokkos_Atomic_View.hpp b/core/src/impl/Kokkos_Atomic_View.hpp
index 45d01c9f9f..23d4c2524c 100644
--- a/core/src/impl/Kokkos_Atomic_View.hpp
+++ b/core/src/impl/Kokkos_Atomic_View.hpp
@@ -39,7 +39,7 @@ class AtomicDataElement {
 
   KOKKOS_INLINE_FUNCTION
   const_value_type operator=(const_value_type& val) const {
-    Kokkos::Impl::atomic_store(ptr, val, Kokkos::Impl::memory_order_relaxed);
+    Kokkos::atomic_store(ptr, val);
     return val;
   }
 
@@ -194,9 +194,7 @@ class AtomicDataElement {
   bool operator>(const_value_type& val) const { return *ptr > val; }
 
   KOKKOS_INLINE_FUNCTION
-  operator value_type() const {
-    return Kokkos::Impl::atomic_load(ptr, Kokkos::Impl::memory_order_relaxed);
-  }
+  operator value_type() const { return Kokkos::atomic_load(ptr); }
 };
 
 template <class ViewTraits>
diff --git a/core/src/impl/Kokkos_Atomic_Windows.hpp b/core/src/impl/Kokkos_Atomic_Windows.hpp
deleted file mode 100644
index ffb0d2bae2..0000000000
--- a/core/src/impl/Kokkos_Atomic_Windows.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-#ifndef KOKKOS_ATOMIC_WINDOWS_HPP
-#define KOKKOS_ATOMIC_WINDOWS_HPP
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <winsock2.h>
-#include <windows.h>
-
-namespace Kokkos {
-namespace Impl {
-#ifdef _MSC_VER
-_declspec(align(16))
-#endif
-    struct cas128_t {
-  LONGLONG lower;
-  LONGLONG upper;
-  KOKKOS_INLINE_FUNCTION
-  bool operator!=(const cas128_t& a) const {
-    return (lower != a.lower) || upper != a.upper;
-  }
-}
-#if defined(__GNUC__) || defined(__clang__)
-__attribute__((aligned(16)))
-#endif
-;
-}  // namespace Impl
-
-#if !defined(__CUDA_ARCH__) || defined(__clang__)
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(CHAR), const T&> val) {
-  union U {
-    CHAR i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U(){};
-  } tmp;
-
-  tmp.i = _InterlockedCompareExchange8((CHAR*)dest, *((CHAR*)&val),
-                                       *((CHAR*)&compare));
-  return tmp.t;
-}
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(SHORT), const T&> val) {
-  union U {
-    SHORT i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U(){};
-  } tmp;
-
-  tmp.i = _InterlockedCompareExchange16((SHORT*)dest, *((SHORT*)&val),
-                                        *((SHORT*)&compare));
-  return tmp.t;
-}
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(LONG), const T&> val) {
-  union U {
-    LONG i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-  tmp.i = _InterlockedCompareExchange((LONG*)dest, *((LONG*)&val),
-                                      *((LONG*)&compare));
-  return tmp.t;
-}
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(LONGLONG), const T&> val) {
-  union U {
-    LONGLONG i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U() {}
-  } tmp;
-
-  tmp.i = _InterlockedCompareExchange64((LONGLONG*)dest, *((LONGLONG*)&val),
-                                        *((LONGLONG*)&compare));
-  return tmp.t;
-}
-
-template <typename T>
-inline T atomic_compare_exchange(
-    volatile T* const dest, const T& compare,
-    std::enable_if_t<sizeof(T) == sizeof(Impl::cas128_t), const T&> val) {
-  T compare_and_result(compare);
-  union U {
-    Impl::cas128_t i;
-    T t;
-    KOKKOS_INLINE_FUNCTION U(){};
-  } newval;
-  newval.t = val;
-  _InterlockedCompareExchange128((LONGLONG*)dest, newval.i.upper,
-                                 newval.i.lower,
-                                 ((LONGLONG*)&compare_and_result));
-  return compare_and_result;
-}
-#endif
-
-}  // namespace Kokkos
-#endif
-#endif
diff --git a/core/src/impl/Kokkos_BitOps.hpp b/core/src/impl/Kokkos_BitOps.hpp
index 16a28f2419..0d83127df9 100644
--- a/core/src/impl/Kokkos_BitOps.hpp
+++ b/core/src/impl/Kokkos_BitOps.hpp
@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <climits>
 
-#ifdef KOKKOS_COMPILER_INTEL
+#if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
 #include <immintrin.h>
 #endif
 
@@ -45,7 +45,7 @@ inline int int_log2_device(unsigned i) {
 #if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
   constexpr int shift = sizeof(unsigned) * CHAR_BIT - 1;
   return shift - __clz(i);
-#elif defined(KOKKOS_COMPILER_INTEL)
+#elif defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return _bit_scan_reverse(i);
 #else
   return int_log2_fallback(i);
@@ -55,7 +55,7 @@ inline int int_log2_device(unsigned i) {
 KOKKOS_IMPL_HOST_FUNCTION
 inline int int_log2_host(unsigned i) {
 // duplicating shift to avoid unused warning in else branch
-#if defined(KOKKOS_COMPILER_INTEL)
+#if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   constexpr int shift = sizeof(unsigned) * CHAR_BIT - 1;
   (void)shift;
   return _bit_scan_reverse(i);
@@ -104,7 +104,7 @@ inline int bit_first_zero_device(unsigned i) noexcept {
   constexpr unsigned full = ~0u;
 #if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
   return full != i ? __ffs(~i) - 1 : -1;
-#elif defined(KOKKOS_COMPILER_INTEL)
+#elif defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return full != i ? _bit_scan_forward(~i) : -1;
 #else
   (void)full;
@@ -115,7 +115,7 @@ inline int bit_first_zero_device(unsigned i) noexcept {
 KOKKOS_IMPL_HOST_FUNCTION
 inline int bit_first_zero_host(unsigned i) noexcept {
   constexpr unsigned full = ~0u;
-#if defined(KOKKOS_COMPILER_INTEL)
+#if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return full != i ? _bit_scan_forward(~i) : -1;
 #elif defined(KOKKOS_COMPILER_CRAYC)
   return full != i ? _popcnt(i ^ (i + 1)) - 1 : -1;
@@ -153,7 +153,7 @@ int bit_scan_forward_fallback(unsigned i) {
 KOKKOS_IMPL_DEVICE_FUNCTION inline int bit_scan_forward_device(unsigned i) {
 #if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
   return __ffs(i) - 1;
-#elif defined(KOKKOS_COMPILER_INTEL)
+#elif defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return _bit_scan_forward(i);
 #else
   return bit_scan_forward_fallback(i);
@@ -161,7 +161,7 @@ KOKKOS_IMPL_DEVICE_FUNCTION inline int bit_scan_forward_device(unsigned i) {
 }
 
 KOKKOS_IMPL_HOST_FUNCTION inline int bit_scan_forward_host(unsigned i) {
-#if defined(KOKKOS_COMPILER_INTEL)
+#if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return _bit_scan_forward(i);
 #elif defined(KOKKOS_COMPILER_CRAYC)
   return i ? _popcnt(~i & (i - 1)) : -1;
@@ -200,7 +200,7 @@ int bit_count_fallback(unsigned i) {
 KOKKOS_IMPL_DEVICE_FUNCTION inline int bit_count_device(unsigned i) {
 #if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
   return __popc(i);
-#elif defined(KOKKOS_COMPILER_INTEL)
+#elif defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return _popcnt32(i);
 #else
   return bit_count_fallback(i);
@@ -208,7 +208,7 @@ KOKKOS_IMPL_DEVICE_FUNCTION inline int bit_count_device(unsigned i) {
 }
 
 KOKKOS_IMPL_HOST_FUNCTION inline int bit_count_host(unsigned i) {
-#if defined(KOKKOS_COMPILER_INTEL)
+#if defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)
   return _popcnt32(i);
 #elif defined(KOKKOS_COMPILER_CRAYC)
   return _popcnt(i);
diff --git a/core/src/impl/Kokkos_CPUDiscovery.cpp b/core/src/impl/Kokkos_CPUDiscovery.cpp
index 85ffaaf969..6ff7718cb5 100644
--- a/core/src/impl/Kokkos_CPUDiscovery.cpp
+++ b/core/src/impl/Kokkos_CPUDiscovery.cpp
@@ -54,3 +54,5 @@ int Kokkos::Impl::mpi_local_rank_on_node() {
   }
   return -1;
 }
+
+bool Kokkos::Impl::mpi_detected() { return mpi_local_rank_on_node() != -1; }
diff --git a/core/src/impl/Kokkos_CPUDiscovery.hpp b/core/src/impl/Kokkos_CPUDiscovery.hpp
index 27b8cd3a7c..a049fd804a 100644
--- a/core/src/impl/Kokkos_CPUDiscovery.hpp
+++ b/core/src/impl/Kokkos_CPUDiscovery.hpp
@@ -18,6 +18,8 @@ namespace Impl {
 
 int mpi_ranks_per_node();
 int mpi_local_rank_on_node();
+// returns true if MPI execution environment is detected, false otherwise.
+bool mpi_detected();
 
 }  // namespace Impl
 }  // namespace Kokkos
diff --git a/core/src/impl/Kokkos_ChaseLev.hpp b/core/src/impl/Kokkos_ChaseLev.hpp
index 855654408e..d8ab77b205 100644
--- a/core/src/impl/Kokkos_ChaseLev.hpp
+++ b/core/src/impl/Kokkos_ChaseLev.hpp
@@ -172,7 +172,8 @@ struct ChaseLevDeque {
         }
 #else
         if (!Impl::atomic_compare_exchange_strong(
-                &m_top, t, t + 1, memory_order_seq_cst, memory_order_relaxed)) {
+                &m_top, t, t + 1, desul::MemoryOrderSeqCst(),
+                desul::MemoryOrderRelaxed())) {
           /* failed race, someone else stole it */
           return_value = nullptr;
         }
@@ -195,7 +196,7 @@ struct ChaseLevDeque {
   KOKKOS_INLINE_FUNCTION
   bool push(node_type& node) {
     auto b  = m_bottom;  // memory order relaxed
-    auto t  = Impl::atomic_load(&m_top, memory_order_acquire);
+    auto t  = Impl::atomic_load(&m_top, desul::MemoryOrderAcquire());
     auto& a = m_array;
     if (b - t > a.size() - 1) {
       /* queue is full, resize */
@@ -204,7 +205,7 @@ struct ChaseLevDeque {
       return false;
     }
     a[b] = &node;  // relaxed
-    Impl::atomic_store(&m_bottom, b + 1, memory_order_release);
+    Impl::atomic_store(&m_bottom, b + 1, desul::MemoryOrderRelease());
     return true;
   }
 
@@ -213,7 +214,7 @@ struct ChaseLevDeque {
     auto t = m_top;  // TODO @tasking @memory_order DSH: atomic load acquire
     Kokkos::memory_fence();  // seq_cst fence, so why does the above need to be
                              // acquire?
-    auto b = Impl::atomic_load(&m_bottom, memory_order_acquire);
+    auto b = Impl::atomic_load(&m_bottom, desul::MemoryOrderAcquire());
     OptionalRef<T> return_value;
     if (t < b) {
       /* Non-empty queue */
@@ -231,8 +232,9 @@ struct ChaseLevDeque {
         return_value = nullptr;
       }
 #else
-      if (!Impl::atomic_compare_exchange_strong(
-              &m_top, t, t + 1, memory_order_seq_cst, memory_order_relaxed)) {
+      if (!Impl::atomic_compare_exchange_strong(&m_top, t, t + 1,
+                                                desul::MemoryOrderSeqCst(),
+                                                desul::MemoryOrderRelaxed())) {
         return_value = nullptr;
       }
 #endif
@@ -247,7 +249,7 @@ struct ChaseLevDeque {
       // essentially using the memory order in this version as a fence, which
       // may be unnecessary
       auto buffer_ptr = (node_type***)&m_array.buffer;
-      auto a = Impl::atomic_load(buffer_ptr, memory_order_acquire); //
+      auto a = Impl::atomic_load(buffer_ptr, desul::MemoryOrderAcquire()); //
    technically consume ordered, but acquire should be fine return_value =
    *static_cast<T*>(a[t % m_array->size]); // relaxed; we'd have to replace the
    m_array->size if we ever allow growth
diff --git a/core/src/impl/Kokkos_ClockTic.hpp b/core/src/impl/Kokkos_ClockTic.hpp
index 9e8c70076c..6e3d99ebd6 100644
--- a/core/src/impl/Kokkos_ClockTic.hpp
+++ b/core/src/impl/Kokkos_ClockTic.hpp
@@ -90,6 +90,27 @@ KOKKOS_IMPL_HOST_FUNCTION inline uint64_t clock_tic_host() noexcept {
 
   return (uint64_t)cycles;
 
+#elif defined(__ppc__)
+  // see : pages.cs.wisc.edu/~legault/miniproj-736.pdf or
+  // cmssdt.cern.ch/lxr/source/FWCore/Utilities/interface/HRRealTime.h
+
+  uint64_t result = 0;
+  uint32_t upper, lower, tmp;
+
+  __asm__ volatile(
+      "0: \n"
+      "\tmftbu %0     \n"
+      "\tmftb  %1     \n"
+      "\tmftbu %2     \n"
+      "\tcmpw  %2, %0 \n"
+      "\tbne   0b     \n"
+      : "=r"(upper), "=r"(lower), "=r"(tmp));
+  result = upper;
+  result = result << 32;
+  result = result | lower;
+
+  return (result);
+
 #else
 
   return std::chrono::high_resolution_clock::now().time_since_epoch().count();
diff --git a/core/src/impl/Kokkos_Combined_Reducer.hpp b/core/src/impl/Kokkos_Combined_Reducer.hpp
index d7304779c7..e6dd3c6339 100644
--- a/core/src/impl/Kokkos_Combined_Reducer.hpp
+++ b/core/src/impl/Kokkos_Combined_Reducer.hpp
@@ -210,6 +210,8 @@ struct CombinedReducerImpl<std::integer_sequence<size_t, Idxs...>, Space,
      ...);
   }
 
+  KOKKOS_FUNCTION auto& reference() const { return *m_value_view.data(); }
+
   // TODO figure out if we also need to call through to final
 
   KOKKOS_FUNCTION
@@ -247,6 +249,22 @@ struct CombinedReducerImpl<std::integer_sequence<size_t, Idxs...>, Space,
 
      ...);
   }
+
+  template <int Idx, class View>
+  KOKKOS_FUNCTION static void write_one_value_back_on_device(
+      View const& inputView, typename View::const_value_type& value) noexcept {
+    *inputView.data() = value;
+  }
+
+  template <typename... CombinedReducers>
+  KOKKOS_FUNCTION void write_value_back_to_original_references_on_device(
+      value_type const& value,
+      CombinedReducers const&... reducers_that_reference_original_values) noexcept {
+    (write_one_value_back_on_device<Idxs>(
+         reducers_that_reference_original_values.view(),
+         value.template get<Idxs, typename CombinedReducers::value_type>()),
+     ...);
+  }
 };
 
 // Apparently this can't be an alias template because of a bug/unimplemented
@@ -466,9 +484,9 @@ KOKKOS_INLINE_FUNCTION constexpr auto make_combined_reducer(
   //----------------------------------------
 }
 
-template <class Functor, class Space, class... ReferencesOrViewsOrReducers>
+template <class Space, class Functor, class... ReferencesOrViewsOrReducers>
 KOKKOS_INLINE_FUNCTION constexpr auto make_wrapped_combined_functor(
-    Functor const& functor, Space, ReferencesOrViewsOrReducers&&...) {
+    Functor const& functor, ReferencesOrViewsOrReducers&&...) {
   //----------------------------------------
   return CombinedReductionFunctorWrapper<
       Functor, Space,
@@ -478,6 +496,32 @@ KOKKOS_INLINE_FUNCTION constexpr auto make_wrapped_combined_functor(
 
 template <typename FunctorType>
 using functor_has_value_t = typename FunctorType::value_type;
+
+template <typename MemberType, typename BoundaryStructType, typename Functor,
+          typename ReturnType1, typename ReturnType2, typename... ReturnTypes>
+KOKKOS_INLINE_FUNCTION void parallel_reduce_combined_reducers_impl(
+    BoundaryStructType const& boundaries, Functor const& functor,
+    ReturnType1&& returnType1, ReturnType2&& returnType2,
+    ReturnTypes&&... returnTypes) noexcept {
+  using mem_space_type = typename MemberType::execution_space::memory_space;
+
+  decltype(Impl::make_combined_reducer_value<mem_space_type>(
+      returnType1, returnType2, returnTypes...)) combined_value;
+
+  auto combined_functor = Impl::make_wrapped_combined_functor<mem_space_type>(
+      functor, returnType1, returnType2, returnTypes...);
+
+  auto combined_reducer = Impl::make_combined_reducer<mem_space_type>(
+      combined_value, returnType1, returnType2, returnTypes...);
+
+  parallel_reduce(boundaries, combined_functor, combined_reducer);
+
+  combined_reducer.write_value_back_to_original_references_on_device(
+      combined_value, Impl::_make_reducer_from_arg<mem_space_type>(returnType1),
+      Impl::_make_reducer_from_arg<mem_space_type>(returnType2),
+      Impl::_make_reducer_from_arg<mem_space_type>(returnTypes)...);
+}
+
 }  // end namespace Impl
 
 //==============================================================================
@@ -499,8 +543,8 @@ auto parallel_reduce(std::string const& label, PolicyType const& policy,
   // directly
   using space_type = Kokkos::DefaultHostExecutionSpace::memory_space;
 
-  auto value = Impl::make_combined_reducer_value<space_type>(
-      returnType1, returnType2, returnTypes...);
+  decltype(Impl::make_combined_reducer_value<space_type>(
+      returnType1, returnType2, returnTypes...)) value;
 
   using combined_reducer_type = Impl::CombinedReducer<
       space_type, Impl::_reducer_from_arg_t<space_type, ReturnType1>,
@@ -509,8 +553,8 @@ auto parallel_reduce(std::string const& label, PolicyType const& policy,
   auto combined_reducer = Impl::make_combined_reducer<space_type>(
       value, returnType1, returnType2, returnTypes...);
 
-  auto combined_functor = Impl::make_wrapped_combined_functor(
-      functor, space_type{}, returnType1, returnType2, returnTypes...);
+  auto combined_functor = Impl::make_wrapped_combined_functor<space_type>(
+      functor, returnType1, returnType2, returnTypes...);
 
   using combined_functor_type = decltype(combined_functor);
   static_assert(
@@ -577,66 +621,36 @@ void parallel_reduce(size_t n, Functor const& functor,
 //------------------------------------------------------------------------------
 // <editor-fold desc="Team overloads"> {{{2
 
-// Copied three times because that's the best way we have right now to match
-// Impl::TeamThreadRangeBoundariesStruct,
-// Impl::ThreadVectorRangeBoundariesStruct, and
-// Impl::TeamVectorRangeBoundariesStruct.
-// TODO make these work after restructuring
-
-// template <class iType, class MemberType, class Functor, class ReturnType1,
-//          class ReturnType2, class... ReturnTypes>
-// KOKKOS_INLINE_FUNCTION void parallel_reduce(
-//    std::string const& label,
-//    Impl::TeamThreadRangeBoundariesStruct<iType, MemberType> const&
-//    boundaries, Functor const& functor, ReturnType1&& returnType1,
-//    ReturnType2&& returnType2, ReturnTypes&&... returnTypes) noexcept {
-//  const auto combined_reducer =
-//      Impl::make_combined_reducer<Kokkos::AnonymousSpace>(
-//          returnType1, returnType2, returnTypes...);
-//
-//  auto combined_functor = Impl::make_wrapped_combined_functor(
-//      functor, Kokkos::AnonymousSpace{}, returnType1, returnType2,
-//      returnTypes...);
-//
-//  parallel_reduce(label, boundaries, combined_functor, combined_reducer);
-//}
-//
-// template <class iType, class MemberType, class Functor, class ReturnType1,
-//          class ReturnType2, class... ReturnTypes>
-// KOKKOS_INLINE_FUNCTION void parallel_reduce(
-//    std::string const& label,
-//    Impl::ThreadVectorRangeBoundariesStruct<iType, MemberType> const&
-//        boundaries,
-//    Functor const& functor, ReturnType1&& returnType1,
-//    ReturnType2&& returnType2, ReturnTypes&&... returnTypes) noexcept {
-//  const auto combined_reducer =
-//      Impl::make_combined_reducer<Kokkos::AnonymousSpace>(
-//          returnType1, returnType2, returnTypes...);
-//
-//  auto combined_functor = Impl::make_wrapped_combined_functor(
-//      functor, Kokkos::AnonymousSpace{}, returnType1, returnType2,
-//      returnTypes...);
-//
-//  parallel_reduce(label, boundaries, combined_functor, combined_reducer);
-//}
-
-// template <class iType, class MemberType, class Functor, class ReturnType1,
-//          class ReturnType2, class... ReturnTypes>
-// KOKKOS_INLINE_FUNCTION void parallel_reduce(
-//    std::string const& label,
-//    Impl::TeamVectorRangeBoundariesStruct<iType, MemberType> const&
-//    boundaries, Functor const& functor, ReturnType1&& returnType1,
-//    ReturnType2&& returnType2, ReturnTypes&&... returnTypes) noexcept {
-//  const auto combined_reducer =
-//      Impl::make_combined_reducer<Kokkos::AnonymousSpace>(
-//          returnType1, returnType2, returnTypes...);
-//
-//  auto combined_functor = Impl::make_wrapped_combined_functor(
-//      functor, Kokkos::AnonymousSpace{}, returnType1, returnType2,
-//      returnTypes...);
-//
-//  parallel_reduce(label, boundaries, combined_functor, combined_reducer);
-//}
+template <class iType, class MemberType, class Functor, class ReturnType1,
+          class ReturnType2, class... ReturnTypes>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    Impl::TeamThreadRangeBoundariesStruct<iType, MemberType> const& boundaries,
+    Functor const& functor, ReturnType1&& returnType1,
+    ReturnType2&& returnType2, ReturnTypes&&... returnTypes) noexcept {
+  Impl::parallel_reduce_combined_reducers_impl<MemberType>(
+      boundaries, functor, returnType1, returnType2, returnTypes...);
+}
+
+template <class iType, class MemberType, class Functor, class ReturnType1,
+          class ReturnType2, class... ReturnTypes>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    Impl::ThreadVectorRangeBoundariesStruct<iType, MemberType> const&
+        boundaries,
+    Functor const& functor, ReturnType1&& returnType1,
+    ReturnType2&& returnType2, ReturnTypes&&... returnTypes) noexcept {
+  Impl::parallel_reduce_combined_reducers_impl<MemberType>(
+      boundaries, functor, returnType1, returnType2, returnTypes...);
+}
+
+template <class iType, class MemberType, class Functor, class ReturnType1,
+          class ReturnType2, class... ReturnTypes>
+KOKKOS_INLINE_FUNCTION void parallel_reduce(
+    Impl::TeamVectorRangeBoundariesStruct<iType, MemberType> const& boundaries,
+    Functor const& functor, ReturnType1&& returnType1,
+    ReturnType2&& returnType2, ReturnTypes&&... returnTypes) noexcept {
+  Impl::parallel_reduce_combined_reducers_impl<MemberType>(
+      boundaries, functor, returnType1, returnType2, returnTypes...);
+}
 
 // </editor-fold> end Team overloads }}}2
 //------------------------------------------------------------------------------
diff --git a/core/src/impl/Kokkos_Core.cpp b/core/src/impl/Kokkos_Core.cpp
index 5e53e42659..87ad693091 100644
--- a/core/src/impl/Kokkos_Core.cpp
+++ b/core/src/impl/Kokkos_Core.cpp
@@ -165,6 +165,26 @@ bool is_valid_map_device_id_by(std::string const& x) {
 
 }  // namespace
 
+[[nodiscard]] int Kokkos::device_id() noexcept {
+#if defined(KOKKOS_ENABLE_CUDA)
+  return Cuda().cuda_device();
+#elif defined(KOKKOS_ENABLE_HIP)
+  return HIP().hip_device();
+#elif defined(KOKKOS_ENABLE_OPENACC)
+  return Experimental::OpenACC().acc_device_number();
+#elif defined(KOKKOS_ENABLE_OPENMPTARGET)
+  return omp_get_default_device();  // FIXME_OPENMPTARGET
+#elif defined(KOKKOS_ENABLE_SYCL)
+  return Experimental::Impl::SYCLInternal::m_syclDev;
+#else
+  return -1;
+#endif
+}
+
+[[nodiscard]] int Kokkos::num_threads() noexcept {
+  return DefaultHostExecutionSpace().concurrency();
+}
+
 Kokkos::Impl::ExecSpaceManager& Kokkos::Impl::ExecSpaceManager::get_instance() {
   static ExecSpaceManager space_initializer = {};
   return space_initializer;
@@ -500,14 +520,20 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
                                  std::to_string(KOKKOS_COMPILER_INTEL));
   declare_configuration_metadata("tools_only", "compiler_family", "intel");
 #endif
+#ifdef KOKKOS_COMPILER_INTEL_LLVM
+  declare_configuration_metadata("compiler_version",
+                                 "KOKKOS_COMPILER_INTEL_LLVM",
+                                 std::to_string(KOKKOS_COMPILER_INTEL_LLVM));
+  declare_configuration_metadata("tools_only", "compiler_family", "intel_llvm");
+#endif
 #ifdef KOKKOS_COMPILER_NVCC
   declare_configuration_metadata("compiler_version", "KOKKOS_COMPILER_NVCC",
                                  std::to_string(KOKKOS_COMPILER_NVCC));
   declare_configuration_metadata("tools_only", "compiler_family", "nvcc");
 #endif
-#ifdef KOKKOS_COMPILER_PGI
-  declare_configuration_metadata("compiler_version", "KOKKOS_COMPILER_PGI",
-                                 std::to_string(KOKKOS_COMPILER_PGI));
+#ifdef KOKKOS_COMPILER_NVHPC
+  declare_configuration_metadata("compiler_version", "KOKKOS_COMPILER_NVHPC",
+                                 std::to_string(KOKKOS_COMPILER_NVHPC));
   declare_configuration_metadata("tools_only", "compiler_family", "pgi");
 #endif
 #ifdef KOKKOS_COMPILER_MSVC
@@ -516,26 +542,6 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
   declare_configuration_metadata("tools_only", "compiler_family", "msvc");
 #endif
 
-#ifdef KOKKOS_ENABLE_GNU_ATOMICS
-  declare_configuration_metadata("atomics", "KOKKOS_ENABLE_GNU_ATOMICS", "yes");
-#else
-  declare_configuration_metadata("atomics", "KOKKOS_ENABLE_GNU_ATOMICS", "no");
-#endif
-#ifdef KOKKOS_ENABLE_INTEL_ATOMICS
-  declare_configuration_metadata("atomics", "KOKKOS_ENABLE_INTEL_ATOMICS",
-                                 "yes");
-#else
-  declare_configuration_metadata("atomics", "KOKKOS_ENABLE_INTEL_ATOMICS",
-                                 "no");
-#endif
-#ifdef KOKKOS_ENABLE_WINDOWS_ATOMICS
-  declare_configuration_metadata("atomics", "KOKKOS_ENABLE_WINDOWS_ATOMICS",
-                                 "yes");
-#else
-  declare_configuration_metadata("atomics", "KOKKOS_ENABLE_WINDOWS_ATOMICS",
-                                 "no");
-#endif
-
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
   declare_configuration_metadata("vectorization", "KOKKOS_ENABLE_PRAGMA_IVDEP",
                                  "yes");
@@ -743,6 +749,8 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
 #elif defined(KOKKOS_ARCH_AMPERE86)
   declare_configuration_metadata("architecture", "GPU architecture",
                                  "AMPERE86");
+#elif defined(KOKKOS_ARCH_ADA89)
+  declare_configuration_metadata("architecture", "GPU architecture", "ADA89");
 #elif defined(KOKKOS_ARCH_HOPPER90)
   declare_configuration_metadata("architecture", "GPU architecture",
                                  "HOPPER90");
@@ -757,10 +765,19 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
 #elif defined(KOKKOS_ARCH_NAVI1030)
   declare_configuration_metadata("architecture", "GPU architecture",
                                  "NAVI1030");
+#elif defined(KOKKOS_ARCH_NAVI1100)
+  declare_configuration_metadata("architecture", "GPU architecture",
+                                 "NAVI1100");
 
 #else
   declare_configuration_metadata("architecture", "GPU architecture", "none");
 #endif
+
+#ifdef KOKKOS_IMPL_32BIT
+  declare_configuration_metadata("architecture", "platform", "32bit");
+#else
+  declare_configuration_metadata("architecture", "platform", "64bit");
+#endif
 }
 
 void post_initialize_internal(const Kokkos::InitializationSettings& settings) {
@@ -775,8 +792,14 @@ void post_initialize_internal(const Kokkos::InitializationSettings& settings) {
 }
 
 void initialize_internal(const Kokkos::InitializationSettings& settings) {
+  // The tool initialization is only called in post_initialize_internal.
+  // Pausing tools here, so that if someone has set callbacks programmatically
+  // these callbacks are not called inside the backend initialization, before
+  // the tool initialization happened.
+  Kokkos::Tools::Experimental::pause_tools();
   pre_initialize_internal(settings);
   initialize_backends(settings);
+  Kokkos::Tools::Experimental::resume_tools();
   post_initialize_internal(settings);
 }
 
@@ -1268,15 +1291,3 @@ void Kokkos::print_configuration(std::ostream& os, bool verbose) {
 bool Kokkos::show_warnings() noexcept { return g_show_warnings; }
 
 bool Kokkos::tune_internals() noexcept { return g_tune_internals; }
-
-namespace Kokkos {
-
-#ifdef KOKKOS_COMPILER_PGI
-namespace Impl {
-// Bizzarely, an extra jump instruction forces the PGI compiler to not have a
-// bug related to (probably?) empty base optimization and/or aggregate
-// construction.
-void _kokkos_pgi_compiler_bug_workaround() {}
-}  // end namespace Impl
-#endif
-}  // namespace Kokkos
diff --git a/core/src/impl/Kokkos_Default_Graph_Impl.hpp b/core/src/impl/Kokkos_Default_Graph_Impl.hpp
index d65b448f1f..0b11b251bc 100644
--- a/core/src/impl/Kokkos_Default_Graph_Impl.hpp
+++ b/core/src/impl/Kokkos_Default_Graph_Impl.hpp
@@ -23,8 +23,8 @@
 #include <impl/Kokkos_GraphImpl_fwd.hpp>
 #include <impl/Kokkos_Default_Graph_fwd.hpp>
 
-#include <Kokkos_Serial.hpp>
-#include <Kokkos_OpenMP.hpp>
+#include <Serial/Kokkos_Serial.hpp>
+#include <OpenMP/Kokkos_OpenMP.hpp>
 // FIXME @graph other backends?
 
 #include <impl/Kokkos_OptionalRef.hpp>
diff --git a/core/src/impl/Kokkos_Error.cpp b/core/src/impl/Kokkos_Error.cpp
index efd0fb998e..5b4e1a7770 100644
--- a/core/src/impl/Kokkos_Error.cpp
+++ b/core/src/impl/Kokkos_Error.cpp
@@ -151,7 +151,7 @@ namespace Experimental {
 void CudaRawMemoryAllocationFailure::append_additional_error_information(
     std::ostream &o) const {
   if (m_error_code != cudaSuccess) {
-    o << "  The Cuda allocation returned the error code \"\""
+    o << "  The Cuda allocation returned the error code \""
       << cudaGetErrorName(m_error_code) << "\".";
   }
 }
diff --git a/core/src/impl/Kokkos_ExecSpaceManager.hpp b/core/src/impl/Kokkos_ExecSpaceManager.hpp
index f0edc8ac47..58ed54275a 100644
--- a/core/src/impl/Kokkos_ExecSpaceManager.hpp
+++ b/core/src/impl/Kokkos_ExecSpaceManager.hpp
@@ -102,9 +102,7 @@ constexpr bool check_valid_execution_space() {
   static_assert(is_detected_v<initialize_finalize_t, ExecutionSpace>);
   static_assert(is_detected_v<fence_t, ExecutionSpace>);
   static_assert(is_detected_v<concurrency_t, ExecutionSpace>);
-#ifndef KOKKOS_ENABLE_HPX  // FIXME_HPX
   static_assert(sizeof(ExecutionSpace) <= 2 * sizeof(void*));
-#endif
   return true;
 }
 
diff --git a/core/src/impl/Kokkos_FunctorAnalysis.hpp b/core/src/impl/Kokkos_FunctorAnalysis.hpp
index 5ef017a004..c635c8bf76 100644
--- a/core/src/impl/Kokkos_FunctorAnalysis.hpp
+++ b/core/src/impl/Kokkos_FunctorAnalysis.hpp
@@ -42,10 +42,10 @@ struct DeduceFunctorPatternInterface<
   using type = FunctorPatternInterface::FOR;
 };
 
-template <class FunctorType, class ExecPolicy, class ReducerType,
+template <class CombinedFunctorReducerType, class ExecPolicy,
           class ExecutionSpace>
 struct DeduceFunctorPatternInterface<
-    ParallelReduce<FunctorType, ExecPolicy, ReducerType, ExecutionSpace>> {
+    ParallelReduce<CombinedFunctorReducerType, ExecPolicy, ExecutionSpace>> {
   using type = FunctorPatternInterface::REDUCE;
 };
 
@@ -64,14 +64,15 @@ struct DeduceFunctorPatternInterface<ParallelScanWithTotal<
 
 /** \brief  Query Functor and execution policy argument tag for value type.
  *
- *  If 'value_type' is not explicitly declared in the functor
- *  then attempt to deduce the type from FunctorType::operator()
- *  interface used by the pattern and policy.
+ *  If 'value_type' is not explicitly declared in the functor and
+ * OverrideValueType is void, then attempt to deduce the type from
+ * FunctorType::operator() interface used by the pattern and policy.
  *
  *  For the REDUCE pattern generate a Reducer and finalization function
  *  derived from what is available within the functor.
  */
-template <typename PatternInterface, class Policy, class Functor>
+template <typename PatternInterface, class Policy, class Functor,
+          typename OverrideValueType>
 struct FunctorAnalysis {
  private:
   using FOR    = FunctorPatternInterface::FOR;
@@ -124,9 +125,10 @@ struct FunctorAnalysis {
   //----------------------------------------
   // Check for Functor::value_type, which is either a simple type T or T[]
 
+  // If the functor doesn't have a value_type alias, use OverrideValueType.
   template <typename F, typename = std::false_type>
   struct has_value_type {
-    using type = void;
+    using type = OverrideValueType;
   };
 
   template <typename F>
@@ -141,9 +143,9 @@ struct FunctorAnalysis {
   };
 
   //----------------------------------------
-  // If Functor::value_type does not exist then evaluate operator(),
-  // depending upon the pattern and whether the policy has a work tag,
-  // to determine the reduction or scan value_type.
+  // If Functor::value_type does not exist and OverrideValueType is void, then
+  // evaluate operator(), depending upon the pattern and whether the policy has
+  // a work tag, to determine the reduction or scan value_type.
 
   template <typename F, typename P = PatternInterface,
             typename V = typename has_value_type<F>::type,
@@ -320,13 +322,15 @@ struct FunctorAnalysis {
 
  private:
   template <bool IsArray, class FF>
-  KOKKOS_INLINE_FUNCTION static constexpr std::enable_if_t<IsArray, unsigned>
+  KOKKOS_INLINE_FUNCTION static constexpr std::enable_if_t<IsArray,
+                                                           unsigned int>
   get_length(FF const& f) {
     return f.value_count;
   }
 
   template <bool IsArray, class FF>
-  KOKKOS_INLINE_FUNCTION static constexpr std::enable_if_t<!IsArray, unsigned>
+  KOKKOS_INLINE_FUNCTION static constexpr std::enable_if_t<!IsArray,
+                                                           unsigned int>
   get_length(FF const&) {
     return candidate_is_void ? 0 : 1;
   }
@@ -337,12 +341,12 @@ struct FunctorAnalysis {
         !candidate_is_void && !candidate_is_array ? sizeof(ValueType) : 0
   };
 
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_count(
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned int value_count(
       const Functor& f) {
     return FunctorAnalysis::template get_length<candidate_is_array>(f);
   }
 
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_size(
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned int value_size(
       const Functor& f) {
     return FunctorAnalysis::template get_length<candidate_is_array>(f) *
            sizeof(ValueType);
@@ -351,13 +355,13 @@ struct FunctorAnalysis {
   //----------------------------------------
 
   template <class Unknown>
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_count(
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned int value_count(
       const Unknown&) {
     return candidate_is_void ? 0 : 1;
   }
 
   template <class Unknown>
-  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned value_size(
+  KOKKOS_FORCEINLINE_FUNCTION static constexpr unsigned int value_size(
       const Unknown&) {
     return candidate_is_void ? 0 : sizeof(ValueType);
   }
@@ -903,12 +907,12 @@ struct FunctorAnalysis {
 
   struct Reducer {
    private:
-    Functor const* const m_functor;
+    Functor m_functor;
 
     template <bool IsArray>
     KOKKOS_INLINE_FUNCTION constexpr std::enable_if_t<IsArray, int> len() const
         noexcept {
-      return m_functor->value_count;
+      return m_functor.value_count;
     }
 
     template <bool IsArray>
@@ -924,6 +928,28 @@ struct FunctorAnalysis {
     using reference_type = FunctorAnalysis::reference_type;
     using functor_type   = Functor;  // Adapts a functor
 
+    static constexpr bool has_join_member_function() {
+      return DeduceJoin<>::value;
+    }
+    static constexpr bool has_init_member_function() {
+      return DeduceInit<>::value;
+    }
+    static constexpr bool has_final_member_function() {
+      return DeduceFinal<>::value;
+    }
+
+    KOKKOS_FUNCTION unsigned int value_size() const {
+      return FunctorAnalysis::value_size(m_functor);
+    }
+
+    KOKKOS_FUNCTION unsigned int value_count() const {
+      return FunctorAnalysis::value_count(m_functor);
+    }
+
+    KOKKOS_FUNCTION static constexpr unsigned int static_value_size() {
+      return StaticValueSize;
+    }
+
     template <bool is_array = candidate_is_array>
     KOKKOS_INLINE_FUNCTION static std::enable_if_t<is_array, reference_type>
     reference(ValueType* dst) noexcept {
@@ -948,20 +974,23 @@ struct FunctorAnalysis {
 
     KOKKOS_INLINE_FUNCTION
     void join(ValueType* dst, ValueType const* src) const noexcept {
-      DeduceJoin<>::join(m_functor, dst, src);
+      DeduceJoin<>::join(&m_functor, dst, src);
     }
 
     KOKKOS_INLINE_FUNCTION reference_type init(ValueType* const dst) const
         noexcept {
-      DeduceInit<>::init(m_functor, dst);
+      DeduceInit<>::init(&m_functor, dst);
       return reference(dst);
     }
 
     KOKKOS_INLINE_FUNCTION
     void final(ValueType* dst) const noexcept {
-      DeduceFinal<>::final(m_functor, dst);
+      DeduceFinal<>::final(&m_functor, dst);
     }
 
+    KOKKOS_INLINE_FUNCTION
+    const Functor& get_functor() const { return m_functor; }
+
     Reducer(Reducer const&) = default;
     Reducer(Reducer&&)      = default;
     Reducer& operator=(Reducer const&) = delete;
@@ -969,7 +998,7 @@ struct FunctorAnalysis {
     ~Reducer()                    = default;
 
     KOKKOS_INLINE_FUNCTION explicit constexpr Reducer(
-        Functor const* arg_functor) noexcept
+        Functor const& arg_functor) noexcept
         : m_functor(arg_functor) {}
   };
 };
diff --git a/core/src/impl/Kokkos_HBWSpace.cpp b/core/src/impl/Kokkos_HBWSpace.cpp
index 7402f1a744..cd640b88cb 100644
--- a/core/src/impl/Kokkos_HBWSpace.cpp
+++ b/core/src/impl/Kokkos_HBWSpace.cpp
@@ -310,41 +310,4 @@ void SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
 }  // namespace Impl
 }  // namespace Kokkos
 
-/*--------------------------------------------------------------------------*/
-/*--------------------------------------------------------------------------*/
-
-namespace Kokkos {
-namespace Experimental {
-namespace {
-const unsigned HBW_SPACE_ATOMIC_MASK     = 0xFFFF;
-const unsigned HBW_SPACE_ATOMIC_XOR_MASK = 0x5A39;
-static int HBW_SPACE_ATOMIC_LOCKS[HBW_SPACE_ATOMIC_MASK + 1];
-}  // namespace
-
-namespace Impl {
-void init_lock_array_hbw_space() {
-  static int is_initialized = 0;
-  if (!is_initialized)
-    for (int i = 0; i < static_cast<int>(HBW_SPACE_ATOMIC_MASK + 1); i++)
-      HBW_SPACE_ATOMIC_LOCKS[i] = 0;
-}
-
-bool lock_address_hbw_space(void *ptr) {
-  return 0 == atomic_compare_exchange(
-                  &HBW_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) &
-                                           HBW_SPACE_ATOMIC_MASK) ^
-                                          HBW_SPACE_ATOMIC_XOR_MASK],
-                  0, 1);
-}
-
-void unlock_address_hbw_space(void *ptr) {
-  atomic_exchange(
-      &HBW_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HBW_SPACE_ATOMIC_MASK) ^
-                              HBW_SPACE_ATOMIC_XOR_MASK],
-      0);
-}
-
-}  // namespace Impl
-}  // namespace Experimental
-}  // namespace Kokkos
 #endif
diff --git a/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp b/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp
new file mode 100644
index 0000000000..7bf315de17
--- /dev/null
+++ b/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp
@@ -0,0 +1,1016 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_HALF_FLOATING_POINT_WRAPPER_HPP_
+#define KOKKOS_HALF_FLOATING_POINT_WRAPPER_HPP_
+
+#include <Kokkos_Macros.hpp>
+
+#include <type_traits>
+#include <iosfwd>  // istream & ostream for extraction and insertion ops
+#include <string>
+
+#ifdef KOKKOS_IMPL_HALF_TYPE_DEFINED
+
+// KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH: A macro to select which
+// floating_pointer_wrapper operator paths should be used. For CUDA, let the
+// compiler conditionally select when device ops are used For SYCL, we have a
+// full half type on both host and device
+#if defined(__CUDA_ARCH__) || defined(KOKKOS_ENABLE_SYCL)
+#define KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+#endif
+
+/************************* BEGIN forward declarations *************************/
+namespace Kokkos {
+namespace Experimental {
+namespace Impl {
+template <class FloatType>
+class floating_point_wrapper;
+}
+
+// Declare half_t (binary16)
+using half_t = Kokkos::Experimental::Impl::floating_point_wrapper<
+    Kokkos::Impl::half_impl_t ::type>;
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(float val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(bool val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(double val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(short val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(int val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(long val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(long long val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned short val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned int val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned long val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned long long val);
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(half_t);
+
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, float>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, bool>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, double>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, short>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, int>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long long>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned short>::value, T>
+        cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, unsigned int>::value, T>
+    cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned long>::value, T>
+        cast_from_half(half_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned long long>::value, T>
+        cast_from_half(half_t);
+
+// declare bhalf_t
+#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+using bhalf_t = Kokkos::Experimental::Impl::floating_point_wrapper<
+    Kokkos::Impl ::bhalf_impl_t ::type>;
+
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(float val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(bool val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(double val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(short val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(int val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(long val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(long long val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned short val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned int val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned long val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned long long val);
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(bhalf_t val);
+
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, float>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, bool>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, double>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, short>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, int>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long long>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned short>::value, T>
+        cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, unsigned int>::value, T>
+    cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned long>::value, T>
+        cast_from_bhalf(bhalf_t);
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned long long>::value, T>
+        cast_from_bhalf(bhalf_t);
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+
+template <class T>
+static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::half_t cast_to_wrapper(
+    T x, const volatile Kokkos::Impl::half_impl_t::type&);
+
+#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+template <class T>
+static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::bhalf_t cast_to_wrapper(
+    T x, const volatile Kokkos::Impl::bhalf_impl_t::type&);
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+
+template <class T>
+static KOKKOS_INLINE_FUNCTION T
+cast_from_wrapper(const Kokkos::Experimental::half_t& x);
+
+#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+template <class T>
+static KOKKOS_INLINE_FUNCTION T
+cast_from_wrapper(const Kokkos::Experimental::bhalf_t& x);
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+/************************** END forward declarations **************************/
+
+namespace Impl {
+template <class FloatType>
+class alignas(FloatType) floating_point_wrapper {
+ public:
+  using impl_type = FloatType;
+
+ private:
+  impl_type val;
+  using fixed_width_integer_type = std::conditional_t<
+      sizeof(impl_type) == 2, uint16_t,
+      std::conditional_t<
+          sizeof(impl_type) == 4, uint32_t,
+          std::conditional_t<sizeof(impl_type) == 8, uint64_t, void>>>;
+  static_assert(!std::is_void<fixed_width_integer_type>::value,
+                "Invalid impl_type");
+
+ public:
+  // In-class initialization and defaulted default constructors not used
+  // since Cuda supports half precision initialization via the below constructor
+  KOKKOS_FUNCTION
+  floating_point_wrapper() : val(0.0F) {}
+
+// Copy constructors
+// Getting "C2580: multiple versions of a defaulted special
+// member function are not allowed" with VS 16.11.3 and CUDA 11.4.2
+#if defined(_WIN32) && defined(KOKKOS_ENABLE_CUDA)
+  KOKKOS_FUNCTION
+  floating_point_wrapper(const floating_point_wrapper& rhs) : val(rhs.val) {}
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator=(const floating_point_wrapper& rhs) {
+    val = rhs.val;
+    return *this;
+  }
+#else
+  KOKKOS_DEFAULTED_FUNCTION
+  floating_point_wrapper(const floating_point_wrapper&) noexcept = default;
+
+  KOKKOS_DEFAULTED_FUNCTION
+  floating_point_wrapper& operator=(const floating_point_wrapper&) noexcept =
+      default;
+#endif
+
+  KOKKOS_INLINE_FUNCTION
+  floating_point_wrapper(const volatile floating_point_wrapper& rhs) {
+#if defined(KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH) && !defined(KOKKOS_ENABLE_SYCL)
+    val = rhs.val;
+#else
+    const volatile fixed_width_integer_type* rv_ptr =
+        reinterpret_cast<const volatile fixed_width_integer_type*>(&rhs.val);
+    const fixed_width_integer_type rv_val = *rv_ptr;
+    val       = reinterpret_cast<const impl_type&>(rv_val);
+#endif  // KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+  }
+
+  // Don't support implicit conversion back to impl_type.
+  // impl_type is a storage only type on host.
+  KOKKOS_FUNCTION
+  explicit operator impl_type() const { return val; }
+  KOKKOS_FUNCTION
+  explicit operator float() const { return cast_from_wrapper<float>(*this); }
+  KOKKOS_FUNCTION
+  explicit operator bool() const { return cast_from_wrapper<bool>(*this); }
+  KOKKOS_FUNCTION
+  explicit operator double() const { return cast_from_wrapper<double>(*this); }
+  KOKKOS_FUNCTION
+  explicit operator short() const { return cast_from_wrapper<short>(*this); }
+  KOKKOS_FUNCTION
+  explicit operator int() const { return cast_from_wrapper<int>(*this); }
+  KOKKOS_FUNCTION
+  explicit operator long() const { return cast_from_wrapper<long>(*this); }
+  KOKKOS_FUNCTION
+  explicit operator long long() const {
+    return cast_from_wrapper<long long>(*this);
+  }
+  KOKKOS_FUNCTION
+  explicit operator unsigned short() const {
+    return cast_from_wrapper<unsigned short>(*this);
+  }
+  KOKKOS_FUNCTION
+  explicit operator unsigned int() const {
+    return cast_from_wrapper<unsigned int>(*this);
+  }
+  KOKKOS_FUNCTION
+  explicit operator unsigned long() const {
+    return cast_from_wrapper<unsigned long>(*this);
+  }
+  KOKKOS_FUNCTION
+  explicit operator unsigned long long() const {
+    return cast_from_wrapper<unsigned long long>(*this);
+  }
+
+  /**
+   * Conversion constructors.
+   *
+   * Support implicit conversions from impl_type, float, double ->
+   * floating_point_wrapper. Mixed precision expressions require upcasting which
+   * is done in the
+   * "// Binary Arithmetic" operator overloads below.
+   *
+   * Support implicit conversions from integral types -> floating_point_wrapper.
+   * Expressions involving floating_point_wrapper with integral types require
+   * downcasting the integral types to floating_point_wrapper. Existing operator
+   * overloads can handle this with the addition of the below implicit
+   * conversion constructors.
+   */
+  KOKKOS_FUNCTION
+  constexpr floating_point_wrapper(impl_type rhs) : val(rhs) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(float rhs) : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(double rhs) : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  explicit floating_point_wrapper(bool rhs)
+      : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(short rhs) : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(int rhs) : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(long rhs) : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(long long rhs) : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(unsigned short rhs)
+      : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(unsigned int rhs)
+      : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(unsigned long rhs)
+      : val(cast_to_wrapper(rhs, val).val) {}
+  KOKKOS_FUNCTION
+  floating_point_wrapper(unsigned long long rhs)
+      : val(cast_to_wrapper(rhs, val).val) {}
+
+  // Unary operators
+  KOKKOS_FUNCTION
+  floating_point_wrapper operator+() const {
+    floating_point_wrapper tmp = *this;
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    tmp.val = +tmp.val;
+#else
+    tmp.val   = cast_to_wrapper(+cast_from_wrapper<float>(tmp), val).val;
+#endif
+    return tmp;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper operator-() const {
+    floating_point_wrapper tmp = *this;
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    tmp.val = -tmp.val;
+#else
+    tmp.val   = cast_to_wrapper(-cast_from_wrapper<float>(tmp), val).val;
+#endif
+    return tmp;
+  }
+
+  // Prefix operators
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator++() {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    val = val + impl_type(1.0F);  // cuda has no operator++ for __nv_bfloat
+#else
+    float tmp = cast_from_wrapper<float>(*this);
+    ++tmp;
+    val       = cast_to_wrapper(tmp, val).val;
+#endif
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator--() {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    val = val - impl_type(1.0F);  // cuda has no operator-- for __nv_bfloat
+#else
+    float tmp = cast_from_wrapper<float>(*this);
+    --tmp;
+    val = cast_to_wrapper(tmp, val).val;
+#endif
+    return *this;
+  }
+
+  // Postfix operators
+  KOKKOS_FUNCTION
+  floating_point_wrapper operator++(int) {
+    floating_point_wrapper tmp = *this;
+    operator++();
+    return tmp;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper operator--(int) {
+    floating_point_wrapper tmp = *this;
+    operator--();
+    return tmp;
+  }
+
+  // Binary operators
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator=(impl_type rhs) {
+    val = rhs;
+    return *this;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION floating_point_wrapper& operator=(T rhs) {
+    val = cast_to_wrapper(rhs, val).val;
+    return *this;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION void operator=(T rhs) volatile {
+    impl_type new_val = cast_to_wrapper(rhs, val).val;
+    volatile fixed_width_integer_type* val_ptr =
+        reinterpret_cast<volatile fixed_width_integer_type*>(
+            const_cast<impl_type*>(&val));
+    *val_ptr = reinterpret_cast<fixed_width_integer_type&>(new_val);
+  }
+
+  // Compound operators
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator+=(floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    val = val + rhs.val;  // cuda has no operator+= for __nv_bfloat
+#else
+    val = cast_to_wrapper(
+              cast_from_wrapper<float>(*this) + cast_from_wrapper<float>(rhs),
+              val)
+              .val;
+#endif
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  void operator+=(const volatile floating_point_wrapper& rhs) volatile {
+    floating_point_wrapper tmp_rhs = rhs;
+    floating_point_wrapper tmp_lhs = *this;
+
+    tmp_lhs += tmp_rhs;
+    *this = tmp_lhs;
+  }
+
+  // Compound operators: upcast overloads for +=
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator+=(T& lhs, floating_point_wrapper rhs) {
+    lhs += static_cast<T>(rhs);
+    return lhs;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator+=(float rhs) {
+    float result = static_cast<float>(val) + rhs;
+    val          = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator+=(double rhs) {
+    double result = static_cast<double>(val) + rhs;
+    val           = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator-=(floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    val = val - rhs.val;  // cuda has no operator-= for __nv_bfloat
+#else
+    val = cast_to_wrapper(
+              cast_from_wrapper<float>(*this) - cast_from_wrapper<float>(rhs),
+              val)
+              .val;
+#endif
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  void operator-=(const volatile floating_point_wrapper& rhs) volatile {
+    floating_point_wrapper tmp_rhs = rhs;
+    floating_point_wrapper tmp_lhs = *this;
+
+    tmp_lhs -= tmp_rhs;
+    *this = tmp_lhs;
+  }
+
+  // Compund operators: upcast overloads for -=
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator-=(T& lhs, floating_point_wrapper rhs) {
+    lhs -= static_cast<T>(rhs);
+    return lhs;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator-=(float rhs) {
+    float result = static_cast<float>(val) - rhs;
+    val          = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator-=(double rhs) {
+    double result = static_cast<double>(val) - rhs;
+    val           = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator*=(floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    val = val * rhs.val;  // cuda has no operator*= for __nv_bfloat
+#else
+    val = cast_to_wrapper(
+              cast_from_wrapper<float>(*this) * cast_from_wrapper<float>(rhs),
+              val)
+              .val;
+#endif
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  void operator*=(const volatile floating_point_wrapper& rhs) volatile {
+    floating_point_wrapper tmp_rhs = rhs;
+    floating_point_wrapper tmp_lhs = *this;
+
+    tmp_lhs *= tmp_rhs;
+    *this = tmp_lhs;
+  }
+
+  // Compund operators: upcast overloads for *=
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator*=(T& lhs, floating_point_wrapper rhs) {
+    lhs *= static_cast<T>(rhs);
+    return lhs;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator*=(float rhs) {
+    float result = static_cast<float>(val) * rhs;
+    val          = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator*=(double rhs) {
+    double result = static_cast<double>(val) * rhs;
+    val           = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator/=(floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    val = val / rhs.val;  // cuda has no operator/= for __nv_bfloat
+#else
+    val = cast_to_wrapper(
+              cast_from_wrapper<float>(*this) / cast_from_wrapper<float>(rhs),
+              val)
+              .val;
+#endif
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  void operator/=(const volatile floating_point_wrapper& rhs) volatile {
+    floating_point_wrapper tmp_rhs = rhs;
+    floating_point_wrapper tmp_lhs = *this;
+
+    tmp_lhs /= tmp_rhs;
+    *this = tmp_lhs;
+  }
+
+  // Compund operators: upcast overloads for /=
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator/=(T& lhs, floating_point_wrapper rhs) {
+    lhs /= static_cast<T>(rhs);
+    return lhs;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator/=(float rhs) {
+    float result = static_cast<float>(val) / rhs;
+    val          = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  KOKKOS_FUNCTION
+  floating_point_wrapper& operator/=(double rhs) {
+    double result = static_cast<double>(val) / rhs;
+    val           = static_cast<impl_type>(result);
+    return *this;
+  }
+
+  // Binary Arithmetic
+  KOKKOS_FUNCTION
+  friend floating_point_wrapper operator+(floating_point_wrapper lhs,
+                                          floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    lhs += rhs;
+#else
+    lhs.val = cast_to_wrapper(
+                  cast_from_wrapper<float>(lhs) + cast_from_wrapper<float>(rhs),
+                  lhs.val)
+                  .val;
+#endif
+    return lhs;
+  }
+
+  // Binary Arithmetic upcast operators for +
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator+(floating_point_wrapper lhs, T rhs) {
+    return T(lhs) + rhs;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator+(T lhs, floating_point_wrapper rhs) {
+    return lhs + T(rhs);
+  }
+
+  KOKKOS_FUNCTION
+  friend floating_point_wrapper operator-(floating_point_wrapper lhs,
+                                          floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    lhs -= rhs;
+#else
+    lhs.val = cast_to_wrapper(
+                  cast_from_wrapper<float>(lhs) - cast_from_wrapper<float>(rhs),
+                  lhs.val)
+                  .val;
+#endif
+    return lhs;
+  }
+
+  // Binary Arithmetic upcast operators for -
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator-(floating_point_wrapper lhs, T rhs) {
+    return T(lhs) - rhs;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator-(T lhs, floating_point_wrapper rhs) {
+    return lhs - T(rhs);
+  }
+
+  KOKKOS_FUNCTION
+  friend floating_point_wrapper operator*(floating_point_wrapper lhs,
+                                          floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    lhs *= rhs;
+#else
+    lhs.val = cast_to_wrapper(
+                  cast_from_wrapper<float>(lhs) * cast_from_wrapper<float>(rhs),
+                  lhs.val)
+                  .val;
+#endif
+    return lhs;
+  }
+
+  // Binary Arithmetic upcast operators for *
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator*(floating_point_wrapper lhs, T rhs) {
+    return T(lhs) * rhs;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator*(T lhs, floating_point_wrapper rhs) {
+    return lhs * T(rhs);
+  }
+
+  KOKKOS_FUNCTION
+  friend floating_point_wrapper operator/(floating_point_wrapper lhs,
+                                          floating_point_wrapper rhs) {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    lhs /= rhs;
+#else
+    lhs.val = cast_to_wrapper(
+                  cast_from_wrapper<float>(lhs) / cast_from_wrapper<float>(rhs),
+                  lhs.val)
+                  .val;
+#endif
+    return lhs;
+  }
+
+  // Binary Arithmetic upcast operators for /
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator/(floating_point_wrapper lhs, T rhs) {
+    return T(lhs) / rhs;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<
+      std::is_same<T, float>::value || std::is_same<T, double>::value, T>
+  operator/(T lhs, floating_point_wrapper rhs) {
+    return lhs / T(rhs);
+  }
+
+  // Logical operators
+  KOKKOS_FUNCTION
+  bool operator!() const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(!val);
+#else
+    return !cast_from_wrapper<float>(*this);
+#endif
+  }
+
+  // NOTE: Loses short-circuit evaluation
+  KOKKOS_FUNCTION
+  bool operator&&(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val && rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) && cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  // NOTE: Loses short-circuit evaluation
+  KOKKOS_FUNCTION
+  bool operator||(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val || rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) || cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  // Comparison operators
+  KOKKOS_FUNCTION
+  bool operator==(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val == rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) == cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  KOKKOS_FUNCTION
+  bool operator!=(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val != rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) != cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  KOKKOS_FUNCTION
+  bool operator<(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val < rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) < cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  KOKKOS_FUNCTION
+  bool operator>(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val > rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) > cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  KOKKOS_FUNCTION
+  bool operator<=(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val <= rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) <= cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  KOKKOS_FUNCTION
+  bool operator>=(floating_point_wrapper rhs) const {
+#ifdef KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH
+    return static_cast<bool>(val >= rhs.val);
+#else
+    return cast_from_wrapper<float>(*this) >= cast_from_wrapper<float>(rhs);
+#endif
+  }
+
+  KOKKOS_FUNCTION
+  friend bool operator==(const volatile floating_point_wrapper& lhs,
+                         const volatile floating_point_wrapper& rhs) {
+    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
+    return tmp_lhs == tmp_rhs;
+  }
+
+  KOKKOS_FUNCTION
+  friend bool operator!=(const volatile floating_point_wrapper& lhs,
+                         const volatile floating_point_wrapper& rhs) {
+    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
+    return tmp_lhs != tmp_rhs;
+  }
+
+  KOKKOS_FUNCTION
+  friend bool operator<(const volatile floating_point_wrapper& lhs,
+                        const volatile floating_point_wrapper& rhs) {
+    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
+    return tmp_lhs < tmp_rhs;
+  }
+
+  KOKKOS_FUNCTION
+  friend bool operator>(const volatile floating_point_wrapper& lhs,
+                        const volatile floating_point_wrapper& rhs) {
+    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
+    return tmp_lhs > tmp_rhs;
+  }
+
+  KOKKOS_FUNCTION
+  friend bool operator<=(const volatile floating_point_wrapper& lhs,
+                         const volatile floating_point_wrapper& rhs) {
+    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
+    return tmp_lhs <= tmp_rhs;
+  }
+
+  KOKKOS_FUNCTION
+  friend bool operator>=(const volatile floating_point_wrapper& lhs,
+                         const volatile floating_point_wrapper& rhs) {
+    floating_point_wrapper tmp_lhs = lhs, tmp_rhs = rhs;
+    return tmp_lhs >= tmp_rhs;
+  }
+
+  // Insertion and extraction operators
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const floating_point_wrapper& x) {
+    const std::string out = std::to_string(static_cast<double>(x));
+    os << out;
+    return os;
+  }
+
+  friend std::istream& operator>>(std::istream& is, floating_point_wrapper& x) {
+    std::string in;
+    is >> in;
+    x = std::stod(in);
+    return is;
+  }
+};
+}  // namespace Impl
+
+// Declare wrapper overloads now that floating_point_wrapper is declared
+template <class T>
+static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::half_t cast_to_wrapper(
+    T x, const volatile Kokkos::Impl::half_impl_t::type&) {
+  return Kokkos::Experimental::cast_to_half(x);
+}
+
+#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+template <class T>
+static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::bhalf_t cast_to_wrapper(
+    T x, const volatile Kokkos::Impl::bhalf_impl_t::type&) {
+  return Kokkos::Experimental::cast_to_bhalf(x);
+}
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+
+template <class T>
+static KOKKOS_INLINE_FUNCTION T
+cast_from_wrapper(const Kokkos::Experimental::half_t& x) {
+  return Kokkos::Experimental::cast_from_half<T>(x);
+}
+
+#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+template <class T>
+static KOKKOS_INLINE_FUNCTION T
+cast_from_wrapper(const Kokkos::Experimental::bhalf_t& x) {
+  return Kokkos::Experimental::cast_from_bhalf<T>(x);
+}
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+
+}  // namespace Experimental
+}  // namespace Kokkos
+
+#endif  // KOKKOS_IMPL_HALF_TYPE_DEFINED
+
+// If none of the above actually did anything and defined a half precision type
+// define a fallback implementation here using float
+#ifndef KOKKOS_IMPL_HALF_TYPE_DEFINED
+#define KOKKOS_IMPL_HALF_TYPE_DEFINED
+#define KOKKOS_HALF_T_IS_FLOAT true
+namespace Kokkos {
+namespace Impl {
+struct half_impl_t {
+  using type = float;
+};
+}  // namespace Impl
+namespace Experimental {
+
+using half_t = Kokkos::Impl::half_impl_t::type;
+
+// cast_to_half
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(float val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(bool val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(double val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(short val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned short val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(int val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned int val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(long val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned long val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(long long val) { return half_t(val); }
+KOKKOS_INLINE_FUNCTION
+half_t cast_to_half(unsigned long long val) { return half_t(val); }
+
+// cast_from_half
+// Using an explicit list here too, since the other ones are explicit and for
+// example don't include char
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<
+    std::is_same<T, float>::value || std::is_same<T, bool>::value ||
+        std::is_same<T, double>::value || std::is_same<T, short>::value ||
+        std::is_same<T, unsigned short>::value || std::is_same<T, int>::value ||
+        std::is_same<T, unsigned int>::value || std::is_same<T, long>::value ||
+        std::is_same<T, unsigned long>::value ||
+        std::is_same<T, long long>::value ||
+        std::is_same<T, unsigned long long>::value,
+    T>
+cast_from_half(half_t val) {
+  return T(val);
+}
+
+}  // namespace Experimental
+}  // namespace Kokkos
+
+#else
+#define KOKKOS_HALF_T_IS_FLOAT false
+#endif  // KOKKOS_IMPL_HALF_TYPE_DEFINED
+
+#ifndef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+#define KOKKOS_IMPL_BHALF_TYPE_DEFINED
+#define KOKKOS_BHALF_T_IS_FLOAT true
+namespace Kokkos {
+namespace Impl {
+struct bhalf_impl_t {
+  using type = float;
+};
+}  // namespace Impl
+
+namespace Experimental {
+
+using bhalf_t = Kokkos::Impl::bhalf_impl_t::type;
+
+// cast_to_bhalf
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(float val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(bool val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(double val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(short val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned short val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(int val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned int val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(long val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned long val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(long long val) { return bhalf_t(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned long long val) { return bhalf_t(val); }
+
+// cast_from_bhalf
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<
+    std::is_same<T, float>::value || std::is_same<T, bool>::value ||
+        std::is_same<T, double>::value || std::is_same<T, short>::value ||
+        std::is_same<T, unsigned short>::value || std::is_same<T, int>::value ||
+        std::is_same<T, unsigned int>::value || std::is_same<T, long>::value ||
+        std::is_same<T, unsigned long>::value ||
+        std::is_same<T, long long>::value ||
+        std::is_same<T, unsigned long long>::value,
+    T>
+cast_from_bhalf(bhalf_t val) {
+  return T(val);
+}
+}  // namespace Experimental
+}  // namespace Kokkos
+#else
+#define KOKKOS_BHALF_T_IS_FLOAT false
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+
+#endif  // KOKKOS_HALF_FLOATING_POINT_WRAPPER_HPP_
diff --git a/core/src/impl/Kokkos_Half_NumericTraits.hpp b/core/src/impl/Kokkos_Half_NumericTraits.hpp
new file mode 100644
index 0000000000..b5cbf22194
--- /dev/null
+++ b/core/src/impl/Kokkos_Half_NumericTraits.hpp
@@ -0,0 +1,349 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_HALF_NUMERIC_TRAITS_HPP_
+#define KOKKOS_HALF_NUMERIC_TRAITS_HPP_
+
+#include <Kokkos_NumericTraits.hpp>
+
+////////////// BEGIN HALF_T (binary16) limits //////////////
+// clang-format off
+// '\brief:' below are from the libc definitions for float and double:
+// https://www.gnu.org/software/libc/manual/html_node/Floating-Point-Parameters.html
+//
+// The arithmetic encoding and equations below are derived from:
+// Ref1: https://en.wikipedia.org/wiki/Single-precision_floating-point_format
+// Ref2: https://en.wikipedia.org/wiki/Exponent_bias
+// Ref3; https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+//
+// Some background on the magic numbers 2**10=1024 and 2**15=32768 used below:
+//
+// IMPORTANT: For IEEE754 encodings, see Ref1.
+//
+// For binary16, we have B = 2 and p = 16 with 2**16 possible significands.
+// The binary16 format is: [s  e  e  e  e  e  f f f f f f f f f f]
+//              bit index:  15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+// s: signed bit (1 bit)
+// e: exponent bits (5 bits)
+// f: fractional bits (10 bits)
+//
+// E_bias      = 2**(n_exponent_bits - 1) - 1 = 2**(5 - 1) - 1 = 15
+// E_subnormal = 00000 (base2)
+// E_infinity  = 11111 (base2)
+// E_min       = 1 - E_bias = 1 - 15
+// E_max       = 2**5 - 1 - E_bias = 2**5 - 1 - 15 = 16
+//
+// 2**10=1024 is the smallest denominator that is representable in binary16:
+// [s  e  e  e  e  e  f f f f f f f f f f]
+// [0  0  0  0  0  0  0 0 0 0 0 0 0 0 0 1]
+// which is: 1 / 2**-10
+//
+//
+// 2**15 is the largest exponent factor representable in binary16, for example the
+// largest integer value representable in binary16 is:
+// [s  e  e  e  e  e  f f f f f f f f f f]
+// [0  1  1  1  1  0  1 1 1 1 1 1 1 1 1 1]
+// which is: 2**(2**4 + 2**3 + 2**2 + 2**1 - 15) * (1 + 2**-10 + 2**-9 + 2**-8 + 2**-7 + 2**-6 + 2**-5 + 2**-4 + 2**-3 + 2**-2 + 2**-1)) =
+//           2**15 * (1 + 0.9990234375) =
+//           65504.0
+//
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+/// \brief: Infinity
+///
+/// Binary16 encoding:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [0  1  1  1  1  1  0 0 0 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+///
+template <>
+struct Kokkos::Experimental::Impl::infinity_helper<Kokkos::Experimental::half_t> {
+  static constexpr int value = 0x7C00;
+};
+
+/// \brief: Minimum normalized number
+///
+/// Stdc defines this as the smallest number (representable in binary16).
+///
+/// Binary16 encoding:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [1  1  1  1  1  0  1 1 1 1 1 1 1 1 1 1]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+///
+/// and in base10: -1 * 2**(2**4 + 2**3 + 2**2 + 2**1 - 15) * (1 + 2**-10 + 2**-9 + 2**-8 + 2**-7 + 2**-6 + 2**-5 + 2**-4 + 2**-3 + 2**-2 + 2**-1)
+///              = -2**15 * (1 + (2**10 - 1) / 2**10)
+template <>
+struct Kokkos::Experimental::Impl::finite_min_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = -65504.0F;
+};
+
+/// \brief: Maximum normalized number
+///
+/// Stdc defines this as the maximum number (representable in binary16).
+///
+/// Binary16 encoding:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [0  1  1  1  1  0  1 1 1 1 1 1 1 1 1 1]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+///
+/// and in base10: 1 * 2**(2**4 + 2**3 + 2**2 + 2**1 - 15) * (1 + 2**-10 + 2**-9 + 2**-8 + 2**-7 + 2**-6 + 2**-5 + 2**-4 + 2**-3 + 2**-2 + 2**-1)
+///              = 2**15 * (1 + (2**10 - 1) / 2**10)
+template <>
+struct Kokkos::Experimental::Impl::finite_max_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = 65504.0F;
+};
+
+/// \brief: This is the difference between 1 and the smallest floating point
+///         number of type binary16 that is greater than 1
+///
+/// Smallest number in binary16 that is greater than 1 encoding:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [0  0  1  1  1  1  0 0 0 0 0 0 0 0 0 1]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+///
+/// and in base10: 1 * 2**(2**3 + 2**2 + 2**1 + 2**0 - 15) * (1 + 2**-10)
+///                = 2**0 * (1 + 2**-10)
+///                = 1.0009765625
+///
+/// Lastly, 1 - 1.0009765625 = 0.0009765625.
+template <>
+struct Kokkos::Experimental::Impl::epsilon_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = 0.0009765625F;
+};
+
+/// @brief: The largest possible rounding error in ULPs
+///
+/// This simply uses the maximum rounding error.
+///
+/// Reference: https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html#689
+template <>
+struct Kokkos::Experimental::Impl::round_error_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = 0.5F;
+};
+
+/// \brief: Minimum normalized positive half precision number
+///
+/// Stdc defines this as the minimum normalized positive floating
+/// point number that is representable in type binary16
+///
+/// Smallest number in binary16 that is greater than 1 encoding:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [0  0  0  0  0  1  0 0 0 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+///
+/// and in base10: 1 * 2**(2**0 - 15) * (1)
+///                = 2**-14
+template <>
+struct Kokkos::Experimental::Impl::norm_min_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = 0.00006103515625F;
+};
+
+/// \brief: Quiet not a half precision number
+///
+/// IEEE 754 defines this as all exponent bits high.
+///
+/// Quiet NaN in binary16:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [1  1  1  1  1  1  0 0 0 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+template <>
+struct Kokkos::Experimental::Impl::quiet_NaN_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = 0xfc000;
+};
+
+/// \brief: Signaling not a half precision number
+///
+/// IEEE 754 defines this as all exponent bits and the first fraction bit high.
+///
+/// Quiet NaN in binary16:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [1  1  1  1  1  1  1 0 0 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+template <>
+struct Kokkos::Experimental::Impl::signaling_NaN_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr float value = 0xfe000;
+};
+
+/// \brief: Number of digits in the matissa that can be represented
+///         without losing precision.
+///
+/// Stdc defines this as the number of base-RADIX digits in the floating point mantissa for the binary16 data type.
+///
+/// In binary16, we have 10 fractional bits plus the implicit leading 1.
+template <>
+struct Kokkos::Experimental::Impl::digits_helper<Kokkos::Experimental::half_t> {
+  static constexpr int value = 11;
+};
+
+/// \brief: "The number of base-10 digits that can be represented by the type T without change"
+/// Reference: https://en.cppreference.com/w/cpp/types/numeric_limits/digits10.
+///
+/// "For base-radix types, it is the value of digits() (digits - 1 for floating-point types) multiplied by log10(radix) and rounded down."
+/// Reference: https://en.cppreference.com/w/cpp/types/numeric_limits/digits10.
+///
+/// This is: floor(11 - 1 * log10(2))
+template <>
+struct Kokkos::Experimental::Impl::digits10_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr int value = 3;
+};
+
+/// \brief: Value of the base of the exponent representation.
+///
+/// Stdc defined this as the value of the base, or radix, of the exponent representation.
+template <>
+struct Kokkos::Experimental::Impl::radix_helper<Kokkos::Experimental::half_t> {
+  static constexpr int value = 2;
+};
+
+/// \brief: This is the smallest possible exponent value
+///
+/// Stdc defines this as the smallest possible exponent value for type binary16. 
+/// More precisely, it is the minimum negative integer such that the value min_exponent_helper
+/// raised to this power minus 1 can be represented as a normalized floating point number of type float.
+///
+/// In binary16:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [0  0  0  0  0  1  0 0 0 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+/// 
+/// and in base10: 1 * 2**(2**0 - 15) * (1 + 0)
+///                = 2**-14
+/// 
+/// with a bias of one from (C11 5.2.4.2.2), gives -13;
+template <>
+struct Kokkos::Experimental::Impl::min_exponent_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr int value = -13;
+};
+
+/// \brief: This is the largest possible exponent value
+///
+/// In binary16:
+///             [s  e  e  e  e  e  f f f f f f f f f f]
+///             [0  1  1  1  1  0  0 0 0 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+/// 
+/// and in base10: 1 * 2**(2**4 + 2**3 + 2**2 + 2**1 - 15) * (1 + 0)
+///                = 2**(30 - 15)
+///                = 2**15
+/// 
+/// with a bias of one from (C11 5.2.4.2.2), gives 16;
+template <>
+struct Kokkos::Experimental::Impl::max_exponent_helper<
+    Kokkos::Experimental::half_t> {
+  static constexpr int value = 16;
+};
+#endif
+////////////// END HALF_T (binary16) limits //////////////
+
+////////////// BEGIN BHALF_T (bfloat16) limits //////////////
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+/// \brief: Infinity
+///
+/// Bfloat16 encoding:
+///             [s  e  e  e  e  e  e e e f f f f f f f]
+///             [0  1  1  1  1  1  1 1 1 0 0 0 0 0 0 0]
+/// bit index:   15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+///
+template <>
+struct Kokkos::Experimental::Impl::infinity_helper<Kokkos::Experimental::bhalf_t> {
+  static constexpr int value = 0x7F80;
+};
+
+// Minimum normalized number
+template <>
+struct Kokkos::Experimental::Impl::finite_min_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = -3.38953139e38;
+};
+// Maximum normalized number
+template <>
+struct Kokkos::Experimental::Impl::finite_max_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = 3.38953139e38;
+};
+// 1/2^7
+template <>
+struct Kokkos::Experimental::Impl::epsilon_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = 0.0078125F;
+};
+template <>
+struct Kokkos::Experimental::Impl::round_error_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = 0.5F;
+};
+// Minimum normalized positive bhalf number
+template <>
+struct Kokkos::Experimental::Impl::norm_min_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = 1.1754494351e-38;
+};
+// Quiet not a bhalf number
+template <>
+struct Kokkos::Experimental::Impl::quiet_NaN_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = 0x7fc000;
+};
+// Signaling not a bhalf number
+template <>
+struct Kokkos::Experimental::Impl::signaling_NaN_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr float value = 0x7fe000;
+};
+// Number of digits in the matissa that can be represented
+// without losing precision.
+template <>
+struct Kokkos::Experimental::Impl::digits_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr int value = 2;
+};
+// 7 - 1 * log10(2)
+template <>
+struct Kokkos::Experimental::Impl::digits10_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr int value = 1;
+};
+// Value of the base of the exponent representation.
+template <>
+struct Kokkos::Experimental::Impl::radix_helper<Kokkos::Experimental::bhalf_t> {
+  static constexpr int value = 2;
+};
+// This is the smallest possible exponent value
+// with a bias of one (C11 5.2.4.2.2).
+template <>
+struct Kokkos::Experimental::Impl::min_exponent_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr int value = -125;
+};
+// This is the largest possible exponent value
+// with a bias of one (C11 5.2.4.2.2).
+template <>
+struct Kokkos::Experimental::Impl::max_exponent_helper<
+    Kokkos::Experimental::bhalf_t> {
+  static constexpr int value = 128;
+};
+#endif
+////////////// END BHALF_T (bfloat16) limits //////////
+
+#endif  // KOKKOS_HALF_NUMERIC_TRAITS_HPP_
diff --git a/core/src/impl/Kokkos_HostSpace.cpp b/core/src/impl/Kokkos_HostSpace.cpp
index b47ce3beec..88dfaadb08 100644
--- a/core/src/impl/Kokkos_HostSpace.cpp
+++ b/core/src/impl/Kokkos_HostSpace.cpp
@@ -26,7 +26,8 @@
 
 /*--------------------------------------------------------------------------*/
 
-#if defined(KOKKOS_COMPILER_INTEL) && !defined(KOKKOS_ENABLE_CUDA)
+#if (defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)) && \
+    !defined(KOKKOS_ENABLE_CUDA)
 
 // Intel specialized allocator does not interoperate with CUDA memory allocation
 
@@ -284,42 +285,6 @@ SharedAllocationRecord<Kokkos::HostSpace, void>::SharedAllocationRecord(
 }  // namespace Impl
 }  // namespace Kokkos
 
-/*--------------------------------------------------------------------------*/
-/*--------------------------------------------------------------------------*/
-
-namespace Kokkos {
-namespace {
-const unsigned HOST_SPACE_ATOMIC_MASK     = 0xFFFF;
-const unsigned HOST_SPACE_ATOMIC_XOR_MASK = 0x5A39;
-static int HOST_SPACE_ATOMIC_LOCKS[HOST_SPACE_ATOMIC_MASK + 1];
-}  // namespace
-
-namespace Impl {
-void init_lock_array_host_space() {
-  static int is_initialized = 0;
-  if (!is_initialized)
-    for (int i = 0; i < static_cast<int>(HOST_SPACE_ATOMIC_MASK + 1); i++)
-      HOST_SPACE_ATOMIC_LOCKS[i] = 0;
-}
-
-bool lock_address_host_space(void *ptr) {
-  return 0 == atomic_compare_exchange(
-                  &HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) &
-                                            HOST_SPACE_ATOMIC_MASK) ^
-                                           HOST_SPACE_ATOMIC_XOR_MASK],
-                  0, 1);
-}
-
-void unlock_address_host_space(void *ptr) {
-  atomic_exchange(
-      &HOST_SPACE_ATOMIC_LOCKS[((size_t(ptr) >> 2) & HOST_SPACE_ATOMIC_MASK) ^
-                               HOST_SPACE_ATOMIC_XOR_MASK],
-      0);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
 //==============================================================================
 // <editor-fold desc="Explicit instantiations of CRTP Base classes"> {{{1
 
diff --git a/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp b/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp
new file mode 100644
index 0000000000..b373167127
--- /dev/null
+++ b/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp
@@ -0,0 +1,52 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_HOSTSPACE_ZEROMEMSET_HPP
+#define KOKKOS_HOSTSPACE_ZEROMEMSET_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <Kokkos_HostSpace.hpp>
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
+
+#include <iostream>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class T, class... P>
+struct ZeroMemset<HostSpace::execution_space, View<T, P...>> {
+  ZeroMemset(const HostSpace::execution_space& exec, const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    // Host spaces, except for HPX, are synchronous and we need to fence for HPX
+    // since we can't properly enqueue a std::memset otherwise.
+    // We can't use exec.fence() directly since we don't have a full definition
+    // of HostSpace here.
+    hostspace_fence(exec);
+    using ValueType = typename View<T, P...>::value_type;
+    std::memset(dst.data(), 0, sizeof(ValueType) * dst.size());
+  }
+
+  ZeroMemset(const View<T, P...>& dst,
+             typename View<T, P...>::const_value_type&) {
+    using ValueType = typename View<T, P...>::value_type;
+    std::memset(dst.data(), 0, sizeof(ValueType) * dst.size());
+  }
+};
+
+}  // end namespace Impl
+}  // end namespace Kokkos
+
+#endif  // KOKKOS_HOSTSPACE_ZEROMEMSET_HPP
diff --git a/core/src/impl/Kokkos_HostSpace_deepcopy.cpp b/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
index 096dfd6b7f..0ce5fe34b6 100644
--- a/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
+++ b/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
@@ -52,7 +52,8 @@ void hostspace_parallel_deepcopy_async(const DefaultHostExecutionSpace& exec,
   // synchronously. The deep copy must be correctly sequenced with respect to
   // other kernels submitted to the same instance, so we only use the fallback
   // parallel_for version in this case.
-#if !(defined(KOKKOS_ENABLE_HPX) && defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH))
+#if !(defined(KOKKOS_ENABLE_HPX) && \
+      defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH))
   constexpr int host_deep_copy_serial_limit = 10 * 8192;
   if ((n < host_deep_copy_serial_limit) ||
       (DefaultHostExecutionSpace().concurrency() == 1)) {
diff --git a/core/src/impl/Kokkos_HostThreadTeam.hpp b/core/src/impl/Kokkos_HostThreadTeam.hpp
index 1fec93237a..94db1f49bb 100644
--- a/core/src/impl/Kokkos_HostThreadTeam.hpp
+++ b/core/src/impl/Kokkos_HostThreadTeam.hpp
@@ -481,14 +481,14 @@ class HostThreadTeamMember {
         // with a return value of 'true'
 
         Kokkos::Impl::atomic_store(shared_value, value,
-                                   Kokkos::Impl::memory_order_release);
+                                   desul::MemoryOrderRelease());
 
         m_data.team_rendezvous_release();
         // This thread released all other threads from 'team_rendezvous'
         // with a return value of 'false'
       } else {
         value = Kokkos::Impl::atomic_load(shared_value,
-                                          Kokkos::Impl::memory_order_acquire);
+                                          desul::MemoryOrderAcquire());
       }
     }))
 
@@ -516,7 +516,7 @@ class HostThreadTeamMember {
 
           if (1 < m_data.m_team_size) {
             Kokkos::Impl::atomic_store(shared_value, value,
-                                       Kokkos::Impl::memory_order_release);
+                                       desul::MemoryOrderRelease());
           }
 
           m_data.team_rendezvous_release();
@@ -524,7 +524,7 @@ class HostThreadTeamMember {
           // with a return value of 'false'
         } else {
           value = Kokkos::Impl::atomic_load(shared_value,
-                                            Kokkos::Impl::memory_order_acquire);
+                                            desul::MemoryOrderAcquire());
         }))
 
     KOKKOS_IF_ON_DEVICE(
@@ -873,7 +873,8 @@ KOKKOS_INLINE_FUNCTION
   // Extract ValueType from the closure
 
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure>::value_type;
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
 
   value_type accum = 0;
 
@@ -899,7 +900,7 @@ KOKKOS_INLINE_FUNCTION
                       loop_boundaries,
                   ClosureType const& closure) {
   using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Impl::FunctorPatternInterface::SCAN, void, ClosureType>::value_type;
+      Impl::FunctorPatternInterface::SCAN, void, ClosureType, void>::value_type;
 
   value_type scan_val = value_type();
 
diff --git a/core/src/impl/Kokkos_Memory_Fence.hpp b/core/src/impl/Kokkos_Memory_Fence.hpp
index 392116a56e..42a53b04fb 100644
--- a/core/src/impl/Kokkos_Memory_Fence.hpp
+++ b/core/src/impl/Kokkos_Memory_Fence.hpp
@@ -19,35 +19,6 @@
 #define KOKKOS_MEMORY_FENCE_HPP
 namespace Kokkos {
 
-//----------------------------------------------------------------------------
-#ifndef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
-KOKKOS_FORCEINLINE_FUNCTION
-void memory_fence() {
-#if defined(__CUDA_ARCH__)
-  __threadfence();
-#elif defined(KOKKOS_ENABLE_OPENMPTARGET)
-#pragma omp flush
-#elif defined(__HIP_DEVICE_COMPILE__)
-  __threadfence();
-#elif defined(KOKKOS_ENABLE_SYCL) && defined(__SYCL_DEVICE_ONLY__)
-  sycl::atomic_fence(sycl::memory_order::acq_rel, sycl::memory_scope::device);
-#elif defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-  asm volatile("mfence" ::: "memory");
-#elif defined(KOKKOS_ENABLE_GNU_ATOMICS) || \
-    (defined(KOKKOS_COMPILER_NVCC) && defined(KOKKOS_ENABLE_INTEL_ATOMICS))
-  __sync_synchronize();
-#elif defined(KOKKOS_ENABLE_INTEL_ATOMICS)
-  _mm_mfence();
-#elif defined(KOKKOS_ENABLE_OPENMP_ATOMICS)
-#pragma omp flush
-#elif defined(KOKKOS_ENABLE_WINDOWS_ATOMICS)
-  MemoryBarrier();
-#elif !defined(KOKKOS_ENABLE_SERIAL_ATOMICS)
-#error "Error: memory_fence() not defined"
-#endif
-}
-#endif
-
 //////////////////////////////////////////////////////
 // store_fence()
 //
diff --git a/core/src/impl/Kokkos_NvidiaGpuArchitectures.hpp b/core/src/impl/Kokkos_NvidiaGpuArchitectures.hpp
new file mode 100644
index 0000000000..956b6dffea
--- /dev/null
+++ b/core/src/impl/Kokkos_NvidiaGpuArchitectures.hpp
@@ -0,0 +1,58 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#ifndef KOKKOS_CUDA_NVIDIA_GPU_ARCHITECTURES_HPP
+#define KOKKOS_CUDA_NVIDIA_GPU_ARCHITECTURES_HPP
+
+#if defined(KOKKOS_ARCH_KEPLER30)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 30
+#elif defined(KOKKOS_ARCH_KEPLER32)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 32
+#elif defined(KOKKOS_ARCH_KEPLER35)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 35
+#elif defined(KOKKOS_ARCH_KEPLER37)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 37
+#elif defined(KOKKOS_ARCH_MAXWELL50)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 50
+#elif defined(KOKKOS_ARCH_MAXWELL52)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 52
+#elif defined(KOKKOS_ARCH_MAXWELL53)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 53
+#elif defined(KOKKOS_ARCH_PASCAL60)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 60
+#elif defined(KOKKOS_ARCH_PASCAL61)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 61
+#elif defined(KOKKOS_ARCH_VOLTA70)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 70
+#elif defined(KOKKOS_ARCH_VOLTA72)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 72
+#elif defined(KOKKOS_ARCH_TURING75)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 75
+#elif defined(KOKKOS_ARCH_AMPERE80)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 80
+#elif defined(KOKKOS_ARCH_AMPERE86)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 86
+#elif defined(KOKKOS_ARCH_ADA89)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 89
+#elif defined(KOKKOS_ARCH_HOPPER90)
+#define KOKKOS_IMPL_ARCH_NVIDIA_GPU 90
+#elif defined(KOKKOS_ENABLE_CUDA)
+// do not raise an error on other backends that may run on NVIDIA GPUs such as
+// OpenACC, OpenMPTarget, or SYCL
+#error NVIDIA GPU arch not recognized
+#endif
+
+#endif
diff --git a/core/src/impl/Kokkos_Profiling.cpp b/core/src/impl/Kokkos_Profiling.cpp
index e3cfcb6a29..47780caab5 100644
--- a/core/src/impl/Kokkos_Profiling.cpp
+++ b/core/src/impl/Kokkos_Profiling.cpp
@@ -177,7 +177,8 @@ Kokkos::Tools::Impl::InitializationStatus parse_environment_variables(
     args = env_tools_args;
   }
   return {
-      Kokkos::Tools::Impl::InitializationStatus::InitializationResult::success};
+      Kokkos::Tools::Impl::InitializationStatus::InitializationResult::success,
+      ""};
 }
 InitializationStatus initialize_tools_subsystem(
     const Kokkos::Tools::InitArguments& args) {
@@ -192,13 +193,13 @@ InitializationStatus initialize_tools_subsystem(
     if (!Kokkos::Tools::printHelp(final_args)) {
       std::cerr << "Tool has not provided a help message" << std::endl;
     }
-    return {InitializationStatus::InitializationResult::help_request};
+    return {InitializationStatus::InitializationResult::help_request, ""};
   }
   Kokkos::Tools::parseArgs(final_args);
 #else
   (void)args;
 #endif
-  return {InitializationStatus::InitializationResult::success};
+  return {InitializationStatus::InitializationResult::success, ""};
 }
 
 }  // namespace Impl
@@ -644,10 +645,6 @@ void initialize(const std::string& profileLibrary) {
                 << ", RTLD_NOW | RTLD_GLOBAL) failed with " << dlerror()
                 << '\n';
     } else {
-#ifdef KOKKOS_ENABLE_PROFILING_LOAD_PRINT
-      std::cout << "KokkosP: Library Loaded: " << profileLibraryName
-                << std::endl;
-#endif
       lookup_function(firstProfileLibrary, "kokkosp_begin_parallel_scan",
                       Experimental::current_callbacks.begin_parallel_scan);
       lookup_function(firstProfileLibrary, "kokkosp_begin_parallel_for",
diff --git a/core/src/impl/Kokkos_Stacktrace.cpp b/core/src/impl/Kokkos_Stacktrace.cpp
index 3b8dc4efc3..b287510b38 100644
--- a/core/src/impl/Kokkos_Stacktrace.cpp
+++ b/core/src/impl/Kokkos_Stacktrace.cpp
@@ -134,7 +134,7 @@ void for_each_token(const std::string& s, Callback c) {
     const size_t end   = find_first_whitespace(s, cur);
     const bool last    = (end == std::string::npos);
     const size_t count = last ? end : size_t(end - cur);
-    c(s.substr(cur, count), last);
+    c(s.substr(cur, count));
     cur = find_first_non_whitespace(s, end);
   }
 }
@@ -147,7 +147,6 @@ void for_each_token(const std::string& s, Callback c) {
 struct main_column_info {
   bool found_main;
   size_t main_col;
-  std::vector<size_t> main_col_lens;
 };
 
 main_column_info find_main_column(const std::vector<std::string>& traceback) {
@@ -155,7 +154,7 @@ main_column_info find_main_column(const std::vector<std::string>& traceback) {
   size_t main_col = 0;
   for (auto&& entry : traceback) {
     size_t col_count = 0;
-    for_each_token(entry, [&](const std::string& s, bool) {
+    for_each_token(entry, [&](const std::string& s) {
       const size_t pos = s.find("main");
       if (pos != std::string::npos) {
         found_main = true;
@@ -168,52 +167,33 @@ main_column_info find_main_column(const std::vector<std::string>& traceback) {
     }
   }
 
-  // Make another pass to get the column lengths.
-  // Only demangle the column of functions.
-  std::vector<size_t> max_col_lengths;
-  for (auto&& entry : traceback) {
-    size_t col_count = 0;
-    for_each_token(entry, [&](const std::string& s, bool) {
-      const size_t cur_col_len =
-          (found_main && col_count == main_col) ? demangle(s).size() : s.size();
-      ++col_count;
-      if (max_col_lengths.size() < col_count) {
-        max_col_lengths.push_back(cur_col_len);
-      } else {
-        const size_t old_max_len = max_col_lengths[col_count - 1];
-        if (old_max_len < cur_col_len) {
-          max_col_lengths[col_count - 1] = cur_col_len;
-        }
-      }
-    });
-  }
-  return main_column_info{found_main, main_col, max_col_lengths};
+  return main_column_info{found_main, main_col};
 }
 
-void demangle_and_print_traceback_entry(
-    std::ostream& out, const std::string& traceback_entry,
-    const bool found_main, const size_t main_col,
-    const std::vector<size_t>& max_col_lens) {
+void demangle_and_print_traceback_entry(std::ostream& out,
+                                        const std::string& traceback_entry,
+                                        const bool found_main,
+                                        const size_t main_col) {
   std::vector<std::string> tokens;
   size_t cur_col = 0;
-  for_each_token(traceback_entry, [&](const std::string& s, bool last) {
-    const size_t old_width(out.width());
-    out.width(max_col_lens[cur_col]);
-    try {
-      if (found_main && cur_col == main_col) {
-        out << demangle(s);
-      } else {
-        out << s;
-      }
-      if (!last) {
-        out << " ";
-      }
-      ++cur_col;
-    } catch (...) {
-      out.width(old_width);
-      throw;
+
+  // Print the address column first
+  for_each_token(traceback_entry, [&](const std::string& s) {
+    if (!(found_main && cur_col == main_col)) {
+      out << s;
+    }
+    ++cur_col;
+  });
+
+  out << " ";
+
+  // Then the function name
+  cur_col = 0;
+  for_each_token(traceback_entry, [&](const std::string& s) {
+    if (found_main && cur_col == main_col) {
+      out << demangle(s);
     }
-    out.width(old_width);
+    ++cur_col;
   });
 }
 
@@ -222,7 +202,7 @@ void demangle_and_print_traceback(std::ostream& out,
   const auto result = find_main_column(traceback);
   for (auto&& entry : traceback) {
     demangle_and_print_traceback_entry(out, entry, result.found_main,
-                                       result.main_col, result.main_col_lens);
+                                       result.main_col);
     out << std::endl;
   }
 }
diff --git a/core/src/impl/Kokkos_StringManipulation.hpp b/core/src/impl/Kokkos_StringManipulation.hpp
index c7baf6d0c3..231cc2c39c 100644
--- a/core/src/impl/Kokkos_StringManipulation.hpp
+++ b/core/src/impl/Kokkos_StringManipulation.hpp
@@ -173,7 +173,7 @@ KOKKOS_FUNCTION constexpr to_chars_result to_chars_i(char *first, char *last,
       unsigned_val = Unsigned(~value) + Unsigned(1);
     }
   }
-  unsigned int const len = to_chars_len(unsigned_val);
+  std::ptrdiff_t const len = to_chars_len(unsigned_val);
   if (last - first < len) {
     return {last, errc::value_too_large};
   }
diff --git a/core/src/impl/Kokkos_TaskBase.hpp b/core/src/impl/Kokkos_TaskBase.hpp
index ac99d07159..ed548e99a8 100644
--- a/core/src/impl/Kokkos_TaskBase.hpp
+++ b/core/src/impl/Kokkos_TaskBase.hpp
@@ -174,17 +174,15 @@ class TaskBase {
 
     // Assign dependence to m_next.  It will be processed in the subsequent
     // call to schedule.  Error if the dependence is reset.
-    if (lock != Kokkos::Impl::desul_atomic_exchange(
-                    &m_next, dep, Kokkos::Impl::MemoryOrderSeqCst(),
-                    Kokkos::Impl::MemoryScopeDevice())) {
+    if (lock != desul::atomic_exchange(&m_next, dep, desul::MemoryOrderSeqCst(),
+                                       desul::MemoryScopeDevice())) {
       Kokkos::abort("TaskScheduler ERROR: resetting task dependence");
     }
     if (nullptr != dep) {
       // The future may be destroyed upon returning from this call
       // so increment reference count to track this assignment.
-      Kokkos::Impl::desul_atomic_inc(&(dep->m_ref_count),
-                                     Kokkos::Impl::MemoryOrderSeqCst(),
-                                     Kokkos::Impl::MemoryScopeDevice());
+      desul::atomic_inc(&(dep->m_ref_count), desul::MemoryOrderSeqCst(),
+                        desul::MemoryScopeDevice());
     }
   }
 
@@ -208,6 +206,7 @@ class TaskBase {
 // the number of full task types that fit into a cache line.  We'll leave it
 // here for now, though, since we're probably going to be ripping all of the
 // old TaskBase stuff out eventually anyway.
+#ifndef KOKKOS_IMPL_32BIT
 constexpr size_t unpadded_task_base_size = 44 + 2 * sizeof(int16_t);
 // don't forget padding:
 constexpr size_t task_base_misalignment =
@@ -231,7 +230,7 @@ static constexpr
 
 static_assert(sizeof(TaskBase) == expected_task_base_size,
               "Verifying expected sizeof(TaskBase)");
-
+#endif
 // </editor-fold> end Verify the size of TaskBase is as expected }}}2
 //------------------------------------------------------------------------------
 
diff --git a/core/src/impl/Kokkos_TaskNode.hpp b/core/src/impl/Kokkos_TaskNode.hpp
index 789ba14696..a81f298bbf 100644
--- a/core/src/impl/Kokkos_TaskNode.hpp
+++ b/core/src/impl/Kokkos_TaskNode.hpp
@@ -42,14 +42,6 @@
 namespace Kokkos {
 namespace Impl {
 
-#ifdef KOKKOS_COMPILER_PGI
-// Bizzarely, an extra jump instruction forces the PGI compiler to not have a
-// bug related to (probably?) empty base optimization and/or aggregate
-// construction.  This must be defined out-of-line to generate a jump
-// jump instruction
-void _kokkos_pgi_compiler_bug_workaround();
-#endif
-
 enum TaskType : int16_t {
   TaskTeam    = 0,
   TaskSingle  = 1,
@@ -101,17 +93,11 @@ class ReferenceCountedBase {
 
  public:
   KOKKOS_INLINE_FUNCTION
-#ifndef KOKKOS_COMPILER_PGI
-  constexpr
-#endif
-      explicit ReferenceCountedBase(
-          reference_count_size_type initial_reference_count)
+  constexpr explicit ReferenceCountedBase(
+      reference_count_size_type initial_reference_count)
       : m_ref_count(initial_reference_count) {
     // This can't be here because it breaks constexpr
     // KOKKOS_EXPECTS(initial_reference_count > 0);
-#ifdef KOKKOS_COMPILER_PGI
-    Impl::_kokkos_pgi_compiler_bug_workaround();
-#endif
   }
 
   /** Decrement the reference count,
@@ -131,9 +117,8 @@ class ReferenceCountedBase {
 
   KOKKOS_INLINE_FUNCTION
   void increment_reference_count() {
-    Kokkos::Impl::desul_atomic_inc(&m_ref_count,
-                                   Kokkos::Impl::MemoryOrderSeqCst(),
-                                   Kokkos::Impl::MemoryScopeDevice());
+    desul::atomic_inc(&m_ref_count, desul::MemoryOrderSeqCst(),
+                      desul::MemoryScopeDevice());
   }
 };
 
diff --git a/core/src/impl/Kokkos_TaskQueue.hpp b/core/src/impl/Kokkos_TaskQueue.hpp
index 5f182dc33f..8312fbc103 100644
--- a/core/src/impl/Kokkos_TaskQueue.hpp
+++ b/core/src/impl/Kokkos_TaskQueue.hpp
@@ -160,9 +160,8 @@ class TaskQueue : public TaskQueueBase {
                                      task_root_type* const rhs) {
     if (*lhs) decrement(*lhs);
     if (rhs) {
-      Kokkos::Impl::desul_atomic_inc(&rhs->m_ref_count,
-                                     Kokkos::Impl::MemoryOrderSeqCst(),
-                                     Kokkos::Impl::MemoryScopeDevice());
+      desul::atomic_inc(&rhs->m_ref_count, desul::MemoryOrderSeqCst(),
+                        desul::MemoryScopeDevice());
     }
 
     // Force write of *lhs
diff --git a/core/src/impl/Kokkos_TaskQueueCommon.hpp b/core/src/impl/Kokkos_TaskQueueCommon.hpp
index 18dc3c757b..4ff9c6b700 100644
--- a/core/src/impl/Kokkos_TaskQueueCommon.hpp
+++ b/core/src/impl/Kokkos_TaskQueueCommon.hpp
@@ -129,17 +129,15 @@ class TaskQueueCommonMixin {
   KOKKOS_INLINE_FUNCTION
   void _increment_ready_count() {
     // TODO @tasking @memory_order DSH memory order
-    Kokkos::Impl::desul_atomic_inc(&this->m_ready_count,
-                                   Kokkos::Impl::MemoryOrderSeqCst(),
-                                   Kokkos::Impl::MemoryScopeDevice());
+    desul::atomic_inc(&this->m_ready_count, desul::MemoryOrderSeqCst(),
+                      desul::MemoryScopeDevice());
   }
 
   KOKKOS_INLINE_FUNCTION
   void _decrement_ready_count() {
     // TODO @tasking @memory_order DSH memory order
-    Kokkos::Impl::desul_atomic_dec(&this->m_ready_count,
-                                   Kokkos::Impl::MemoryOrderSeqCst(),
-                                   Kokkos::Impl::MemoryScopeDevice());
+    desul::atomic_dec(&this->m_ready_count, desul::MemoryOrderSeqCst(),
+                      desul::MemoryScopeDevice());
   }
 
  public:
diff --git a/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp b/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp
index aef919e834..e2bb9d2b61 100644
--- a/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp
+++ b/core/src/impl/Kokkos_TaskQueueMemoryManager.hpp
@@ -73,9 +73,9 @@ class TaskQueueMemoryManager : public TaskQueueBase {
     } else {
       void* data = m_pool.allocate(static_cast<size_t>(requested_size));
 
-      Kokkos::Impl::desul_atomic_inc(
-          &m_count_alloc, Kokkos::Impl::MemoryOrderSeqCst(),
-          Kokkos::Impl::MemoryScopeDevice());  // TODO? memory_order_relaxed
+      desul::atomic_inc(
+          &m_count_alloc, desul::MemoryOrderSeqCst(),
+          desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
       // TODO @tasking @minor DSH make this thread safe? (otherwise, it's just
       // an approximation, which is probably fine...)
       if (m_max_alloc < m_count_alloc) m_max_alloc = m_count_alloc;
@@ -171,9 +171,9 @@ class TaskQueueMemoryManager : public TaskQueueBase {
   KOKKOS_INLINE_FUNCTION void deallocate(
       PoolAllocatedObjectBase<CountType>&& obj) {
     m_pool.deallocate((void*)&obj, 1);
-    Kokkos::Impl::desul_atomic_dec(
-        &m_count_alloc, Kokkos::Impl::MemoryOrderSeqCst(),
-        Kokkos::Impl::MemoryScopeDevice());  // TODO? memory_order_relaxed
+    desul::atomic_dec(
+        &m_count_alloc, desul::MemoryOrderSeqCst(),
+        desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
   }
 
   KOKKOS_INLINE_FUNCTION
diff --git a/core/src/impl/Kokkos_TaskQueueMultiple.hpp b/core/src/impl/Kokkos_TaskQueueMultiple.hpp
index e653f70fe9..39d70f331d 100644
--- a/core/src/impl/Kokkos_TaskQueueMultiple.hpp
+++ b/core/src/impl/Kokkos_TaskQueueMultiple.hpp
@@ -128,14 +128,12 @@ class TaskQueueMultiple : public TaskQueue<ExecSpace, MemorySpace> {
               // task stolen.
               // first increment our ready count, then decrement the ready count
               // on the other queue:
-              Kokkos::Impl::desul_atomic_inc(
-                  &this->m_ready_count, Kokkos::Impl::MemoryOrderSeqCst(),
-                  Kokkos::Impl::MemoryScopeDevice());  // TODO?
-                                                       // memory_order_relaxed
-              Kokkos::Impl::desul_atomic_dec(
-                  &steal_from.m_ready_count, Kokkos::Impl::MemoryOrderSeqCst(),
-                  Kokkos::Impl::MemoryScopeDevice());  // TODO?
-                                                       // memory_order_relaxed
+              desul::atomic_inc(
+                  &this->m_ready_count, desul::MemoryOrderSeqCst(),
+                  desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
+              desul::atomic_dec(
+                  &steal_from.m_ready_count, desul::MemoryOrderSeqCst(),
+                  desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
               return rv;
             }
           }
diff --git a/core/src/impl/Kokkos_TaskQueue_impl.hpp b/core/src/impl/Kokkos_TaskQueue_impl.hpp
index 68ff36579f..074dc7bb98 100644
--- a/core/src/impl/Kokkos_TaskQueue_impl.hpp
+++ b/core/src/impl/Kokkos_TaskQueue_impl.hpp
@@ -119,9 +119,9 @@ KOKKOS_FUNCTION void *TaskQueue<ExecSpace, MemorySpace>::allocate(size_t n) {
   void *const p = m_memory.allocate(n);
 
   if (p) {
-    Kokkos::Impl::desul_atomic_inc(
-        &m_count_alloc, Kokkos::Impl::MemoryOrderSeqCst(),
-        Kokkos::Impl::MemoryScopeDevice());  // TODO? memory_order_relaxed
+    desul::atomic_inc(
+        &m_count_alloc, desul::MemoryOrderSeqCst(),
+        desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
 
     // if ( m_max_alloc < m_count_alloc ) m_max_alloc = m_count_alloc ;
   }
@@ -133,9 +133,8 @@ template <typename ExecSpace, typename MemorySpace>
 KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::deallocate(void *p,
                                                                    size_t n) {
   m_memory.deallocate(p, n);
-  Kokkos::Impl::desul_atomic_dec(
-      &m_count_alloc, Kokkos::Impl::MemoryOrderSeqCst(),
-      Kokkos::Impl::MemoryScopeDevice());  // TODO? memory_order_relaxed
+  desul::atomic_dec(&m_count_alloc, desul::MemoryOrderSeqCst(),
+                    desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
 }
 
 //----------------------------------------------------------------------------
@@ -186,9 +185,9 @@ KOKKOS_FUNCTION bool TaskQueue<ExecSpace, MemorySpace>::push_task(
     //     *queue = task;
     //   }
     //   old_head = *queue;
-    old_head = Kokkos::Impl::desul_atomic_compare_exchange(
+    old_head = desul::atomic_compare_exchange(
         const_cast<task_root_type **>(queue), old_head, task,
-        Kokkos::Impl::MemoryOrderSeqCst(), Kokkos::Impl::MemoryScopeDevice());
+        desul::MemoryOrderSeqCst(), desul::MemoryScopeDevice());
 
     if (old_head_tmp == old_head) return true;
   }
@@ -237,9 +236,9 @@ TaskQueue<ExecSpace, MemorySpace>::pop_ready_task(
     task_root_type *const x = task;
 
     //    task = Kokkos::atomic_compare_exchange(queue, x, lock);
-    task = Kokkos::Impl::desul_atomic_compare_exchange(
-        const_cast<task_root_type **>(queue), x, lock,
-        Kokkos::Impl::MemoryOrderSeqCst(), Kokkos::Impl::MemoryScopeDevice());
+    task = desul::atomic_compare_exchange(const_cast<task_root_type **>(queue),
+                                          x, lock, desul::MemoryOrderSeqCst(),
+                                          desul::MemoryScopeDevice());
 
     if (x == task) {
       // CAS succeeded and queue is locked
@@ -383,9 +382,9 @@ KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::schedule_runnable(
     // to track number of ready + executing tasks.
     // The ready count will be decremented when the task is complete.
 
-    Kokkos::Impl::desul_atomic_inc(
-        &m_ready_count, Kokkos::Impl::MemoryOrderSeqCst(),
-        Kokkos::Impl::MemoryScopeDevice());  // TODO? memory_order_relaxed
+    desul::atomic_inc(
+        &m_ready_count, desul::MemoryOrderSeqCst(),
+        desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
 
     task_root_type *volatile *const ready_queue =
         &m_ready[t.m_priority][t.m_task_type];
@@ -538,9 +537,9 @@ KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::reschedule(
 
   task_root_type *const zero = nullptr;
   task_root_type *const lock = (task_root_type *)task_root_type::LockTag;
-  if (lock != Kokkos::Impl::desul_atomic_exchange(
-                  &task->m_next, zero, Kokkos::Impl::MemoryOrderSeqCst(),
-                  Kokkos::Impl::MemoryScopeDevice())) {
+  if (lock != desul::atomic_exchange(&task->m_next, zero,
+                                     desul::MemoryOrderSeqCst(),
+                                     desul::MemoryScopeDevice())) {
     Kokkos::abort("TaskScheduler::respawn ERROR: already respawned");
   }
 }
@@ -587,9 +586,9 @@ KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::complete(
 
     // Stop other tasks from adding themselves to this task's wait queue
     // by locking the head of this task's wait queue.
-    task_root_type *x = Kokkos::Impl::desul_atomic_exchange(
+    task_root_type *x = desul::atomic_exchange(
         const_cast<task_root_type **>(&t.m_wait), lock,
-        Kokkos::Impl::MemoryOrderSeqCst(), Kokkos::Impl::MemoryScopeDevice());
+        desul::MemoryOrderSeqCst(), desul::MemoryScopeDevice());
 
     if (x != (task_root_type *)lock) {
       // This thread has transitioned this 'task' to complete.
@@ -632,9 +631,9 @@ KOKKOS_FUNCTION void TaskQueue<ExecSpace, MemorySpace>::complete(
     // A runnable task was popped from a ready queue and executed.
     // If respawned into a ready queue then the ready count was incremented
     // so decrement whether respawned or not.
-    Kokkos::Impl::desul_atomic_dec(
-        &m_ready_count, Kokkos::Impl::MemoryOrderSeqCst(),
-        Kokkos::Impl::MemoryScopeDevice());  // TODO? memory_order_relaxed
+    desul::atomic_dec(
+        &m_ready_count, desul::MemoryOrderSeqCst(),
+        desul::MemoryScopeDevice());  // TODO? memory_order_relaxed
   }
 }
 
diff --git a/core/src/impl/Kokkos_Tools_Generic.hpp b/core/src/impl/Kokkos_Tools_Generic.hpp
index 4ccb64ce4f..a77e139ec3 100644
--- a/core/src/impl/Kokkos_Tools_Generic.hpp
+++ b/core/src/impl/Kokkos_Tools_Generic.hpp
@@ -18,6 +18,7 @@
 #define KOKKOS_IMPL_KOKKOS_TOOLS_GENERIC_HPP
 
 #include <impl/Kokkos_Profiling.hpp>
+#include <impl/Kokkos_FunctorAnalysis.hpp>
 
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_ExecPolicy.hpp>
@@ -99,9 +100,12 @@ struct SimpleTeamSizeCalculator {
                                         const Functor& functor,
                                         const Kokkos::ParallelReduceTag&) {
     using exec_space = typename Policy::execution_space;
-    using driver =
-        Kokkos::Impl::ParallelReduce<Functor, Policy, Kokkos::InvalidType,
-                                     exec_space>;
+    using analysis   = Kokkos::Impl::FunctorAnalysis<
+        Kokkos::Impl::FunctorPatternInterface::REDUCE, Policy, Functor, void>;
+    using driver = typename Kokkos::Impl::ParallelReduce<
+        Kokkos::Impl::CombinedFunctorReducer<Functor,
+                                             typename analysis::Reducer>,
+        Policy, exec_space>;
     return driver::max_tile_size_product(policy, functor);
   }
 };
@@ -120,7 +124,13 @@ struct ComplexReducerSizeCalculator {
     using value_type = typename ReducerType::value_type;
     value_type value;
     ReducerType reducer_example = ReducerType(value);
-    return policy.team_size_max(functor, reducer_example, tag);
+
+    using Analysis = Kokkos::Impl::FunctorAnalysis<
+        Kokkos::Impl::FunctorPatternInterface::REDUCE, Policy, ReducerType,
+        value_type>;
+    typename Analysis::Reducer final_reducer(reducer_example);
+
+    return policy.team_size_max(functor, final_reducer, tag);
   }
   template <typename Policy, typename Functor, typename Tag>
   int get_recommended_team_size(const Policy& policy, const Functor& functor,
@@ -128,15 +138,26 @@ struct ComplexReducerSizeCalculator {
     using value_type = typename ReducerType::value_type;
     value_type value;
     ReducerType reducer_example = ReducerType(value);
-    return policy.team_size_recommended(functor, reducer_example, tag);
+
+    using Analysis = Kokkos::Impl::FunctorAnalysis<
+        Kokkos::Impl::FunctorPatternInterface::REDUCE, Policy, ReducerType,
+        value_type>;
+    typename Analysis::Reducer final_reducer(reducer_example);
+
+    return policy.team_size_recommended(functor, final_reducer, tag);
   }
   template <typename Policy, typename Functor>
   int get_mdrange_max_tile_size_product(const Policy& policy,
                                         const Functor& functor,
                                         const Kokkos::ParallelReduceTag&) {
     using exec_space = typename Policy::execution_space;
-    using driver =
-        Kokkos::Impl::ParallelReduce<Functor, Policy, ReducerType, exec_space>;
+    using Analysis   = Kokkos::Impl::FunctorAnalysis<
+        Kokkos::Impl::FunctorPatternInterface::REDUCE, Policy, ReducerType,
+        void>;
+    using driver = typename Kokkos::Impl::ParallelReduce<
+        Kokkos::Impl::CombinedFunctorReducer<Functor,
+                                             typename Analysis::Reducer>,
+        Policy, exec_space>;
     return driver::max_tile_size_product(policy, functor);
   }
 };
diff --git a/core/src/impl/Kokkos_Utilities.hpp b/core/src/impl/Kokkos_Utilities.hpp
index c3504ffce5..67021c134c 100644
--- a/core/src/impl/Kokkos_Utilities.hpp
+++ b/core/src/impl/Kokkos_Utilities.hpp
@@ -29,6 +29,23 @@
 namespace Kokkos {
 namespace Impl {
 
+// same as std::integral_constant but with __host__ __device__ annotations on
+// the implicit conversion function and the call operator
+template <class T, T v>
+struct integral_constant {
+  using value_type         = T;
+  using type               = integral_constant<T, v>;
+  static constexpr T value = v;
+  KOKKOS_FUNCTION constexpr operator value_type() const noexcept {
+    return value;
+  }
+  KOKKOS_FUNCTION constexpr value_type operator()() const noexcept {
+    return value;
+  }
+};
+
+//==============================================================================
+
 template <typename... Is>
 struct always_true : std::true_type {};
 
@@ -74,25 +91,6 @@ struct is_specialization_of<Template<Args...>, Template> : std::true_type {};
 // </editor-fold> end is_specialization_of }}}1
 //==============================================================================
 
-//==============================================================================
-// destruct_delete is a unique_ptr deleter for objects
-// created by placement new into already allocated memory
-// by only calling the destructor on the object.
-//
-// Because unique_ptr never calls its deleter with a nullptr value,
-// no need to check if p == nullptr.
-//
-// Note:  This differs in interface from std::default_delete in that the
-// function call operator is templated instead of the class, to make
-// it easier to use and disallow specialization.
-struct destruct_delete {
-  template <typename T>
-  KOKKOS_INLINE_FUNCTION constexpr void operator()(T* p) const noexcept {
-    p->~T();
-  }
-};
-//==============================================================================
-
 //==============================================================================
 // <editor-fold desc="type_list"> {{{1
 
diff --git a/core/src/impl/Kokkos_ViewArray.hpp b/core/src/impl/Kokkos_ViewArray.hpp
index c76bde4993..725ba5de09 100644
--- a/core/src/impl/Kokkos_ViewArray.hpp
+++ b/core/src/impl/Kokkos_ViewArray.hpp
@@ -123,7 +123,7 @@ class ViewMapping<Traits, Kokkos::Array<>> {
   //----------------------------------------
   // Domain dimensions
 
-  enum { Rank = Traits::dimension::rank };
+  static constexpr unsigned Rank = Traits::dimension::rank;
 
   template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType &r) const {
diff --git a/core/src/impl/Kokkos_ViewCtor.hpp b/core/src/impl/Kokkos_ViewCtor.hpp
index 92c17d0cf5..e1b8ba86a5 100644
--- a/core/src/impl/Kokkos_ViewCtor.hpp
+++ b/core/src/impl/Kokkos_ViewCtor.hpp
@@ -234,6 +234,7 @@ struct ViewCtorProp : public ViewCtorProp<void, P>... {
   }
 };
 
+#if !defined(KOKKOS_COMPILER_MSVC) || !defined(KOKKOS_COMPILER_NVCC)
 template <typename... P>
 auto with_properties_if_unset(const ViewCtorProp<P...> &view_ctor_prop) {
   return view_ctor_prop;
@@ -274,6 +275,52 @@ auto with_properties_if_unset(const ViewCtorProp<P...> &view_ctor_prop,
 #endif
 #endif
 }
+#else
+
+template <class ViewCtorP, class... Properties>
+struct WithPropertiesIfUnset;
+
+template <class ViewCtorP>
+struct WithPropertiesIfUnset<ViewCtorP> {
+  static constexpr auto apply_prop(const ViewCtorP &view_ctor_prop) {
+    return view_ctor_prop;
+  }
+};
+
+template <class... P, class Property, class... Properties>
+struct WithPropertiesIfUnset<ViewCtorProp<P...>, Property, Properties...> {
+  static constexpr auto apply_prop(const ViewCtorProp<P...> &view_ctor_prop,
+                                   const Property &prop,
+                                   const Properties &... properties) {
+    if constexpr ((is_execution_space<Property>::value &&
+                   !ViewCtorProp<P...>::has_execution_space) ||
+                  (is_memory_space<Property>::value &&
+                   !ViewCtorProp<P...>::has_memory_space) ||
+                  (is_view_label<Property>::value &&
+                   !ViewCtorProp<P...>::has_label) ||
+                  (std::is_same_v<Property, WithoutInitializing_t> &&
+                   ViewCtorProp<P...>::initialize)) {
+      using NewViewCtorProp = ViewCtorProp<P..., Property>;
+      NewViewCtorProp new_view_ctor_prop(view_ctor_prop);
+      static_cast<ViewCtorProp<void, Property> &>(new_view_ctor_prop).value =
+          prop;
+      return WithPropertiesIfUnset<NewViewCtorProp, Properties...>::apply_prop(
+          new_view_ctor_prop, properties...);
+    } else
+      return WithPropertiesIfUnset<ViewCtorProp<P...>,
+                                   Properties...>::apply_prop(view_ctor_prop,
+                                                              properties...);
+  }
+};
+
+template <typename... P, class... Properties>
+auto with_properties_if_unset(const ViewCtorProp<P...> &view_ctor_prop,
+                              const Properties &... properties) {
+  return WithPropertiesIfUnset<ViewCtorProp<P...>, Properties...>::apply_prop(
+      view_ctor_prop, properties...);
+}
+
+#endif
 
 struct ExecutionSpaceTag {};
 struct MemorySpaceTag {};
diff --git a/core/src/impl/Kokkos_ViewMapping.hpp b/core/src/impl/Kokkos_ViewMapping.hpp
index 3ab8237cd1..877004ae4c 100644
--- a/core/src/impl/Kokkos_ViewMapping.hpp
+++ b/core/src/impl/Kokkos_ViewMapping.hpp
@@ -32,6 +32,7 @@
 #include <impl/Kokkos_Atomic_View.hpp>
 #include <impl/Kokkos_Tools.hpp>
 #include <impl/Kokkos_StringManipulation.hpp>
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -159,8 +160,8 @@ struct KOKKOS_IMPL_ENFORCE_EMPTY_BASE_OPTIMIZATION ViewDimension
   using D6::N6;
   using D7::N7;
 
-  enum : unsigned { rank = sizeof...(Vals) };
-  enum : unsigned { rank_dynamic = Impl::rank_dynamic<Vals...>::value };
+  static constexpr unsigned rank         = sizeof...(Vals);
+  static constexpr unsigned rank_dynamic = Impl::rank_dynamic<Vals...>::value;
 
   ViewDimension()                     = default;
   ViewDimension(const ViewDimension&) = default;
@@ -286,7 +287,6 @@ struct ViewDimensionAssignable<ViewDimension<DstArgs...>,
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
-namespace Impl {
 
 struct ALL_t {
   KOKKOS_INLINE_FUNCTION
@@ -296,7 +296,15 @@ struct ALL_t {
   constexpr bool operator==(const ALL_t&) const { return true; }
 };
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+namespace Impl {
+// TODO This alias declaration forces us to fully qualify ALL_t inside the
+// Kokkos::Impl namespace to avoid deprecation warnings. Replace the
+// fully-qualified name when we remove Kokkos::Impl::ALL_t.
+using ALL_t KOKKOS_DEPRECATED_WITH_COMMENT("Use Kokkos::ALL_t instead!") =
+    Kokkos::ALL_t;
 }  // namespace Impl
+#endif
 }  // namespace Kokkos
 
 namespace Kokkos {
@@ -304,7 +312,7 @@ namespace Impl {
 
 template <class T>
 struct is_integral_extent_type {
-  enum : bool { value = std::is_same<T, Kokkos::Impl::ALL_t>::value ? 1 : 0 };
+  enum : bool { value = std::is_same<T, Kokkos::ALL_t>::value ? 1 : 0 };
 };
 
 template <class iType>
@@ -354,7 +362,7 @@ struct SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
               (Kokkos::Impl::is_integral_extent_type<Arg>::value)) ||
              ((CurrentArg >= RankDest) && (std::is_integral<Arg>::value)) ||
              ((CurrentArg < RankDest) &&
-              (std::is_same<Arg, Kokkos::Impl::ALL_t>::value)) ||
+              (std::is_same<Arg, Kokkos::ALL_t>::value)) ||
              ((CurrentArg == 0) &&
               (Kokkos::Impl::is_integral_extent_type<Arg>::value))) &&
             (SubviewLegalArgsCompileTime<Kokkos::LayoutLeft, Kokkos::LayoutLeft,
@@ -385,7 +393,7 @@ struct SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight,
              ((CurrentArg < RankSrc - RankDest) &&
               (std::is_integral<Arg>::value)) ||
              ((CurrentArg >= RankSrc - RankDest) &&
-              (std::is_same<Arg, Kokkos::Impl::ALL_t>::value))) &&
+              (std::is_same<Arg, Kokkos::ALL_t>::value))) &&
             (SubviewLegalArgsCompileTime<Kokkos::LayoutRight,
                                          Kokkos::LayoutRight, RankDest, RankSrc,
                                          CurrentArg + 1, SubViewArgs...>::value)
@@ -397,7 +405,7 @@ struct SubviewLegalArgsCompileTime<Kokkos::LayoutRight, Kokkos::LayoutRight,
                                    RankDest, RankSrc, CurrentArg, Arg> {
   enum {
     value = ((CurrentArg == RankSrc - 1) &&
-             (std::is_same<Arg, Kokkos::Impl::ALL_t>::value))
+             (std::is_same<Arg, Kokkos::ALL_t>::value))
   };
 };
 
@@ -463,8 +471,7 @@ struct SubviewExtents {
   KOKKOS_FORCEINLINE_FUNCTION bool set(unsigned domain_rank,
                                        unsigned range_rank,
                                        const ViewDimension<DimArgs...>& dim,
-                                       const Kokkos::Impl::ALL_t,
-                                       Args... args) {
+                                       Kokkos::ALL_t, Args... args) {
     m_begin[domain_rank] = 0;
     m_length[range_rank] = dim.extent(domain_rank);
     m_index[range_rank]  = domain_rank;
@@ -559,7 +566,7 @@ struct SubviewExtents {
   // std::pair range
   template <size_t... DimArgs, class... Args>
   void error(char* buf, int buf_len, unsigned domain_rank, unsigned range_rank,
-             const ViewDimension<DimArgs...>& dim, const Kokkos::Impl::ALL_t,
+             const ViewDimension<DimArgs...>& dim, Kokkos::ALL_t,
              Args... args) const {
     const int n = std::min(buf_len, snprintf(buf, buf_len, " Kokkos::ALL %c",
                                              int(sizeof...(Args) ? ',' : ')')));
@@ -2183,7 +2190,8 @@ struct ViewStride;
 
 template <>
 struct ViewStride<0> {
-  enum { S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
+  static constexpr size_t S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0, S5 = 0,
+                          S6 = 0, S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2197,7 +2205,8 @@ struct ViewStride<0> {
 template <>
 struct ViewStride<1> {
   size_t S0;
-  enum { S1 = 0, S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
+  static constexpr size_t S1 = 0, S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0,
+                          S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2212,7 +2221,7 @@ struct ViewStride<1> {
 template <>
 struct ViewStride<2> {
   size_t S0, S1;
-  enum { S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
+  static constexpr size_t S2 = 0, S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2227,7 +2236,7 @@ struct ViewStride<2> {
 template <>
 struct ViewStride<3> {
   size_t S0, S1, S2;
-  enum { S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
+  static constexpr size_t S3 = 0, S4 = 0, S5 = 0, S6 = 0, S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2242,7 +2251,7 @@ struct ViewStride<3> {
 template <>
 struct ViewStride<4> {
   size_t S0, S1, S2, S3;
-  enum { S4 = 0, S5 = 0, S6 = 0, S7 = 0 };
+  static constexpr size_t S4 = 0, S5 = 0, S6 = 0, S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2257,7 +2266,7 @@ struct ViewStride<4> {
 template <>
 struct ViewStride<5> {
   size_t S0, S1, S2, S3, S4;
-  enum { S5 = 0, S6 = 0, S7 = 0 };
+  static constexpr size_t S5 = 0, S6 = 0, S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2272,7 +2281,7 @@ struct ViewStride<5> {
 template <>
 struct ViewStride<6> {
   size_t S0, S1, S2, S3, S4, S5;
-  enum { S6 = 0, S7 = 0 };
+  static constexpr size_t S6 = 0, S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2287,7 +2296,7 @@ struct ViewStride<6> {
 template <>
 struct ViewStride<7> {
   size_t S0, S1, S2, S3, S4, S5, S6;
-  enum { S7 = 0 };
+  static constexpr size_t S7 = 0;
 
   ViewStride()                  = default;
   ViewStride(const ViewStride&) = default;
@@ -2707,14 +2716,8 @@ struct ViewDataHandle<
     Traits,
     std::enable_if_t<(std::is_void<typename Traits::specialize>::value &&
                       (!Traits::memory_traits::is_aligned) &&
-                      Traits::memory_traits::is_restrict
-#ifdef KOKKOS_ENABLE_CUDA
-                      && (!(std::is_same<typename Traits::memory_space,
-                                         Kokkos::CudaSpace>::value ||
-                            std::is_same<typename Traits::memory_space,
-                                         Kokkos::CudaUVMSpace>::value))
-#endif
-                      && (!Traits::memory_traits::is_atomic))>> {
+                      Traits::memory_traits::is_restrict &&
+                      (!Traits::memory_traits::is_atomic))>> {
   using value_type  = typename Traits::value_type;
   using handle_type = typename Traits::value_type* KOKKOS_RESTRICT;
   using return_type = typename Traits::value_type& KOKKOS_RESTRICT;
@@ -2737,14 +2740,8 @@ struct ViewDataHandle<
     Traits,
     std::enable_if_t<(std::is_void<typename Traits::specialize>::value &&
                       Traits::memory_traits::is_aligned &&
-                      (!Traits::memory_traits::is_restrict)
-#ifdef KOKKOS_ENABLE_CUDA
-                      && (!(std::is_same<typename Traits::memory_space,
-                                         Kokkos::CudaSpace>::value ||
-                            std::is_same<typename Traits::memory_space,
-                                         Kokkos::CudaUVMSpace>::value))
-#endif
-                      && (!Traits::memory_traits::is_atomic))>> {
+                      (!Traits::memory_traits::is_restrict) &&
+                      (!Traits::memory_traits::is_atomic))>> {
   using value_type = typename Traits::value_type;
   // typedef work-around for intel compilers error #3186: expected typedef
   // declaration
@@ -2782,14 +2779,8 @@ struct ViewDataHandle<
     Traits,
     std::enable_if_t<(std::is_void<typename Traits::specialize>::value &&
                       Traits::memory_traits::is_aligned &&
-                      Traits::memory_traits::is_restrict
-#ifdef KOKKOS_ENABLE_CUDA
-                      && (!(std::is_same<typename Traits::memory_space,
-                                         Kokkos::CudaSpace>::value ||
-                            std::is_same<typename Traits::memory_space,
-                                         Kokkos::CudaUVMSpace>::value))
-#endif
-                      && (!Traits::memory_traits::is_atomic))>> {
+                      Traits::memory_traits::is_restrict &&
+                      (!Traits::memory_traits::is_atomic))>> {
   using value_type = typename Traits::value_type;
   // typedef work-around for intel compilers error #3186: expected typedef
   // declaration
@@ -2928,8 +2919,9 @@ struct ViewValueFunctor<DeviceType, ValueType, false /* is_scalar */> {
             "Kokkos::View::initialization [" + name + "] via memset",
             Kokkos::Profiling::Experimental::device_id(space), &kpID);
       }
-      (void)ZeroMemset<ExecSpace, ValueType*, typename DeviceType::memory_space,
-                       Kokkos::MemoryTraits<Kokkos::Unmanaged>>(
+      (void)ZeroMemset<
+          ExecSpace, Kokkos::View<ValueType*, typename DeviceType::memory_space,
+                                  Kokkos::MemoryTraits<Kokkos::Unmanaged>>>(
           space,
           Kokkos::View<ValueType*, typename DeviceType::memory_space,
                        Kokkos::MemoryTraits<Kokkos::Unmanaged>>(ptr, n),
@@ -3065,8 +3057,9 @@ struct ViewValueFunctor<DeviceType, ValueType, true /* is_scalar */> {
             Kokkos::Profiling::Experimental::device_id(space), &kpID);
       }
 
-      (void)ZeroMemset<ExecSpace, ValueType*, typename DeviceType::memory_space,
-                       Kokkos::MemoryTraits<Kokkos::Unmanaged>>(
+      (void)ZeroMemset<
+          ExecSpace, Kokkos::View<ValueType*, typename DeviceType::memory_space,
+                                  Kokkos::MemoryTraits<Kokkos::Unmanaged>>>(
           space,
           Kokkos::View<ValueType*, typename DeviceType::memory_space,
                        Kokkos::MemoryTraits<Kokkos::Unmanaged>>(ptr, n),
@@ -3158,7 +3151,7 @@ class ViewMapping<
   //----------------------------------------
   // Domain dimensions
 
-  enum { Rank = Traits::dimension::rank };
+  static constexpr unsigned Rank = Traits::dimension::rank;
 
   template <typename iType>
   KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType& r) const {
@@ -3674,7 +3667,7 @@ class ViewMapping<
     size_t exp_stride = 1;
     if (std::is_same<typename DstTraits::array_layout,
                      Kokkos::LayoutLeft>::value) {
-      for (int i = 0; i < src.Rank; i++) {
+      for (unsigned int i = 0; i < src.Rank; i++) {
         if (i > 0) exp_stride *= src.extent(i - 1);
         if (strides[i] != exp_stride) {
           assignable = false;
@@ -3683,9 +3676,9 @@ class ViewMapping<
       }
     } else if (std::is_same<typename DstTraits::array_layout,
                             Kokkos::LayoutRight>::value) {
-      for (int i = src.Rank - 1; i >= 0; i--) {
-        if (i < src.Rank - 1) exp_stride *= src.extent(i + 1);
-        if (strides[i] != exp_stride) {
+      for (unsigned int i = 0; i < src.Rank; i++) {
+        if (i > 0) exp_stride *= src.extent(src.Rank - i);
+        if (strides[src.Rank - 1 - i] != exp_stride) {
           assignable = false;
           break;
         }
@@ -3786,8 +3779,8 @@ struct SubViewDataTypeImpl<
 /* for ALL slice, subview has the same dimension */
 template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class... Args>
 struct SubViewDataTypeImpl<void, ValueType,
-                           Kokkos::Experimental::Extents<Ext, Exts...>, ALL_t,
-                           Args...>
+                           Kokkos::Experimental::Extents<Ext, Exts...>,
+                           Kokkos::ALL_t, Args...>
     : SubViewDataTypeImpl<void, typename ApplyExtent<ValueType, Ext>::type,
                           Kokkos::Experimental::Extents<Exts...>, Args...> {};
 
diff --git a/algorithms/unit_tests/TestSortCommon.hpp b/core/src/impl/Kokkos_ZeroMemset_fwd.hpp
similarity index 67%
rename from algorithms/unit_tests/TestSortCommon.hpp
rename to core/src/impl/Kokkos_ZeroMemset_fwd.hpp
index b8e2e17e4f..f36e72e914 100644
--- a/algorithms/unit_tests/TestSortCommon.hpp
+++ b/core/src/impl/Kokkos_ZeroMemset_fwd.hpp
@@ -14,14 +14,16 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_COMMON_HPP
-#define KOKKOS_ALGORITHMS_UNITTESTS_TESTSORT_COMMON_HPP
+#ifndef KOKKOS_ZEROMEMSET_FWD_HPP
+#define KOKKOS_ZEROMEMSET_FWD_HPP
 
-#include <TestSort.hpp>
+namespace Kokkos {
+namespace Impl {
 
-namespace Test {
-TEST(TEST_CATEGORY, SortUnsigned) {
-  Impl::test_sort<TEST_EXECSPACE, unsigned>(171);
-}
-}  // namespace Test
-#endif
+template <typename ExecutionSpace, class ViewType>
+struct ZeroMemset;
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // #ifndef KOKKOS_ZEROMEMSET_FWD_HPP
diff --git a/core/src/setup/Kokkos_Setup_Cuda.hpp b/core/src/setup/Kokkos_Setup_Cuda.hpp
index d774914d9f..1130485e84 100644
--- a/core/src/setup/Kokkos_Setup_Cuda.hpp
+++ b/core/src/setup/Kokkos_Setup_Cuda.hpp
@@ -53,28 +53,9 @@
 #error "Cuda device capability >= 3.0 is required."
 #endif
 
-#ifdef KOKKOS_ENABLE_CUDA_LAMBDA
 #define KOKKOS_LAMBDA [=] __host__ __device__
-
 #define KOKKOS_CLASS_LAMBDA [ =, *this ] __host__ __device__
 
-#else  // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
-#undef KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
-#endif  // !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
-
-#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 700)
-// PTX atomics with memory order semantics are only available on volta and later
-#if !defined(KOKKOS_DISABLE_CUDA_ASM)
-#if !defined(KOKKOS_ENABLE_CUDA_ASM)
-#define KOKKOS_ENABLE_CUDA_ASM
-#if !defined(KOKKOS_DISABLE_CUDA_ASM_ATOMICS) && \
-    defined(KOKKOS_ENABLE_GNU_ATOMICS)
-#define KOKKOS_ENABLE_CUDA_ASM_ATOMICS
-#endif
-#endif
-#endif
-#endif
-
 #define KOKKOS_IMPL_FORCEINLINE_FUNCTION __device__ __host__ __forceinline__
 #define KOKKOS_IMPL_FORCEINLINE __forceinline__
 #define KOKKOS_IMPL_INLINE_FUNCTION __device__ __host__ inline
diff --git a/core/unit_test/CMakeLists.txt b/core/unit_test/CMakeLists.txt
index 8019e5f3bb..f5a979a313 100644
--- a/core/unit_test/CMakeLists.txt
+++ b/core/unit_test/CMakeLists.txt
@@ -3,7 +3,7 @@
 #
 
 IF(NOT GTest_FOUND)  # fallback to internal gtest
-  SET(GTEST_SOURCE_DIR ${${PARENT_PACKAGE_NAME}_SOURCE_DIR}/tpls/gtest)
+  SET(GTEST_SOURCE_DIR ${Kokkos_SOURCE_DIR}/tpls/gtest)
 
   #need here for tribits
   KOKKOS_INCLUDE_DIRECTORIES(${GTEST_SOURCE_DIR})
@@ -58,7 +58,7 @@ SET(KOKKOS_SYCL_FEATURE_LEVEL 999)
 SET(KOKKOS_SYCL_NAME Experimental::SYCL)
 SET(KOKKOS_THREADS_FEATURE_LEVEL 999)
 SET(KOKKOS_THREADS_NAME Threads)
-SET(KOKKOS_OPENACC_FEATURE_LEVEL 11)
+SET(KOKKOS_OPENACC_FEATURE_LEVEL 16)
 SET(KOKKOS_OPENACC_NAME Experimental::OpenACC)
 
 
@@ -75,8 +75,11 @@ SET(COMPILE_ONLY_SOURCES
   TestArray.cpp
   TestCreateMirror.cpp
   TestDetectionIdiom.cpp
+  TestBitManipulation.cpp
   TestInterOp.cpp
   TestStringManipulation.cpp
+  TestVersionMacros.cpp
+  TestViewRank.cpp
   TestViewTypeTraits.cpp
   TestTypeList.cpp
   view/TestExtentsDatatypeConversion.cpp
@@ -92,7 +95,7 @@ IF(KOKKOS_HAS_TRILINOS)
   LIST(REMOVE_ITEM COMPILE_ONLY_SOURCES TestInterOp.cpp)
 ENDIF()
 KOKKOS_ADD_EXECUTABLE(
-  TestCompileOnly
+  CoreTestCompileOnly
   SOURCES
   TestCompileMain.cpp
   ${COMPILE_ONLY_SOURCES}
@@ -110,39 +113,39 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
     # file. That then exceeded the shell command line max length.
     set(${Tag}_SOURCES1A)
     foreach(Name
+        Abort
+        AtomicOperations_complexdouble
+        AtomicOperations_complexfloat
+        AtomicOperations_double
+        AtomicOperations_float
         AtomicOperations_int
-        AtomicOperations_unsignedint
         AtomicOperations_longint
-        AtomicOperations_unsignedlongint
         AtomicOperations_longlongint
-        AtomicOperations_double
-        AtomicOperations_float
-        AtomicOperations_complexdouble
-        AtomicOperations_complexfloat
         AtomicOperations_shared
-        AtomicViews
+        AtomicOperations_unsignedint
+        AtomicOperations_unsignedlongint
         Atomics
+        AtomicViews
+        BitManipulationBuiltins
         BlockSizeDeduction
-        Concepts
+        CommonPolicyConstructors
+        CommonPolicyInterface
         Complex
+        Concepts
         Crs
         DeepCopyAlignment
+        ExecSpacePartitioning
         ExecutionSpace
         FunctorAnalysis
+        HostSharedPtr
+        HostSharedPtrAccessOnDevice
         Init
         JoinBackwardCompatibility
         LocalDeepCopy
-        MinMaxClamp
         MathematicalConstants
         MathematicalFunctions1
         MathematicalFunctions2
-        MDRange_a
-        MDRange_b
-        MDRange_c
-        HostSharedPtr
-        HostSharedPtrAccessOnDevice
-        QuadPrecisionMath
-        ExecSpacePartitioning
+        MathematicalFunctions3
         MathematicalSpecialFunctions
         )
       set(file ${dir}/Test${Tag}_${Name}.cpp)
@@ -158,31 +161,33 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
 
     set(${Tag}_SOURCES1B)
     foreach(Name
+        MDRange_a
+        MDRange_b
+        MDRange_c
         MDRange_d
         MDRange_e
         MDRange_f
         MDRange_g
+        MDRangePolicyConstructors
+        MDRangeReduce
+        MDSpan
+        MinMaxClamp
         NumericTraits
         Other
+        ParallelScanRangePolicy
+        QuadPrecisionMath
         RangePolicy
-        RangePolicyRequire
-        CommonPolicyConstructors
         RangePolicyConstructors
-        TeamPolicyConstructors
-        MDRangePolicyConstructors
-        CommonPolicyInterface
-        Reductions
+        RangePolicyRequire
+        ReducerCTADs
         Reducers_a
         Reducers_b
         Reducers_c
         Reducers_d
         Reducers_e
-        ReducerCTADs
+        Reductions
         Reductions_DeviceView
-        Scan
         SharedAlloc
-        TeamMDRange
-        ViewMapping_a
         )
       set(file ${dir}/Test${Tag}_${Name}.cpp)
       # Write to a temporary intermediate file and call configure_file to avoid
@@ -197,15 +202,17 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
 
     SET(${Tag}_SOURCES2A)
     foreach(Name
-      Abort
-      MDSpan
       TeamBasic
+      TeamCombinedReducers
+      TeamMDRange
+      TeamPolicyConstructors
       TeamReductionScan
       TeamScan
       TeamScratch
       TeamTeamSize
       TeamVectorRange
       UniqueToken
+      View_64bit
       ViewAPI_a
       ViewAPI_b
       ViewAPI_c
@@ -216,12 +223,12 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
       ViewCtorDimMatch
       ViewHooks
       ViewLayoutStrideAssignment
+      ViewMapping_a
       ViewMapping_b
       ViewMapping_subview
       ViewMemoryAccessViolation
       ViewOfClass
       ViewResize
-      View_64bit
       WorkGraph
       WithoutInitializing
       )
@@ -350,34 +357,36 @@ endforeach()
 if(Kokkos_ENABLE_OPENMPTARGET)
   list(REMOVE_ITEM OpenMPTarget_SOURCES
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Other.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamCombinedReducers.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamReductionScan.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_WorkGraph.cpp
+    # FIXME_OPENMPTARGET_CRAY: The following tests fail at compile time when the OpenMPTarget backend is enabled with the Cray compiler.
+    # Atomic compare/exchange is used in these tests which can be one of the reasons for the compilation failures.
+    IF(KOKKOS_CXX_COMPILER_ID STREQUAL Cray)
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_complexdouble.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_UniqueToken.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SharedAlloc.cpp
+    ENDIF()
     )
 endif()
 
 if(Kokkos_ENABLE_OPENACC)
   list(REMOVE_ITEM OpenACC_SOURCES
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_complexfloat.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_complexdouble.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_complexfloat.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Crs.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_JoinBackwardCompatibility.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_LocalDeepCopy.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Other.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamCombinedReducers.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamMDRange.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamReductionScan.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamScan.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamVectorRange.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_e.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewCopy_a.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewCopy_b.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewMapping_subview.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewOfClass.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_WorkGraph.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamVectorRange.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_JoinBackwardCompatibility.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_CommonPolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_RangePolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamPolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRangePolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_CommonPolicyInterface.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamMDRange.cpp
   )
 endif()
 
@@ -402,43 +411,40 @@ ENDIF()
 # FIXME_OPENMPTARGET - Comment non-passing tests with the NVIDIA HPC compiler nvc++
 IF(KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
   list(REMOVE_ITEM OpenMPTarget_SOURCES
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_int64_t_reduce.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_int64_t_reduce_dynamic.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_int64_t_reduce_dynamic_view.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_double_reduce.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_double_reduce_dynamic.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamTeamSize.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reductions_DeviceView.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamVectorRange.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_UniqueToken.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_HostSharedPtr.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_HostSharedPtrAccessOnDevice.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamScratch.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TestScan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TestTeamScan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TestTeamReductionScan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Atomics.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_a1.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_b1.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_double.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_float.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_int.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_longint.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_longlongint.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_double.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedint.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_unsignedlongint.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Atomics.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicViews.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_BlockSizeDeduction.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_CommonPolicyConstructors.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_CommonPolicyInterface.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_DeepCopyAlignment.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_HostSharedPtr.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_HostSharedPtrAccessOnDevice.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MathematicalFunctions.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_a.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_b.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_c.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_d.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRangePolicyConstructors.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_NumericTraits.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_RangePolicy.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_RangePolicyConstructors.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_RangePolicyRequire.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_a.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_b.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_c.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_d.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_e.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewMapping_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamBasic.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Scan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_NumericTraits.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_DeepCopyAlignment.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MathematicalFunctions.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reductions_DeviceView.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_b.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c01.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c02.cpp
@@ -453,129 +459,85 @@ IF(KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c11.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c12.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c13.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_a.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_c.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRange_d.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamBasic.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamPolicyConstructors.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamScratch.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamTeamSize.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamVectorRange.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_UniqueToken.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewAPI_a.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewAPI_b.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewAPI_c.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewAPI_d.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewAPI_f.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewMapping_b.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewResize.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_RangePolicyRequire.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_RangePolicy.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_CommonPolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_RangePolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamPolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MDRangePolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_CommonPolicyInterface.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_a1.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_b1.cpp
     )
 endif()
 
 # FIXME_OPENACC - Comment non-passing tests with the NVIDIA HPC compiler nvc++
 IF(KOKKOS_ENABLE_OPENACC AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
   list(REMOVE_ITEM OpenACC_SOURCES
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_int64_t_reduce.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_int64_t_reduce_dynamic.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_int64_t_reduce_dynamic_view.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_double_reduce.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_double_reduce_dynamic.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamTeamSize.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reductions_DeviceView.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamVectorRange.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_UniqueToken.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_HostSharedPtr.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_HostSharedPtrAccessOnDevice.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamScratch.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TestScan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TestTeamScan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TestTeamReductionScan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Atomics.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_a1.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_b1.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_double.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_float.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_int.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_longint.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_longlongint.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_double.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_shared.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_unsignedint.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_unsignedlongint.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_shared.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Atomics.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicViews.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_BlockSizeDeduction.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reductions.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reduce.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_a.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_c.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_d.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_e.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewMapping_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamBasic.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Scan.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_NumericTraits.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_DeepCopyAlignment.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalFunctions.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_HostSharedPtr.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_HostSharedPtrAccessOnDevice.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalFunctions1.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalFunctions2.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_a.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalFunctions3.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_c.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_f.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_NumericTraits.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_RangePolicy.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_RangePolicyRequire.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_a.cpp #fails if NVHPC V22.5 or lower.
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reducers_d.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reductions.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Reductions_DeviceView.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c01.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c02.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c03.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c04.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c05.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c06.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c07.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c08.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c09.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c10.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c11.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c12.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c13.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_a.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_c.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_d.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_e.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_f.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRange_g.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_a.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_b.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_c.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_d.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_f.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamBasic.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamScratch.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamTeamSize.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_UniqueToken.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewMapping_b.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewResize.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_RangePolicyRequire.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_RangePolicy.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_CommonPolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_RangePolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_TeamPolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MDRangePolicyConstructors.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_CommonPolicyInterface.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_a1.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_b1.cpp
     )
 endif()
 
 if(Kokkos_ENABLE_SERIAL)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Serial1
+    CoreUnitTest_Serial1
     SOURCES
     UnitTestMainInit.cpp
     ${Serial_SOURCES1}
     serial/TestSerial_Task.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Serial2
+    CoreUnitTest_Serial2
     SOURCES
     UnitTestMainInit.cpp
     ${Serial_SOURCES2}
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SerialGraph
+    CoreUnitTest_SerialGraph
     SOURCES
     UnitTestMainInit.cpp
     serial/TestSerial_Graph.cpp
@@ -584,7 +546,7 @@ endif()
 
 if(Kokkos_ENABLE_THREADS)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Threads
+    CoreUnitTest_Threads
     SOURCES ${Threads_SOURCES}
     UnitTestMainInit.cpp
   )
@@ -596,20 +558,20 @@ if (Kokkos_ENABLE_OPENMP)
     openmp/TestOpenMP_PartitionMaster.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_OpenMP
+    CoreUnitTest_OpenMP
     SOURCES
     UnitTestMainInit.cpp
     ${OpenMP_SOURCES}
     ${OpenMP_EXTRA_SOURCES}
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_OpenMPInterOp
+    CoreUnitTest_OpenMPInterOp
     SOURCES
       UnitTestMain.cpp
       openmp/TestOpenMP_InterOp.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_OpenMPGraph
+    CoreUnitTest_OpenMPGraph
     SOURCES
       UnitTestMainInit.cpp
       openmp/TestOpenMP_Graph.cpp
@@ -618,32 +580,39 @@ endif()
 
 if(Kokkos_ENABLE_HPX)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_HPX
+    CoreUnitTest_HPX
     SOURCES
       UnitTestMainInit.cpp
       ${HPX_SOURCES}
       hpx/TestHPX_Task.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_HPXInterOp
+    CoreUnitTest_HPXInterOp
     SOURCES
       UnitTestMain.cpp
       hpx/TestHPX_InterOp.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_HPX_IndependentInstances
+    CoreUnitTest_HPX_IndependentInstances
     SOURCES
       UnitTestMainInit.cpp
       hpx/TestHPX_IndependentInstances.cpp
       hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
       hpx/TestHPX_IndependentInstancesInstanceIds.cpp
       hpx/TestHPX_IndependentInstancesRefCounting.cpp
+      hpx/TestHPX_IndependentInstancesSynchronization.cpp
+  )
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    CoreUnitTest_HPX_InParallel
+    SOURCES
+      UnitTestMainInit.cpp
+      hpx/TestHPX_InParallel.cpp
   )
 endif()
 
 if(Kokkos_ENABLE_OPENMPTARGET)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_OpenMPTarget
+    CoreUnitTest_OpenMPTarget
     SOURCES
     UnitTestMainInit.cpp
     ${OpenMPTarget_SOURCES}
@@ -652,7 +621,7 @@ endif()
 
 if(Kokkos_ENABLE_OPENACC)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_OpenACC
+    CoreUnitTest_OpenACC
     SOURCES
     UnitTestMainInit.cpp
     ${OpenACC_SOURCES}
@@ -661,7 +630,7 @@ endif()
 
 if(Kokkos_ENABLE_CUDA)
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Cuda1
+    CoreUnitTest_Cuda1
     SOURCES
       UnitTestMainInit.cpp
       ${Cuda_SOURCES1}
@@ -669,14 +638,14 @@ if(Kokkos_ENABLE_CUDA)
     )
 
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Cuda2
+    CoreUnitTest_Cuda2
     SOURCES
       UnitTestMainInit.cpp
       ${Cuda_SOURCES2}
     )
 
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_Cuda3
+    CoreUnitTest_Cuda3
     SOURCES
       UnitTestMainInit.cpp
       cuda/TestCuda_Task.cpp
@@ -687,7 +656,7 @@ if(Kokkos_ENABLE_CUDA)
     )
 
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_CudaTimingBased
+    CoreUnitTest_CudaTimingBased
     SOURCES
       UnitTestMainInit.cpp
       cuda/TestCuda_DebugSerialExecution.cpp
@@ -695,19 +664,19 @@ if(Kokkos_ENABLE_CUDA)
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_CudaInterOpInit
+    CoreUnitTest_CudaInterOpInit
     SOURCES
       UnitTestMain.cpp
       cuda/TestCuda_InterOp_Init.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_CudaInterOpStreams
+    CoreUnitTest_CudaInterOpStreams
     SOURCES
       UnitTestMain.cpp
       cuda/TestCuda_InterOp_Streams.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_CudaGraph
+    CoreUnitTest_CudaGraph
     SOURCES
       UnitTestMainInit.cpp
       cuda/TestCuda_Graph.cpp
@@ -716,7 +685,7 @@ endif()
 
 if(Kokkos_ENABLE_HIP)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_HIP
+    CoreUnitTest_HIP
     SOURCES
       UnitTestMainInit.cpp
       ${HIP_SOURCES}
@@ -728,73 +697,74 @@ if(Kokkos_ENABLE_HIP)
       hip/TestHIP_BlocksizeDeduction.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_HIPInterOpInit
+    CoreUnitTest_HIPInterOpInit
     SOURCES
       UnitTestMain.cpp
       hip/TestHIP_InterOp_Init.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_HIPInterOpStreams
+    CoreUnitTest_HIPInterOpStreams
     SOURCES
       UnitTestMain.cpp
       hip/TestHIP_InterOp_Streams.cpp
   )
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_HIPGraph
+    SOURCES
+      UnitTestMainInit.cpp
+      hip/TestHIP_Graph.cpp
+  )
 endif()
 
 if(Kokkos_ENABLE_SYCL)
-  list(REMOVE_ITEM SYCL_SOURCES1A
-       # FIXME_SYCL atomic_fetch_oper for large types to be implemented
-       ${CMAKE_CURRENT_BINARY_DIR}/sycl/TestSYCL_AtomicOperations_complexdouble.cpp
-  )
-
   list(REMOVE_ITEM SYCL_SOURCES2A
        ${CMAKE_CURRENT_BINARY_DIR}/sycl/TestSYCL_WorkGraph.cpp
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL1A
+    CoreUnitTest_SYCL1A
     SOURCES
       UnitTestMainInit.cpp
       ${SYCL_SOURCES1A}
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL1B
+    CoreUnitTest_SYCL1B
     SOURCES
       UnitTestMainInit.cpp
       ${SYCL_SOURCES1B}
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL2A
+    CoreUnitTest_SYCL2A
     SOURCES
       UnitTestMainInit.cpp
       ${SYCL_SOURCES2A}
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL2B
+    CoreUnitTest_SYCL2B
     SOURCES
       UnitTestMainInit.cpp
       ${SYCL_SOURCES2B}
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL2C
+    CoreUnitTest_SYCL2C
     SOURCES
       UnitTestMainInit.cpp
       ${SYCL_SOURCES2C}
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL2D
+    CoreUnitTest_SYCL2D
     SOURCES
       UnitTestMainInit.cpp
       ${SYCL_SOURCES2D}
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCL3
+    CoreUnitTest_SYCL3
     SOURCES
       UnitTestMainInit.cpp
       # FIXME_SYCL
@@ -805,19 +775,19 @@ if(Kokkos_ENABLE_SYCL)
   )
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCLInterOpInit
+    CoreUnitTest_SYCLInterOpInit
     SOURCES
       UnitTestMain.cpp
       sycl/TestSYCL_InterOp_Init.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCLInterOpInit_Context
+    CoreUnitTest_SYCLInterOpInit_Context
     SOURCES
     UnitTestMainInit.cpp
       sycl/TestSYCL_InterOp_Init_Context.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_SYCLInterOpStreams
+    CoreUnitTest_SYCLInterOpStreams
     SOURCES
       UnitTestMain.cpp
      sycl/TestSYCL_InterOp_Streams.cpp
@@ -830,6 +800,7 @@ SET(DEFAULT_DEVICE_SOURCES
   TestParseCmdLineArgsAndEnvVars.cpp
   TestSharedSpace.cpp
   TestSharedHostPinnedSpace.cpp
+  TestCompilerMacros.cpp
   default/TestDefaultDeviceType.cpp
   default/TestDefaultDeviceType_a1.cpp
   default/TestDefaultDeviceType_b1.cpp
@@ -865,19 +836,19 @@ if ((KOKKOS_ENABLE_OPENMPTARGET OR KOKKOS_ENABLE_OPENACC) AND KOKKOS_CXX_COMPILE
 endif()
 
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_Default
+  CoreUnitTest_Default
   SOURCES ${DEFAULT_DEVICE_SOURCES}
 )
 
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_LegionInitialization
+  CoreUnitTest_LegionInitialization
   SOURCES
     UnitTestMain.cpp
     TestLegionInitialization.cpp
 )
 
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_PushFinalizeHook
+  CoreUnitTest_PushFinalizeHook
   SOURCES
     UnitTest_PushFinalizeHook.cpp
 )
@@ -885,7 +856,7 @@ KOKKOS_ADD_EXECUTABLE_AND_TEST(
 # This test is intended for development and debugging by putting code
 # into TestDefaultDeviceDevelop.cpp. By default its empty.
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_Develop
+  CoreUnitTest_Develop
   SOURCES
     UnitTestMainInit.cpp
     default/TestDefaultDeviceDevelop.cpp
@@ -900,7 +871,7 @@ KOKKOS_ADD_TEST_EXECUTABLE( push_finalize_hook_terminate
   SOURCES UnitTest_PushFinalizeHook_terminate.cpp
 )
 
-KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
+KOKKOS_ADD_ADVANCED_TEST( CoreUnitTest_PushFinalizeHook_terminate
   TEST_0
     EXEC push_finalize_hook_terminate
     NUM_MPI_PROCS 1
@@ -910,24 +881,24 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
 )
   if(KOKKOS_ENABLE_TUNING)
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_TuningBuiltins
+      CoreUnitTest_TuningBuiltins
       SOURCES
       tools/TestBuiltinTuners.cpp
     )
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_TuningBasics
+      CoreUnitTest_TuningBasics
       SOURCES
         tools/TestTuning.cpp
     )
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_CategoricalTuner
+      CoreUnitTest_CategoricalTuner
       SOURCES
       tools/TestCategoricalTuner.cpp
     )
   endif()
   if((NOT Kokkos_ENABLE_OPENMPTARGET) AND (NOT Kokkos_ENABLE_OPENACC))
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_LogicalSpaces
+    CoreUnitTest_LogicalSpaces
     SOURCES
       tools/TestLogicalSpaces.cpp
   )
@@ -937,6 +908,7 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
     tools/TestEventCorrectness.cpp
     tools/TestWithoutInitializing.cpp
     tools/TestProfilingSection.cpp
+    tools/TestScopedRegion.cpp
     )
 
   # FIXME_OPENMPTARGET This test causes internal compiler errors as of 09/01/22
@@ -946,18 +918,18 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
   endif()
 
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_KokkosP
+    CoreUnitTest_KokkosP
     SOURCES
     ${KOKKOSP_SOURCES}
   )
   if(KOKKOS_ENABLE_LIBDL)
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
-      UnitTest_ToolIndependence
+      CoreUnitTest_ToolIndependence
       SOURCES
       tools/TestIndependence.cpp
     )
     TARGET_COMPILE_DEFINITIONS(
-      KokkosCore_UnitTest_ToolIndependence PUBLIC
+      Kokkos_CoreUnitTest_ToolIndependence PUBLIC
       KOKKOS_TOOLS_INDEPENDENT_BUILD
     )
     KOKKOS_ADD_TEST_LIBRARY(
@@ -974,6 +946,12 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
       tools/TestAllCalls.cpp
     )
 
+    KOKKOS_ADD_TEST_EXECUTABLE(
+      ToolsInitialization
+      UnitTestMain.cpp
+      tools/TestToolsInitialization.cpp
+    )
+
     set(ADDRESS_REGEX "0x[0-9a-f]*")
     set(MEMSPACE_REGEX "[HC][ou][sd][ta][a-zA-Z]*")
     set(SIZE_REGEX "[0-9]*")
@@ -987,7 +965,7 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
       TOOL kokkosprinter-tool
       ARGS --kokkos-tools-help
       PASS_REGULAR_EXPRESSION
-        "kokkosp_init_library::kokkosp_print_help:KokkosCore_ProfilingAllCalls::kokkosp_finalize_library::")
+        "kokkosp_init_library::kokkosp_print_help:Kokkos_ProfilingAllCalls::kokkosp_finalize_library::")
 
     # check help works via direct library specification
     KOKKOS_ADD_TEST(
@@ -997,7 +975,7 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
       ARGS --kokkos-tools-help
            --kokkos-tools-libs=$<TARGET_FILE:kokkosprinter-tool>
       PASS_REGULAR_EXPRESSION
-        "kokkosp_init_library::kokkosp_print_help:KokkosCore_ProfilingAllCalls::kokkosp_finalize_library::")
+        "kokkosp_init_library::kokkosp_print_help:Kokkos_ProfilingAllCalls::kokkosp_finalize_library::")
 
     KOKKOS_ADD_TEST(
       SKIP_TRIBITS
@@ -1005,7 +983,7 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
       EXE  ProfilingAllCalls
       TOOL kokkosprinter-tool
       ARGS --kokkos-tools-args="-c test delimit"
-      PASS_REGULAR_EXPRESSION "kokkosp_init_library::kokkosp_parse_args:4:KokkosCore_ProfilingAllCalls:-c:test:delimit::.*::kokkosp_allocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]source] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_allocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]destination] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_begin_deep_copy:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::.*kokkosp_end_deep_copy::kokkosp_begin_parallel_for:parallel_for:${SIZE_REGEX}:0::kokkosp_end_parallel_for:0::kokkosp_begin_parallel_reduce:parallel_reduce:${SIZE_REGEX}:1${SKIP_SCRATCH_INITIALIZATION_REGEX}::kokkosp_end_parallel_reduce:1::kokkosp_begin_parallel_scan:parallel_scan:${SIZE_REGEX}:2::kokkosp_end_parallel_scan:2::kokkosp_push_profile_region:push_region::kokkosp_pop_profile_region::kokkosp_create_profile_section:created_section:3::kokkosp_start_profile_section:3::kokkosp_stop_profile_section:3::kokkosp_destroy_profile_section:3::kokkosp_profile_event:profiling_event::kokkosp_declare_metadata:dogs:good::kokkosp_deallocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_deallocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_finalize_library::"
+      PASS_REGULAR_EXPRESSION "kokkosp_init_library::kokkosp_parse_args:4:Kokkos_ProfilingAllCalls:-c:test:delimit::.*::kokkosp_allocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]source] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_allocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]destination] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_begin_deep_copy:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::.*kokkosp_end_deep_copy::kokkosp_begin_parallel_for:parallel_for:${SIZE_REGEX}:0::kokkosp_end_parallel_for:0::kokkosp_begin_parallel_reduce:parallel_reduce:${SIZE_REGEX}:1${SKIP_SCRATCH_INITIALIZATION_REGEX}::kokkosp_end_parallel_reduce:1::kokkosp_begin_parallel_scan:parallel_scan:${SIZE_REGEX}:2::kokkosp_end_parallel_scan:2::kokkosp_push_profile_region:push_region::kokkosp_pop_profile_region::kokkosp_create_profile_section:created_section:3::kokkosp_start_profile_section:3::kokkosp_stop_profile_section:3::kokkosp_destroy_profile_section:3::kokkosp_profile_event:profiling_event::kokkosp_declare_metadata:dogs:good::kokkosp_deallocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_deallocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_finalize_library::"
     )
 
     # Above will test that leading/trailing quotes are stripped bc ctest cmd args is:
@@ -1022,7 +1000,7 @@ KOKKOS_ADD_ADVANCED_TEST( UnitTest_PushFinalizeHook_terminate
       EXE  ProfilingAllCalls
       ARGS [=[--kokkos-tools-args=-c test delimit]=]
             --kokkos-tools-libs=$<TARGET_FILE:kokkosprinter-tool>
-      PASS_REGULAR_EXPRESSION "kokkosp_init_library::kokkosp_parse_args:4:KokkosCore_ProfilingAllCalls:-c:test:delimit::.*::kokkosp_allocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]source] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_allocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]destination] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_begin_deep_copy:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::.*kokkosp_end_deep_copy::kokkosp_begin_parallel_for:parallel_for:${SIZE_REGEX}:0::kokkosp_end_parallel_for:0::kokkosp_begin_parallel_reduce:parallel_reduce:${SIZE_REGEX}:1${SKIP_SCRATCH_INITIALIZATION_REGEX}::kokkosp_end_parallel_reduce:1::kokkosp_begin_parallel_scan:parallel_scan:${SIZE_REGEX}:2::kokkosp_end_parallel_scan:2::kokkosp_push_profile_region:push_region::kokkosp_pop_profile_region::kokkosp_create_profile_section:created_section:3::kokkosp_start_profile_section:3::kokkosp_stop_profile_section:3::kokkosp_destroy_profile_section:3::kokkosp_profile_event:profiling_event::kokkosp_declare_metadata:dogs:good::kokkosp_deallocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_deallocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_finalize_library::"
+      PASS_REGULAR_EXPRESSION "kokkosp_init_library::kokkosp_parse_args:4:Kokkos_ProfilingAllCalls:-c:test:delimit::.*::kokkosp_allocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]source] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_allocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_begin_parallel_for:Kokkos::View::initialization [[]destination] via memset:[0-9]+:0::kokkosp_end_parallel_for:0::kokkosp_begin_deep_copy:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::.*kokkosp_end_deep_copy::kokkosp_begin_parallel_for:parallel_for:${SIZE_REGEX}:0::kokkosp_end_parallel_for:0::kokkosp_begin_parallel_reduce:parallel_reduce:${SIZE_REGEX}:1${SKIP_SCRATCH_INITIALIZATION_REGEX}::kokkosp_end_parallel_reduce:1::kokkosp_begin_parallel_scan:parallel_scan:${SIZE_REGEX}:2::kokkosp_end_parallel_scan:2::kokkosp_push_profile_region:push_region::kokkosp_pop_profile_region::kokkosp_create_profile_section:created_section:3::kokkosp_start_profile_section:3::kokkosp_stop_profile_section:3::kokkosp_destroy_profile_section:3::kokkosp_profile_event:profiling_event::kokkosp_declare_metadata:dogs:good::kokkosp_deallocate_data:${MEMSPACE_REGEX}:destination:${ADDRESS_REGEX}:40::kokkosp_deallocate_data:${MEMSPACE_REGEX}:source:${ADDRESS_REGEX}:40::kokkosp_finalize_library::"
     )
   endif() #KOKKOS_ENABLE_LIBDL
 if(NOT KOKKOS_HAS_TRILINOS)
@@ -1040,7 +1018,7 @@ KOKKOS_ADD_TEST_EXECUTABLE(
 # to work correctly with shared libraries
 KOKKOS_SET_EXE_PROPERTY(StackTraceTestExec ENABLE_EXPORTS ON)
 
-KOKKOS_ADD_TEST( NAME UnitTest_StackTraceTest
+KOKKOS_ADD_TEST( NAME CoreUnitTest_StackTraceTest
                  EXE  StackTraceTestExec
                  FAIL_REGULAR_EXPRESSION "FAILED"
                )
@@ -1049,7 +1027,7 @@ endif()
 if(Kokkos_ENABLE_DEPRECATED_CODE_3)
   foreach(INITTESTS_NUM RANGE 1 18)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    UnitTest_DefaultInit_${INITTESTS_NUM}
+    CoreUnitTest_DefaultInit_${INITTESTS_NUM}
     SOURCES UnitTestMain.cpp default/TestDefaultDeviceTypeInit_${INITTESTS_NUM}.cpp
   )
   endforeach(INITTESTS_NUM)
@@ -1057,7 +1035,7 @@ endif()
 
 if (KOKKOS_ENABLE_HWLOC)
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_HWLOC
+  CoreUnitTest_HWLOC
   SOURCES UnitTestMain.cpp  TestHWLOC.cpp
 )
 endif()
@@ -1113,34 +1091,35 @@ FOREACH (DEVICE ${KOKKOS_ENABLED_DEVICES})
 ENDFOREACH()
 
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_CTestDevice
+  CoreUnitTest_CTestDevice
   SOURCES UnitTestMain.cpp  TestCTestDevice.cpp
 )
 
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_CMakePassCmdLineArgs
+  CoreUnitTest_CMakePassCmdLineArgs
   SOURCES UnitTest_CMakePassCmdLineArgs.cpp
   ARGS "one 2 THREE"
 )
 
 # This test is not properly set up to run within Trilinos
 if (NOT KOKKOS_HAS_TRILINOS)
-  add_executable(KokkosCore_UnitTest_DeviceAndThreads UnitTest_DeviceAndThreads.cpp)
-  target_link_libraries(KokkosCore_UnitTest_DeviceAndThreads Kokkos::kokkoscore)
+  SET_SOURCE_FILES_PROPERTIES(UnitTest_DeviceAndThreads.cpp PROPERTIES LANGUAGE ${KOKKOS_COMPILE_LANGUAGE})
+  add_executable(Kokkos_CoreUnitTest_DeviceAndThreads UnitTest_DeviceAndThreads.cpp)
+  target_link_libraries(Kokkos_CoreUnitTest_DeviceAndThreads Kokkos::kokkoscore)
   find_package(Python3 COMPONENTS Interpreter)
   if(Python3_Interpreter_FOUND AND Python3_VERSION VERSION_GREATER_EQUAL 3.7)
     if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.20)
       set(USE_SOURCE_PERMISSIONS_WHEN_SUPPORTED USE_SOURCE_PERMISSIONS)
     endif()
     file(GENERATE
-      OUTPUT $<TARGET_FILE_DIR:KokkosCore_UnitTest_DeviceAndThreads>/TestDeviceAndThreads.py
+      OUTPUT $<TARGET_FILE_DIR:Kokkos_CoreUnitTest_DeviceAndThreads>/TestDeviceAndThreads.py
       INPUT TestDeviceAndThreads.py
       ${USE_SOURCE_PERMISSIONS_WHEN_SUPPORTED}
     )
     if(NOT Kokkos_ENABLE_OPENMPTARGET)  # FIXME_OPENMPTARGET does not select the right device
       add_test(
-        NAME KokkosCore_UnitTest_DeviceAndThreads
-        COMMAND ${Python3_EXECUTABLE} -m unittest -v $<TARGET_FILE_DIR:KokkosCore_UnitTest_DeviceAndThreads>/TestDeviceAndThreads.py
+        NAME Kokkos_CoreUnitTest_DeviceAndThreads
+        COMMAND ${Python3_EXECUTABLE} -m unittest -v $<TARGET_FILE_DIR:Kokkos_CoreUnitTest_DeviceAndThreads>/TestDeviceAndThreads.py
       )
     endif()
   endif()
diff --git a/core/unit_test/Makefile b/core/unit_test/Makefile
index 05be225265..33a84b61f9 100644
--- a/core/unit_test/Makefile
+++ b/core/unit_test/Makefile
@@ -52,8 +52,8 @@ ifneq ($(KOKKOS_INTERNAL_USE_RDYNAMIC), 1)
    KOKKOS_INTERNAL_USE_RDYNAMIC := $(call kokkos_has_string,$(CXXFLAGS),rdynamic)
 endif
 
-ifeq ($(KOKKOS_INTERNAL_USE_RDYNAMIC),1) 
-   ifneq ($(KOKKOS_INTERNAL_HAS_OPTIMIZATIONS),1) 
+ifeq ($(KOKKOS_INTERNAL_USE_RDYNAMIC),1)
+   ifneq ($(KOKKOS_INTERNAL_HAS_OPTIMIZATIONS),1)
       STACK_TRACE_TERMINATE_FILTER :=_dynamic
    else
       STACK_TRACE_TERMINATE_FILTER :=
@@ -62,7 +62,7 @@ else
    STACK_TRACE_TERMINATE_FILTER :=
 endif
 
-TESTS = AtomicOperations_int AtomicOperations_unsignedint AtomicOperations_longint AtomicOperations_unsignedlongint AtomicOperations_longlongint AtomicOperations_double AtomicOperations_float AtomicOperations_complexdouble AtomicOperations_complexfloat AtomicViews Atomics BlockSizeDeduction Concepts Complex Crs DeepCopyAlignment FunctorAnalysis Init LocalDeepCopy MDRange_a MDRange_b MDRange_c MDRange_d MDRange_e MDRange_f Other RangePolicy RangePolicyRequire Reductions Reducers_a Reducers_b Reducers_c Reducers_d Reducers_e Reductions_DeviceView Scan SharedAlloc TeamBasic TeamReductionScan TeamScratch TeamTeamSize TeamVectorRange UniqueToken ViewAPI_a ViewAPI_b ViewAPI_c ViewAPI_d ViewAPI_e ViewCopy_a ViewCopy_b ViewLayoutStrideAssignment ViewMapping_a ViewMapping_b ViewMapping_subview ViewOfClass WorkGraph View_64bit ViewResize
+TESTS = AtomicOperations_int AtomicOperations_unsignedint AtomicOperations_longint AtomicOperations_unsignedlongint AtomicOperations_longlongint AtomicOperations_double AtomicOperations_float AtomicOperations_complexdouble AtomicOperations_complexfloat AtomicViews Atomics BlockSizeDeduction Concepts Complex Crs DeepCopyAlignment FunctorAnalysis Init LocalDeepCopy MDRange_a MDRange_b MDRange_c MDRange_d MDRange_e MDRange_f Other ParallelScanRangePolicy RangePolicy RangePolicyRequire Reductions Reducers_a Reducers_b Reducers_c Reducers_d Reducers_e Reductions_DeviceView SharedAlloc TeamBasic TeamReductionScan TeamScratch TeamTeamSize TeamVectorRange UniqueToken ViewAPI_a ViewAPI_b ViewAPI_c ViewAPI_d ViewAPI_e ViewCopy_a ViewCopy_b ViewLayoutStrideAssignment ViewMapping_a ViewMapping_b ViewMapping_subview ViewOfClass WorkGraph View_64bit ViewResize
 
 tmp := $(foreach device, $(KOKKOS_DEVICELIST), \
   tmp2 := $(foreach test, $(TESTS), \
@@ -127,7 +127,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     OBJ_CUDA += TestCuda_SubView_c07.o TestCuda_SubView_c08.o TestCuda_SubView_c09.o
     OBJ_CUDA += TestCuda_SubView_c10.o TestCuda_SubView_c11.o TestCuda_SubView_c12.o
     OBJ_CUDA += TestCuda_SubView_c13.o
-    OBJ_CUDA += TestCuda_Reductions.o TestCuda_Scan.o
+    OBJ_CUDA += TestCuda_Reductions.o TestCuda_ParallelScanRangePolicy.o
     OBJ_CUDA += TestCuda_Reductions_DeviceView.o
     OBJ_CUDA += TestCuda_Reducers_a.o TestCuda_Reducers_b.o TestCuda_Reducers_c.o TestCuda_Reducers_d.o TestCuda_Reducers_e.o
     OBJ_CUDA += TestCuda_Complex.o
@@ -171,7 +171,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
     OBJ_THREADS += TestThreads_SubView_c04.o TestThreads_SubView_c05.o TestThreads_SubView_c06.o
     OBJ_THREADS += TestThreads_SubView_c07.o TestThreads_SubView_c08.o TestThreads_SubView_c09.o
     OBJ_THREADS += TestThreads_SubView_c10.o TestThreads_SubView_c11.o TestThreads_SubView_c12.o
-    OBJ_THREADS += TestThreads_Reductions.o TestThreads_Scan.o
+    OBJ_THREADS += TestThreads_Reductions.o TestThreads_ParallelScanRangePolicy.o
     OBJ_THREADS += TestThreads_Reductions_DeviceView.o
     OBJ_THREADS += TestThreads_Reducers_a.o TestThreads_Reducers_b.o TestThreads_Reducers_c.o TestThreads_Reducers_d.o TestThreads_Reducers_e.o
     OBJ_THREADS += TestThreads_Complex.o
@@ -207,7 +207,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
     OBJ_OPENMP += TestOpenMP_SubView_c07.o TestOpenMP_SubView_c08.o TestOpenMP_SubView_c09.o
     OBJ_OPENMP += TestOpenMP_SubView_c10.o TestOpenMP_SubView_c11.o TestOpenMP_SubView_c12.o
     OBJ_OPENMP += TestOpenMP_SubView_c13.o
-    OBJ_OPENMP += TestOpenMP_Reductions.o TestOpenMP_Scan.o
+    OBJ_OPENMP += TestOpenMP_Reductions.o TestOpenMP_ParallelScanRangePolicy.o
     OBJ_OPENMP += TestOpenMP_Reductions_DeviceView.o
     OBJ_OPENMP += TestOpenMP_Reducers_a.o TestOpenMP_Reducers_b.o TestOpenMP_Reducers_c.o TestOpenMP_Reducers_d.o TestOpenMP_Reducers_e.o
     OBJ_OPENMP += TestOpenMP_Complex.o
@@ -251,11 +251,11 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
     #OBJ_OPENMPTARGET += TestOpenMPTarget_SubView_c10.o TestOpenMPTarget_SubView_c11.o TestOpenMPTarget_SubView_c12.o
     #OBJ_OPENMPTARGET += TestOpenMPTarget_Reductions.o # Need custom reductions
     OBJ_OPENMPTARGET += TestOpenMPTarget_Reducers_a.o TestOpenMPTarget_Reducers_b.o TestOpenMPTarget_Reducers_c.o TestOpenMPTarget_Reducers_d.o TestOpenMPTarget_Reducers_e.o
-    #OBJ_OPENMPTARGET += TestOpenMPTarget_Scan.o
+    OBJ_OPENMPTARGET += TestOpenMPTarget_ParallelScanRangePolicy.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_Complex.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_AtomicOperations_int.o TestOpenMPTarget_AtomicOperations_unsignedint.o TestOpenMPTarget_AtomicOperations_longint.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_AtomicOperations_unsignedlongint.o TestOpenMPTarget_AtomicOperations_longlongint.o TestOpenMPTarget_AtomicOperations_double.o TestOpenMPTarget_AtomicOperations_float.o
-    #OBJ_OPENMPTARGET += TestOpenMPTarget_AtomicOperations_complexfloat.o 
+    #OBJ_OPENMPTARGET += TestOpenMPTarget_AtomicOperations_complexfloat.o
     #OBJ_OPENMPTARGET += TestOpenMPTarget_AtomicOperations_complexdouble.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_AtomicViews.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_Atomics.o # Commented Out Arbitrary Type Atomics
@@ -290,6 +290,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
 	OBJ_HIP += TestHIP_MDRange_a.o TestHIP_MDRange_b.o TestHIP_MDRange_c.o TestHIP_MDRange_d.o TestHIP_MDRange_e.o
 	OBJ_HIP += TestHIP_Spaces.o
 	OBJ_HIP += TestHIP_Memory_Requirements.o
+        OBJ_HIP += TestHIP_ParallelScanRangePolicy.o
 	OBJ_HIP += TestHIPHostPinned_ViewAPI_a.o TestHIPHostPinned_ViewAPI_b.o TestHIPHostPinned_ViewAPI_c.o TestHIPHostPinned_ViewAPI_d.o TestHIPHostPinned_ViewAPI_e.o
 	OBJ_HIP += TestHIPHostPinned_ViewCopy_a.o TestHIPHostPinned_ViewCopy_b.o
 	OBJ_HIP += TestHIPHostPinned_ViewMapping_a.o TestHIPHostPinned_ViewMapping_b.o TestHIPHostPinned_ViewMapping_subview.o
@@ -316,7 +317,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
 	OBJ_HPX += TestHPX_SubView_c10.o TestHPX_SubView_c11.o TestHPX_SubView_c12.o
 	OBJ_HPX += TestHPX_SubView_c13.o
 	OBJ_HPX += TestHPX_Reductions.o
-	OBJ_HPX += TestHPX_Scan.o
+	OBJ_HPX += TestHPX_ParallelScanRangePolicy.o
 	OBJ_HPX += TestHPX_Reducers_a.o TestHPX_Reducers_b.o TestHPX_Reducers_c.o TestHPX_Reducers_d.o TestHPX_Reducers_e.o
 	OBJ_HPX += TestHPX_Complex.o
 	OBJ_HPX += TestHPX_AtomicOperations_int.o TestHPX_AtomicOperations_unsignedint.o TestHPX_AtomicOperations_longint.o
@@ -355,7 +356,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
     OBJ_SERIAL += TestSerial_SubView_c07.o TestSerial_SubView_c08.o TestSerial_SubView_c09.o
     OBJ_SERIAL += TestSerial_SubView_c10.o TestSerial_SubView_c11.o TestSerial_SubView_c12.o
     OBJ_SERIAL += TestSerial_SubView_c13.o
-    OBJ_SERIAL += TestSerial_Reductions.o TestSerial_Scan.o
+    OBJ_SERIAL += TestSerial_Reductions.o TestSerial_ParallelScanRangePolicy.o
     OBJ_SERIAL += TestSerial_Reductions_DeviceView.o
     OBJ_SERIAL += TestSerial_Reducers_a.o TestSerial_Reducers_b.o TestSerial_Reducers_c.o TestSerial_Reducers_d.o TestSerial_Reducers_e.o
     OBJ_SERIAL += TestSerial_Complex.o
diff --git a/core/unit_test/TestAggregate.hpp b/core/unit_test/TestAggregate.hpp
index 23cc5860ac..4f67b2eddc 100644
--- a/core/unit_test/TestAggregate.hpp
+++ b/core/unit_test/TestAggregate.hpp
@@ -56,8 +56,8 @@ void TestViewAggregate() {
                 "");
   static_assert(std::is_same<typename a32_type::pointer_type, double *>::value,
                 "");
-  static_assert(a32_type::Rank == 2, "");
-  static_assert(a32_flat_type::Rank == 3, "");
+  static_assert(a32_type::rank == 2, "");
+  static_assert(a32_flat_type::rank == 3, "");
 
   a32_type x("test", 4, 5);
   a32_flat_type y(x);
diff --git a/core/unit_test/TestAtomicOperations.hpp b/core/unit_test/TestAtomicOperations.hpp
index b8940378bd..9965041e52 100644
--- a/core/unit_test/TestAtomicOperations.hpp
+++ b/core/unit_test/TestAtomicOperations.hpp
@@ -56,7 +56,6 @@ struct InitFunctor {
 //---------------------------------------------------
 //--------------atomic_load/store/assign---------------------
 //---------------------------------------------------
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
 template <class T, class DEVICE_TYPE>
 struct LoadStoreFunctor {
   using execution_space = DEVICE_TYPE;
@@ -76,7 +75,6 @@ struct LoadStoreFunctor {
   }
   LoadStoreFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
 };
-#endif
 
 template <class T, class DeviceType>
 bool LoadStoreAtomicTest(T i0, T i1) {
@@ -89,14 +87,10 @@ bool LoadStoreAtomicTest(T i0, T i1) {
   Kokkos::parallel_for(1, f_init);
   execution_space().fence();
 
-#ifdef KOKKOS_ENABLE_DESUL_ATOMICS
   struct LoadStoreFunctor<T, execution_space> f(i0, i1);
 
   f.data = data;
   Kokkos::parallel_for(1, f);
-#else
-  h_data() = i1;
-#endif
 
   Kokkos::deep_copy(h_data, data);
 
@@ -332,10 +326,8 @@ struct WrappingIncFunctor {
 
   KOKKOS_INLINE_FUNCTION
   void operator()(int) const {
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
     desul::atomic_fetch_inc_mod(&data(), (T)i1, desul::MemoryOrderRelaxed(),
                                 desul::MemoryScopeDevice());
-#endif
   }
 
   WrappingIncFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
@@ -480,10 +472,8 @@ struct WrappingDecFunctor {
 
   KOKKOS_INLINE_FUNCTION
   void operator()(int) const {
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
     desul::atomic_fetch_dec_mod(&data(), (T)i1, desul::MemoryOrderRelaxed(),
                                 desul::MemoryScopeDevice());
-#endif
   }
 
   WrappingDecFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
diff --git a/core/unit_test/TestAtomicOperations_complexdouble.hpp b/core/unit_test/TestAtomicOperations_complexdouble.hpp
index 9f55aa947b..852fade58b 100644
--- a/core/unit_test/TestAtomicOperations_complexdouble.hpp
+++ b/core/unit_test/TestAtomicOperations_complexdouble.hpp
@@ -18,6 +18,11 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_complexdouble) {
+#if defined(KOKKOS_ENABLE_SYCL) && \
+    !defined(KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+    GTEST_SKIP() << "skipping since device_global variables are not available";
+#endif
   const int start = 1;  // Avoid zero for division.
   const int end   = 11;
   for (int i = start; i < end; ++i) {
diff --git a/core/unit_test/TestAtomicOperations_unsignedint.hpp b/core/unit_test/TestAtomicOperations_unsignedint.hpp
index 31b2693d64..f844c9062d 100644
--- a/core/unit_test/TestAtomicOperations_unsignedint.hpp
+++ b/core/unit_test/TestAtomicOperations_unsignedint.hpp
@@ -45,14 +45,12 @@ TEST(TEST_CATEGORY, atomic_operations_unsigned) {
                  unsigned int, TEST_EXECSPACE>(start, end - i, 12)));
     ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
                  unsigned int, TEST_EXECSPACE>(start, end - i, 13)));
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
     ASSERT_TRUE(
         (TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
             unsigned int, TEST_EXECSPACE>(start, end - i, 1)));  // Wrapping Inc
     ASSERT_TRUE(
         (TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
             unsigned int, TEST_EXECSPACE>(start, end - i, 2)));  // Wrapping Dec
-#endif
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_unsignedlongint.hpp b/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
index 98c2d28b20..8b6ca64e99 100644
--- a/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
+++ b/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
@@ -45,14 +45,12 @@ TEST(TEST_CATEGORY, atomic_operations_unsignedlong) {
                  unsigned long int, TEST_EXECSPACE>(start, end - i, 12)));
     ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
                  unsigned long int, TEST_EXECSPACE>(start, end - i, 13)));
-#ifdef KOKKOS_ENABLE_IMPL_DESUL_ATOMICS
     ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
                  unsigned long int, TEST_EXECSPACE>(start, end - i,
                                                     1)));  // Wrapping Inc
     ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
                  unsigned long int, TEST_EXECSPACE>(start, end - i,
                                                     2)));  // Wrapping Dec
-#endif
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomics.hpp b/core/unit_test/TestAtomics.hpp
index e5866bb89b..fd3b8facfc 100644
--- a/core/unit_test/TestAtomics.hpp
+++ b/core/unit_test/TestAtomics.hpp
@@ -510,8 +510,12 @@ TEST(TEST_CATEGORY, atomics) {
   ASSERT_TRUE(
       (TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(100, 3)));
 
-// FIXME_SYCL atomics for large types to be implemented
-#ifndef KOKKOS_ENABLE_SYCL
+// FIXME_SYCL Replace macro by SYCL_EXT_ONEAPI_DEVICE_GLOBAL or remove
+// condition alltogether when possible.
+#if defined(KOKKOS_ENABLE_SYCL) && \
+    !defined(KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>) return;
+#endif
   ASSERT_TRUE(
       (TestAtomic::Loop<Kokkos::complex<double>, TEST_EXECSPACE>(1, 1)));
   ASSERT_TRUE(
@@ -536,7 +540,53 @@ TEST(TEST_CATEGORY, atomics) {
       (TestAtomic::Loop<TestAtomic::SuperScalar<4>, TEST_EXECSPACE>(100, 3)));
 #endif
 #endif
+}
+
+// see https://github.com/trilinos/Trilinos/pull/11506
+struct TpetraUseCase {
+  template <class Scalar>
+  struct AbsMaxHelper {
+    Scalar value;
+
+    KOKKOS_FUNCTION AbsMaxHelper& operator+=(AbsMaxHelper const& rhs) {
+      Scalar lhs_abs_value = Kokkos::abs(value);
+      Scalar rhs_abs_value = Kokkos::abs(rhs.value);
+      value = lhs_abs_value > rhs_abs_value ? lhs_abs_value : rhs_abs_value;
+      return *this;
+    }
+
+    KOKKOS_FUNCTION AbsMaxHelper operator+(AbsMaxHelper const& rhs) const {
+      AbsMaxHelper ret = *this;
+      ret += rhs;
+      return ret;
+    }
+  };
+
+  using T = int;
+  Kokkos::View<T> d_{"lbl"};
+  KOKKOS_FUNCTION void operator()(int i) const {
+    // 0, -1, 2, -3, ...
+    auto v_i = static_cast<T>(i);
+    if (i % 2 == 1) v_i = -v_i;
+    Kokkos::atomic_add(reinterpret_cast<AbsMaxHelper<T>*>(&d_()),
+                       AbsMaxHelper<T>{v_i});
+  }
+
+  TpetraUseCase() { Kokkos::parallel_for(10, *this); }
+
+  void check() {
+    T v;
+    Kokkos::deep_copy(v, d_);
+    ASSERT_EQ(v, 9);
+  }
+};
+
+TEST(TEST_CATEGORY, atomics_tpetra_max_abs) {
+#ifdef KOKKOS_COMPILER_NVHPC
+  GTEST_SKIP() << "FIXME_NVHPC (?)";
 #endif
+
+  TpetraUseCase().check();
 }
 
 }  // namespace Test
diff --git a/core/unit_test/TestBitManipulation.cpp b/core/unit_test/TestBitManipulation.cpp
new file mode 100644
index 0000000000..dccabed3db
--- /dev/null
+++ b/core/unit_test/TestBitManipulation.cpp
@@ -0,0 +1,547 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_BitManipulation.hpp>
+
+struct X {
+  constexpr bool did_not_match() { return true; }
+};
+
+#define TEST_BIT_MANIPULATION(FUNC)                     \
+  constexpr X test_##FUNC(...) { return {}; }           \
+  static_assert(test_##FUNC((unsigned char)0));         \
+  static_assert(test_##FUNC((unsigned short)0));        \
+  static_assert(test_##FUNC((unsigned int)0));          \
+  static_assert(test_##FUNC((unsigned long)0));         \
+  static_assert(test_##FUNC((unsigned long long)0));    \
+  static_assert(test_##FUNC((bool)0).did_not_match());  \
+  static_assert(test_##FUNC((int)0).did_not_match());   \
+  static_assert(test_##FUNC((float)0).did_not_match()); \
+  static_assert(test_##FUNC((void *)0).did_not_match())
+
+//<editor-fold desc="[bit.rotate]">
+template <class UInt>
+constexpr auto test_rotl(UInt x) -> decltype(Kokkos::rotl(x, 0)) {
+  using Kokkos::rotl;
+
+  static_assert(noexcept(rotl(x, 0)));
+  static_assert(std::is_same_v<decltype(rotl(x, 0)), UInt>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(rotl(UInt(0), 0) == 0);
+  static_assert(rotl(UInt(0), 1) == 0);
+  static_assert(rotl(UInt(0), 4) == 0);
+  static_assert(rotl(UInt(0), 8) == 0);
+  static_assert(rotl(max, 0) == max);
+  static_assert(rotl(max, 1) == max);
+  static_assert(rotl(max, 4) == max);
+  static_assert(rotl(max, 8) == max);
+  static_assert(rotl(UInt(1), 0) == UInt(1) << 0);
+  static_assert(rotl(UInt(1), 1) == UInt(1) << 1);
+  static_assert(rotl(UInt(1), 4) == UInt(1) << 4);
+  static_assert(rotl(UInt(1), dig) == UInt(1));
+  static_assert(rotl(UInt(7), dig) == UInt(7));
+  static_assert(rotl(UInt(6), dig - 1) == UInt(3));
+  static_assert(rotl(UInt(3), 6) == UInt(3) << 6);
+
+  static_assert(rotl(UInt(max - 1), 0) == UInt(max - 1));
+  static_assert(rotl(UInt(max - 1), 1) == UInt(max - 2));
+  static_assert(rotl(UInt(max - 1), 2) == UInt(max - 4));
+  static_assert(rotl(UInt(max - 1), 3) == UInt(max - 8));
+  static_assert(rotl(UInt(max - 1), 4) == UInt(max - 16));
+  static_assert(rotl(UInt(max - 1), 5) == UInt(max - 32));
+  static_assert(rotl(UInt(max - 1), 6) == UInt(max - 64));
+  static_assert(rotl(UInt(max - 1), 7) == UInt(max - 128));
+  static_assert(rotl(UInt(1), 0) == UInt(1));
+  static_assert(rotl(UInt(1), 1) == UInt(2));
+  static_assert(rotl(UInt(1), 2) == UInt(4));
+  static_assert(rotl(UInt(1), 3) == UInt(8));
+  static_assert(rotl(UInt(1), 4) == UInt(16));
+  static_assert(rotl(UInt(1), 5) == UInt(32));
+  static_assert(rotl(UInt(1), 6) == UInt(64));
+  static_assert(rotl(UInt(1), 7) == UInt(128));
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(rotl);
+
+template <class UInt>
+constexpr auto test_rotr(UInt x) -> decltype(Kokkos::rotr(x, 0)) {
+  using Kokkos::rotr;
+
+  static_assert(noexcept(rotr(x, 0)));
+  static_assert(std::is_same_v<decltype(rotr(x, 0)), UInt>);
+
+  constexpr auto dig     = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max     = Kokkos::Experimental::finite_max_v<UInt>;
+  constexpr auto highbit = rotr(UInt(1), 1);
+
+  static_assert(rotr(UInt(0), 0) == 0);
+  static_assert(rotr(UInt(0), 1) == 0);
+  static_assert(rotr(UInt(0), 4) == 0);
+  static_assert(rotr(UInt(0), 8) == 0);
+  static_assert(rotr(max, 0) == max);
+  static_assert(rotr(max, 1) == max);
+  static_assert(rotr(max, 4) == max);
+  static_assert(rotr(max, 8) == max);
+  static_assert(rotr(UInt(128), 0) == UInt(128) >> 0);
+  static_assert(rotr(UInt(128), 1) == UInt(128) >> 1);
+  static_assert(rotr(UInt(128), 4) == UInt(128) >> 4);
+  static_assert(rotr(UInt(1), dig) == UInt(1));
+  static_assert(rotr(UInt(7), dig) == UInt(7));
+  static_assert(rotr(UInt(6), dig - 1) == UInt(12));
+  static_assert(rotr(UInt(36), dig - 2) == UInt(144));
+
+  static_assert(rotr(UInt(max - 1), 0) == UInt(max - 1));
+  static_assert(rotr(UInt(max - 1), 1) == UInt(max - highbit));
+  static_assert(rotr(UInt(max - 1), 2) == UInt(max - (highbit >> 1)));
+  static_assert(rotr(UInt(max - 1), 3) == UInt(max - (highbit >> 2)));
+  static_assert(rotr(UInt(max - 1), 4) == UInt(max - (highbit >> 3)));
+  static_assert(rotr(UInt(max - 1), 5) == UInt(max - (highbit >> 4)));
+  static_assert(rotr(UInt(max - 1), 6) == UInt(max - (highbit >> 5)));
+  static_assert(rotr(UInt(max - 1), 7) == UInt(max - (highbit >> 6)));
+  static_assert(rotr(UInt(128), 0) == UInt(128));
+  static_assert(rotr(UInt(128), 1) == UInt(64));
+  static_assert(rotr(UInt(128), 2) == UInt(32));
+  static_assert(rotr(UInt(128), 3) == UInt(16));
+  static_assert(rotr(UInt(128), 4) == UInt(8));
+  static_assert(rotr(UInt(128), 5) == UInt(4));
+  static_assert(rotr(UInt(128), 6) == UInt(2));
+  static_assert(rotr(UInt(128), 7) == UInt(1));
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(rotr);
+//</editor-fold>
+
+//<editor-fold desc="[bit.count]">
+template <class UInt>
+constexpr auto test_countl_zero(UInt x) -> decltype(Kokkos::countl_zero(x)) {
+  using Kokkos::countl_zero;
+
+  static_assert(noexcept(countl_zero(x)));
+  static_assert(std::is_same_v<decltype(countl_zero(x)), int>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(countl_zero(UInt(0)) == dig);
+  static_assert(countl_zero(UInt(1)) == dig - 1);
+  static_assert(countl_zero(UInt(2)) == dig - 2);
+  static_assert(countl_zero(UInt(3)) == dig - 2);
+  static_assert(countl_zero(UInt(4)) == dig - 3);
+  static_assert(countl_zero(UInt(5)) == dig - 3);
+  static_assert(countl_zero(UInt(6)) == dig - 3);
+  static_assert(countl_zero(UInt(7)) == dig - 3);
+  static_assert(countl_zero(UInt(8)) == dig - 4);
+  static_assert(countl_zero(UInt(9)) == dig - 4);
+  static_assert(countl_zero(UInt(127)) == dig - 7);
+  static_assert(countl_zero(UInt(128)) == dig - 8);
+  static_assert(countl_zero(max) == 0);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(countl_zero);
+
+template <class UInt>
+constexpr auto test_countl_one(UInt x) -> decltype(Kokkos::countl_one(x)) {
+  using Kokkos::countl_one;
+
+  static_assert(noexcept(countl_one(x)));
+  static_assert(std::is_same_v<decltype(countl_one(x)), int>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(countl_one(UInt(0)) == 0);
+  static_assert(countl_one(UInt(1)) == 0);
+  static_assert(countl_one(UInt(2)) == 0);
+  static_assert(countl_one(UInt(3)) == 0);
+  static_assert(countl_one(UInt(4)) == 0);
+  static_assert(countl_one(UInt(5)) == 0);
+  static_assert(countl_one(UInt(6)) == 0);
+  static_assert(countl_one(UInt(7)) == 0);
+  static_assert(countl_one(UInt(8)) == 0);
+  static_assert(countl_one(UInt(9)) == 0);
+  static_assert(countl_one(UInt(100)) == 0);
+  static_assert(countl_one(max) == dig);
+  static_assert(countl_one(UInt(max - 1)) == dig - 1);
+  static_assert(countl_one(UInt(max - 2)) == dig - 2);
+  static_assert(countl_one(UInt(max - 3)) == dig - 2);
+  static_assert(countl_one(UInt(max - 4)) == dig - 3);
+  static_assert(countl_one(UInt(max - 5)) == dig - 3);
+  static_assert(countl_one(UInt(max - 6)) == dig - 3);
+  static_assert(countl_one(UInt(max - 7)) == dig - 3);
+  static_assert(countl_one(UInt(max - 8)) == dig - 4);
+  static_assert(countl_one(UInt(max - 9)) == dig - 4);
+  static_assert(countl_one(UInt(max - 126)) == dig - 7);
+  static_assert(countl_one(UInt(max - 127)) == dig - 7);
+  static_assert(countl_one(UInt(max - 128)) == dig - 8);
+  static_assert(countl_one(UInt(UInt(1) << (dig - 1))) == 1);
+  static_assert(countl_one(UInt(UInt(3) << (dig - 2))) == 2);
+  static_assert(countl_one(UInt(UInt(7) << (dig - 3))) == 3);
+  static_assert(countl_one(UInt(UInt(255) << (dig - 8))) == 8);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(countl_one);
+
+template <class UInt>
+constexpr auto test_countr_zero(UInt x) -> decltype(Kokkos::countr_zero(x)) {
+  using Kokkos::countr_zero;
+
+  static_assert(noexcept(countr_zero(x)));
+  static_assert(std::is_same_v<decltype(countr_zero(x)), int>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(countr_zero(UInt(0)) == dig);
+  static_assert(countr_zero(UInt(1)) == 0);
+  static_assert(countr_zero(UInt(2)) == 1);
+  static_assert(countr_zero(UInt(3)) == 0);
+  static_assert(countr_zero(UInt(4)) == 2);
+  static_assert(countr_zero(UInt(5)) == 0);
+  static_assert(countr_zero(UInt(6)) == 1);
+  static_assert(countr_zero(UInt(7)) == 0);
+  static_assert(countr_zero(UInt(8)) == 3);
+  static_assert(countr_zero(UInt(9)) == 0);
+  static_assert(countr_zero(UInt(126)) == 1);
+  static_assert(countr_zero(UInt(127)) == 0);
+  static_assert(countr_zero(UInt(128)) == 7);
+  static_assert(countr_zero(UInt(129)) == 0);
+  static_assert(countr_zero(UInt(130)) == 1);
+  static_assert(countr_zero(max) == 0);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(countr_zero);
+
+template <class UInt>
+constexpr auto test_countr_one(UInt x) -> decltype(Kokkos::countr_one(x)) {
+  using Kokkos::countr_one;
+
+  static_assert(noexcept(countr_one(x)));
+  static_assert(std::is_same_v<decltype(countr_one(x)), int>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(countr_one(UInt(0)) == 0);
+  static_assert(countr_one(UInt(1)) == 1);
+  static_assert(countr_one(UInt(2)) == 0);
+  static_assert(countr_one(UInt(3)) == 2);
+  static_assert(countr_one(UInt(4)) == 0);
+  static_assert(countr_one(UInt(5)) == 1);
+  static_assert(countr_one(UInt(6)) == 0);
+  static_assert(countr_one(UInt(7)) == 3);
+  static_assert(countr_one(UInt(8)) == 0);
+  static_assert(countr_one(UInt(9)) == 1);
+  static_assert(countr_one(UInt(126)) == 0);
+  static_assert(countr_one(UInt(127)) == 7);
+  static_assert(countr_one(UInt(128)) == 0);
+  static_assert(countr_one(UInt(max - 1)) == 0);
+  static_assert(countr_one(max) == dig);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(countr_one);
+
+template <class UInt>
+constexpr auto test_popcount(UInt x) -> decltype(Kokkos::popcount(x)) {
+  using Kokkos::popcount;
+
+  static_assert(noexcept(popcount(x)));
+  static_assert(std::is_same_v<decltype(popcount(x)), int>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(popcount(UInt(0)) == 0);
+  static_assert(popcount(UInt(1)) == 1);
+  static_assert(popcount(UInt(2)) == 1);
+  static_assert(popcount(UInt(3)) == 2);
+  static_assert(popcount(UInt(4)) == 1);
+  static_assert(popcount(UInt(5)) == 2);
+  static_assert(popcount(UInt(6)) == 2);
+  static_assert(popcount(UInt(7)) == 3);
+  static_assert(popcount(UInt(8)) == 1);
+  static_assert(popcount(UInt(9)) == 2);
+  static_assert(popcount(UInt(127)) == 7);
+  static_assert(popcount(max) == dig);
+  static_assert(popcount(UInt(max - 1)) == dig - 1);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(popcount);
+//</editor-fold>
+
+//<editor-fold desc="[bit.pow.two]">
+template <class UInt>
+constexpr auto test_has_single_bit(UInt x)
+    -> decltype(Kokkos::has_single_bit(x)) {
+  using Kokkos::has_single_bit;
+
+  static_assert(noexcept(has_single_bit(x)));
+  static_assert(std::is_same_v<decltype(has_single_bit(x)), bool>);
+
+  static_assert(!has_single_bit(UInt(0)));
+  static_assert(has_single_bit(UInt(1)));
+  static_assert(has_single_bit(UInt(2)));
+  static_assert(!has_single_bit(UInt(3)));
+  static_assert(has_single_bit(UInt(4)));
+  static_assert(!has_single_bit(UInt(5)));
+  static_assert(!has_single_bit(UInt(6)));
+  static_assert(!has_single_bit(UInt(7)));
+  static_assert(has_single_bit(UInt(8)));
+  static_assert(!has_single_bit(UInt(9)));
+
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  static_assert(!has_single_bit(max));
+  constexpr UInt one = 1;
+  static_assert(has_single_bit(UInt(one << 0)));
+  static_assert(has_single_bit(UInt(one << 1)));
+  static_assert(has_single_bit(UInt(one << 2)));
+  static_assert(has_single_bit(UInt(one << 3)));
+  static_assert(has_single_bit(UInt(one << 4)));
+  static_assert(has_single_bit(UInt(one << 5)));
+  static_assert(has_single_bit(UInt(one << 6)));
+  static_assert(has_single_bit(UInt(one << 7)));
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(has_single_bit);
+
+template <class UInt>
+constexpr auto test_bit_floor(UInt x) -> decltype(Kokkos::bit_floor(x)) {
+  using Kokkos::bit_floor;
+
+  static_assert(noexcept(bit_floor(x)));
+  static_assert(std::is_same_v<decltype(bit_floor(x)), UInt>);
+
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(bit_floor(UInt(0)) == 0);
+  static_assert(bit_floor(UInt(1)) == 1);
+  static_assert(bit_floor(UInt(2)) == 2);
+  static_assert(bit_floor(UInt(3)) == 2);
+  static_assert(bit_floor(UInt(4)) == 4);
+  static_assert(bit_floor(UInt(5)) == 4);
+  static_assert(bit_floor(UInt(6)) == 4);
+  static_assert(bit_floor(UInt(7)) == 4);
+  static_assert(bit_floor(UInt(8)) == 8);
+  static_assert(bit_floor(UInt(9)) == 8);
+  static_assert(bit_floor(UInt(125)) == 64);
+  static_assert(bit_floor(UInt(126)) == 64);
+  static_assert(bit_floor(UInt(127)) == 64);
+  static_assert(bit_floor(UInt(128)) == 128);
+  static_assert(bit_floor(UInt(129)) == 128);
+  static_assert(bit_floor(max) == UInt(max - (max >> 1)));
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(bit_floor);
+
+template <class UInt>
+constexpr auto test_bit_ceil(UInt x) -> decltype(Kokkos::bit_ceil(x)) {
+  using Kokkos::bit_ceil;
+
+  static_assert(noexcept(bit_ceil(x)));
+  static_assert(std::is_same_v<decltype(bit_ceil(x)), UInt>);
+
+  static_assert(bit_ceil(UInt(0)) == 1);
+  static_assert(bit_ceil(UInt(1)) == 1);
+  static_assert(bit_ceil(UInt(2)) == 2);
+  static_assert(bit_ceil(UInt(3)) == 4);
+  static_assert(bit_ceil(UInt(4)) == 4);
+  static_assert(bit_ceil(UInt(5)) == 8);
+  static_assert(bit_ceil(UInt(6)) == 8);
+  static_assert(bit_ceil(UInt(7)) == 8);
+  static_assert(bit_ceil(UInt(8)) == 8);
+  static_assert(bit_ceil(UInt(9)) == 16);
+  static_assert(bit_ceil(UInt(60)) == 64);
+  static_assert(bit_ceil(UInt(61)) == 64);
+  static_assert(bit_ceil(UInt(62)) == 64);
+  static_assert(bit_ceil(UInt(63)) == 64);
+  static_assert(bit_ceil(UInt(64)) == 64);
+  static_assert(bit_ceil(UInt(65)) == 128);
+  static_assert(bit_ceil(UInt(66)) == 128);
+  static_assert(bit_ceil(UInt(67)) == 128);
+  static_assert(bit_ceil(UInt(68)) == 128);
+  static_assert(bit_ceil(UInt(69)) == 128);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(bit_ceil);
+
+template <class UInt>
+constexpr auto test_bit_width(UInt x) -> decltype(Kokkos::bit_width(x)) {
+  using Kokkos::bit_width;
+
+  static_assert(noexcept(bit_width(x)));
+  static_assert(std::is_same_v<decltype(bit_width(x)), UInt>);
+
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+
+  static_assert(bit_width(UInt(0)) == 0);
+  static_assert(bit_width(UInt(1)) == 1);
+  static_assert(bit_width(UInt(2)) == 2);
+  static_assert(bit_width(UInt(3)) == 2);
+  static_assert(bit_width(UInt(4)) == 3);
+  static_assert(bit_width(UInt(5)) == 3);
+  static_assert(bit_width(UInt(6)) == 3);
+  static_assert(bit_width(UInt(7)) == 3);
+  static_assert(bit_width(UInt(8)) == 4);
+  static_assert(bit_width(UInt(9)) == 4);
+
+  static_assert(bit_width(UInt(max - 1)) == dig);
+  static_assert(bit_width(max) == dig);
+
+  return true;
+}
+
+TEST_BIT_MANIPULATION(bit_width);
+//</editor-fold>
+
+//<editor-fold desc="[bit.byteswap]">
+template <class T>
+constexpr auto test_byteswap(T x) -> decltype(Kokkos::byteswap(x)) {
+  using Kokkos::byteswap;
+
+  static_assert(noexcept(byteswap(x)));
+  static_assert(std::is_same_v<decltype(byteswap(x)), T>);
+
+  return true;
+}
+
+constexpr X test_byteswap(...) { return {}; }
+
+static_assert(test_byteswap((void *)0).did_not_match());  // NOLINT
+static_assert(test_byteswap((float)0).did_not_match());
+constexpr char c2[2] = {};
+static_assert(test_byteswap(c2).did_not_match());
+static_assert(test_byteswap((char)0));
+static_assert(test_byteswap((short)0));
+static_assert(test_byteswap((int)0));
+static_assert(test_byteswap((long)0));
+static_assert(test_byteswap((long long)0));
+static_assert(test_byteswap((unsigned char)0));
+static_assert(test_byteswap((unsigned short)0));
+static_assert(test_byteswap((unsigned int)0));
+static_assert(test_byteswap((unsigned long)0));
+static_assert(test_byteswap((unsigned long long)0));
+
+constexpr bool test_byteswap2() {
+  using Kokkos::byteswap;
+
+  static_assert(byteswap<int8_t>(INT8_C(0x12)) == INT8_C(0x12));
+  static_assert(byteswap<int16_t>(INT16_C(0x1234)) == INT16_C(0x3412));
+  static_assert(byteswap<int32_t>(INT32_C(0x12345678)) == INT32_C(0x78563412));
+
+  // These static_casts are a workaround for an nvcc 11.2 compiler bug
+  static_assert(
+      static_cast<uint64_t>(byteswap<int64_t>(INT64_C(0x123456789abcdef0))) ==
+      static_cast<uint64_t>(INT64_C(0xf0debc9a78563412)));
+
+  static_assert(byteswap<uint8_t>(UINT8_C(0x21)) == UINT8_C(0x21));
+  static_assert(byteswap<uint16_t>(UINT16_C(0x4321)) == UINT16_C(0x2143));
+  static_assert(byteswap<uint32_t>(UINT32_C(0x87654321)) ==
+                UINT32_C(0x21436587));
+  static_assert(byteswap<uint64_t>(UINT64_C(0xfedcba9876543210)) ==
+                UINT64_C(0x1032547698badcfe));
+  static_assert(byteswap<const uint32_t>(UINT32_C(0xdeadbeef)) ==
+                UINT32_C(0xefbeadde));
+
+  return true;
+}
+static_assert(test_byteswap2());
+//</editor-fold>
+
+#undef TEST_BIT_MANIPULATION
+
+//<editor-fold desc="[bit.bit_cast]">
+template <class To, class From>
+constexpr auto test_bit_cast() -> typename std::is_same<
+    decltype(Kokkos::bit_cast<To>(std::declval<From const &>())),
+    To>::value_type {
+  static_assert(
+      std::is_same_v<
+          decltype(Kokkos::bit_cast<To>(std::declval<From const &>())), To>);
+  return true;
+}
+template <class To, class From>
+constexpr X test_bit_cast(...) {
+  return {};
+}
+
+// FIXME_SYCL The SYCL implementation is unconstrained
+#ifndef KOKKOS_ENABLE_SYCL
+namespace TypesNotTheSameSize {
+struct To {
+  char a;
+};
+struct From {
+  char b;
+  char c;
+};
+static_assert(test_bit_cast<To, From>().did_not_match());
+}  // namespace TypesNotTheSameSize
+
+namespace ToNotTriviallyCopyable {
+struct To {
+  char a;
+  To(To const &);
+};
+struct From {
+  char b;
+};
+static_assert(test_bit_cast<To, From>().did_not_match());
+}  // namespace ToNotTriviallyCopyable
+
+namespace FromNotTriviallyCopyable {
+struct To {
+  char a;
+};
+struct From {
+  char b;
+  From(From const &);
+};
+static_assert(test_bit_cast<To, From>().did_not_match());
+}  // namespace FromNotTriviallyCopyable
+#endif
+
+namespace ReturnTypeIllFormed {
+struct From {
+  char a;
+  char b;
+};
+static_assert(test_bit_cast<int(), From>().did_not_match());
+static_assert(test_bit_cast<char[2], From>().did_not_match());
+}  // namespace ReturnTypeIllFormed
+   //</editor-fold>
diff --git a/core/unit_test/TestBitManipulationBuiltins.hpp b/core/unit_test/TestBitManipulationBuiltins.hpp
new file mode 100644
index 0000000000..9e353de9e7
--- /dev/null
+++ b/core/unit_test/TestBitManipulationBuiltins.hpp
@@ -0,0 +1,863 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <gtest/gtest.h>
+
+#include <Kokkos_Core.hpp>
+
+// clang-format off
+template <class>
+struct type_helper;
+#define DEFINE_TYPE_NAME(T) \
+template <> struct type_helper<T> { static char const * name() { return #T; } };
+DEFINE_TYPE_NAME(unsigned char)
+DEFINE_TYPE_NAME(unsigned short)
+DEFINE_TYPE_NAME(unsigned int)
+DEFINE_TYPE_NAME(unsigned long)
+DEFINE_TYPE_NAME(unsigned long long)
+DEFINE_TYPE_NAME(char)
+DEFINE_TYPE_NAME(short)
+DEFINE_TYPE_NAME(int)
+DEFINE_TYPE_NAME(long)
+DEFINE_TYPE_NAME(long long)
+#undef DEFINE_TYPE_NAME
+// clang-format on
+
+#define DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(FUNC)   \
+  struct BitManipFunction_##FUNC {                    \
+    template <class T>                                \
+    static KOKKOS_FUNCTION auto eval_constexpr(T x) { \
+      return Kokkos::FUNC(x);                         \
+    }                                                 \
+    template <class T>                                \
+    static KOKKOS_FUNCTION auto eval_builtin(T x) {   \
+      return Kokkos::Experimental::FUNC##_builtin(x); \
+    }                                                 \
+    static char const* name() { return #FUNC; }       \
+  }
+
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(countl_zero);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(countl_one);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(countr_zero);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(countr_one);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(popcount);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(has_single_bit);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(bit_ceil);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(bit_floor);
+DEFINE_BIT_MANIPULATION_FUNCTION_EVAL(bit_width);
+
+#undef DEFINE_BIT_MANIPULATION_FUNCTION_EVAL
+
+template <class Space, class Func, class Arg, std::size_t N>
+struct TestBitManipFunction {
+  Arg val_[N];
+  TestBitManipFunction(const Arg (&val)[N]) {
+    std::copy(val, val + N, val_);
+    run();
+  }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, N), *this, errors);
+    ASSERT_EQ(errors, 0) << "Failed check no error for " << Func::name() << "("
+                         << type_helper<Arg>::name() << ")";
+  }
+  KOKKOS_FUNCTION void operator()(int i, int& e) const {
+    if (Func::eval_builtin(val_[i]) != Func::eval_constexpr(val_[i])) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          "value at %x which is %d was expected to be %d\n", (unsigned)val_[i],
+          (int)Func::eval_builtin(val_[i]), (int)Func::eval_constexpr(val_[i]));
+    }
+  }
+};
+
+template <class Space, class... Func, class Arg, std::size_t N>
+void do_test_bit_manip_function(const Arg (&x)[N]) {
+  (void)std::initializer_list<int>{
+      (TestBitManipFunction<Space, Func, Arg, N>(x), 0)...};
+}
+
+#define TEST_BIT_MANIP_FUNCTION(FUNC) \
+  do_test_bit_manip_function<TEST_EXECSPACE, BitManipFunction_##FUNC>
+
+template <class UInt>
+void test_bit_manip_countl_zero() {
+  using Kokkos::Experimental::countl_zero_builtin;
+  static_assert(noexcept(countl_zero_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(countl_zero_builtin(UInt())), int>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(countl_zero)
+  ({
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(127),
+      UInt(128),
+      UInt(max),
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_countl_zero) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_countl_zero<unsigned char>();
+    test_bit_manip_countl_zero<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_countl_zero<unsigned int>();
+  test_bit_manip_countl_zero<unsigned long>();
+  test_bit_manip_countl_zero<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_countl_one() {
+  using Kokkos::Experimental::countl_one_builtin;
+  static_assert(noexcept(countl_one_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(countl_one_builtin(UInt())), int>);
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(countl_one)
+  ({
+      // clang-format off
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(100),
+      UInt(127),
+      UInt(128),
+      UInt(max),
+      UInt(max - 1),
+      UInt(max - 2),
+      UInt(max - 3),
+      UInt(max - 4),
+      UInt(max - 5),
+      UInt(max - 6),
+      UInt(max - 7),
+      UInt(max - 8),
+      UInt(max - 9),
+      UInt(max - 126),
+      UInt(max - 127),
+      UInt(max - 128),
+      UInt(UInt(1) << (dig - 1)),
+      UInt(UInt(3) << (dig - 2)),
+      UInt(UInt(7) << (dig - 3)),
+      UInt(UInt(255) << (dig - 8)),
+      // clang-format on
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_countl_one) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_countl_one<unsigned char>();
+    test_bit_manip_countl_one<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_countl_one<unsigned int>();
+  test_bit_manip_countl_one<unsigned long>();
+  test_bit_manip_countl_one<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_countr_zero() {
+  using Kokkos::Experimental::countr_zero_builtin;
+  static_assert(noexcept(countr_zero_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(countr_zero_builtin(UInt())), int>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(countr_zero)
+  ({
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(126),
+      UInt(127),
+      UInt(128),
+      UInt(129),
+      UInt(130),
+      UInt(max),
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_countr_zero) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+#if defined(KOKKOS_ENABLE_SYCL) && \
+    !defined(KOKKOS_ARCH_INTEL_GPU)  // FIXME_SYCL returns wrong result
+    if (!std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+#endif
+      test_bit_manip_countr_zero<unsigned char>();
+    test_bit_manip_countr_zero<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_countr_zero<unsigned int>();
+  test_bit_manip_countr_zero<unsigned long>();
+  test_bit_manip_countr_zero<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_countr_one() {
+  using Kokkos::Experimental::countr_one_builtin;
+  static_assert(noexcept(countr_one_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(countr_one_builtin(UInt())), int>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(countr_one)
+  ({
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(126),
+      UInt(127),
+      UInt(128),
+      UInt(max - 1),
+      UInt(max),
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_countr_one) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+#if defined(KOKKOS_ENABLE_SYCL) && \
+    !defined(KOKKOS_ARCH_INTEL_GPU)  // FIXME_SYCL returns wrong result
+    if (!std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+#endif
+      test_bit_manip_countr_one<unsigned char>();
+    test_bit_manip_countr_one<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_countr_one<unsigned int>();
+  test_bit_manip_countr_one<unsigned long>();
+  test_bit_manip_countr_one<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_popcount() {
+  using Kokkos::Experimental::popcount_builtin;
+  static_assert(noexcept(popcount_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(popcount_builtin(UInt())), int>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(popcount)
+  ({
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(127),
+      UInt(max),
+      UInt(max - 1),
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_popcount) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_popcount<unsigned char>();
+    test_bit_manip_popcount<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_popcount<unsigned int>();
+  test_bit_manip_popcount<unsigned long>();
+  test_bit_manip_popcount<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_has_single_bit() {
+  using Kokkos::Experimental::has_single_bit_builtin;
+  static_assert(noexcept(has_single_bit_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(has_single_bit_builtin(UInt())), bool>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  constexpr UInt one = 1;
+  TEST_BIT_MANIP_FUNCTION(has_single_bit)
+  ({
+      // clang-format off
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(max),
+      UInt(one << 0),
+      UInt(one << 1),
+      UInt(one << 2),
+      UInt(one << 3),
+      UInt(one << 4),
+      UInt(one << 5),
+      UInt(one << 6),
+      UInt(one << 7),
+      // clang-format on
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_has_single_bit) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_has_single_bit<unsigned char>();
+    test_bit_manip_has_single_bit<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_has_single_bit<unsigned int>();
+  test_bit_manip_has_single_bit<unsigned long>();
+  test_bit_manip_has_single_bit<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_bit_floor() {
+  using Kokkos::Experimental::bit_floor_builtin;
+  static_assert(noexcept(bit_floor_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(bit_floor_builtin(UInt())), UInt>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(bit_floor)
+  ({
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(125),
+      UInt(126),
+      UInt(127),
+      UInt(128),
+      UInt(129),
+      UInt(max),
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_bit_floor) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_bit_floor<unsigned char>();
+    test_bit_manip_bit_floor<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_bit_floor<unsigned int>();
+  test_bit_manip_bit_floor<unsigned long>();
+  test_bit_manip_bit_floor<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_bit_ceil() {
+  using Kokkos::Experimental::bit_ceil_builtin;
+  static_assert(noexcept(bit_ceil_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(bit_ceil_builtin(UInt())), UInt>);
+  TEST_BIT_MANIP_FUNCTION(bit_ceil)
+  ({
+      // clang-format off
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(60),
+      UInt(61),
+      UInt(62),
+      UInt(63),
+      UInt(64),
+      UInt(65),
+      UInt(66),
+      UInt(67),
+      UInt(68),
+      UInt(69),
+      // clang-format on
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_bit_ceil) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_bit_ceil<unsigned char>();
+    test_bit_manip_bit_ceil<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_bit_ceil<unsigned int>();
+  test_bit_manip_bit_ceil<unsigned long>();
+  test_bit_manip_bit_ceil<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_bit_width() {
+  using Kokkos::Experimental::bit_width_builtin;
+  static_assert(noexcept(bit_width_builtin(UInt())));
+  static_assert(std::is_same_v<decltype(bit_width_builtin(UInt())), UInt>);
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_MANIP_FUNCTION(bit_width)
+  ({
+      UInt(0),
+      UInt(1),
+      UInt(2),
+      UInt(3),
+      UInt(4),
+      UInt(5),
+      UInt(6),
+      UInt(7),
+      UInt(8),
+      UInt(9),
+      UInt(max - 1),
+      UInt(max),
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_bit_width) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_bit_width<unsigned char>();
+    test_bit_manip_bit_width<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_bit_width<unsigned int>();
+  test_bit_manip_bit_width<unsigned long>();
+  test_bit_manip_bit_width<unsigned long long>();
+}
+
+#undef TEST_BIT_MANIP_FUNCTION
+
+#define DEFINE_BIT_ROTATE_FUNCTION_EVAL(FUNC)                \
+  struct BitRotateFunction_##FUNC {                          \
+    template <class T>                                       \
+    static KOKKOS_FUNCTION auto eval_constexpr(T x, int s) { \
+      return Kokkos::FUNC(x, s);                             \
+    }                                                        \
+    template <class T>                                       \
+    static KOKKOS_FUNCTION auto eval_builtin(T x, int s) {   \
+      return Kokkos::Experimental::FUNC##_builtin(x, s);     \
+    }                                                        \
+    static char const* name() { return #FUNC; }              \
+  }
+
+DEFINE_BIT_ROTATE_FUNCTION_EVAL(rotl);
+DEFINE_BIT_ROTATE_FUNCTION_EVAL(rotr);
+
+#undef DEFINE_BIT_ROTATE_FUNCTION_EVAL
+
+template <class T>
+struct P {
+  using type = T;
+  T x;
+  int s;
+};
+
+template <class Space, class Func, class Arg, std::size_t N>
+struct TestBitRotateFunction {
+  Arg val_[N];
+  TestBitRotateFunction(const Arg (&val)[N]) {
+    std::copy(val, val + N, val_);
+    run();
+  }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, N), *this, errors);
+    ASSERT_EQ(errors, 0) << "Failed check no error for " << Func::name() << "("
+                         << type_helper<typename Arg::type>::name() << ", int)";
+  }
+  KOKKOS_FUNCTION void operator()(int i, int& e) const {
+    if (Func::eval_builtin(val_[i].x, val_[i].s) !=
+        Func::eval_constexpr(val_[i].x, val_[i].s)) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          "value at %x rotated by %d which is %x was expected to be %x\n",
+          (unsigned)val_[i].x, val_[i].s,
+          (unsigned)Func::eval_builtin(val_[i].x, val_[i].s),
+          (unsigned)Func::eval_constexpr(val_[i].x, val_[i].s));
+    }
+  }
+};
+
+template <class Space, class... Func, class Arg, std::size_t N>
+void do_test_bit_rotate_function(const Arg (&x)[N]) {
+  (void)std::initializer_list<int>{
+      (TestBitRotateFunction<Space, Func, Arg, N>(x), 0)...};
+}
+
+#define TEST_BIT_ROTATE_FUNCTION(FUNC) \
+  do_test_bit_rotate_function<TEST_EXECSPACE, BitRotateFunction_##FUNC>
+
+template <class UInt>
+void test_bit_manip_rotl() {
+  using Kokkos::Experimental::rotl_builtin;
+  static_assert(noexcept(rotl_builtin(UInt(), 0)));
+  static_assert(std::is_same_v<decltype(rotl_builtin(UInt(), 0)), UInt>);
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_ROTATE_FUNCTION(rotl)
+  ({
+      // clang-format off
+      P<UInt>{UInt(0), 0},
+      P<UInt>{UInt(0), 1},
+      P<UInt>{UInt(0), 4},
+      P<UInt>{UInt(0), 8},
+      P<UInt>{max, 0},
+      P<UInt>{max, 1},
+      P<UInt>{max, 4},
+      P<UInt>{max, 8},
+      P<UInt>{UInt(1), 0},
+      P<UInt>{UInt(1), 1},
+      P<UInt>{UInt(1), 4},
+      P<UInt>{UInt(1), dig},
+      P<UInt>{UInt(7), dig},
+      P<UInt>{UInt(6), dig - 1},
+      P<UInt>{UInt(3), 6},
+      P<UInt>{UInt(max - 1), 0},
+      P<UInt>{UInt(max - 1), 1},
+      P<UInt>{UInt(max - 1), 2},
+      P<UInt>{UInt(max - 1), 3},
+      P<UInt>{UInt(max - 1), 4},
+      P<UInt>{UInt(max - 1), 5},
+      P<UInt>{UInt(max - 1), 6},
+      P<UInt>{UInt(max - 1), 7},
+      P<UInt>{UInt(1), 0},
+      P<UInt>{UInt(1), 1},
+      P<UInt>{UInt(1), 2},
+      P<UInt>{UInt(1), 3},
+      P<UInt>{UInt(1), 4},
+      P<UInt>{UInt(1), 5},
+      P<UInt>{UInt(1), 6},
+      P<UInt>{UInt(1), 7},
+      // clang-format on
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_rotl) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_rotl<unsigned char>();
+    test_bit_manip_rotl<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_rotl<unsigned int>();
+  test_bit_manip_rotl<unsigned long>();
+  test_bit_manip_rotl<unsigned long long>();
+}
+
+template <class UInt>
+void test_bit_manip_rotr() {
+  using Kokkos::rotr;
+  using Kokkos::Experimental::rotr_builtin;
+  static_assert(noexcept(rotr_builtin(UInt(), 0)));
+  static_assert(std::is_same_v<decltype(rotr_builtin(UInt(), 0)), UInt>);
+  constexpr auto dig = Kokkos::Experimental::digits_v<UInt>;
+  constexpr auto max = Kokkos::Experimental::finite_max_v<UInt>;
+  TEST_BIT_ROTATE_FUNCTION(rotr)
+  ({
+      // clang-format off
+      P<UInt>{UInt(0), 0},
+      P<UInt>{UInt(0), 1},
+      P<UInt>{UInt(0), 4},
+      P<UInt>{UInt(0), 8},
+      P<UInt>{max, 0},
+      P<UInt>{max, 1},
+      P<UInt>{max, 4},
+      P<UInt>{max, 8},
+      P<UInt>{UInt(128), 0},
+      P<UInt>{UInt(128), 1},
+      P<UInt>{UInt(128), 4},
+      P<UInt>{UInt(1), dig},
+      P<UInt>{UInt(7), dig},
+      P<UInt>{UInt(6), dig - 1},
+      P<UInt>{UInt(36), dig - 2},
+      P<UInt>{UInt(max - 1), 0},
+      P<UInt>{UInt(max - 1), 1},
+      P<UInt>{UInt(max - 1), 2},
+      P<UInt>{UInt(max - 1), 3},
+      P<UInt>{UInt(max - 1), 4},
+      P<UInt>{UInt(max - 1), 5},
+      P<UInt>{UInt(max - 1), 6},
+      P<UInt>{UInt(max - 1), 7},
+      P<UInt>{UInt(128), 0},
+      P<UInt>{UInt(128), 1},
+      P<UInt>{UInt(128), 2},
+      P<UInt>{UInt(128), 3},
+      P<UInt>{UInt(128), 4},
+      P<UInt>{UInt(128), 5},
+      P<UInt>{UInt(128), 6},
+      P<UInt>{UInt(128), 0},
+      // clang-format on
+  });
+}
+
+TEST(TEST_CATEGORY, bit_manip_rotr) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_rotr<unsigned char>();
+    test_bit_manip_rotr<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_rotr<unsigned int>();
+  test_bit_manip_rotr<unsigned long>();
+  test_bit_manip_rotr<unsigned long long>();
+}
+
+#undef TEST_BIT_ROTATE_FUNCTION
+
+template <class Space, class T>
+struct TestByteswapFunction {
+  TestByteswapFunction() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0) << "Failed check no error for byteswap("
+                         << type_helper<T>::name() << ")";
+  }
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    T value;
+    T expected;
+    switch (sizeof(T)) {
+      case 1:
+        value    = static_cast<T>(0x12);
+        expected = static_cast<T>(0x12);
+        break;
+      case 2:
+        value    = static_cast<T>(0x1234);
+        expected = static_cast<T>(0x3412);
+        break;
+      case 4:
+        value    = static_cast<T>(0x60AF8503);
+        expected = static_cast<T>(0x0385AF60);
+        break;
+      case 8:
+        value    = static_cast<T>(0xABCDFE9477936406);
+        expected = static_cast<T>(0x0664937794FECDAB);
+        break;
+      default: Kokkos::abort("logic error");
+    }
+    using Kokkos::Experimental::byteswap_builtin;
+    if (byteswap_builtin(value) != expected) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          "value at %llx which is %llx was expected to be %llx\n",
+          (unsigned long long)value,
+          (unsigned long long)byteswap_builtin(value),
+          (unsigned long long)expected);
+    }
+  }
+};
+
+template <class Integral>
+void test_bit_manip_byteswap() {
+  using Kokkos::rotr;
+  using Kokkos::Experimental::byteswap_builtin;
+  static_assert(noexcept(byteswap_builtin(Integral())));
+  static_assert(
+      std::is_same_v<decltype(byteswap_builtin(Integral())), Integral>);
+  TestByteswapFunction<TEST_EXECSPACE, Integral>();
+}
+
+TEST(TEST_CATEGORY, bit_manip_byeswap) {
+// FIXME_NVHPC: NVC++-W-0155-Compiler failed to translate accelerator region
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  if constexpr (!std::is_same_v<TEST_EXECSPACE,
+                                Kokkos::Experimental::OpenACC>) {
+#endif
+    test_bit_manip_byteswap<char>();
+    test_bit_manip_byteswap<unsigned char>();
+    test_bit_manip_byteswap<short>();
+    test_bit_manip_byteswap<unsigned short>();
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+  }
+#endif
+  test_bit_manip_byteswap<int>();
+  test_bit_manip_byteswap<unsigned int>();
+  test_bit_manip_byteswap<long>();
+  test_bit_manip_byteswap<unsigned long>();
+  test_bit_manip_byteswap<long long>();
+  test_bit_manip_byteswap<unsigned long long>();
+}
+
+// CUDA doesn't provide memcmp
+KOKKOS_FUNCTION int my_memcmp(void const* lhs, void const* rhs, size_t count) {
+  auto u1 = static_cast<unsigned char const*>(lhs);
+  auto u2 = static_cast<unsigned char const*>(rhs);
+  while (count-- != 0) {
+    if (*u1 != *u2) {
+      return (*u1 < *u2) ? -1 : +1;
+    }
+    ++u1;
+    ++u2;
+  }
+  return 0;
+}
+
+template <class Space>
+struct TestBitCastFunction {
+  TestBitCastFunction() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0) << "Failed check no error for bit_cast()";
+  }
+  template <typename To, typename From>
+#if defined(KOKKOS_COMPILER_GNU) && (900 <= KOKKOS_COMPILER_GNU) && \
+    (KOKKOS_COMPILER_GNU < 930)
+  // workaround compiler bug seen in GCC 9.0.1 and GCC 9.2.0
+  KOKKOS_FUNCTION bool check(const From& from) const
+#else
+  static KOKKOS_FUNCTION bool check(const From& from)
+#endif
+  {
+    using Kokkos::Experimental::bit_cast_builtin;
+    return bit_cast_builtin<From>(bit_cast_builtin<To>(from)) == from;
+  }
+
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using Kokkos::bit_cast;
+    if (bit_cast<int>(123) != 123) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #1\n");
+    }
+    if (bit_cast<int>(123u) != 123) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #2\n");
+    }
+    if (bit_cast<int>(~0u) != ~0) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #3\n");
+    }
+    if constexpr (sizeof(int) == sizeof(float)) {
+      if (!check<int>(12.34f)) {
+        ++e;
+        KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #4\n");
+      }
+    }
+    if constexpr (sizeof(unsigned long long) == sizeof(double)) {
+      if (!check<unsigned long long>(123.456)) {
+        ++e;
+        KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #5\n");
+      }
+    }
+
+#if defined(KOKKOS_ENABLE_CUDA) && \
+    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
+    if constexpr (std::is_same_v<Space, Kokkos::Cuda>) {
+      return;
+    }
+#endif
+    struct S {
+      int i;
+
+      KOKKOS_FUNCTION bool operator==(const char* s) const {
+        return my_memcmp(&i, s, sizeof(i)) == 0;
+      }
+    };
+    char arr[sizeof(int)];
+    char arr2[sizeof(int)];
+    for (size_t i = 0; i < sizeof(int); ++i) {
+      arr[i]  = i + 1;
+      arr2[i] = (i + 1) * -(i % 2);
+    }
+    if (!(bit_cast<S>(arr) == arr)) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #6\n");
+    }
+    if (!(bit_cast<S>(arr2) == arr2)) {
+      ++e;
+      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #7\n");
+    }
+  }
+};
+
+TEST(TEST_CATEGORY, bit_manip_bit_cast) {
+  TestBitCastFunction<TEST_EXECSPACE>();
+}
diff --git a/core/unit_test/TestCompilerMacros.hpp b/core/unit_test/TestCompilerMacros.cpp
similarity index 71%
rename from core/unit_test/TestCompilerMacros.hpp
rename to core/unit_test/TestCompilerMacros.cpp
index 9d22c4b0a7..63b368b23e 100644
--- a/core/unit_test/TestCompilerMacros.hpp
+++ b/core/unit_test/TestCompilerMacros.cpp
@@ -14,8 +14,21 @@
 //
 //@HEADER
 
+#include <gtest/gtest.h>
 #include <Kokkos_Core.hpp>
 
+#if 1 != ((defined(KOKKOS_COMPILER_INTEL) ? 1 : 0) +      \
+          (defined(KOKKOS_COMPILER_INTEL_LLVM) ? 1 : 0) + \
+          (defined(KOKKOS_COMPILER_CRAYC) ? 1 : 0) +      \
+          (defined(KOKKOS_COMPILER_CRAY_LLVM) ? 1 : 0) +  \
+          (defined(KOKKOS_COMPILER_APPLECC) ? 1 : 0) +    \
+          (defined(KOKKOS_COMPILER_CLANG) ? 1 : 0) +      \
+          (defined(KOKKOS_COMPILER_GNU) ? 1 : 0) +        \
+          (defined(KOKKOS_COMPILER_NVHPC) ? 1 : 0) +      \
+          (defined(KOKKOS_COMPILER_MSVC) ? 1 : 0))
+#error "Only one host compiler macro can be defined"
+#endif
+
 #if defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
 #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
 #error "Macro bug: KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA shouldn't be defined"
@@ -26,8 +39,6 @@
 #endif
 #endif
 
-#define KOKKOS_PRAGMA_UNROLL(a)
-
 namespace TestCompilerMacros {
 
 template <class DEVICE_TYPE>
@@ -51,7 +62,7 @@ struct AddFunctor {
 #pragma vector always
 #endif
 #ifdef KOKKOS_ENABLE_PRAGMA_LOOPCOUNT
-#pragma loop count(128)
+#pragma loop_count(128)
 #endif
     for (int j = 0; j < length; j++) {
       a(i, j) += b(i, j);
@@ -75,7 +86,7 @@ bool Test() {
 }  // namespace TestCompilerMacros
 
 namespace Test {
-TEST(TEST_CATEGORY, compiler_macros) {
-  ASSERT_TRUE((TestCompilerMacros::Test<TEST_EXECSPACE>()));
+TEST(defaultdevicetype, compiler_macros) {
+  ASSERT_TRUE((TestCompilerMacros::Test<Kokkos::DefaultHostExecutionSpace>()));
 }
 }  // namespace Test
diff --git a/core/unit_test/TestComplex.hpp b/core/unit_test/TestComplex.hpp
index 87085f3648..bcae2e1d81 100644
--- a/core/unit_test/TestComplex.hpp
+++ b/core/unit_test/TestComplex.hpp
@@ -519,9 +519,13 @@ TEST(TEST_CATEGORY, complex_operations_arithmetic_types_overloads) {
   ASSERT_EQ(Kokkos::conj(1), Kokkos::complex<double>(1));
   ASSERT_EQ(Kokkos::conj(2.f), Kokkos::complex<float>(2.f));
   ASSERT_EQ(Kokkos::conj(3.), Kokkos::complex<double>(3.));
+// long double has size 12 but Kokkos::complex requires 2*sizeof(T) to be a
+// power of two.
+#ifndef KOKKOS_IMPL_32BIT
   ASSERT_EQ(Kokkos::conj(4.l), Kokkos::complex<long double>(4.l));
   static_assert((
       std::is_same<decltype(Kokkos::conj(1)), Kokkos::complex<double>>::value));
+#endif
   static_assert((std::is_same<decltype(Kokkos::conj(2.f)),
                               Kokkos::complex<float>>::value));
   static_assert((std::is_same<decltype(Kokkos::conj(3.)),
diff --git a/core/unit_test/TestDeepCopyAlignment.hpp b/core/unit_test/TestDeepCopyAlignment.hpp
index b7e6a87786..8e5ff3b9af 100644
--- a/core/unit_test/TestDeepCopyAlignment.hpp
+++ b/core/unit_test/TestDeepCopyAlignment.hpp
@@ -341,6 +341,9 @@ struct TestDeepCopyScalarConversion {
 }  // namespace Impl
 
 TEST(TEST_CATEGORY, deep_copy_conversion) {
+#ifdef KOKKOS_IMPL_32BIT
+  GTEST_SKIP() << "Failing KOKKOS_IMPL_32BIT";  // FIXME_32BIT
+#endif
   int64_t N0 = 19381;
   int64_t N1 = 17;
 
diff --git a/core/unit_test/TestDefaultDeviceTypeInit.hpp b/core/unit_test/TestDefaultDeviceTypeInit.hpp
index 7ae73b14d3..929c91db4e 100644
--- a/core/unit_test/TestDefaultDeviceTypeInit.hpp
+++ b/core/unit_test/TestDefaultDeviceTypeInit.hpp
@@ -262,7 +262,7 @@ void check_correct_initialization(const Kokkos::InitArguments& argstruct) {
 #endif
   }
 
-  ASSERT_EQ(Kokkos::HostSpace::execution_space::impl_thread_pool_size(),
+  ASSERT_EQ(Kokkos::HostSpace::execution_space().impl_thread_pool_size(),
             expected_nthreads);
 
 #ifdef KOKKOS_ENABLE_CUDA
diff --git a/core/unit_test/TestDeviceAndThreads.py b/core/unit_test/TestDeviceAndThreads.py
index fd70e3ff68..1d3ff8eea7 100644
--- a/core/unit_test/TestDeviceAndThreads.py
+++ b/core/unit_test/TestDeviceAndThreads.py
@@ -18,8 +18,8 @@
 import unittest
 import subprocess
 
-PREFIX = "$<TARGET_FILE_DIR:KokkosCore_UnitTest_DeviceAndThreads>"
-EXECUTABLE = "$<TARGET_FILE_NAME:KokkosCore_UnitTest_DeviceAndThreads>"
+PREFIX = "$<TARGET_FILE_DIR:Kokkos_CoreUnitTest_DeviceAndThreads>"
+EXECUTABLE = "$<TARGET_FILE_NAME:Kokkos_CoreUnitTest_DeviceAndThreads>"
 COMMAND = "/".join([PREFIX, EXECUTABLE])
 
 
diff --git a/core/unit_test/TestExecSpacePartitioning.hpp b/core/unit_test/TestExecSpacePartitioning.hpp
index 0b02a5e36f..1a70b7b267 100644
--- a/core/unit_test/TestExecSpacePartitioning.hpp
+++ b/core/unit_test/TestExecSpacePartitioning.hpp
@@ -131,9 +131,9 @@ TEST(TEST_CATEGORY, partitioning_by_args) {
 }
 
 TEST(TEST_CATEGORY, partitioning_by_vector) {
-  std::vector<int> weights{1, 1};
-  auto instances =
-      Kokkos::Experimental::partition_space(TEST_EXECSPACE(), weights);
+  // Make sure we can use a temporary as argument for weights
+  auto instances = Kokkos::Experimental::partition_space(
+      TEST_EXECSPACE(), std::vector<int> /*weights*/ {1, 1});
   ASSERT_EQ(int(instances.size()), 2);
   test_partitioning(instances);
 }
diff --git a/core/unit_test/TestFunctorAnalysis.hpp b/core/unit_test/TestFunctorAnalysis.hpp
index 9ebb9c066a..c024526111 100644
--- a/core/unit_test/TestFunctorAnalysis.hpp
+++ b/core/unit_test/TestFunctorAnalysis.hpp
@@ -38,6 +38,16 @@ struct TestFunctorAnalysis_03 {
   KOKKOS_INLINE_FUNCTION static void init(value_type&) {}
 };
 
+struct TestFunctorAnalysis_04 {
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int, float&) const {}
+
+  KOKKOS_INLINE_FUNCTION
+  void join(float&, float const&) const {}
+
+  KOKKOS_INLINE_FUNCTION static void init(float&) {}
+};
+
 template <class ExecSpace>
 void test_functor_analysis() {
   //------------------------------
@@ -45,7 +55,7 @@ void test_functor_analysis() {
   using A01 =
       Kokkos::Impl::FunctorAnalysis<Kokkos::Impl::FunctorPatternInterface::FOR,
                                     Kokkos::RangePolicy<ExecSpace>,
-                                    decltype(c01)>;
+                                    decltype(c01), void>;
 
   using R01 = typename A01::Reducer;
 
@@ -59,13 +69,13 @@ void test_functor_analysis() {
   static_assert(!A01::has_init_member_function, "");
   static_assert(!A01::has_final_member_function, "");
   static_assert(A01::StaticValueSize == 0, "");
-  ASSERT_EQ(R01(&c01).length(), 0);
+  ASSERT_EQ(R01(c01).length(), 0);
 
   //------------------------------
   auto c02  = KOKKOS_LAMBDA(int, double&){};
   using A02 = Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::REDUCE,
-      Kokkos::RangePolicy<ExecSpace>, decltype(c02)>;
+      Kokkos::RangePolicy<ExecSpace>, decltype(c02), void>;
   using R02 = typename A02::Reducer;
 
   static_assert(std::is_same<typename A02::value_type, double>::value, "");
@@ -78,14 +88,14 @@ void test_functor_analysis() {
   static_assert(!A02::has_init_member_function, "");
   static_assert(!A02::has_final_member_function, "");
   static_assert(A02::StaticValueSize == sizeof(double), "");
-  ASSERT_EQ(R02(&c02).length(), 1);
+  ASSERT_EQ(R02(c02).length(), 1);
 
   //------------------------------
 
   TestFunctorAnalysis_03 c03;
   using A03 = Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::REDUCE,
-      Kokkos::RangePolicy<ExecSpace>, TestFunctorAnalysis_03>;
+      Kokkos::RangePolicy<ExecSpace>, TestFunctorAnalysis_03, void>;
   using R03 = typename A03::Reducer;
 
   static_assert(std::is_same<typename A03::value_type,
@@ -106,9 +116,29 @@ void test_functor_analysis() {
   static_assert(!A03::has_final_member_function, "");
   static_assert(
       A03::StaticValueSize == sizeof(TestFunctorAnalysis_03::value_type), "");
-  ASSERT_EQ(R03(&c03).length(), 1);
+  ASSERT_EQ(R03(c03).length(), 1);
 
   //------------------------------
+
+  TestFunctorAnalysis_04 c04;
+  using A04 = Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::REDUCE,
+      Kokkos::RangePolicy<ExecSpace>, TestFunctorAnalysis_04, float>;
+  using R04 = typename A04::Reducer;
+
+  static_assert(std::is_same_v<typename A04::value_type, float>);
+  static_assert(
+      std::is_same_v<typename A04::pointer_type, typename A04::value_type*>);
+  static_assert(
+      std::is_same_v<typename A04::reference_type, typename A04::value_type&>);
+  static_assert(
+      std::is_same_v<typename R04::functor_type, TestFunctorAnalysis_04>);
+
+  static_assert(A04::has_join_member_function);
+  static_assert(A04::has_init_member_function);
+  static_assert(!A04::has_final_member_function);
+  static_assert(A04::StaticValueSize == sizeof(typename A04::value_type));
+  ASSERT_EQ(R04(c04).length(), 1);
 }
 
 TEST(TEST_CATEGORY, functor_analysis) {
diff --git a/core/unit_test/TestHalfOperators.hpp b/core/unit_test/TestHalfOperators.hpp
index 6a2bc359e5..29844a3c6a 100644
--- a/core/unit_test/TestHalfOperators.hpp
+++ b/core/unit_test/TestHalfOperators.hpp
@@ -17,8 +17,6 @@
 #ifndef TESTHALFOPERATOR_HPP_
 #define TESTHALFOPERATOR_HPP_
 namespace Test {
-#define FP16_EPSILON 0.0009765625F  // 1/2^10
-#define BF16_EPSILON 0.0078125F     // 1/2^7
 using namespace Kokkos::Experimental;
 using ExecutionSpace = TEST_EXECSPACE;
 using ScalarType     = double;
@@ -26,9 +24,19 @@ using ViewType       = Kokkos::View<ScalarType*, ExecutionSpace>;
 using ViewTypeHost   = Kokkos::View<ScalarType*, Kokkos::HostSpace>;
 KOKKOS_FUNCTION
 const half_t& accept_ref(const half_t& a) { return a; }
+KOKKOS_FUNCTION
+double accept_ref_expected(const half_t& a) {
+  double tmp = static_cast<double>(a);
+  return tmp;
+}
 #if !KOKKOS_BHALF_T_IS_FLOAT
 KOKKOS_FUNCTION
 const bhalf_t& accept_ref(const bhalf_t& a) { return a; }
+KOKKOS_FUNCTION
+double accept_ref_expected(const bhalf_t& a) {
+  double tmp = static_cast<double>(a);
+  return tmp;
+}
 #endif  // !KOKKOS_BHALF_T_IS_FLOAT
 
 enum OP_TESTS {
@@ -886,8 +894,16 @@ struct Functor_TestHalfOperators {
     // actual_lhs(TW)   = h_lhs <=> h_rhs;  // Need C++20?
     // expected_lhs(TW) = d_lhs <=> d_rhs;  // Need C++20?
 
-    actual_lhs(PASS_BY_REF)   = static_cast<double>(accept_ref(h_lhs));
-    expected_lhs(PASS_BY_REF) = d_lhs;
+    actual_lhs(PASS_BY_REF) = static_cast<double>(accept_ref(h_lhs));
+
+    // Use accept_ref and accept_ref_expected to ensure the compiler
+    // does not optimize out the casts half_type -> double -> half_type.
+    // Note that these casts are accompanied by rounding. For the bhalf_t
+    // epsilon, these rounding policies used for casting is enough to cause
+    // the unit tests to fail.
+    // In short, one cannot simply assign static_cast<double>(h_lhs) to
+    // expected_lhs(PASS_BY_REF).
+    expected_lhs(PASS_BY_REF) = accept_ref_expected(h_lhs);
 
     half_tmp = static_cast<float>(h_lhs);
     tmp_ptr  = &(tmp_lhs = half_tmp);
@@ -910,12 +926,7 @@ struct Functor_TestHalfOperators {
 
 template <class half_type>
 void __test_half_operators(half_type h_lhs, half_type h_rhs) {
-  double epsilon = FLT_EPSILON;
-
-  if (std::is_same<half_type, Kokkos::Experimental::half_t>::value)
-    epsilon = FP16_EPSILON;
-  if (std::is_same<half_type, Kokkos::Experimental::bhalf_t>::value)
-    epsilon = BF16_EPSILON;
+  double epsilon = Kokkos::Experimental::epsilon<half_type>::value;
 
   Functor_TestHalfOperators<ViewType, half_type> f_device(h_lhs, h_rhs);
   Functor_TestHalfOperators<ViewTypeHost, half_type> f_host(h_lhs, h_rhs);
diff --git a/core/unit_test/TestInit.hpp b/core/unit_test/TestInit.hpp
index 7be9ef5f12..9a8dba8dc8 100644
--- a/core/unit_test/TestInit.hpp
+++ b/core/unit_test/TestInit.hpp
@@ -40,5 +40,3 @@ TEST(TEST_CATEGORY, dispatch) { test_dispatch<TEST_EXECSPACE>(); }
 #endif
 
 }  // namespace Test
-
-#include <TestCompilerMacros.hpp>
diff --git a/core/unit_test/TestJoinBackwardCompatibility.hpp b/core/unit_test/TestJoinBackwardCompatibility.hpp
index 60da9e0713..3ca4421270 100644
--- a/core/unit_test/TestJoinBackwardCompatibility.hpp
+++ b/core/unit_test/TestJoinBackwardCompatibility.hpp
@@ -21,13 +21,16 @@
                                // unimplemented reduction features
 namespace {
 
+// FIXME_NVHPC 23.3 errors out when using enums here
+// NVC++-F-0000-Internal compiler error. process_acc_put_dinit: unexpected
+// datatype    5339
+#ifndef KOKKOS_COMPILER_NVHPC
 enum MyErrorCode {
   no_error                           = 0b000,
   error_operator_plus_equal          = 0b001,
   error_operator_plus_equal_volatile = 0b010,
   error_join_volatile                = 0b100,
   expected_join_volatile             = 0b1000
-
 };
 
 KOKKOS_FUNCTION constexpr MyErrorCode operator|(MyErrorCode lhs,
@@ -36,6 +39,17 @@ KOKKOS_FUNCTION constexpr MyErrorCode operator|(MyErrorCode lhs,
                                   static_cast<int>(rhs));
 }
 
+#else
+
+using MyErrorCode                                        = unsigned;
+constexpr MyErrorCode no_error                           = 0b000;
+constexpr MyErrorCode error_operator_plus_equal          = 0b001;
+constexpr MyErrorCode error_operator_plus_equal_volatile = 0b010;
+constexpr MyErrorCode error_join_volatile                = 0b100;
+constexpr MyErrorCode expected_join_volatile             = 0b1000;
+
+#endif
+
 static_assert((no_error | error_operator_plus_equal_volatile) ==
                   error_operator_plus_equal_volatile,
               "");
@@ -130,8 +144,9 @@ void test_join_backward_compatibility() {
 }
 
 TEST(TEST_CATEGORY, join_backward_compatibility) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
+#if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_NVHPC) && \
+    KOKKOS_COMPILER_NVHPC <                                          \
+        230300  // FIXME_NVHPC test passes with workaround in 23.3
   GTEST_SKIP() << "FIXME wrong result";
 #endif
   test_join_backward_compatibility();
diff --git a/core/unit_test/TestMDRangeReduce.hpp b/core/unit_test/TestMDRangeReduce.hpp
new file mode 100644
index 0000000000..007fa420c3
--- /dev/null
+++ b/core/unit_test/TestMDRangeReduce.hpp
@@ -0,0 +1,68 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <gtest/gtest.h>
+
+#include <Kokkos_Core.hpp>
+
+namespace {
+
+template <typename T>
+void MDRangeReduceTester([[maybe_unused]] int bound, int k) {
+  const auto policy_MD = Kokkos::MDRangePolicy<Kokkos::Rank<2>, TEST_EXECSPACE>(
+      {0, 0}, {bound, 2});
+
+  // No explicit fence() calls needed because result is in HostSpace
+  {
+    T lor_MD = 0;
+    Kokkos::parallel_reduce(
+        policy_MD,
+        KOKKOS_LAMBDA(const int i, const int, T& res) { res = res || i == k; },
+        Kokkos::LOr<T>(lor_MD));
+    EXPECT_EQ(lor_MD, 1);
+  }
+  {
+    // Stick just a few true values in the Logical-OR reduction space,
+    // to try to make sure every value is being captured
+    T land_MD = 0;
+    Kokkos::parallel_reduce(
+        policy_MD, KOKKOS_LAMBDA(const int, const int, T& res) { res = 1; },
+        Kokkos::LAnd<T>(land_MD));
+    EXPECT_EQ(land_MD, 1);
+  }
+}
+
+TEST(TEST_CATEGORY, mdrange_parallel_reduce_primitive_types) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  GTEST_SKIP() << "FIXME OPENMPTARGET Tests of MDRange reduce over values "
+                  "smaller than int would fail";
+#elif defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
+  GTEST_SKIP() << "Skipped ENABLE_CUDA_LAMBDA";
+#else
+  for (int bound : {0, 1, 7, 32, 65, 7000}) {
+    for (int k = 0; k < bound; ++k) {
+      MDRangeReduceTester<bool>(bound, k);
+      MDRangeReduceTester<signed char>(bound, k);
+      MDRangeReduceTester<int8_t>(bound, k);
+      MDRangeReduceTester<int16_t>(bound, k);
+      MDRangeReduceTester<int32_t>(bound, k);
+      MDRangeReduceTester<int64_t>(bound, k);
+    }
+  }
+#endif
+}
+
+}  // namespace
diff --git a/core/unit_test/TestMathematicalConstants.hpp b/core/unit_test/TestMathematicalConstants.hpp
index f52bfeaff7..b9b350c9b7 100644
--- a/core/unit_test/TestMathematicalConstants.hpp
+++ b/core/unit_test/TestMathematicalConstants.hpp
@@ -63,7 +63,7 @@ struct TestMathematicalConstants {
 
   KOKKOS_FUNCTION void use_on_device() const {
 #if defined(KOKKOS_COMPILER_NVCC) || defined(KOKKOS_ENABLE_OPENMPTARGET) || \
-    defined(KOKKOS_ENABLE_OPENACC)
+    defined(KOKKOS_ENABLE_OPENACC) || defined(KOKKOS_COMPILER_NVHPC)
     take_by_value(Trait::value);
 #else
     (void)take_address_of(Trait::value);
diff --git a/core/unit_test/TestMathematicalFunctions.hpp b/core/unit_test/TestMathematicalFunctions.hpp
index b198006cbb..fe7074d5a1 100644
--- a/core/unit_test/TestMathematicalFunctions.hpp
+++ b/core/unit_test/TestMathematicalFunctions.hpp
@@ -30,12 +30,6 @@
 #define MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
 #endif
 
-// WORKAROUND icpx changing default FP model when optimization level is >= 1
-// using -fp-model=precise works too
-#if defined(__INTEL_LLVM_COMPILER)
-#define KOKKOS_IMPL_WORKAROUND_INTEL_LLVM_DEFAULT_FLOATING_POINT_MODEL
-#endif
-
 // clang-format off
 template <class>
 struct math_unary_function_return_type;
@@ -292,7 +286,32 @@ struct math_function_name;
   };                                                                  \
   constexpr char math_function_name<MathUnaryFunction_##FUNC>::name[]
 
-#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#define DEFINE_UNARY_FUNCTION_EVAL_CUSTOM(FUNC, ULP_FACTOR, REF_FUNC) \
+  struct MathUnaryFunction_##FUNC {                                   \
+    template <typename T>                                             \
+    static KOKKOS_FUNCTION auto eval(T x) {                           \
+      static_assert(                                                  \
+          std::is_same<decltype(Kokkos::FUNC((T)0)),                  \
+                       math_unary_function_return_type_t<T>>::value); \
+      return Kokkos::FUNC(x);                                         \
+    }                                                                 \
+    template <typename T>                                             \
+    static auto eval_std(T x) {                                       \
+      static_assert(                                                  \
+          std::is_same<decltype(REF_FUNC),                            \
+                       math_unary_function_return_type_t<T>>::value); \
+      return REF_FUNC;                                                \
+    }                                                                 \
+    static KOKKOS_FUNCTION double ulp_factor() { return ULP_FACTOR; } \
+  };                                                                  \
+  using kk_##FUNC = MathUnaryFunction_##FUNC;                         \
+  template <>                                                         \
+  struct math_function_name<MathUnaryFunction_##FUNC> {               \
+    static constexpr char name[] = #FUNC;                             \
+  };                                                                  \
+  constexpr char math_function_name<MathUnaryFunction_##FUNC>::name[]
+
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
 // Generally the expected ULP error should come from here:
 // https://www.gnu.org/software/libc/manual/html_node/Errors-in-Math-Functions.html
 // For now 1s largely seem to work ...
@@ -308,7 +327,9 @@ DEFINE_UNARY_FUNCTION_EVAL(log, 2);
 DEFINE_UNARY_FUNCTION_EVAL(log10, 2);
 DEFINE_UNARY_FUNCTION_EVAL(log2, 2);
 DEFINE_UNARY_FUNCTION_EVAL(log1p, 2);
+#endif
 
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
 DEFINE_UNARY_FUNCTION_EVAL(sqrt, 2);
 DEFINE_UNARY_FUNCTION_EVAL(cbrt, 2);
 
@@ -325,6 +346,10 @@ DEFINE_UNARY_FUNCTION_EVAL(tanh, 2);
 DEFINE_UNARY_FUNCTION_EVAL(asinh, 4);
 DEFINE_UNARY_FUNCTION_EVAL(acosh, 2);
 DEFINE_UNARY_FUNCTION_EVAL(atanh, 2);
+
+// non-standard math functions
+DEFINE_UNARY_FUNCTION_EVAL_CUSTOM(rsqrt, 2,
+                                  decltype(std::sqrt(x))(1) / std::sqrt(x));
 #endif
 
 #ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
@@ -474,6 +499,13 @@ template <class Space, class... Func, class Arg, std::size_t N>
 void do_test_math_unary_function(const Arg (&x)[N]) {
   (void)std::initializer_list<int>{
       (TestMathUnaryFunction<Space, Func, Arg, N>(x), 0)...};
+
+  // test if potentially device specific math functions also work on host
+  if constexpr (!std::is_same_v<Space, Kokkos::DefaultHostExecutionSpace>)
+    (void)std::initializer_list<int>{
+        (TestMathUnaryFunction<Kokkos::DefaultHostExecutionSpace, Func, Arg, N>(
+             x),
+         0)...};
 }
 
 #define TEST_MATH_FUNCTION(FUNC) \
@@ -699,7 +731,9 @@ TEST(TEST_CATEGORY, mathematical_functions_fma) {
   do_test_math_ternary_function<TEST_EXECSPACE, kk3_fma>(2.l, 3.l, 4.l);
 #endif
 }
+#endif
 
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
 TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(exp)({-9, -8, -7, -6, -5, 4, 3, 2, 1, 0});
   TEST_MATH_FUNCTION(exp)({-9l, -8l, -7l, -6l, -5l, 4l, 3l, 2l, 1l, 0l});
@@ -791,7 +825,9 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(log1p)({1234.l, 567.l, 89.l, -.007l});
 #endif
 }
+#endif
 
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
 TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(sinh)({-3, -2, -1, 0, 1});
   TEST_MATH_FUNCTION(sinh)({-3l, -2l, -1l, 0l, 1l});
@@ -865,6 +901,20 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(atanh)({-.97l, .86l, -.53l, .42l, -.1l, 0.l});
 #endif
 }
+
+TEST(TEST_CATEGORY, mathematical_functions_non_standard) {
+  TEST_MATH_FUNCTION(rsqrt)({1, 2, 3, 5, 7, 11});
+  TEST_MATH_FUNCTION(rsqrt)({1l, 2l, 3l, 5l, 7l, 11l});
+  TEST_MATH_FUNCTION(rsqrt)({1ll, 2ll, 3ll, 5ll, 7ll, 11ll});
+  TEST_MATH_FUNCTION(rsqrt)({1u, 2u, 3u, 5u, 7u});
+  TEST_MATH_FUNCTION(rsqrt)({1ul, 2ul, 3ul, 5ul, 7ul});
+  TEST_MATH_FUNCTION(rsqrt)({1ull, 2ull, 3ull, 5ull, 7ull});
+  TEST_MATH_FUNCTION(rsqrt)({10.f, 20.f, 30.f, 40.f});
+  TEST_MATH_FUNCTION(rsqrt)({11.1, 22.2, 33.3, 44.4});
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+  TEST_MATH_FUNCTION(rsqrt)({10.l, 20.l, 30.l, 40.l});
+#endif
+}
 #endif
 
 #ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
@@ -1060,11 +1110,7 @@ struct TestAbsoluteValueFunction {
     // special values
     using Kokkos::isinf;
     using Kokkos::isnan;
-    if (abs(-0.) != 0.
-#ifndef KOKKOS_IMPL_WORKAROUND_INTEL_LLVM_DEFAULT_FLOATING_POINT_MODEL
-        || !isinf(abs(-INFINITY)) || !isnan(abs(-NAN))
-#endif
-    ) {
+    if (abs(-0.) != 0. || !isinf(abs(-INFINITY)) || !isnan(abs(-NAN))) {
       ++e;
       KOKKOS_IMPL_DO_NOT_USE_PRINTF(
           "failed abs(floating_point) special values\n");
@@ -1101,44 +1147,31 @@ struct TestIsNaN {
       ++e;
       KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(integral)\n");
     }
-    if (isnan(2.f)
-#ifndef KOKKOS_IMPL_WORKAROUND_INTEL_LLVM_DEFAULT_FLOATING_POINT_MODEL
-        || !isnan(quiet_NaN<float>::value) ||
+    if (isnan(2.f) || !isnan(quiet_NaN<float>::value) ||
         !isnan(signaling_NaN<float>::value)
-#endif
 
     ) {
       ++e;
       KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(float)\n");
     }
     if (isnan(3.)
-#ifndef KOKKOS_IMPL_WORKAROUND_INTEL_LLVM_DEFAULT_FLOATING_POINT_MODEL
 #ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
         || !isnan(quiet_NaN<double>::value) ||
         !isnan(signaling_NaN<double>::value)
-#endif
 #endif
     ) {
       ++e;
       KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(double)\n");
     }
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
-    if (isnan(4.l)
-#ifndef KOKKOS_IMPL_WORKAROUND_INTEL_LLVM_DEFAULT_FLOATING_POINT_MODEL
-        || !isnan(quiet_NaN<long double>::value) ||
-        !isnan(signaling_NaN<long double>::value)
-#endif
-    ) {
+    if (isnan(4.l) || !isnan(quiet_NaN<long double>::value) ||
+        !isnan(signaling_NaN<long double>::value)) {
       ++e;
       KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(long double)\n");
     }
 #endif
     // special values
-    if (isnan(INFINITY)
-#ifndef KOKKOS_IMPL_WORKAROUND_INTEL_LLVM_DEFAULT_FLOATING_POINT_MODEL
-        || !isnan(NAN)
-#endif
-    ) {
+    if (isnan(INFINITY) || !isnan(NAN)) {
       ++e;
       KOKKOS_IMPL_DO_NOT_USE_PRINTF(
           "failed isnan(floating_point) special values\n");
diff --git a/core/unit_test/TestMathematicalFunctions1.hpp b/core/unit_test/TestMathematicalFunctions1.hpp
index d902a04422..7452d45e42 100644
--- a/core/unit_test/TestMathematicalFunctions1.hpp
+++ b/core/unit_test/TestMathematicalFunctions1.hpp
@@ -15,5 +15,7 @@
 //@HEADER
 
 #define KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
+#define KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
 #include "TestMathematicalFunctions.hpp"
 #undef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
+#undef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
diff --git a/core/unit_test/TestMathematicalFunctions2.hpp b/core/unit_test/TestMathematicalFunctions2.hpp
index 58572ebe6f..72f792b089 100644
--- a/core/unit_test/TestMathematicalFunctions2.hpp
+++ b/core/unit_test/TestMathematicalFunctions2.hpp
@@ -15,5 +15,7 @@
 //@HEADER
 
 #define KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#define KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
 #include "TestMathematicalFunctions.hpp"
 #undef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#undef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_3
diff --git a/core/unit_test/TestMathematicalFunctions3.hpp b/core/unit_test/TestMathematicalFunctions3.hpp
new file mode 100644
index 0000000000..3d7b356367
--- /dev/null
+++ b/core/unit_test/TestMathematicalFunctions3.hpp
@@ -0,0 +1,21 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#define KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#define KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
+#include "TestMathematicalFunctions.hpp"
+#undef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#undef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
diff --git a/core/unit_test/TestNumericTraits.hpp b/core/unit_test/TestNumericTraits.hpp
index 9146297cd8..f97fe7a699 100644
--- a/core/unit_test/TestNumericTraits.hpp
+++ b/core/unit_test/TestNumericTraits.hpp
@@ -40,7 +40,14 @@ struct extrema {
 
   DEFINE_EXTREMA(float, -FLT_MAX, FLT_MAX);
   DEFINE_EXTREMA(double, -DBL_MAX, DBL_MAX);
+
+// FIXME_NVHPC: with 23.3 using long double in KOKKOS_FUNCTION is hard error
+#if !defined(KOKKOS_ENABLE_CUDA) || !defined(KOKKOS_COMPILER_NVHPC)
   DEFINE_EXTREMA(long double, -LDBL_MAX, LDBL_MAX);
+#else
+  static long double min(long double) { return -LDBL_MAX; }
+  static long double max(long double) { return LDBL_MAX; }
+#endif
 
 #undef DEFINE_EXTREMA
 };
@@ -163,7 +170,8 @@ struct TestNumericTraits {
   }
 
   KOKKOS_FUNCTION void use_on_device() const {
-#if defined(KOKKOS_COMPILER_NVCC) || defined(KOKKOS_ENABLE_OPENMPTARGET)
+#if defined(KOKKOS_COMPILER_NVCC) || defined(KOKKOS_COMPILER_NVHPC) || \
+    defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_OPENACC)
     take_by_value(trait<T>::value);
 #else
     (void)take_address_of(trait<T>::value);
@@ -481,7 +489,14 @@ CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(double, round_error);
 CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(long double, round_error);
 CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(float, denorm_min);
 CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(double, denorm_min);
+
+// FIXME_OPENMPTARGET - The static_assert causes issues on Intel GPUs with the
+// OpenMPTarget backend.
+#if !(defined(KOKKOS_ENABLE_OPENMPTARGET) && \
+      defined(KOKKOS_COMPILER_INTEL_LLVM))
 CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(long double, denorm_min);
+#endif
+
 // clang-format off
 static_assert(Kokkos::Experimental::norm_min<float      >::value == std::numeric_limits<      float>::min(), "");
 static_assert(Kokkos::Experimental::norm_min<double     >::value == std::numeric_limits<     double>::min(), "");
diff --git a/core/unit_test/TestParallelScanRangePolicy.hpp b/core/unit_test/TestParallelScanRangePolicy.hpp
new file mode 100644
index 0000000000..6335b4a06f
--- /dev/null
+++ b/core/unit_test/TestParallelScanRangePolicy.hpp
@@ -0,0 +1,253 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <gtest/gtest.h>
+
+#include <Kokkos_Core.hpp>
+#include <cstdio>
+
+// This test checks parallel_scan() calls which use RangePolicy.
+
+namespace {
+
+template <typename ValueType>
+struct TestParallelScanRangePolicy {
+  // This typedef is needed for parallel_scan() where a
+  // work count is given (instead of a RangePolicy) so
+  // that the execution space can be deduced internally.
+  using execution_space = TEST_EXECSPACE;
+
+  using ViewType = Kokkos::View<ValueType*, execution_space>;
+
+  ViewType prefix_results;
+  ViewType postfix_results;
+
+  // Operator defining work done in parallel_scan.
+  // Simple scan over [0,1,...,N-1].
+  // Compute both prefix and postfix scans.
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const size_t i, ValueType& update, bool final_pass) const {
+    if (final_pass) {
+      prefix_results(i) = update;
+    }
+    update += i;
+    if (final_pass) {
+      postfix_results(i) = update;
+    }
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  void init(ValueType& update) const { update = 0; }
+
+  KOKKOS_INLINE_FUNCTION
+  void join(ValueType& update, const ValueType& input) const {
+    update += input;
+  }
+
+  template <typename... Args>
+  void test_scan(const size_t work_size) {
+    // Reset member data based on work_size
+    prefix_results  = ViewType("prefix_results", work_size);
+    postfix_results = ViewType("postfix_results", work_size);
+
+    // Lambda for checking errors from stored value at each index.
+    auto check_scan_results = [&]() {
+      auto const prefix_h = Kokkos::create_mirror_view_and_copy(
+          Kokkos::HostSpace(), prefix_results);
+      auto const postfix_h = Kokkos::create_mirror_view_and_copy(
+          Kokkos::HostSpace(), postfix_results);
+
+      for (size_t i = 0; i < work_size; ++i) {
+        // Check prefix sum
+        ASSERT_EQ(ValueType((i * (i - 1)) / 2), prefix_h(i));
+
+        // Check postfix sum
+        ASSERT_EQ(ValueType(((i + 1) * i) / 2), postfix_h(i));
+      }
+
+      // Reset results
+      Kokkos::deep_copy(prefix_results, 0);
+      Kokkos::deep_copy(postfix_results, 0);
+    };
+
+    // If policy template args are not given, call parallel_scan()
+    // with work_size input, if args are given, call
+    // parallel_scan() with RangePolicy<Args...>(0, work_size).
+    // For each case, call parallel_scan() with all possible
+    // function signatures.
+    if (sizeof...(Args) == 0) {
+      // Input: label, work_count, functor
+      Kokkos::parallel_scan("TestWithStrArg1", work_size, *this);
+      check_scan_results();
+
+      // Input: work_count, functor
+      Kokkos::parallel_scan(work_size, *this);
+      check_scan_results();
+
+      // Input: label, work_count, functor
+      // Input/Output: return_value
+      {
+        ValueType return_val = 0;
+        Kokkos::parallel_scan("TestWithStrArg2", work_size, *this, return_val);
+        check_scan_results();
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  return_val);  // sum( 0 .. N-1 )
+      }
+
+      // Input: work_count, functor
+      // Input/Output: return_value
+      {
+        ValueType return_val = 0;
+        Kokkos::parallel_scan(work_size, *this, return_val);
+        check_scan_results();
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  return_val);  // sum( 0 .. N-1 )
+      }
+
+      // Input: work_count, functor
+      // Input/Output: return_view (host space)
+      {
+        Kokkos::View<ValueType, Kokkos::HostSpace> return_view("return_view");
+        Kokkos::parallel_scan(work_size, *this, return_view);
+        check_scan_results();
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  return_view());  // sum( 0 .. N-1 )
+      }
+    } else {
+      // Construct RangePolicy for parallel_scan
+      // based on template Args and work_size.
+      Kokkos::RangePolicy<execution_space, Args...> policy(0, work_size);
+
+      // Input: label, work_count, functor
+      Kokkos::parallel_scan("TestWithStrArg3", policy, *this);
+      check_scan_results();
+
+      // Input: work_count, functor
+      Kokkos::parallel_scan(policy, *this);
+      check_scan_results();
+
+      {
+        // Input: label, work_count, functor
+        // Input/Output: return_value
+        ValueType return_val = 0;
+        Kokkos::parallel_scan("TestWithStrArg4", policy, *this, return_val);
+        check_scan_results();
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  return_val);  // sum( 0 .. N-1 )
+      }
+
+      // Input: work_count, functor
+      // Input/Output: return_value
+      {
+        ValueType return_val = 0;
+        Kokkos::parallel_scan(policy, *this, return_val);
+        check_scan_results();
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  return_val);  // sum( 0 .. N-1 )
+      }
+
+      // Input: work_count, functor
+      // Input/Output: return_view (Device)
+      {
+        Kokkos::View<ValueType, execution_space> return_view("return_view");
+        Kokkos::parallel_scan(policy, *this, return_view);
+        check_scan_results();
+
+        ValueType total;
+        Kokkos::deep_copy(total, return_view);
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  total);  // sum( 0 .. N-1 )
+      }
+
+      // Check Kokkos::Experimental::require()
+      // for one of the signatures.
+      {
+        using Property =
+            Kokkos::Experimental::WorkItemProperty::HintLightWeight_t;
+        const auto policy_with_require =
+            Kokkos::Experimental::require(policy, Property());
+
+        // Input: work_count, functor
+        // Input/Output: return_value
+        ValueType return_val = 0;
+        Kokkos::parallel_scan(policy_with_require, *this, return_val);
+        check_scan_results();
+        ASSERT_EQ(ValueType(work_size * (work_size - 1) / 2),
+                  return_val);  // sum( 0 .. N-1 )
+      }
+    }
+  }
+
+  // Run test_scan() for a collection of work size
+  template <typename... Args>
+  void test_scan(const std::vector<size_t> work_sizes) {
+    for (size_t i = 0; i < work_sizes.size(); ++i) {
+      test_scan<Args...>(work_sizes[i]);
+    }
+  }
+};  // struct TestParallelScanRangePolicy
+
+TEST(TEST_CATEGORY, parallel_scan_range_policy) {
+  {
+    TestParallelScanRangePolicy<char> f;
+
+    std::vector<size_t> work_sizes{5, 10};
+    f.test_scan<>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Static>>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Dynamic>>(work_sizes);
+  }
+  {
+    TestParallelScanRangePolicy<short int> f;
+
+    std::vector<size_t> work_sizes{50, 100};
+    f.test_scan<>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Static>>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Dynamic>>(work_sizes);
+  }
+  {
+    TestParallelScanRangePolicy<int> f;
+
+    std::vector<size_t> work_sizes{0, 1, 2, 1000, 1001};
+    f.test_scan<>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Static>>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Dynamic>>(work_sizes);
+  }
+  {
+    TestParallelScanRangePolicy<long int> f;
+
+    std::vector<size_t> work_sizes{1000, 10000};
+    f.test_scan<>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Static>>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Dynamic>>(work_sizes);
+  }
+  {
+    TestParallelScanRangePolicy<float> f;
+
+    std::vector<size_t> work_sizes{13, 34};
+    f.test_scan<>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Static>>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Dynamic>>(work_sizes);
+  }
+  {
+    TestParallelScanRangePolicy<double> f;
+
+    std::vector<size_t> work_sizes{17, 59};
+    f.test_scan<>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Static>>(work_sizes);
+    f.test_scan<Kokkos::Schedule<Kokkos::Dynamic>>(work_sizes);
+  }
+}
+}  // namespace
diff --git a/core/unit_test/TestRange.hpp b/core/unit_test/TestRange.hpp
index 0c465bdc1c..1648cb6ab4 100644
--- a/core/unit_test/TestRange.hpp
+++ b/core/unit_test/TestRange.hpp
@@ -203,55 +203,6 @@ struct TestRange {
     update += 1 + m_flags(i - offset);
   }
 
-  //----------------------------------------
-
-  void test_scan() {
-    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, ScheduleType>(0, N),
-                         *this);
-
-    auto check_scan_results = [&]() {
-      auto const host_mirror =
-          Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), result_view);
-      for (int i = 0; i < N; ++i) {
-        if (((i + 1) * i) / 2 != host_mirror(i)) {
-          std::cout << "Error at " << i << std::endl;
-          EXPECT_EQ(size_t(((i + 1) * i) / 2), size_t(host_mirror(i)));
-        }
-      }
-    };
-
-    Kokkos::parallel_scan(
-        "TestKernelScan",
-        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(0, N), *this);
-
-    check_scan_results();
-
-    value_type total = 0;
-    Kokkos::parallel_scan(
-        "TestKernelScanWithTotal",
-        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(0, N), *this,
-        total);
-
-    check_scan_results();
-
-    ASSERT_EQ(size_t((N - 1) * (N) / 2), size_t(total));  // sum( 0 .. N-1 )
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const OffsetTag &, const int i, value_type &update,
-                  bool final) const {
-    update += m_flags(i);
-
-    if (final) {
-      if (update != (i * (i + 1)) / 2) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-            "TestRange::test_scan error (%d,%d) : %d != %d\n", i, m_flags(i),
-            (i * (i + 1)) / 2, update);
-      }
-      result_view(i) = update;
-    }
-  }
-
   void test_dynamic_policy() {
 #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
     auto const N_no_implicit_capture = N;
@@ -404,49 +355,17 @@ TEST(TEST_CATEGORY, range_reduce) {
 }
 
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-TEST(TEST_CATEGORY, range_scan) {
-  {
-    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(0);
-    f.test_scan();
-  }
-  {
-    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(0);
-    f.test_scan();
-  }
+TEST(TEST_CATEGORY, range_dynamic_policy) {
 #if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_HIP) && \
     !defined(KOKKOS_ENABLE_SYCL)
   {
     TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(0);
     f.test_dynamic_policy();
   }
-#endif
-
-  {
-    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(2);
-    f.test_scan();
-  }
-  {
-    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(3);
-    f.test_scan();
-  }
-#if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_HIP) && \
-    !defined(KOKKOS_ENABLE_SYCL)
   {
     TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(3);
     f.test_dynamic_policy();
   }
-#endif
-
-  {
-    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static> > f(1000);
-    f.test_scan();
-  }
-  {
-    TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(1001);
-    f.test_scan();
-  }
-#if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_HIP) && \
-    !defined(KOKKOS_ENABLE_SYCL)
   {
     TestRange<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic> > f(1001);
     f.test_dynamic_policy();
@@ -454,4 +373,5 @@ TEST(TEST_CATEGORY, range_scan) {
 #endif
 }
 #endif
+
 }  // namespace Test
diff --git a/core/unit_test/TestRangePolicyRequire.hpp b/core/unit_test/TestRangePolicyRequire.hpp
index 749f8b97d2..4057216288 100644
--- a/core/unit_test/TestRangePolicyRequire.hpp
+++ b/core/unit_test/TestRangePolicyRequire.hpp
@@ -214,36 +214,6 @@ struct TestRangeRequire {
 
   //----------------------------------------
 
-  void test_scan() {
-    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace, ScheduleType>(0, N),
-                         *this);
-
-    Kokkos::parallel_scan(
-        "TestKernelScan",
-        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(0, N), *this);
-
-    int total = 0;
-    Kokkos::parallel_scan(
-        "TestKernelScanWithTotal",
-        Kokkos::RangePolicy<ExecSpace, ScheduleType, OffsetTag>(0, N), *this,
-        total);
-    ASSERT_EQ(size_t((N - 1) * (N) / 2), size_t(total));  // sum( 0 .. N-1 )
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const OffsetTag &, const int i, value_type &update,
-                  bool final) const {
-    update += m_flags(i);
-
-    if (final) {
-      if (update != (i * (i + 1)) / 2) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-            "TestRangeRequire::test_scan error %d : %d != %d\n", i,
-            (i * (i + 1)) / 2, m_flags(i));
-      }
-    }
-  }
-
   void test_dynamic_policy() {
 #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
     auto const N_no_implicit_capture = N;
@@ -416,63 +386,22 @@ TEST(TEST_CATEGORY, range_reduce_require) {
 }
 
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
-TEST(TEST_CATEGORY, range_scan_require) {
-  using Property = Kokkos::Experimental::WorkItemProperty::HintLightWeight_t;
-  {
-    TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static>, Property>
-        f(0);
-    f.test_scan();
-  }
-  {
-    TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic>,
-                     Property>
-        f(0);
-    f.test_scan();
-  }
+TEST(TEST_CATEGORY, range_dynamic_policy_require) {
 #if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_HIP) && \
     !defined(KOKKOS_ENABLE_SYCL)
+  using Property = Kokkos::Experimental::WorkItemProperty::HintLightWeight_t;
   {
     TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic>,
                      Property>
         f(0);
     f.test_dynamic_policy();
   }
-#endif
-
-  {
-    TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static>, Property>
-        f(2);
-    f.test_scan();
-  }
-  {
-    TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic>,
-                     Property>
-        f(3);
-    f.test_scan();
-  }
-#if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_HIP) && \
-    !defined(KOKKOS_ENABLE_SYCL)
   {
     TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic>,
                      Property>
         f(3);
     f.test_dynamic_policy();
   }
-#endif
-
-  {
-    TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static>, Property>
-        f(1000);
-    f.test_scan();
-  }
-  {
-    TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic>,
-                     Property>
-        f(1001);
-    f.test_scan();
-  }
-#if !defined(KOKKOS_ENABLE_CUDA) && !defined(KOKKOS_ENABLE_HIP) && \
-    !defined(KOKKOS_ENABLE_SYCL)
   {
     TestRangeRequire<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Dynamic>,
                      Property>
@@ -482,4 +411,5 @@ TEST(TEST_CATEGORY, range_scan_require) {
 #endif
 }
 #endif
+
 }  // namespace Test
diff --git a/core/unit_test/TestReduce.hpp b/core/unit_test/TestReduce.hpp
index 4cf30f6fbe..e1aa851f10 100644
--- a/core/unit_test/TestReduce.hpp
+++ b/core/unit_test/TestReduce.hpp
@@ -369,7 +369,10 @@ class TestReduceDynamic {
 
   TestReduceDynamic(const size_type nwork) {
     run_test_dynamic(nwork);
+#ifndef KOKKOS_ENABLE_OPENACC
+    // FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
     run_test_dynamic_minmax(nwork);
+#endif
     run_test_dynamic_final(nwork);
   }
 
@@ -542,6 +545,8 @@ TEST(TEST_CATEGORY, int64_t_reduce_dynamic_view) {
 
 // FIXME_OPENMPTARGET: Not yet implemented.
 #ifndef KOKKOS_ENABLE_OPENMPTARGET
+// FIXME_OPENACC: Not yet implemented.
+#ifndef KOKKOS_ENABLE_OPENACC
 TEST(TEST_CATEGORY, int_combined_reduce) {
   using functor_type = CombinedReduceFunctorSameType<int64_t, TEST_EXECSPACE>;
   constexpr uint64_t nw = 1000;
@@ -619,4 +624,5 @@ TEST(TEST_CATEGORY, int_combined_reduce_mixed) {
   }
 }
 #endif
+#endif
 }  // namespace Test
diff --git a/core/unit_test/TestReducers.hpp b/core/unit_test/TestReducers.hpp
index 633b203afe..ce71f334e0 100644
--- a/core/unit_test/TestReducers.hpp
+++ b/core/unit_test/TestReducers.hpp
@@ -22,6 +22,17 @@
 
 //--------------------------------------------------------------------------
 
+namespace Test {
+struct MyPair : Kokkos::pair<int, int> {};
+}  // namespace Test
+
+template <>
+struct Kokkos::reduction_identity<Test::MyPair> {
+  KOKKOS_FUNCTION static Test::MyPair min() {
+    return Test::MyPair{{INT_MAX, INT_MAX}};
+  }
+};
+
 namespace Test {
 
 struct ReducerTag {};
@@ -74,6 +85,20 @@ struct TestReducers {
     }
   };
 
+  struct MinLocFunctor2D {
+    Kokkos::View<const Scalar**, ExecSpace> values;
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(
+        const int& i, const int& j,
+        typename Kokkos::MinLoc<Scalar, MyPair>::value_type& value) const {
+      if (values(i, j) < value.val) {
+        value.val = values(i, j);
+        value.loc = {{i, j}};
+      }
+    }
+  };
+
   struct MaxLocFunctor {
     Kokkos::View<const Scalar*, ExecSpace> values;
 
@@ -88,6 +113,20 @@ struct TestReducers {
     }
   };
 
+  struct MaxLocFunctor2D {
+    Kokkos::View<const Scalar**, ExecSpace> values;
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(
+        const int& i, const int& j,
+        typename Kokkos::MaxLoc<Scalar, MyPair>::value_type& value) const {
+      if (values(i, j) > value.val) {
+        value.val = values(i, j);
+        value.loc = {{i, j}};
+      }
+    }
+  };
+
   struct MinMaxLocFunctor {
     Kokkos::View<const Scalar*, ExecSpace> values;
 
@@ -107,6 +146,25 @@ struct TestReducers {
     }
   };
 
+  struct MinMaxLocFunctor2D {
+    Kokkos::View<const Scalar**, ExecSpace> values;
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(
+        const int& i, const int& j,
+        typename Kokkos::MinMaxLoc<Scalar, MyPair>::value_type& value) const {
+      if (values(i, j) > value.max_val) {
+        value.max_val = values(i, j);
+        value.max_loc = {{i, j}};
+      }
+
+      if (values(i, j) < value.min_val) {
+        value.min_val = values(i, j);
+        value.min_loc = {{i, j}};
+      }
+    }
+  };
+
   struct BAndFunctor {
     Kokkos::View<const Scalar*, ExecSpace> values;
 
@@ -598,6 +656,44 @@ struct TestReducers {
     }
   }
 
+  static void test_minloc_2d(int N) {
+    using reducer_type = Kokkos::MinLoc<Scalar, MyPair>;
+    using value_type   = typename reducer_type::value_type;
+
+    Kokkos::View<Scalar**, ExecSpace> values("Values", N, N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_min = std::numeric_limits<Scalar>::max();
+    MyPair reference_loc = {{-1, -1}};
+
+    for (int i = 0; i < N; i++)
+      for (int j = 0; j < N; j++) {
+        h_values(i, j) = (Scalar)(rand() % 100000 + 2);
+
+        if (h_values(i, j) < reference_min) {
+          reference_min = h_values(i, j);
+          reference_loc = {{i, j}};
+        } else if (h_values(i, j) == reference_min) {
+          // Make min unique.
+          h_values(i, j) += Scalar(1);
+        }
+      }
+    Kokkos::deep_copy(values, h_values);
+
+    MinLocFunctor2D f;
+    f.values = values;
+
+    {
+      value_type min_scalar;
+      reducer_type reducer_scalar(min_scalar);
+
+      Kokkos::parallel_reduce(
+          Kokkos::MDRangePolicy<Kokkos::Rank<2>, ExecSpace>({0, 0}, {N, N}), f,
+          reducer_scalar);
+      ASSERT_EQ(min_scalar.val, reference_min);
+      ASSERT_EQ(min_scalar.loc, reference_loc);
+    }
+  }
+
   static void test_maxloc(int N) {
     using value_type = typename Kokkos::MaxLoc<Scalar, int>::value_type;
 
@@ -661,6 +757,44 @@ struct TestReducers {
     }
   }
 
+  static void test_maxloc_2d(int N) {
+    using reducer_type = Kokkos::MaxLoc<Scalar, MyPair>;
+    using value_type   = typename reducer_type::value_type;
+
+    Kokkos::View<Scalar**, ExecSpace> values("Values", N, N);
+    auto h_values        = Kokkos::create_mirror_view(values);
+    Scalar reference_max = std::numeric_limits<Scalar>::min();
+    MyPair reference_loc = {{-1, -1}};
+
+    for (int i = 0; i < N; ++i)
+      for (int j = 0; j < N; ++j) {
+        h_values(i, j) = (Scalar)(rand() % 100000 + 2);
+
+        if (h_values(i, j) > reference_max) {
+          reference_max = h_values(i, j);
+          reference_loc = {{i, j}};
+        } else if (h_values(i, j) == reference_max) {
+          // Make max unique.
+          h_values(i, j) -= Scalar(1);
+        }
+      }
+    Kokkos::deep_copy(values, h_values);
+
+    MaxLocFunctor2D f;
+    f.values = values;
+
+    {
+      value_type max_scalar;
+      reducer_type reducer_scalar(max_scalar);
+
+      Kokkos::parallel_reduce(
+          Kokkos::MDRangePolicy<Kokkos::Rank<2>, ExecSpace>({0, 0}, {N, N}), f,
+          reducer_scalar);
+      ASSERT_EQ(max_scalar.val, reference_max);
+      ASSERT_EQ(max_scalar.loc, reference_loc);
+    }
+  }
+
   static void test_minmaxloc(int N) {
     using value_type = typename Kokkos::MinMaxLoc<Scalar, int>::value_type;
 
@@ -777,6 +911,78 @@ struct TestReducers {
     }
   }
 
+  static void test_minmaxloc_2d(int N) {
+    using reducer_type = Kokkos::MinMaxLoc<Scalar, MyPair>;
+    using value_type   = typename reducer_type::value_type;
+
+    Kokkos::View<Scalar**, ExecSpace> values("Values", N, N);
+    auto h_values           = Kokkos::create_mirror_view(values);
+    Scalar reference_max    = std::numeric_limits<Scalar>::min();
+    Scalar reference_min    = std::numeric_limits<Scalar>::max();
+    MyPair reference_minloc = {{-1, -1}};
+    MyPair reference_maxloc = {{-1, -1}};
+
+    for (int i = 0; i < N; i++)
+      for (int j = 0; j < N; j++) {
+        h_values(i, j) = (Scalar)(rand() % 100000 + 2);
+      }
+
+    for (int i = 0; i < N; i++)
+      for (int j = 0; j < N; j++) {
+        if (h_values(i, j) > reference_max) {
+          reference_max    = h_values(i, j);
+          reference_maxloc = {{i, j}};
+        } else if (h_values(i, j) == reference_max) {
+          // Make max unique.
+          h_values(i, j) -= Scalar(1);
+        }
+      }
+
+    for (int i = 0; i < N; i++)
+      for (int j = 0; j < N; j++) {
+        if (h_values(i, j) < reference_min) {
+          reference_min    = h_values(i, j);
+          reference_minloc = {{i, j}};
+        } else if (h_values(i, j) == reference_min) {
+          // Make min unique.
+          h_values(i, j) += Scalar(1);
+        }
+      }
+
+    Kokkos::deep_copy(values, h_values);
+
+    MinMaxLocFunctor2D f;
+    f.values = values;
+    {
+      value_type minmax_scalar;
+      reducer_type reducer_scalar(minmax_scalar);
+
+      Kokkos::parallel_reduce(
+          Kokkos::MDRangePolicy<Kokkos::Rank<2>, ExecSpace>({0, 0}, {N, N}), f,
+          reducer_scalar);
+
+      ASSERT_EQ(minmax_scalar.min_val, reference_min);
+      for (int i = 0; i < N; i++)
+        for (int j = 0; j < N; j++) {
+          if ((minmax_scalar.min_loc == MyPair{{i, j}}) &&
+              (h_values(i, j) == reference_min)) {
+            reference_minloc = {{i, j}};
+          }
+        }
+      ASSERT_EQ(minmax_scalar.min_loc, reference_minloc);
+
+      ASSERT_EQ(minmax_scalar.max_val, reference_max);
+      for (int i = 0; i < N; i++)
+        for (int j = 0; j < N; j++) {
+          if ((minmax_scalar.max_loc == MyPair{{i, j}}) &&
+              (h_values(i, j) == reference_max)) {
+            reference_maxloc = {{i, j}};
+          }
+        }
+      ASSERT_EQ(minmax_scalar.max_loc, reference_maxloc);
+    }
+  }
+
   static void test_BAnd(int N) {
     Kokkos::View<Scalar*, ExecSpace> values("Values", N);
     auto h_values         = Kokkos::create_mirror_view(values);
@@ -982,14 +1188,38 @@ struct TestReducers {
     test_sum(10001);
     test_prod(35);
     test_min(10003);
+#if !defined(KOKKOS_ENABLE_OPENACC)
+    // FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
     test_minloc(10003);
+// FIXME_OPENMPTARGET requires custom reductions.
+#if !defined(KOKKOS_ENABLE_OPENMPTARGET)
+    test_minloc_2d(100);
+#endif
+#endif
     test_max(10007);
+#if !defined(KOKKOS_ENABLE_OPENACC)
+    // FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
     test_maxloc(10007);
-#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_COMPILER_CLANG) && \
-    (KOKKOS_COMPILER_CLANG < 1300)
-    // FIXME_OPENMPTARGET - The minmaxloc test fails llvm <= 13 version.
+// FIXME_OPENMPTARGET requires custom reductions.
+#if !defined(KOKKOS_ENABLE_OPENMPTARGET)
+    test_maxloc_2d(100);
+#endif
+#endif
+// FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
+#if !defined(KOKKOS_ENABLE_OPENACC)
+// FIXME_OPENMPTARGET - The minmaxloc test fails llvm < 13 version,
+// test_minmaxloc_2d requires custom reductions
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+#if defined(KOKKOS_COMPILER_CLANG) && (KOKKOS_COMPILER_CLANG >= 1300)
+    test_minmaxloc(10007);
+#else
+    if (!std::is_same_v<ExecSpace, Kokkos::Experimental::OpenMPTarget>)
+      test_minmaxloc(10007);
+#endif
 #else
     test_minmaxloc(10007);
+    test_minmaxloc_2d(100);
+#endif
 #endif
   }
 
@@ -1000,14 +1230,48 @@ struct TestReducers {
     test_sum(10001);
     test_prod(sizeof(Scalar) > 4 ? 35 : 19);  // avoid int overflow (see above)
     test_min(10003);
+#if !defined(KOKKOS_ENABLE_OPENACC)
+    // FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
     test_minloc(10003);
+#if defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC misaligned memory
+#if defined(KOKKOS_ENABLE_CUDA)
+    if (!std::is_same_v<ExecSpace, Kokkos::Cuda>)
+#endif
+    // FIXME_OPENMPTARGET requires custom reductions.
+#if !defined(KOKKOS_ENABLE_OPENMPTARGET)
+      test_minloc_2d(100);
+#endif
+#endif
+#endif
     test_max(10007);
+#if !defined(KOKKOS_ENABLE_OPENACC)
+    // FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
     test_maxloc(10007);
-#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_COMPILER_CLANG) && \
-    (KOKKOS_COMPILER_CLANG < 1300)
-    // FIXME_OPENMPTARGET - The minmaxloc test fails llvm <= 13 version.
+#if !defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC misaligned memory
+#if defined(KOKKOS_ENABLE_CUDA)
+    if (!std::is_same_v<ExecSpace, Kokkos::Cuda>)
+#endif
+// FIXME_OPENMPTARGET requires custom reductions.
+#if !defined(KOKKOS_ENABLE_OPENMPTARGET)
+      test_maxloc_2d(100);
+#endif
+#endif
+#endif
+// FIXME_OPENACC - OpenACC (V3.3) does not support custom reductions.
+#if !defined(KOKKOS_ENABLE_OPENACC)
+// FIXME_OPENMPTARGET - The minmaxloc test fails llvm < 13 version,
+// the minmaxloc_2d test requires custom reductions.
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+#if defined(KOKKOS_COMPILER_CLANG) && (KOKKOS_COMPILER_CLANG >= 1300)
+    test_minmaxloc(10007);
+#else
+    if (!std::is_same_v<ExecSpace, Kokkos::Experimental::OpenMPTarget>)
+      test_minmaxloc(10007);
+#endif
 #else
     test_minmaxloc(10007);
+    test_minmaxloc_2d(100);
+#endif
 #endif
     test_BAnd(35);
     test_BOr(35);
diff --git a/core/unit_test/TestScan.hpp b/core/unit_test/TestScan.hpp
deleted file mode 100644
index 8c6a02f31f..0000000000
--- a/core/unit_test/TestScan.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#include <Kokkos_Core.hpp>
-#include <cstdio>
-
-namespace {
-
-template <class Device, class T, T ImbalanceSz>
-struct TestScan {
-  using execution_space = Device;
-  using value_type      = T;
-
-  Kokkos::View<int, Device, Kokkos::MemoryTraits<Kokkos::Atomic> > errors;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const int iwork, value_type& update,
-                  const bool final_pass) const {
-    const value_type n = iwork + 1;
-    const value_type imbalance =
-        ((ImbalanceSz <= n) && (value_type(0) == n % ImbalanceSz))
-            ? ImbalanceSz
-            : value_type(0);
-
-    // Insert an artificial load imbalance
-
-    for (value_type i = 0; i < imbalance; ++i) {
-      ++update;
-    }
-
-    update += n - imbalance;
-
-    if (final_pass) {
-      const value_type answer =
-          n & 1 ? (n * ((n + 1) / 2)) : ((n / 2) * (n + 1));
-
-      if (answer != update) {
-        int fail = errors()++;
-
-        if (fail < 20) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF("TestScan(%d,%ld) != %ld\n", iwork,
-                                        static_cast<long>(update),
-                                        static_cast<long>(answer));
-        }
-      }
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void init(value_type& update) const { update = 0; }
-
-  KOKKOS_INLINE_FUNCTION
-  void join(value_type& update, const value_type& input) const {
-    update += input;
-  }
-
-  TestScan(const size_t N) {
-    Kokkos::View<int, Device> errors_a("Errors");
-    Kokkos::deep_copy(errors_a, 0);
-    errors = errors_a;
-
-    {
-      Kokkos::parallel_scan(N, *this);
-      check_error();
-    }
-
-    {
-      Kokkos::deep_copy(errors_a, 0);
-      value_type total = 0;
-      Kokkos::parallel_scan(N, *this, total);
-
-      // We can't return a value in a constructor so use a lambda as wrapper to
-      // ignore it.
-      [&] { ASSERT_EQ(size_t((N + 1) * N / 2), size_t(total)); }();
-      check_error();
-    }
-
-    {
-      Kokkos::deep_copy(errors_a, 0);
-      Kokkos::View<value_type, Kokkos::HostSpace> total_view("total");
-      Kokkos::parallel_scan(N, *this, total_view);
-      Kokkos::fence();
-
-      // We can't return a value in a constructor so use a lambda as wrapper to
-      // ignore it.
-      [&] { ASSERT_EQ(size_t((N + 1) * N / 2), size_t(total_view())); }();
-      check_error();
-    }
-
-    {
-      Kokkos::deep_copy(errors_a, 0);
-      Kokkos::View<value_type, typename Device::memory_space> total_view(
-          "total");
-      typename Device::execution_space exec;
-      Kokkos::parallel_scan(
-          Kokkos::RangePolicy<typename Device::execution_space>(exec, 0, N),
-          *this, total_view);
-      value_type total;
-      Kokkos::deep_copy(exec, total, total_view);
-      exec.fence();
-
-      // We can't return a value in a constructor so use a lambda as wrapper to
-      // ignore it.
-      [&] { ASSERT_EQ(size_t((N + 1) * N / 2), size_t(total)); }();
-      check_error();
-    }
-  }
-
-  TestScan(const size_t Start, const size_t N) {
-    using exec_policy = Kokkos::RangePolicy<execution_space>;
-
-    Kokkos::View<int, Device> errors_a("Errors");
-    Kokkos::deep_copy(errors_a, 0);
-    errors = errors_a;
-
-    Kokkos::parallel_scan(exec_policy(Start, N), *this);
-    Kokkos::fence();
-
-    check_error();
-  }
-
-  void check_error() {
-    int total_errors;
-    Kokkos::deep_copy(total_errors, errors);
-    ASSERT_EQ(total_errors, 0);
-  }
-
-  static void test_range(const size_t begin, const size_t end) {
-    for (auto i = begin; i < end; ++i) {
-      (void)TestScan(i);
-    }
-  }
-};
-}  // namespace
-
-TEST(TEST_CATEGORY, scan) {
-  constexpr auto imbalance_size = 1000;
-  TestScan<TEST_EXECSPACE, int64_t, imbalance_size>::test_range(1, 1000);
-  TestScan<TEST_EXECSPACE, int64_t, imbalance_size>(0);
-  TestScan<TEST_EXECSPACE, int64_t, imbalance_size>(100000);
-  TestScan<TEST_EXECSPACE, int64_t, imbalance_size>(10000000);
-}
-
-TEST(TEST_CATEGORY, small_size_scan) {
-  constexpr auto imbalance_size = 10;  // Pick to not overflow...
-  TestScan<TEST_EXECSPACE, std::int8_t, imbalance_size>(0);
-  TestScan<TEST_EXECSPACE, std::int8_t, imbalance_size>(5);
-  TestScan<TEST_EXECSPACE, std::int8_t, imbalance_size>(10);
-  TestScan<TEST_EXECSPACE, std::int8_t, imbalance_size>(
-      static_cast<std::size_t>(
-          std::sqrt(std::numeric_limits<std::int8_t>::max())));
-  constexpr auto short_imbalance_size = 100;  // Pick to not overflow...
-  TestScan<TEST_EXECSPACE, std::int16_t, short_imbalance_size>(0);
-  TestScan<TEST_EXECSPACE, std::int16_t, short_imbalance_size>(5);
-  TestScan<TEST_EXECSPACE, std::int16_t, short_imbalance_size>(100);
-  TestScan<TEST_EXECSPACE, std::int16_t, short_imbalance_size>(
-      static_cast<std::size_t>(
-          std::sqrt(std::numeric_limits<std::int16_t>::max())));
-}
diff --git a/core/unit_test/TestStackTrace.hpp b/core/unit_test/TestStackTrace.hpp
index f5a0b95a02..4dbe436e93 100644
--- a/core/unit_test/TestStackTrace.hpp
+++ b/core/unit_test/TestStackTrace.hpp
@@ -33,6 +33,12 @@ void stacktrace_test_f4();
 
 void my_fancy_handler();
 
+size_t find_first_non_whitespace(const std::string& s, const size_t start_pos) {
+  constexpr size_t num_ws_chars = 3;
+  const char ws_chars[]         = "\n\t ";
+  return s.find_first_not_of(ws_chars, start_pos, num_ws_chars);
+}
+
 void test_stacktrace(bool bTerminate, bool bCustom = true) {
   stacktrace_test_f1(std::cout);
   bool bDynamic = false;
@@ -44,7 +50,7 @@ void test_stacktrace(bool bTerminate, bool bCustom = true) {
     bDynamic = std::string::npos != foutput.find("stacktrace");
 
     if (bDynamic) {
-      printf("test_f1: %s \n", foutput.c_str());
+      printf("test_f1:\n%s \n", foutput.c_str());
       ASSERT_NE(std::string::npos, foutput.find("stacktrace_test_f1"));
       for (auto x : {"stacktrace_test_f0", "stacktrace_test_f2",
                      "stacktrace_test_f3", "stacktrace_test_f4"}) {
@@ -59,13 +65,13 @@ void test_stacktrace(bool bTerminate, bool bCustom = true) {
 
     if (bDynamic) {
       std::string foutput = sstream.str();
-      printf("demangled test_f1: %s \n", foutput.c_str());
-      ASSERT_TRUE(std::string::npos !=
-                  foutput.find("Test::stacktrace_test_f1"));
+      printf("demangled test_f1:\n%s \n", foutput.c_str());
+      ASSERT_NE(std::string::npos, foutput.find("Test::stacktrace_test_f1"));
       for (auto x : {"stacktrace_test_f0", "stacktrace_test_f2",
                      "stacktrace_test_f3", "stacktrace_test_f4"}) {
         ASSERT_EQ(std::string::npos, foutput.find(x));
       }
+      EXPECT_EQ(0u, find_first_non_whitespace(foutput, 0));
     }
   }
 
@@ -84,7 +90,7 @@ void test_stacktrace(bool bTerminate, bool bCustom = true) {
 
     if (bDynamic) {
       std::string foutput = sstream.str();
-      printf("test_f3: %s \n", foutput.c_str());
+      printf("test_f3:\n%s \n", foutput.c_str());
       for (auto x : {"stacktrace_test_f1", "stacktrace_test_f3"}) {
         ASSERT_NE(std::string::npos, foutput.find(x));
       }
@@ -99,10 +105,11 @@ void test_stacktrace(bool bTerminate, bool bCustom = true) {
 
     if (bDynamic) {
       std::string foutput = sstream.str();
-      printf("demangled test_f3: %s \n", foutput.c_str());
+      printf("demangled test_f3:\n%s \n", foutput.c_str());
       for (auto x : {"stacktrace_test_f1", "stacktrace_test_f3"}) {
         ASSERT_NE(std::string::npos, foutput.find(x));
       }
+      EXPECT_EQ(0u, find_first_non_whitespace(foutput, 0));
     }
 
     // TODO make sure stacktrace_test_f2/4 don't show up
diff --git a/core/unit_test/TestTaskScheduler.hpp b/core/unit_test/TestTaskScheduler.hpp
index 5a0394f6c1..1d72662ad2 100644
--- a/core/unit_test/TestTaskScheduler.hpp
+++ b/core/unit_test/TestTaskScheduler.hpp
@@ -170,9 +170,9 @@ struct TestTaskDependence {
 
   KOKKOS_INLINE_FUNCTION
   void operator()(typename sched_type::member_type& member) {
-    auto& sched = member.scheduler();
-    enum { CHUNK = 8 };
-    const int n = CHUNK < m_count ? CHUNK : m_count;
+    auto& sched                = member.scheduler();
+    static constexpr int CHUNK = 8;
+    const int n                = CHUNK < m_count ? CHUNK : m_count;
 
     if (1 < m_count) {
       const int increment = (m_count + n - 1) / n;
diff --git a/core/unit_test/TestTeam.hpp b/core/unit_test/TestTeam.hpp
index 0f86f9f369..f2a064cbc9 100644
--- a/core/unit_test/TestTeam.hpp
+++ b/core/unit_test/TestTeam.hpp
@@ -1582,7 +1582,7 @@ struct TestScratchAlignment {
     Kokkos::fence();
     int minimal_scratch_allocation_failed = 0;
     Kokkos::deep_copy(minimal_scratch_allocation_failed, flag);
-    ASSERT_TRUE(minimal_scratch_allocation_failed == 0);
+    ASSERT_EQ(minimal_scratch_allocation_failed, 0);
   }
 
   // test alignment of successive allocations
@@ -1615,10 +1615,9 @@ struct TestScratchAlignment {
             flag() = 1;
 
           // Now request aligned memory such that the allocation after
-          // for scratch_ptr2 would be unaligned if it doesn't pad
-          // correct.
-          // Depending on whether scratch_ptr3 is 4 or 8 byte aligned
-          // we need to request different amount of memory.
+          // scratch_ptr2 would be unaligned if it doesn't pad correctly.
+          // Depending on scratch_ptr3 being 4 or 8 byte aligned
+          // we need to request a different amount of memory.
           if ((scratch_ptr3 + 12) % 8 == 4)
             scratch_ptr1 = reinterpret_cast<intptr_t>(
                 team.team_shmem().get_shmem_aligned(24, 4));
@@ -1631,26 +1630,27 @@ struct TestScratchAlignment {
           scratch_ptr3 = reinterpret_cast<intptr_t>(
               team.team_shmem().get_shmem_aligned(8, 4));
 
-          // note the difference between scratch_ptr2 and scratch_ptr1
-          // is 4 bytes larger than what we requested in either of the
-          // two cases.
+          // The difference between scratch_ptr2 and scratch_ptr1 should be 4
+          // bytes larger than what we requested in either case.
           if (((scratch_ptr2 - scratch_ptr1) != 28) &&
               ((scratch_ptr2 - scratch_ptr1) != 16))
             flag() = 1;
-          // check that there wasn't unnneccessary padding happening
-          // i.e. scratch_ptr2 was allocated with a 32 byte request
-          // and since scratch_ptr3 is then already aligned it difference
-          // should match that
+          // Check that there wasn't unneccessary padding happening. Since
+          // scratch_ptr2 was allocated with a 32 byte request and scratch_ptr3
+          // is then already aligned, its difference should match 32 bytes.
           if ((scratch_ptr3 - scratch_ptr2) != 32) flag() = 1;
+
           // check actually alignment of ptrs is as requested
-          if (((scratch_ptr1 % 4) != 0) || ((scratch_ptr2 % 8) != 0) ||
-              ((scratch_ptr3 % 4) != 0))
+          // cast to int here to avoid failure with icpx in mixed integer type
+          // comparison
+          if ((int(scratch_ptr1 % 4) != 0) || (int(scratch_ptr2 % 8) != 0) ||
+              (int(scratch_ptr3 % 4) != 0))
             flag() = 1;
         });
     Kokkos::fence();
     int raw_get_shmem_alignment_failed = 0;
     Kokkos::deep_copy(raw_get_shmem_alignment_failed, flag);
-    ASSERT_TRUE(raw_get_shmem_alignment_failed == 0);
+    ASSERT_EQ(raw_get_shmem_alignment_failed, 0);
   }
 };
 
diff --git a/core/unit_test/TestTeamBasic.hpp b/core/unit_test/TestTeamBasic.hpp
index 5ee8629656..c395bc0837 100644
--- a/core/unit_test/TestTeamBasic.hpp
+++ b/core/unit_test/TestTeamBasic.hpp
@@ -182,6 +182,9 @@ struct LargeTeamScratchFunctor {
 };
 
 TEST(TEST_CATEGORY, large_team_scratch_size) {
+#ifdef KOKKOS_IMPL_32BIT
+  GTEST_SKIP() << "Fails on 32-bit";  // FIXME_32BIT
+#endif
   const int level   = 1;
   const int n_teams = 1;
 
@@ -247,6 +250,9 @@ struct long_wrapper {
   KOKKOS_FUNCTION
   long_wrapper(long val) : value(val) {}
 
+  KOKKOS_FUNCTION
+  long_wrapper(const long_wrapper& val) : value(val.value) {}
+
   KOKKOS_FUNCTION
   friend void operator+=(long_wrapper& lhs, const long_wrapper& rhs) {
     lhs.value += rhs.value;
diff --git a/core/unit_test/TestTeamCombinedReducers.hpp b/core/unit_test/TestTeamCombinedReducers.hpp
new file mode 100644
index 0000000000..47c2f666c9
--- /dev/null
+++ b/core/unit_test/TestTeamCombinedReducers.hpp
@@ -0,0 +1,515 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Core.hpp>
+#include <gtest/gtest.h>
+
+namespace {
+
+// Extended lambdas in parallel_for and parallel_reduce will not compile if
+// KOKKOS_ENABLE_CUDA_LAMBDA is off
+#if !defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_CUDA_LAMBDA)
+
+struct TeamTeamCombinedReducer {
+ public:
+  void test_team_thread_range_only_scalars(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamThreadRange = Kokkos::TeamThreadRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_reduce(
+              teamThreadRange,
+              [=](int const& i, int& localVal0, int& localVal1, int& localVal2,
+                  int& localVal3) {
+                localVal0 += 1;
+                localVal1 += i + 1;
+                localVal2 += (i + 1) * n;
+                localVal3 += n;
+              },
+              teamResult0, teamResult1, teamResult2, teamResult3);
+
+          Kokkos::single(Kokkos::PerTeam(team), [=]() {
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(3));
+    } else {
+      EXPECT_EQ(n, hostView(0));
+      EXPECT_EQ((n * (n + 1) / 2), hostView(1));
+      EXPECT_EQ(n * n * (n + 1) / 2, hostView(2));
+      EXPECT_EQ(n * n, hostView(3));
+    }
+  }
+
+  void test_team_thread_range_only_builtin(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamThreadRange = Kokkos::TeamThreadRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_reduce(
+              teamThreadRange,
+              [=](int const& i, int& localVal0, int& localVal1, int& localVal2,
+                  int& localVal3) {
+                localVal0 += i + 1;
+                localVal1 *= n;
+                localVal2 = (localVal2 > (i + 1)) ? (i + 1) : localVal2;
+                localVal3 = (localVal3 < (i + 1)) ? (i + 1) : localVal3;
+              },
+              Kokkos::Sum<int>(teamResult0), Kokkos::Prod<int>(teamResult1),
+              Kokkos::Min<int>(teamResult2), Kokkos::Max<int>(teamResult3));
+
+          Kokkos::single(Kokkos::PerTeam(team), [=]() {
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::prod(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::min(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::max(), hostView(3));
+    } else {
+      EXPECT_EQ((n * (n + 1) / 2), hostView(0));
+      EXPECT_EQ(std::pow(n, n), hostView(1));
+      EXPECT_EQ(1, hostView(2));
+      EXPECT_EQ(n, hostView(3));
+    }
+  }
+
+  void test_team_thread_range_combined_reducers(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int*, TEST_EXECSPACE::memory_space>("view", 4);
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamThreadRange = Kokkos::TeamThreadRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_reduce(
+              teamThreadRange,
+              [=](int const& i, int& localVal0, int& localVal1, int& localVal2,
+                  int& localVal3) {
+                localVal0 += i + 1;
+                localVal1 += i + 1;
+                localVal2 = (localVal2 < (i + 1)) ? (i + 1) : localVal2;
+                localVal3 += n;
+              },
+              teamResult0, Kokkos::Sum<int>(teamResult1),
+              Kokkos::Max<int>(teamResult2), teamResult3);
+
+          Kokkos::single(Kokkos::PerTeam(team), [=]() {
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::max(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(3));
+    } else {
+      EXPECT_EQ((n * (n + 1) / 2), hostView(0));
+      EXPECT_EQ((n * (n + 1) / 2), hostView(1));
+      EXPECT_EQ(n, hostView(2));
+      EXPECT_EQ(n * n, hostView(3));
+    }
+  }
+
+  void test_thread_vector_range_only_scalars(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamThreadRange   = Kokkos::TeamThreadRange(team, 1);
+          auto threadVectorRange = Kokkos::ThreadVectorRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_for(teamThreadRange, [&](int const&) {
+            Kokkos::parallel_reduce(
+                threadVectorRange,
+                [=](int const& i, int& localVal0, int& localVal1,
+                    int& localVal2, int& localVal3) {
+                  localVal0 += 1;
+                  localVal1 += i + 1;
+                  localVal2 += (i + 1) * n;
+                  localVal3 += n;
+                },
+                teamResult0, teamResult1, teamResult2, teamResult3);
+
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(3));
+    } else {
+      EXPECT_EQ(n, hostView(0));
+      EXPECT_EQ((n * (n + 1) / 2), hostView(1));
+      EXPECT_EQ(n * n * (n + 1) / 2, hostView(2));
+      EXPECT_EQ(n * n, hostView(3));
+    }
+  }
+
+  void test_thread_vector_range_only_builtin(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamThreadRange   = Kokkos::TeamThreadRange(team, 1);
+          auto threadVectorRange = Kokkos::ThreadVectorRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_for(teamThreadRange, [&](int const&) {
+            Kokkos::parallel_reduce(
+                threadVectorRange,
+                [=](int const& i, int& localVal0, int& localVal1,
+                    int& localVal2, int& localVal3) {
+                  localVal0 += i + 1;
+                  localVal1 *= n;
+                  localVal2 = (localVal2 > (i + 1)) ? (i + 1) : localVal2;
+                  localVal3 = (localVal3 < (i + 1)) ? (i + 1) : localVal3;
+                },
+                Kokkos::Sum<int>(teamResult0), Kokkos::Prod<int>(teamResult1),
+                Kokkos::Min<int>(teamResult2), Kokkos::Max<int>(teamResult3));
+
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::prod(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::min(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::max(), hostView(3));
+    } else {
+      EXPECT_EQ((n * (n + 1) / 2), hostView(0));
+      EXPECT_EQ(std::pow(n, n), hostView(1));
+      EXPECT_EQ(1, hostView(2));
+      EXPECT_EQ(n, hostView(3));
+    }
+  }
+
+  void test_thread_vector_range_combined_reducers(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamThreadRange   = Kokkos::TeamThreadRange(team, 1);
+          auto threadVectorRange = Kokkos::ThreadVectorRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_for(teamThreadRange, [&](int const&) {
+            Kokkos::parallel_reduce(
+                threadVectorRange,
+                [=](int const& i, int& localVal0, int& localVal1,
+                    int& localVal2, int& localVal3) {
+                  localVal0 *= n;
+                  localVal1 += i + 1;
+                  localVal2 = (localVal2 > (i + 1)) ? (i + 1) : localVal2;
+                  localVal3 += n;
+                },
+                Kokkos::Prod<int>(teamResult0), teamResult1,
+                Kokkos::Min<int>(teamResult2), teamResult3);
+
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::prod(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::min(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(3));
+    } else {
+      EXPECT_EQ(std::pow(n, n), hostView(0));
+      EXPECT_EQ((n * (n + 1) / 2), hostView(1));
+      EXPECT_EQ(1, hostView(2));
+      EXPECT_EQ(n * n, hostView(3));
+    }
+  }
+
+  void test_team_vector_range_only_scalars(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamVectorRange = Kokkos::TeamVectorRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_reduce(
+              teamVectorRange,
+              [=](int const& i, int& localVal0, int& localVal1, int& localVal2,
+                  int& localVal3) {
+                localVal0 += 1;
+                localVal1 += i + 1;
+                localVal2 += (i + 1) * n;
+                localVal3 += n;
+              },
+              teamResult0, teamResult1, teamResult2, teamResult3);
+
+          Kokkos::single(Kokkos::PerTeam(team), [=]() {
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(3));
+    } else {
+      EXPECT_EQ(n, hostView(0));
+      EXPECT_EQ((n * (n + 1) / 2), hostView(1));
+      EXPECT_EQ(n * n * (n + 1) / 2, hostView(2));
+      EXPECT_EQ(n * n, hostView(3));
+    }
+  }
+
+  void test_team_vector_range_only_builtin(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamVectorRange = Kokkos::TeamVectorRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_reduce(
+              teamVectorRange,
+              [=](int const& i, int& localVal0, int& localVal1, int& localVal2,
+                  int& localVal3) {
+                localVal0 += i + 1;
+                localVal1 *= n;
+                localVal2 = (localVal2 > (i + 1)) ? (i + 1) : localVal2;
+                localVal3 = (localVal3 < (i + 1)) ? (i + 1) : localVal3;
+              },
+              Kokkos::Sum<int>(teamResult0), Kokkos::Prod<int>(teamResult1),
+              Kokkos::Min<int>(teamResult2), Kokkos::Max<int>(teamResult3));
+
+          Kokkos::single(Kokkos::PerTeam(team), [=]() {
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::prod(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::min(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::max(), hostView(3));
+    } else {
+      EXPECT_EQ((n * (n + 1) / 2), hostView(0));
+      EXPECT_EQ(std::pow(n, n), hostView(1));
+      EXPECT_EQ(1, hostView(2));
+      EXPECT_EQ(n, hostView(3));
+    }
+  }
+
+  void test_team_vector_range_combined_reducers(const int n) {
+    auto policy = Kokkos::TeamPolicy<TEST_EXECSPACE>(1, Kokkos::AUTO);
+    using team_member_type = decltype(policy)::member_type;
+
+    auto teamView = Kokkos::View<int[4], TEST_EXECSPACE::memory_space>("view");
+
+    Kokkos::parallel_for(
+        policy, KOKKOS_LAMBDA(team_member_type const& team) {
+          auto teamVectorRange = Kokkos::TeamVectorRange(team, n);
+          int teamResult0, teamResult1, teamResult2, teamResult3;
+
+          Kokkos::parallel_reduce(
+              teamVectorRange,
+              [=](int const& i, int& localVal0, int& localVal1, int& localVal2,
+                  int& localVal3) {
+                localVal0 += i + 1;
+                localVal1 += i + 1;
+                localVal2 = (localVal2 < (i + 1)) ? (i + 1) : localVal2;
+                localVal3 += n;
+              },
+              teamResult0, Kokkos::Sum<int>(teamResult1),
+              Kokkos::Max<int>(teamResult2), teamResult3);
+
+          Kokkos::single(Kokkos::PerTeam(team), [=]() {
+            teamView(0) = teamResult0;
+            teamView(1) = teamResult1;
+            teamView(2) = teamResult2;
+            teamView(3) = teamResult3;
+          });
+        });
+
+    auto hostView = Kokkos::create_mirror_view_and_copy(
+        Kokkos::DefaultHostExecutionSpace(), teamView);
+
+    if (n == 0) {
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(0));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(1));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::max(), hostView(2));
+      EXPECT_EQ(Kokkos::reduction_identity<int>::sum(), hostView(3));
+    } else {
+      EXPECT_EQ((n * (n + 1) / 2), hostView(0));
+      EXPECT_EQ((n * (n + 1) / 2), hostView(1));
+      EXPECT_EQ(n, hostView(2));
+      EXPECT_EQ(n * n, hostView(3));
+    }
+  }
+};
+
+TEST(TEST_CATEGORY, team_thread_range_combined_reducers) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  if constexpr (std::is_same_v<TEST_EXECSPACE,
+                               Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "team_reduce with a generic reducer is not implemented for "
+                 << TEST_EXECSPACE::name();
+
+#elif defined(KOKKOS_ENABLE_OPENACC)
+  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenACC>)
+    GTEST_SKIP() << "team_reduce with a generic reducer is not implemented for "
+                 << TEST_EXECSPACE::name();
+#endif
+
+  TeamTeamCombinedReducer tester;
+  tester.test_team_thread_range_only_scalars(5);
+  tester.test_team_thread_range_only_builtin(7);
+  tester.test_team_thread_range_combined_reducers(0);
+  tester.test_team_thread_range_combined_reducers(9);
+}
+
+TEST(TEST_CATEGORY, thread_vector_range_combined_reducers) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  if constexpr (std::is_same_v<TEST_EXECSPACE,
+                               Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "team_reduce with a generic reducer is not implemented for "
+                 << TEST_EXECSPACE::name();
+
+#elif defined(KOKKOS_ENABLE_OPENACC)
+  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenACC>)
+    GTEST_SKIP() << "team_reduce with a generic reducer is not implemented for "
+                 << TEST_EXECSPACE::name();
+#endif
+
+  TeamTeamCombinedReducer tester;
+  tester.test_thread_vector_range_only_scalars(5);
+  tester.test_thread_vector_range_only_builtin(7);
+  tester.test_thread_vector_range_combined_reducers(0);
+  tester.test_thread_vector_range_combined_reducers(9);
+}
+
+TEST(TEST_CATEGORY, team_vector_range_combined_reducers) {
+#ifdef KOKKOS_ENABLE_OPENMPTARGET  // FIXME_OPENMPTARGET
+  if constexpr (std::is_same_v<TEST_EXECSPACE,
+                               Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "team_reduce with a generic reducer is not implemented for "
+                 << TEST_EXECSPACE::name();
+#endif
+
+#ifdef KOKKOS_ENABLE_OPENACC  // FIXME_OPENACC
+  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenACC>)
+    GTEST_SKIP() << "team_reduce with a generic reducer is not implemented for "
+                 << TEST_EXECSPACE::name();
+#endif
+
+  TeamTeamCombinedReducer tester;
+  tester.test_team_vector_range_only_scalars(5);
+  tester.test_team_vector_range_only_builtin(7);
+  tester.test_team_vector_range_combined_reducers(0);
+  tester.test_team_vector_range_combined_reducers(9);
+}
+
+#endif
+
+}  // namespace
diff --git a/core/unit_test/TestTeamMDRange.hpp b/core/unit_test/TestTeamMDRange.hpp
index 8ac7e8338c..6e65cde0cf 100644
--- a/core/unit_test/TestTeamMDRange.hpp
+++ b/core/unit_test/TestTeamMDRange.hpp
@@ -1904,6 +1904,13 @@ TEST(TEST_CATEGORY, ThreadVectorMDRangeParallelReduce) {
     GTEST_SKIP() << "skipping because of bug in group_barrier implementation";
 #endif
 
+// FIXME_OPENMPTARGET_CRAY: The unit tests fails correctness.
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_COMPILER_CRAYCLANG)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "Cray compiler fails correctness at runtime with the "
+                    "OpenMPTarget backend.";
+#endif
+
   TestThreadVectorMDRangeParallelReduce<TEST_EXECSPACE>::
       test_parallel_reduce_for_4D_ThreadVectorMDRange<Left>(dims);
   TestThreadVectorMDRangeParallelReduce<TEST_EXECSPACE>::
@@ -1937,6 +1944,13 @@ TEST(TEST_CATEGORY, TeamVectorMDRangeParallelReduce) {
     GTEST_SKIP() << "skipping because of bug in group_barrier implementation";
 #endif
 
+// FIXME_OPENMPTARGET_CRAY: The unit tests fails correctness.
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_COMPILER_CRAYCLANG)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "Cray compiler fails correctness at runtime with the "
+                    "OpenMPTarget backend.";
+#endif
+
   TestTeamVectorMDRangeParallelReduce<TEST_EXECSPACE>::
       test_parallel_reduce_for_4D_TeamVectorMDRange<Left>(dims);
   TestTeamVectorMDRangeParallelReduce<TEST_EXECSPACE>::
diff --git a/core/unit_test/TestTeamReductionScan.hpp b/core/unit_test/TestTeamReductionScan.hpp
index f8f56ad0d8..8bdd5e8432 100644
--- a/core/unit_test/TestTeamReductionScan.hpp
+++ b/core/unit_test/TestTeamReductionScan.hpp
@@ -113,6 +113,10 @@ TEST(TEST_CATEGORY, repeated_team_reduce) {
                     "properly implemented";
 #endif
 
+#ifdef KOKKOS_IMPL_32BIT
+  GTEST_SKIP() << "Failing KOKKOS_IMPL_32BIT";  // FIXME_32BIT
+#endif
+
   TestRepeatedTeamReduce<TEST_EXECSPACE>();
 }
 
diff --git a/core/unit_test/TestTeamTeamSize.hpp b/core/unit_test/TestTeamTeamSize.hpp
index 7a6a4dd581..b4304fc2eb 100644
--- a/core/unit_test/TestTeamTeamSize.hpp
+++ b/core/unit_test/TestTeamTeamSize.hpp
@@ -31,10 +31,6 @@ class MyArray {
   void operator+=(const MyArray& src) {
     for (int i = 0; i < N; i++) values[i] += src.values[i];
   }
-  KOKKOS_INLINE_FUNCTION
-  void operator=(const MyArray& src) {
-    for (int i = 0; i < N; i++) values[i] = src.values[i];
-  }
 };
 
 template <class T, int N, class PolicyType, int S>
diff --git a/core/unit_test/TestVersionMacros.cpp b/core/unit_test/TestVersionMacros.cpp
new file mode 100644
index 0000000000..e18b597310
--- /dev/null
+++ b/core/unit_test/TestVersionMacros.cpp
@@ -0,0 +1,59 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Core.hpp>
+
+#ifndef KOKKOS_VERSION
+static_assert(false, "KOKKOS_VERSION macro is not defined!");
+#endif
+
+#ifndef KOKKOS_VERSION_MAJOR
+static_assert(false, "KOKKOS_VERSION_MAJOR macro is not defined!");
+#endif
+
+#ifndef KOKKOS_VERSION_MINOR
+static_assert(false, "KOKKOS_VERSION_MINOR macro is not defined!");
+#endif
+
+#ifndef KOKKOS_VERSION_PATCH
+static_assert(false, "KOKKOS_VERSION_PATCH macro is not defined!");
+#endif
+
+static_assert(KOKKOS_VERSION == KOKKOS_VERSION_MAJOR * 10000 +
+                                    KOKKOS_VERSION_MINOR * 100 +
+                                    KOKKOS_VERSION_PATCH);
+
+// clang-format off
+static_assert(!KOKKOS_VERSION_LESS            (KOKKOS_VERSION_MAJOR    , KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert(!KOKKOS_VERSION_LESS            (KOKKOS_VERSION_MAJOR - 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert( KOKKOS_VERSION_LESS            (KOKKOS_VERSION_MAJOR + 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+
+static_assert( KOKKOS_VERSION_LESS_EQUAL      (KOKKOS_VERSION_MAJOR    , KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert(!KOKKOS_VERSION_LESS_EQUAL      (KOKKOS_VERSION_MAJOR - 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert( KOKKOS_VERSION_LESS_EQUAL      (KOKKOS_VERSION_MAJOR + 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+
+static_assert(!KOKKOS_VERSION_GREATER         (KOKKOS_VERSION_MAJOR    , KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert( KOKKOS_VERSION_GREATER         (KOKKOS_VERSION_MAJOR - 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert(!KOKKOS_VERSION_GREATER         (KOKKOS_VERSION_MAJOR + 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+
+static_assert( KOKKOS_VERSION_GREATER_EQUAL   (KOKKOS_VERSION_MAJOR    , KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert( KOKKOS_VERSION_GREATER_EQUAL   (KOKKOS_VERSION_MAJOR - 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert(!KOKKOS_VERSION_GREATER_EQUAL   (KOKKOS_VERSION_MAJOR + 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+
+static_assert( KOKKOS_VERSION_EQUAL           (KOKKOS_VERSION_MAJOR    , KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert(!KOKKOS_VERSION_EQUAL           (KOKKOS_VERSION_MAJOR - 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+static_assert(!KOKKOS_VERSION_EQUAL           (KOKKOS_VERSION_MAJOR + 1, KOKKOS_VERSION_MINOR, KOKKOS_VERSION_PATCH));
+// clang-format on
diff --git a/core/unit_test/TestViewAPI_e.hpp b/core/unit_test/TestViewAPI_e.hpp
index df66396ab8..2e416d0320 100644
--- a/core/unit_test/TestViewAPI_e.hpp
+++ b/core/unit_test/TestViewAPI_e.hpp
@@ -100,7 +100,7 @@ void test_left_stride(Extents... extents) {
   size_t expected_stride = 1;
   size_t all_strides[view_type::rank + 1];
   view.stride(all_strides);
-  for (int i = 0; i < view_type::rank; ++i) {
+  for (size_t i = 0; i < view_type::rank; ++i) {
     ASSERT_EQ(view.stride(i), expected_stride);
     ASSERT_EQ(all_strides[i], expected_stride);
     expected_stride *= view.extent(i);
@@ -115,7 +115,7 @@ void test_right_stride(Extents... extents) {
   size_t expected_stride = 1;
   size_t all_strides[view_type::rank + 1];
   view.stride(all_strides);
-  for (int ri = 0; ri < view_type::rank; ++ri) {
+  for (size_t ri = 0; ri < view_type::rank; ++ri) {
     auto i = view_type::rank - 1 - ri;
     ASSERT_EQ(view.stride(i), expected_stride);
     ASSERT_EQ(all_strides[i], expected_stride);
diff --git a/core/unit_test/TestViewMapping_a.hpp b/core/unit_test/TestViewMapping_a.hpp
index 9df044ec7a..9173f0d431 100644
--- a/core/unit_test/TestViewMapping_a.hpp
+++ b/core/unit_test/TestViewMapping_a.hpp
@@ -713,7 +713,7 @@ void test_view_mapping() {
                               typename Space::memory_space>::value));
     ASSERT_TRUE((std::is_same<typename T::reference_type, int&>::value));
 
-    ASSERT_EQ(T::Rank, 1);
+    ASSERT_EQ(T::rank, size_t(1));
 
     ASSERT_TRUE((std::is_same<typename C::data_type, const int*>::value));
     ASSERT_TRUE((std::is_same<typename C::const_data_type, const int*>::value));
@@ -734,7 +734,7 @@ void test_view_mapping() {
                               typename Space::memory_space>::value));
     ASSERT_TRUE((std::is_same<typename C::reference_type, const int&>::value));
 
-    ASSERT_EQ(C::Rank, 1);
+    ASSERT_EQ(C::rank, size_t(1));
 
     ASSERT_EQ(vr1.extent(0), size_t(N));
 
@@ -781,7 +781,7 @@ void test_view_mapping() {
     ASSERT_TRUE((std::is_same<typename T::memory_space,
                               typename Space::memory_space>::value));
     ASSERT_TRUE((std::is_same<typename T::reference_type, int&>::value));
-    ASSERT_EQ(T::Rank, 1);
+    ASSERT_EQ(T::rank, size_t(1));
 
     ASSERT_EQ(vr1.extent(0), size_t(N));
 
@@ -1038,10 +1038,7 @@ void test_view_mapping() {
     ASSERT_EQ(a.use_count(), 1);
     ASSERT_EQ(b.use_count(), 0);
 
-// TODO: a.use_count() and x.use_count() are 0 with the asynchronous HPX
-// backend. Why?
-#if !defined(KOKKOS_ENABLE_CUDA_LAMBDA) && \
-    !(defined(KOKKOS_ENABLE_HPX) && defined(KOKKOS_ENABLE_HPX_ASYNC_DISPATCH))
+#if !defined(KOKKOS_ENABLE_CUDA) || !defined(KOKKOS_ENABLE_CUDA_LAMBDA)
     // Cannot launch host lambda when CUDA lambda is enabled.
 
     using host_exec_space =
diff --git a/core/unit_test/TestViewMapping_subview.hpp b/core/unit_test/TestViewMapping_subview.hpp
index 069ad09da9..888abf4ca8 100644
--- a/core/unit_test/TestViewMapping_subview.hpp
+++ b/core/unit_test/TestViewMapping_subview.hpp
@@ -100,8 +100,7 @@ struct TestViewMappingSubview {
 
   KOKKOS_INLINE_FUNCTION
   void operator()(const int, long& error_count) const {
-    auto Ad = Kokkos::subview<Kokkos::MemoryUnmanaged>(
-        Aa, Kokkos::pair<int, int>(1, AN - 1));
+    auto Ad = Kokkos::subview(Aa, Kokkos::pair<int, int>(1, AN - 1));
 
     for (int i = 1; i < AN - 1; ++i)
       if (&Aa[i] != &Ab[i - 1]) ++error_count;
diff --git a/core/unit_test/TestViewMemoryAccessViolation.hpp b/core/unit_test/TestViewMemoryAccessViolation.hpp
index cdd90426eb..d8febd2ba1 100644
--- a/core/unit_test/TestViewMemoryAccessViolation.hpp
+++ b/core/unit_test/TestViewMemoryAccessViolation.hpp
@@ -143,7 +143,7 @@ void test_view_memory_access_violations_from_device() {
 }
 
 // FIXME_SYCL
-#if !(defined(KOKKOS_COMPILER_INTEL) && defined(KOKKOS_ENABLE_SYCL))
+#if !(defined(KOKKOS_COMPILER_INTEL_LLVM) && defined(KOKKOS_ENABLE_SYCL))
 TEST(TEST_CATEGORY_DEATH, view_memory_access_violations_from_host) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
diff --git a/core/unit_test/TestViewRank.cpp b/core/unit_test/TestViewRank.cpp
new file mode 100644
index 0000000000..7ea11afca3
--- /dev/null
+++ b/core/unit_test/TestViewRank.cpp
@@ -0,0 +1,63 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Core.hpp>
+
+namespace {
+
+template <class View, size_t Rank, size_t RankDynamic>
+constexpr bool test_view_rank_and_dynamic_rank() {
+  static_assert(View::rank == Rank);
+  static_assert(View::rank() == Rank);
+  static_assert(View::rank_dynamic == RankDynamic);
+  static_assert(View::rank_dynamic() == RankDynamic);
+  static_assert(std::is_convertible_v<decltype(View::rank), size_t>);
+  static_assert(std::is_same_v<decltype(View::rank()), size_t>);
+  static_assert(std::is_convertible_v<decltype(View::rank_dynamic), size_t>);
+  static_assert(std::is_same_v<decltype(View::rank_dynamic()), size_t>);
+  auto rank = View::rank;  // not an integral type in contrast to Kokkos version
+  // less than 4.0.01
+  static_assert(!std::is_integral_v<decltype(rank)>);
+  auto rank_preferred = View::rank();  // since 4.0.01
+  static_assert(std::is_same_v<decltype(rank_preferred), size_t>);
+  (void)rank;
+  (void)rank_preferred;
+  return true;
+}
+
+// clang-format off
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<long long>, 0, 0>());
+
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<unsigned[1]>, 1, 0>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<unsigned * >, 1, 1>());
+
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<double[1][2]>, 2, 0>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<double * [2]>, 2, 1>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<double *  * >, 2, 2>());
+
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<float[1][2][3]>, 3, 0>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<float * [2][3]>, 3, 1>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<float *  * [3]>, 3, 2>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<float *  *  * >, 3, 3>());
+
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<int[1][2][3][4]>, 4, 0>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<int * [2][3][4]>, 4, 1>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<int *  * [3][4]>, 4, 2>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<int *  *  * [4]>, 4, 3>());
+static_assert(test_view_rank_and_dynamic_rank<Kokkos::View<int *  *  *  * >, 4, 4>());
+//clang-format on
+
+}  // namespace
diff --git a/core/unit_test/TestViewSubview.hpp b/core/unit_test/TestViewSubview.hpp
index eb0050a682..386887d923 100644
--- a/core/unit_test/TestViewSubview.hpp
+++ b/core/unit_test/TestViewSubview.hpp
@@ -487,8 +487,8 @@ void test_left_1(bool use_constr) {
       for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
         for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
           for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
-            ASSERT_TRUE(&sx4(i0, i1, i2, i3) ==
-                        &x8(0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3));
+            ASSERT_EQ(&sx4(i0, i1, i2, i3),
+                      &x8(0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3));
           }
   }
 }
@@ -559,8 +559,8 @@ void test_left_2() {
       for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
         for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
           for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
-            ASSERT_TRUE(&sx4(i0, i1, i2, i3) ==
-                        &x4(1 + i0, 1 + i1, 0 + i2, 2 + i3));
+            ASSERT_EQ(&sx4(i0, i1, i2, i3),
+                      &x4(1 + i0, 1 + i1, 0 + i2, 2 + i3));
           }
   }
 }
@@ -769,8 +769,8 @@ void test_right_1(bool use_constr) {
       for (int i1 = 0; i1 < (int)sx4.extent(1); ++i1)
         for (int i2 = 0; i2 < (int)sx4.extent(2); ++i2)
           for (int i3 = 0; i3 < (int)sx4.extent(3); ++i3) {
-            ASSERT_TRUE(&sx4(i0, i1, i2, i3) ==
-                        &x8(0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3));
+            ASSERT_EQ(&sx4(i0, i1, i2, i3),
+                      &x8(0, 0 + i0, 1, 1 + i1, 1, 0 + i2, 2, 2 + i3));
           }
   }
 }
@@ -865,7 +865,7 @@ struct FillView_3D {
   using exec_t = typename Space::execution_space;
   using view_t = Kokkos::View<int***, Layout, Space>;
   using rank_t = Kokkos::Rank<
-      view_t::Rank,
+      view_t::rank,
       std::is_same<Layout, Kokkos::LayoutLeft>::value ? Kokkos::Iterate::Left
                                                       : Kokkos::Iterate::Right,
       std::is_same<Layout, Kokkos::LayoutLeft>::value ? Kokkos::Iterate::Left
@@ -893,7 +893,7 @@ struct FillView_4D {
   using exec_t = typename Space::execution_space;
   using view_t = Kokkos::View<int****, Layout, Space>;
   using rank_t = Kokkos::Rank<
-      view_t::Rank,
+      view_t::rank,
       std::is_same<Layout, Kokkos::LayoutLeft>::value ? Kokkos::Iterate::Left
                                                       : Kokkos::Iterate::Right,
       std::is_same<Layout, Kokkos::LayoutLeft>::value ? Kokkos::Iterate::Left
@@ -922,7 +922,7 @@ struct FillView_5D {
   using exec_t = typename Space::execution_space;
   using view_t = Kokkos::View<int*****, Layout, Space>;
   using rank_t = Kokkos::Rank<
-      view_t::Rank,
+      view_t::rank,
       std::is_same<Layout, Kokkos::LayoutLeft>::value ? Kokkos::Iterate::Left
                                                       : Kokkos::Iterate::Right,
       std::is_same<Layout, Kokkos::LayoutLeft>::value ? Kokkos::Iterate::Left
@@ -1471,30 +1471,30 @@ void test_3d_subview_5d_impl_layout() {
 }
 
 inline void test_subview_legal_args_right() {
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::ALL_t, Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::ALL_t, Kokkos::ALL_t, int, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, Kokkos::ALL_t, int, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>, int, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::pair<int, int>, int, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int, int>::value));
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t, int,
+                   int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1502,98 +1502,101 @@ inline void test_subview_legal_args_right() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int, int>::value));
+                   Kokkos::ALL_t, int, int>::value));
 
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             int, Kokkos::ALL_t, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             int, Kokkos::ALL_t, Kokkos::ALL_t, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             int, Kokkos::pair<int, int>, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::pair<int, int>, int, Kokkos::ALL_t, Kokkos::ALL_t,
+                   int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
                    Kokkos::pair<int, int>, int, Kokkos::pair<int, int>,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int>::value));
 
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::ALL_t, int, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::ALL_t, int, Kokkos::ALL_t, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, int, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
-                   Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int, Kokkos::ALL_t,
+                   int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int,
                    Kokkos::pair<int, int>, int>::value));
 
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::ALL_t, Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::ALL_t, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+          Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1601,32 +1604,35 @@ inline void test_subview_legal_args_right() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::ALL_t, int>::value));
 
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::ALL_t, int, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
-                   Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
-                   Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, int, Kokkos::ALL_t>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, int, Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, int, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int,
                    Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
+          Kokkos::pair<int, int>, Kokkos::ALL_t, int, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
@@ -1634,32 +1640,31 @@ inline void test_subview_legal_args_right() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t>::value));
 
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::ALL_t, Kokkos::pair<int, int>,
                    Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                Kokkos::ALL_t, Kokkos::pair<int, int>, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(1,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
+                Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1667,36 +1672,35 @@ inline void test_subview_legal_args_right() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 5, 0, int, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t>::value));
 
   ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::ALL_t>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::ALL_t,
+             Kokkos::ALL_t, Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(1,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
+                Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, Kokkos::ALL_t>::value));
+  ASSERT_EQ(
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutRight, Kokkos::LayoutRight, 3, 3, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1704,34 +1708,30 @@ inline void test_subview_legal_args_right() {
 }
 
 inline void test_subview_legal_args_left() {
+  ASSERT_EQ(1,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                Kokkos::ALL_t, Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(1,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                Kokkos::ALL_t, Kokkos::ALL_t, int, int>::value));
   ASSERT_EQ(
-      1,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int, int>::value));
-  ASSERT_EQ(
-      1,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int, int>::value));
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, Kokkos::pair<int, int>, int, int>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                Kokkos::pair<int, int>, Kokkos::ALL_t, int, int>::value));
   ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int, int>::value));
   ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int, int>::value));
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t, int,
+                   int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1739,106 +1739,101 @@ inline void test_subview_legal_args_left() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int, int>::value));
-
+                   Kokkos::ALL_t, int, int>::value));
+
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                int, Kokkos::ALL_t, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                int, Kokkos::ALL_t, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          int, Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          int, Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          int, Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int>::value));
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+             int, Kokkos::pair<int, int>, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                int, Kokkos::pair<int, int>, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::pair<int, int>, int, Kokkos::ALL_t, Kokkos::ALL_t,
+                   int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
                    Kokkos::pair<int, int>, int, Kokkos::pair<int, int>,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, int, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int>::value));
 
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                Kokkos::ALL_t, int, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                Kokkos::ALL_t, int, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::Impl::ALL_t, int, Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::Impl::ALL_t, int, Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::Impl::ALL_t,
-          Kokkos::pair<int, int>, int, Kokkos::Impl::ALL_t, int>::value));
+      0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
+             Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+             Kokkos::pair<int, int>, int, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, Kokkos::ALL_t,
+                Kokkos::pair<int, int>, int, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int, Kokkos::ALL_t,
+                   int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
                    Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int,
                    Kokkos::pair<int, int>, int>::value));
 
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::ALL_t, Kokkos::pair<int, int>, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::ALL_t, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::pair<int, int>, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>, int>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t, int>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+          Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t, int>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1846,32 +1841,35 @@ inline void test_subview_legal_args_left() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t, int>::value));
+                   Kokkos::ALL_t, int>::value));
 
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::ALL_t, int, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
-                   Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
-                   Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>, int,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, int, Kokkos::ALL_t>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, int, Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, Kokkos::ALL_t,
+          Kokkos::pair<int, int>, int, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t, int,
                    Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t, int,
-                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(
+      0,
+      (Kokkos::Impl::SubviewLegalArgsCompileTime<
+          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
+          Kokkos::pair<int, int>, Kokkos::ALL_t, int, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
@@ -1879,32 +1877,31 @@ inline void test_subview_legal_args_left() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>, int,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t>::value));
 
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
+                   Kokkos::ALL_t, Kokkos::pair<int, int>,
                    Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                Kokkos::ALL_t, Kokkos::pair<int, int>, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
-                   Kokkos::Impl::ALL_t, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
                    Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
-                   Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
+                Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -1912,40 +1909,35 @@ inline void test_subview_legal_args_left() {
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 5, 0, int, int,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t>::value));
 
-  ASSERT_EQ(
-      1,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
-          Kokkos::Impl::ALL_t, Kokkos::pair<int, int>>::value));
-  ASSERT_EQ(
-      1,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
-          Kokkos::Impl::ALL_t, Kokkos::Impl::ALL_t>::value));
+  ASSERT_EQ(1,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::ALL_t,
+                Kokkos::ALL_t, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::pair<int, int>>::value));
+                   Kokkos::ALL_t, Kokkos::ALL_t, Kokkos::ALL_t>::value));
   ASSERT_EQ(1, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
-                   Kokkos::pair<int, int>, Kokkos::Impl::ALL_t,
-                   Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
-          Kokkos::pair<int, int>, Kokkos::Impl::ALL_t>::value));
-  ASSERT_EQ(
-      0,
-      (Kokkos::Impl::SubviewLegalArgsCompileTime<
-          Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::Impl::ALL_t,
-          Kokkos::pair<int, int>, Kokkos::pair<int, int>>::value));
+                   Kokkos::pair<int, int>, Kokkos::ALL_t,
+                   Kokkos::pair<int, int>>::value));
+  ASSERT_EQ(1,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
+                Kokkos::pair<int, int>, Kokkos::ALL_t, Kokkos::ALL_t>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::ALL_t,
+                Kokkos::pair<int, int>, Kokkos::ALL_t>::value));
+  ASSERT_EQ(0,
+            (Kokkos::Impl::SubviewLegalArgsCompileTime<
+                Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0, Kokkos::ALL_t,
+                Kokkos::pair<int, int>, Kokkos::pair<int, int>>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
-                   Kokkos::Impl::ALL_t>::value));
+                   Kokkos::ALL_t>::value));
   ASSERT_EQ(0, (Kokkos::Impl::SubviewLegalArgsCompileTime<
                    Kokkos::LayoutLeft, Kokkos::LayoutLeft, 3, 3, 0,
                    Kokkos::pair<int, int>, Kokkos::pair<int, int>,
@@ -2118,15 +2110,33 @@ void test_unmanaged_subview_reset() {
 template <std::underlying_type_t<Kokkos::MemoryTraitsFlags> MTF>
 struct TestSubviewMemoryTraitsConstruction {
   void operator()() const noexcept {
-    using view_type          = Kokkos::View<double*, Kokkos::HostSpace>;
-    using size_type          = view_type::size_type;
     using memory_traits_type = Kokkos::MemoryTraits<MTF>;
-
-    view_type v("v", 7);
+    using view_type =
+        Kokkos::View<double*, Kokkos::HostSpace, memory_traits_type>;
+    using size_type = typename view_type::size_type;
+
+    // Create a managed View first and then apply the desired memory traits to
+    // an unmanaged version of it since a managed View can't use the Unmanaged
+    // trait.
+    Kokkos::View<double*, Kokkos::HostSpace> v_original("v", 7);
+    view_type v(v_original.data(), v_original.size());
     for (size_type i = 0; i != v.size(); ++i) v[i] = static_cast<double>(i);
 
     std::pair<int, int> range(3, 5);
-    auto sv = Kokkos::subview<memory_traits_type>(v, range);
+    auto sv = Kokkos::subview(v, range);
+
+    // check that the subview memory traits are the same as the original view
+    // (with the Aligned trait stripped).
+    using view_memory_traits    = typename decltype(v)::memory_traits;
+    using subview_memory_traits = typename decltype(sv)::memory_traits;
+    static_assert(view_memory_traits::impl_value ==
+                  memory_traits_type::impl_value);
+    if constexpr (memory_traits_type::is_aligned)
+      static_assert(subview_memory_traits::impl_value + Kokkos::Aligned ==
+                    memory_traits_type::impl_value);
+    else
+      static_assert(subview_memory_traits::impl_value ==
+                    memory_traits_type::impl_value);
 
     ASSERT_EQ(2u, sv.size());
     EXPECT_EQ(3., sv[0]);
@@ -2140,6 +2150,7 @@ inline void test_subview_memory_traits_construction() {
   // RandomAccess (2)
   // Atomic (4)
   // Restricted (8)
+  // Aligned (16)
   TestSubviewMemoryTraitsConstruction<0>()();
   TestSubviewMemoryTraitsConstruction<1>()();
   TestSubviewMemoryTraitsConstruction<2>()();
@@ -2156,6 +2167,22 @@ inline void test_subview_memory_traits_construction() {
   TestSubviewMemoryTraitsConstruction<13>()();
   TestSubviewMemoryTraitsConstruction<14>()();
   TestSubviewMemoryTraitsConstruction<15>()();
+  TestSubviewMemoryTraitsConstruction<16>()();
+  TestSubviewMemoryTraitsConstruction<17>()();
+  TestSubviewMemoryTraitsConstruction<18>()();
+  TestSubviewMemoryTraitsConstruction<19>()();
+  TestSubviewMemoryTraitsConstruction<20>()();
+  TestSubviewMemoryTraitsConstruction<21>()();
+  TestSubviewMemoryTraitsConstruction<22>()();
+  TestSubviewMemoryTraitsConstruction<23>()();
+  TestSubviewMemoryTraitsConstruction<24>()();
+  TestSubviewMemoryTraitsConstruction<25>()();
+  TestSubviewMemoryTraitsConstruction<26>()();
+  TestSubviewMemoryTraitsConstruction<27>()();
+  TestSubviewMemoryTraitsConstruction<28>()();
+  TestSubviewMemoryTraitsConstruction<29>()();
+  TestSubviewMemoryTraitsConstruction<30>()();
+  TestSubviewMemoryTraitsConstruction<31>()();
 }
 
 //----------------------------------------------------------------------------
diff --git a/core/unit_test/UnitTest_DeviceAndThreads.cpp b/core/unit_test/UnitTest_DeviceAndThreads.cpp
index 2b3c90ef2a..b522ac3e69 100644
--- a/core/unit_test/UnitTest_DeviceAndThreads.cpp
+++ b/core/unit_test/UnitTest_DeviceAndThreads.cpp
@@ -38,21 +38,24 @@ int get_device_count() {
 }
 
 int get_device_id() {
+  int device_id;
 #if defined(KOKKOS_ENABLE_CUDA)
-  int device;
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDevice(&device));
-  return device;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDevice(&device_id));
 #elif defined(KOKKOS_ENABLE_HIP)
-  int device_id;
   KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDevice(&device_id));
-  return device_id;
 #elif defined(KOKKOS_ENABLE_OPENMPTARGET)
-  return omp_get_device_num();
+  device_id = omp_get_device_num();
 #elif defined(KOKKOS_ENABLE_OPENACC)
-  return acc_get_device_num(acc_get_device_type());
+  device_id = acc_get_device_num(acc_get_device_type());
+#elif defined(KOKKOS_ENABLE_SYCL)
+  // FIXME_SYCL ?
+  assert(false);
+  return -2;
 #else
-  return -1;
+  device_id = -1;
 #endif
+  assert(device_id == Kokkos::device_id());
+  return device_id;
 }
 
 int get_max_threads() {
@@ -66,7 +69,9 @@ int get_max_threads() {
 }
 
 int get_num_threads() {
-  return Kokkos::DefaultHostExecutionSpace().concurrency();
+  int const num_threads = Kokkos::DefaultHostExecutionSpace().concurrency();
+  assert(num_threads == Kokkos::num_threads());
+  return num_threads;
 }
 
 int get_disable_warnings() { return !Kokkos::show_warnings(); }
diff --git a/core/unit_test/category_files/TestHIP_Category.hpp b/core/unit_test/category_files/TestHIP_Category.hpp
index adaed3281a..6086f7e05b 100644
--- a/core/unit_test/category_files/TestHIP_Category.hpp
+++ b/core/unit_test/category_files/TestHIP_Category.hpp
@@ -23,5 +23,6 @@
 #define TEST_CATEGORY_NUMBER 6
 #define TEST_CATEGORY_DEATH hip_DeathTest
 #define TEST_EXECSPACE Kokkos::HIP
+#define TEST_CATEGORY_FIXTURE(name) hip_##name
 
 #endif
diff --git a/core/unit_test/cuda/TestCuda_Spaces.cpp b/core/unit_test/cuda/TestCuda_Spaces.cpp
index 407aa60a0a..d71984a75a 100644
--- a/core/unit_test/cuda/TestCuda_Spaces.cpp
+++ b/core/unit_test/cuda/TestCuda_Spaces.cpp
@@ -374,7 +374,8 @@ template <typename View>
 View create_view() {
   using execution_space = typename View::execution_space;
   View view("", 10);
-  InitFunctor iota(view);
+  // MSVC+CUDA errors on CTAD here
+  InitFunctor<View> iota(view);
   Kokkos::parallel_for("test_view_subview_const_randomaccess",
                        Kokkos::RangePolicy<execution_space>(0, view.extent(0)),
                        iota);
diff --git a/core/unit_test/default/TestDefaultDeviceTypeViewAPI.cpp b/core/unit_test/default/TestDefaultDeviceTypeViewAPI.cpp
index 96fffa0dc7..d81c71499f 100644
--- a/core/unit_test/default/TestDefaultDeviceTypeViewAPI.cpp
+++ b/core/unit_test/default/TestDefaultDeviceTypeViewAPI.cpp
@@ -113,11 +113,17 @@ TYPED_TEST(TestViewAPI, sizes) {
   static_assert(view_t::rank == TestFixture::expected_rank,
                 "TestViewAPI: Error: rank mismatch");
   size_t expected_span = 1;
-  for (int r = 0; r < view_t::rank; r++) expected_span *= this->all_sizes[r];
+  // avoid pointless comparison of unsigned integer with zero warning
+  if constexpr (view_t::rank > 0) {
+    for (size_t r = 0; r < view_t::rank; r++)
+      expected_span *= this->all_sizes[r];
+  }
 
   EXPECT_EQ(expected_span, a.span());
-  for (int r = 0; r < view_t::rank; r++) {
-    EXPECT_EQ(this->all_sizes[r], a.extent(r));
-    EXPECT_EQ(this->all_sizes[r], size_t(a.extent_int(r)));
+  if constexpr (view_t::rank > 0) {
+    for (size_t r = 0; r < view_t::rank; r++) {
+      EXPECT_EQ(this->all_sizes[r], a.extent(r));
+      EXPECT_EQ(this->all_sizes[r], size_t(a.extent_int(r)));
+    }
   }
 }
diff --git a/core/src/dummy.cpp b/core/unit_test/hip/TestHIP_Graph.cpp
similarity index 73%
rename from core/src/dummy.cpp
rename to core/unit_test/hip/TestHIP_Graph.cpp
index 929380b6c3..405cb76c64 100644
--- a/core/src/dummy.cpp
+++ b/core/unit_test/hip/TestHIP_Graph.cpp
@@ -14,11 +14,5 @@
 //
 //@HEADER
 
-namespace Kokkos {
-namespace AvoidCompilerWarnings {
-int dontComplain() {
-  // keep the compiler from complaining about emptiness
-  return 0;
-}
-}  // namespace AvoidCompilerWarnings
-}  // namespace Kokkos
+#include <TestHIP_Category.hpp>
+#include <TestGraph.hpp>
diff --git a/core/unit_test/hip/TestHIP_ScanUnit.cpp b/core/unit_test/hip/TestHIP_ScanUnit.cpp
index 0b46d9742a..fe3a14d2b8 100644
--- a/core/unit_test/hip/TestHIP_ScanUnit.cpp
+++ b/core/unit_test/hip/TestHIP_ScanUnit.cpp
@@ -33,7 +33,8 @@ __global__ void start_intra_block_scan()
   DummyFunctor f;
   typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN,
-      Kokkos::RangePolicy<Kokkos::HIP>, DummyFunctor>::Reducer reducer(&f);
+      Kokkos::RangePolicy<Kokkos::HIP>, DummyFunctor,
+      DummyFunctor::value_type>::Reducer reducer(f);
   Kokkos::Impl::hip_intra_block_reduce_scan<true>(reducer, values);
 
   __syncthreads();
diff --git a/core/unit_test/hpx/TestHPX_InParallel.cpp b/core/unit_test/hpx/TestHPX_InParallel.cpp
new file mode 100644
index 0000000000..438c81c880
--- /dev/null
+++ b/core/unit_test/hpx/TestHPX_InParallel.cpp
@@ -0,0 +1,183 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
+
+// These tests specifically check that work dispatched to independent instances
+// is synchronized correctly on fences. A previous bug that this protects
+// against is work being mistakenly dispatched to the default instance, but the
+// fence fencing the independent instance. In that case these tests will fail.
+
+namespace {
+inline constexpr int n = 1 << 10;
+
+TEST(hpx, in_parallel_for_range_policy) {
+  Kokkos::View<bool *, Kokkos::Experimental::HPX> a("a", n);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::RangePolicy<Kokkos::Experimental::HPX> policy(0, n);
+  Kokkos::parallel_for(
+      "parallel_for_range_policy", policy, KOKKOS_LAMBDA(const int i) {
+        a(i) = Kokkos::Experimental::HPX::in_parallel();
+      });
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_TRUE(a(i));
+  }
+}
+
+TEST(hpx, in_parallel_for_mdrange_policy) {
+  Kokkos::View<bool *, Kokkos::Experimental::HPX> a("a", n);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::MDRangePolicy<Kokkos::Experimental::HPX, Kokkos::Rank<2>> policy(
+      {0, 0}, {n, 1});
+  Kokkos::parallel_for(
+      "parallel_for_mdrange_policy", policy,
+      KOKKOS_LAMBDA(const int i, const int) {
+        a(i) = Kokkos::Experimental::HPX::in_parallel();
+      });
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_TRUE(a(i));
+  }
+}
+
+TEST(hpx, in_parallel_for_team_policy) {
+  Kokkos::View<bool *, Kokkos::Experimental::HPX> a("a", n);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::TeamPolicy<Kokkos::Experimental::HPX> policy(n, 1);
+  using member_type = decltype(policy)::member_type;
+  Kokkos::parallel_for(
+      "parallel_for_team_policy", policy,
+      KOKKOS_LAMBDA(const member_type &handle) {
+        a(handle.league_rank()) = Kokkos::Experimental::HPX::in_parallel();
+      });
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_TRUE(a(i));
+  }
+}
+
+TEST(hpx, in_parallel_reduce_range_policy) {
+  Kokkos::View<int, Kokkos::Experimental::HPX> a("a");
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::RangePolicy<Kokkos::Experimental::HPX> policy(0, n);
+  Kokkos::parallel_reduce(
+      "parallel_reduce_range_policy", policy,
+      KOKKOS_LAMBDA(const int, int &x) {
+        if (!Kokkos::Experimental::HPX::in_parallel()) {
+          ++x;
+        }
+      },
+      a);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  ASSERT_EQ(a(), 0);
+}
+
+TEST(hpx, in_parallel_reduce_mdrange_policy) {
+  Kokkos::View<int, Kokkos::Experimental::HPX> a("a");
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::MDRangePolicy<Kokkos::Experimental::HPX, Kokkos::Rank<2>> policy(
+      {0, 0}, {n, 1});
+  Kokkos::parallel_reduce(
+      "parallel_reduce_mdrange_policy", policy,
+      KOKKOS_LAMBDA(const int, const int, int &x) {
+        if (!Kokkos::Experimental::HPX::in_parallel()) {
+          ++x;
+        }
+      },
+      a);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  ASSERT_EQ(a(), 0);
+}
+
+TEST(hpx, in_parallel_reduce_team_policy) {
+  Kokkos::View<int, Kokkos::Experimental::HPX> a("a");
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::TeamPolicy<Kokkos::Experimental::HPX> policy(n, 1);
+  using member_type = decltype(policy)::member_type;
+  Kokkos::parallel_reduce(
+      "parallel_reduce_team_policy", policy,
+      KOKKOS_LAMBDA(const member_type &, int &x) {
+        if (!Kokkos::Experimental::HPX::in_parallel()) {
+          ++x;
+        }
+      },
+      a);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  ASSERT_EQ(a(), 0);
+}
+
+TEST(hpx, in_parallel_scan_range_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  Kokkos::RangePolicy<Kokkos::Experimental::HPX> policy(0, n);
+  Kokkos::parallel_scan(
+      "parallel_scan_range_policy", policy,
+      KOKKOS_LAMBDA(const int, int &x, bool) {
+        if (!Kokkos::Experimental::HPX::in_parallel()) {
+          ++x;
+        }
+      },
+      a);
+
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+  Kokkos::fence();
+  ASSERT_FALSE(Kokkos::Experimental::HPX::in_parallel());
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a(i), 0);
+  }
+}
+}  // namespace
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstances.cpp b/core/unit_test/hpx/TestHPX_IndependentInstances.cpp
index 8f349cf804..7ca48afeff 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstances.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstances.cpp
@@ -20,7 +20,6 @@
 #include <hpx/config.hpp>
 #include <hpx/local/future.hpp>
 
-#ifdef KOKKOS_ENABLE_HPX_ASYNC_DISPATCH
 #ifndef HPX_COMPUTE_DEVICE_CODE
 
 namespace {
@@ -99,7 +98,7 @@ TEST(hpx, independent_instances) {
           Kokkos::Experimental::WorkItemProperty::HintLightWeight),
       FunctorInitConstant(v1, c));
 
-  Kokkos::Experimental::HPX hpx2(hpx1.impl_get_future());
+  Kokkos::Experimental::HPX hpx2(hpx1.get_sender());
   Kokkos::parallel_for(
       "Test::hpx::independent_instances::add",
       Kokkos::Experimental::require(
@@ -107,7 +106,7 @@ TEST(hpx, independent_instances) {
           Kokkos::Experimental::WorkItemProperty::HintLightWeight),
       FunctorAdd(v1, v2, d));
 
-  Kokkos::Experimental::HPX hpx3(hpx1.impl_get_future());
+  Kokkos::Experimental::HPX hpx3(hpx1.get_sender());
   Kokkos::parallel_for(
       "Test::hpx::independent_instances::add_index",
       Kokkos::Experimental::require(
@@ -115,12 +114,8 @@ TEST(hpx, independent_instances) {
           Kokkos::Experimental::WorkItemProperty::HintLightWeight),
       FunctorAddIndex(v1, v3));
 
-  // NOTE: This monstrosity is used to collapse a future<tuple<future<void>,
-  // future<void>>> (return type of when_all) into a future<void> which is
-  // ready whenever the un-collapsed future would've been ready. HPX does not
-  // currently have the functionality to collapse this automatically.
-  Kokkos::Experimental::HPX hpx4(hpx::get<0>(hpx::split_future(
-      hpx::when_all(hpx2.impl_get_future(), hpx3.impl_get_future()))));
+  Kokkos::Experimental::HPX hpx4(hpx::execution::experimental::when_all(
+      hpx2.get_sender(), hpx3.get_sender()));
   Kokkos::parallel_for(
       "Test::hpx::independent_instances::pointwise_sum",
       Kokkos::Experimental::require(
@@ -137,11 +132,6 @@ TEST(hpx, independent_instances) {
 
   hpx4.fence();
 
-  ASSERT_EQ(true, hpx1.impl_get_future().is_ready());
-  ASSERT_EQ(true, hpx2.impl_get_future().is_ready());
-  ASSERT_EQ(true, hpx3.impl_get_future().is_ready());
-  ASSERT_EQ(true, hpx4.impl_get_future().is_ready());
-
   const int expected_sum = n * (2 * c + d) + (n * (n - 1) / 2);
   ASSERT_EQ(expected_sum, sum_v());
 }
@@ -149,4 +139,3 @@ TEST(hpx, independent_instances) {
 }  // namespace
 
 #endif
-#endif
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp b/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
index 177d87c1c8..3759d85438 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
@@ -17,18 +17,20 @@
 #include <Kokkos_Core.hpp>
 #include <TestHPX_Category.hpp>
 
-#include <hpx/local/future.hpp>
-
-#ifdef KOKKOS_ENABLE_HPX_ASYNC_DISPATCH
+#include <hpx/local/execution.hpp>
 
 namespace {
 
 TEST(hpx, independent_instances_delayed_execution) {
   Kokkos::View<bool, Kokkos::Experimental::HPX> ran("ran");
-  hpx::lcos::local::promise<void> p;
-  hpx::shared_future<void> f = p.get_future();
 
-  Kokkos::Experimental::HPX hpx(f);
+  // Create a sender that will call set_value on a receiver after a delay.
+  hpx::execution::experimental::unique_any_sender<> s{
+      hpx::execution::experimental::schedule(
+          hpx::execution::experimental::thread_pool_scheduler{}) |
+      hpx::execution::experimental::then(
+          [] { hpx::this_thread::sleep_for(std::chrono::milliseconds(500)); })};
+  Kokkos::Experimental::HPX hpx(std::move(s));
   Kokkos::parallel_for(
       "Test::hpx::independent_instances::delay_execution",
       Kokkos::Experimental::require(
@@ -36,15 +38,13 @@ TEST(hpx, independent_instances_delayed_execution) {
           Kokkos::Experimental::WorkItemProperty::HintLightWeight),
       KOKKOS_LAMBDA(int) { ran() = true; });
 
+#if defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
   ASSERT_FALSE(ran());
-  ASSERT_FALSE(hpx.impl_get_future().is_ready());
-
-  p.set_value();
-
+#else
+  ASSERT_TRUE(ran());
+#endif
   hpx.fence();
-  ASSERT_TRUE(hpx.impl_get_future().is_ready());
+  ASSERT_TRUE(ran());
 }
 
 }  // namespace
-
-#endif
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp b/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp
index 6441666e64..2c9b50f049 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp
@@ -17,9 +17,7 @@
 #include <Kokkos_Core.hpp>
 #include <TestHPX_Category.hpp>
 
-#include <hpx/local/future.hpp>
-
-#ifdef KOKKOS_ENABLE_HPX_ASYNC_DISPATCH
+#include <hpx/local/execution.hpp>
 
 namespace {
 
@@ -59,25 +57,24 @@ TEST(hpx, independent_instances_instance_ids) {
   ASSERT_EQ(hpx_independent1.impl_instance_id(),
             hpx_independent4.impl_instance_id());
 
-  hpx::shared_future<void> f = hpx::make_ready_future<void>();
-  Kokkos::Experimental::HPX hpx_independent_future1(f);
-  Kokkos::Experimental::HPX hpx_independent_future2 = hpx_independent_future1;
-  Kokkos::Experimental::HPX hpx_independent_future3{hpx_independent_future1};
-  Kokkos::Experimental::HPX hpx_independent_future4;
-  hpx_independent_future4 = hpx_independent_future1;
+  Kokkos::Experimental::HPX hpx_independent_sender1(
+      hpx::execution::experimental::unique_any_sender<>{
+          hpx::execution::experimental::just()});
+  Kokkos::Experimental::HPX hpx_independent_sender2 = hpx_independent_sender1;
+  Kokkos::Experimental::HPX hpx_independent_sender3{hpx_independent_sender1};
+  Kokkos::Experimental::HPX hpx_independent_sender4;
+  hpx_independent_sender4 = hpx_independent_sender1;
 
   ASSERT_NE(hpx_default1.impl_instance_id(),
-            hpx_independent1.impl_instance_id());
+            hpx_independent_sender1.impl_instance_id());
   ASSERT_NE(hpx_independent1.impl_instance_id(),
-            hpx_independent_future1.impl_instance_id());
-  ASSERT_EQ(hpx_independent_future1.impl_instance_id(),
-            hpx_independent_future2.impl_instance_id());
-  ASSERT_EQ(hpx_independent_future1.impl_instance_id(),
-            hpx_independent_future3.impl_instance_id());
-  ASSERT_EQ(hpx_independent_future1.impl_instance_id(),
-            hpx_independent_future4.impl_instance_id());
+            hpx_independent_sender1.impl_instance_id());
+  ASSERT_EQ(hpx_independent_sender1.impl_instance_id(),
+            hpx_independent_sender2.impl_instance_id());
+  ASSERT_EQ(hpx_independent_sender1.impl_instance_id(),
+            hpx_independent_sender3.impl_instance_id());
+  ASSERT_EQ(hpx_independent_sender1.impl_instance_id(),
+            hpx_independent_sender4.impl_instance_id());
 }
 
 }  // namespace
-
-#endif
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstancesRefCounting.cpp b/core/unit_test/hpx/TestHPX_IndependentInstancesRefCounting.cpp
index 2e9ca081bc..3fc7d83909 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstancesRefCounting.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstancesRefCounting.cpp
@@ -17,13 +17,12 @@
 #include <Kokkos_Core.hpp>
 #include <TestHPX_Category.hpp>
 
-#ifdef KOKKOS_ENABLE_HPX_ASYNC_DISPATCH
-
 namespace {
 std::atomic<int> dummy_count;
 
 struct dummy {
   dummy() { ++dummy_count; }
+  dummy(dummy &&) { ++dummy_count; }
   dummy(dummy const &) { ++dummy_count; }
   ~dummy() { --dummy_count; }
   void f() const {}
@@ -32,28 +31,26 @@ struct dummy {
 // This test makes sure the independent HPX instances don't hold on to captured
 // data after destruction.
 TEST(hpx, independent_instances_reference_counting) {
-  dummy d;
-  Kokkos::Experimental::HPX hpx(
-      Kokkos::Experimental::HPX::instance_mode::independent);
-  Kokkos::parallel_for(
-      "Test::hpx::reference_counting::dummy",
-      Kokkos::RangePolicy<Kokkos::Experimental::HPX>(hpx, 0, 1),
-      KOKKOS_LAMBDA(int) {
-        // Make sure dummy struct is captured.
-        d.f();
-      });
-
-  hpx.fence();
-
-  // The fence above makes sure that copies of dummy get released. However,
-  // all copies are not guaranteed to be released as soon as fence returns.
-  // Therefore we wait for a short time to make it almost guaranteed that all
-  // copies have been released.
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-
-  ASSERT_EQ(1, dummy_count);
+  ASSERT_EQ(0, dummy_count);
+
+  {
+    dummy d;
+    ASSERT_EQ(1, dummy_count);
+    Kokkos::Experimental::HPX hpx(
+        Kokkos::Experimental::HPX::instance_mode::independent);
+    Kokkos::parallel_for(
+        "Test::hpx::reference_counting::dummy",
+        Kokkos::RangePolicy<Kokkos::Experimental::HPX>(hpx, 0, 1),
+        KOKKOS_LAMBDA(int) {
+          // Make sure dummy struct is captured.
+          d.f();
+        });
+
+    hpx.fence();
+    ASSERT_EQ(1, dummy_count);
+  }
+
+  ASSERT_EQ(0, dummy_count);
 }
 
 }  // namespace
-
-#endif
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstancesSynchronization.cpp b/core/unit_test/hpx/TestHPX_IndependentInstancesSynchronization.cpp
new file mode 100644
index 0000000000..24eb642f6b
--- /dev/null
+++ b/core/unit_test/hpx/TestHPX_IndependentInstancesSynchronization.cpp
@@ -0,0 +1,162 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Core.hpp>
+#include <TestHPX_Category.hpp>
+
+// These tests specifically check that work dispatched to independent instances
+// is synchronized correctly on fences. A previous bug that this protects
+// against is work being mistakenly dispatched to the default instance, but the
+// fence fencing the independent instance. In that case these tests will fail.
+
+namespace {
+inline constexpr int n = 1 << 10;
+
+TEST(hpx, independent_instances_synchronization_parallel_for_range_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::RangePolicy<Kokkos::Experimental::HPX> policy(instance, 0, n);
+  Kokkos::parallel_for(
+      "parallel_for_range_policy", policy,
+      KOKKOS_LAMBDA(const auto i) { a[i] = i; });
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+
+TEST(hpx, independent_instances_synchronization_parallel_for_mdrange_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::MDRangePolicy<Kokkos::Experimental::HPX, Kokkos::Rank<2>> policy(
+      instance, {{0, 0}}, {{n, 1}});
+  Kokkos::parallel_for(
+      "parallel_for_mdrange_policy", policy,
+      KOKKOS_LAMBDA(const auto i, const auto) { a[i] = i; });
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+
+TEST(hpx, independent_instances_synchronization_parallel_for_team_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::TeamPolicy<Kokkos::Experimental::HPX> policy(instance, n, 1);
+  Kokkos::parallel_for(
+      "parallel_for_team_policy", policy, KOKKOS_LAMBDA(const auto &handle) {
+        a[handle.league_rank()] = handle.league_rank();
+      });
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+
+TEST(hpx, independent_instances_synchronization_parallel_reduce_range_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+  Kokkos::View<int, Kokkos::Experimental::HPX> b("b");
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::RangePolicy<Kokkos::Experimental::HPX> policy(instance, 0, n);
+  Kokkos::parallel_reduce(
+      "parallel_reduce_range_policy", policy,
+      KOKKOS_LAMBDA(const int i, int &) { a[i] = i; }, b);
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+
+TEST(hpx,
+     independent_instances_synchronization_parallel_reduce_mdrange_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+  Kokkos::View<int, Kokkos::Experimental::HPX> b("b");
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::MDRangePolicy<Kokkos::Experimental::HPX, Kokkos::Rank<2>> policy(
+      instance, {{0, 0}}, {{n, 1}});
+  Kokkos::parallel_reduce(
+      "parallel_reduce_mdrange_policy", policy,
+      KOKKOS_LAMBDA(const int i, const int, int &) { a[i] = i; }, b);
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+
+TEST(hpx, independent_instances_synchronization_parallel_reduce_team_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+  Kokkos::View<int, Kokkos::Experimental::HPX> b("b");
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::TeamPolicy<Kokkos::Experimental::HPX> policy(instance, n, 1);
+  Kokkos::parallel_reduce(
+      "parallel_reduce_team_policy", policy,
+      KOKKOS_LAMBDA(const decltype(policy)::member_type &handle, int &) {
+        a[handle.league_rank()] = handle.league_rank();
+      },
+      b);
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+
+TEST(hpx, independent_instances_synchronization_parallel_scan_range_policy) {
+  Kokkos::View<int *, Kokkos::Experimental::HPX> a("a", n);
+  Kokkos::View<int *, Kokkos::Experimental::HPX> b("b", n);
+
+  Kokkos::Experimental::HPX instance{
+      Kokkos::Experimental::HPX::instance_mode::independent};
+  Kokkos::RangePolicy<Kokkos::Experimental::HPX> policy(instance, 0, n);
+  Kokkos::parallel_scan(
+      "parallel_scan_range_policy", policy,
+      KOKKOS_LAMBDA(const int i, int &, bool final) {
+        if (!final) {
+          a[i] = i;
+        }
+      },
+      b);
+
+  instance.fence();
+
+  for (int i = 0; i < n; ++i) {
+    ASSERT_EQ(a[i], i);
+  }
+}
+}  // namespace
diff --git a/core/unit_test/incremental/Test05_ParallelReduce_RangePolicy.hpp b/core/unit_test/incremental/Test05_ParallelReduce_RangePolicy.hpp
index 4235c73c8e..ed22c22d70 100644
--- a/core/unit_test/incremental/Test05_ParallelReduce_RangePolicy.hpp
+++ b/core/unit_test/incremental/Test05_ParallelReduce_RangePolicy.hpp
@@ -28,8 +28,11 @@ using value_type       = double;
 constexpr double value = 0.5;
 
 struct ReduceFunctor {
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const int i, double &UpdateSum) const {
+  // The functor is templated on purpose to check that the value_type deduction
+  // in parallel_reduce even works in this case.
+  template <typename IndexType, typename ValueType>
+  KOKKOS_INLINE_FUNCTION void operator()(const IndexType i,
+                                         ValueType &UpdateSum) const {
     UpdateSum += (i + 1) * value;
   }
 };
@@ -45,6 +48,7 @@ struct NonTrivialReduceFunctor {
   NonTrivialReduceFunctor(NonTrivialReduceFunctor &&)      = default;
   NonTrivialReduceFunctor &operator=(NonTrivialReduceFunctor &&) = default;
   NonTrivialReduceFunctor &operator=(NonTrivialReduceFunctor const &) = default;
+  // Also make sure that it's OK if the destructor is not device-callable.
   ~NonTrivialReduceFunctor() {}
 };
 
diff --git a/core/unit_test/incremental/Test12a_ThreadScratch.hpp b/core/unit_test/incremental/Test12a_ThreadScratch.hpp
index a4cd4fc56f..8c97043f30 100644
--- a/core/unit_test/incremental/Test12a_ThreadScratch.hpp
+++ b/core/unit_test/incremental/Test12a_ThreadScratch.hpp
@@ -98,6 +98,10 @@ struct ThreadScratch {
 
 TEST(TEST_CATEGORY, IncrTest_12a_ThreadScratch) {
   ThreadScratch<TEST_EXECSPACE> test;
+#ifdef KOKKOS_ENABLE_OPENACC  // FIXME_OPENACC
+  GTEST_SKIP() << "skipping since scratch memory is not yet implemented in the "
+                  "OpenACC backend";
+#endif
   // FIXME_OPENMPTARGET - team_size has to be a multiple of 32 for the tests to
   // pass in the Release and RelWithDebInfo builds. Does not need the team_size
   // to be a multiple of 32 for the Debug builds.
diff --git a/core/unit_test/incremental/Test12b_TeamScratch.hpp b/core/unit_test/incremental/Test12b_TeamScratch.hpp
index 9b27e35dfe..0ebb5c50fb 100644
--- a/core/unit_test/incremental/Test12b_TeamScratch.hpp
+++ b/core/unit_test/incremental/Test12b_TeamScratch.hpp
@@ -88,6 +88,10 @@ struct TeamScratch {
 
 TEST(TEST_CATEGORY, IncrTest_12b_TeamScratch) {
   TeamScratch<TEST_EXECSPACE> test;
+#ifdef KOKKOS_ENABLE_OPENACC  // FIXME_OPENACC
+  GTEST_SKIP() << "skipping since scratch memory is not yet implemented in the "
+                  "OpenACC backend";
+#endif
   // FIXME_OPENMPTARGET - team_size has to be a multiple of 32 for the tests to
   // pass in the Release and RelWithDebInfo builds. Does not need the team_size
   // to be a multiple of 32 for the Debug builds.
diff --git a/core/unit_test/incremental/Test14_MDRangeReduce.hpp b/core/unit_test/incremental/Test14_MDRangeReduce.hpp
index a1f307c0c8..f79d4f8ea3 100644
--- a/core/unit_test/incremental/Test14_MDRangeReduce.hpp
+++ b/core/unit_test/incremental/Test14_MDRangeReduce.hpp
@@ -38,6 +38,13 @@ struct MyComplex {
   KOKKOS_INLINE_FUNCTION
   MyComplex(const MyComplex& src) : _re(src._re), _im(src._im) {}
 
+  KOKKOS_INLINE_FUNCTION
+  MyComplex& operator=(const MyComplex& src) {
+    _re = src._re;
+    _im = src._im;
+    return *this;
+  }
+
   KOKKOS_INLINE_FUNCTION
   void operator+=(const MyComplex& src) {
     _re += src._re;
@@ -93,6 +100,8 @@ struct TestMDRangeReduce {
         },
         d_result);
 
+// FIXME_OPENACC: scalar reduction variable on the device is not yet supported.
+#if !defined(KOKKOS_ENABLE_OPENACC)
     // Parallel reduce on a view.
     Kokkos::parallel_reduce(
         mdPolicy_2D,
@@ -100,16 +109,23 @@ struct TestMDRangeReduce {
           update_value += d_data(i, j);
         },
         d_resultView);
+#endif
 
     // Check correctness.
     ASSERT_EQ(h_result, d_result);
 
+// FIXME_OPENACC: scalar reduction variable on the device is not yet supported.
+#if !defined(KOKKOS_ENABLE_OPENACC)
     // Copy view back to host.
     value_type view_result = 0.0;
     Kokkos::deep_copy(view_result, d_resultView);
     ASSERT_EQ(h_result, view_result);
+#endif
   }
 
+// FIXME_OPENACC: custom reductions are not yet supported in the
+// OpenACC backend.
+#if !defined(KOKKOS_ENABLE_OPENACC)
   // Custom Reduction
   void reduce_custom() {
     Complex_View_1D d_data("complex array", N);
@@ -136,6 +152,7 @@ struct TestMDRangeReduce {
     ASSERT_EQ(result._re, sum * 0.5);
     ASSERT_EQ(result._im, -sum * 0.5);
   }
+#endif
 };
 
 // Reductions tests for MDRange policy and customized reduction.
@@ -144,9 +161,13 @@ TEST(TEST_CATEGORY, incr_14_MDrangeReduce) {
   test.reduce_MDRange();
 // FIXME_OPENMPTARGET: custom reductions are not yet supported in the
 // OpenMPTarget backend.
+// FIXME_OPENACC: custom reductions are not yet supported in the
+// OpenACC backend.
 #if !defined(KOKKOS_ENABLE_OPENMPTARGET)
+#if !defined(KOKKOS_ENABLE_OPENACC)
   test.reduce_custom();
 #endif
+#endif
 }
 
 }  // namespace Test
diff --git a/core/unit_test/incremental/Test16_ParallelScan.hpp b/core/unit_test/incremental/Test16_ParallelScan.hpp
index 78f791914a..efcb19a5c6 100644
--- a/core/unit_test/incremental/Test16_ParallelScan.hpp
+++ b/core/unit_test/incremental/Test16_ParallelScan.hpp
@@ -26,11 +26,60 @@ namespace Test {
 using value_type = double;
 const int N      = 10;
 
+template <typename ExecSpace>
+struct TrivialScanFunctor {
+  Kokkos::View<value_type *, ExecSpace> d_data;
+
+  KOKKOS_FUNCTION
+  void operator()(const int i, value_type &update_value,
+                  const bool final) const {
+    const value_type val_i = d_data(i);
+    if (final) d_data(i) = update_value;
+    update_value += val_i;
+  }
+};
+
+template <typename ExecSpace>
+struct NonTrivialScanFunctor {
+  Kokkos::View<value_type *, ExecSpace> d_data;
+
+  KOKKOS_FUNCTION
+  void operator()(const int i, value_type &update_value,
+                  const bool final) const {
+    const value_type val_i = d_data(i);
+    if (final) d_data(i) = update_value;
+    update_value += val_i;
+  }
+
+  NonTrivialScanFunctor(const Kokkos::View<value_type *, ExecSpace> &data)
+      : d_data(data) {}
+  NonTrivialScanFunctor(NonTrivialScanFunctor const &) = default;
+  NonTrivialScanFunctor(NonTrivialScanFunctor &&)      = default;
+  NonTrivialScanFunctor &operator=(NonTrivialScanFunctor &&) = default;
+  NonTrivialScanFunctor &operator=(NonTrivialScanFunctor const &) = default;
+  // Also make sure that it's OK if the destructor is not device-callable.
+  ~NonTrivialScanFunctor() {}
+};
+
+template <typename ExecSpace>
+struct GenericExclusiveScanFunctor {
+  Kokkos::View<value_type *, ExecSpace> d_data;
+
+  template <typename IndexType, typename ValueType>
+  KOKKOS_FUNCTION void operator()(const IndexType i, ValueType &update_value,
+                                  const bool final) const {
+    const ValueType val_i = d_data(i);
+    if (final) d_data(i) = update_value;
+    update_value += val_i;
+  }
+};
+
 template <class ExecSpace>
 struct TestScan {
   // 1D  View of double
   using View_1D = typename Kokkos::View<value_type *, ExecSpace>;
 
+  template <typename FunctorType>
   void parallel_scan() {
     View_1D d_data("data", N);
 
@@ -39,15 +88,44 @@ struct TestScan {
         Kokkos::RangePolicy<ExecSpace>(0, N),
         KOKKOS_LAMBDA(const int i) { d_data(i) = i * 0.5; });
 
-    // Exclusive parallel_scan call.
-    Kokkos::parallel_scan(
-        Kokkos::RangePolicy<ExecSpace>(0, N),
-        KOKKOS_LAMBDA(const int i, value_type &update_value, const bool final) {
-          const value_type val_i = d_data(i);
-          if (final) d_data(i) = update_value;
+    // Exclusive parallel_scan call
+    Kokkos::parallel_scan(Kokkos::RangePolicy<ExecSpace>(0, N),
+                          FunctorType{d_data});
+
+    // Copy back the data.
+    auto h_data =
+        Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), d_data);
+
+    // Check Correctness
+    ASSERT_EQ(h_data(0), 0.0);
+    value_type upd = h_data(0);
+    for (int i = 1; i < N; ++i) {
+      upd += (i - 1) * 0.5;
+      ASSERT_EQ(h_data(i), upd);
+    }
+  }
+};
+
+template <class ExecSpace>
+struct TestScanWithTotal {
+  // 1D  View of double
+  using View_1D  = typename Kokkos::View<value_type *, ExecSpace>;
+  View_1D d_data = View_1D("data", N);
+
+  template <typename IndexType>
+  KOKKOS_FUNCTION void operator()(IndexType i) const {
+    d_data(i) = i * 0.5;
+  }
+
+  template <typename FunctorType>
+  void parallel_scan() {
+    // Initialize data.
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, N), *this);
 
-          update_value += val_i;
-        });
+    value_type total;
+    // Exclusive parallel_scan call
+    Kokkos::parallel_scan(Kokkos::RangePolicy<ExecSpace>(0, N),
+                          FunctorType{d_data}, total);
 
     // Copy back the data.
     auto h_data =
@@ -60,12 +138,18 @@ struct TestScan {
       upd += (i - 1) * 0.5;
       ASSERT_EQ(h_data(i), upd);
     }
+    ASSERT_EQ(total, N * (N - 1) * 0.25);
   }
 };
 
 TEST(TEST_CATEGORY, IncrTest_16_parallelscan) {
   TestScan<TEST_EXECSPACE> test;
-  test.parallel_scan();
+  test.parallel_scan<TrivialScanFunctor<TEST_EXECSPACE>>();
+  test.parallel_scan<NonTrivialScanFunctor<TEST_EXECSPACE>>();
+  TestScanWithTotal<TEST_EXECSPACE> test_total;
+  test_total.parallel_scan<TrivialScanFunctor<TEST_EXECSPACE>>();
+  test_total.parallel_scan<NonTrivialScanFunctor<TEST_EXECSPACE>>();
+  test_total.parallel_scan<GenericExclusiveScanFunctor<TEST_EXECSPACE>>();
 }
 
 }  // namespace Test
diff --git a/core/unit_test/openmp/TestOpenMP.hpp b/core/unit_test/openmp/TestOpenMP.hpp
deleted file mode 100644
index 3a974d517c..0000000000
--- a/core/unit_test/openmp/TestOpenMP.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_TEST_OPENMP_HPP
-#define KOKKOS_TEST_OPENMP_HPP
-
-#include <gtest/gtest.h>
-
-#include <Kokkos_Macros.hpp>
-
-#ifdef KOKKOS_LAMBDA
-#undef KOKKOS_LAMBDA
-#endif
-#define KOKKOS_LAMBDA [=]
-
-#include <Kokkos_Core.hpp>
-
-#include <TestViewMapping.hpp>
-#include <TestViewAPI.hpp>
-#include <TestViewOfClass.hpp>
-#include <TestViewSubview.hpp>
-#include <TestAtomic.hpp>
-#include <TestAtomicOperations.hpp>
-#include <TestAtomicViews.hpp>
-#include <TestRange.hpp>
-#include <TestTeam.hpp>
-#include <TestReduce.hpp>
-#include <TestScan.hpp>
-#include <TestAggregate.hpp>
-#include <TestCompilerMacros.hpp>
-#include <TestTaskScheduler.hpp>
-#include <TestMemoryPool.hpp>
-#include <TestCXX11.hpp>
-#include <TestCXX11Deduction.hpp>
-#include <TestTeamVector.hpp>
-#include <TestPolicyConstruction.hpp>
-#include <TestMDRange.hpp>
-#include <TestConcurrentBitset.hpp>
-
-namespace Test {
-
-class openmp : public ::testing::Test {
- protected:
-  static void SetUpTestCase() {
-    int threads_count = 0;
-#pragma omp parallel
-    {
-#pragma omp atomic
-      ++threads_count;
-    }
-
-    if (threads_count > 3) {
-      threads_count /= 2;
-    }
-
-    Kokkos::OpenMP::initialize(threads_count);
-    Kokkos::print_configuration(std::cout, true);
-
-    srand(10231);
-  }
-
-  static void TearDownTestCase() { Kokkos::OpenMP::finalize(); }
-};
-
-}  // namespace Test
-
-#endif
diff --git a/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp b/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp
index 6983fabb2a..92b8032bf0 100644
--- a/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp
+++ b/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp
@@ -29,7 +29,7 @@ TEST(openmp, partition_master) {
   int errors = 0;
 
   auto master = [&errors, &mtx](int /*partition_id*/, int /*num_partitions*/) {
-    const int pool_size = Kokkos::OpenMP::impl_thread_pool_size();
+    const int pool_size = Kokkos::OpenMP().impl_thread_pool_size();
 
     {
       std::unique_lock<Mutex> lock(mtx);
@@ -46,7 +46,7 @@ TEST(openmp, partition_master) {
       Kokkos::parallel_reduce(
           Kokkos::RangePolicy<Kokkos::OpenMP>(0, 1000),
           [pool_size](const int, int& errs) {
-            if (Kokkos::OpenMP::impl_thread_pool_size() != pool_size) {
+            if (Kokkos::OpenMP().impl_thread_pool_size() != pool_size) {
               ++errs;
             }
           },
diff --git a/core/unit_test/openmptarget/TestOpenMPTarget.hpp b/core/unit_test/openmptarget/TestOpenMPTarget.hpp
deleted file mode 100644
index 6ae45620f2..0000000000
--- a/core/unit_test/openmptarget/TestOpenMPTarget.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 4.0
-//       Copyright (2022) National Technology & Engineering
-//               Solutions of Sandia, LLC (NTESS).
-//
-// Under the terms of Contract DE-NA0003525 with NTESS,
-// the U.S. Government retains certain rights in this software.
-//
-// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
-// See https://kokkos.org/LICENSE for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//@HEADER
-
-#ifndef KOKKOS_TEST_OPENMPTARGET_HPP
-#define KOKKOS_TEST_OPENMPTARGET_HPP
-
-#include <gtest/gtest.h>
-
-#include <Kokkos_Macros.hpp>
-
-#ifdef KOKKOS_LAMBDA
-#undef KOKKOS_LAMBDA
-#endif
-#define KOKKOS_LAMBDA [=]
-
-#include <Kokkos_Core.hpp>
-
-//#include <TestViewAPI.hpp>
-//#include <TestViewOfClass.hpp>
-//#include <TestViewSubview.hpp>
-//#include <TestAtomic.hpp>
-//#include <TestAtomicOperations.hpp>
-//#include <TestAtomicViews.hpp>
-#include <TestRange.hpp>
-#include <TestTeam.hpp>
-//#include <TestReduce.hpp>
-//#include <TestScan.hpp>
-//#include <TestAggregate.hpp>
-//#include <TestCompilerMacros.hpp>
-
-// TODO enable task scheduler tests for openmptarget
-//#include <TestTaskScheduler.hpp>
-
-//#include <TestMemoryPool.hpp>
-//#include <TestCXX11.hpp>
-//#include <TestCXX11Deduction.hpp>
-#include <TestTeamVector.hpp>
-//#include <TestPolicyConstruction.hpp>
-//#include <TestMDRange.hpp>
-
-namespace Test {
-
-class openmptarget : public ::testing::Test {
- protected:
-  static void SetUpTestCase() {
-    const unsigned numa_count = Kokkos::hwloc::get_available_numa_count();
-    const unsigned cores_per_numa =
-        Kokkos::hwloc::get_available_cores_per_numa();
-    const unsigned openmptarget_per_core =
-        Kokkos::hwloc::get_available_openmptarget_per_core();
-
-    unsigned openmptarget_count = 0;
-
-    openmptarget_count = std::max(1u, numa_count) *
-                         std::max(2u, cores_per_numa * openmptarget_per_core);
-
-    Kokkos::OpenMPTarget::initialize(openmptarget_count);
-    Kokkos::print_configuration(std::cout, true /* detailed */);
-  }
-
-  static void TearDownTestCase() { Kokkos::OpenMPTarget::finalize(); }
-};
-
-}  // namespace Test
-
-#endif
diff --git a/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp b/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp
index 25c5c9a50c..4b2530316d 100644
--- a/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp
+++ b/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp
@@ -29,8 +29,7 @@ TEST(sycl, raw_sycl_interop) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::default_selector device_selector;
-  sycl::queue queue(default_context, device_selector);
+  sycl::queue queue(default_context, sycl::default_selector_v);
   constexpr int n = 100;
   int* p          = sycl::malloc_device<int>(n, queue);
   {
diff --git a/core/unit_test/sycl/TestSYCL_InterOp_Init_Context.cpp b/core/unit_test/sycl/TestSYCL_InterOp_Init_Context.cpp
index 336a5d59c3..bbd3d2af94 100644
--- a/core/unit_test/sycl/TestSYCL_InterOp_Init_Context.cpp
+++ b/core/unit_test/sycl/TestSYCL_InterOp_Init_Context.cpp
@@ -27,8 +27,7 @@ TEST(sycl, raw_sycl_interop_context_1) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::default_selector device_selector;
-  sycl::queue queue(default_context, device_selector);
+  sycl::queue queue(default_context, sycl::default_selector_v);
   constexpr int n = 100;
   int* p          = sycl::malloc_device<int>(n, queue);
 
@@ -61,8 +60,7 @@ TEST(sycl, raw_sycl_interop_context_2) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::default_selector device_selector;
-  sycl::queue queue(default_context, device_selector);
+  sycl::queue queue(default_context, sycl::default_selector_v);
   constexpr int n = 100;
 
   Kokkos::Experimental::SYCL space(queue);
diff --git a/core/unit_test/sycl/TestSYCL_InterOp_Streams.cpp b/core/unit_test/sycl/TestSYCL_InterOp_Streams.cpp
index 13810d861c..0cfaab8813 100644
--- a/core/unit_test/sycl/TestSYCL_InterOp_Streams.cpp
+++ b/core/unit_test/sycl/TestSYCL_InterOp_Streams.cpp
@@ -25,8 +25,7 @@ TEST(sycl, raw_sycl_queues) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::default_selector device_selector;
-  sycl::queue queue(default_context, device_selector);
+  sycl::queue queue(default_context, sycl::default_selector_v);
   int* p            = sycl::malloc_device<int>(100, queue);
   using MemorySpace = typename TEST_EXECSPACE::memory_space;
 
diff --git a/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp b/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp
index 11207a5480..d7ed93d49e 100644
--- a/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp
+++ b/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp
@@ -76,13 +76,12 @@ void sycl_queue_scratch_test(
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::default_selector device_selector;
-  sycl::queue queue(default_context, device_selector);
+  sycl::queue queue(default_context, sycl::default_selector_v);
 
   std::array<Kokkos::Experimental::SYCL, K> sycl;
   for (int i = 0; i < K; i++) {
     sycl[i] = Kokkos::Experimental::SYCL(
-        sycl::queue(default_context, device_selector));
+        sycl::queue(default_context, sycl::default_selector_v));
   }
 
   // Test that growing scratch size in subsequent calls doesn't crash things
diff --git a/core/unit_test/tools/TestEventCorrectness.hpp b/core/unit_test/tools/TestEventCorrectness.hpp
index 4081604113..3c85f661aa 100644
--- a/core/unit_test/tools/TestEventCorrectness.hpp
+++ b/core/unit_test/tools/TestEventCorrectness.hpp
@@ -197,7 +197,7 @@ TEST(kokkosp, test_multiple_default_instances) {
       ex1.fence("named_instance_fence_one");
       ex2.fence("named_instance_fence_two");
     });
-    ASSERT_TRUE(found_payloads[0].dev_id == found_payloads[1].dev_id);
+    ASSERT_EQ(found_payloads[0].dev_id, found_payloads[1].dev_id);
   });
 }
 
@@ -393,6 +393,13 @@ TEST(kokkosp, parallel_scan_no_fence) {
 #ifdef KOKKOS_ENABLE_THREADS
   if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Threads>::value)
     GTEST_SKIP() << "skipping since the Thread backend always fences";
+#endif
+#if defined(KOKKOS_ENABLE_HPX) && \
+    !defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+  if (std::is_same<Kokkos::DefaultExecutionSpace,
+                   Kokkos::Experimental::HPX>::value)
+    GTEST_SKIP() << "skipping since the HPX backend always fences with async "
+                    "dispatch disabled";
 #endif
     // FIXME_OPENMPTARGET
 #ifdef KOKKOS_ENABLE_OPENMPTARGET
@@ -427,6 +434,13 @@ TEST(kokkosp, parallel_scan_no_fence_view) {
 #ifdef KOKKOS_ENABLE_THREADS
   if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Threads>::value)
     GTEST_SKIP() << "skipping since the Thread backend always fences";
+#endif
+#if defined(KOKKOS_ENABLE_HPX) && \
+    !defined(KOKKOS_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+  if (std::is_same<Kokkos::DefaultExecutionSpace,
+                   Kokkos::Experimental::HPX>::value)
+    GTEST_SKIP() << "skipping since the HPX backend always fences with async "
+                    "dispatch disabled";
 #endif
     // FIXME_OPENMPTARGET
 #ifdef KOKKOS_ENABLE_OPENMPTARGET
@@ -716,7 +730,7 @@ TEST(kokkosp, get_events) {
   });
   for (const auto& ptr : event_vector) {
     auto ptr_as_begin = std::dynamic_pointer_cast<BeginParallelForEvent>(ptr);
-    ASSERT_TRUE(ptr_as_begin == nullptr);
+    ASSERT_EQ(ptr_as_begin, nullptr);
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/tools/TestLogicalSpaces.hpp b/core/unit_test/tools/TestLogicalSpaces.hpp
index 1b20bd5933..4e56f8996a 100644
--- a/core/unit_test/tools/TestLogicalSpaces.hpp
+++ b/core/unit_test/tools/TestLogicalSpaces.hpp
@@ -165,7 +165,7 @@ TEST(defaultdevicetype, access_allowed) {
   test_allowed_access<fake_memory_space>();
 }
 // FIXME_SYCL
-#if !(defined(KOKKOS_COMPILER_INTEL) && defined(KOKKOS_ENABLE_SYCL))
+#if !(defined(KOKKOS_COMPILER_INTEL_LLVM) && defined(KOKKOS_ENABLE_SYCL))
 TEST(defaultdevicetype_DeathTest, access_forbidden) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
   ASSERT_DEATH(
diff --git a/core/unit_test/tools/TestScopedRegion.cpp b/core/unit_test/tools/TestScopedRegion.cpp
new file mode 100644
index 0000000000..5306496d76
--- /dev/null
+++ b/core/unit_test/tools/TestScopedRegion.cpp
@@ -0,0 +1,72 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+#include <Kokkos_Profiling_ScopedRegion.hpp>
+
+#include <gtest/gtest.h>
+
+#include <string>
+#include <stack>
+
+namespace {
+
+std::stack<std::string> test_region_stack;
+
+// NOTE: cannot use lambdas because they can only be converted to function
+// pointers if they don't capture anything
+void test_push_region(char const *label) { test_region_stack.push(label); }
+
+void test_pop_region() { test_region_stack.pop(); }
+
+TEST(defaultdevicetype, scoped_profile_region) {
+  Kokkos::Tools::Experimental::set_push_region_callback(test_push_region);
+  Kokkos::Tools::Experimental::set_pop_region_callback(test_pop_region);
+
+  ASSERT_TRUE(test_region_stack.empty());
+
+  {
+    std::string outer_identifier = "outer";
+    Kokkos::Profiling::ScopedRegion guard_outer(outer_identifier);
+
+    ASSERT_EQ(test_region_stack.size(), 1u);
+    ASSERT_EQ(test_region_stack.top(), outer_identifier);
+
+    {
+      std::string inner_identifier = "inner";
+      Kokkos::Profiling::ScopedRegion guard_inner(inner_identifier);
+      ASSERT_EQ(test_region_stack.size(), 2u);
+      ASSERT_EQ(test_region_stack.top(), inner_identifier);
+    }
+
+    ASSERT_EQ(test_region_stack.size(), 1u);
+    ASSERT_EQ(test_region_stack.top(), outer_identifier);
+  }
+
+  ASSERT_TRUE(test_region_stack.empty());
+
+  // Unset callbacks
+  Kokkos::Tools::Experimental::set_push_region_callback(nullptr);
+  Kokkos::Tools::Experimental::set_pop_region_callback(nullptr);
+}
+
+using Kokkos::Profiling::ScopedRegion;
+static_assert(!std::is_default_constructible<ScopedRegion>::value);
+static_assert(!std::is_copy_constructible<ScopedRegion>::value);
+static_assert(!std::is_move_constructible<ScopedRegion>::value);
+static_assert(!std::is_copy_assignable<ScopedRegion>::value);
+static_assert(!std::is_move_assignable<ScopedRegion>::value);
+
+}  // namespace
diff --git a/core/unit_test/tools/TestToolsInitialization.cpp b/core/unit_test/tools/TestToolsInitialization.cpp
new file mode 100644
index 0000000000..1ae974ca71
--- /dev/null
+++ b/core/unit_test/tools/TestToolsInitialization.cpp
@@ -0,0 +1,216 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+
+// This file calls most of the basic Kokkos primitives. When combined with a
+// testing library this tests that our shared-library loading based profiling
+// mechanisms work
+
+#include <Kokkos_Core.hpp>
+#include <gtest/gtest.h>
+
+bool init_callback                               = false;
+bool finalize_callback                           = false;
+bool begin_parallel_for_callback                 = false;
+bool end_parallel_for_callback                   = false;
+bool begin_parallel_reduce_callback              = false;
+bool end_parallel_reduce_callback                = false;
+bool begin_parallel_scan_callback                = false;
+bool end_parallel_scan_callback                  = false;
+bool push_region_callback                        = false;
+bool pop_region_callback                         = false;
+bool allocate_data_callback                      = false;
+bool deallocate_data_callback                    = false;
+bool create_profile_section_callback             = false;
+bool start_profile_section_callback              = false;
+bool stop_profile_section_callback               = false;
+bool destroy_profile_section_callback            = false;
+bool profile_event_callback                      = false;
+bool begin_deep_copy_callback                    = false;
+bool end_deep_copy_callback                      = false;
+bool begin_fence_callback                        = false;
+bool end_fence_callback                          = false;
+bool declare_metadata_callback                   = false;
+bool request_tool_settings_callback              = false;
+bool provide_tool_programming_interface_callback = false;
+
+void test_tools_initialization_with_callbacks() {
+  Kokkos::Tools::Experimental::set_init_callback(
+      [](const int /*loadseq*/, const uint64_t /*version*/,
+         const uint32_t /*num_infos*/,
+         Kokkos::Profiling::KokkosPDeviceInfo* /*infos*/) {
+        init_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_finalize_callback(
+      []() { finalize_callback = true; });
+  Kokkos::Tools::Experimental::set_begin_parallel_for_callback(
+      [](const char* /*n*/, const uint32_t /*d*/, uint64_t* /*k*/) {
+        begin_parallel_for_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_end_parallel_for_callback(
+      [](const uint64_t /*k*/) { end_parallel_for_callback = true; });
+  Kokkos::Tools::Experimental::set_begin_parallel_reduce_callback(
+      [](const char* /*n*/, const uint32_t /*d*/, uint64_t* /*k*/) {
+        begin_parallel_reduce_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_end_parallel_reduce_callback(
+      [](const uint64_t /*k*/) { end_parallel_reduce_callback = true; });
+  Kokkos::Tools::Experimental::set_begin_parallel_scan_callback(
+      [](const char* /*n*/, const uint32_t /*d*/, uint64_t* /*k*/) {
+        begin_parallel_scan_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_end_parallel_scan_callback(
+      [](const uint64_t /*k*/) { end_parallel_scan_callback = true; });
+  Kokkos::Tools::Experimental::set_push_region_callback(
+      [](const char* /*name*/) { push_region_callback = true; });
+  Kokkos::Tools::Experimental::set_pop_region_callback(
+      []() { pop_region_callback = true; });
+  Kokkos::Tools::Experimental::set_allocate_data_callback(
+      [](Kokkos::Tools::SpaceHandle /*handle*/, const char* /*name*/,
+         const void* /*ptr*/,
+         const uint64_t /*size*/) { allocate_data_callback = true; });
+  Kokkos::Tools::Experimental::set_deallocate_data_callback(
+      [](Kokkos::Tools::SpaceHandle /*handle*/, const char* /*name*/,
+         const void* /*ptr*/,
+         const uint64_t /*size*/) { deallocate_data_callback = true; });
+  Kokkos::Tools::Experimental::set_create_profile_section_callback(
+      [](const char* /*name*/, uint32_t* /*id*/) {
+        create_profile_section_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_destroy_profile_section_callback(
+      [](const uint32_t /*id*/) { destroy_profile_section_callback = true; });
+  Kokkos::Tools::Experimental::set_start_profile_section_callback(
+      [](uint32_t /*id*/) { start_profile_section_callback = true; });
+  Kokkos::Tools::Experimental::set_stop_profile_section_callback(
+      [](uint32_t /*id*/) { stop_profile_section_callback = true; });
+  Kokkos::Tools::Experimental::set_profile_event_callback(
+      [](const char* /*name*/) { profile_event_callback = true; });
+  Kokkos::Tools::Experimental::set_begin_deep_copy_callback(
+      [](Kokkos::Tools::SpaceHandle /*dst_handle*/, const char* /*dst_name*/,
+         const void* /*dst_ptr*/, Kokkos::Tools::SpaceHandle /*src_handle*/,
+         const char* /*src_name*/, const void* /*src_ptr*/,
+         uint64_t /*size*/) { begin_deep_copy_callback = true; });
+  Kokkos::Tools::Experimental::set_end_deep_copy_callback(
+      []() { end_deep_copy_callback = true; });
+  Kokkos::Tools::Experimental::set_begin_fence_callback(
+      [](const char* /*n*/, const uint32_t /*d*/, uint64_t* /*k*/) {
+        begin_fence_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_end_fence_callback(
+      [](const uint64_t /*k*/) { end_fence_callback = true; });
+  Kokkos::Tools::Experimental::set_declare_metadata_callback(
+      [](const char* /*key*/, const char* /*value*/) {
+        declare_metadata_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_request_tool_settings_callback(
+      [](const uint32_t /*num_settings*/,
+         Kokkos::Tools::Experimental::ToolSettings* /*settings*/) {
+        request_tool_settings_callback = true;
+      });
+  Kokkos::Tools::Experimental::set_provide_tool_programming_interface_callback(
+      [](const uint32_t /*num_functions*/,
+         Kokkos::Tools::Experimental::ToolProgrammingInterface /*interface*/) {
+        provide_tool_programming_interface_callback = true;
+      });
+
+  Kokkos::initialize();
+  {
+    ASSERT_TRUE(init_callback);
+    ASSERT_FALSE(finalize_callback);
+    ASSERT_FALSE(begin_parallel_for_callback);
+    ASSERT_FALSE(end_parallel_for_callback);
+    ASSERT_FALSE(begin_parallel_reduce_callback);
+    ASSERT_FALSE(end_parallel_reduce_callback);
+    ASSERT_FALSE(begin_parallel_scan_callback);
+    ASSERT_FALSE(end_parallel_scan_callback);
+    ASSERT_FALSE(push_region_callback);
+    ASSERT_FALSE(pop_region_callback);
+    ASSERT_FALSE(allocate_data_callback);
+    ASSERT_FALSE(deallocate_data_callback);
+    ASSERT_FALSE(create_profile_section_callback);
+    ASSERT_FALSE(start_profile_section_callback);
+    ASSERT_FALSE(stop_profile_section_callback);
+    ASSERT_FALSE(destroy_profile_section_callback);
+    ASSERT_FALSE(profile_event_callback);
+    ASSERT_FALSE(begin_deep_copy_callback);
+    ASSERT_FALSE(end_deep_copy_callback);
+    ASSERT_FALSE(begin_fence_callback);
+    ASSERT_FALSE(end_fence_callback);
+    ASSERT_TRUE(declare_metadata_callback);
+    ASSERT_TRUE(request_tool_settings_callback);
+    ASSERT_TRUE(provide_tool_programming_interface_callback);
+  }
+  {
+    using execution_space = Kokkos::DefaultExecutionSpace;
+    using memory_space    = typename execution_space::memory_space;
+    Kokkos::View<int*, memory_space> src_view("source", 10);
+    Kokkos::View<int*, memory_space> dst_view("destination", 10);
+    Kokkos::deep_copy(dst_view, src_view);
+    Kokkos::parallel_for(
+        "parallel_for", Kokkos::RangePolicy<execution_space>(0, 1),
+        KOKKOS_LAMBDA(int i) { (void)i; });
+    int result;
+    Kokkos::parallel_reduce(
+        "parallel_reduce", Kokkos::RangePolicy<execution_space>(0, 1),
+        KOKKOS_LAMBDA(int i, int& hold_result) { hold_result += i; }, result);
+    Kokkos::parallel_scan(
+        "parallel_scan", Kokkos::RangePolicy<execution_space>(0, 1),
+        KOKKOS_LAMBDA(const int i, int& hold_result, const bool final) {
+          if (final) {
+            hold_result += i;
+          }
+        });
+    Kokkos::Profiling::pushRegion("push_region");
+    Kokkos::Profiling::popRegion();
+    uint32_t sectionId;
+    Kokkos::Profiling::createProfileSection("created_section", &sectionId);
+    Kokkos::Profiling::startSection(sectionId);
+    Kokkos::Profiling::stopSection(sectionId);
+    Kokkos::Profiling::destroyProfileSection(sectionId);
+    Kokkos::Profiling::markEvent("profiling_event");
+    Kokkos::Tools::declareMetadata("dogs", "good");
+  }
+  Kokkos::finalize();
+  {
+    ASSERT_TRUE(init_callback);
+    ASSERT_TRUE(finalize_callback);
+    ASSERT_TRUE(begin_parallel_for_callback);
+    ASSERT_TRUE(end_parallel_for_callback);
+    ASSERT_TRUE(begin_parallel_reduce_callback);
+    ASSERT_TRUE(end_parallel_reduce_callback);
+    ASSERT_TRUE(begin_parallel_scan_callback);
+    ASSERT_TRUE(end_parallel_scan_callback);
+    ASSERT_TRUE(push_region_callback);
+    ASSERT_TRUE(pop_region_callback);
+    ASSERT_TRUE(allocate_data_callback);
+    ASSERT_TRUE(deallocate_data_callback);
+    ASSERT_TRUE(create_profile_section_callback);
+    ASSERT_TRUE(start_profile_section_callback);
+    ASSERT_TRUE(stop_profile_section_callback);
+    ASSERT_TRUE(destroy_profile_section_callback);
+    ASSERT_TRUE(profile_event_callback);
+    ASSERT_TRUE(begin_deep_copy_callback);
+    ASSERT_TRUE(end_deep_copy_callback);
+    ASSERT_TRUE(begin_fence_callback);
+    ASSERT_TRUE(end_fence_callback);
+    ASSERT_TRUE(declare_metadata_callback);
+    ASSERT_TRUE(request_tool_settings_callback);
+    ASSERT_TRUE(provide_tool_programming_interface_callback);
+  }
+}
+
+TEST(tools, initialization_with_callbacks) {
+  test_tools_initialization_with_callbacks();
+}
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 7ecaec0f24..3920dc9a27 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -1,10 +1,2 @@
-
-
-# Subpackage name must match what appears in kokkos/cmake/Dependencies.cmake
-#
-KOKKOS_SUBPACKAGE(Example)
-
 KOKKOS_ADD_EXAMPLE_DIRECTORIES(query_device)
 KOKKOS_ADD_EXAMPLE_DIRECTORIES(tutorial)
-
-KOKKOS_SUBPACKAGE_POSTPROCESS()
diff --git a/generate_makefile.bash b/generate_makefile.bash
index 60791d1c01..018426c9b8 100755
--- a/generate_makefile.bash
+++ b/generate_makefile.bash
@@ -161,6 +161,7 @@ display_help_text() {
       echo "                 VEGA908         = AMD GPU MI100 GFX908"
       echo "                 VEGA90A         = AMD GPU MI200 GFX90A"
       echo "                 NAVI1030        = AMD GPU V620/W6800 GFX1030"
+      echo "                 NAVI1100        = AMD GPU RX 7900 XT(X) GFX1100"
       echo "               [ARM]"
       echo "                 ARMV80          = ARMv8.0 Compatible CPU"
       echo "                 ARMV81          = ARMv8.1 Compatible CPU"
diff --git a/master_history.txt b/master_history.txt
index abe65ff450..41c0a5c393 100644
--- a/master_history.txt
+++ b/master_history.txt
@@ -30,4 +30,6 @@ tag:  3.6.00     date: 04:14:2022    master: 2834f94a    release: 6ea708ff
 tag:  3.6.01     date: 06:16:2022    master: b52f8c83    release: afe9b404
 tag:  3.7.00     date: 08:25:2022    master: d19aab99    release: 0018e5fb
 tag:  3.7.01     date: 12:01:2022    master: 61d7db55    release: d3bb8cfe
-tag:  4.0.0      date: 02:23:2023    master: 5ad60966    release: 52ea2953
+tag:  4.0.00     date: 02:23:2023    master: 5ad60966    release: 52ea2953
+tag:  4.0.01     date: 04:26:2023    master: aa1f48f3    release: 5893754f
+tag:  4.1.00     date: 06:20:2023    master: 62d2b6c8    release: adde1e6a
diff --git a/scripts/diff_files b/scripts/diff_files
index 125568d345..8b13789179 100644
--- a/scripts/diff_files
+++ b/scripts/diff_files
@@ -1,2 +1 @@
 
-core/src/Cuda/Kokkos_Cuda_Atomic_Intrinsics.hpp
diff --git a/scripts/docker/Dockerfile.clang b/scripts/docker/Dockerfile.clang
index 9df93b5754..5c6abc1c6d 100644
--- a/scripts/docker/Dockerfile.clang
+++ b/scripts/docker/Dockerfile.clang
@@ -1,8 +1,9 @@
-FROM nvidia/cuda:9.2-devel
+FROM ubuntu:18.04
 
 RUN apt-get update && apt-get install -y \
         bc \
         git \
+        build-essential \
         wget \
         ccache \
         && \
@@ -34,7 +35,7 @@ ENV PATH=${CMAKE_DIR}/bin:$PATH
 
 ENV LLVM_DIR=/opt/llvm
 RUN LLVM_VERSION=8.0.0 && \
-    LLVM_URL=http://releases.llvm.org/${LLVM_VERSION}/clang+llvm-${LLVM_VERSION}-x86_64-linux-gnu-ubuntu-16.04.tar.xz && \
+    LLVM_URL=https://releases.llvm.org/${LLVM_VERSION}/clang+llvm-${LLVM_VERSION}-x86_64-linux-gnu-ubuntu-18.04.tar.xz && \
     LLVM_ARCHIVE=llvm-${LLVM_VERSION}.tar.xz && \
     SCRATCH_DIR=/scratch && mkdir -p ${SCRATCH_DIR} && cd ${SCRATCH_DIR} && \
     wget --quiet ${LLVM_URL} --output-document=${LLVM_ARCHIVE} && \
diff --git a/scripts/docker/Dockerfile.sycl b/scripts/docker/Dockerfile.sycl
index d7d764e8aa..4e185f4c1b 100644
--- a/scripts/docker/Dockerfile.sycl
+++ b/scripts/docker/Dockerfile.sycl
@@ -1,4 +1,4 @@
-ARG BASE=nvidia/cuda:10.2-devel
+ARG BASE=nvidia/cuda:11.7.0-devel-ubuntu22.04
 FROM $BASE
 
 RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
@@ -10,19 +10,11 @@ RUN apt-get update && apt-get install -y \
         ninja-build \
         python3 \
         git \
+        libomp-dev \
         && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
-# unbuntu18.04-based images have libstdc++ that is lacking filesystem support
-RUN apt-get update && \
-    apt-get install -y software-properties-common && \
-    add-apt-repository ppa:ubuntu-toolchain-r/test -y && \
-    apt-get update && \
-    apt-get install -y g++-9 && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
 RUN KEYDUMP_URL=https://cloud.cees.ornl.gov/download && \
     KEYDUMP_FILE=keydump && \
     wget --quiet ${KEYDUMP_URL}/${KEYDUMP_FILE} && \
@@ -46,19 +38,20 @@ RUN CMAKE_URL=https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSIO
     rm cmake*
 ENV PATH=${CMAKE_DIR}/bin:$PATH
 
-ENV SYCL_DIR=/opt/sycl
-RUN SYCL_VERSION=20220112 && \
-    SYCL_URL=https://github.com/intel/llvm/archive/sycl-nightly && \
-    SYCL_ARCHIVE=${SYCL_VERSION}.tar.gz && \
-    SCRATCH_DIR=/scratch && mkdir -p ${SCRATCH_DIR} && cd ${SCRATCH_DIR} && \
-    wget --quiet ${SYCL_URL}/${SYCL_ARCHIVE} && \
-    mkdir llvm && \
-    tar -xf ${SYCL_ARCHIVE} -C llvm --strip-components=1 && \
-    cd llvm && \
-    python3 buildbot/configure.py --cuda && \
-    python3 buildbot/compile.py && \
-    mkdir -p ${SYCL_DIR} && \
-    mv ${SCRATCH_DIR}/llvm/build/install/* ${SYCL_DIR} && \
-    echo "${SYCL_DIR}/lib" > /etc/ld.so.conf.d/sycl.conf && ldconfig && \
-    rm -rf ${SCRATCH_DIR}
-ENV PATH=${SYCL_DIR}/bin:$PATH
+RUN wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB && \
+    apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB && \
+    echo "deb https://apt.repos.intel.com/oneapi all main" | tee /etc/apt/sources.list.d/oneAPI.list && \
+    apt-get update -o Dir::Etc::sourcelist="sources.list.d/oneAPI.list" -o APT::Get::List-Cleanup="0" && \
+    apt-get install -y intel-oneapi-compiler-dpcpp-cpp-and-cpp-classic-2023.0.0 && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN wget https://cloud.cees.ornl.gov/download/oneapi-for-nvidia-gpus-2023.0.0-linux.sh && \
+    chmod +x oneapi-for-nvidia-gpus-2023.0.0-linux.sh && \
+    ./oneapi-for-nvidia-gpus-2023.0.0-linux.sh -y && \
+    rm oneapi-for-nvidia-gpus-2023.0.0-linux.sh
+
+RUN wget https://registrationcenter-download.intel.com/akdlm/irc_nas/19133/l_oneDPL_p_2022.0.0.25335.sh &&\
+    chmod +x ./l_oneDPL_p_2022.0.0.25335.sh && \
+    ./l_oneDPL_p_2022.0.0.25335.sh -a -s --eula accept && \
+    rm l_oneDPL_p_2022.0.0.25335.sh
diff --git a/scripts/testing_scripts/test_all_sandia b/scripts/testing_scripts/test_all_sandia
index 40c30ba7f4..a3dc9ffd34 100755
--- a/scripts/testing_scripts/test_all_sandia
+++ b/scripts/testing_scripts/test_all_sandia
@@ -105,10 +105,6 @@ if [[ "$HOSTNAME" == caraway* ]]; then
   MACHINE=caraway
 fi
 
-if [[ "$HOSTNAME" == kokkos-dev\.sandia\.gov* ]]; then
-  MACHINE=kokkos-dev
-fi
-
 if [[ "$HOSTNAME" == sogpu01* ]]; then
   MACHINE=sogpu
 fi
@@ -272,18 +268,12 @@ fi
 #
 
 if [ "$MACHINE" = "sems" ]; then
-  source /projects/sems/modulefiles/utils/sems-archive-modules-init.sh
-
-  # On unnamed sems machines, assume more restricted rhel7 environment
-  # On rhel7 sems machines gcc/7.3.0, clang/4.0.1, and intel/16.0.3 are missing
-  # Remove kokkkos-env module use
+  module purge
+  MODULE_ENVIRONMENT="sh /projects/sems/modulefiles/utils/sems-v2-modules-init.sh"
+  eval "$MODULE_ENVIRONMENT"
 
-  module load sems-archive-cmake/3.17.1
-  BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  OLDINTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/6.4.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  INTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CLANG_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA9_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
+  module load sems-cmake sems-git
+  BASE_MODULE_LIST="sems-cmake,sems-<COMPILER_NAME>/<COMPILER_VERSION>"
   SKIP_HWLOC=True
   # No sems hwloc module
 
@@ -291,130 +281,61 @@ if [ "$MACHINE" = "sems" ]; then
     ARCH_FLAG=""
   fi
 
-  if [ "$SPOT_CHECK" = "True" ]; then
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/5.3.0 $BASE_MODULE_LIST "OpenMP" g++ $GCC_WARNING_FLAGS"
-               "gcc/7.2.0 $BASE_MODULE_LIST "Serial" g++ $GCC_WARNING_FLAGS"
-               "intel/17.0.1 $INTEL_BASE_MODULE_LIST "OpenMP" icpc $INTEL_WARNING_FLAGS"
-               "cuda/9.2 $CUDA9_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-    )
-  else
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/5.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/6.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/6.4.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/9.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "clang/5.0.1 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/7.0.1 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/9.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/10.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "intel/17.0.1 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/18.0.5 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/19.0.5 $INTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "cuda/9.2 $CUDA9_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-    )
-  fi
+  # Format: (compiler module-list build-list exe-name warning-flag)
+  COMPILERS=("gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "gcc/10.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "clang/11.0.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
+             "clang/14.0.2 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
+             "intel/19.0.5 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+             "intel/19.1.2 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+             "intel/2021.3 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+  )
+
 elif [ "$MACHINE" = "sogpu" ]; then
-  source /projects/sems/modulefiles/utils/sems-archive-modules-init.sh
+  MODULE_ENVIRONMENT="sh /projects/sems/modulefiles/utils/sems-v2-modules-init.sh"
+  eval "$MODULE_ENVIRONMENT"
 
-  module load sems-archive-cmake/3.17.1 sems-archive-git
-  BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  OLDINTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/6.4.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  INTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CLANG_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA11_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/8.3.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
+  module load sems-cmake sems-git
+  BASE_MODULE_LIST="sems-cmake,sems-<COMPILER_NAME>/<COMPILER_VERSION>"
+  CUDA11_MODULE_LIST="sems-cmake,sems-gcc/8.3.0,sems-<COMPILER_NAME>/<COMPILER_VERSION>"
   SKIP_HWLOC=True
   # No sems hwloc module
 
+  echo "."
+  module list
   if [ -z "$ARCH_FLAG" ]; then
     ARCH_FLAG="--arch=Volta70"
   fi
 
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/5.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/6.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/6.4.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/9.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "clang/5.0.1 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/7.0.1 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/9.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/10.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "intel/17.0.1 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/18.0.5 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/19.0.5 $INTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "cuda/10.1 $CUDA_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/11.1 $CUDA11_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-              )
-elif [ "$MACHINE" = "kokkos-dev" ]; then
-  source /projects/sems/modulefiles/utils/sems-archive-modules-init.sh
-
-  module load sems-archive-cmake/3.17.1
-  BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  OLDINTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/6.4.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  INTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CLANG_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA9_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/6.1.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA10_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA11_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CLANG7_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-cuda/9.2,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  SKIP_HWLOC=True
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=Kepler35"
-  fi
+  echo "."
+  # Format: (compiler module-list build-list exe-name warning-flag)
+  COMPILERS=("gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "gcc/10.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "clang/11.0.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
+             "clang/14.0.2 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
+             "intel/19.0.5 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+             "intel/19.1.2 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+             "intel/2021.3 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+             "cuda/11.1.0 $CUDA11_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+             "cuda/11.4.2 $CUDA11_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+  )
 
-  if [ "$SPOT_CHECK" = "True" ]; then
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/5.3.0 $BASE_MODULE_LIST "OpenMP" g++ $GCC_WARNING_FLAGS"
-               "gcc/7.3.0 $BASE_MODULE_LIST "Serial" g++ $GCC_WARNING_FLAGS"
-               "intel/17.0.1 $OLDINTEL_BASE_MODULE_LIST "OpenMP" icpc $INTEL_WARNING_FLAGS"
-               "intel/18.0.5 $OLDINTEL_BASE_MODULE_LIST "Serial" icpc $INTEL_WARNING_FLAGS"
-               "intel/19.0.5 $INTEL_BASE_MODULE_LIST "Pthread_Serial" icpc $INTEL_WARNING_FLAGS"
-               "clang/5.0.1 $BASE_MODULE_LIST "Pthread_Serial" clang++ $CLANG_WARNING_FLAGS"
-               "clang/7.0.1 $CLANG7_MODULE_LIST "Cuda_OpenMP" clang++ $CLANG_WARNING_FLAGS"
-               "cuda/9.2 $CUDA9_MODULE_LIST "Cuda_OpenMP" $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-    )
-  else
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/5.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/6.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/9.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "intel/17.0.1 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/18.0.5 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/19.0.5 $INTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "clang/5.0.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/7.0.1 $CLANG7_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/9.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/10.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "cuda/10.1 $CUDA10_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/11.1 $CUDA11_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/9.2 $CUDA9_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-    )
-  fi
+  echo "."
+  echo "COMPILER VAR : $COMPILERS"
 
 elif [ "$MACHINE" = "weaver" ]; then
   source /etc/profile.d/modules.sh
   SKIP_HWLOC=True
 
-  # For rhel7W queue
-  BASE_MODULE_LIST="cmake/3.19.3,<COMPILER_NAME>/<COMPILER_VERSION>"
-
-  # For rhel8 queue
-  # Cuda/11 modules available only on the rhel8 queue (rhel8 OS)
-  RHEL8_BASE_MODULE_LIST="cmake/3.21.2,<COMPILER_NAME>/<COMPILER_VERSION>"
-  RHEL8_CUDA11_MODULE_LIST="cmake/3.21.2,<COMPILER_NAME>/<COMPILER_VERSION>"
+  # Cuda/11 modules available only on the dev queue (rhel8 OS); gcc/8.3.1 loaded by default
+  CUDA11_MODULE_LIST="cmake/3.21.2,<COMPILER_NAME>/<COMPILER_VERSION>"
 
   # Don't do pthread with Power
-  GCC_IBM_BUILD_LIST="OpenMP,Serial,OpenMP_Serial"
+  GCC_BUILD_LIST="OpenMP,Serial,OpenMP_Serial"
+
+  # Format: (compiler module-list build-list exe-name warning-flag)
+  COMPILERS=("cuda/11.2.2 $CUDA11_MODULE_LIST $CUDA_IBM_BUILD_LIST ${KOKKOS_PATH}/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+  )
 
   # Format: (compiler module-list build-list exe-name warning-flag)
   COMPILERS=("gcc/9.3.0 $BASE_MODULE_LIST $GCC_IBM_BUILD_LIST g++ $GCC_WARNING_FLAGS"
@@ -432,9 +353,7 @@ elif [ "$MACHINE" = "voltrino" ]; then
   BASE_MODULE_LIST="PrgEnv-intel,craype-mic-knl,cmake/3.16.2,slurm/20.11.4a,<COMPILER_NAME>/<COMPILER_VERSION>,gcc/9.3.0"
 
   # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("intel/17.0.4 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "intel/18.0.5 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "intel/19.0.4 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+  COMPILERS=("intel/19.0.4 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
   )
 
   if [ -z "$ARCH_FLAG" ]; then
@@ -448,8 +367,7 @@ elif [ "$MACHINE" = "mayer" ]; then
   BASE_MODULE_LIST="cmake/3.17.1,<COMPILER_NAME>/<COMPILER_VERSION>"
 
   # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("gnu7/7.2.0 $BASE_MODULE_LIST $ARM_GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-             "gnu9/9.3.0 $BASE_MODULE_LIST $ARM_GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+  COMPILERS=("gnu9/9.3.0 $BASE_MODULE_LIST $ARM_GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
              "arm/20.1 $BASE_MODULE_LIST $ARM_GCC_BUILD_LIST armclang++ $CLANG_WARNING_FLAGS")
 
   if [ -z "$ARCH_FLAG" ]; then
@@ -460,15 +378,12 @@ elif [ "$MACHINE" = "caraway" ]; then
   SKIP_HWLOC=True
 
   BASE_MODULE_LIST="cmake/3.19.3,<COMPILER_NAME>/<COMPILER_VERSION>"
-  # Cuda11 usage available on the V100 queue
-  CUDA11_MODULE_LIST="cmake/3.22.2,<COMPILER_NAME>/<COMPILER_VERSION>,gcc/8.2.0"
 
   HIPCLANG_BUILD_LIST="Hip_Serial,Hip_OpenMP"
   HIPCLANG_WARNING_FLAGS="-Werror -Wno-unused-command-line-argument -DNDEBUG"
 
   # Format: (compiler module-list build-list exe-name warning-flag)
   COMPILERS=("rocm/5.2.0 $BASE_MODULE_LIST $HIPCLANG_BUILD_LIST hipcc $HIPCLANG_WARNING_FLAGS"
-             "cuda/11.4 $CUDA11_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
              "gcc/8.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
              "gcc/9.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
              "gcc/10.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
@@ -491,13 +406,6 @@ elif [ "$MACHINE" = "blake" ]; then
   BASE_MODULE_LIST_ONEAPI="cmake/3.19.3,<COMPILER_NAME>/oneAPI/base-toolkit/<COMPILER_VERSION>"
   ONEAPI_WARNING_FLAGS=""
 
-  if [ "$SPOT_CHECK" = "True" ]; then
-
-  # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("intel/18.1.163 $BASE_MODULE_LIST_INTEL $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "gcc/7.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-  )
-  else
   COMPILERS=("intel/19.5.281 $BASE_MODULE_LIST_INTEL $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
              "intel/2021.1.1 $BASE_MODULE_LIST_ONEAPI $INTEL_BUILD_LIST icpx $ONEAPI_WARNING_FLAGS"
              "gcc/8.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
@@ -506,77 +414,46 @@ elif [ "$MACHINE" = "blake" ]; then
              "gcc/10.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
   )
 
-  fi
   if [ -z "$ARCH_FLAG" ]; then
     ARCH_FLAG="--arch=SKX"
   fi
 
 elif [ "$MACHINE" = "kokkos-dev-2" ]; then
+  module purge
   source /projects/sems/modulefiles/utils/sems-archive-modules-init.sh
   module use /home/projects/x86-64/modulefiles/local
-  module purge
   module load sems-archive-env
 
   module load sems-archive-git
-  module load sems-archive-tex
   module load sems-archive-cmake/3.17.1
   module load sems-archive-gdb
 
   SKIP_HWLOC=True
 
   BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  OLDINTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/6.4.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  INTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
+  INTEL_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/8.3.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
   CLANG_BASE_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CLANG8_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.2.0,cuda/10.0,<COMPILER_NAME>/<COMPILER_VERSION>"
   GCC91_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,<COMPILER_NAME>/<COMPILER_VERSION>"
-  NVCC9_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/5.3.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  NVCC_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.3.0,<COMPILER_NAME>/<COMPILER_VERSION>"
   NVCC_SEMSMODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/7.3.0,sems-archive-<COMPILER_NAME>/<COMPILER_VERSION>"
-  NVCC11_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,<COMPILER_NAME>/<COMPILER_VERSION>"
+  NVCC_MODULE_LIST="sems-archive-env,sems-archive-cmake/3.17.1,sems-archive-gcc/9.2.0,<COMPILER_NAME>/<COMPILER_VERSION>"
 
-  BUILD_LIST_CUDA_NVCC="Cuda_Serial,Cuda_Pthread"
-  BUILD_LIST_CUDA_CLANG="Cuda_Serial,Cuda_OpenMP"
   BUILD_LIST_CLANG="Serial,Pthread,OpenMP"
 
-  if [ "$SPOT_CHECK" = "True" ]; then
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/7.3.0 $BASE_MODULE_LIST "OpenMP,Pthread" g++ $GCC_WARNING_FLAGS"
-               "gcc/8.3.0 $BASE_MODULE_LIST "OpenMP" g++ $GCC_WARNING_FLAGS"
-               "gcc/9.1 $GCC91_MODULE_LIST "OpenMP,Serial" g++ $GCC_WARNING_FLAGS"
-               "intel/18.0.5 $OLDINTEL_BASE_MODULE_LIST "OpenMP" icpc $INTEL_WARNING_FLAGS"
-               "clang/8.0 $CLANG8_MODULE_LIST "Cuda_OpenMP,Pthread_Serial" clang++ $CLANG_WARNING_FLAGS"
-               "cuda/10.1 $NVCC_MODULE_LIST "Cuda_OpenMP" $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-    )
-  else
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("cuda/10.0 $NVCC_MODULE_LIST $BUILD_LIST_CUDA_NVCC $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/10.1 $NVCC_SEMSMODULE_LIST $BUILD_LIST_CUDA_NVCC $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/11.0 $NVCC11_MODULE_LIST $BUILD_LIST_CUDA_NVCC $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/11.1 $NVCC_SEMSMODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/11.2 $NVCC11_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/9.2 $NVCC9_MODULE_LIST $BUILD_LIST_CUDA_NVCC $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "clang/8.0 $CLANG8_MODULE_LIST $BUILD_LIST_CUDA_CLANG clang++ $CUDA_WARNING_FLAGS"
-               "clang/8.0 $CLANG8_MODULE_LIST $BUILD_LIST_CLANG clang++ $CLANG_WARNING_FLAGS"
-               "gcc/5.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/6.1.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/7.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/9.1 $GCC91_MODULE_LIST "$GCC_BUILD_LIST" g++ $GCC_WARNING_FLAGS"
-               "gcc/9.2.0 $BASE_MODULE_LIST "$GCC_BUILD_LIST" g++ $GCC_WARNING_FLAGS"
-               "intel/17.0.1 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/18.0.5 $OLDINTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/19.0.5 $INTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "clang/5.0.1 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/7.0.1 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/9.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/10.0.0 $CLANG_BASE_MODULE_LIST $BUILD_LIST_CLANG clang++ $CLANG_WARNING_FLAGS"
-    )
-  fi
+  # Format: (compiler module-list build-list exe-name warning-flag)
+  COMPILERS=("cuda/11.1 $NVCC_SEMSMODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+             "cuda/11.2 $NVCC_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+             "cuda/11.7 $NVCC_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+             "cuda/12.0 $NVCC_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
+             "gcc/8.3.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "gcc/9.1 $GCC91_MODULE_LIST "$GCC_BUILD_LIST" g++ $GCC_WARNING_FLAGS"
+             "gcc/9.2.0 $BASE_MODULE_LIST "$GCC_BUILD_LIST" g++ $GCC_WARNING_FLAGS"
+             "intel/19.0.5 $INTEL_BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
+             "clang/9.0.0 $CLANG_BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
+             "clang/10.0.0 $CLANG_BASE_MODULE_LIST $BUILD_LIST_CLANG clang++ $CLANG_WARNING_FLAGS"
+  )
 
   if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=SNB,Volta70"
+    ARCH_FLAG="--arch=Volta70"
   fi
 
 else
diff --git a/simd/CMakeLists.txt b/simd/CMakeLists.txt
index 83557e61e6..59e09b85ac 100644
--- a/simd/CMakeLists.txt
+++ b/simd/CMakeLists.txt
@@ -1,10 +1,5 @@
-
-KOKKOS_SUBPACKAGE(Simd)
-
 IF (NOT Kokkos_INSTALL_TESTING)
   ADD_SUBDIRECTORY(src)
 ENDIF()
 
 KOKKOS_ADD_TEST_DIRECTORIES(unit_tests)
-
-KOKKOS_SUBPACKAGE_POSTPROCESS()
diff --git a/simd/cmake/Dependencies.cmake b/simd/cmake/Dependencies.cmake
deleted file mode 100644
index 1d71d8af34..0000000000
--- a/simd/cmake/Dependencies.cmake
+++ /dev/null
@@ -1,5 +0,0 @@
-TRIBITS_PACKAGE_DEFINE_DEPENDENCIES(
-  LIB_REQUIRED_PACKAGES KokkosCore
-  LIB_OPTIONAL_TPLS Pthread CUDA HWLOC
-  TEST_OPTIONAL_TPLS CUSPARSE
-  )
diff --git a/simd/src/Kokkos_SIMD.hpp b/simd/src/Kokkos_SIMD.hpp
index 9280763407..a587394acd 100644
--- a/simd/src/Kokkos_SIMD.hpp
+++ b/simd/src/Kokkos_SIMD.hpp
@@ -47,7 +47,7 @@ using host_native  = avx2_fixed_size<4>;
 #elif defined(__ARM_NEON)
 using host_native  = neon_fixed_size<2>;
 #else
-using host_native  = scalar;
+using host_native   = scalar;
 #endif
 
 template <class T>
@@ -136,14 +136,25 @@ namespace Impl {
 template <class... Abis>
 class abi_set {};
 
+template <typename... Ts>
+class data_types {};
+
 #if defined(KOKKOS_ARCH_AVX512XEON)
-using host_abi_set = abi_set<simd_abi::scalar, simd_abi::avx512_fixed_size<8>>;
+using host_abi_set  = abi_set<simd_abi::scalar, simd_abi::avx512_fixed_size<8>>;
+using data_type_set = data_types<std::int32_t, std::uint32_t, std::int64_t,
+                                 std::uint64_t, double>;
 #elif defined(KOKKOS_ARCH_AVX2)
 using host_abi_set = abi_set<simd_abi::scalar, simd_abi::avx2_fixed_size<4>>;
+using data_type_set =
+    data_types<std::int32_t, std::int64_t, std::uint64_t, double>;
 #elif defined(__ARM_NEON)
 using host_abi_set = abi_set<simd_abi::scalar, simd_abi::neon_fixed_size<2>>;
+using data_type_set =
+    data_types<std::int32_t, std::int64_t, std::uint64_t, double>;
 #else
-using host_abi_set = abi_set<simd_abi::scalar>;
+using host_abi_set  = abi_set<simd_abi::scalar>;
+using data_type_set = data_types<std::int32_t, std::uint32_t, std::int64_t,
+                                 std::uint64_t, double>;
 #endif
 
 using device_abi_set = abi_set<simd_abi::scalar>;
diff --git a/simd/src/Kokkos_SIMD_AVX2.hpp b/simd/src/Kokkos_SIMD_AVX2.hpp
index 1732c33ca5..1c4ff4765d 100644
--- a/simd/src/Kokkos_SIMD_AVX2.hpp
+++ b/simd/src/Kokkos_SIMD_AVX2.hpp
@@ -21,6 +21,7 @@
 #include <type_traits>
 
 #include <Kokkos_SIMD_Common.hpp>
+#include <Kokkos_BitManipulation.hpp>  // bit_cast
 
 #include <immintrin.h>
 
@@ -389,9 +390,6 @@ class simd<double, simd_abi::avx2_fixed_size<4>> {
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
       : m_value(_mm256_set1_pd(value_type(value))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(double a, double b, double c,
-                                             double d)
-      : m_value(_mm256_setr_pd(a, b, c, d)) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
       __m256d const& value_in)
       : m_value(value_in) {}
@@ -586,19 +584,17 @@ class simd<std::int32_t, simd_abi::avx2_fixed_size<4>> {
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
       : m_value(_mm_set1_epi32(value_type(value))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(std::int32_t a, std::int32_t b,
-                                             std::int32_t c, std::int32_t d)
-      : m_value(_mm_setr_epi32(a, b, c, d)) {}
   template <class G,
             std::enable_if_t<
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen)
-      : simd(gen(std::integral_constant<std::size_t, 0>()),
-             gen(std::integral_constant<std::size_t, 1>()),
-             gen(std::integral_constant<std::size_t, 2>()),
-             gen(std::integral_constant<std::size_t, 3>())) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen)
+      : m_value(_mm_setr_epi32(gen(std::integral_constant<std::size_t, 0>()),
+                               gen(std::integral_constant<std::size_t, 1>()),
+                               gen(std::integral_constant<std::size_t, 2>()),
+                               gen(std::integral_constant<std::size_t, 3>()))) {
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
       __m128i const& value_in)
       : m_value(value_in) {}
@@ -680,6 +676,8 @@ template <>
 class simd<std::int64_t, simd_abi::avx2_fixed_size<4>> {
   __m256i m_value;
 
+  static_assert(sizeof(long long) == 8);
+
  public:
   using value_type = std::int64_t;
   using abi_type   = simd_abi::avx2_fixed_size<4>;
@@ -697,19 +695,17 @@ class simd<std::int64_t, simd_abi::avx2_fixed_size<4>> {
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
       : m_value(_mm256_set1_epi64x(value_type(value))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(std::int64_t a, std::int64_t b,
-                                             std::int64_t c, std::int64_t d)
-      : m_value(_mm256_setr_epi64x(a, b, c, d)) {}
   template <class G,
             std::enable_if_t<
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen)
-      : simd(gen(std::integral_constant<std::size_t, 0>()),
-             gen(std::integral_constant<std::size_t, 1>()),
-             gen(std::integral_constant<std::size_t, 2>()),
-             gen(std::integral_constant<std::size_t, 3>())) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen)
+      : m_value(_mm256_setr_epi64x(
+            gen(std::integral_constant<std::size_t, 0>()),
+            gen(std::integral_constant<std::size_t, 1>()),
+            gen(std::integral_constant<std::size_t, 2>()),
+            gen(std::integral_constant<std::size_t, 3>()))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
       __m256i const& value_in)
       : m_value(value_in) {}
@@ -727,11 +723,13 @@ class simd<std::int64_t, simd_abi::avx2_fixed_size<4>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
-    m_value = _mm256_maskload_epi64(ptr, static_cast<__m256i>(mask_type(true)));
+    m_value = _mm256_maskload_epi64(reinterpret_cast<long long const*>(ptr),
+                                    static_cast<__m256i>(mask_type(true)));
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
-    _mm256_maskstore_epi64(ptr, static_cast<__m256i>(mask_type(true)), m_value);
+    _mm256_maskstore_epi64(reinterpret_cast<long long*>(ptr),
+                           static_cast<__m256i>(mask_type(true)), m_value);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
       const {
@@ -778,6 +776,14 @@ class simd<std::int64_t, simd_abi::avx2_fixed_size<4>> {
   return simd<std::int64_t, simd_abi::avx2_fixed_size<4>>(0) - a;
 }
 
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int64_t, simd_abi::avx2_fixed_size<4>>
+    operator+(simd<std::int64_t, simd_abi::avx2_fixed_size<4>> const& lhs,
+              simd<std::int64_t, simd_abi::avx2_fixed_size<4>> const& rhs) {
+  return simd<std::int64_t, simd_abi::avx2_fixed_size<4>>(
+      _mm256_add_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+}
+
 KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
 simd<std::int64_t, simd_abi::avx2_fixed_size<4>> condition(
     simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>> const& a,
@@ -804,13 +810,24 @@ class simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator=(simd const&) = default;
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd& operator=(simd&&) = default;
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
-    return 8;
+    return 4;
   }
   template <class U, std::enable_if_t<std::is_convertible_v<U, value_type>,
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
-      : m_value(_mm256_set1_epi64x(bit_cast<std::int64_t>(value_type(value)))) {
-  }
+      : m_value(_mm256_set1_epi64x(
+            Kokkos::bit_cast<std::int64_t>(value_type(value)))) {}
+  template <class G,
+            std::enable_if_t<
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen)
+      : m_value(_mm256_setr_epi64x(
+            gen(std::integral_constant<std::size_t, 0>()),
+            gen(std::integral_constant<std::size_t, 1>()),
+            gen(std::integral_constant<std::size_t, 2>()),
+            gen(std::integral_constant<std::size_t, 3>()))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr simd(__m256i const& value_in)
       : m_value(value_in) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
@@ -826,6 +843,11 @@ class simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> {
   operator[](std::size_t i) const {
     return reinterpret_cast<value_type const*>(&m_value)[i];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       element_aligned_tag) {
+    m_value = _mm256_maskload_epi64(reinterpret_cast<long long const*>(ptr),
+                                    static_cast<__m256i>(mask_type(true)));
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
   operator>>(unsigned int rhs) const {
     return _mm256_srli_epi64(m_value, rhs);
@@ -871,6 +893,22 @@ simd<std::int64_t, simd_abi::avx2_fixed_size<4>>::simd(
     simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& other)
     : m_value(static_cast<__m256i>(other)) {}
 
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>
+    operator+(simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& lhs,
+              simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& rhs) {
+  return simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>(
+      _mm256_add_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>
+    operator-(simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& lhs,
+              simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& rhs) {
+  return simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>(
+      _mm256_sub_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+}
+
 KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
 simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> condition(
     simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& a,
@@ -905,14 +943,7 @@ class const_where_expression<simd_mask<double, simd_abi::avx2_fixed_size<4>>,
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
-    return m_mask;
-  }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
-    return m_value;
-  }
+
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_to(double* mem, element_aligned_tag) const {
     _mm256_maskstore_pd(mem, _mm256_castpd_si256(static_cast<__m256d>(m_mask)),
@@ -926,6 +957,16 @@ class const_where_expression<simd_mask<double, simd_abi::avx2_fixed_size<4>>,
       if (m_mask[lane]) mem[index[lane]] = m_value[lane];
     }
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <>
@@ -982,19 +1023,22 @@ class const_where_expression<
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
-    return m_mask;
-  }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
-    return m_value;
-  }
+
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_to(std::int32_t* mem, element_aligned_tag) const {
     _mm_maskstore_epi32(mem, static_cast<__m128i>(m_mask),
                         static_cast<__m128i>(m_value));
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <>
@@ -1012,6 +1056,156 @@ class where_expression<simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>>,
   void copy_from(std::int32_t const* mem, element_aligned_tag) {
     m_value = value_type(_mm_maskload_epi32(mem, static_cast<__m128i>(m_mask)));
   }
+  template <
+      class U,
+      std::enable_if_t<std::is_convertible_v<
+                           U, simd<std::int32_t, simd_abi::avx2_fixed_size<4>>>,
+                       bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::int32_t, simd_abi::avx2_fixed_size<4>>>(
+            std::forward<U>(x));
+    m_value = simd<std::int32_t, simd_abi::avx2_fixed_size<4>>(_mm_castps_si128(
+        _mm_blendv_ps(_mm_castsi128_ps(static_cast<__m128i>(m_value)),
+                      _mm_castsi128_ps(static_cast<__m128i>(x_as_value_type)),
+                      _mm_castsi128_ps(static_cast<__m128i>(m_mask)))));
+  }
+};
+
+template <>
+class const_where_expression<
+    simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>>,
+    simd<std::int64_t, simd_abi::avx2_fixed_size<4>>> {
+ public:
+  using abi_type   = simd_abi::avx2_fixed_size<4>;
+  using value_type = simd<std::int64_t, abi_type>;
+  using mask_type  = simd_mask<std::int64_t, abi_type>;
+
+ protected:
+  value_type& m_value;
+  mask_type const& m_mask;
+
+ public:
+  const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
+      : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      std::int64_t* mem, element_aligned_tag) const {
+    _mm256_maskstore_epi64(reinterpret_cast<long long*>(mem),
+                           static_cast<__m256i>(m_mask),
+                           static_cast<__m256i>(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>>,
+                       simd<std::int64_t, simd_abi::avx2_fixed_size<4>>>
+    : public const_where_expression<
+          simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>>,
+          simd<std::int64_t, simd_abi::avx2_fixed_size<4>>> {
+ public:
+  where_expression(
+      simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>> const& mask_arg,
+      simd<std::int64_t, simd_abi::avx2_fixed_size<4>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(std::int64_t const* mem,
+                                                       element_aligned_tag) {
+    m_value = value_type(_mm256_maskload_epi64(
+        reinterpret_cast<long long const*>(mem), static_cast<__m256i>(m_mask)));
+  }
+  template <
+      class u,
+      std::enable_if_t<std::is_convertible_v<
+                           u, simd<std::int64_t, simd_abi::avx2_fixed_size<4>>>,
+                       bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(u&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::int64_t, simd_abi::avx2_fixed_size<4>>>(
+            std::forward<u>(x));
+    m_value = simd<std::int64_t, simd_abi::avx2_fixed_size<4>>(
+        _mm256_castpd_si256(_mm256_blendv_pd(
+            _mm256_castsi256_pd(static_cast<__m256i>(m_value)),
+            _mm256_castsi256_pd(static_cast<__m256i>(x_as_value_type)),
+            _mm256_castsi256_pd(static_cast<__m256i>(m_mask)))));
+  }
+};
+
+template <>
+class const_where_expression<
+    simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>>,
+    simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>> {
+ public:
+  using abi_type   = simd_abi::avx2_fixed_size<4>;
+  using value_type = simd<std::uint64_t, abi_type>;
+  using mask_type  = simd_mask<std::uint64_t, abi_type>;
+
+ protected:
+  value_type& m_value;
+  mask_type const& m_mask;
+
+ public:
+  const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
+      : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      std::uint64_t* mem, element_aligned_tag) const {
+    _mm256_maskstore_epi64(reinterpret_cast<long long*>(mem),
+                           static_cast<__m256i>(m_mask),
+                           static_cast<__m256i>(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>>,
+                       simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>>
+    : public const_where_expression<
+          simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>>,
+          simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>> {
+ public:
+  where_expression(
+      simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& mask_arg,
+      simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(std::uint64_t const* mem,
+                                                       element_aligned_tag) {
+    m_value = value_type(_mm256_maskload_epi64(
+        reinterpret_cast<long long const*>(mem), static_cast<__m256i>(m_mask)));
+  }
+  template <class u,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    u, simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(u&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>>(
+            std::forward<u>(x));
+    m_value = simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>(
+        _mm256_castpd_si256(_mm256_blendv_pd(
+            _mm256_castsi256_pd(static_cast<__m256i>(m_value)),
+            _mm256_castsi256_pd(static_cast<__m256i>(x_as_value_type)),
+            _mm256_castsi256_pd(static_cast<__m256i>(m_mask)))));
+  }
 };
 
 }  // namespace Experimental
diff --git a/simd/src/Kokkos_SIMD_AVX512.hpp b/simd/src/Kokkos_SIMD_AVX512.hpp
index b63bb569bb..240314a8c1 100644
--- a/simd/src/Kokkos_SIMD_AVX512.hpp
+++ b/simd/src/Kokkos_SIMD_AVX512.hpp
@@ -21,6 +21,7 @@
 #include <type_traits>
 
 #include <Kokkos_SIMD_Common.hpp>
+#include <Kokkos_BitManipulation.hpp>  // bit_cast
 
 #include <immintrin.h>
 
@@ -86,7 +87,8 @@ class simd_mask<T, simd_abi::avx512_fixed_size<8>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
   operator[](std::size_t i) const {
-    return static_cast<value_type>(reference(m_value, int(i)));
+    auto const bit_mask = __mmask8(std::int16_t(1 << i));
+    return (m_value & bit_mask) != 0;
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
   operator||(simd_mask const& other) const {
@@ -143,7 +145,7 @@ class simd<std::int32_t, simd_abi::avx512_fixed_size<8>> {
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen)
       : m_value(
             _mm256_setr_epi32(gen(std::integral_constant<std::size_t, 0>()),
                               gen(std::integral_constant<std::size_t, 1>()),
@@ -260,7 +262,8 @@ class simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> {
   template <class U, std::enable_if_t<std::is_convertible_v<U, value_type>,
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
-      : m_value(_mm256_set1_epi32(bit_cast<std::int32_t>(value_type(value)))) {}
+      : m_value(_mm256_set1_epi32(
+            Kokkos::bit_cast<std::int32_t>(value_type(value)))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
       __m256i const& value_in)
       : m_value(value_in) {}
@@ -274,6 +277,16 @@ class simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> {
   operator[](std::size_t i) const {
     return reinterpret_cast<value_type const*>(&m_value)[i];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm256_mask_storeu_epi32(ptr, static_cast<__mmask8>(mask_type(true)),
+                             m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       element_aligned_tag) {
+    m_value = _mm256_mask_loadu_epi32(
+        _mm256_set1_epi32(0), static_cast<__mmask8>(mask_type(true)), ptr);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
       const {
     return m_value;
@@ -373,10 +386,13 @@ class simd<std::int64_t, simd_abi::avx512_fixed_size<8>> {
   operator[](std::size_t i) const {
     return reinterpret_cast<value_type const*>(&m_value)[i];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       element_aligned_tag) {
+    m_value = _mm512_loadu_si512(ptr);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
-    _mm512_mask_storeu_epi64(ptr, static_cast<__mmask8>(mask_type(true)),
-                             m_value);
+    _mm512_storeu_si512(ptr, m_value);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator>>(int rhs) const {
     return _mm512_srai_epi64(m_value, rhs);
@@ -484,7 +500,8 @@ class simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> {
   template <class U, std::enable_if_t<std::is_convertible_v<U, value_type>,
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
-      : m_value(_mm512_set1_epi64(bit_cast<std::int64_t>(value_type(value)))) {}
+      : m_value(_mm512_set1_epi64(
+            Kokkos::bit_cast<std::int64_t>(value_type(value)))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr simd(__m512i const& value_in)
       : m_value(value_in) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
@@ -500,6 +517,14 @@ class simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> {
   operator[](std::size_t i) const {
     return reinterpret_cast<value_type const*>(&m_value)[i];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       element_aligned_tag) {
+    m_value = _mm512_loadu_si512(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm512_storeu_si512(ptr, m_value);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
   operator>>(unsigned int rhs) const {
     return _mm512_srli_epi64(m_value, rhs);
@@ -621,10 +646,6 @@ class simd<double, simd_abi::avx512_fixed_size<8>> {
                                       bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(U&& value)
       : m_value(_mm512_set1_pd(value_type(value))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(double a, double b, double c,
-                                             double d, double e, double f,
-                                             double g, double h)
-      : m_value(_mm512_setr_pd(a, b, c, d, e, f, g, h)) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
       __m512d const& value_in)
       : m_value(value_in) {}
@@ -818,14 +839,7 @@ class const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
-    return m_mask;
-  }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
-    return m_value;
-  }
+
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_to(double* mem, element_aligned_tag) const {
     _mm512_mask_storeu_pd(mem, static_cast<__mmask8>(m_mask),
@@ -839,6 +853,16 @@ class const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
                               static_cast<__m256i>(index),
                               static_cast<__m512d>(m_value), 8);
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <>
@@ -895,19 +919,22 @@ class const_where_expression<
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
-    return m_mask;
-  }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
-    return m_value;
-  }
+
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_to(std::int32_t* mem, element_aligned_tag) const {
     _mm256_mask_storeu_epi32(mem, static_cast<__mmask8>(m_mask),
                              static_cast<__m256i>(m_value));
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <>
@@ -926,6 +953,86 @@ class where_expression<simd_mask<std::int32_t, simd_abi::avx512_fixed_size<8>>,
     m_value = value_type(_mm256_mask_loadu_epi32(
         _mm256_set1_epi32(0), static_cast<__mmask8>(m_mask), mem));
   }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::int32_t, simd_abi::avx512_fixed_size<8>>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::int32_t, simd_abi::avx512_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
+        _mm256_mask_blend_epi32(static_cast<__mmask8>(m_mask),
+                                static_cast<__m256i>(m_value),
+                                static_cast<__m256i>(x_as_value_type)));
+  }
+};
+
+template <>
+class const_where_expression<
+    simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>>,
+    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using value_type = simd<std::uint32_t, abi_type>;
+  using mask_type  = simd_mask<std::uint32_t, abi_type>;
+
+ protected:
+  value_type& m_value;
+  mask_type const& m_mask;
+
+ public:
+  const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
+      : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint32_t* mem, element_aligned_tag) const {
+    _mm256_mask_storeu_epi32(mem, static_cast<__mmask8>(m_mask),
+                             static_cast<__m256i>(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>>,
+                       simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>>,
+          simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  where_expression(
+      simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& mask_arg,
+      simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint32_t const* mem, element_aligned_tag) {
+    m_value = value_type(_mm256_mask_loadu_epi32(
+        _mm256_set1_epi32(0), static_cast<__mmask8>(m_mask), mem));
+  }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>(
+        _mm256_mask_blend_epi32(static_cast<__mmask8>(m_mask),
+                                static_cast<__m256i>(m_value),
+                                static_cast<__m256i>(x_as_value_type)));
+  }
 };
 
 template <>
@@ -944,14 +1051,120 @@ class const_where_expression<
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int64_t* mem, element_aligned_tag) const {
+    _mm512_mask_storeu_epi64(mem, static_cast<__mmask8>(m_mask),
+                             static_cast<__m512i>(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
     return m_mask;
   }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
+};
+
+template <>
+class where_expression<simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>>,
+                       simd<std::int64_t, simd_abi::avx512_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>>,
+          simd<std::int64_t, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  where_expression(
+      simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>> const& mask_arg,
+      simd<std::int64_t, simd_abi::avx512_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int64_t const* mem, element_aligned_tag) {
+    m_value = value_type(_mm512_mask_loadu_epi64(
+        _mm512_set1_epi64(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::int64_t, simd_abi::avx512_fixed_size<8>>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::int64_t, simd_abi::avx512_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(
+        _mm512_mask_blend_epi64(static_cast<__mmask8>(m_mask),
+                                static_cast<__m512i>(m_value),
+                                static_cast<__m512i>(x_as_value_type)));
+  }
+};
+
+template <>
+class const_where_expression<
+    simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>>,
+    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using value_type = simd<std::uint64_t, abi_type>;
+  using mask_type  = simd_mask<std::uint64_t, abi_type>;
+
+ protected:
+  value_type& m_value;
+  mask_type const& m_mask;
+
+ public:
+  const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
+      : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint64_t* mem, element_aligned_tag) const {
+    _mm512_mask_storeu_epi64(mem, static_cast<__mmask8>(m_mask),
+                             static_cast<__m512i>(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
     return m_value;
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>>,
+                       simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>>,
+          simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  where_expression(
+      simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& mask_arg,
+      simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint64_t const* mem, element_aligned_tag) {
+    m_value = value_type(_mm512_mask_loadu_epi64(
+        _mm512_set1_epi64(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>(
+        _mm512_mask_blend_epi64(static_cast<__mmask8>(m_mask),
+                                static_cast<__m512i>(m_value),
+                                static_cast<__m512i>(x_as_value_type)));
+  }
 };
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION std::int32_t hmax(
@@ -959,16 +1172,16 @@ class const_where_expression<
         simd_mask<std::int32_t, simd_abi::avx512_fixed_size<8>>,
         simd<std::int32_t, simd_abi::avx512_fixed_size<8>>> const& x) {
   return _mm512_mask_reduce_max_epi32(
-      static_cast<__mmask8>(x.mask()),
-      _mm512_castsi256_si512(static_cast<__m256i>(x.value())));
+      static_cast<__mmask8>(x.impl_get_mask()),
+      _mm512_castsi256_si512(static_cast<__m256i>(x.impl_get_value())));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION double hmin(
     const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
                            simd<double, simd_abi::avx512_fixed_size<8>>> const&
         x) {
-  return _mm512_mask_reduce_min_pd(static_cast<__mmask8>(x.mask()),
-                                   static_cast<__m512d>(x.value()));
+  return _mm512_mask_reduce_min_pd(static_cast<__mmask8>(x.impl_get_mask()),
+                                   static_cast<__m512d>(x.impl_get_value()));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION std::int64_t reduce(
@@ -976,8 +1189,8 @@ class const_where_expression<
         simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>>,
         simd<std::int64_t, simd_abi::avx512_fixed_size<8>>> const& x,
     std::int64_t, std::plus<>) {
-  return _mm512_mask_reduce_add_epi64(static_cast<__mmask8>(x.mask()),
-                                      static_cast<__m512i>(x.value()));
+  return _mm512_mask_reduce_add_epi64(static_cast<__mmask8>(x.impl_get_mask()),
+                                      static_cast<__m512i>(x.impl_get_value()));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION double reduce(
@@ -985,8 +1198,8 @@ class const_where_expression<
                            simd<double, simd_abi::avx512_fixed_size<8>>> const&
         x,
     double, std::plus<>) {
-  return _mm512_mask_reduce_add_pd(static_cast<__mmask8>(x.mask()),
-                                   static_cast<__m512d>(x.value()));
+  return _mm512_mask_reduce_add_pd(static_cast<__mmask8>(x.impl_get_mask()),
+                                   static_cast<__m512d>(x.impl_get_value()));
 }
 
 }  // namespace Experimental
diff --git a/simd/src/Kokkos_SIMD_Common.hpp b/simd/src/Kokkos_SIMD_Common.hpp
index c29d49fb3a..de11640430 100644
--- a/simd/src/Kokkos_SIMD_Common.hpp
+++ b/simd/src/Kokkos_SIMD_Common.hpp
@@ -26,14 +26,6 @@ namespace Kokkos {
 
 namespace Experimental {
 
-template <class To, class From>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION constexpr To bit_cast(
-    From const& src) {
-  To dst;
-  std::memcpy(&dst, &src, sizeof(To));
-  return dst;
-}
-
 template <class T, class Abi>
 class simd;
 
@@ -100,14 +92,14 @@ class where_expression<bool, T> : public const_where_expression<bool, T> {
 };
 
 template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
     where_expression<simd_mask<T, Abi>, simd<T, Abi>>
     where(typename simd<T, Abi>::mask_type const& mask, simd<T, Abi>& value) {
   return where_expression(mask, value);
 }
 
 template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
     const_where_expression<simd_mask<T, Abi>, simd<T, Abi>>
     where(typename simd<T, Abi>::mask_type const& mask,
           simd<T, Abi> const& value) {
@@ -316,28 +308,28 @@ KOKKOS_FORCEINLINE_FUNCTION where_expression<M, T>& operator/=(
 // fallback implementations of reductions across simd_mask:
 
 template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION bool all_of(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool all_of(
     simd_mask<T, Abi> const& a) {
   return a == simd_mask<T, Abi>(true);
 }
 
 template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION bool any_of(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool any_of(
     simd_mask<T, Abi> const& a) {
   return a != simd_mask<T, Abi>(false);
 }
 
 template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION bool none_of(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool none_of(
     simd_mask<T, Abi> const& a) {
   return a == simd_mask<T, Abi>(false);
 }
 
-template <class T, class Abi>
+template <typename T, typename Abi>
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T
 hmin(const_where_expression<simd_mask<T, Abi>, simd<T, Abi>> const& x) {
-  auto const& v = x.value();
-  auto const& m = x.mask();
+  auto const& v = x.impl_get_value();
+  auto const& m = x.impl_get_mask();
   auto result   = Kokkos::reduction_identity<T>::min();
   for (std::size_t i = 0; i < v.size(); ++i) {
     if (m[i]) result = Kokkos::min(result, v[i]);
@@ -348,8 +340,8 @@ hmin(const_where_expression<simd_mask<T, Abi>, simd<T, Abi>> const& x) {
 template <class T, class Abi>
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T
 hmax(const_where_expression<simd_mask<T, Abi>, simd<T, Abi>> const& x) {
-  auto const& v = x.value();
-  auto const& m = x.mask();
+  auto const& v = x.impl_get_value();
+  auto const& m = x.impl_get_mask();
   auto result   = Kokkos::reduction_identity<T>::max();
   for (std::size_t i = 0; i < v.size(); ++i) {
     if (m[i]) result = Kokkos::max(result, v[i]);
@@ -361,8 +353,8 @@ template <class T, class Abi>
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION T
 reduce(const_where_expression<simd_mask<T, Abi>, simd<T, Abi>> const& x, T,
        std::plus<>) {
-  auto const& v = x.value();
-  auto const& m = x.mask();
+  auto const& v = x.impl_get_value();
+  auto const& m = x.impl_get_mask();
   auto result   = Kokkos::reduction_identity<T>::sum();
   for (std::size_t i = 0; i < v.size(); ++i) {
     if (m[i]) result += v[i];
diff --git a/simd/src/Kokkos_SIMD_NEON.hpp b/simd/src/Kokkos_SIMD_NEON.hpp
index 2473004098..612137a060 100644
--- a/simd/src/Kokkos_SIMD_NEON.hpp
+++ b/simd/src/Kokkos_SIMD_NEON.hpp
@@ -299,7 +299,7 @@ class simd<double, simd_abi::neon_fixed_size<2>> {
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen) {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen) {
     m_value = vsetq_lane_f64(gen(std::integral_constant<std::size_t, 0>()),
                              m_value, 0);
     m_value = vsetq_lane_f64(gen(std::integral_constant<std::size_t, 1>()),
@@ -502,7 +502,7 @@ class simd<std::int32_t, simd_abi::neon_fixed_size<2>> {
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen) {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen) {
     m_value = vset_lane_s32(gen(std::integral_constant<std::size_t, 0>()),
                             m_value, 0);
     m_value = vset_lane_s32(gen(std::integral_constant<std::size_t, 1>()),
@@ -640,7 +640,7 @@ class simd<std::int64_t, simd_abi::neon_fixed_size<2>> {
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen) {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen) {
     m_value = vsetq_lane_s64(gen(std::integral_constant<std::size_t, 0>()),
                              m_value, 0);
     m_value = vsetq_lane_s64(gen(std::integral_constant<std::size_t, 1>()),
@@ -778,7 +778,7 @@ class simd<std::uint64_t, simd_abi::neon_fixed_size<2>> {
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen) {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen) {
     m_value = vsetq_lane_u64(gen(std::integral_constant<std::size_t, 0>()),
                              m_value, 0);
     m_value = vsetq_lane_u64(gen(std::integral_constant<std::size_t, 1>()),
@@ -798,6 +798,10 @@ class simd<std::uint64_t, simd_abi::neon_fixed_size<2>> {
   operator[](std::size_t i) const {
     return reference(const_cast<simd*>(this)->m_value, int(i));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       element_aligned_tag) {
+    m_value = vld1q_u64(ptr);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
   operator&(simd const& other) const {
     return simd(vandq_u64(m_value, other.m_value));
@@ -880,14 +884,7 @@ class const_where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
-    return m_mask;
-  }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
-    return m_value;
-  }
+
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_to(double* mem, element_aligned_tag) const {
     if (m_mask[0]) mem[0] = m_value[0];
@@ -900,6 +897,16 @@ class const_where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
     if (m_mask[0]) mem[index[0]] = m_value[0];
     if (m_mask[1]) mem[index[1]] = m_value[1];
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <>
@@ -956,19 +963,22 @@ class const_where_expression<
  public:
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr mask_type const&
-  mask() const {
-    return m_mask;
-  }
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr value_type const&
-  value() const {
-    return m_value;
-  }
+
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_to(std::int32_t* mem, element_aligned_tag) const {
     if (m_mask[0]) mem[0] = m_value[0];
     if (m_mask[1]) mem[1] = m_value[1];
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <>
@@ -987,6 +997,152 @@ class where_expression<simd_mask<std::int32_t, simd_abi::neon_fixed_size<2>>,
     if (m_mask[0]) m_value[0] = mem[0];
     if (m_mask[1]) m_value[1] = mem[1];
   }
+  template <
+      class U,
+      std::enable_if_t<
+          std::is_convertible_v<U, simd<int32_t, simd_abi::neon_fixed_size<2>>>,
+          bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<int32_t, simd_abi::neon_fixed_size<2>>>(
+            std::forward<U>(x));
+    m_value = static_cast<simd<int32_t, simd_abi::neon_fixed_size<2>>>(
+        vbsl_s32(static_cast<uint32x2_t>(m_mask),
+                 static_cast<int32x2_t>(x_as_value_type),
+                 static_cast<int32x2_t>(m_value)));
+  }
+};
+
+template <>
+class const_where_expression<
+    simd_mask<std::int64_t, simd_abi::neon_fixed_size<2>>,
+    simd<std::int64_t, simd_abi::neon_fixed_size<2>>> {
+ public:
+  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using value_type = simd<std::int64_t, abi_type>;
+  using mask_type  = simd_mask<std::int64_t, abi_type>;
+
+ protected:
+  value_type& m_value;
+  mask_type const& m_mask;
+
+ public:
+  const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
+      : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int64_t* mem, element_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<std::int64_t, simd_abi::neon_fixed_size<2>>,
+                       simd<std::int64_t, simd_abi::neon_fixed_size<2>>>
+    : public const_where_expression<
+          simd_mask<std::int64_t, simd_abi::neon_fixed_size<2>>,
+          simd<std::int64_t, simd_abi::neon_fixed_size<2>>> {
+ public:
+  where_expression(
+      simd_mask<std::int64_t, simd_abi::neon_fixed_size<2>> const& mask_arg,
+      simd<std::int64_t, simd_abi::neon_fixed_size<2>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int64_t const* mem, element_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+  template <
+      class U,
+      std::enable_if_t<std::is_convertible_v<
+                           U, simd<std::int64_t, simd_abi::neon_fixed_size<2>>>,
+                       bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::int64_t, simd_abi::neon_fixed_size<2>>>(
+            std::forward<U>(x));
+    m_value = static_cast<simd<std::int64_t, simd_abi::neon_fixed_size<2>>>(
+        vbslq_s64(static_cast<uint64x2_t>(m_mask),
+                  static_cast<int64x2_t>(x_as_value_type),
+                  static_cast<int64x2_t>(m_value)));
+  }
+};
+
+template <>
+class const_where_expression<
+    simd_mask<std::uint64_t, simd_abi::neon_fixed_size<2>>,
+    simd<std::uint64_t, simd_abi::neon_fixed_size<2>>> {
+ public:
+  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using value_type = simd<std::uint64_t, abi_type>;
+  using mask_type  = simd_mask<std::uint64_t, abi_type>;
+
+ protected:
+  value_type& m_value;
+  mask_type const& m_mask;
+
+ public:
+  const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
+      : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint64_t* mem, element_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<std::uint64_t, simd_abi::neon_fixed_size<2>>,
+                       simd<std::uint64_t, simd_abi::neon_fixed_size<2>>>
+    : public const_where_expression<
+          simd_mask<std::uint64_t, simd_abi::neon_fixed_size<2>>,
+          simd<std::uint64_t, simd_abi::neon_fixed_size<2>>> {
+ public:
+  where_expression(
+      simd_mask<std::uint64_t, simd_abi::neon_fixed_size<2>> const& mask_arg,
+      simd<std::uint64_t, simd_abi::neon_fixed_size<2>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint64_t const* mem, element_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::uint64_t, simd_abi::neon_fixed_size<2>>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<std::uint64_t, simd_abi::neon_fixed_size<2>>>(
+            std::forward<U>(x));
+    m_value = static_cast<simd<std::uint64_t, simd_abi::neon_fixed_size<2>>>(
+        vbslq_u64(static_cast<uint64x2_t>(m_mask),
+                  static_cast<uint64x2_t>(x_as_value_type),
+                  static_cast<uint64x2_t>(m_value)));
+  }
 };
 
 }  // namespace Experimental
diff --git a/simd/src/Kokkos_SIMD_Scalar.hpp b/simd/src/Kokkos_SIMD_Scalar.hpp
index e878eec296..8803417447 100644
--- a/simd/src/Kokkos_SIMD_Scalar.hpp
+++ b/simd/src/Kokkos_SIMD_Scalar.hpp
@@ -244,10 +244,7 @@ class const_where_expression<simd_mask<T, simd_abi::scalar>,
   KOKKOS_FORCEINLINE_FUNCTION
   const_where_expression(mask_type const& mask_arg, value_type const& value_arg)
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
-  KOKKOS_FORCEINLINE_FUNCTION
-  mask_type const& mask() const { return m_mask; }
-  KOKKOS_FORCEINLINE_FUNCTION
-  value_type const& value() const { return m_value; }
+
   KOKKOS_FORCEINLINE_FUNCTION
   void copy_to(T* mem, element_aligned_tag) const {
     if (static_cast<bool>(m_mask)) *mem = static_cast<T>(m_value);
@@ -258,6 +255,16 @@ class const_where_expression<simd_mask<T, simd_abi::scalar>,
     if (static_cast<bool>(m_mask))
       mem[static_cast<Integral>(index)] = static_cast<T>(m_value);
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
 };
 
 template <class T>
@@ -294,29 +301,70 @@ class where_expression<simd_mask<T, simd_abi::scalar>,
   }
 };
 
+template <class T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+    where_expression<simd_mask<T, Kokkos::Experimental::simd_abi::scalar>,
+                     simd<T, Kokkos::Experimental::simd_abi::scalar>>
+    where(typename simd<
+              T, Kokkos::Experimental::simd_abi::scalar>::mask_type const& mask,
+          simd<T, Kokkos::Experimental::simd_abi::scalar>& value) {
+  return where_expression(mask, value);
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+    const_where_expression<simd_mask<T, Kokkos::Experimental::simd_abi::scalar>,
+                           simd<T, Kokkos::Experimental::simd_abi::scalar>>
+    where(typename simd<
+              T, Kokkos::Experimental::simd_abi::scalar>::mask_type const& mask,
+          simd<T, Kokkos::Experimental::simd_abi::scalar> const& value) {
+  return const_where_expression(mask, value);
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION bool all_of(
+    simd_mask<T, Kokkos::Experimental::simd_abi::scalar> const& a) {
+  return a == simd_mask<T, Kokkos::Experimental::simd_abi::scalar>(true);
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION bool any_of(
+    simd_mask<T, Kokkos::Experimental::simd_abi::scalar> const& a) {
+  return a != simd_mask<T, Kokkos::Experimental::simd_abi::scalar>(false);
+}
+
+template <class T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION bool none_of(
+    simd_mask<T, Kokkos::Experimental::simd_abi::scalar> const& a) {
+  return a == simd_mask<T, Kokkos::Experimental::simd_abi::scalar>(false);
+}
+
 template <class T>
 [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T
 reduce(const_where_expression<simd_mask<T, simd_abi::scalar>,
                               simd<T, simd_abi::scalar>> const& x,
        T identity_element, std::plus<>) {
-  return static_cast<bool>(x.mask()) ? static_cast<T>(x.value())
-                                     : identity_element;
+  return static_cast<bool>(x.impl_get_mask())
+             ? static_cast<T>(x.impl_get_value())
+             : identity_element;
 }
 
 template <class T>
 [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T
 hmax(const_where_expression<simd_mask<T, simd_abi::scalar>,
                             simd<T, simd_abi::scalar>> const& x) {
-  return static_cast<bool>(x.mask()) ? static_cast<T>(x.value())
-                                     : Kokkos::reduction_identity<T>::max();
+  return static_cast<bool>(x.impl_get_mask())
+             ? static_cast<T>(x.impl_get_value())
+             : Kokkos::reduction_identity<T>::max();
 }
 
 template <class T>
 [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION T
 hmin(const_where_expression<simd_mask<T, simd_abi::scalar>,
                             simd<T, simd_abi::scalar>> const& x) {
-  return static_cast<bool>(x.mask()) ? static_cast<T>(x.value())
-                                     : Kokkos::reduction_identity<T>::min();
+  return static_cast<bool>(x.impl_get_mask())
+             ? static_cast<T>(x.impl_get_value())
+             : Kokkos::reduction_identity<T>::min();
 }
 
 }  // namespace Experimental
diff --git a/simd/unit_tests/TestSIMD.cpp b/simd/unit_tests/TestSIMD.cpp
index 7a4ecf19ed..cf00cc36cb 100644
--- a/simd/unit_tests/TestSIMD.cpp
+++ b/simd/unit_tests/TestSIMD.cpp
@@ -168,9 +168,12 @@ void host_check_binary_op_one_loader(BinaryOp binary_op, std::size_t n,
         loader.host_load(second_args + i, nlanes, second_arg);
     if (!(loaded_first_arg && loaded_second_arg)) continue;
     simd_type expected_result;
-    for (std::size_t lane = 0; lane < nlanes; ++lane) {
-      expected_result[lane] =
-          binary_op.on_host(T(first_arg[lane]), T(second_arg[lane]));
+    // gcc 8.4.0 warns if using nlanes as upper bound about first_arg and/or
+    // second_arg being uninitialized
+    for (std::size_t lane = 0; lane < simd_type::size(); ++lane) {
+      if (lane < nlanes)
+        expected_result[lane] =
+            binary_op.on_host(T(first_arg[lane]), T(second_arg[lane]));
     }
     simd_type const computed_result = binary_op.on_host(first_arg, second_arg);
     host_check_equality(expected_result, computed_result, nlanes);
@@ -277,16 +280,42 @@ class divides {
   }
 };
 
-template <class Abi>
-inline void host_check_math_ops() {
-  std::size_t constexpr n     = 11;
-  double const first_args[n]  = {1, 2, -1, 10, 0, 1, -2, 10, 0, 1, -2};
-  double const second_args[n] = {1, 2, 1, 1, 1, -3, -2, 1, 13, -3, -2};
+template <typename Abi, typename DataType, size_t n>
+inline void host_check_all_math_ops(const DataType (&first_args)[n],
+                                    const DataType (&second_args)[n]) {
   host_check_binary_op_all_loaders<Abi>(plus(), n, first_args, second_args);
   host_check_binary_op_all_loaders<Abi>(minus(), n, first_args, second_args);
   host_check_binary_op_all_loaders<Abi>(multiplies(), n, first_args,
                                         second_args);
-  host_check_binary_op_all_loaders<Abi>(divides(), n, first_args, second_args);
+
+  // TODO: Place fallback division implementations for all simd integer types
+  if constexpr (std::is_same_v<DataType, double>)
+    host_check_binary_op_all_loaders<Abi>(divides(), n, first_args,
+                                          second_args);
+}
+
+template <typename Abi, typename DataType>
+inline void host_check_abi_size() {
+  using simd_type = Kokkos::Experimental::simd<DataType, Abi>;
+  using mask_type = typename simd_type::mask_type;
+  static_assert(simd_type::size() == mask_type::size());
+}
+
+template <class Abi, typename DataType>
+inline void host_check_math_ops() {
+  constexpr size_t n = 11;
+
+  host_check_abi_size<Abi, DataType>();
+
+  if constexpr (std::is_signed_v<DataType>) {
+    DataType const first_args[n]  = {1, 2, -1, 10, 0, 1, -2, 10, 0, 1, -2};
+    DataType const second_args[n] = {1, 2, 1, 1, 1, -3, -2, 1, 13, -3, -2};
+    host_check_all_math_ops<Abi>(first_args, second_args);
+  } else {
+    DataType const first_args[n]  = {1, 2, 1, 10, 0, 1, 2, 10, 0, 1, 2};
+    DataType const second_args[n] = {1, 2, 1, 1, 1, 3, 2, 1, 13, 3, 2};
+    host_check_all_math_ops<Abi>(first_args, second_args);
+  }
 }
 
 template <class Abi>
@@ -353,17 +382,41 @@ inline void host_check_condition() {
   EXPECT_TRUE(all_of(a == decltype(a)(16)));
 }
 
-template <class Abi>
-KOKKOS_INLINE_FUNCTION void device_check_math_ops() {
-  std::size_t constexpr n     = 11;
-  double const first_args[n]  = {1, 2, -1, 10, 0, 1, -2, 10, 0, 1, -2};
-  double const second_args[n] = {1, 2, 1, 1, 1, -3, -2, 1, 13, -3, -2};
+template <typename Abi, typename DataType, size_t n>
+KOKKOS_INLINE_FUNCTION void device_check_all_math_ops(
+    const DataType (&first_args)[n], const DataType (&second_args)[n]) {
   device_check_binary_op_all_loaders<Abi>(plus(), n, first_args, second_args);
   device_check_binary_op_all_loaders<Abi>(minus(), n, first_args, second_args);
   device_check_binary_op_all_loaders<Abi>(multiplies(), n, first_args,
                                           second_args);
-  device_check_binary_op_all_loaders<Abi>(divides(), n, first_args,
-                                          second_args);
+
+  if constexpr (std::is_same_v<DataType, double>)
+    device_check_binary_op_all_loaders<Abi>(divides(), n, first_args,
+                                            second_args);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_abi_size() {
+  using simd_type = Kokkos::Experimental::simd<DataType, Abi>;
+  using mask_type = typename simd_type::mask_type;
+  static_assert(simd_type::size() == mask_type::size());
+}
+
+template <class Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_math_ops() {
+  constexpr size_t n = 11;
+
+  device_check_abi_size<Abi, DataType>();
+
+  if constexpr (std::is_signed_v<DataType>) {
+    DataType const first_args[n]  = {1, 2, -1, 10, 0, 1, -2, 10, 0, 1, -2};
+    DataType const second_args[n] = {1, 2, 1, 1, 1, -3, -2, 1, 13, -3, -2};
+    device_check_all_math_ops<Abi>(first_args, second_args);
+  } else {
+    DataType const first_args[n]  = {1, 2, 1, 10, 0, 1, 2, 10, 0, 1, 2};
+    DataType const second_args[n] = {1, 2, 1, 1, 1, 3, 2, 1, 13, 3, 2};
+    device_check_all_math_ops<Abi>(first_args, second_args);
+  }
 }
 
 template <class Abi>
@@ -434,18 +487,34 @@ KOKKOS_INLINE_FUNCTION void device_check_condition() {
   checker.truth(all_of(a == decltype(a)(16)));
 }
 
+template <typename Abi, typename... DataTypes>
+inline void host_check_math_ops_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_math_ops<Abi, DataTypes>(), ...);
+}
+
 template <class Abi>
 inline void host_check_abi() {
-  host_check_math_ops<Abi>();
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+
+  host_check_math_ops_all_types<Abi>(DataTypes());
   host_check_mask_ops<Abi>();
   host_check_conversions<Abi>();
   host_check_shifts<Abi>();
   host_check_condition<Abi>();
 }
 
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_math_ops_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_math_ops<Abi, DataTypes>(), ...);
+}
+
 template <class Abi>
 KOKKOS_INLINE_FUNCTION void device_check_abi() {
-  device_check_math_ops<Abi>();
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+
+  device_check_math_ops_all_types<Abi>(DataTypes());
   device_check_mask_ops<Abi>();
   device_check_conversions<Abi>();
   device_check_shifts<Abi>();
diff --git a/tpls/desul/Config.hpp.cmake.in b/tpls/desul/Config.hpp.cmake.in
index 40ab5c1c6c..a7bc738191 100644
--- a/tpls/desul/Config.hpp.cmake.in
+++ b/tpls/desul/Config.hpp.cmake.in
@@ -10,7 +10,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #define DESUL_ATOMICS_CONFIG_HPP_
 
 #cmakedefine DESUL_ATOMICS_ENABLE_CUDA
+#cmakedefine DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
 #cmakedefine DESUL_ATOMICS_ENABLE_HIP
+#cmakedefine DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
 #cmakedefine DESUL_ATOMICS_ENABLE_SYCL
 #cmakedefine DESUL_ATOMICS_ENABLE_OPENMP
 
diff --git a/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp b/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp
index c8449d495d..082fc132de 100644
--- a/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp
+++ b/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp
@@ -22,77 +22,54 @@ SPDX-License-Identifier: (BSD-3-Clause)
 namespace desul {
 namespace Impl {
 
-#ifdef __clang__
-namespace sycl_sync_and_atomics = ::sycl::ext::oneapi;
-#else
-namespace sycl_sync_and_atomics = ::sycl;
-#endif
-
-template <bool extended_namespace>
-using sycl_memory_order = std::conditional_t<extended_namespace,
-                                             sycl_sync_and_atomics::memory_order,
-                                             sycl::memory_order>;
-template <bool extended_namespace>
-using sycl_memory_scope = std::conditional_t<extended_namespace,
-                                             sycl_sync_and_atomics::memory_scope,
-                                             sycl::memory_scope>;
-
 //<editor-fold desc="SYCL memory order">
 // The default memory order for sycl::atomic_ref
 // can be seq_cst, acq_rel, or relaxed according to the
 // "SYCL 2020 Specification (revision 6)", see
 // https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#sec:atomic-references.
 // Thus, we map MemoryOrderAcquire and MemoryOrderRelease to acq_rel.
-template <class MemoryOrder, bool extended_namespace = true>
+template <class MemoryOrder>
 struct SYCLMemoryOrder;
 
-template <bool extended_namespace>
-struct SYCLMemoryOrder<MemoryOrderSeqCst, extended_namespace> {
-  static constexpr sycl_memory_order<extended_namespace> value =
-      sycl_memory_order<extended_namespace>::seq_cst;
+template <>
+struct SYCLMemoryOrder<MemoryOrderSeqCst> {
+  static constexpr sycl::memory_order value = sycl::memory_order::seq_cst;
 };
-template <bool extended_namespace>
-struct SYCLMemoryOrder<MemoryOrderAcquire, extended_namespace> {
-  static constexpr sycl_memory_order<extended_namespace> value =
-      sycl_memory_order<extended_namespace>::acq_rel;
+template <>
+struct SYCLMemoryOrder<MemoryOrderAcquire> {
+  static constexpr sycl::memory_order value = sycl::memory_order::acq_rel;
 };
-template <bool extended_namespace>
-struct SYCLMemoryOrder<MemoryOrderRelease, extended_namespace> {
-  static constexpr sycl_memory_order<extended_namespace> value =
-      sycl_memory_order<extended_namespace>::acq_rel;
+template <>
+struct SYCLMemoryOrder<MemoryOrderRelease> {
+  static constexpr sycl::memory_order value = sycl::memory_order::acq_rel;
 };
-template <bool extended_namespace>
-struct SYCLMemoryOrder<MemoryOrderAcqRel, extended_namespace> {
-  static constexpr sycl_memory_order<extended_namespace> value =
-      sycl_memory_order<extended_namespace>::acq_rel;
+template <>
+struct SYCLMemoryOrder<MemoryOrderAcqRel> {
+  static constexpr sycl::memory_order value = sycl::memory_order::acq_rel;
 };
-template <bool extended_namespace>
-struct SYCLMemoryOrder<MemoryOrderRelaxed, extended_namespace> {
-  static constexpr sycl_memory_order<extended_namespace> value =
-      sycl_memory_order<extended_namespace>::relaxed;
+template <>
+struct SYCLMemoryOrder<MemoryOrderRelaxed> {
+  static constexpr sycl::memory_order value = sycl::memory_order::relaxed;
 };
 //</editor-fold>
 
 //<editor-fold desc="SYCL memory scope">
-template <class MemoryScope, bool extended_namespace = true>
+template <class MemoryScope>
 struct SYCLMemoryScope;
 
-template <bool extended_namespace>
-struct SYCLMemoryScope<MemoryScopeCore, extended_namespace> {
-  static constexpr sycl_memory_scope<extended_namespace> value =
-      sycl_memory_scope<extended_namespace>::work_group;
+template <>
+struct SYCLMemoryScope<MemoryScopeCore> {
+  static constexpr sycl::memory_scope value = sycl::memory_scope::work_group;
 };
 
-template <bool extended_namespace>
-struct SYCLMemoryScope<MemoryScopeDevice, extended_namespace> {
-  static constexpr sycl_memory_scope<extended_namespace> value =
-      sycl_memory_scope<extended_namespace>::device;
+template <>
+struct SYCLMemoryScope<MemoryScopeDevice> {
+  static constexpr sycl::memory_scope value = sycl::memory_scope::device;
 };
 
-template <bool extended_namespace>
-struct SYCLMemoryScope<MemoryScopeSystem, extended_namespace> {
-  static constexpr sycl_memory_scope<extended_namespace> value =
-      sycl_memory_scope<extended_namespace>::system;
+template <>
+struct SYCLMemoryScope<MemoryScopeSystem> {
+  static constexpr sycl::memory_scope value = sycl::memory_scope::system;
 };
 //</editor-fold>
 
@@ -111,6 +88,16 @@ using sycl_atomic_ref = sycl::atomic_ref<T,
                                          sycl::access::address_space::generic_space>;
 #endif
 
+// FIXME_SYCL Use SYCL_EXT_ONEAPI_DEVICE_GLOBAL when available instead
+#ifdef DESUL_SYCL_DEVICE_GLOBAL_SUPPORTED
+// FIXME_SYCL The compiler forces us to use device_image_scope. Drop this when possible.
+template <class T>
+using sycl_device_global = sycl::ext::oneapi::experimental::device_global<
+    T,
+    decltype(sycl::ext::oneapi::experimental::properties(
+        sycl::ext::oneapi::experimental::device_image_scope))>;
+#endif
+
 }  // namespace Impl
 }  // namespace desul
 
diff --git a/tpls/desul/include/desul/atomics/Common.hpp b/tpls/desul/include/desul/atomics/Common.hpp
index b8dfcb8acd..b7353e7dba 100644
--- a/tpls/desul/include/desul/atomics/Common.hpp
+++ b/tpls/desul/include/desul/atomics/Common.hpp
@@ -83,11 +83,11 @@ struct numeric_limits_max;
 
 template <>
 struct numeric_limits_max<uint32_t> {
-  static constexpr uint32_t value = 0xffffffffu;
+  static constexpr auto value = static_cast<uint32_t>(-1);
 };
 template <>
 struct numeric_limits_max<uint64_t> {
-  static constexpr uint64_t value = 0xfffffffflu;
+  static constexpr auto value = static_cast<uint64_t>(-1);
 };
 
 constexpr bool atomic_always_lock_free(std::size_t size) {
diff --git a/tpls/desul/include/desul/atomics/Compare_Exchange_SYCL.hpp b/tpls/desul/include/desul/atomics/Compare_Exchange_SYCL.hpp
index 34e36bc4e4..43b4fb56f9 100644
--- a/tpls/desul/include/desul/atomics/Compare_Exchange_SYCL.hpp
+++ b/tpls/desul/include/desul/atomics/Compare_Exchange_SYCL.hpp
@@ -11,6 +11,7 @@ SPDX-License-Identifier: (BSD-3-Clause)
 
 #include <desul/atomics/Adapt_SYCL.hpp>
 #include <desul/atomics/Common.hpp>
+#include <desul/atomics/Lock_Array_SYCL.hpp>
 #include <desul/atomics/Thread_Fence_SYCL.hpp>
 
 // FIXME_SYCL SYCL2020 dictates that <sycl/sycl.hpp> is the header to include
@@ -78,16 +79,62 @@ std::enable_if_t<sizeof(T) == 8, T> device_atomic_exchange(T* const dest,
 template <class T, class MemoryOrder, class MemoryScope>
 std::enable_if_t<(sizeof(T) != 8) && (sizeof(T) != 4), T>
 device_atomic_compare_exchange(
-    T* const /*dest*/, T compare, T /*value*/, MemoryOrder, MemoryScope) {
-  assert(false);  // FIXME_SYCL not implemented
-  return compare;
+    T* const dest, T compare, T value, MemoryOrder, MemoryScope scope) {
+  // This is a way to avoid deadlock in a subgroup
+  T return_val;
+  int done = 0;
+  auto sg = sycl::ext::oneapi::experimental::this_sub_group();
+  using sycl::ext::oneapi::group_ballot;
+  using sycl::ext::oneapi::sub_group_mask;
+  sub_group_mask active = group_ballot(sg, 1);
+  sub_group_mask done_active = group_ballot(sg, 0);
+  while (active != done_active) {
+    if (!done) {
+      if (lock_address_sycl((void*)dest, scope)) {
+        if (std::is_same<MemoryOrder, MemoryOrderSeqCst>::value)
+          atomic_thread_fence(MemoryOrderRelease(), scope);
+        atomic_thread_fence(MemoryOrderAcquire(), scope);
+        return_val = *dest;
+        if (return_val == compare) {
+          *dest = value;
+          device_atomic_thread_fence(MemoryOrderRelease(), scope);
+        }
+        unlock_address_sycl((void*)dest, scope);
+        done = 1;
+      }
+    }
+    done_active = group_ballot(sg, done);
+  }
+  return return_val;
 }
 
 template <class T, class MemoryOrder, class MemoryScope>
 std::enable_if_t<(sizeof(T) != 8) && (sizeof(T) != 4), T> device_atomic_exchange(
-    T* const /*dest*/, T value, MemoryOrder, MemoryScope) {
-  assert(false);  // FIXME_SYCL not implemented
-  return value;
+    T* const dest, T value, MemoryOrder, MemoryScope scope) {
+  // This is a way to avoid deadlock in a subgroup
+  T return_val;
+  int done = 0;
+  auto sg = sycl::ext::oneapi::experimental::this_sub_group();
+  using sycl::ext::oneapi::group_ballot;
+  using sycl::ext::oneapi::sub_group_mask;
+  sub_group_mask active = group_ballot(sg, 1);
+  sub_group_mask done_active = group_ballot(sg, 0);
+  while (active != done_active) {
+    if (!done) {
+      if (lock_address_sycl((void*)dest, scope)) {
+        if (std::is_same<MemoryOrder, MemoryOrderSeqCst>::value)
+          atomic_thread_fence(MemoryOrderRelease(), scope);
+        device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+        return_val = *dest;
+        *dest = value;
+        device_atomic_thread_fence(MemoryOrderRelease(), scope);
+        unlock_address_sycl((void*)dest, scope);
+        done = 1;
+      }
+    }
+    done_active = group_ballot(sg, done);
+  }
+  return return_val;
 }
 
 }  // namespace Impl
diff --git a/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp b/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp
index 5c662bfc58..69ed8bcb9f 100644
--- a/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp
+++ b/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp
@@ -63,7 +63,7 @@ inline __device__ unsigned long long device_atomic_fetch_inc(unsigned long long*
 
 inline __device__                int device_atomic_fetch_dec(               int* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicSub(ptr,  1  ); }
 inline __device__       unsigned int device_atomic_fetch_dec(      unsigned int* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicSub(ptr,  1u ); }
-inline __device__ unsigned long long device_atomic_fetch_dec(unsigned long long* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, -1  ); }
+inline __device__ unsigned long long device_atomic_fetch_dec(unsigned long long* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, -1ull);}
 
 inline __device__       unsigned int device_atomic_fetch_inc_mod(  unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicInc(ptr,  val); }
 inline __device__       unsigned int device_atomic_fetch_dec_mod(  unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicDec(ptr,  val); }
diff --git a/tpls/desul/include/desul/atomics/Lock_Array.hpp b/tpls/desul/include/desul/atomics/Lock_Array.hpp
index a5af4c48c2..33e26b37b9 100644
--- a/tpls/desul/include/desul/atomics/Lock_Array.hpp
+++ b/tpls/desul/include/desul/atomics/Lock_Array.hpp
@@ -17,6 +17,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifdef DESUL_HAVE_HIP_ATOMICS
 #include <desul/atomics/Lock_Array_HIP.hpp>
 #endif
+#ifdef DESUL_HAVE_SYCL_ATOMICS
+#include <desul/atomics/Lock_Array_SYCL.hpp>
+#endif
 
 namespace desul {
 namespace Impl {
@@ -67,7 +70,7 @@ inline void ensure_lock_arrays_on_device() {
 #endif
 
 #ifdef DESUL_HAVE_HIP_ATOMICS
-  DESUL_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE();
+  ensure_hip_lock_arrays_on_device();
 #endif
 }
 
diff --git a/tpls/desul/include/desul/atomics/Lock_Array_CUDA.hpp b/tpls/desul/include/desul/atomics/Lock_Array_CUDA.hpp
index e0e4e129ac..ebfb8172e5 100644
--- a/tpls/desul/include/desul/atomics/Lock_Array_CUDA.hpp
+++ b/tpls/desul/include/desul/atomics/Lock_Array_CUDA.hpp
@@ -9,13 +9,11 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifndef DESUL_ATOMICS_LOCK_ARRAY_CUDA_HPP_
 #define DESUL_ATOMICS_LOCK_ARRAY_CUDA_HPP_
 
+#include <cstdint>
+
 #include "desul/atomics/Common.hpp"
 #include "desul/atomics/Macros.hpp"
 
-#ifdef DESUL_HAVE_CUDA_ATOMICS
-
-#include <cstdint>
-
 namespace desul {
 namespace Impl {
 
@@ -42,14 +40,6 @@ void init_lock_arrays_cuda();
 template <typename /*AlwaysInt*/ = int>
 void finalize_lock_arrays_cuda();
 
-}  // namespace Impl
-}  // namespace desul
-
-#if defined(__CUDACC__)
-
-namespace desul {
-namespace Impl {
-
 /// \brief This global variable in CUDA space is what kernels use
 ///        to get access to the lock arrays.
 ///
@@ -69,17 +59,15 @@ namespace Impl {
 /// variable based on the Host global variable prior to running any kernels
 /// that will use it.
 /// That is the purpose of the ensure_cuda_lock_arrays_on_device function.
-__device__
-#ifdef __CUDACC_RDC__
-    __constant__ extern
+#ifdef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
+extern
 #endif
-    int32_t* CUDA_SPACE_ATOMIC_LOCKS_DEVICE;
+    __device__ __constant__ int32_t* CUDA_SPACE_ATOMIC_LOCKS_DEVICE;
 
-__device__
-#ifdef __CUDACC_RDC__
-    __constant__ extern
+#ifdef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
+extern
 #endif
-    int32_t* CUDA_SPACE_ATOMIC_LOCKS_NODE;
+    __device__ __constant__ int32_t* CUDA_SPACE_ATOMIC_LOCKS_NODE;
 
 #define CUDA_SPACE_ATOMIC_MASK 0x1FFFF
 
@@ -120,45 +108,31 @@ __device__ inline void unlock_address_cuda(void* ptr, desul::MemoryScopeNode) {
   atomicExch(&desul::Impl::CUDA_SPACE_ATOMIC_LOCKS_NODE[offset], 0);
 }
 
-}  // namespace Impl
-}  // namespace desul
-
-// Make lock_array_copied an explicit translation unit scope thingy
-namespace desul {
-namespace Impl {
-namespace {
-static int lock_array_copied = 0;
-inline int eliminate_warning_for_lock_array() { return lock_array_copied; }
-}  // namespace
-
-#ifdef __CUDACC_RDC__
+#ifdef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
 inline
 #else
 inline static
 #endif
     void
     copy_cuda_lock_arrays_to_device() {
-  if (lock_array_copied == 0) {
+  static bool once = []() {
     cudaMemcpyToSymbol(CUDA_SPACE_ATOMIC_LOCKS_DEVICE,
                        &CUDA_SPACE_ATOMIC_LOCKS_DEVICE_h,
                        sizeof(int32_t*));
     cudaMemcpyToSymbol(CUDA_SPACE_ATOMIC_LOCKS_NODE,
                        &CUDA_SPACE_ATOMIC_LOCKS_NODE_h,
                        sizeof(int32_t*));
-  }
-  lock_array_copied = 1;
+    return true;
+  }();
+  (void)once;
 }
 
 }  // namespace Impl
 }  // namespace desul
 
-#endif /* defined( __CUDACC__ ) */
-
-#endif /* defined( DESUL_HAVE_CUDA_ATOMICS ) */
-
 namespace desul {
 
-#if defined(__CUDACC_RDC__) || (!defined(__CUDACC__))
+#ifdef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
 inline void ensure_cuda_lock_arrays_on_device() {}
 #else
 static inline void ensure_cuda_lock_arrays_on_device() {
diff --git a/tpls/desul/include/desul/atomics/Lock_Array_HIP.hpp b/tpls/desul/include/desul/atomics/Lock_Array_HIP.hpp
index 1ab9544eb4..beca3e9e40 100644
--- a/tpls/desul/include/desul/atomics/Lock_Array_HIP.hpp
+++ b/tpls/desul/include/desul/atomics/Lock_Array_HIP.hpp
@@ -35,7 +35,7 @@ extern int32_t* HIP_SPACE_ATOMIC_LOCKS_NODE_h;
 template <typename /*AlwaysInt*/ = int>
 void init_lock_arrays_hip();
 
-/// \brief After this call, the g_host_cuda_lock_arrays variable has
+/// \brief After this call, the g_host_hip_lock_arrays variable has
 ///        all null pointers, and all array memory has been freed.
 ///
 /// This call is idempotent.
@@ -43,12 +43,6 @@ void init_lock_arrays_hip();
 ///   snapshotted version while also linking against pure Desul
 template <typename /*AlwaysInt*/ = int>
 void finalize_lock_arrays_hip();
-}  // namespace Impl
-}  // namespace desul
-
-#ifdef __HIPCC__
-namespace desul {
-namespace Impl {
 
 /**
  * \brief This global variable in HIP space is what kernels use to get access
@@ -64,22 +58,20 @@ namespace Impl {
  * be created in every translation unit that sees this header file (we make this
  * clear by marking it static, meaning no other translation unit can link to
  * it). Since the Kokkos_HIP_Locks.cpp translation unit cannot initialize the
- * instances in other translation units, we must update this CUDA global
+ * instances in other translation units, we must update this HIP global
  * variable based on the Host global variable prior to running any kernels that
  * will use it.  That is the purpose of the
- * KOKKOS_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE macro.
+ * ensure_hip_lock_arrays_on_device function.
  */
-__device__
-#ifdef DESUL_HIP_RDC
-    __constant__ extern
+#ifdef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
+extern
 #endif
-    int32_t* HIP_SPACE_ATOMIC_LOCKS_DEVICE;
+    __device__ __constant__ int32_t* HIP_SPACE_ATOMIC_LOCKS_DEVICE;
 
-__device__
-#ifdef DESUL_HIP_RDC
-    __constant__ extern
+#ifdef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
+extern
 #endif
-    int32_t* HIP_SPACE_ATOMIC_LOCKS_NODE;
+    __device__ __constant__ int32_t* HIP_SPACE_ATOMIC_LOCKS_NODE;
 
 #define HIP_SPACE_ATOMIC_MASK 0x1FFFF
 
@@ -122,42 +114,35 @@ __device__ inline void unlock_address_hip(void* ptr, desul::MemoryScopeNode) {
   offset = offset & HIP_SPACE_ATOMIC_MASK;
   atomicExch(&desul::Impl::HIP_SPACE_ATOMIC_LOCKS_NODE[offset], 0);
 }
-#endif
-}  // namespace Impl
-}  // namespace desul
 
-// Make lock_array_copied an explicit translation unit scope thing
-namespace desul {
-namespace Impl {
-namespace {
-static int lock_array_copied = 0;
-inline int eliminate_warning_for_lock_array() { return lock_array_copied; }
-}  // namespace
+#ifdef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
+inline
+#else
+inline static
+#endif
+    void
+    copy_hip_lock_arrays_to_device() {
+  static bool once = []() {
+    (void)hipMemcpyToSymbol(HIP_SYMBOL(HIP_SPACE_ATOMIC_LOCKS_DEVICE),
+                            &HIP_SPACE_ATOMIC_LOCKS_DEVICE_h,
+                            sizeof(int32_t*));
+    (void)hipMemcpyToSymbol(HIP_SYMBOL(HIP_SPACE_ATOMIC_LOCKS_NODE),
+                            &HIP_SPACE_ATOMIC_LOCKS_NODE_h,
+                            sizeof(int32_t*));
+    return true;
+  }();
+  (void)once;
+}
 }  // namespace Impl
-}  // namespace desul
 
-/* It is critical that this code be a macro, so that it will
-   capture the right address for g_device_hip_lock_arrays!
-   putting this in an inline function will NOT do the right thing! */
-#define DESUL_IMPL_COPY_HIP_LOCK_ARRAYS_TO_DEVICE()                                   \
-  {                                                                                   \
-    if (::desul::Impl::lock_array_copied == 0) {                                      \
-      (void)hipMemcpyToSymbol(                                                        \
-          HIP_SYMBOL(::desul::Impl::HIP_SPACE_ATOMIC_LOCKS_DEVICE),                   \
-          &::desul::Impl::HIP_SPACE_ATOMIC_LOCKS_DEVICE_h,                            \
-          sizeof(int32_t*));                                                          \
-      (void)hipMemcpyToSymbol(HIP_SYMBOL(::desul::Impl::HIP_SPACE_ATOMIC_LOCKS_NODE), \
-                              &::desul::Impl::HIP_SPACE_ATOMIC_LOCKS_NODE_h,          \
-                              sizeof(int32_t*));                                      \
-    }                                                                                 \
-    ::desul::Impl::lock_array_copied = 1;                                             \
-  }
-
-#if defined(DESUL_HIP_RDC) || (!defined(__HIPCC__))
-#define DESUL_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE()
+#ifdef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
+inline void ensure_hip_lock_arrays_on_device() {}
 #else
-#define DESUL_ENSURE_HIP_LOCK_ARRAYS_ON_DEVICE() \
-  DESUL_IMPL_COPY_HIP_LOCK_ARRAYS_TO_DEVICE()
+static inline void ensure_hip_lock_arrays_on_device() {
+  Impl::copy_hip_lock_arrays_to_device();
+}
 #endif
 
+}  // namespace desul
+
 #endif
diff --git a/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp b/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp
new file mode 100644
index 0000000000..8216f9a797
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp
@@ -0,0 +1,161 @@
+/*
+Copyright (c) 2019, Lawrence Livermore National Security, LLC
+and DESUL project contributors. See the COPYRIGHT file for details.
+Source: https://github.com/desul/desul
+
+SPDX-License-Identifier: (BSD-3-Clause)
+*/
+
+#ifndef DESUL_ATOMICS_LOCK_ARRAY_SYCL_HPP_
+#define DESUL_ATOMICS_LOCK_ARRAY_SYCL_HPP_
+
+#include <cstdint>
+
+#include "desul/atomics/Adapt_SYCL.hpp"
+#include "desul/atomics/Common.hpp"
+#include "desul/atomics/Macros.hpp"
+
+// FIXME_SYCL
+#if __has_include(<sycl/sycl.hpp>)
+#include <sycl/sycl.hpp>
+#else
+#include <CL/sycl.hpp>
+#endif
+
+namespace desul {
+namespace Impl {
+
+// FIXME_SYCL Use SYCL_EXT_ONEAPI_DEVICE_GLOBAL when available instead
+#ifdef DESUL_SYCL_DEVICE_GLOBAL_SUPPORTED
+
+/**
+ * \brief This global variable in Host space is the central definition of these
+ * arrays.
+ */
+extern int32_t* SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h;
+extern int32_t* SYCL_SPACE_ATOMIC_LOCKS_NODE_h;
+
+/// \brief After this call, the lock arrays used in [un]lock_address_sycl
+///        are initialized and ready to be used.
+///
+/// This call is idempotent.
+/// The function is templated to make it a weak symbol to deal with Kokkos/RAJA
+///   snapshotted version while also linking against pure Desul
+template <typename /*AlwaysInt*/ = int>
+void init_lock_arrays_sycl(sycl::queue q);
+
+/// \brief After this call, the lock arrays used in [un]lock_address_sycl
+///        are freed and can't be used anymore.
+///
+/// This call is idempotent.
+/// The function is templated to make it a weak symbol to deal with Kokkos/RAJA
+///   snapshotted version while also linking against pure Desul
+template <typename /*AlwaysInt*/ = int>
+void finalize_lock_arrays_sycl(sycl::queue q);
+
+/**
+ * \brief This global variable in SYCL space is what kernels use to get access
+ * to the lock arrays.
+ *
+ * There is only one single instance of this global variable for the entire
+ * executable, whose definition will be in Kokkos_SYCL_Locks.cpp (and whose
+ * declaration here must be extern). This one instance will be initialized
+ * by initialize_host_sycl_lock_arrays and need not be modified afterwards.
+ */
+SYCL_EXTERNAL extern sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_DEVICE;
+
+SYCL_EXTERNAL extern sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_NODE;
+
+#define SYCL_SPACE_ATOMIC_MASK 0x1FFFF
+
+/// \brief Acquire a lock for the address
+///
+/// This function tries to acquire the lock for the hash value derived
+/// from the provided ptr. If the lock is successfully acquired the
+/// function returns true. Otherwise it returns false.
+inline bool lock_address_sycl(void* ptr, MemoryScopeDevice) {
+  size_t offset = size_t(ptr);
+  offset = offset >> 2;
+  offset = offset & SYCL_SPACE_ATOMIC_MASK;
+  sycl::atomic_ref<int32_t,
+                   sycl::memory_order::relaxed,
+                   sycl::memory_scope::device,
+                   sycl::access::address_space::global_space>
+      lock_device_ref(SYCL_SPACE_ATOMIC_LOCKS_DEVICE[offset]);
+  return (0 == lock_device_ref.exchange(1));
+}
+
+inline bool lock_address_sycl(void* ptr, MemoryScopeNode) {
+  size_t offset = size_t(ptr);
+  offset = offset >> 2;
+  offset = offset & SYCL_SPACE_ATOMIC_MASK;
+  sycl::atomic_ref<int32_t,
+                   sycl::memory_order::relaxed,
+                   sycl::memory_scope::system,
+                   sycl::access::address_space::global_space>
+      lock_node_ref(SYCL_SPACE_ATOMIC_LOCKS_NODE[offset]);
+  return (0 == lock_node_ref.exchange(1));
+}
+
+/**
+ * \brief Release lock for the address
+ *
+ * This function releases the lock for the hash value derived from the provided
+ * ptr. This function should only be called after previously successfully
+ * acquiring a lock with lock_address.
+ */
+inline void unlock_address_sycl(void* ptr, MemoryScopeDevice) {
+  size_t offset = size_t(ptr);
+  offset = offset >> 2;
+  offset = offset & SYCL_SPACE_ATOMIC_MASK;
+  sycl::atomic_ref<int32_t,
+                   sycl::memory_order::relaxed,
+                   sycl::memory_scope::device,
+                   sycl::access::address_space::global_space>
+      lock_device_ref(SYCL_SPACE_ATOMIC_LOCKS_DEVICE[offset]);
+  lock_device_ref.exchange(0);
+}
+
+inline void unlock_address_sycl(void* ptr, MemoryScopeNode) {
+  size_t offset = size_t(ptr);
+  offset = offset >> 2;
+  offset = offset & SYCL_SPACE_ATOMIC_MASK;
+  sycl::atomic_ref<int32_t,
+                   sycl::memory_order::relaxed,
+                   sycl::memory_scope::system,
+                   sycl::access::address_space::global_space>
+      lock_node_ref(SYCL_SPACE_ATOMIC_LOCKS_NODE[offset]);
+  lock_node_ref.exchange(0);
+}
+
+#else  // not supported
+
+template <typename /*AlwaysInt*/ = int>
+void init_lock_arrays_sycl(sycl::queue) {
+  assert(false);
+}
+
+template <typename /*AlwaysInt*/ = int>
+void finalize_lock_arrays_sycl(sycl::queue) {
+  assert(false);
+}
+
+inline bool lock_address_sycl(void*, MemoryScopeDevice) {
+  assert(false);
+  // return true so that the CAS loops don't hang.
+  return true;
+}
+
+inline bool lock_address_sycl(void*, MemoryScopeNode) {
+  assert(false);
+  // return true so that the CAS loops don't hang.
+  return true;
+}
+
+inline void unlock_address_sycl(void*, MemoryScopeDevice) { assert(false); }
+
+inline void unlock_address_sycl(void*, MemoryScopeNode) { assert(false); }
+#endif
+}  // namespace Impl
+}  // namespace desul
+#endif
diff --git a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op.hpp b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op.hpp
index e7c36673e2..cb97f4a906 100644
--- a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op.hpp
+++ b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op.hpp
@@ -18,7 +18,7 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #include <desul/atomics/Lock_Based_Fetch_Op_HIP.hpp>
 #endif
 #ifdef DESUL_HAVE_SYCL_ATOMICS
-#include <desul/atomics/Lock_Based_Fetch_Op_Unimplemented.hpp>
+#include <desul/atomics/Lock_Based_Fetch_Op_SYCL.hpp>
 #endif
 
 #include <desul/atomics/Lock_Based_Fetch_Op_Host.hpp>
diff --git a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_SYCL.hpp b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_SYCL.hpp
new file mode 100644
index 0000000000..8774a6e96e
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_SYCL.hpp
@@ -0,0 +1,94 @@
+/*
+Copyright (c) 2019, Lawrence Livermore National Security, LLC
+and DESUL project contributors. See the COPYRIGHT file for details.
+Source: https://github.com/desul/desul
+
+SPDX-License-Identifier: (BSD-3-Clause)
+*/
+
+#ifndef DESUL_ATOMICS_LOCK_BASED_FETCH_OP_SYCL_HPP_
+#define DESUL_ATOMICS_LOCK_BASED_FETCH_OP_SYCL_HPP_
+
+#include <desul/atomics/Common.hpp>
+#include <desul/atomics/Lock_Array_SYCL.hpp>
+#include <desul/atomics/Thread_Fence_SYCL.hpp>
+#include <type_traits>
+
+namespace desul {
+namespace Impl {
+
+template <class Oper,
+          class T,
+          class MemoryOrder,
+          class MemoryScope,
+          // equivalent to:
+          //   requires !atomic_always_lock_free(sizeof(T))
+          std::enable_if_t<!atomic_always_lock_free(sizeof(T)), int> = 0>
+T device_atomic_fetch_oper(const Oper& op,
+                           T* const dest,
+                           dont_deduce_this_parameter_t<const T> val,
+                           MemoryOrder /*order*/,
+                           MemoryScope scope) {
+  // This is a way to avoid deadlock in a subgroup
+  T return_val;
+  int done = 0;
+  auto sg = sycl::ext::oneapi::experimental::this_sub_group();
+  using sycl::ext::oneapi::group_ballot;
+  using sycl::ext::oneapi::sub_group_mask;
+  sub_group_mask active = group_ballot(sg, 1);
+  sub_group_mask done_active = group_ballot(sg, 0);
+  while (active != done_active) {
+    if (!done) {
+      if (lock_address_sycl((void*)dest, scope)) {
+        device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+        return_val = *dest;
+        *dest = op.apply(return_val, val);
+        device_atomic_thread_fence(MemoryOrderRelease(), scope);
+        unlock_address_sycl((void*)dest, scope);
+        done = 1;
+      }
+    }
+    done_active = group_ballot(sg, done);
+  }
+  return return_val;
+}
+
+template <class Oper,
+          class T,
+          class MemoryOrder,
+          class MemoryScope,
+          // equivalent to:
+          //   requires !atomic_always_lock_free(sizeof(T))
+          std::enable_if_t<!atomic_always_lock_free(sizeof(T)), int> = 0>
+T device_atomic_oper_fetch(const Oper& op,
+                           T* const dest,
+                           dont_deduce_this_parameter_t<const T> val,
+                           MemoryOrder /*order*/,
+                           MemoryScope scope) {
+  // This is a way to avoid deadlock in a subgroup
+  T return_val;
+  int done = 0;
+  auto sg = sycl::ext::oneapi::experimental::this_sub_group();
+  using sycl::ext::oneapi::group_ballot;
+  using sycl::ext::oneapi::sub_group_mask;
+  sub_group_mask active = group_ballot(sg, 1);
+  sub_group_mask done_active = group_ballot(sg, 0);
+  while (active != done_active) {
+    if (!done) {
+      if (lock_address_sycl((void*)dest, scope)) {
+        device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+        return_val = op.apply(*dest, val);
+        *dest = return_val;
+        device_atomic_thread_fence(MemoryOrderRelease(), scope);
+        unlock_address_sycl((void*)dest, scope);
+        done = 1;
+      }
+    }
+    done_active = group_ballot(sg, done);
+  }
+  return return_val;
+}
+}  // namespace Impl
+}  // namespace desul
+
+#endif
diff --git a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_Unimplemented.hpp b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_Unimplemented.hpp
deleted file mode 100644
index b9f9fac535..0000000000
--- a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_Unimplemented.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-Copyright (c) 2019, Lawrence Livermore National Security, LLC
-and DESUL project contributors. See the COPYRIGHT file for details.
-Source: https://github.com/desul/desul
-
-SPDX-License-Identifier: (BSD-3-Clause)
-*/
-
-#ifndef DESUL_ATOMICS_LOCK_BASED_FETCH_OP_UNIMPLEMENTED_HPP_
-#define DESUL_ATOMICS_LOCK_BASED_FETCH_OP_UNIMPLEMENTED_HPP_
-
-#include <cassert>
-#include <desul/atomics/Common.hpp>
-#include <type_traits>
-
-namespace desul {
-namespace Impl {
-
-template <class Oper,
-          class T,
-          class MemoryOrder,
-          class MemoryScope,
-          // equivalent to:
-          //   requires !atomic_always_lock_free(sizeof(T))
-          std::enable_if_t<!atomic_always_lock_free(sizeof(T)), int> = 0>
-DESUL_INLINE_FUNCTION T
-device_atomic_fetch_oper(const Oper& /*op*/,
-                         T* const /*dest*/,
-                         dont_deduce_this_parameter_t<const T> val,
-                         MemoryOrder /*order*/,
-                         MemoryScope /*scope*/) {
-  assert(false);
-  return val;  // FIXME not implemented
-}
-
-template <class Oper,
-          class T,
-          class MemoryOrder,
-          class MemoryScope,
-          // equivalent to:
-          //   requires !atomic_always_lock_free(sizeof(T))
-          std::enable_if_t<!atomic_always_lock_free(sizeof(T)), int> = 0>
-DESUL_INLINE_FUNCTION T
-device_atomic_oper_fetch(const Oper& /*op*/,
-                         T* const /*dest*/,
-                         dont_deduce_this_parameter_t<const T> val,
-                         MemoryOrder /*order*/,
-                         MemoryScope /*scope*/) {
-  assert(false);
-  return val;  // FIXME not implemented
-}
-}  // namespace Impl
-}  // namespace desul
-
-#endif
diff --git a/tpls/desul/include/desul/atomics/Macros.hpp b/tpls/desul/include/desul/atomics/Macros.hpp
index 992fb9fa66..3a14b93d32 100644
--- a/tpls/desul/include/desul/atomics/Macros.hpp
+++ b/tpls/desul/include/desul/atomics/Macros.hpp
@@ -11,6 +11,34 @@ SPDX-License-Identifier: (BSD-3-Clause)
 
 #include <desul/atomics/Config.hpp>
 
+// Intercept incompatible relocatable device code mode which leads to ODR violations
+#ifdef DESUL_ATOMICS_ENABLE_CUDA
+#if (defined(__clang__) && defined(__CUDA__) && defined(__CLANG_RDC__)) || \
+    defined(__CUDACC_RDC__)
+#define DESUL_IMPL_CUDA_RDC
+#endif
+
+#if (defined(DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION) &&  \
+     !defined(DESUL_IMPL_CUDA_RDC)) ||                            \
+    (!defined(DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION) && \
+     defined(DESUL_IMPL_CUDA_RDC))
+#error Relocatable device code mode incompatible with desul atomics configuration
+#endif
+
+#ifdef DESUL_IMPL_CUDA_RDC
+#undef DESUL_IMPL_CUDA_RDC
+#endif
+#endif
+
+#ifdef DESUL_ATOMICS_ENABLE_HIP
+#if (defined(DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION) &&  \
+     !defined(__CLANG_RDC__)) ||                                 \
+    (!defined(DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION) && \
+     defined(__CLANG_RDC__))
+#error Relocatable device code mode incompatible with desul atomics configuration
+#endif
+#endif
+
 // Macros
 
 #if defined(DESUL_ATOMICS_ENABLE_CUDA) && defined(__CUDACC__)
@@ -39,12 +67,6 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #define DESUL_HAVE_MSVC_ATOMICS
 #endif
 
-#if (defined(DESUL_ATOMICS_ENABLE_CUDA) && defined(__CUDA_ARCH__)) ||         \
-    (defined(DESUL_ATOMICS_ENABLE_HIP) && defined(__HIP_DEVICE_COMPILE__)) || \
-    (defined(DESUL_ATOMICS_ENABLE_SYCL) && defined(__SYCL_DEVICE_ONLY__))
-#define DESUL_HAVE_GPU_LIKE_PROGRESS
-#endif
-
 #if defined(DESUL_HAVE_CUDA_ATOMICS) || defined(DESUL_HAVE_HIP_ATOMICS)
 #define DESUL_FORCEINLINE_FUNCTION inline __host__ __device__
 #define DESUL_INLINE_FUNCTION inline __host__ __device__
@@ -59,10 +81,6 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #define DESUL_IMPL_DEVICE_FUNCTION
 #endif
 
-#if !defined(DESUL_HAVE_GPU_LIKE_PROGRESS)
-#define DESUL_HAVE_FORWARD_PROGRESS
-#endif
-
 #define DESUL_IMPL_STRIP_PARENS(X) DESUL_IMPL_ESC(DESUL_IMPL_ISH X)
 #define DESUL_IMPL_ISH(...) DESUL_IMPL_ISH __VA_ARGS__
 #define DESUL_IMPL_ESC(...) DESUL_IMPL_ESC_(__VA_ARGS__)
diff --git a/tpls/desul/include/desul/atomics/Thread_Fence_OpenMP.hpp b/tpls/desul/include/desul/atomics/Thread_Fence_OpenMP.hpp
index 72fc7a5e7c..402f1a7bde 100644
--- a/tpls/desul/include/desul/atomics/Thread_Fence_OpenMP.hpp
+++ b/tpls/desul/include/desul/atomics/Thread_Fence_OpenMP.hpp
@@ -16,7 +16,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 namespace desul {
 namespace Impl {
 
-#if _OPENMP > 201800
+// NVHPC compiler only supports the basic flush construct without the
+// memory-order-clause.
+#if _OPENMP > 201800 && !defined(__NVCOMPILER)
 
 // There is no seq_cst flush in OpenMP, isn't it the same anyway for fence?
 inline void host_atomic_thread_fence(MemoryOrderSeqCst, MemoryScopeCore) {
diff --git a/tpls/desul/include/desul/atomics/Thread_Fence_SYCL.hpp b/tpls/desul/include/desul/atomics/Thread_Fence_SYCL.hpp
index 769e92abfe..7cf3e8d5c0 100644
--- a/tpls/desul/include/desul/atomics/Thread_Fence_SYCL.hpp
+++ b/tpls/desul/include/desul/atomics/Thread_Fence_SYCL.hpp
@@ -25,8 +25,8 @@ namespace Impl {
 
 template <class MemoryOrder, class MemoryScope>
 void device_atomic_thread_fence(MemoryOrder, MemoryScope) {
-  sycl::atomic_fence(SYCLMemoryOrder<MemoryOrder, /*extended namespace*/ false>::value,
-                     SYCLMemoryScope<MemoryScope, /*extended namespace*/ false>::value);
+  sycl::atomic_fence(SYCLMemoryOrder<MemoryOrder>::value,
+                     SYCLMemoryScope<MemoryScope>::value);
 }
 
 }  // namespace Impl
diff --git a/tpls/desul/include/desul/atomics/cuda/CUDA_asm.hpp b/tpls/desul/include/desul/atomics/cuda/CUDA_asm.hpp
index 96e0dfa269..9471862a6b 100644
--- a/tpls/desul/include/desul/atomics/cuda/CUDA_asm.hpp
+++ b/tpls/desul/include/desul/atomics/cuda/CUDA_asm.hpp
@@ -2,10 +2,15 @@
 namespace desul {
 namespace Impl {
 // Choose the variant of atomics we are using later
+// The __isGlobal intrinsic was only introduced in CUDA 11.2
+// It also stopped working in NVC++ 23.1 - it works in 22.11
+// this is a bug in NVHPC, not treating CUDA intrinsics correctly
+// FIXME_NVHPC
 #if !defined(DESUL_IMPL_ATOMIC_CUDA_PTX_PREDICATE) && \
     !defined(DESUL_IMPL_ATOMIC_CUDA_PTX_ISGLOBAL)
-#if (__CUDACC_VER_MAJOR__ > 11) || \
-    ((__CUDACC_VER_MAJOR__ == 11) && (__CUDACC_VER_MINOR__ > 1))
+#if ((__CUDACC_VER_MAJOR__ > 11) ||                                   \
+     ((__CUDACC_VER_MAJOR__ == 11) && (__CUDACC_VER_MINOR__ > 1))) && \
+    (!defined(__NVCOMPILER) || __NVCOMPILER_MAJOR__ < 23)
 #define DESUL_IMPL_ATOMIC_CUDA_PTX_ISGLOBAL
 #else
 #define DESUL_IMPL_ATOMIC_CUDA_PTX_PREDICATE
diff --git a/tpls/desul/src/Lock_Array_CUDA.cpp b/tpls/desul/src/Lock_Array_CUDA.cpp
index 19944b378e..155f33653e 100644
--- a/tpls/desul/src/Lock_Array_CUDA.cpp
+++ b/tpls/desul/src/Lock_Array_CUDA.cpp
@@ -11,8 +11,7 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #include <sstream>
 #include <string>
 
-#ifdef DESUL_HAVE_CUDA_ATOMICS
-#ifdef __CUDACC_RDC__
+#ifdef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
 namespace desul {
 namespace Impl {
 __device__ __constant__ int32_t* CUDA_SPACE_ATOMIC_LOCKS_DEVICE = nullptr;
@@ -84,7 +83,7 @@ void finalize_lock_arrays_cuda() {
   cudaFreeHost(CUDA_SPACE_ATOMIC_LOCKS_NODE_h);
   CUDA_SPACE_ATOMIC_LOCKS_DEVICE_h = nullptr;
   CUDA_SPACE_ATOMIC_LOCKS_NODE_h = nullptr;
-#ifdef __CUDACC_RDC__
+#ifdef DESUL_ATOMICS_ENABLE_CUDA_SEPARABLE_COMPILATION
   copy_cuda_lock_arrays_to_device();
 #endif
 }
@@ -96,4 +95,3 @@ template void finalize_lock_arrays_cuda<int>();
 }  // namespace Impl
 
 }  // namespace desul
-#endif
diff --git a/tpls/desul/src/Lock_Array_HIP.cpp b/tpls/desul/src/Lock_Array_HIP.cpp
index 5ccc6f7d54..465b2eb25a 100644
--- a/tpls/desul/src/Lock_Array_HIP.cpp
+++ b/tpls/desul/src/Lock_Array_HIP.cpp
@@ -11,8 +11,7 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #include <sstream>
 #include <string>
 
-#ifdef DESUL_HAVE_HIP_ATOMICS
-#ifdef DESUL_HIP_RDC
+#ifdef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
 namespace desul {
 namespace Impl {
 __device__ __constant__ int32_t* HIP_SPACE_ATOMIC_LOCKS_DEVICE = nullptr;
@@ -70,7 +69,7 @@ void init_lock_arrays_hip() {
                             "init_lock_arrays_hip: hipMallocHost host locks");
 
   auto error_sync1 = hipDeviceSynchronize();
-  DESUL_IMPL_COPY_HIP_LOCK_ARRAYS_TO_DEVICE();
+  copy_hip_lock_arrays_to_device();
   check_error_and_throw_hip(error_sync1, "init_lock_arrays_hip: post malloc");
 
   init_lock_arrays_hip_kernel<<<(HIP_SPACE_ATOMIC_MASK + 1 + 255) / 256, 256>>>();
@@ -88,8 +87,8 @@ void finalize_lock_arrays_hip() {
   check_error_and_throw_hip(error_free2, "finalize_lock_arrays_hip: free host locks");
   HIP_SPACE_ATOMIC_LOCKS_DEVICE_h = nullptr;
   HIP_SPACE_ATOMIC_LOCKS_NODE_h = nullptr;
-#ifdef DESUL_HIP_RDC
-  DESUL_IMPL_COPY_HIP_LOCK_ARRAYS_TO_DEVICE();
+#ifdef DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
+  copy_hip_lock_arrays_to_device();
 #endif
 }
 
@@ -99,4 +98,3 @@ template void finalize_lock_arrays_hip<int>();
 }  // namespace Impl
 
 }  // namespace desul
-#endif
diff --git a/tpls/desul/src/Lock_Array_SYCL.cpp b/tpls/desul/src/Lock_Array_SYCL.cpp
new file mode 100644
index 0000000000..9e84c60e41
--- /dev/null
+++ b/tpls/desul/src/Lock_Array_SYCL.cpp
@@ -0,0 +1,69 @@
+/*
+Copyright (c) 2019, Lawrence Livermore National Security, LLC
+and DESUL project contributors. See the COPYRIGHT file for details.
+Source: https://github.com/desul/desul
+
+SPDX-License-Identifier: (BSD-3-Clause)
+*/
+
+// FIXME_SYCL Use SYCL_EXT_ONEAPI_DEVICE_GLOBAL when available instead
+#ifdef DESUL_SYCL_DEVICE_GLOBAL_SUPPORTED
+
+#include <cinttypes>
+#include <desul/atomics/Lock_Array_SYCL.hpp>
+
+namespace desul::Impl {
+
+SYCL_EXTERNAL
+sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_DEVICE;
+SYCL_EXTERNAL
+sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_NODE;
+
+int32_t* SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h = nullptr;
+int32_t* SYCL_SPACE_ATOMIC_LOCKS_NODE_h = nullptr;
+
+template <>
+void init_lock_arrays_sycl<int>(sycl::queue q) {
+  if (SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h != nullptr) return;
+
+  SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h =
+      sycl::malloc_device<int32_t>(SYCL_SPACE_ATOMIC_MASK + 1, q);
+  SYCL_SPACE_ATOMIC_LOCKS_NODE_h =
+      sycl::malloc_host<int32_t>(SYCL_SPACE_ATOMIC_MASK + 1, q);
+
+  // FIXME_SYCL Once supported, the following should be replaced by
+  // q.memcpy(SYCL_SPACE_ATOMIC_LOCKS_DEVICE,
+  //          &SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h,
+  //          sizeof(int32_t*));
+  // q.memcpy(SYCL_SPACE_ATOMIC_LOCKS_NODE,
+  //          &SYCL_SPACE_ATOMIC_LOCKS_NODE_h,
+  //          sizeof(int32_t*));
+  auto device_ptr = SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h;
+  auto node_ptr = SYCL_SPACE_ATOMIC_LOCKS_NODE_h;
+  q.single_task([=] {
+    SYCL_SPACE_ATOMIC_LOCKS_DEVICE.get() = device_ptr;
+    SYCL_SPACE_ATOMIC_LOCKS_NODE.get() = node_ptr;
+  });
+
+  q.memset(SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h,
+           0,
+           sizeof(int32_t) * (SYCL_SPACE_ATOMIC_MASK + 1));
+  q.memset(SYCL_SPACE_ATOMIC_LOCKS_NODE_h,
+           0,
+           sizeof(int32_t) * (SYCL_SPACE_ATOMIC_MASK + 1));
+
+  q.wait_and_throw();
+}
+
+template <>
+void finalize_lock_arrays_sycl<int>(sycl::queue q) {
+  if (SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h == nullptr) return;
+
+  sycl::free(SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h, q);
+  sycl::free(SYCL_SPACE_ATOMIC_LOCKS_NODE_h, q);
+  SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h = nullptr;
+  SYCL_SPACE_ATOMIC_LOCKS_NODE_h = nullptr;
+}
+
+} // namespace desul::Impl
+#endif