diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 5a259e3a58..f7a0a7185a 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,21 +1,22 @@
 ---
 name: Bug report
-about: Create a report to correct failures and improve our code
+about: Create a report (for github issue tracker) to correct failures
 title: ''
 labels: ''
 assignees: ''
 ---
 **Describe the bug**
-Please provide a concise, clear description of the bug, as well as any available error logs.
 
-**Please also include the following items to support reproducing the bug**
-1. compilers (with versions)
+Please provide a concise, clear description of the bug, as well as any available error logs.  Feel free to contact the Kokkos Slack `# build` channel for further discussion of your issue.
+
+**Please include the following for a minimal reproducer**
+
+1. Compilers (with versions)
 2. Kokkos release or commit used (i.e., the sha1 number)
-3. platform and backend
-4. cmake configure command
-5. output from cmake command
-6. code needed to reproduce the bug
-7. command line needed to reproduce the bug
-7. please also attach the `KokkosCore_config.h` header file (generated during the build);
-**Any additional info**
-Please provide any additional context about the issue here.
+3. Platform, architecture and backend
+4. CMake configure command
+5. Output from CMake configure command
+6. Minimum, complete code needed to reproduce the bug
+7. Command line needed to reproduce the bug
+8. `KokkosCore_config.h` header file (generated during the build)
+9. Please provide any additional relevant error logs
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..7242bd2851
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: /
+    schedule:
+      interval: "weekly"
diff --git a/.github/workflows/clang-format-check.yml b/.github/workflows/clang-format-check.yml
new file mode 100644
index 0000000000..f4dbe56011
--- /dev/null
+++ b/.github/workflows/clang-format-check.yml
@@ -0,0 +1,15 @@
+name: clang-format check
+
+on: [push, pull_request]
+
+permissions: read-all
+
+jobs:
+  formatting-check:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Run clang-format style check.
+      uses: DoozyX/clang-format-lint-action@v0.17
+      with:
+        clangFormatVersion: 8
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 0000000000..2ed86a1475
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,51 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master", "develop", "release-*" ]
+  pull_request:
+    branches: [ "develop" ]
+
+permissions: read-all
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    timeout-minutes: 360
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: c-cpp
+
+    - name: configure
+      run:
+        cmake -B build .
+          -DKokkos_ENABLE_OPENMP=ON
+          -DCMAKE_CXX_STANDARD=17
+          -DKokkos_ENABLE_DEPRECATED_CODE_4=OFF
+          -DKokkos_ENABLE_TESTS=ON
+          -DKokkos_ENABLE_EXAMPLES=ON
+          -DKokkos_ENABLE_BENCHMARKS=ON
+          -DCMAKE_BUILD_TYPE=Debug
+    - name: build
+      run:
+        cmake --build build --parallel 2
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:c-cpp"
diff --git a/.github/workflows/continuous-integration-workflow-32bit.yml b/.github/workflows/continuous-integration-workflow-32bit.yml
index 7fab3b0e62..0260cb5894 100644
--- a/.github/workflows/continuous-integration-workflow-32bit.yml
+++ b/.github/workflows/continuous-integration-workflow-32bit.yml
@@ -1,5 +1,15 @@
 name: github-Linux-32bit
-on: [push, pull_request]
+
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    paths-ignore:
+    - '**/*.md'
+    types: [ opened, reopened, synchronize ]
+
+permissions: read-all
 
 concurrency:
   group: ${ {github.event_name }}-${{ github.workflow }}-${{ github.ref }}
@@ -13,7 +23,7 @@ jobs:
       image: ghcr.io/kokkos/ci-containers/ubuntu:latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: install_multilib
         run: sudo apt-get update && sudo apt-get install -y gcc-multilib g++-multilib gfortran-multilib
       - name: Configure Kokkos
@@ -26,7 +36,7 @@ jobs:
             -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_FLAGS="-Werror -m32" \
             -DCMAKE_CXX_COMPILER=g++ \
             -DCMAKE_BUILD_TYPE=RelWithDebInfo
       - name: Build
diff --git a/.github/workflows/continuous-integration-workflow-hpx.yml b/.github/workflows/continuous-integration-workflow-hpx.yml
index 0c7abd2fc1..35704a28cf 100644
--- a/.github/workflows/continuous-integration-workflow-hpx.yml
+++ b/.github/workflows/continuous-integration-workflow-hpx.yml
@@ -1,11 +1,20 @@
 name: github-Linux-hpx
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    paths-ignore:
+    - '**/*.md'
+    types: [ opened, reopened, synchronize ]
 
 concurrency:
   group: ${ {github.event_name }}-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{github.event_name == 'pull_request'}}
 
+permissions: read-all
+
 jobs:
   hpx:
     name: hpx
@@ -13,7 +22,7 @@ jobs:
 
     steps:
       - name: checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: kokkos
       - name: setup hpx dependencies
@@ -26,12 +35,12 @@ jobs:
             libboost-all-dev \
             ninja-build
       - name: checkout hpx
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: STELLAR-GROUP/hpx
-          ref: 1.8.0
+          ref: v1.9.0
           path: hpx
-      - uses: actions/cache@v3
+      - uses: actions/cache@v4
         id:   cache-hpx
         with:
           path:         ./hpx/install
@@ -73,7 +82,7 @@ jobs:
             -DKokkos_ENABLE_DEPRECATED_CODE_4=OFF \
             -DKokkos_ENABLE_EXAMPLES=ON \
             -DKokkos_ENABLE_HPX=ON \
-            -DKokkos_ENABLE_SERIAL=OFF \
+            -DKokkos_ENABLE_SERIAL=ON \
             -DKokkos_ENABLE_TESTS=ON \
             ..
 
diff --git a/.github/workflows/continuous-integration-workflow.yml b/.github/workflows/continuous-integration-workflow.yml
index 741f6b2746..9c7b7585d0 100644
--- a/.github/workflows/continuous-integration-workflow.yml
+++ b/.github/workflows/continuous-integration-workflow.yml
@@ -1,60 +1,87 @@
 name: github-Linux
-on: [push, pull_request]
+
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    paths-ignore:
+    - '**/*.md'
+    types: [ opened, reopened, synchronize ]
 
 concurrency:
   group: ${ {github.event_name }}-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{github.event_name == 'pull_request'}}
 
+permissions: read-all
+
 jobs:
   CI:
     continue-on-error: true
     strategy:
       matrix:
-        distro: ['fedora:latest', 'fedora:rawhide', 'ubuntu:latest']
+        distro: ['fedora:latest', 'ubuntu:latest']
         cxx: ['g++', 'clang++']
         cxx_extra_flags: ['']
         cmake_build_type: ['Release', 'Debug']
         backend: ['OPENMP']
         clang-tidy: ['']
+        stdcxx: [17]
         include:
-          - distro: 'fedora:intel'
+          - distro: 'ubuntu:intel'
             cxx: 'icpc'
             cxx_extra_flags: '-diag-disable=177,10441'
             cmake_build_type: 'Release'
             backend: 'OPENMP'
-          - distro: 'fedora:intel'
+            stdcxx: '17'
+          - distro: 'ubuntu:intel'
             cxx: 'icpc'
             cxx_extra_flags: '-diag-disable=177,10441'
             cmake_build_type: 'Debug'
             backend: 'OPENMP'
-          - distro: 'fedora:intel'
+            stdcxx: '17'
+          - distro: 'ubuntu:intel'
             cxx: 'icpx'
-            cxx_extra_flags: '-fp-model=precise -Wno-pass-failed'
+            cxx_extra_flags: '-fp-model=precise -Wno-pass-failed -fsanitize=address,undefined -fno-sanitize=function -fno-sanitize-recover=all'
+            extra_linker_flags: '-fsanitize=address,undefined -fno-sanitize=function -fno-sanitize-recover=all'
             cmake_build_type: 'Release'
             backend: 'OPENMP'
-          - distro: 'fedora:intel'
+            stdcxx: '17'
+          - distro: 'ubuntu:intel'
             cxx: 'icpx'
             cxx_extra_flags: '-fp-model=precise -Wno-pass-failed'
             cmake_build_type: 'Debug'
             backend: 'OPENMP'
+            stdcxx: '20'
           - distro: 'ubuntu:latest'
             cxx: 'clang++'
+            cxx_extra_flags: '-fsanitize=address,undefined -fno-sanitize=function -fno-sanitize-recover=all'
+            extra_linker_flags: '-fsanitize=address,undefined -fno-sanitize=function -fno-sanitize-recover=all'
             cmake_build_type: 'RelWithDebInfo'
             backend: 'THREADS'
             clang-tidy: '-DCMAKE_CXX_CLANG_TIDY="clang-tidy;-warnings-as-errors=*"'
+            stdcxx: '23'
+          - distro: 'ubuntu:latest'
+            cxx: 'clang++'
+            cxx_extra_flags: '-fsanitize=address,undefined -fno-sanitize=function -fno-sanitize-recover=all'
+            extra_linker_flags: '-fsanitize=address,undefined -fno-sanitize=function -fno-sanitize-recover=all'
+            cmake_build_type: 'RelWithDebInfo'
+            backend: 'SERIAL'
+            stdcxx: '20'
           - distro: 'ubuntu:latest'
             cxx: 'g++'
             cmake_build_type: 'RelWithDebInfo'
             backend: 'THREADS'
+            stdcxx: '23'
     runs-on: ubuntu-latest
     container:
       image: ghcr.io/kokkos/ci-containers/${{ matrix.distro }}
     steps:
       - name: Checkout desul
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: desul/desul
-          ref: 477da9c8f40f8db369c28dd3f93a67e376d8511b
+          ref: 779d0441a778c7088a36d38c4cbf8df3cfa182cc
           path: desul
       - name: Install desul
         working-directory: desul
@@ -66,15 +93,12 @@ 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@v3
-      - uses: actions/cache@v3
+        uses: actions/checkout@v4
+      - uses: actions/cache@v4
         with:
           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
       - name: maybe_use_flang_new
         if: ${{ matrix.cxx == 'clang++' && startsWith(matrix.distro,'fedora:') }}
         run: echo "FC=flang-new" >> $GITHUB_ENV
@@ -100,6 +124,8 @@ jobs:
             -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF \
             -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
             -DCMAKE_CXX_FLAGS="-Werror ${{ matrix.cxx_extra_flags }}" \
+            -DCMAKE_CXX_STANDARD="${{ matrix.stdcxx }}" \
+            -DCMAKE_EXE_LINKER_FLAGS="${{ matrix.extra_linker_flags }}" \
             -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} \
             -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -DCMAKE_BUILD_TYPE=${{ matrix.cmake_build_type }}
@@ -112,6 +138,7 @@ jobs:
         working-directory: builddir
         run: ctest --output-on-failure
       - name: Test linking against build dir
+        if: ${{ !contains(matrix.cxx_extra_flags, '-fsanitize=address') }}
         working-directory: example/build_cmake_installed
         run: |
           cmake -B builddir_buildtree -DCMAKE_CXX_COMPILER=${{ matrix.cxx }} -DKokkos_ROOT=../../builddir
@@ -122,6 +149,7 @@ jobs:
       - name: Install
         run: sudo cmake --build builddir --target install
       - name: Test install
+        if: ${{ !contains(matrix.cxx_extra_flags, '-fsanitize=address') }}
         working-directory: example/build_cmake_installed
         run: |
           cmake -B builddir -DCMAKE_CXX_COMPILER=${{ matrix.cxx }}
diff --git a/.github/workflows/osx.yml b/.github/workflows/osx.yml
index 0ff3266848..2bcf41a0d3 100644
--- a/.github/workflows/osx.yml
+++ b/.github/workflows/osx.yml
@@ -1,11 +1,20 @@
 name: github-OSX
 
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    paths-ignore:
+    - '**/*.md'
+    types: [ opened, reopened, synchronize ]
 
 concurrency:
   group: ${ {github.event_name }}-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{github.event_name == 'pull_request'}}
 
+permissions: read-all
+
 jobs:
   osxci:
     name: osx-ci
@@ -24,7 +33,7 @@ jobs:
             cmake_build_type: "Release"
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: configure
         run:
           cmake -B build .
diff --git a/.github/workflows/performance-benchmark.yml b/.github/workflows/performance-benchmark.yml
index 205239e043..bfbbeea4a8 100644
--- a/.github/workflows/performance-benchmark.yml
+++ b/.github/workflows/performance-benchmark.yml
@@ -4,6 +4,11 @@ on:
     branches:
       - develop
   pull_request:
+    paths-ignore:
+      - '**/*.md'
+    types: [ opened, reopened, synchronize ]
+
+permissions: read-all
 
 jobs:
   CI:
@@ -20,8 +25,8 @@ jobs:
       BUILD_ID: ${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.backend }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
-      - uses: actions/cache@v3
+        uses: actions/checkout@v4
+      - uses: actions/cache@v4
         with:
           path: ~/.cache/ccache
           key: kokkos-${{ matrix.distro }}-${{ matrix.cxx }}-${{ matrix.backend }}-${{ github.ref }}-${{ github.sha }}
diff --git a/.github/workflows/releases.yml b/.github/workflows/releases.yml
new file mode 100644
index 0000000000..f0bb9b0b19
--- /dev/null
+++ b/.github/workflows/releases.yml
@@ -0,0 +1,83 @@
+on:
+  push:
+    tags: '[0-9]+.[0-9]+.[0-9][0-9]'
+  
+
+permissions: read-all
+
+jobs:
+  # This step builds our artifacts, uploads them to the workflow run, and
+  # outputs their digest.
+  build:
+    outputs:
+      hashes: ${{ steps.hash.outputs.hashes }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build artifacts
+        run: |
+          git archive -o kokkos-${{ github.ref_name }}.zip HEAD
+          git archive -o kokkos-${{ github.ref_name }}.tar.gz HEAD
+
+      - name: Generate hashes
+        shell: bash
+        id: hash
+        run: |
+          # sha256sum generates sha256 hash for all artifacts.
+          # base64 -w0 encodes to base64 and outputs on a single line.
+          echo "hashes=$(sha256sum kokkos-${{ github.ref_name }}.zip kokkos-${{ github.ref_name }}.tar.gz | base64 -w0)" >> "$GITHUB_OUTPUT"
+
+      - name: Upload source code (zip)
+        uses: actions/upload-artifact@89ef406dd8d7e03cfd12d9e0a4a378f454709029 # v4.3.5
+        with:
+          name: kokkos-${{ github.ref_name }}.zip
+          path: kokkos-${{ github.ref_name }}.zip
+          if-no-files-found: error
+          retention-days: 5
+
+      - name: Upload source code (tar.gz)
+        uses: actions/upload-artifact@89ef406dd8d7e03cfd12d9e0a4a378f454709029 # v4.3.5
+        with:
+          name: kokkos-${{ github.ref_name }}.tar.gz
+          path: kokkos-${{ github.ref_name }}.tar.gz
+          if-no-files-found: error
+          retention-days: 5
+
+  # This step calls the generic workflow to generate provenance.
+  provenance:
+    needs: [build]
+    permissions:
+      actions: read
+      id-token: write
+      contents: write
+    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.0.0
+    with:
+      base64-subjects: "${{ needs.build.outputs.hashes }}"
+      # Upload provenance to a new release
+      upload-assets: true
+      provenance-name: "kokkos-${{ github.ref_name }}.intoto.jsonl"
+
+  # This step uploads our artifacts to the tagged GitHub release.
+  release:
+    needs: [build, provenance]
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - name: Download kokkos-${{ github.ref_name }}.zip
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
+        with:
+          name: kokkos-${{ github.ref_name }}.zip
+
+      - name: Download kokkos-${{ github.ref_name }}.tar.gz
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
+        with:
+          name: kokkos-${{ github.ref_name }}.tar.gz
+
+      - name: Upload assets
+        uses: softprops/action-gh-release@c062e08bd532815e2082a85e87e3ef29c3e6d191 # v2.0.8
+        with:
+          files: |
+            kokkos-${{ github.ref_name }}.zip
+            kokkos-${{ github.ref_name }}.tar.gz
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 0000000000..77580978b2
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,73 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    # Weekly on Saturdays.
+    - cron: '30 1 * * 6'
+  push:
+    branches: [ master, develop ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      # Uncomment the permissions below if installing in a private repository.
+      # contents: read
+      # actions: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46 # v2.4.0
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # - you are installing Scorecard on a *private* repository
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories:
+          #   - `publish_results` will always be set to `false`, regardless
+          #     of the value entered here.
+          publish_results: true
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@0b2256b8c012f0828dc542b3febcab082c67f72b # v4.3.4
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload SARIF results to code scanning"
+        uses: github/codeql-action/upload-sarif@9fdb3e49720b44c48891d036bb502feb25684276 # v3.25.6
+        with:
+          sarif_file: results.sarif
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
new file mode 100644
index 0000000000..d801c740a7
--- /dev/null
+++ b/.github/workflows/windows.yml
@@ -0,0 +1,35 @@
+name: github-windows
+
+on:
+  push:
+  pull_request:
+
+concurrency:
+  group: ${ {github.event_name }}-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{github.event_name == 'pull_request'}}
+
+permissions: read-all
+
+jobs:
+  windows-cuda:
+    # Cuda build on Windows
+    name: Windows Cuda
+    runs-on: windows-2022
+
+    steps:
+    - uses: Jimver/cuda-toolkit@v0.2.16
+      id: cuda-toolkit
+      with:
+        cuda: '12.4.1'
+    - uses: actions/checkout@v4
+    - name: configure
+      shell: bash
+      run: |
+        mkdir build
+        mkdir c:/project
+        cd build
+        cmake -DKokkos_ENABLE_CUDA=ON -DKokkos_ARCH_VOLTA70=ON -DKokkos_ENABLE_TESTS=ON -DKokkos_ENABLE_COMPILE_AS_CMAKE_LANGUAGE=ON ..
+    - name: build library
+      shell: bash
+      run: |
+        cmake --build build --parallel 2 --config Release
diff --git a/.jenkins b/.jenkins
index c7d8ce533d..0393ff06fb 100644
--- a/.jenkins
+++ b/.jenkins
@@ -3,21 +3,26 @@ pipeline {
 
     environment {
         CCACHE_DIR = '/tmp/ccache'
-        CCACHE_MAXSIZE = '10G'
+        CCACHE_MAXSIZE = '5G'
         CCACHE_CPP2 = 'true'
     }
 
     options {
+        disableConcurrentBuilds(abortPrevious: true)
         timeout(time: 6, unit: 'HOURS')
     }
 
+    triggers {
+        issueCommentTrigger('.*test this please.*')
+    }
+
     stages {
         stage('Clang-Format') {
             agent {
                 dockerfile {
                     filename 'Dockerfile.clang'
                     dir 'scripts/docker'
-                    label 'nvidia-docker || rocm-docker || docker'
+                    label 'nvidia-docker || docker'
                     args '-v /tmp/ccache.kokkos:/tmp/ccache'
                 }
             }
@@ -27,7 +32,7 @@ pipeline {
         }
         stage('Build') {
             parallel {
-                stage('OPENACC-NVHPC-CUDA-11.6') {
+                stage('OPENACC-NVHPC-CUDA-12.2') {
                     agent {
                         dockerfile {
                             filename 'Dockerfile.nvhpc'
@@ -37,7 +42,7 @@ pipeline {
                         }
                     }
                     environment {
-                        CUDA_HOME = '/opt/nvidia/hpc_sdk/Linux_x86_64/22.3/cuda/11.6'
+                        NVHPC_CUDA_HOME = '/opt/nvidia/hpc_sdk/Linux_x86_64/23.7/cuda/12.2'
                     }
                     steps {
                         sh '''rm -rf build && mkdir -p build && cd build && \
@@ -53,13 +58,12 @@ pipeline {
                               make -j8 && ctest --verbose'''
                     }
                 }
-                stage('CUDA-11.7-NVHPC') {
+                stage('CUDA-12.2-NVHPC-AS-HOST-COMPILER') {
                     agent {
                         dockerfile {
                             filename 'Dockerfile.nvhpc'
                             dir 'scripts/docker'
-                            additionalBuildArgs '--build-arg BASE=nvcr.io/nvidia/nvhpc:22.9-devel-cuda11.7-ubuntu20.04'
-                            label 'nvidia-docker && large_images'
+                            label 'nvidia-docker && large_images && volta'
                             args '-v /tmp/ccache.kokkos:/tmp/ccache --env NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES'
                         }
                     }
@@ -70,7 +74,7 @@ pipeline {
                         OMP_MAX_ACTIVE_LEVELS = 1
                         OMP_PLACES = 'threads'
                         OMP_PROC_BIND = 'spread'
-                        NVHPC_CUDA_HOME = '/opt/nvidia/hpc_sdk/Linux_x86_64/22.9/cuda/11.7'
+                        NVHPC_CUDA_HOME = '/opt/nvidia/hpc_sdk/Linux_x86_64/23.7/cuda/12.2'
                     }
                     steps {
                         sh '''rm -rf build && mkdir -p build && cd build && \
@@ -78,7 +82,7 @@ pipeline {
                                 -DCMAKE_BUILD_TYPE=RelWithDebInfo \
                                 -DCMAKE_CXX_COMPILER=nvc++ \
                                 -DCMAKE_CXX_STANDARD=17 \
-                                -DCMAKE_CXX_FLAGS="--diag_suppress=implicit_return_from_non_void_function,no_device_stack" \
+                                -DCMAKE_CXX_FLAGS="--diag_suppress=implicit_return_from_non_void_function" \
                                 -DKokkos_ARCH_NATIVE=ON \
                                 -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
                                 -DKokkos_ENABLE_DEPRECATED_CODE_4=OFF \
@@ -95,22 +99,22 @@ pipeline {
                         dockerfile {
                             filename 'Dockerfile.sycl'
                             dir 'scripts/docker'
-                            label 'nvidia-docker && volta'
+                            label 'nvidia-docker && ampere'
                             args '-v /tmp/ccache.kokkos:/tmp/ccache'
                         }
                     }
                     steps {
                         sh 'ccache --zero-stats'
-                        sh '''. /opt/intel/oneapi/setvars.sh --include-intel-llvm && \
-                              rm -rf build && mkdir -p build && cd build && \
+                        sh '''rm -rf build && mkdir -p build && cd build && \
                               cmake \
                                 -DCMAKE_BUILD_TYPE=Release \
                                 -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-                                -DCMAKE_CXX_COMPILER=/opt/intel/oneapi/compiler/2023.0.0/linux/bin-llvm/clang++ \
+                                -DCMAKE_CXX_COMPILER=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" \
+                                -DCMAKE_PREFIX_PATH="$ONE_DPL_DIR" \
                                 -DKOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED=0 \
                                 -DKokkos_ARCH_NATIVE=ON \
-                                -DKokkos_ARCH_VOLTA70=ON \
+                                -DKokkos_ARCH_AMPERE80=ON \
                                 -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
                                 -DKokkos_ENABLE_DEPRECATED_CODE_4=OFF \
                                 -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF \
@@ -134,8 +138,8 @@ pipeline {
                         dockerfile {
                             filename 'Dockerfile.hipcc'
                             dir 'scripts/docker'
-                            additionalBuildArgs '--build-arg BASE=rocm/dev-ubuntu-20.04:5.2'
-                            label 'rocm-docker && vega'
+                            additionalBuildArgs '--build-arg BASE=rocm/dev-ubuntu-20.04:5.2-complete'
+                            label 'rocm-docker '
                             args '-v /tmp/ccache.kokkos:/tmp/ccache --device=/dev/kfd --device=/dev/dri --security-opt seccomp=unconfined --group-add video --env HIP_VISIBLE_DEVICES=$HIP_VISIBLE_DEVICES'
                         }
                     }
@@ -161,6 +165,7 @@ pipeline {
                                 -DKokkos_ENABLE_BENCHMARKS=ON \
                                 -DKokkos_ENABLE_HIP=ON \
                                 -DKokkos_ENABLE_OPENMP=ON \
+                                -DKokkos_ENABLE_IMPL_MDSPAN=OFF \
                                 -DKokkos_ENABLE_HIP_MULTIPLE_KERNEL_INSTANTIATIONS=ON \
                               .. && \
                               make -j8 && ctest --verbose'''
@@ -171,13 +176,13 @@ pipeline {
                         }
                     }
                 }
-                stage('HIP-ROCm-5.2-C++20') {
+                stage('HIP-ROCm-5.6-C++20') {
                     agent {
                         dockerfile {
                             filename 'Dockerfile.hipcc'
                             dir 'scripts/docker'
-                            additionalBuildArgs '--build-arg BASE=rocm/dev-ubuntu-20.04:5.2'
-                            label 'rocm-docker && vega'
+                            additionalBuildArgs '--build-arg BASE=rocm/dev-ubuntu-22.04:5.6-complete'
+                            label 'rocm-docker'
                             args '-v /tmp/ccache.kokkos:/tmp/ccache --device=/dev/kfd --device=/dev/dri --security-opt seccomp=unconfined --group-add video --env HIP_VISIBLE_DEVICES=$HIP_VISIBLE_DEVICES'
                         }
                     }
@@ -185,6 +190,7 @@ pipeline {
                         sh 'ccache --zero-stats'
                         sh '''rm -rf build && mkdir -p build && cd build && \
                               cmake \
+                                -DBUILD_SHARED_LIBS=ON \
                                 -DCMAKE_BUILD_TYPE=RelWithDebInfo \
                                 -DCMAKE_CXX_COMPILER=hipcc \
                                 -DCMAKE_CXX_FLAGS="-Werror -Wno-unused-command-line-argument" \
@@ -239,7 +245,7 @@ pipeline {
                                 -DKokkos_ENABLE_BENCHMARKS=ON \
                                 -DKokkos_ENABLE_OPENMPTARGET=ON \
                                 -DKokkos_ENABLE_OPENMP=ON \
-                                -DKokkos_ARCH_VEGA906=ON \
+                                -DKokkos_ARCH_AMD_GFX906=ON \
                               && \
                               cmake --build build --parallel ${BUILD_JOBS} && \
                               cd build && ctest --output-on-failure
@@ -287,7 +293,7 @@ pipeline {
                         }
                     }
                 }
-                stage('CUDA-10.1-Clang-Tidy') {
+                stage('CUDA-11.0.3-Clang-Tidy') {
                     agent {
                         dockerfile {
                             filename 'Dockerfile.kokkosllvmproject'
@@ -304,7 +310,7 @@ pipeline {
                                 -DCMAKE_CXX_CLANG_TIDY="clang-tidy;-warnings-as-errors=*" \
                                 -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
                                 -DCMAKE_CXX_COMPILER=clang++ \
-                                -DCMAKE_CXX_FLAGS=-Werror \
+                                -DCMAKE_CXX_FLAGS="-Werror -Wno-unknown-cuda-version" \
                                 -DCMAKE_CXX_STANDARD=17 \
                                 -DKokkos_ARCH_NATIVE=ON \
                                 -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
@@ -330,7 +336,7 @@ pipeline {
                         dockerfile {
                             filename 'Dockerfile.nvcc'
                             dir 'scripts/docker'
-                            additionalBuildArgs '--build-arg BASE=nvidia/cuda:11.7.0-devel-ubuntu20.04'
+                            additionalBuildArgs '--build-arg BASE=nvidia/cuda:11.7.1-devel-ubuntu20.04'
                             label 'nvidia-docker && volta'
                             args '-v /tmp/ccache.kokkos:/tmp/ccache --env NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES'
                         }
@@ -340,7 +346,7 @@ pipeline {
                         sh '''rm -rf build && mkdir -p build && cd build && \
                               ../gnu_generate_makefile.bash \
                                 --with-options=compiler_warnings \
-                                --cxxflags="-Werror" \
+                                --cxxflags="-Werror -Werror all-warnings -Xcudafe --diag_suppress=20208" \
                                 --cxxstandard=c++17 \
                                 --with-cuda \
                                 --with-cuda-options=enable_lambda \
@@ -360,7 +366,7 @@ pipeline {
                             filename 'Dockerfile.nvcc'
                             dir 'scripts/docker'
                             additionalBuildArgs '--build-arg BASE=nvidia/cuda:11.0.3-devel-ubuntu18.04 --build-arg ADDITIONAL_PACKAGES="g++-8 gfortran clang" --build-arg CMAKE_VERSION=3.17.3'
-                            label 'nvidia-docker'
+                            label 'nvidia-docker && (volta || ampere)'
                             args '-v /tmp/ccache.kokkos:/tmp/ccache --env NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES'
                         }
                     }
@@ -389,7 +395,6 @@ pipeline {
                                 -DKokkos_ENABLE_CUDA_LAMBDA=OFF \
                                 -DKokkos_ENABLE_CUDA_UVM=ON \
                                 -DKokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE=ON \
-                                -DKokkos_ENABLE_DEPRECATED_CODE_3=ON \
                                 -DKokkos_ENABLE_DEPRECATED_CODE_4=ON \
                                 -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF \
                                 -DCMAKE_INSTALL_PREFIX=${PWD}/../install \
@@ -431,8 +436,8 @@ pipeline {
                         dockerfile {
                             filename 'Dockerfile.nvcc'
                             dir 'scripts/docker'
-                            additionalBuildArgs '--build-arg BASE=nvidia/cuda:11.6.0-devel-ubuntu20.04'
-                            label 'nvidia-docker'
+                            additionalBuildArgs '--build-arg BASE=nvidia/cuda:11.6.2-devel-ubuntu20.04'
+                            label 'nvidia-docker && (volta || ampere)'
                             args '-v /tmp/ccache.kokkos:/tmp/ccache --env NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES'
                         }
                     }
@@ -440,10 +445,11 @@ pipeline {
                         sh 'ccache --zero-stats'
                         sh '''rm -rf build && mkdir -p build && cd build && \
                               cmake \
+                                -DBUILD_SHARED_LIBS=ON \
                                 -DCMAKE_BUILD_TYPE=Debug \
                                 -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
                                 -DCMAKE_CXX_COMPILER=$WORKSPACE/bin/nvcc_wrapper \
-                                -DCMAKE_CXX_FLAGS=-Werror \
+                                -DCMAKE_CXX_FLAGS="-Werror -Werror all-warnings -Xcudafe --diag_suppress=20208" \
                                 -DCMAKE_CXX_STANDARD=17 \
                                 -DKokkos_ARCH_NATIVE=ON \
                                 -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
@@ -455,6 +461,8 @@ pipeline {
                                 -DKokkos_ENABLE_CUDA=ON \
                                 -DKokkos_ENABLE_CUDA_LAMBDA=ON \
                                 -DKokkos_ENABLE_LIBDL=OFF \
+                                -DKokkos_ENABLE_IMPL_MDSPAN=OFF \
+                                -DKokkos_ENABLE_IMPL_CUDA_MALLOC_ASYNC=OFF \
                               .. && \
                               make -j8 && ctest --verbose && \
                               cd ../example/build_cmake_in_tree && \
@@ -489,9 +497,8 @@ 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_DEPRECATION_WARNINGS=ON \
                                 -DKokkos_ENABLE_TESTS=ON \
                                 -DKokkos_ENABLE_BENCHMARKS=ON \
                                 -DKokkos_ENABLE_OPENMP=ON \
diff --git a/.jenkins_nightly b/.jenkins_nightly
index 8bcdb75a2a..8dd02e9f02 100644
--- a/.jenkins_nightly
+++ b/.jenkins_nightly
@@ -70,6 +70,74 @@ pipeline {
                           '''
                     }      
                 }   
+                stage('GCC-14') {
+                    agent {
+                        docker {
+                            image 'gcc:14.1'
+                            label 'docker'
+                        }
+                    }
+                    steps {
+                        sh '''
+                          wget https://github.com/Kitware/CMake/releases/download/v3.30.0/cmake-3.30.0-linux-x86_64.sh && \
+                          chmod +x cmake-3.30.0-linux-x86_64.sh && ./cmake-3.30.0-linux-x86_64.sh --skip-license --prefix=/usr
+
+                          mkdir -p build && cd build && \
+                          cmake \
+                            -DCMAKE_BUILD_TYPE=Release \
+                            -DCMAKE_CXX_STANDARD=26 \
+                            -DCMAKE_CXX_FLAGS=-Werror \
+                            -DKokkos_ARCH_NATIVE=ON \
+                            -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
+                            -DKokkos_ENABLE_BENCHMARKS=ON \
+                            -DKokkos_ENABLE_EXAMPLES=ON \
+                            -DKokkos_ENABLE_TESTS=ON \
+                            -DKokkos_ENABLE_DEPRECATED_CODE_4=ON \
+                            -DKokkos_ENABLE_DEPRECATION_WARNINGS=ON \
+                            -DKokkos_ENABLE_SERIAL=ON \
+                          .. && \
+                          make -j8 && ctest --verbose
+                          '''
+                    }
+                }
+                stage('HIP-ROCM-6.1') {
+                    agent {
+                        dockerfile {
+                            filename 'Dockerfile.hipcc'
+                            dir 'scripts/docker'
+                            additionalBuildArgs '--build-arg BASE=rocm/dev-ubuntu-22.04:6.1.2-complete'
+                            label 'rocm-docker && AMD_Radeon_Instinct_MI210'
+                            args '-v /tmp/ccache.kokkos:/tmp/ccache --device=/dev/kfd --device=/dev/dri --security-opt seccomp=unconfined --group-add video --env HIP_VISIBLE_DEVICES=$HIP_VISIBLE_DEVICES'
+                        }
+                    }
+                    environment {
+                        // FIXME Test returns a wrong value
+                        GTEST_FILTER = '-hip_hostpinned.view_allocation_large_rank'
+                    }
+                    steps {
+                        sh 'ccache --zero-stats'
+                        sh '''rm -rf build && mkdir -p build && cd build && \
+                              cmake \
+                                -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+                                -DCMAKE_CXX_COMPILER=hipcc \
+                                -DCMAKE_CXX_FLAGS="-Werror -Wno-unused-command-line-argument" \
+                                -DCMAKE_CXX_STANDARD=20 \
+                                -DKokkos_ARCH_NATIVE=ON \
+                                -DKokkos_ENABLE_COMPILER_WARNINGS=ON \
+                                -DKokkos_ENABLE_DEPRECATED_CODE_4=ON \
+                                -DKokkos_ENABLE_DEPRECATION_WARNINGS=ON \
+                                -DKokkos_ENABLE_TESTS=ON \
+                                -DKokkos_ENABLE_BENCHMARKS=ON \
+                                -DKokkos_ENABLE_HIP=ON \
+                              .. && \
+                              make -j8 && ctest --verbose'''
+                    }
+                    post {
+                        always {
+                            sh 'ccache --show-stats'
+                        }
+                    }
+                }
             }
         }
     }
diff --git a/.olcf-gitlab-ci.yml b/.olcf-gitlab-ci.yml
new file mode 100644
index 0000000000..4e737cc536
--- /dev/null
+++ b/.olcf-gitlab-ci.yml
@@ -0,0 +1,12 @@
+test:
+  stage: test
+  tags: [frontier, shell]
+  id_tokens:
+    OLCF_ID_TOKEN:
+      aud: https://code.olcf.ornl.gov
+  script:
+    - module load rocm/6.0
+    - cmake -B build -DCMAKE_CXX_COMPILER=hipcc -DKokkos_ENABLE_HIP=ON -DKokkos_ENABLE_TESTS=ON
+    - cmake --build build -j48
+    - cd build
+    - ctest -E Kokkos_CoreUnitTest_DeviceAndThreads -V
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4c145c44b3..78225f9e6c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,307 @@
 # CHANGELOG
 
-## [4.1.00](https://github.com/kokkos/kokkos/tree/4.0.01) (2023-06-16)
+## [4.4.00](https://github.com/kokkos/kokkos/tree/4.4.00)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.3.01...4.4.00)
+
+### Features:
+* Add `Kokkos::View` conversions from and to [`std::mdspan`](https://en.cppreference.com/w/cpp/container/mdspan) [\#6830](https://github.com/kokkos/kokkos/pull/6830) [\#7069](https://github.com/kokkos/kokkos/pull/7069)
+
+### Backend and Architecture Enhancements:
+
+#### CUDA:
+* `nvcc_wrapper`: Adding ability to process `--disable-warnings` flag [\#6936](https://github.com/kokkos/kokkos/issues/6936)
+* Use recommended/max team size functions in Cuda ParallelFor and Reduce constructors [\#6891](https://github.com/kokkos/kokkos/issues/6891)
+* Improve compile-times when building with `Kokkos_ENABLE_DEBUG_BOUNDS_CHECK` in Cuda [\#7013](https://github.com/kokkos/kokkos/pull/7013)
+
+#### HIP:
+* Use HIP builtin atomics [\#6882](https://github.com/kokkos/kokkos/pull/6882) [\#7000](https://github.com/kokkos/kokkos/pull/7000)
+* Enable user-specified compiler and linker flags for AMD GPUs [\#7127](https://github.com/kokkos/kokkos/pull/7127)
+
+#### SYCL:
+* Add support for Graphs [\#6912](https://github.com/kokkos/kokkos/pull/6912)
+* Fix multi-GPU support [\#6887](https://github.com/kokkos/kokkos/pull/6887)
+* Improve performance of reduction and scan operations [\#6562](https://github.com/kokkos/kokkos/pull/6562), [\#6750](https://github.com/kokkos/kokkos/pull/6750)
+* Fix lock for guarding scratch space in `TeamPolicy` `parallel_reduce` [\#6988](https://github.com/kokkos/kokkos/pull/6988)
+* Include submission command queue property information into `SYCL::print_configuration()` [\#7004](https://github.com/kokkos/kokkos/pull/7004)
+
+#### OpenACC:
+* Make `TeamPolicy` `parallel_for` execute on the correct async queue [\#7012](https://github.com/kokkos/kokkos/pull/7012)
+
+#### OpenMPTarget:
+* Honor user requested loop ordering in `MDRange` policy [\#6925](https://github.com/kokkos/kokkos/pull/6925)
+* Prevent data races by guarding the scratch space used in `parallel_scan` [\#6998](https://github.com/kokkos/kokkos/pull/6998)
+
+#### HPX:
+* Workaround issue with template argument deduction to support compilation with NVCC [\#7015](https://github.com/kokkos/kokkos/pull/7015)
+
+### General Enhancements
+* Improve performance of view copies in host parallel regions [\#6730](https://github.com/kokkos/kokkos/pull/6730)
+* Harmonize convertibility rules of `Kokkos::RandomAccessIterator` with `View`s [\#6929](https://github.com/kokkos/kokkos/pull/6929)
+* Add a check precondition non-overlapping ranges for the `adjacent_difference` algorithm in debug mode [\#6922](https://github.com/kokkos/kokkos/pull/6922)
+* Add deduction guides for `TeamPolicy` [\#7030](https://github.com/kokkos/kokkos/pull/7030)
+* SIMD: Allow flexible vector width for 32 bit types [\#6802](https://github.com/kokkos/kokkos/pull/6802)
+* Updates for `Kokkos::Array`: add `kokkos_swap(Array<T, N>)` specialization [\#6943](https://github.com/kokkos/kokkos/pull/6943), add `Kokkos::to_array` [\#6375](https://github.com/kokkos/kokkos/pull/6375),  make `Kokkos::Array` equality-comparable [\#7148](https://github.com/kokkos/kokkos/pull/7148)
+* Structured binding support for `Kokkos::complex` [\#7040](https://github.com/kokkos/kokkos/pull/7040)
+
+### Build System Changes
+* Do not require OpenMP support for languages other than CXX [\#6965](https://github.com/kokkos/kokkos/pull/6965)
+* Update Intel GPU architectures in Makefile [\#6895](https://github.com/kokkos/kokkos/pull/6895)
+* Fix use of OpenMP with Cuda or HIP as compile language [\#6972](https://github.com/kokkos/kokkos/pull/6972)
+* Define and enforce new minimum compiler versions for C++20 support [\#7128](https://github.com/kokkos/kokkos/pull/7128), [\#7123](https://github.com/kokkos/kokkos/pull/7123)
+* Add nvidia Grace CPU architecture: `Kokkos_ARCH_ARMV9_GRACE` [\#7158](https://github.com/kokkos/kokkos/pull/7158)
+* Fix Makefile.kokkos for Threads [\#6896](https://github.com/kokkos/kokkos/pull/6896)
+* Remove support for NVHPC as CUDA device compiler [\#6987](https://github.com/kokkos/kokkos/pull/6987)
+* Fix using CUDAToolkit for CMake 3.28.4 and higher [\#7062](https://github.com/kokkos/kokkos/pull/7062)
+
+### Incompatibilities (i.e. breaking changes)
+* Drop `Kokkos::Array` special treatment in `View`s [\#6906](https://github.com/kokkos/kokkos/pull/6906)
+* Drop `Experimental::RawMemoryAllocationFailure` [\#7145](https://github.com/kokkos/kokkos/pull/7145)
+
+### Deprecations
+* Remove `Experimental::LayoutTiled` class template and deprecate `is_layouttiled` trait [\#6907](https://github.com/kokkos/kokkos/pull/6907)
+* Deprecate `Kokkos::layout_iterate_type_selector` [\#7076](https://github.com/kokkos/kokkos/pull/7076)
+* Deprecate specialization of `Kokkos::pair` for a single element [\#6947](https://github.com/kokkos/kokkos/pull/6947)
+* Deprecate `deep_copy` of `UnorderedMap` of different size [\#6812](https://github.com/kokkos/kokkos/pull/6812)
+* Deprecate trailing `Proxy` template argument of `Kokkos::Array` [\#6934](https://github.com/kokkos/kokkos/pull/6934)
+* Deprecate implicit conversions of integers to `ChunkSize` [\#7151](https://github.com/kokkos/kokkos/pull/7151)
+* Deprecate implicit conversions to execution spaces [\#7156](https://github.com/kokkos/kokkos/pull/7156)
+
+### Bug Fixes
+* Do not return a copy of the input functor in `Experimental::for_each` [\#6910](https://github.com/kokkos/kokkos/pull/6910)
+* Fix `realloc` on views of non-default constructible element types [\#6993](https://github.com/kokkos/kokkos/pull/6993)
+* Fix undefined behavior in `View` initialization or fill with zeros [\#7014](https://github.com/kokkos/kokkos/pull/7014)
+* Fix `sort_by_key` on host execution spaces when building with NVCC [\#7059](https://github.com/kokkos/kokkos/pull/7059)
+* Fix using shared libraries and -fvisibility=hidden [\#7065](https://github.com/kokkos/kokkos/pull/7065)
+* Fix view reference counting when functor copy constructor throws in parallel dispatch [\#6289](https://github.com/kokkos/kokkos/pull/6289)
+* Fix `initialize(InitializationSetting)` for handling `print_configuration` setting [\#7098](https://github.com/kokkos/kokkos/pull/7098)
+* Thread safety fixes for the Serial and OpenMP backend [\#7080](https://github.com/kokkos/kokkos/pull/7080), [\#6151](https://github.com/kokkos/kokkos/pull/6151)
+
+## [4.3.01](https://github.com/kokkos/kokkos/tree/4.3.01)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.3.00...4.3.01)
+
+### Backend and Architecture Enhancements:
+
+#### HIP:
+* MI300 support unified memory [\#6877](https://github.com/kokkos/kokkos/pull/6877)
+
+### Bug Fixes
+* Serial: Use the provided execution space instance in TeamPolicy [\#6951](https://github.com/kokkos/kokkos/pull/6951)
+* `nvcc_wrapper`: bring back support for `--fmad` option [\#6931](https://github.com/kokkos/kokkos/pull/6931)
+* Fix CUDA reduction overflow for `RangePolicy` [\#6578](https://github.com/kokkos/kokkos/pull/6578)
+
+## [4.3.00](https://github.com/kokkos/kokkos/tree/4.3.00) (2024-03-19)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.2.01...4.3.00)
+
+### Features:
+* Add `Experimental::sort_by_key(exec, keys, values)` algorithm [\#6801](https://github.com/kokkos/kokkos/pull/6801)
+
+### Backend and Architecture Enhancements:
+
+#### CUDA:
+* Experimental multi-GPU support (from the same process) [\#6782](https://github.com/kokkos/kokkos/pull/6782)
+* Link against CUDA libraries even with KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE [\#6701](https://github.com/kokkos/kokkos/pull/6701)
+* Don't use the compiler launcher script if the CMake compile language is CUDA. [\#6704](https://github.com/kokkos/kokkos/pull/6704)
+* nvcc(wrapper): adding "long" and "short" versions for all flags [\#6615](https://github.com/kokkos/kokkos/pull/6615)
+
+#### HIP:
+ * Fix compilation when using amdclang (with ROCm >= 5.7) and RDC [\#6857](https://github.com/kokkos/kokkos/pull/6857)
+ * Use rocthrust for sorting, when available [\#6793](https://github.com/kokkos/kokkos/pull/6793)
+
+#### SYCL:
+* We only support OneAPI SYCL implementation: add check during initialization
+  * Error out on initialization if the backend is different from `ext_oneapi_*` [\#6784](https://github.com/kokkos/kokkos/pull/6784)
+  * Filter GPU devices for `ext_onapi_*` GPU devices [\#6758](https://github.com/kokkos/kokkos/pull/6784)
+* Performance Improvements
+  * Avoid unnecessary zero-memset of the scratch flags in SYCL [\#6739](https://github.com/kokkos/kokkos/pull/6739)
+  * Use host-pinned memory to copy reduction/scan result [\#6500](https://github.com/kokkos/kokkos/pull/6500)
+* Address deprecations after oneAPI 2023.2.0 [\#6577](https://github.com/kokkos/kokkos/pull/6739)
+* Make sure to call find_dependency for oneDPL if necessary [\#6870](https://github.com/kokkos/kokkos/pull/6870)
+
+#### OpenMPTarget:
+* Use LLVM extensions for dynamic shared memory [\#6380](https://github.com/kokkos/kokkos/pull/6380)
+* Guard scratch memory usage in ParallelReduce [\#6585 ](https://github.com/kokkos/kokkos/pull/6585)
+* Update linker flags for Intel GPUs update [\#6735](https://github.com/kokkos/kokkos/pull/6735)
+* Improve handling of printf on Intel GPUs [\#6652](https://github.com/kokkos/kokkos/pull/6652)
+
+#### OpenACC:
+* Add atomics support [\#6446](https://github.com/kokkos/kokkos/pull/6446)
+* Make the OpenACC backend asynchronous [\#6772](https://github.com/kokkos/kokkos/pull/6772)
+
+#### Threads:
+* Add missing broadcast to TeamThreadRange parallel_scan [\#6601](https://github.com/kokkos/kokkos/pull/6601)
+
+#### OpenMP:
+* Improve performance of view initializations and filling with zeros [\#6573](https://github.com/kokkos/kokkos/pull/6573)
+
+### General Enhancements
+
+* Improve performance of random number generation when using a normal distribution on GPUs [\#6556](https://github.com/kokkos/kokkos/pull/6556)
+* Allocate temporary view with the user-provided execution space instance and do not initialize in `unique` algorithm [\#6598](https://github.com/kokkos/kokkos/pull/6598)
+* Add deduction guide for `Kokkos::Array` [\#6373](https://github.com/kokkos/kokkos/pull/6373)
+* Provide new public headers `<Kokkos_Clamp.hpp>` and `<Kokkos_MinMax.hpp>` [\#6687](https://github.com/kokkos/kokkos/pull/6687)
+* Fix/improvement to `remove_if` parallel algorithm: use the provided execution space instance for temporary allocations and drop unnecessaryinitialization + avoid evaluating twice the predicate during final pass [\#6747](https://github.com/kokkos/kokkos/pull/6747)
+* Add runtime function to query the number of devices and make device ID consistent with `KOKKOS_VISIBLE_DEVICES` [\#6713](https://github.com/kokkos/kokkos/pull/6713)
+* simd: support `vector_aligned_tag` [\#6243](https://github.com/kokkos/kokkos/pull/6243)
+* Avoid unnecessary allocation when default constructing Bitset [\#6524](https://github.com/kokkos/kokkos/pull/6524)
+* Fix constness for views in std algorithms [\#6813](https://github.com/kokkos/kokkos/pull/6813)
+* Improve error message on unsafe implicit conversion in MDRangePolicy [\#6855](https://github.com/kokkos/kokkos/pull/6855)
+* CTAD (deduction guides) for RangePolicy [\#6850](https://github.com/kokkos/kokkos/pull/6850)
+* CTAD (deduction guides) for MDRangePolicy [\#5516](https://github.com/kokkos/kokkos/pull/5516)
+
+### Build System Changes
+* Require `Kokkos_ENABLE_ATOMICS_BYPASS` option to bypass atomic operation for Serial backend only builds [\#6692](https://github.com/kokkos/kokkos/pull/6692)
+* Add support for RISCV and the Milk-V's Pioneer [\#6773](https://github.com/kokkos/kokkos/pull/6773)
+* Add C++26 standard to CMake setup [\#6733](https://github.com/kokkos/kokkos/pull/6733)
+* Fix Makefile when using gnu_generate_makefile.sh and make >= 4.3 [\#6606](https://github.com/kokkos/kokkos/pull/6606)
+* Cuda: Fix configuring with CMake >= 3.28.4 - temporary fallback to internal CudaToolkit.cmake [\#6898](https://github.com/kokkos/kokkos/pull/6898)
+
+### Incompatibilities (i.e. breaking changes)
+* Remove all `DEPRECATED_CODE_3` option and all code that was guarded by it  [\#6523](https://github.com/kokkos/kokkos/pull/6523)
+* Drop guards to accommodate external code defining `KOKKOS_ASSERT` [\#6665](https://github.com/kokkos/kokkos/pull/6665)
+* `Profiling::ProfilingSection(std::string)` constructor marked explicit and nodiscard [\#6690](https://github.com/kokkos/kokkos/pull/6690)
+* Add bound check preconditions for `RangePolicy` and `MDRangePolicy` [\#6617](https://github.com/kokkos/kokkos/pull/6617) [\#6726](https://github.com/kokkos/kokkos/pull/6726)
+* Add checks for unsafe implicit conversions in RangePolicy [\#6754](https://github.com/kokkos/kokkos/pull/6754)
+* Remove Kokkos::[b]half_t volatile overloads [\#6579](https://github.com/kokkos/kokkos/pull/6579)
+* Remove KOKKOS_IMPL_DO_NOT_USE_PRINTF [\#6593](https://github.com/kokkos/kokkos/pull/6593)
+* Check matching static extents in View constructor [\#5190 ](https://github.com/kokkos/kokkos/pull/5190)
+* Tools(profiling): fix typo Kokkos_Tools_Optim[i]zationGoal [\#6642](https://github.com/kokkos/kokkos/pull/6642)
+* Remove variadic range policy constructor (disallow passing multiple trailing chunk size arguments) [\#6845](https://github.com/kokkos/kokkos/pull/6845)
+* Improve message on view out of bounds access and always abort [\#6861](https://github.com/kokkos/kokkos/pull/6861)
+* Drop `KOKKOS_ENABLE_INTEL_MM_ALLOC` macro [\#6797](https://github.com/kokkos/kokkos/pull/6797)
+* Remove `Kokkos::Experimental::LogicalMemorySpace` (without going through deprecation) [\#6557](https://github.com/kokkos/kokkos/pull/6557)
+* Remove `Experimental::HBWSpace` and support for linking against memkind [\#6791](https://github.com/kokkos/kokkos/pull/6791)
+* Drop librt TPL and associated `KOKKOS_ENABLE_LIBRT` macro [\#6798](https://github.com/kokkos/kokkos/pull/6798)
+* Drop support for old CPU architectures (`ARCH_BGQ`, `ARCH_POWER7`, `ARCH_WSM` and associated `ARCH_SSE4` macro) [\#6806](https://github.com/kokkos/kokkos/pull/6806)
+* Drop support for deprecated command-line arguments and environment variables [\#6744](https://github.com/kokkos/kokkos/pull/6744)
+
+### Deprecations
+* Provide kokkos_swap as part of Core and deprecate Experimental::swap in Algorithms [\#6697](https://github.com/kokkos/kokkos/pull/6697)
+* Deprecate {Cuda,HIP}::detect_device_count() and Cuda::[detect_]device_arch() [\#6710](https://github.com/kokkos/kokkos/pull/6710)
+* Deprecate `ExecutionSpace::in_parallel()` [\#6582](https://github.com/kokkos/kokkos/pull/6582)
+
+### Bug Fixes
+* Fix team-level MDRange reductions: [\#6511](https://github.com/kokkos/kokkos/pull/6511)
+* Fix CUDA and SYCL small value type (16-bit) team reductions [\#5334](https://github.com/kokkos/kokkos/pull/5334)
+* Enable `{transform_}exclusive_scan` in place [\#6667](https://github.com/kokkos/kokkos/pull/6667)
+* `fill_random` overload that do not take an execution space instance argument should fence [\#6658](https://github.com/kokkos/kokkos/pull/6658)
+* HIP,Cuda,OpenMPTarget: Fixup use provided execution space when copying host inaccessible reduction result [\#6777](https://github.com/kokkos/kokkos/pull/6777)
+* Fix typo in `cuda_func_set_attribute[s]_wrapper` preventing proper setting of desired occupancy [\#6786](https://github.com/kokkos/kokkos/pull/6786)
+* Avoid undefined behavior due to conversion between signed and unsigned integers in shift_{right, left}_team_impl [\#6821](https://github.com/kokkos/kokkos/pull/6821)
+* Fix a bug in Makefile.kokkos when using AMD GPU architectures as `AMD_GFXYYY` [\#6892](https://github.com/kokkos/kokkos/pull/6892)
+
+## [4.2.01](https://github.com/kokkos/kokkos/tree/4.2.01) (2023-12-07)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.2.00...4.2.01)
+
+### Backend and Architecture Enhancements:
+
+#### CUDA:
+- Add warp sync for `parallel_reduce` to avoid race condition [\#6630](https://github.com/kokkos/kokkos/pull/6630), [\#6746](https://github.com/kokkos/kokkos/pull/6746)
+
+#### HIP:
+- Fix Graph "multiple definition of" linking error (missing `inline` specifier) [\#6624](https://github.com/kokkos/kokkos/pull/6624)
+- Add support for gfx940 (AMD Instinct MI300 GPU) [\#6671](https://github.com/kokkos/kokkos/pull/6671)
+
+### Build System
+- CMake: Don't let Kokkos set `CMAKE_CXX_FLAGS` for Trilinos builds [\#6742](https://github.com/kokkos/kokkos/pull/6742)
+
+### Bug Fixes
+- Remove deprecation warning for `AllocationMechanism` for GCC <11.0 [\#6653](https://github.com/kokkos/kokkos/pull/6653)
+- Fix bug early tools finalize with non-default host execution instances [\#6635](https://github.com/kokkos/kokkos/pull/6635)
+- Fix various issues for MSVC CUDA builds [\#6659](https://github.com/kokkos/kokkos/pull/6659)
+- Fix "extra `;`" warning with `-pedantic` flag in `<Kokkos_SIMD_Scalar.hpp>` [\#6510](https://github.com/kokkos/kokkos/pull/6510)
+
+## [4.2.00](https://github.com/kokkos/kokkos/tree/4.2.00) (2023-11-06)
+[Full Changelog](https://github.com/kokkos/kokkos/compare/4.1.00...4.2.00)
+
+### Features:
+- SIMD: significant improvements to SIMD support and alignment with C++26 SIMD
+  - add `Kokkos::abs` overload for SIMD types [\#6069](https://github.com/kokkos/kokkos/pull/6069)
+  - add generator constructors [\#6347](https://github.com/kokkos/kokkos/pull/6347)
+  - convert binary operators to hidden friends [\#6320](https://github.com/kokkos/kokkos/pull/6320)
+  - add shift operators [\#6109](https://github.com/kokkos/kokkos/pull/6109)
+  - add `float` support [\#6177](https://github.com/kokkos/kokkos/pull/6177)
+  - add remaining `gather_from` and `scatter_to` overloads [\#6220](https://github.com/kokkos/kokkos/pull/6220)
+  - define simd math function overloads in the Kokkos namespace [\#6465](https://github.com/kokkos/kokkos/pull/6465), [\#6487](https://github.com/kokkos/kokkos/pull/6487)
+  - `Kokkos_ENABLE_NATIVE=ON` autodetects SIMD types supported [\#6188](https://github.com/kokkos/kokkos/pull/6188)
+  - fix AVX2 SIMD support for ZEN2 AMD CPU [\#6238](https://github.com/kokkos/kokkos/pull/6238)
+- `Kokkos::printf` [\#6083](https://github.com/kokkos/kokkos/pull/6083)
+- `Kokkos::sort`: support custom comparator [\#6253](https://github.com/kokkos/kokkos/pull/6253)
+- `half_t` and `bhalf_t` numeric traits [\#5778](https://github.com/kokkos/kokkos/pull/5778)
+- `half_t` and `bhalf_t` mixed comparisons [\#6407](https://github.com/kokkos/kokkos/pull/6407)
+- `half_t` and `bhalf_t` mathematical functions [\#6124](https://github.com/kokkos/kokkos/pull/6124)
+- `TeamThreadRange` `parallel_scan` with return value [\#6090](https://github.com/kokkos/kokkos/pull/6090), [\#6301](https://github.com/kokkos/kokkos/pull/6301), [\#6302](https://github.com/kokkos/kokkos/pull/6302), [\#6303](https://github.com/kokkos/kokkos/pull/6303), [\#6307](https://github.com/kokkos/kokkos/pull/6307)
+- `ThreadVectorRange` `parallel_scan` with return value [\#6235](https://github.com/kokkos/kokkos/pull/6235), [\#6242](https://github.com/kokkos/kokkos/pull/6242), [\#6308](https://github.com/kokkos/kokkos/pull/6308), [\#6305](https://github.com/kokkos/kokkos/pull/6305), [\#6292](https://github.com/kokkos/kokkos/pull/6292)
+- Add team-level std algorithms [\#6200](https://github.com/kokkos/kokkos/pull/6200), [\#6205](https://github.com/kokkos/kokkos/pull/6205), [\#6207](https://github.com/kokkos/kokkos/pull/6207), [\#6208](https://github.com/kokkos/kokkos/pull/6208), [\#6209](https://github.com/kokkos/kokkos/pull/6209), [\#6210](https://github.com/kokkos/kokkos/pull/6210), [\#6211](https://github.com/kokkos/kokkos/pull/6211), [\#6212](https://github.com/kokkos/kokkos/pull/6212), [\#6213](https://github.com/kokkos/kokkos/pull/6213), [\#6256](https://github.com/kokkos/kokkos/pull/6256), [\#6258](https://github.com/kokkos/kokkos/pull/6258), [\#6350](https://github.com/kokkos/kokkos/pull/6350), [\#6351](https://github.com/kokkos/kokkos/pull/6351)
+- Serial: Allow for distinct execution space instances [\#6441](https://github.com/kokkos/kokkos/pull/6441)
+
+### Backend and Architecture Enhancements:
+
+#### CUDA:
+- Fixed potential data race in Cuda `parallel_reduce` [\#6236](https://github.com/kokkos/kokkos/pull/6236)
+- Use `cudaMallocAsync` by default [\#6402](https://github.com/kokkos/kokkos/pull/6402)
+- Bugfix for using Kokkos from a thread of execution [\#6299](https://github.com/kokkos/kokkos/pull/6299)
+
+#### HIP:
+- New naming convention for AMD GPU: VEGA906, VEGA908, VEGA90A, NAVI1030 to AMD_GFX906, AMD_GFX908, AMD_GFX90A, AMD_GFX1030 [\#6266](https://github.com/kokkos/kokkos/pull/6266)
+- Add initial support for gfx942: [\#6358](https://github.com/kokkos/kokkos/pull/6358)
+- Improve reduction performance [\#6229](https://github.com/kokkos/kokkos/pull/6229)
+- Deprecate `HIP(hipStream_t,bool)` constructor [\#6401](https://github.com/kokkos/kokkos/pull/6401)
+- Add support for Graph [\#6370](https://github.com/kokkos/kokkos/pull/6370)
+- Improve reduction performance when using Teams [\#6284](https://github.com/kokkos/kokkos/pull/6284)
+- Fix concurrency calculation [\#6479](https://github.com/kokkos/kokkos/pull/6479)
+- Fix potential data race in HIP `parallel_reduce` [\#6429](https://github.com/kokkos/kokkos/pull/6429)
+
+#### SYCL:
+- Enforce external `sycl::queues` to be in-order [\#6246](https://github.com/kokkos/kokkos/pull/6246)
+- Improve reduction performance: [\#6272](https://github.com/kokkos/kokkos/pull/6272) [\#6271](https://github.com/kokkos/kokkos/pull/6271) [\#6270](https://github.com/kokkos/kokkos/pull/6270) [\#6264](https://github.com/kokkos/kokkos/pull/6264)
+- Allow using the SYCL execution space on AMD GPUs [\#6321](https://github.com/kokkos/kokkos/pull/6321)
+- Allow sorting via native oneDPL to support Views with stride=1 [\#6322](https://github.com/kokkos/kokkos/pull/6322)
+- Make in-order queues the default via macro [\#6189](https://github.com/kokkos/kokkos/pull/6189)
+
+#### OpenACC:
+- Support Clacc compiler [\#6250](https://github.com/kokkos/kokkos/pull/6250)
+
+### General Enhancements
+- Add missing `is_*_view` traits and `is_*_view_v` helper variable templates for `DynRankView`, `DynamicView`, `OffsetView`, `ScatterView` containers [\#6195](https://github.com/kokkos/kokkos/pull/6195)
+- Make `nvcc_wrapper` and `compiler_launcher` scripts more portable by switching to a `#!/usr/bin/env` shebang [\#6357](https://github.com/kokkos/kokkos/pull/6357)
+- Add an improved `Kokkos::malloc` / `Kokkos::free` performance test [\#6377](https://github.com/kokkos/kokkos/pull/6377)
+- Ensure `Views` with `size==0` can be used with `deep_copy` [\#6273](https://github.com/kokkos/kokkos/pull/6273)
+- `Kokkos::abort` is moved to header `Kokkos_Abort.hpp` [\#6445](https://github.com/kokkos/kokkos/pull/6445)
+- `KOKKOS_ASSERT`, `KOKKOS_EXPECTS`, `KOKKOS_ENSURES` are moved to header `Kokkos_Assert.hpp` [\#6445](https://github.com/kokkos/kokkos/pull/6445)
+- Add a permuted-index mode to the gups benchmark [\#6378](https://github.com/kokkos/kokkos/pull/6378)
+- Check for overflow during backend initialization [\#6159](https://github.com/kokkos/kokkos/pull/6159)
+- Make constraints on `Kokkos::sort` more visible [\#6234](https://github.com/kokkos/kokkos/pull/6234) and cleanup API [\#6239](https://github.com/kokkos/kokkos/pull/6239)
+- Add converting assignment to `DualView`:  [\#6474](https://github.com/kokkos/kokkos/pull/6474)
+
+
+### Build System Changes
+
+- Export `Kokkos_CXX_COMPILER_VERSION` [\#6282](https://github.com/kokkos/kokkos/pull/6282)
+- Disable default oneDPL support in Trilinos [\#6342](https://github.com/kokkos/kokkos/pull/6342)
+
+### Incompatibilities (i.e. breaking changes)
+ - Ensure that `Kokkos::complex` only gets instantiated for cv-unqualified floating-point types  [\#6251](https://github.com/kokkos/kokkos/pull/6251)
+ - Removed (deprecated-3) support for volatile join operators in reductions [\#6385](https://github.com/kokkos/kokkos/pull/6385)
+ - Enforce `ViewCtorArgs` restrictions for `create_mirror_view` [\#6304](https://github.com/kokkos/kokkos/pull/6304)
+ - SIMD types for ARM NEON are not autodetected anymore but need `Kokkos_ARCH_ARM_NEON` or `Kokkos_ARCH_NATIVE=ON` [\#6394](https://github.com/kokkos/kokkos/pull/6394)
+ - Remove `#include <iostream>` from headers where possible [\#6482](https://github.com/kokkos/kokkos/pull/6482)
+
+### Deprecations
+- Deprecated `Kokkos::vector` [\#6252](https://github.com/kokkos/kokkos/pull/6252)
+- All host allocation mechanisms except for `STD_MALLOC` have been deprecated [\#6341](https://github.com/kokkos/kokkos/pull/6341)
+
+### Bug Fixes
+ - Missing memory fence in `RandomPool::free_state` functions [\#6290](https://github.com/kokkos/kokkos/pull/6290)
+ - Fix for corner case in `Kokkos::Experimental::is_partitioned` algorithm [\#6257](https://github.com/kokkos/kokkos/pull/6257)
+ - Fix initialization of scratch lock variables in the `Cuda` backend [\#6433](https://github.com/kokkos/kokkos/pull/6433)
+ - Fixes for `Kokkos::Array` [\#6372](https://github.com/kokkos/kokkos/pull/6372)
+ - Fixed symlink configure issue for Windows [\#6241](https://github.com/kokkos/kokkos/pull/6241)
+ - OpenMPTarget init-join fix [\#6444](https://github.com/kokkos/kokkos/pull/6444)
+ - Fix atomic operations bug for Min and Max [\#6435](https://github.com/kokkos/kokkos/pull/6435)
+ - Fix implementation for `cyl_bessel_i0` [\#6484](https://github.com/kokkos/kokkos/pull/6484)
+ - Fix various NVCC warnings in `BinSort`, `Array`, and bit manipulation function templates [\#6483](https://github.com/kokkos/kokkos/pull/6483)
+
+## [4.1.00](https://github.com/kokkos/kokkos/tree/4.1.00) (2023-06-16)
 [Full Changelog](https://github.com/kokkos/kokkos/compare/4.0.01...4.1.00)
 
 ### Features:
@@ -887,95 +1188,95 @@
 - Major update for OpenMPTarget: many capabilities now work. For details contact us.
 - Added DPC++/SYCL backend: primary capabilites are working.
 - Added Kokkos Graph API analogous to CUDA Graphs.
-- Added parallel_scan support with TeamThreadRange [\#3536](https://github.com/kokkos/kokkos/pull/#3536)
-- Added Logical Memory Spaces [\#3546](https://github.com/kokkos/kokkos/pull/#3546)
-- Added initial half precision support [\#3439](https://github.com/kokkos/kokkos/pull/#3439)
-- Experimental feature: control cuda occupancy [\#3379](https://github.com/kokkos/kokkos/pull/#3379)
+- Added parallel_scan support with TeamThreadRange [\#3536](https://github.com/kokkos/kokkos/pull/3536)
+- Added Logical Memory Spaces [\#3546](https://github.com/kokkos/kokkos/pull/3546)
+- Added initial half precision support [\#3439](https://github.com/kokkos/kokkos/pull/3439)
+- Experimental feature: control cuda occupancy [\#3379](https://github.com/kokkos/kokkos/pull/3379)
 
 **Implemented enhancements Backends and Archs:**
-- Add a64fx and fujitsu Compiler support [\#3614](https://github.com/kokkos/kokkos/pull/#3614)
-- Adding support for AMD gfx908 archictecture [\#3375](https://github.com/kokkos/kokkos/pull/#3375)
-- SYCL parallel\_for MDRangePolicy [\#3583](https://github.com/kokkos/kokkos/pull/#3583)
-- SYCL add parallel\_scan [\#3577](https://github.com/kokkos/kokkos/pull/#3577)
-- SYCL custom reductions [\#3544](https://github.com/kokkos/kokkos/pull/#3544)
-- SYCL Enable container unit tests [\#3550](https://github.com/kokkos/kokkos/pull/#3550)
-- SYCL feature level 5 [\#3480](https://github.com/kokkos/kokkos/pull/#3480)
-- SYCL Feature level 4 (parallel\_for) [\#3474](https://github.com/kokkos/kokkos/pull/#3474)
-- SYCL feature level 3 [\#3451](https://github.com/kokkos/kokkos/pull/#3451)
-- SYCL feature level 2 [\#3447](https://github.com/kokkos/kokkos/pull/#3447)
-- OpenMPTarget: Hierarchial reduction for + operator on scalars [\#3504](https://github.com/kokkos/kokkos/pull/#3504)
-- OpenMPTarget hierarchical [\#3411](https://github.com/kokkos/kokkos/pull/#3411)
-- HIP Add Impl::atomic\_[store,load] [\#3440](https://github.com/kokkos/kokkos/pull/#3440)
-- HIP enable global lock arrays [\#3418](https://github.com/kokkos/kokkos/pull/#3418)
-- HIP Implement multiple occupancy paths for various HIP kernel launchers [\#3366](https://github.com/kokkos/kokkos/pull/#3366)
+- Add a64fx and fujitsu Compiler support [\#3614](https://github.com/kokkos/kokkos/pull/3614)
+- Adding support for AMD gfx908 archictecture [\#3375](https://github.com/kokkos/kokkos/pull/3375)
+- SYCL parallel\_for MDRangePolicy [\#3583](https://github.com/kokkos/kokkos/pull/3583)
+- SYCL add parallel\_scan [\#3577](https://github.com/kokkos/kokkos/pull/3577)
+- SYCL custom reductions [\#3544](https://github.com/kokkos/kokkos/pull/3544)
+- SYCL Enable container unit tests [\#3550](https://github.com/kokkos/kokkos/pull/3550)
+- SYCL feature level 5 [\#3480](https://github.com/kokkos/kokkos/pull/3480)
+- SYCL Feature level 4 (parallel\_for) [\#3474](https://github.com/kokkos/kokkos/pull/3474)
+- SYCL feature level 3 [\#3451](https://github.com/kokkos/kokkos/pull/3451)
+- SYCL feature level 2 [\#3447](https://github.com/kokkos/kokkos/pull/3447)
+- OpenMPTarget: Hierarchial reduction for + operator on scalars [\#3504](https://github.com/kokkos/kokkos/pull/3504)
+- OpenMPTarget hierarchical [\#3411](https://github.com/kokkos/kokkos/pull/3411)
+- HIP Add Impl::atomic\_[store,load] [\#3440](https://github.com/kokkos/kokkos/pull/3440)
+- HIP enable global lock arrays [\#3418](https://github.com/kokkos/kokkos/pull/3418)
+- HIP Implement multiple occupancy paths for various HIP kernel launchers [\#3366](https://github.com/kokkos/kokkos/pull/3366)
 
 **Implemented enhancements Policies:**
-- MDRangePolicy: Let it be semiregular [\#3494](https://github.com/kokkos/kokkos/pull/#3494)
-- MDRangePolicy: Check narrowing conversion in construction [\#3527](https://github.com/kokkos/kokkos/pull/#3527)
-- MDRangePolicy: CombinedReducers support [\#3395](https://github.com/kokkos/kokkos/pull/#3395)
-- Kokkos Graph: Interface and Default Implementation [\#3362](https://github.com/kokkos/kokkos/pull/#3362)
-- Kokkos Graph: add Cuda Graph implementation [\#3369](https://github.com/kokkos/kokkos/pull/#3369)
-- TeamPolicy: implemented autotuning of team sizes and vector lengths [\#3206](https://github.com/kokkos/kokkos/pull/#3206)
-- RangePolicy: Initialize all data members in default constructor [\#3509](https://github.com/kokkos/kokkos/pull/#3509)
+- MDRangePolicy: Let it be semiregular [\#3494](https://github.com/kokkos/kokkos/pull/3494)
+- MDRangePolicy: Check narrowing conversion in construction [\#3527](https://github.com/kokkos/kokkos/pull/3527)
+- MDRangePolicy: CombinedReducers support [\#3395](https://github.com/kokkos/kokkos/pull/3395)
+- Kokkos Graph: Interface and Default Implementation [\#3362](https://github.com/kokkos/kokkos/pull/3362)
+- Kokkos Graph: add Cuda Graph implementation [\#3369](https://github.com/kokkos/kokkos/pull/3369)
+- TeamPolicy: implemented autotuning of team sizes and vector lengths [\#3206](https://github.com/kokkos/kokkos/pull/3206)
+- RangePolicy: Initialize all data members in default constructor [\#3509](https://github.com/kokkos/kokkos/pull/3509)
 
 **Implemented enhancements BuildSystem:**
-- Auto-generate core test files for all backends [\#3488](https://github.com/kokkos/kokkos/pull/#3488)
-- Avoid rewriting test files when calling cmake [\#3548](https://github.com/kokkos/kokkos/pull/#3548)
-- RULE\_LAUNCH\_COMPILE and RULE\_LAUNCH\_LINK system for nvcc\_wrapper [\#3136](https://github.com/kokkos/kokkos/pull/#3136)
-- Adding -include as a known argument to nvcc\_wrapper [\#3434](https://github.com/kokkos/kokkos/pull/#3434)
-- Install hpcbind script [\#3402](https://github.com/kokkos/kokkos/pull/#3402)
-- cmake/kokkos\_tribits.cmake: add parsing for args [\#3457](https://github.com/kokkos/kokkos/pull/#3457)
+- Auto-generate core test files for all backends [\#3488](https://github.com/kokkos/kokkos/pull/3488)
+- Avoid rewriting test files when calling cmake [\#3548](https://github.com/kokkos/kokkos/pull/3548)
+- RULE\_LAUNCH\_COMPILE and RULE\_LAUNCH\_LINK system for nvcc\_wrapper [\#3136](https://github.com/kokkos/kokkos/pull/3136)
+- Adding -include as a known argument to nvcc\_wrapper [\#3434](https://github.com/kokkos/kokkos/pull/3434)
+- Install hpcbind script [\#3402](https://github.com/kokkos/kokkos/pull/3402)
+- cmake/kokkos\_tribits.cmake: add parsing for args [\#3457](https://github.com/kokkos/kokkos/pull/3457)
 
 **Implemented enhancements Tools:**
-- Changed namespacing of Kokkos::Tools::Impl::Impl::tune\_policy [\#3455](https://github.com/kokkos/kokkos/pull/#3455)
-- Delegate to an impl allocate/deallocate method to allow specifying a SpaceHandle for MemorySpaces [\#3530](https://github.com/kokkos/kokkos/pull/#3530)
-- Use the Kokkos Profiling interface rather than the Impl interface [\#3518](https://github.com/kokkos/kokkos/pull/#3518)
-- Runtime option for tuning [\#3459](https://github.com/kokkos/kokkos/pull/#3459)
-- Dual View Tool Events [\#3326](https://github.com/kokkos/kokkos/pull/#3326)
+- Changed namespacing of Kokkos::Tools::Impl::Impl::tune\_policy [\#3455](https://github.com/kokkos/kokkos/pull/3455)
+- Delegate to an impl allocate/deallocate method to allow specifying a SpaceHandle for MemorySpaces [\#3530](https://github.com/kokkos/kokkos/pull/3530)
+- Use the Kokkos Profiling interface rather than the Impl interface [\#3518](https://github.com/kokkos/kokkos/pull/3518)
+- Runtime option for tuning [\#3459](https://github.com/kokkos/kokkos/pull/3459)
+- Dual View Tool Events [\#3326](https://github.com/kokkos/kokkos/pull/3326)
 
 **Implemented enhancements Other:**
-- Abort on errors instead of just printing [\#3528](https://github.com/kokkos/kokkos/pull/#3528)
-- Enable C++14 macros unconditionally [\#3449](https://github.com/kokkos/kokkos/pull/#3449)
-- Make ViewMapping trivially copyable [\#3436](https://github.com/kokkos/kokkos/pull/#3436)
-- Rename struct ViewMapping to class [\#3435](https://github.com/kokkos/kokkos/pull/#3435)
-- Replace enums in Kokkos\_ViewMapping.hpp (removes -Wextra) [\#3422](https://github.com/kokkos/kokkos/pull/#3422)
-- Use bool for enums representing bools [\#3416](https://github.com/kokkos/kokkos/pull/#3416)
-- Fence active instead of default execution space instances [\#3388](https://github.com/kokkos/kokkos/pull/#3388)
-- Refactor parallel\_reduce fence usage [\#3359](https://github.com/kokkos/kokkos/pull/#3359)
-- Moved Space EBO helpers to Kokkos\_EBO [\#3357](https://github.com/kokkos/kokkos/pull/#3357)
-- Add remove\_cvref type trait [\#3340](https://github.com/kokkos/kokkos/pull/#3340)
-- Adding identity type traits and update definition of identity\_t alias [\#3339](https://github.com/kokkos/kokkos/pull/#3339)
-- Add is\_specialization\_of type trait [\#3338](https://github.com/kokkos/kokkos/pull/#3338)
-- Make ScratchMemorySpace semi-regular [\#3309](https://github.com/kokkos/kokkos/pull/#3309)
-- Optimize min/max atomics with early exit on no-op case [\#3265](https://github.com/kokkos/kokkos/pull/#3265)
-- Refactor Backend Development [\#2941](https://github.com/kokkos/kokkos/pull/#2941)
+- Abort on errors instead of just printing [\#3528](https://github.com/kokkos/kokkos/pull/3528)
+- Enable C++14 macros unconditionally [\#3449](https://github.com/kokkos/kokkos/pull/3449)
+- Make ViewMapping trivially copyable [\#3436](https://github.com/kokkos/kokkos/pull/3436)
+- Rename struct ViewMapping to class [\#3435](https://github.com/kokkos/kokkos/pull/3435)
+- Replace enums in Kokkos\_ViewMapping.hpp (removes -Wextra) [\#3422](https://github.com/kokkos/kokkos/pull/3422)
+- Use bool for enums representing bools [\#3416](https://github.com/kokkos/kokkos/pull/3416)
+- Fence active instead of default execution space instances [\#3388](https://github.com/kokkos/kokkos/pull/3388)
+- Refactor parallel\_reduce fence usage [\#3359](https://github.com/kokkos/kokkos/pull/3359)
+- Moved Space EBO helpers to Kokkos\_EBO [\#3357](https://github.com/kokkos/kokkos/pull/3357)
+- Add remove\_cvref type trait [\#3340](https://github.com/kokkos/kokkos/pull/3340)
+- Adding identity type traits and update definition of identity\_t alias [\#3339](https://github.com/kokkos/kokkos/pull/3339)
+- Add is\_specialization\_of type trait [\#3338](https://github.com/kokkos/kokkos/pull/3338)
+- Make ScratchMemorySpace semi-regular [\#3309](https://github.com/kokkos/kokkos/pull/3309)
+- Optimize min/max atomics with early exit on no-op case [\#3265](https://github.com/kokkos/kokkos/pull/3265)
+- Refactor Backend Development [\#2941](https://github.com/kokkos/kokkos/pull/2941)
 
 **Fixed bugs:**
-- Fixup MDRangePolicy construction from Kokkos arrays [\#3591](https://github.com/kokkos/kokkos/pull/#3591)
-- Add atomic functions for unsigned long long using gcc built-in [\#3588](https://github.com/kokkos/kokkos/pull/#3588)
-- Fixup silent pointless comparison with zero in checked\_narrow\_cast (compiler workaround) [\#3566](https://github.com/kokkos/kokkos/pull/#3566)
-- Fixes for ROCm 3.9 [\#3565](https://github.com/kokkos/kokkos/pull/#3565)
-- Fix windows build issues which crept in for the CUDA build [\#3532](https://github.com/kokkos/kokkos/pull/#3532)
-- HIP Fix atomics of large data types and clean up lock arrays [\#3529](https://github.com/kokkos/kokkos/pull/#3529)
-- Pthreads fix exception resulting from 0 grain size [\#3510](https://github.com/kokkos/kokkos/pull/#3510)
-- Fixup do not require atomic operation to be default constructible [\#3503](https://github.com/kokkos/kokkos/pull/#3503)
-- Fix race condition in HIP backend [\#3467](https://github.com/kokkos/kokkos/pull/#3467)
-- Replace KOKKOS\_DEBUG with KOKKOS\_ENABLE\_DEBUG [\#3458](https://github.com/kokkos/kokkos/pull/#3458)
-- Fix multi-stream team scratch space definition for HIP [\#3398](https://github.com/kokkos/kokkos/pull/#3398)
-- HIP fix template deduction [\#3393](https://github.com/kokkos/kokkos/pull/#3393)
-- Fix compiling with HIP and C++17 [\#3390](https://github.com/kokkos/kokkos/pull/#3390)
-- Fix sigFPE in HIP blocksize deduction [\#3378](https://github.com/kokkos/kokkos/pull/#3378)
-- Type alias change: replace CS with CTS to avoid conflicts with NVSHMEM [\#3348](https://github.com/kokkos/kokkos/pull/#3348)
-- Clang compilation of CUDA backend on Windows [\#3345](https://github.com/kokkos/kokkos/pull/#3345)
-- Fix HBW support [\#3343](https://github.com/kokkos/kokkos/pull/#3343)
-- Added missing fences to unique token [\#3260](https://github.com/kokkos/kokkos/pull/#3260)
+- Fixup MDRangePolicy construction from Kokkos arrays [\#3591](https://github.com/kokkos/kokkos/pull/3591)
+- Add atomic functions for unsigned long long using gcc built-in [\#3588](https://github.com/kokkos/kokkos/pull/3588)
+- Fixup silent pointless comparison with zero in checked\_narrow\_cast (compiler workaround) [\#3566](https://github.com/kokkos/kokkos/pull/3566)
+- Fixes for ROCm 3.9 [\#3565](https://github.com/kokkos/kokkos/pull/3565)
+- Fix windows build issues which crept in for the CUDA build [\#3532](https://github.com/kokkos/kokkos/pull/3532)
+- HIP Fix atomics of large data types and clean up lock arrays [\#3529](https://github.com/kokkos/kokkos/pull/3529)
+- Pthreads fix exception resulting from 0 grain size [\#3510](https://github.com/kokkos/kokkos/pull/3510)
+- Fixup do not require atomic operation to be default constructible [\#3503](https://github.com/kokkos/kokkos/pull/3503)
+- Fix race condition in HIP backend [\#3467](https://github.com/kokkos/kokkos/pull/3467)
+- Replace KOKKOS\_DEBUG with KOKKOS\_ENABLE\_DEBUG [\#3458](https://github.com/kokkos/kokkos/pull/3458)
+- Fix multi-stream team scratch space definition for HIP [\#3398](https://github.com/kokkos/kokkos/pull/3398)
+- HIP fix template deduction [\#3393](https://github.com/kokkos/kokkos/pull/3393)
+- Fix compiling with HIP and C++17 [\#3390](https://github.com/kokkos/kokkos/pull/3390)
+- Fix sigFPE in HIP blocksize deduction [\#3378](https://github.com/kokkos/kokkos/pull/3378)
+- Type alias change: replace CS with CTS to avoid conflicts with NVSHMEM [\#3348](https://github.com/kokkos/kokkos/pull/3348)
+- Clang compilation of CUDA backend on Windows [\#3345](https://github.com/kokkos/kokkos/pull/3345)
+- Fix HBW support [\#3343](https://github.com/kokkos/kokkos/pull/3343)
+- Added missing fences to unique token [\#3260](https://github.com/kokkos/kokkos/pull/3260)
 
 **Incompatibilities:**
-- Remove unused utilities (forward, move, and expand\_variadic) from Kokkos::Impl [\#3535](https://github.com/kokkos/kokkos/pull/#3535)
-- Remove unused traits [\#3534](https://github.com/kokkos/kokkos/pull/#3534)
-- HIP: Remove old HCC code [\#3301](https://github.com/kokkos/kokkos/pull/#3301)
-- Prepare for deprecation of ViewAllocateWithoutInitializing [\#3264](https://github.com/kokkos/kokkos/pull/#3264)
-- Remove ROCm backend [\#3148](https://github.com/kokkos/kokkos/pull/#3148)
+- Remove unused utilities (forward, move, and expand\_variadic) from Kokkos::Impl [\#3535](https://github.com/kokkos/kokkos/pull/3535)
+- Remove unused traits [\#3534](https://github.com/kokkos/kokkos/pull/3534)
+- HIP: Remove old HCC code [\#3301](https://github.com/kokkos/kokkos/pull/3301)
+- Prepare for deprecation of ViewAllocateWithoutInitializing [\#3264](https://github.com/kokkos/kokkos/pull/3264)
+- Remove ROCm backend [\#3148](https://github.com/kokkos/kokkos/pull/3148)
 
 ## [3.2.01](https://github.com/kokkos/kokkos/tree/3.2.01) (2020-11-17)
 [Full Changelog](https://github.com/kokkos/kokkos/compare/3.2.00...3.2.01)
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 0000000000..28c674c451
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,65 @@
+cff-version: 1.2.0
+title: Kokkos
+message: >-
+  If you use this software, please cite the overview paper
+type: software
+authors:
+  - name: The Kokkos authors
+    website: https://kokkos.org/community/team/
+identifiers:
+  - type: url
+    website: https://kokkos.org/kokkos-core-wiki/citation.html
+repository-code: 'https://github.com/kokkos/kokkos'
+url: 'https://kokkos.org/'
+license: Apache-2.0
+preferred-citation:
+  type: article
+  authors:
+  - given-names: Christian R.
+    family-names: Trott
+  - given-names: Damien
+    family-names: Lebrun-Grandié
+  - given-names: Daniel
+    family-names: Arndt
+  - family-names: Ciesko
+    given-names: Jan
+  - given-names: Vinh
+    family-names: Dang
+  - family-names: Ellingwood
+    given-names: Nathan
+  - given-names: Rahulkumar
+    family-names: Gayatri
+  - given-names: Evan
+    family-names: Harvey
+  - given-names: Daisy S.
+    family-names: Hollman
+  - given-names: Dan
+    family-names: Ibanez
+  - given-names: Nevin
+    family-names: Liber
+  - given-names: Jonathan
+    family-names: Madsen
+  - given-names: Jeff
+    family-names: Miles
+  - given-names: David
+    family-names: Poliakoff
+  - given-names: Amy
+    family-names: Powell
+  - given-names: Sivasankaran
+    family-names: Rajamanickam
+  - given-names: Mikael
+    family-names: Simberg
+  - given-names: Dan
+    family-names: Sunderland
+  - given-names: Bruno
+    family-names: Turcksin
+  - given-names: Jeremiah
+    family-names: Wilke
+  doi: 10.1109/TPDS.2021.3097283
+  journal: IEEE Transactions on Parallel and Distributed Systems
+  start: 805
+  end: 817
+  title: "Kokkos 3: Programming Model Extensions for the Exascale Era"
+  volume: 33
+  issue: 4
+  year: 2022
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 895cee6a08..054de2c1da 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -150,8 +150,8 @@ ENDIF()
 
 
 set(Kokkos_VERSION_MAJOR 4)
-set(Kokkos_VERSION_MINOR 1)
-set(Kokkos_VERSION_PATCH 00)
+set(Kokkos_VERSION_MINOR 4)
+set(Kokkos_VERSION_PATCH 0)
 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}")
@@ -252,7 +252,6 @@ ENDIF()
 # subpackages
 
 ## This restores the old behavior of ProjectCompilerPostConfig.cmake
-# It sets the CMAKE_CXX_FLAGS globally to those used by Kokkos
 # We must do this before KOKKOS_PACKAGE_DECL
 IF (KOKKOS_HAS_TRILINOS)
   # Overwrite the old flags at the top-level
@@ -280,21 +279,13 @@ IF (KOKKOS_HAS_TRILINOS)
     SET(KOKKOSCORE_XCOMPILER_OPTIONS "${KOKKOSCORE_XCOMPILER_OPTIONS} -Xcompiler ${XCOMP_FLAG}")
     LIST(APPEND KOKKOS_ALL_COMPILE_OPTIONS -Xcompiler ${XCOMP_FLAG})
   ENDFOREACH()
-  SET(KOKKOSCORE_CXX_FLAGS "${KOKKOSCORE_COMPILE_OPTIONS} ${KOKKOSCORE_XCOMPILER_OPTIONS}")
   IF (KOKKOS_ENABLE_CUDA)
     STRING(REPLACE ";" " " KOKKOSCORE_CUDA_OPTIONS    "${KOKKOS_CUDA_OPTIONS}")
     FOREACH(CUDAFE_FLAG ${KOKKOS_CUDAFE_OPTIONS})
       SET(KOKKOSCORE_CUDAFE_OPTIONS "${KOKKOSCORE_CUDAFE_OPTIONS} -Xcudafe ${CUDAFE_FLAG}")
       LIST(APPEND KOKKOS_ALL_COMPILE_OPTIONS -Xcudafe ${CUDAFE_FLAG})
     ENDFOREACH()
-    SET(KOKKOSCORE_CXX_FLAGS "${KOKKOSCORE_CXX_FLAGS} ${KOKKOSCORE_CUDA_OPTIONS} ${KOKKOSCORE_CUDAFE_OPTIONS}")
   ENDIF()
-  # Both parent scope and this package
-  # In ProjectCompilerPostConfig.cmake, we capture the "global" flags Trilinos wants in
-  # TRILINOS_TOPLEVEL_CXX_FLAGS
-  SET(CMAKE_CXX_FLAGS "${TRILINOS_TOPLEVEL_CXX_FLAGS} ${KOKKOSCORE_CXX_FLAGS}" PARENT_SCOPE)
-  SET(CMAKE_CXX_FLAGS "${TRILINOS_TOPLEVEL_CXX_FLAGS} ${KOKKOSCORE_CXX_FLAGS}")
-  #CMAKE_CXX_FLAGS will get added to Kokkos and Kokkos dependencies automatically here
   #These flags get set up in KOKKOS_PACKAGE_DECL, which means they
   #must be configured before KOKKOS_PACKAGE_DECL
   SET(KOKKOS_ALL_COMPILE_OPTIONS
@@ -314,7 +305,6 @@ KOKKOS_PROCESS_SUBPACKAGES()
 # E) If Kokkos itself is enabled, process the Kokkos package
 #
 
-KOKKOS_EXCLUDE_AUTOTOOLS_FILES()
 KOKKOS_PACKAGE_POSTPROCESS()
 KOKKOS_CONFIGURE_CORE()
 
diff --git a/Copyright.txt b/Copyright.txt
index 5e2f8d8647..cbba3efc7b 100644
--- a/Copyright.txt
+++ b/Copyright.txt
@@ -1,41 +1,8 @@
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 3.0
-//       Copyright (2020) 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.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY NTESS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NTESS OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@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.
diff --git a/LICENSE b/LICENSE
index 6572cc2db0..4d9d69d7c4 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,13 +1,3 @@
- ************************************************************************
- 
-                        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.
-
-
  ==============================================================================
  Kokkos is under the Apache License v2.0 with LLVM Exceptions:
  ==============================================================================
diff --git a/Makefile.kokkos b/Makefile.kokkos
index 9436b75b9e..15f24f3073 100644
--- a/Makefile.kokkos
+++ b/Makefile.kokkos
@@ -1,8 +1,8 @@
 # Default settings common options.
 
 KOKKOS_VERSION_MAJOR = 4
-KOKKOS_VERSION_MINOR = 1
-KOKKOS_VERSION_PATCH = 00
+KOKKOS_VERSION_MINOR = 4
+KOKKOS_VERSION_PATCH = 0
 KOKKOS_VERSION = $(shell echo $(KOKKOS_VERSION_MAJOR)*10000+$(KOKKOS_VERSION_MINOR)*100+$(KOKKOS_VERSION_PATCH) | bc)
 
 # Options: Cuda,HIP,SYCL,OpenMPTarget,OpenMP,Threads,Serial
@@ -11,15 +11,15 @@ 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,Ada89,Hopper90
-# ARM:      ARMv80,ARMv81,ARMv8-ThunderX,ARMv8-TX2,A64FX
-# IBM:      BGQ,Power7,Power8,Power9
-# AMD-GPUS: Vega906,Vega908,Vega90A,Navi1030
+# ARM:      ARMv80,ARMv81,ARMv8-ThunderX,ARMv8-TX2,A64FX,ARMv9-Grace
+# IBM:      Power8,Power9
+# AMD-GPUS: AMD_GFX906,AMD_GFX908,AMD_GFX90A,AMD_GFX940,AMD_GFX942,AMD_GFX1030,AMD_GFX1100
 # AMD-CPUS: AMDAVX,Zen,Zen2,Zen3
-# Intel-GPUs: Gen9,Gen11,Gen12LP,DG1,XeHP,PVC
+# Intel-GPUs: Intel_Gen,Intel_Gen9,Intel_Gen11,Intel_Gen12LP,Intel_DG1,Intel_XeHP,Intel_PVC
 KOKKOS_ARCH ?= ""
 # Options: yes,no
 KOKKOS_DEBUG ?= "no"
-# Options: hwloc,librt,experimental_memkind
+# Options: hwloc
 KOKKOS_USE_TPLS ?= ""
 # Options: c++17,c++1z,c++20,c++2a,c++23,c++2b
 KOKKOS_CXX_STANDARD ?= "c++17"
@@ -30,7 +30,7 @@ KOKKOS_TRIBITS ?= "no"
 KOKKOS_STANDALONE_CMAKE ?= "no"
 
 # Default settings specific options.
-# Options: force_uvm,use_ldg,rdc,enable_lambda,enable_constexpr
+# Options: force_uvm,use_ldg,rdc,enable_lambda,enable_constexpr,disable_malloc_async
 KOKKOS_CUDA_OPTIONS ?= ""
 
 # Options: rdc
@@ -46,7 +46,7 @@ uppercase_internal=$(if $1,$$(subst $(firstword $1),$(call uppercase_internal,$(
 uppercase=$(eval uppercase_RESULT:=$(call uppercase_internal,$(uppercase_TABLE),$1))$(uppercase_RESULT)
 # Return a 1 if a string contains a substring and 0 if not
 # Note the search string should be without '"'
-# Example: $(call kokkos_has_string,"hwloc,librt",hwloc)
+# Example: $(call kokkos_has_string,"hwloc,libdl",hwloc)
 #   Will return a 1
 kokkos_has_string=$(if $(findstring $(call uppercase,$2),$(call uppercase,$1)),1,0)
 # Returns 1 if the path exists, 0 otherwise
@@ -63,11 +63,11 @@ KOKKOS_INTERNAL_ENABLE_CXX20 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),
 KOKKOS_INTERNAL_ENABLE_CXX2A := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++2a)
 KOKKOS_INTERNAL_ENABLE_CXX23 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++23)
 KOKKOS_INTERNAL_ENABLE_CXX2B := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++2b)
+KOKKOS_INTERNAL_ENABLE_CXX26 := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++26)
+KOKKOS_INTERNAL_ENABLE_CXX2C := $(call kokkos_has_string,$(KOKKOS_CXX_STANDARD),c++2c)
 
 # Check for external libraries.
 KOKKOS_INTERNAL_USE_HWLOC := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),hwloc)
-KOKKOS_INTERNAL_USE_LIBRT := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),librt)
-KOKKOS_INTERNAL_USE_MEMKIND := $(call kokkos_has_string,$(KOKKOS_USE_TPLS),experimental_memkind)
 
 # Check for advanced settings.
 KOKKOS_INTERNAL_ENABLE_COMPILER_WARNINGS := $(call kokkos_has_string,$(KOKKOS_OPTIONS),compiler_warnings)
@@ -82,6 +82,7 @@ KOKKOS_INTERNAL_CUDA_USE_UVM := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),
 KOKKOS_INTERNAL_CUDA_USE_RELOC := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),rdc)
 KOKKOS_INTERNAL_CUDA_USE_LAMBDA := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_lambda)
 KOKKOS_INTERNAL_CUDA_USE_CONSTEXPR := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),enable_constexpr)
+KOKKOS_INTERNAL_CUDA_DISABLE_MALLOC_ASYNC := $(call kokkos_has_string,$(KOKKOS_CUDA_OPTIONS),disable_malloc_async)
 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)
@@ -307,7 +308,6 @@ endif
 
 # Intel based.
 KOKKOS_INTERNAL_USE_ARCH_KNC := $(call kokkos_has_string,$(KOKKOS_ARCH),KNC)
-KOKKOS_INTERNAL_USE_ARCH_WSM := $(call kokkos_has_string,$(KOKKOS_ARCH),WSM)
 KOKKOS_INTERNAL_USE_ARCH_SNB := $(call kokkos_has_string,$(KOKKOS_ARCH),SNB)
 KOKKOS_INTERNAL_USE_ARCH_HSW := $(call kokkos_has_string,$(KOKKOS_ARCH),HSW)
 KOKKOS_INTERNAL_USE_ARCH_BDW := $(call kokkos_has_string,$(KOKKOS_ARCH),BDW)
@@ -318,12 +318,43 @@ KOKKOS_INTERNAL_USE_ARCH_ICL := $(call kokkos_has_string,$(KOKKOS_ARCH),ICL)
 KOKKOS_INTERNAL_USE_ARCH_ICX := $(call kokkos_has_string,$(KOKKOS_ARCH),ICX)
 KOKKOS_INTERNAL_USE_ARCH_SPR := $(call kokkos_has_string,$(KOKKOS_ARCH),SPR)
 
-KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen)
+# Traditionally, we supported, e.g., IntelGen9 instead of Intel_Gen9. The latter
+# matches the CMake option but we also accept the former for backward-compatibility.
 KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9 := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen9)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9 := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_Gen9)
+endif
 KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN11 := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen11)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN11), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN11 := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_Gen11)
+endif
 KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN12LP := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen12LP)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN12LP), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN12LP := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_Gen12LP)
+endif
+KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen9)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9 := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_Gen9)
+endif
+KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN_SET := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN9)  \
+                                                     + $(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN11) \
+                                                     + $(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN12LP))
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN_SET), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelGen)
+  ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN), 0)
+    KOKKOS_INTERNAL_USE_ARCH_INTEL_GEN := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_Gen)
+  endif
+endif
 KOKKOS_INTERNAL_USE_ARCH_INTEL_DG1 := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelDG1)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_DG1), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_DG1 := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_DG1)
+endif
 KOKKOS_INTERNAL_USE_ARCH_INTEL_XEHP := $(call kokkos_has_string,$(KOKKOS_ARCH),IntelXeHP)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_INTEL_XEHP), 0)
+  KOKKOS_INTERNAL_USE_ARCH_INTEL_XEHP := $(call kokkos_has_string,$(KOKKOS_ARCH),Intel_XeHP)
+endif
+# Traditionally the architecture was called PVC instead of Intel_PVC. This
+# version makes us accept IntelPVC and Intel_PVC as well.
 KOKKOS_INTERNAL_USE_ARCH_INTEL_PVC := $(call kokkos_has_string,$(KOKKOS_ARCH),PVC)
 
 # NVIDIA based.
@@ -384,14 +415,13 @@ KOKKOS_INTERNAL_USE_ARCH_ARMV81 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8
 KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8-ThunderX)
 KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2 := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv8-TX2)
 KOKKOS_INTERNAL_USE_ARCH_A64FX := $(call kokkos_has_string,$(KOKKOS_ARCH),A64FX)
-KOKKOS_INTERNAL_USE_ARCH_ARM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_ARMV80)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV81)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2)+$(KOKKOS_INTERNAL_USE_ARCH_A64FX) | bc))
+KOKKOS_INTERNAL_USE_ARCH_ARMV9_GRACE := $(call kokkos_has_string,$(KOKKOS_ARCH),ARMv9-Grace)
+KOKKOS_INTERNAL_USE_ARCH_ARM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_ARMV80)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV81)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2)+$(KOKKOS_INTERNAL_USE_ARCH_A64FX)+$(KOKKOS_INTERNAL_USE_ARCH_ARMV9_GRACE) | bc))
 
 # IBM based.
-KOKKOS_INTERNAL_USE_ARCH_BGQ := $(call kokkos_has_string,$(KOKKOS_ARCH),BGQ)
-KOKKOS_INTERNAL_USE_ARCH_POWER7 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power7)
 KOKKOS_INTERNAL_USE_ARCH_POWER8 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power8)
 KOKKOS_INTERNAL_USE_ARCH_POWER9 := $(call kokkos_has_string,$(KOKKOS_ARCH),Power9)
-KOKKOS_INTERNAL_USE_ARCH_IBM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_BGQ)+$(KOKKOS_INTERNAL_USE_ARCH_POWER7)+$(KOKKOS_INTERNAL_USE_ARCH_POWER8)+$(KOKKOS_INTERNAL_USE_ARCH_POWER9) | bc))
+KOKKOS_INTERNAL_USE_ARCH_IBM := $(strip $(shell echo $(KOKKOS_INTERNAL_USE_ARCH_POWER8)+$(KOKKOS_INTERNAL_USE_ARCH_POWER9) | bc))
 
 # AMD based.
 KOKKOS_INTERNAL_USE_ARCH_AMDAVX := $(call kokkos_has_string,$(KOKKOS_ARCH),AMDAVX)
@@ -402,19 +432,37 @@ ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN3), 0)
     KOKKOS_INTERNAL_USE_ARCH_ZEN := $(call kokkos_has_string,$(KOKKOS_ARCH),Zen)
   endif
 endif
-KOKKOS_INTERNAL_USE_ARCH_VEGA906 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega906)
-KOKKOS_INTERNAL_USE_ARCH_VEGA908 := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega908)
-KOKKOS_INTERNAL_USE_ARCH_VEGA90A := $(call kokkos_has_string,$(KOKKOS_ARCH),Vega90A)
-KOKKOS_INTERNAL_USE_ARCH_NAVI1030 := $(call kokkos_has_string,$(KOKKOS_ARCH),Navi1030)
+
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX906 := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX906)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX906), 0)
+  KOKKOS_INTERNAL_USE_ARCH_AMD_GFX906 := $(call kokkos_has_string,$(KOKKOS_ARCH),VEGA906)
+endif
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX908 := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX908)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX908), 0)
+  KOKKOS_INTERNAL_USE_ARCH_AMD_GFX908 := $(call kokkos_has_string,$(KOKKOS_ARCH),VEGA908)
+endif
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX90A := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX90A)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX90A), 0)
+  KOKKOS_INTERNAL_USE_ARCH_AMD_GFX90A := $(call kokkos_has_string,$(KOKKOS_ARCH),VEGA90A)
+endif
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX940 := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX940)
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX942 := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX942)
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1030 := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX1030)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1030), 0)
+  KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1030 := $(call kokkos_has_string,$(KOKKOS_ARCH),NAVI1030)
+endif
+KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1100 := $(call kokkos_has_string,$(KOKKOS_ARCH),AMD_GFX1100)
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1100), 0)
+  KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1100 := $(call kokkos_has_string,$(KOKKOS_ARCH),NAVI1100)
+endif
 
 # Any AVX?
-KOKKOS_INTERNAL_USE_ARCH_SSE42      := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_WSM))
 KOKKOS_INTERNAL_USE_ARCH_AVX        := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_SNB) + $(KOKKOS_INTERNAL_USE_ARCH_AMDAVX))
 KOKKOS_INTERNAL_USE_ARCH_AVX2       := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_HSW) + $(KOKKOS_INTERNAL_USE_ARCH_BDW) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN2) + $(KOKKOS_INTERNAL_USE_ARCH_ZEN3))
 KOKKOS_INTERNAL_USE_ARCH_AVX512MIC  := $(shell expr $(KOKKOS_INTERNAL_USE_ARCH_KNL))
 
 # Incompatible flags?
-KOKKOS_INTERNAL_USE_ARCH_MULTIHOST := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_SSE42)+$(KOKKOS_INTERNAL_USE_ARCH_AVX)+$(KOKKOS_INTERNAL_USE_ARCH_AVX2)+$(KOKKOS_INTERNAL_USE_ARCH_AVX512MIC)+$(KOKKOS_INTERNAL_USE_ARCH_SKL)+$(KOKKOS_INTERNAL_USE_ARCH_SKX)+$(KOKKOS_INTERNAL_USE_ARCH_ICL)+$(KOKKOS_INTERNAL_USE_ARCH_ICX)+$(KOKKOS_INTERNAL_USE_ARCH_SPR)+$(KOKKOS_INTERNAL_USE_ARCH_KNC)+$(KOKKOS_INTERNAL_USE_ARCH_IBM)+$(KOKKOS_INTERNAL_USE_ARCH_ARM)>1") | bc)
+KOKKOS_INTERNAL_USE_ARCH_MULTIHOST := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_AVX)+$(KOKKOS_INTERNAL_USE_ARCH_AVX2)+$(KOKKOS_INTERNAL_USE_ARCH_AVX512MIC)+$(KOKKOS_INTERNAL_USE_ARCH_SKL)+$(KOKKOS_INTERNAL_USE_ARCH_SKX)+$(KOKKOS_INTERNAL_USE_ARCH_ICL)+$(KOKKOS_INTERNAL_USE_ARCH_ICX)+$(KOKKOS_INTERNAL_USE_ARCH_SPR)+$(KOKKOS_INTERNAL_USE_ARCH_KNC)+$(KOKKOS_INTERNAL_USE_ARCH_IBM)+$(KOKKOS_INTERNAL_USE_ARCH_ARM)>1") | bc)
 KOKKOS_INTERNAL_USE_ARCH_MULTIGPU := $(strip $(shell echo "$(KOKKOS_INTERNAL_USE_ARCH_NVIDIA)>1") | bc)
 
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_MULTIHOST), 1)
@@ -559,6 +607,16 @@ ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX2B), 1)
   KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX2B_FLAG)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX23")
 endif
+ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX26), 1)
+  #I cannot make CMake add this in a good way - so add it here
+  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX26_FLAG)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX26")
+endif
+ifeq ($(KOKKOS_INTERNAL_ENABLE_CXX2C), 1)
+  #I cannot make CMake add this in a good way - so add it here
+  KOKKOS_CXXFLAGS += $(KOKKOS_INTERNAL_CXX2C_FLAG)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_CXX26")
+endif
 
 ifeq ($(KOKKOS_INTERNAL_ENABLE_DEBUG), 1)
   ifeq ($(KOKKOS_INTERNAL_COMPILER_NVCC), 1)
@@ -598,27 +656,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_HWLOC), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HWLOC")
 endif
 
-ifeq ($(KOKKOS_INTERNAL_USE_LIBRT), 1)
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_USE_LIBRT")
-  KOKKOS_LIBS += -lrt
-  KOKKOS_TPL_LIBRARY_NAMES += rt
-endif
-
-ifeq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
-  ifneq ($(KOKKOS_CMAKE), yes)
-    ifneq ($(MEMKIND_PATH),)
-      KOKKOS_CPPFLAGS += -I$(MEMKIND_PATH)/include
-      KOKKOS_LIBDIRS += -L$(MEMKIND_PATH)/lib
-      KOKKOS_CXXLDFLAGS += -L$(MEMKIND_PATH)/lib
-      KOKKOS_TPL_INCLUDE_DIRS += $(MEMKIND_PATH)/include
-      KOKKOS_TPL_LIBRARY_DIRS += $(MEMKIND_PATH)/lib
-    endif
-    KOKKOS_LIBS += -lmemkind -lnuma
-    KOKKOS_TPL_LIBRARY_NAMES += memkind numa
-  endif
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_HBWSPACE")
-endif
-
 ifeq ($(KOKKOS_INTERNAL_ENABLE_LARGE_MEM_TESTS), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_LARGE_MEM_TESTS")
 endif
@@ -685,8 +722,10 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     endif
   endif
 
-  ifeq ($(KOKKOS_INTERNAL_COMPILER_CLANG), 1)
-    tmp := $(call kokkos_append_header,"$H""define KOKKOS_IMPL_CUDA_CLANG_WORKAROUND")
+  ifeq ($(KOKKOS_INTERNAL_CUDA_DISABLE_MALLOC_ASYNC), 0)
+    tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC")
+  else
+    tmp := $(call kokkos_append_header,"/* $H""undef KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC */")
   endif
 endif
 
@@ -700,6 +739,7 @@ endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV80), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV80")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARM_NEON")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
     KOKKOS_CXXFLAGS +=
@@ -712,6 +752,7 @@ endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV81), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV81")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARM_NEON")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
     KOKKOS_CXXFLAGS +=
@@ -724,6 +765,7 @@ endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_A64FX), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_A64FX")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARM_NEON")
 
   KOKKOS_CXXFLAGS += -march=armv8.2-a+sve
   KOKKOS_LDFLAGS += -march=armv8.2-a+sve
@@ -737,9 +779,17 @@ ifeq ($(KOKKOS_INTERNAL_USE_ARCH_A64FX), 1)
   endif
 endif
 
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV9_GRACE), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV9_GRACE")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARM_NEON")
+
+  KOKKOS_CXXFLAGS += -mcpu=neoverse-v2  -msve-vector-bits=128
+  KOKKOS_LDFLAGS += -mcpu=neoverse-v2  -msve-vector-bits=128
+endif
+
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_ZEN")
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_AVX2")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX2")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
     KOKKOS_CXXFLAGS += -mavx2
@@ -752,7 +802,7 @@ endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN2), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_ZEN2")
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_AVX2")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX2")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
     KOKKOS_CXXFLAGS += -mavx2
@@ -765,7 +815,7 @@ endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ZEN3), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_ZEN3")
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_AVX2")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX2")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
     KOKKOS_CXXFLAGS += -mavx2
@@ -779,6 +829,7 @@ endif
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV80")
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV8_THUNDERX")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARM_NEON")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
     KOKKOS_CXXFLAGS +=
@@ -792,6 +843,7 @@ endif
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV81")
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARMV8_THUNDERX2")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_ARM_NEON")
 
   ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
     KOKKOS_CXXFLAGS +=
@@ -802,20 +854,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_ARCH_ARMV8_THUNDERX2), 1)
   endif
 endif
 
-ifeq ($(KOKKOS_INTERNAL_USE_ARCH_SSE42), 1)
-  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_SSE42")
-
-  ifeq ($(KOKKOS_INTERNAL_COMPILER_INTEL), 1)
-    KOKKOS_CXXFLAGS += -xSSE4.2
-    KOKKOS_LDFLAGS  += -xSSE4.2
-  else ifeq ($(KOKKOS_INTERNAL_COMPILER_CRAY), 1)
-  else
-    # Assume that this is a really a GNU compiler.
-    KOKKOS_CXXFLAGS += -msse4.2
-    KOKKOS_LDFLAGS  += -msse4.2
-  endif
-endif
-
 ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AVX), 1)
   tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AVX")
 
@@ -1075,29 +1113,39 @@ endif
 
 
 # Figure out the architecture flag for ROCm.
-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")
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX906), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX906")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
   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")
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX908), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX908")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
   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")
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX90A), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX90A")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
   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")
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX940), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX940")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx940
+endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX942), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX942")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
+  KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx942
+endif
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1030), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX1030")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
   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")
+ifeq ($(KOKKOS_INTERNAL_USE_ARCH_AMD_GFX1100), 1)
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GFX1100")
+  tmp := $(call kokkos_append_header,"$H""define KOKKOS_ARCH_AMD_GPU")
   KOKKOS_INTERNAL_HIP_ARCH_FLAG := --offload-arch=gfx1100
 endif
 
@@ -1192,6 +1240,8 @@ ifeq ($(KOKKOS_INTERNAL_DISABLE_BUNDLED_MDSPAN), 0)
 endif
 tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_IMPL_MDSPAN")
 
+tmp := $(call kokkos_append_header,"$H""define KOKKOS_ENABLE_IMPL_REF_COUNT_BRANCH_UNLIKELY")
+
 KOKKOS_INTERNAL_LS_CONFIG := $(shell ls KokkosCore_config.h 2>&1)
 
 ifeq ($(KOKKOS_INTERNAL_LS_CONFIG), KokkosCore_config.h)
@@ -1214,7 +1264,22 @@ ifneq ($(KOKKOS_INTERNAL_NEW_CONFIG), 0)
   tmp := $(call kokkos_update_config_header, KOKKOS_FWD_HPP_, "KokkosCore_Config_FwdBackend.tmp", "KokkosCore_Config_FwdBackend.hpp")
   tmp := $(call kokkos_update_config_header, KOKKOS_SETUP_HPP_, "KokkosCore_Config_SetupBackend.tmp", "KokkosCore_Config_SetupBackend.hpp")
   tmp := $(call kokkos_update_config_header, KOKKOS_DECLARE_HPP_, "KokkosCore_Config_DeclareBackend.tmp", "KokkosCore_Config_DeclareBackend.hpp")
-  tmp := $(call kokkos_update_config_header, KOKKOS_POST_INCLUDE_HPP_, "KokkosCore_Config_PostInclude.tmp", "KokkosCore_Config_PostInclude.hpp")
+  ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
+    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_OPENMP.hpp>","KokkosCore_Config_FwdBackend.hpp")
+    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_OPENMP.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")
+    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_THREADS.hpp>","KokkosCore_Config_DeclareBackend.hpp")
+  endif
+  ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
+    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HPX.hpp>","KokkosCore_Config_FwdBackend.hpp")
+    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HPX.hpp>","KokkosCore_Config_DeclareBackend.hpp")
+  endif
+  ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
+    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_SERIAL.hpp>","KokkosCore_Config_FwdBackend.hpp")
+    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_SERIAL.hpp>","KokkosCore_Config_DeclareBackend.hpp")
+  endif
   ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_CUDA.hpp>","KokkosCore_Config_FwdBackend.hpp")
     tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_CUDA.hpp>","KokkosCore_Config_DeclareBackend.hpp")
@@ -1234,30 +1299,10 @@ ifneq ($(KOKKOS_INTERNAL_NEW_CONFIG), 0)
     tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HIP.hpp>","KokkosCore_Config_DeclareBackend.hpp")
     tmp := $(call kokkos_append_config_header,"$H""include <setup/Kokkos_Setup_HIP.hpp>","KokkosCore_Config_SetupBackend.hpp")
   endif
-  ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
-    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_OPENMP.hpp>","KokkosCore_Config_FwdBackend.hpp")
-    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,"$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")
-    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_THREADS.hpp>","KokkosCore_Config_DeclareBackend.hpp")
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
-    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HPX.hpp>","KokkosCore_Config_FwdBackend.hpp")
-    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HPX.hpp>","KokkosCore_Config_DeclareBackend.hpp")
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
-    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_SERIAL.hpp>","KokkosCore_Config_FwdBackend.hpp")
-    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_SERIAL.hpp>","KokkosCore_Config_DeclareBackend.hpp")
-  endif
-  ifeq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
-    tmp := $(call kokkos_append_config_header,"$H""include <fwd/Kokkos_Fwd_HBWSpace.hpp>","KokkosCore_Config_FwdBackend.hpp")
-    tmp := $(call kokkos_append_config_header,"$H""include <decl/Kokkos_Declare_HBWSpace.hpp>","KokkosCore_Config_DeclareBackend.hpp")
-  endif
 endif
 
 KOKKOS_HEADERS += $(wildcard $(KOKKOS_PATH)/core/src/*.hpp)
@@ -1368,11 +1413,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
   KOKKOS_TPL_LIBRARY_NAMES += hpx
 endif
 
-# Don't include Kokkos_HBWSpace.cpp if not using MEMKIND to avoid a link warning.
-ifneq ($(KOKKOS_INTERNAL_USE_MEMKIND), 1)
-  KOKKOS_SRC := $(filter-out $(KOKKOS_PATH)/core/src/impl/Kokkos_HBWSpace.cpp,$(KOKKOS_SRC))
-endif
-
 # With Cygwin functions such as fdopen and fileno are not defined
 # when strict ansi is enabled. strict ansi gets enabled with -std=c++14
 # though. So we hard undefine it here. Not sure if that has any bad side effects
@@ -1426,6 +1466,12 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
 else
   tmp := $(call desul_append_header,"/* $H""undef DESUL_ATOMICS_ENABLE_OPENMP */")
 endif
+
+ifeq ($(KOKKOS_INTERNAL_USE_OPENACC), 1)
+  tmp := $(call desul_append_header,"$H""define DESUL_ATOMICS_ENABLE_OPENACC")
+else
+  tmp := $(call desul_append_header,"/* $H""undef DESUL_ATOMICS_ENABLE_OPENACC */")
+endif
 tmp := $(call desul_append_header, "")
 tmp := $(call desul_append_header, "$H""endif")
 
@@ -1458,7 +1504,7 @@ include $(KOKKOS_PATH)/Makefile.targets
 kokkos-clean:
 	rm -f $(KOKKOS_OBJ_LINK) $(DESUL_CONFIG_HEADER) $(DESUL_INTERNAL_CONFIG_TMP) KokkosCore_config.h KokkosCore_config.tmp libkokkos.a KokkosCore_Config_SetupBackend.hpp \
 	KokkosCore_Config_FwdBackend.hpp KokkosCore_Config_DeclareBackend.hpp KokkosCore_Config_DeclareBackend.tmp \
-        KokkosCore_Config_FwdBackend.tmp KokkosCore_Config_PostInclude.hpp KokkosCore_Config_PostInclude.tmp KokkosCore_Config_SetupBackend.tmp
+        KokkosCore_Config_FwdBackend.tmp KokkosCore_Config_SetupBackend.tmp
 
 libkokkos.a: $(KOKKOS_OBJ_LINK) $(KOKKOS_SRC) $(KOKKOS_HEADERS)
 	ar cr libkokkos.a $(KOKKOS_OBJ_LINK)
diff --git a/Makefile.targets b/Makefile.targets
index 4e08a46c69..e8e429e027 100644
--- a/Makefile.targets
+++ b/Makefile.targets
@@ -20,8 +20,6 @@ Kokkos_TaskQueue.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_Ta
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_TaskQueue.cpp
 Kokkos_HostThreadTeam.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_HostThreadTeam.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_HostThreadTeam.cpp
-Kokkos_Spinwait.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_Spinwait.cpp
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_Spinwait.cpp
 Kokkos_HostBarrier.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_HostBarrier.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_HostBarrier.cpp
 Kokkos_Profiling.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_Profiling.cpp
@@ -30,12 +28,12 @@ Kokkos_SharedAlloc.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_SharedAlloc.cpp
 Kokkos_MemoryPool.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_MemoryPool.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_MemoryPool.cpp
-Kokkos_MemorySpace.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_MemorySpace.cpp
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_MemorySpace.cpp
 Kokkos_HostSpace_deepcopy.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_HostSpace_deepcopy.cpp 
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
 Kokkos_NumericTraits.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_NumericTraits.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_NumericTraits.cpp
+Kokkos_Abort.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_Abort.cpp
+	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_Abort.cpp
 
 ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
 Kokkos_Serial.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Serial/Kokkos_Serial.cpp
@@ -80,8 +78,10 @@ Lock_Array_HIP.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/tpls/desul/src/Lock_Array
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
-Kokkos_ThreadsExec.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Threads/Kokkos_ThreadsExec.cpp
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/Threads/Kokkos_ThreadsExec.cpp
+Kokkos_Threads_Instance.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Threads/Kokkos_Threads_Instance.cpp
+	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/Threads/Kokkos_Threads_Instance.cpp
+Kokkos_Threads_Spinwait.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/Threads/Kokkos_Threads_Spinwait.cpp
+	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/Threads/Kokkos_Threads_Spinwait.cpp
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
@@ -121,6 +121,3 @@ Kokkos_OpenACC_Instance.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/OpenACC
 Kokkos_OpenACC_SharedAllocationRecord.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.cpp
 	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.cpp
 endif
-
-Kokkos_HBWSpace.o: $(KOKKOS_CPP_DEPENDS) $(KOKKOS_PATH)/core/src/impl/Kokkos_HBWSpace.cpp
-	$(CXX) $(KOKKOS_CPPFLAGS) $(KOKKOS_CXXFLAGS) $(CXXFLAGS) -c $(KOKKOS_PATH)/core/src/impl/Kokkos_HBWSpace.cpp
diff --git a/README.md b/README.md
index 033346e956..c8c6f8f7cf 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-![Kokkos](https://avatars2.githubusercontent.com/u/10199860?s=200&v=4)
+[![Kokkos](https://avatars2.githubusercontent.com/u/10199860?s=200&v=4)](https://kokkos.org)
 
 # Kokkos: Core Libraries
 
@@ -10,48 +10,71 @@ hierarchies and multiple types of execution resources. It currently can use
 CUDA, HIP, SYCL, HPX, OpenMP and C++ threads as backend programming models with several other
 backends in development.
 
-**Kokkos Core is part of the Kokkos C++ Performance Portability Programming EcoSystem.**
+**Kokkos Core is part of the [Kokkos C++ Performance Portability Programming Ecosystem](https://kokkos.org/about/abstract/).**
 
-For the complete documentation, click below:
+Kokkos is a [Linux Foundation](https://linuxfoundation.org) project.
 
-# [kokkos.github.io/kokkos-core-wiki](https://kokkos.github.io/kokkos-core-wiki)
-
-# Learning about Kokkos
+## Learning about Kokkos
 
 To start learning about Kokkos:
 
-- [Kokkos Lectures](https://kokkos.github.io/kokkos-core-wiki/videolectures.html): they contain a mix of lecture videos and hands-on exercises covering all the important Kokkos Ecosystem capabilities.
+- [Kokkos Lectures](https://kokkos.org/kokkos-core-wiki/videolectures.html): they contain a mix of lecture videos and hands-on exercises covering all the important capabilities.
 
-- [Programming guide](https://kokkos.github.io/kokkos-core-wiki/programmingguide.html): contains in "narrative" form a technical description of the programming model, machine model, and the main building blocks like the Views and parallel dispatch.
+- [Programming guide](https://kokkos.org/kokkos-core-wiki/programmingguide.html): contains in "narrative" form a technical description of the programming model, machine model, and the main building blocks like the Views and parallel dispatch.
 
-- [API reference](https://kokkos.github.io/kokkos-core-wiki/): organized by category, i.e., [core](https://kokkos.github.io/kokkos-core-wiki/API/core-index.html), [algorithms](https://kokkos.github.io/kokkos-core-wiki/API/algorithms-index.html) and [containers](https://kokkos.github.io/kokkos-core-wiki/API/containers-index.html) or, if you prefer, in [alphabetical order](https://kokkos.github.io/kokkos-core-wiki/API/alphabetical.html).
+- [API reference](https://kokkos.org/kokkos-core-wiki/): organized by category, i.e., [core](https://kokkos.org/kokkos-core-wiki/API/core-index.html), [algorithms](https://kokkos.org/kokkos-core-wiki/API/algorithms-index.html) and [containers](https://kokkos.org/kokkos-core-wiki/API/containers-index.html) or, if you prefer, in [alphabetical order](https://kokkos.org/kokkos-core-wiki/API/alphabetical.html).
 
-- [Use cases and Examples](https://kokkos.github.io/kokkos-core-wiki/usecases.html): a series of examples ranging from how to use Kokkos with MPI to Fortran interoperability.
+- [Use cases and Examples](https://kokkos.org/kokkos-core-wiki/usecases.html): a serie of examples ranging from how to use Kokkos with MPI to Fortran interoperability.
 
-For questions find us on Slack: https://kokkosteam.slack.com or open a github issue.
+## Obtaining Kokkos
 
-For non-public questions send an email to: *crtrott(at)sandia.gov*
+The latest release of Kokkos can be obtained from the [GitHub releases page](https://github.com/kokkos/kokkos/releases/latest).
+
+The current release is [4.3.01](https://github.com/kokkos/kokkos/releases/tag/4.3.01).
+
+```bash
+curl -OJ -L https://github.com/kokkos/kokkos/archive/refs/tags/4.3.01.tar.gz
+# Or with wget
+wget https://github.com/kokkos/kokkos/archive/refs/tags/4.3.01.tar.gz
+```
+
+To clone the latest development version of Kokkos from GitHub:
+
+```bash
+git clone -b develop  https://github.com/kokkos/kokkos.git
+```
 
-# Contributing to Kokkos
+### Building Kokkos
 
-Please see [this page](https://kokkos.github.io/kokkos-core-wiki/contributing.html) for details on how to contribute.
+To build Kokkos, you will need to have a C++ compiler that supports C++17 or later.
+All requirements including minimum and primary tested compiler versions can be found [here](https://kokkos.org/kokkos-core-wiki/requirements.html).
 
-# Requirements, Building and Installing
+Building and installation instructions are described [here](https://kokkos.org/kokkos-core-wiki/building.html).
+
+You can also install Kokkos using [Spack](https://spack.io/): `spack install kokkos`. [Available configuration options](https://packages.spack.io/package.html?name=kokkos) can be displayed using `spack info kokkos`.
+
+## For the complete documentation: [kokkos.org/kokkos-core-wiki/](https://kokkos.org/kokkos-core-wiki/)
+
+## Support
+
+For questions find us on Slack: https://kokkosteam.slack.com or open a GitHub issue.
+
+For non-public questions send an email to: *crtrott(at)sandia.gov*
 
-All requirements including minimum and primary tested compiler versions can be found [here](https://kokkos.github.io/kokkos-core-wiki/requirements.html).
+## Contributing
 
-Building and installation instructions are described [here](https://kokkos.github.io/kokkos-core-wiki/building.html).
+Please see [this page](https://kokkos.org/kokkos-core-wiki/contributing.html) for details on how to contribute.
 
-# Citing Kokkos
+## Citing Kokkos
 
-Please see the [following page](https://kokkos.github.io/kokkos-core-wiki/citation.html).
+Please see the [following page](https://kokkos.org/kokkos-core-wiki/citation.html).
 
-# License
+## License
 
-[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![License](https://img.shields.io/badge/License-Apache--2.0_WITH_LLVM--exception-blue)](https://spdx.org/licenses/LLVM-exception.html)
 
 Under the terms of Contract DE-NA0003525 with NTESS,
 the U.S. Government retains certain rights in this software.
 
-The full license statement used in all headers is available [here](https://kokkos.github.io/kokkos-core-wiki/license.html) or
-[here](https://github.com/kokkos/kokkos/blob/master/LICENSE).
+The full license statement used in all headers is available [here](https://kokkos.org/kokkos-core-wiki/license.html) or
+[here](https://github.com/kokkos/kokkos/blob/develop/LICENSE).
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000..93cf6e3663
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,12 @@
+# Reporting Security Issues
+
+To report a security issue, please email
+[lebrungrandt@ornl.gov](mailto:lebrungrandt@ornl.gov)
+and [crtrott@sandia.gov](mailto:crtrott@sandia.gov)
+with a description of the issue, the steps you took to create the issue,
+affected versions, and, if known, mitigations for the issue.
+
+Our vulnerability management team will respond within 5 working days of your
+email. If the issue is confirmed as a vulnerability, we will open a
+Security Advisory and acknowledge your contributions as part of it. This project
+follows a 90 day disclosure timeline.
diff --git a/Spack.md b/Spack.md
index 79606c259d..06c763a64e 100644
--- a/Spack.md
+++ b/Spack.md
@@ -159,7 +159,6 @@ If you don't specify a CUDA build variant in a `packages.yaml` and you build you
 > spack install superscience
 ````
 you may end up just getting the default Kokkos (i.e. Serial).
-Some examples are included in the `config/yaml` folder for common platforms.
 Before running `spack install <package>` we recommend running `spack spec <package>` to confirm your dependency tree is correct.
 For example, with Kokkos Kernels:
 ````bash
diff --git a/algorithms/CMakeLists.txt b/algorithms/CMakeLists.txt
index ab557ab66a..368984647e 100644
--- a/algorithms/CMakeLists.txt
+++ b/algorithms/CMakeLists.txt
@@ -2,6 +2,6 @@ IF (NOT Kokkos_INSTALL_TESTING)
   ADD_SUBDIRECTORY(src)
 ENDIF()
 # FIXME_OPENACC: temporarily disabled due to unimplemented features
-IF(NOT ((KOKKOS_ENABLE_OPENMPTARGET OR KOKKOS_ENABLE_OPENACC) AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC))
+IF(NOT ((KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC) OR KOKKOS_ENABLE_OPENACC))
   KOKKOS_ADD_TEST_DIRECTORIES(unit_tests)
 ENDIF()
diff --git a/algorithms/src/CMakeLists.txt b/algorithms/src/CMakeLists.txt
index 1695778947..b490caca62 100644
--- a/algorithms/src/CMakeLists.txt
+++ b/algorithms/src/CMakeLists.txt
@@ -30,5 +30,5 @@ KOKKOS_LIB_INCLUDE_DIRECTORIES(kokkosalgorithms
   ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-
-
+KOKKOS_LINK_TPL(kokkoscontainers PUBLIC ROCTHRUST)
+KOKKOS_LINK_TPL(kokkoscore PUBLIC ONEDPL)
diff --git a/algorithms/src/Kokkos_NestedSort.hpp b/algorithms/src/Kokkos_NestedSort.hpp
index 4c8be792d8..18e0674efe 100644
--- a/algorithms/src/Kokkos_NestedSort.hpp
+++ b/algorithms/src/Kokkos_NestedSort.hpp
@@ -14,175 +14,17 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_NESTEDSORT_HPP_
-#define KOKKOS_NESTEDSORT_HPP_
-
-#include <Kokkos_Core.hpp>
-#include <std_algorithms/impl/Kokkos_HelperPredicates.hpp>
-#include <std_algorithms/Kokkos_Swap.hpp>
-
-namespace Kokkos {
-namespace Experimental {
-namespace Impl {
-
-// true for TeamVectorRange, false for ThreadVectorRange
-template <bool teamLevel>
-struct NestedRange {};
-
-// Specialization for team-level
-template <>
-struct NestedRange<true> {
-  template <typename TeamMember, typename SizeType>
-  KOKKOS_FUNCTION static auto create(const TeamMember& t, SizeType len) {
-    return Kokkos::TeamVectorRange(t, len);
-  }
-  template <typename TeamMember>
-  KOKKOS_FUNCTION static void barrier(const TeamMember& t) {
-    t.team_barrier();
-  }
-};
-
-// Specialization for thread-level
-template <>
-struct NestedRange<false> {
-  template <typename TeamMember, typename SizeType>
-  KOKKOS_FUNCTION static auto create(const TeamMember& t, SizeType len) {
-    return Kokkos::ThreadVectorRange(t, len);
-  }
-  // Barrier is no-op, as vector lanes of a thread are implicitly synchronized
-  // after parallel region
-  template <typename TeamMember>
-  KOKKOS_FUNCTION static void barrier(const TeamMember&) {}
-};
-
-// When just doing sort (not sort_by_key), use nullptr_t for ValueViewType.
-// This only takes the NestedRange instance for template arg deduction.
-template <class TeamMember, class KeyViewType, class ValueViewType,
-          class Comparator, bool useTeamLevel>
-KOKKOS_INLINE_FUNCTION void sort_nested_impl(
-    const TeamMember& t, const KeyViewType& keyView,
-    [[maybe_unused]] const ValueViewType& valueView, const Comparator& comp,
-    const NestedRange<useTeamLevel>) {
-  using SizeType  = typename KeyViewType::size_type;
-  using KeyType   = typename KeyViewType::non_const_value_type;
-  using Range     = NestedRange<useTeamLevel>;
-  SizeType n      = keyView.extent(0);
-  SizeType npot   = 1;
-  SizeType levels = 0;
-  // FIXME: ceiling power-of-two is a common thing to need - make it a utility
-  while (npot < n) {
-    levels++;
-    npot <<= 1;
-  }
-  for (SizeType i = 0; i < levels; i++) {
-    for (SizeType j = 0; j <= i; j++) {
-      // n/2 pairs of items are compared in parallel
-      Kokkos::parallel_for(Range::create(t, npot / 2), [=](const SizeType k) {
-        // How big are the brown/pink boxes?
-        // (Terminology comes from Wikipedia diagram)
-        // https://commons.wikimedia.org/wiki/File:BitonicSort.svg#/media/File:BitonicSort.svg
-        SizeType boxSize = SizeType(2) << (i - j);
-        // Which box contains this thread?
-        SizeType boxID     = k >> (i - j);          // k * 2 / boxSize;
-        SizeType boxStart  = boxID << (1 + i - j);  // boxID * boxSize
-        SizeType boxOffset = k - (boxStart >> 1);   // k - boxID * boxSize / 2;
-        SizeType elem1     = boxStart + boxOffset;
-        // In first phase (j == 0, brown box): within a box, compare with the
-        // opposite value in the box.
-        // In later phases (j > 0, pink box): within a box, compare with fixed
-        // distance (boxSize / 2) apart.
-        SizeType elem2 = (j == 0) ? (boxStart + boxSize - 1 - boxOffset)
-                                  : (elem1 + boxSize / 2);
-        if (elem2 < n) {
-          KeyType key1 = keyView(elem1);
-          KeyType key2 = keyView(elem2);
-          if (comp(key2, key1)) {
-            keyView(elem1) = key2;
-            keyView(elem2) = key1;
-            if constexpr (!std::is_same_v<ValueViewType, std::nullptr_t>) {
-              Kokkos::Experimental::swap(valueView(elem1), valueView(elem2));
-            }
-          }
-        }
-      });
-      Range::barrier(t);
-    }
-  }
-}
-
-}  // namespace Impl
-
-template <class TeamMember, class ViewType>
-KOKKOS_INLINE_FUNCTION void sort_team(const TeamMember& t,
-                                      const ViewType& view) {
-  Impl::sort_nested_impl(t, view, nullptr,
-                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
-                             typename ViewType::non_const_value_type>(),
-                         Impl::NestedRange<true>());
-}
-
-template <class TeamMember, class ViewType, class Comparator>
-KOKKOS_INLINE_FUNCTION void sort_team(const TeamMember& t, const ViewType& view,
-                                      const Comparator& comp) {
-  Impl::sort_nested_impl(t, view, nullptr, comp, Impl::NestedRange<true>());
-}
-
-template <class TeamMember, class KeyViewType, class ValueViewType>
-KOKKOS_INLINE_FUNCTION void sort_by_key_team(const TeamMember& t,
-                                             const KeyViewType& keyView,
-                                             const ValueViewType& valueView) {
-  Impl::sort_nested_impl(t, keyView, valueView,
-                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
-                             typename KeyViewType::non_const_value_type>(),
-                         Impl::NestedRange<true>());
-}
-
-template <class TeamMember, class KeyViewType, class ValueViewType,
-          class Comparator>
-KOKKOS_INLINE_FUNCTION void sort_by_key_team(const TeamMember& t,
-                                             const KeyViewType& keyView,
-                                             const ValueViewType& valueView,
-                                             const Comparator& comp) {
-  Impl::sort_nested_impl(t, keyView, valueView, comp,
-                         Impl::NestedRange<true>());
-}
-
-template <class TeamMember, class ViewType>
-KOKKOS_INLINE_FUNCTION void sort_thread(const TeamMember& t,
-                                        const ViewType& view) {
-  Impl::sort_nested_impl(t, view, nullptr,
-                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
-                             typename ViewType::non_const_value_type>(),
-                         Impl::NestedRange<false>());
-}
-
-template <class TeamMember, class ViewType, class Comparator>
-KOKKOS_INLINE_FUNCTION void sort_thread(const TeamMember& t,
-                                        const ViewType& view,
-                                        const Comparator& comp) {
-  Impl::sort_nested_impl(t, view, nullptr, comp, Impl::NestedRange<false>());
-}
-
-template <class TeamMember, class KeyViewType, class ValueViewType>
-KOKKOS_INLINE_FUNCTION void sort_by_key_thread(const TeamMember& t,
-                                               const KeyViewType& keyView,
-                                               const ValueViewType& valueView) {
-  Impl::sort_nested_impl(t, keyView, valueView,
-                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
-                             typename KeyViewType::non_const_value_type>(),
-                         Impl::NestedRange<false>());
-}
+#ifndef KOKKOS_NESTED_SORT_HPP_
+#define KOKKOS_NESTED_SORT_HPP_
+#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
+#define KOKKOS_IMPL_PUBLIC_INCLUDE
+#define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_NESTED_SORT
+#endif
 
-template <class TeamMember, class KeyViewType, class ValueViewType,
-          class Comparator>
-KOKKOS_INLINE_FUNCTION void sort_by_key_thread(const TeamMember& t,
-                                               const KeyViewType& keyView,
-                                               const ValueViewType& valueView,
-                                               const Comparator& comp) {
-  Impl::sort_nested_impl(t, keyView, valueView, comp,
-                         Impl::NestedRange<false>());
-}
+#include "sorting/Kokkos_NestedSortPublicAPI.hpp"
 
-}  // namespace Experimental
-}  // namespace Kokkos
+#ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_NESTED_SORT
+#undef KOKKOS_IMPL_PUBLIC_INCLUDE
+#undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_NESTED_SORT
+#endif
 #endif
diff --git a/algorithms/src/Kokkos_Random.hpp b/algorithms/src/Kokkos_Random.hpp
index abb028d28e..7df12b8518 100644
--- a/algorithms/src/Kokkos_Random.hpp
+++ b/algorithms/src/Kokkos_Random.hpp
@@ -849,18 +849,17 @@ class Random_XorShift64 {
     return drand(end - start) + start;
   }
 
-  // Marsaglia polar method for drawing a standard normal distributed random
+  // Box-muller method for drawing a standard normal distributed random
   // number
   KOKKOS_INLINE_FUNCTION
   double normal() {
-    double S = 2.0;
-    double U;
-    while (S >= 1.0) {
-      U              = 2.0 * drand() - 1.0;
-      const double V = 2.0 * drand() - 1.0;
-      S              = U * U + V * V;
-    }
-    return U * std::sqrt(-2.0 * std::log(S) / S);
+    constexpr auto two_pi = 2 * Kokkos::numbers::pi_v<double>;
+
+    const double u     = drand();
+    const double v     = drand();
+    const double r     = Kokkos::sqrt(-2.0 * Kokkos::log(u));
+    const double theta = v * two_pi;
+    return r * Kokkos::cos(theta);
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -956,6 +955,8 @@ class Random_XorShift64_Pool {
   KOKKOS_INLINE_FUNCTION
   void free_state(const Random_XorShift64<DeviceType>& state) const {
     state_(state.state_idx_, 0) = state.state_;
+    // Release the lock only after the state has been updated in memory
+    Kokkos::memory_fence();
     locks_(state.state_idx_, 0) = 0;
   }
 };
@@ -1092,18 +1093,17 @@ class Random_XorShift1024 {
     return drand(end - start) + start;
   }
 
-  // Marsaglia polar method for drawing a standard normal distributed random
+  // Box-muller method for drawing a standard normal distributed random
   // number
   KOKKOS_INLINE_FUNCTION
   double normal() {
-    double S = 2.0;
-    double U;
-    while (S >= 1.0) {
-      U              = 2.0 * drand() - 1.0;
-      const double V = 2.0 * drand() - 1.0;
-      S              = U * U + V * V;
-    }
-    return U * std::sqrt(-2.0 * std::log(S) / S);
+    constexpr auto two_pi = 2 * Kokkos::numbers::pi_v<double>;
+
+    const double u     = drand();
+    const double v     = drand();
+    const double r     = Kokkos::sqrt(-2.0 * Kokkos::log(u));
+    const double theta = v * two_pi;
+    return r * Kokkos::cos(theta);
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -1208,7 +1208,9 @@ class Random_XorShift1024_Pool {
   KOKKOS_INLINE_FUNCTION
   void free_state(const Random_XorShift1024<DeviceType>& state) const {
     for (int i = 0; i < 16; i++) state_(state.state_idx_, i) = state.state_[i];
-    p_(state.state_idx_, 0)     = state.p_;
+    p_(state.state_idx_, 0) = state.p_;
+    // Release the lock only after the state has been updated in memory
+    Kokkos::memory_fence();
     locks_(state.state_idx_, 0) = 0;
   }
 };
@@ -1541,13 +1543,23 @@ template <class ViewType, class RandomPool, class IndexType = int64_t>
 void fill_random(ViewType a, RandomPool g,
                  typename ViewType::const_value_type begin,
                  typename ViewType::const_value_type end) {
-  fill_random(typename ViewType::execution_space{}, a, g, begin, end);
+  Kokkos::fence(
+      "fill_random: fence before since no execution space instance provided");
+  typename ViewType::execution_space exec;
+  fill_random(exec, a, g, begin, end);
+  exec.fence(
+      "fill_random: fence after since no execution space instance provided");
 }
 
 template <class ViewType, class RandomPool, class IndexType = int64_t>
 void fill_random(ViewType a, RandomPool g,
                  typename ViewType::const_value_type range) {
-  fill_random(typename ViewType::execution_space{}, a, g, 0, range);
+  Kokkos::fence(
+      "fill_random: fence before since no execution space instance provided");
+  typename ViewType::execution_space exec;
+  fill_random(exec, a, g, 0, range);
+  exec.fence(
+      "fill_random: fence after since no execution space instance provided");
 }
 
 }  // namespace Kokkos
diff --git a/algorithms/src/Kokkos_Sort.hpp b/algorithms/src/Kokkos_Sort.hpp
index 10f9ad6462..136b4ec82d 100644
--- a/algorithms/src/Kokkos_Sort.hpp
+++ b/algorithms/src/Kokkos_Sort.hpp
@@ -21,762 +21,10 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_SORT
 #endif
 
-#include <Kokkos_Core.hpp>
-#include <Kokkos_NestedSort.hpp>
-#include <std_algorithms/Kokkos_BeginEnd.hpp>
-#include <algorithm>
-
-#if defined(KOKKOS_ENABLE_CUDA)
-
-// Workaround for `Instruction 'shfl' without '.sync' is not supported on
-// .target sm_70 and higher from PTX ISA version 6.4`.
-// Also see https://github.com/NVIDIA/cub/pull/170.
-#if !defined(CUB_USE_COOPERATIVE_GROUPS)
-#define CUB_USE_COOPERATIVE_GROUPS
-#endif
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-
-#if defined(KOKKOS_COMPILER_CLANG)
-// Some versions of Clang fail to compile Thrust, failing with errors like
-// this:
-//    <snip>/thrust/system/cuda/detail/core/agent_launcher.h:557:11:
-//    error: use of undeclared identifier 'va_printf'
-// The exact combination of versions for Clang and Thrust (or CUDA) for this
-// failure was not investigated, however even very recent version combination
-// (Clang 10.0.0 and Cuda 10.0) demonstrated failure.
-//
-// Defining _CubLog here locally allows us to avoid that code path, however
-// disabling some debugging diagnostics
-#pragma push_macro("_CubLog")
-#ifdef _CubLog
-#undef _CubLog
-#endif
-#define _CubLog
-#include <thrust/device_ptr.h>
-#include <thrust/sort.h>
-#pragma pop_macro("_CubLog")
-#else
-#include <thrust/device_ptr.h>
-#include <thrust/sort.h>
-#endif
-
-#pragma GCC diagnostic pop
-
-#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>
-struct CopyOp;
-
-template <class DstViewType, class SrcViewType>
-struct CopyOp<DstViewType, SrcViewType, 1> {
-  KOKKOS_INLINE_FUNCTION
-  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
-                   size_t i_src) {
-    dst(i_dst) = src(i_src);
-  }
-};
-
-template <class DstViewType, class SrcViewType>
-struct CopyOp<DstViewType, SrcViewType, 2> {
-  KOKKOS_INLINE_FUNCTION
-  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
-                   size_t i_src) {
-    for (int j = 0; j < (int)dst.extent(1); j++) dst(i_dst, j) = src(i_src, j);
-  }
-};
-
-template <class DstViewType, class SrcViewType>
-struct CopyOp<DstViewType, SrcViewType, 3> {
-  KOKKOS_INLINE_FUNCTION
-  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
-                   size_t i_src) {
-    for (int j = 0; j < dst.extent(1); j++)
-      for (int k = 0; k < dst.extent(2); k++)
-        dst(i_dst, j, k) = src(i_src, j, k);
-  }
-};
-}  // namespace Impl
-
-//----------------------------------------------------------------------------
-
-template <class KeyViewType, class BinSortOp,
-          class Space    = typename KeyViewType::device_type,
-          class SizeType = typename KeyViewType::memory_space::size_type>
-class BinSort {
- public:
-  template <class DstViewType, class SrcViewType>
-  struct copy_functor {
-    using src_view_type = typename SrcViewType::const_type;
-
-    using copy_op = Impl::CopyOp<DstViewType, src_view_type>;
-
-    DstViewType dst_values;
-    src_view_type src_values;
-    int dst_offset;
-
-    copy_functor(DstViewType const& dst_values_, int const& dst_offset_,
-                 SrcViewType const& src_values_)
-        : dst_values(dst_values_),
-          src_values(src_values_),
-          dst_offset(dst_offset_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const int& i) const {
-      copy_op::copy(dst_values, i + dst_offset, src_values, i);
-    }
-  };
-
-  template <class DstViewType, class PermuteViewType, class SrcViewType>
-  struct copy_permute_functor {
-    // If a Kokkos::View then can generate constant random access
-    // otherwise can only use the constant type.
-
-    using src_view_type = std::conditional_t<
-        Kokkos::is_view<SrcViewType>::value,
-        Kokkos::View<typename SrcViewType::const_data_type,
-                     typename SrcViewType::array_layout,
-                     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;
-
-    using copy_op = Impl::CopyOp<DstViewType, src_view_type>;
-
-    DstViewType dst_values;
-    perm_view_type sort_order;
-    src_view_type src_values;
-    int src_offset;
-
-    copy_permute_functor(DstViewType const& dst_values_,
-                         PermuteViewType const& sort_order_,
-                         SrcViewType const& src_values_, int const& src_offset_)
-        : dst_values(dst_values_),
-          sort_order(sort_order_),
-          src_values(src_values_),
-          src_offset(src_offset_) {}
-
-    KOKKOS_INLINE_FUNCTION
-    void operator()(const int& i) const {
-      copy_op::copy(dst_values, i, src_values, src_offset + sort_order(i));
-    }
-  };
-
-  // Naming this alias "execution_space" would be problematic since it would be
-  // considered as execution space for the various functors which might use
-  // another execution space through sort() or create_permute_vector().
-  using exec_space  = typename Space::execution_space;
-  using bin_op_type = BinSortOp;
-
-  struct bin_count_tag {};
-  struct bin_offset_tag {};
-  struct bin_binning_tag {};
-  struct bin_sort_bins_tag {};
-
- public:
-  using size_type  = SizeType;
-  using value_type = size_type;
-
-  using offset_type    = Kokkos::View<size_type*, Space>;
-  using bin_count_type = Kokkos::View<const int*, Space>;
-
-  using const_key_view_type = typename KeyViewType::const_type;
-
-  // If a Kokkos::View then can generate constant random access
-  // otherwise can only use the constant type.
-
-  using const_rnd_key_view_type = std::conditional_t<
-      Kokkos::is_view<KeyViewType>::value,
-      Kokkos::View<typename KeyViewType::const_data_type,
-                   typename KeyViewType::array_layout,
-                   typename KeyViewType::device_type,
-                   Kokkos::MemoryTraits<Kokkos::RandomAccess> >,
-      const_key_view_type>;
-
-  using non_const_key_scalar = typename KeyViewType::non_const_value_type;
-  using const_key_scalar     = typename KeyViewType::const_value_type;
-
-  using bin_count_atomic_type =
-      Kokkos::View<int*, Space, Kokkos::MemoryTraits<Kokkos::Atomic> >;
-
- private:
-  const_key_view_type keys;
-  const_rnd_key_view_type keys_rnd;
-
- public:
-  BinSortOp bin_op;
-  offset_type bin_offsets;
-  bin_count_atomic_type bin_count_atomic;
-  bin_count_type bin_count_const;
-  offset_type sort_order;
-
-  int range_begin;
-  int range_end;
-  bool sort_within_bins;
-
- public:
-#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
-  // sort within bins (default false)
-  template <typename ExecutionSpace>
-  BinSort(const ExecutionSpace& exec, const_key_view_type keys_,
-          int range_begin_, int range_end_, BinSortOp bin_op_,
-          bool sort_within_bins_ = false)
-      : keys(keys_),
-        keys_rnd(keys_),
-        bin_op(bin_op_),
-        bin_offsets(),
-        bin_count_atomic(),
-        bin_count_const(),
-        sort_order(),
-        range_begin(range_begin_),
-        range_end(range_end_),
-        sort_within_bins(sort_within_bins_) {
-    static_assert(
-        Kokkos::SpaceAccessibility<ExecutionSpace,
-                                   typename Space::memory_space>::accessible,
-        "The provided execution space must be able to access the memory space "
-        "BinSort was initialized with!");
-    if (bin_op.max_bins() <= 0)
-      Kokkos::abort(
-          "The number of bins in the BinSortOp object must be greater than 0!");
-    bin_count_atomic = Kokkos::View<int*, Space>(
-        "Kokkos::SortImpl::BinSortFunctor::bin_count", bin_op.max_bins());
-    bin_count_const = bin_count_atomic;
-    bin_offsets =
-        offset_type(view_alloc(exec, WithoutInitializing,
-                               "Kokkos::SortImpl::BinSortFunctor::bin_offsets"),
-                    bin_op.max_bins());
-    sort_order =
-        offset_type(view_alloc(exec, WithoutInitializing,
-                               "Kokkos::SortImpl::BinSortFunctor::sort_order"),
-                    range_end - range_begin);
-  }
-
-  BinSort(const_key_view_type keys_, int range_begin_, int range_end_,
-          BinSortOp bin_op_, bool sort_within_bins_ = false)
-      : BinSort(exec_space{}, keys_, range_begin_, range_end_, bin_op_,
-                sort_within_bins_) {}
-
-  template <typename ExecutionSpace>
-  BinSort(const ExecutionSpace& exec, const_key_view_type keys_,
-          BinSortOp bin_op_, bool sort_within_bins_ = false)
-      : BinSort(exec, keys_, 0, keys_.extent(0), bin_op_, sort_within_bins_) {}
-
-  BinSort(const_key_view_type keys_, BinSortOp bin_op_,
-          bool sort_within_bins_ = false)
-      : BinSort(exec_space{}, keys_, bin_op_, sort_within_bins_) {}
-
-  //----------------------------------------
-  // Create the permutation vector, the bin_offset array and the bin_count
-  // array. Can be called again if keys changed
-  template <class ExecutionSpace>
-  void create_permute_vector(const ExecutionSpace& exec) {
-    static_assert(
-        Kokkos::SpaceAccessibility<ExecutionSpace,
-                                   typename Space::memory_space>::accessible,
-        "The provided execution space must be able to access the memory space "
-        "BinSort was initialized with!");
-
-    const size_t len = range_end - range_begin;
-    Kokkos::parallel_for(
-        "Kokkos::Sort::BinCount",
-        Kokkos::RangePolicy<ExecutionSpace, bin_count_tag>(exec, 0, len),
-        *this);
-    Kokkos::parallel_scan("Kokkos::Sort::BinOffset",
-                          Kokkos::RangePolicy<ExecutionSpace, bin_offset_tag>(
-                              exec, 0, bin_op.max_bins()),
-                          *this);
-
-    Kokkos::deep_copy(exec, bin_count_atomic, 0);
-    Kokkos::parallel_for(
-        "Kokkos::Sort::BinBinning",
-        Kokkos::RangePolicy<ExecutionSpace, bin_binning_tag>(exec, 0, len),
-        *this);
-
-    if (sort_within_bins)
-      Kokkos::parallel_for(
-          "Kokkos::Sort::BinSort",
-          Kokkos::RangePolicy<ExecutionSpace, bin_sort_bins_tag>(
-              exec, 0, bin_op.max_bins()),
-          *this);
-  }
-
-  // Create the permutation vector, the bin_offset array and the bin_count
-  // array. Can be called again if keys changed
-  void create_permute_vector() {
-    Kokkos::fence("Kokkos::Binsort::create_permute_vector: before");
-    exec_space e{};
-    create_permute_vector(e);
-    e.fence("Kokkos::Binsort::create_permute_vector: after");
-  }
-
-  // Sort a subset of a view with respect to the first dimension using the
-  // permutation array
-  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,
-        "The provided execution space must be able to access the memory space "
-        "BinSort was initialized with!");
-    static_assert(
-        Kokkos::SpaceAccessibility<
-            ExecutionSpace, typename ValuesViewType::memory_space>::accessible,
-        "The provided execution space must be able to access the memory space "
-        "of the View argument!");
-
-    const size_t len        = range_end - range_begin;
-    const size_t values_len = values_range_end - values_range_begin;
-    if (len != values_len) {
-      Kokkos::abort(
-          "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"),
-        values.rank_dynamic > 0 ? len : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 1 ? values.extent(1)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 2 ? values.extent(2)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 3 ? values.extent(3)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 4 ? values.extent(4)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 5 ? values.extent(5)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 6 ? values.extent(6)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
-        values.rank_dynamic > 7 ? values.extent(7)
-                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG);
-
-    {
-      copy_permute_functor<scratch_view_type /* DstViewType */
-                           ,
-                           offset_type /* PermuteViewType */
-                           ,
-                           ValuesViewType /* SrcViewType */
-                           >
-          functor(sorted_values, sort_order, values,
-                  values_range_begin - range_begin);
-
-      parallel_for("Kokkos::Sort::CopyPermute",
-                   Kokkos::RangePolicy<ExecutionSpace>(exec, 0, len), functor);
-    }
-
-    {
-      copy_functor<ValuesViewType, scratch_view_type> functor(
-          values, range_begin, sorted_values);
-
-      parallel_for("Kokkos::Sort::Copy",
-                   Kokkos::RangePolicy<ExecutionSpace>(exec, 0, len), functor);
-    }
-  }
-
-  // Sort a subset of a view with respect to the first dimension using the
-  // permutation array
-  template <class ValuesViewType>
-  void sort(ValuesViewType const& values, int values_range_begin,
-            int values_range_end) const {
-    Kokkos::fence("Kokkos::Binsort::sort: before");
-    exec_space exec;
-    sort(exec, values, values_range_begin, values_range_end);
-    exec.fence("Kokkos::BinSort:sort: after");
-  }
-
-  template <class ExecutionSpace, class ValuesViewType>
-  void sort(ExecutionSpace const& exec, ValuesViewType const& values) const {
-    this->sort(exec, values, 0, /*values.extent(0)*/ range_end - range_begin);
-  }
-
-  template <class ValuesViewType>
-  void sort(ValuesViewType const& values) const {
-    this->sort(values, 0, /*values.extent(0)*/ range_end - range_begin);
-  }
-
-  // Get the permutation vector
-  KOKKOS_INLINE_FUNCTION
-  offset_type get_permute_vector() const { return sort_order; }
-
-  // Get the start offsets for each bin
-  KOKKOS_INLINE_FUNCTION
-  offset_type get_bin_offsets() const { return bin_offsets; }
-
-  // Get the count for each bin
-  KOKKOS_INLINE_FUNCTION
-  bin_count_type get_bin_count() const { return bin_count_const; }
-
- public:
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const bin_count_tag& /*tag*/, const int i) const {
-    const int j = range_begin + i;
-    bin_count_atomic(bin_op.bin(keys, j))++;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const bin_offset_tag& /*tag*/, const int i,
-                  value_type& offset, const bool& final) const {
-    if (final) {
-      bin_offsets(i) = offset;
-    }
-    offset += bin_count_const(i);
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const bin_binning_tag& /*tag*/, const int i) const {
-    const int j     = range_begin + i;
-    const int bin   = bin_op.bin(keys, j);
-    const int count = bin_count_atomic(bin)++;
-
-    sort_order(bin_offsets(bin) + count) = j;
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const bin_sort_bins_tag& /*tag*/, const int i) const {
-    auto bin_size = bin_count_const(i);
-    if (bin_size <= 1) return;
-    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;
-      }
-    }
-  }
-};
-
-//----------------------------------------------------------------------------
-
-template <class KeyViewType>
-struct BinOp1D {
-  int max_bins_ = {};
-  double mul_   = {};
-  double min_   = {};
-
-#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,
-          typename KeyViewType::const_value_type max)
-      : max_bins_(max_bins__ + 1),
-        // Cast to double to avoid possible overflow when using integer
-        mul_(static_cast<double>(max_bins__) /
-             (static_cast<double>(max) - static_cast<double>(min))),
-        min_(static_cast<double>(min)) {
-    // For integral types the number of bins may be larger than the range
-    // in which case we can exactly have one unique value per bin
-    // and then don't need to sort bins.
-    if (std::is_integral<typename KeyViewType::const_value_type>::value &&
-        (static_cast<double>(max) - static_cast<double>(min)) <=
-            static_cast<double>(max_bins__)) {
-      mul_ = 1.;
-    }
-  }
-
-  // Determine bin index from key value
-  template <class ViewType>
-  KOKKOS_INLINE_FUNCTION int bin(ViewType& keys, const int& i) const {
-    return static_cast<int>(mul_ * (static_cast<double>(keys(i)) - min_));
-  }
-
-  // Return maximum bin index + 1
-  KOKKOS_INLINE_FUNCTION
-  int max_bins() const { return max_bins_; }
-
-  // Compare to keys within a bin if true new_val will be put before old_val
-  template <class ViewType, typename iType1, typename iType2>
-  KOKKOS_INLINE_FUNCTION bool operator()(ViewType& keys, iType1& i1,
-                                         iType2& i2) const {
-    return keys(i1) < keys(i2);
-  }
-};
-
-template <class KeyViewType>
-struct BinOp3D {
-  int max_bins_[3] = {};
-  double mul_[3]   = {};
-  double min_[3]   = {};
-
-#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[]) {
-    max_bins_[0] = max_bins__[0];
-    max_bins_[1] = max_bins__[1];
-    max_bins_[2] = max_bins__[2];
-    mul_[0]      = static_cast<double>(max_bins__[0]) /
-              (static_cast<double>(max[0]) - static_cast<double>(min[0]));
-    mul_[1] = static_cast<double>(max_bins__[1]) /
-              (static_cast<double>(max[1]) - static_cast<double>(min[1]));
-    mul_[2] = static_cast<double>(max_bins__[2]) /
-              (static_cast<double>(max[2]) - static_cast<double>(min[2]));
-    min_[0] = static_cast<double>(min[0]);
-    min_[1] = static_cast<double>(min[1]);
-    min_[2] = static_cast<double>(min[2]);
-  }
-
-  template <class ViewType>
-  KOKKOS_INLINE_FUNCTION int bin(ViewType& keys, const int& i) const {
-    return int((((int(mul_[0] * (keys(i, 0) - min_[0])) * max_bins_[1]) +
-                 int(mul_[1] * (keys(i, 1) - min_[1]))) *
-                max_bins_[2]) +
-               int(mul_[2] * (keys(i, 2) - min_[2])));
-  }
-
-  KOKKOS_INLINE_FUNCTION
-  int max_bins() const { return max_bins_[0] * max_bins_[1] * max_bins_[2]; }
-
-  template <class ViewType, typename iType1, typename iType2>
-  KOKKOS_INLINE_FUNCTION bool operator()(ViewType& keys, iType1& i1,
-                                         iType2& i2) const {
-    if (keys(i1, 0) > keys(i2, 0))
-      return true;
-    else if (keys(i1, 0) == keys(i2, 0)) {
-      if (keys(i1, 1) > keys(i2, 1))
-        return true;
-      else if (keys(i1, 1) == keys(i2, 1)) {
-        if (keys(i1, 2) > keys(i2, 2)) return true;
-      }
-    }
-    return false;
-  }
-};
-
-namespace Impl {
-
-template <class ViewType>
-struct min_max_functor {
-  using minmax_scalar =
-      Kokkos::MinMaxScalar<typename ViewType::non_const_value_type>;
-
-  ViewType view;
-  min_max_functor(const ViewType& view_) : view(view_) {}
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const size_t& i, minmax_scalar& minmax) const {
-    if (view(i) < minmax.min_val) minmax.min_val = view(i);
-    if (view(i) > minmax.max_val) minmax.max_val = view(i);
-  }
-};
-
-}  // namespace Impl
-
-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& exec,
-     const Kokkos::View<DataType, Properties...>& view) {
-  if (view.extent(0) == 0) {
-    return;
-  }
-
-  using ViewType = Kokkos::View<DataType, Properties...>;
-  using CompType = BinOp1D<ViewType>;
-
-  Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> result;
-  Kokkos::MinMax<typename ViewType::non_const_value_type> reducer(result);
-  parallel_reduce("Kokkos::Sort::FindExtent",
-                  Kokkos::RangePolicy<typename ViewType::execution_space>(
-                      exec, 0, view.extent(0)),
-                  Impl::min_max_functor<ViewType>(view), reducer);
-  if (result.min_val == result.max_val) return;
-  // For integral types the number of bins may be larger than the range
-  // in which case we can exactly have one unique value per bin
-  // and then don't need to sort bins.
-  bool sort_in_bins = true;
-  // TODO: figure out better max_bins then this ...
-  int64_t max_bins = view.extent(0) / 2;
-  if (std::is_integral<typename ViewType::non_const_value_type>::value) {
-    // Cast to double to avoid possible overflow when using integer
-    auto const max_val = static_cast<double>(result.max_val);
-    auto const min_val = static_cast<double>(result.min_val);
-    // using 10M as the cutoff for special behavior (roughly 40MB for the count
-    // array)
-    if ((max_val - min_val) < 10000000) {
-      max_bins     = max_val - min_val + 1;
-      sort_in_bins = false;
-    }
-  }
-  if (std::is_floating_point<typename ViewType::non_const_value_type>::value) {
-    KOKKOS_ASSERT(std::isfinite(static_cast<double>(result.max_val) -
-                                static_cast<double>(result.min_val)));
-  }
-
-  BinSort<ViewType, CompType> bin_sort(
-      view, CompType(max_bins, result.min_val, result.max_val), sort_in_bins);
-  bin_sort.create_permute_vector(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);
-}
-
-#if defined(KOKKOS_ENABLE_CUDA)
-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);
-  thrust::sort(exec, first, last);
-}
-#endif
-
-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");
-}
-
-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>;
-
-  Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> result;
-  Kokkos::MinMax<typename ViewType::non_const_value_type> reducer(result);
-
-  parallel_reduce("Kokkos::Sort::FindExtent", range_policy(exec, begin, end),
-                  Impl::min_max_functor<ViewType>(view), reducer);
-
-  if (result.min_val == result.max_val) return;
-
-  BinSort<ViewType, CompType> bin_sort(
-      exec, view, begin, end,
-      CompType((end - begin) / 2, result.min_val, result.max_val), true);
-
-  bin_sort.create_permute_vector(exec);
-  bin_sort.sort(exec, view, begin, end);
-}
-
-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");
-}
-
-}  // namespace Kokkos
+#include "sorting/Kokkos_BinSortPublicAPI.hpp"
+#include "sorting/Kokkos_SortPublicAPI.hpp"
+#include "sorting/Kokkos_SortByKeyPublicAPI.hpp"
+#include "sorting/Kokkos_NestedSortPublicAPI.hpp"
 
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_SORT
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
diff --git a/algorithms/src/Kokkos_StdAlgorithms.hpp b/algorithms/src/Kokkos_StdAlgorithms.hpp
index 436ae0d10b..b532a774e1 100644
--- a/algorithms/src/Kokkos_StdAlgorithms.hpp
+++ b/algorithms/src/Kokkos_StdAlgorithms.hpp
@@ -35,7 +35,6 @@
 // following the std classification.
 
 // modifying ops
-#include "std_algorithms/Kokkos_Swap.hpp"
 #include "std_algorithms/Kokkos_IterSwap.hpp"
 
 // non-modifying sequence
diff --git a/algorithms/src/sorting/Kokkos_BinOpsPublicAPI.hpp b/algorithms/src/sorting/Kokkos_BinOpsPublicAPI.hpp
new file mode 100644
index 0000000000..73e751f572
--- /dev/null
+++ b/algorithms/src/sorting/Kokkos_BinOpsPublicAPI.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_BIN_OPS_PUBLIC_API_HPP_
+#define KOKKOS_BIN_OPS_PUBLIC_API_HPP_
+
+#include <Kokkos_Macros.hpp>
+#include <type_traits>
+
+namespace Kokkos {
+
+template <class KeyViewType>
+struct BinOp1D {
+  int max_bins_ = {};
+  double mul_   = {};
+  double min_   = {};
+
+#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,
+          typename KeyViewType::const_value_type max)
+      : max_bins_(max_bins__ + 1),
+        // Cast to double to avoid possible overflow when using integer
+        mul_(static_cast<double>(max_bins__) /
+             (static_cast<double>(max) - static_cast<double>(min))),
+        min_(static_cast<double>(min)) {
+    // For integral types the number of bins may be larger than the range
+    // in which case we can exactly have one unique value per bin
+    // and then don't need to sort bins.
+    if (std::is_integral<typename KeyViewType::const_value_type>::value &&
+        (static_cast<double>(max) - static_cast<double>(min)) <=
+            static_cast<double>(max_bins__)) {
+      mul_ = 1.;
+    }
+  }
+
+  // Determine bin index from key value
+  template <class ViewType>
+  KOKKOS_INLINE_FUNCTION int bin(ViewType& keys, const int& i) const {
+    return static_cast<int>(mul_ * (static_cast<double>(keys(i)) - min_));
+  }
+
+  // Return maximum bin index + 1
+  KOKKOS_INLINE_FUNCTION
+  int max_bins() const { return max_bins_; }
+
+  // Compare to keys within a bin if true new_val will be put before old_val
+  template <class ViewType, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION bool operator()(ViewType& keys, iType1& i1,
+                                         iType2& i2) const {
+    return keys(i1) < keys(i2);
+  }
+};
+
+template <class KeyViewType>
+struct BinOp3D {
+  int max_bins_[3] = {};
+  double mul_[3]   = {};
+  double min_[3]   = {};
+
+#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[]) {
+    max_bins_[0] = max_bins__[0];
+    max_bins_[1] = max_bins__[1];
+    max_bins_[2] = max_bins__[2];
+    mul_[0]      = static_cast<double>(max_bins__[0]) /
+              (static_cast<double>(max[0]) - static_cast<double>(min[0]));
+    mul_[1] = static_cast<double>(max_bins__[1]) /
+              (static_cast<double>(max[1]) - static_cast<double>(min[1]));
+    mul_[2] = static_cast<double>(max_bins__[2]) /
+              (static_cast<double>(max[2]) - static_cast<double>(min[2]));
+    min_[0] = static_cast<double>(min[0]);
+    min_[1] = static_cast<double>(min[1]);
+    min_[2] = static_cast<double>(min[2]);
+  }
+
+  template <class ViewType>
+  KOKKOS_INLINE_FUNCTION int bin(ViewType& keys, const int& i) const {
+    return int((((int(mul_[0] * (keys(i, 0) - min_[0])) * max_bins_[1]) +
+                 int(mul_[1] * (keys(i, 1) - min_[1]))) *
+                max_bins_[2]) +
+               int(mul_[2] * (keys(i, 2) - min_[2])));
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  int max_bins() const { return max_bins_[0] * max_bins_[1] * max_bins_[2]; }
+
+  template <class ViewType, typename iType1, typename iType2>
+  KOKKOS_INLINE_FUNCTION bool operator()(ViewType& keys, iType1& i1,
+                                         iType2& i2) const {
+    if (keys(i1, 0) > keys(i2, 0))
+      return true;
+    else if (keys(i1, 0) == keys(i2, 0)) {
+      if (keys(i1, 1) > keys(i2, 1))
+        return true;
+      else if (keys(i1, 1) == keys(i2, 1)) {
+        if (keys(i1, 2) > keys(i2, 2)) return true;
+      }
+    }
+    return false;
+  }
+};
+
+}  // namespace Kokkos
+#endif
diff --git a/algorithms/src/sorting/Kokkos_BinSortPublicAPI.hpp b/algorithms/src/sorting/Kokkos_BinSortPublicAPI.hpp
new file mode 100644
index 0000000000..c399279fe4
--- /dev/null
+++ b/algorithms/src/sorting/Kokkos_BinSortPublicAPI.hpp
@@ -0,0 +1,410 @@
+//@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_BIN_SORT_PUBLIC_API_HPP_
+#define KOKKOS_BIN_SORT_PUBLIC_API_HPP_
+
+#include "Kokkos_BinOpsPublicAPI.hpp"
+#include "impl/Kokkos_CopyOpsForBinSortImpl.hpp"
+#include <Kokkos_Core.hpp>
+#include <algorithm>
+
+namespace Kokkos {
+
+template <class KeyViewType, class BinSortOp,
+          class Space    = typename KeyViewType::device_type,
+          class SizeType = typename KeyViewType::memory_space::size_type>
+class BinSort {
+ public:
+  template <class DstViewType, class SrcViewType>
+  struct copy_functor {
+    using src_view_type = typename SrcViewType::const_type;
+
+    using copy_op = Impl::CopyOp<DstViewType, src_view_type>;
+
+    DstViewType dst_values;
+    src_view_type src_values;
+    int dst_offset;
+
+    copy_functor(DstViewType const& dst_values_, int const& dst_offset_,
+                 SrcViewType const& src_values_)
+        : dst_values(dst_values_),
+          src_values(src_values_),
+          dst_offset(dst_offset_) {}
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const int& i) const {
+      copy_op::copy(dst_values, i + dst_offset, src_values, i);
+    }
+  };
+
+  template <class DstViewType, class PermuteViewType, class SrcViewType>
+  struct copy_permute_functor {
+    // If a Kokkos::View then can generate constant random access
+    // otherwise can only use the constant type.
+
+    using src_view_type = std::conditional_t<
+        Kokkos::is_view<SrcViewType>::value,
+        Kokkos::View<typename SrcViewType::const_data_type,
+                     typename SrcViewType::array_layout,
+                     typename SrcViewType::device_type
+#if !defined(KOKKOS_COMPILER_NVHPC) || (KOKKOS_COMPILER_NVHPC >= 230700)
+                     ,
+                     Kokkos::MemoryTraits<Kokkos::RandomAccess>
+#endif
+                     >,
+        typename SrcViewType::const_type>;
+
+    using perm_view_type = typename PermuteViewType::const_type;
+
+    using copy_op = Impl::CopyOp<DstViewType, src_view_type>;
+
+    DstViewType dst_values;
+    perm_view_type sort_order;
+    src_view_type src_values;
+    int src_offset;
+
+    copy_permute_functor(DstViewType const& dst_values_,
+                         PermuteViewType const& sort_order_,
+                         SrcViewType const& src_values_, int const& src_offset_)
+        : dst_values(dst_values_),
+          sort_order(sort_order_),
+          src_values(src_values_),
+          src_offset(src_offset_) {}
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const int& i) const {
+      copy_op::copy(dst_values, i, src_values, src_offset + sort_order(i));
+    }
+  };
+
+  // Naming this alias "execution_space" would be problematic since it would be
+  // considered as execution space for the various functors which might use
+  // another execution space through sort() or create_permute_vector().
+  using exec_space  = typename Space::execution_space;
+  using bin_op_type = BinSortOp;
+
+  struct bin_count_tag {};
+  struct bin_offset_tag {};
+  struct bin_binning_tag {};
+  struct bin_sort_bins_tag {};
+
+ public:
+  using size_type  = SizeType;
+  using value_type = size_type;
+
+  using offset_type    = Kokkos::View<size_type*, Space>;
+  using bin_count_type = Kokkos::View<const int*, Space>;
+
+  using const_key_view_type = typename KeyViewType::const_type;
+
+  // If a Kokkos::View then can generate constant random access
+  // otherwise can only use the constant type.
+
+  using const_rnd_key_view_type = std::conditional_t<
+      Kokkos::is_view<KeyViewType>::value,
+      Kokkos::View<typename KeyViewType::const_data_type,
+                   typename KeyViewType::array_layout,
+                   typename KeyViewType::device_type,
+                   Kokkos::MemoryTraits<Kokkos::RandomAccess> >,
+      const_key_view_type>;
+
+  using non_const_key_scalar = typename KeyViewType::non_const_value_type;
+  using const_key_scalar     = typename KeyViewType::const_value_type;
+
+  using bin_count_atomic_type =
+      Kokkos::View<int*, Space, Kokkos::MemoryTraits<Kokkos::Atomic> >;
+
+ private:
+  const_key_view_type keys;
+  const_rnd_key_view_type keys_rnd;
+
+ public:
+  BinSortOp bin_op;
+  offset_type bin_offsets;
+  bin_count_atomic_type bin_count_atomic;
+  bin_count_type bin_count_const;
+  offset_type sort_order;
+
+  int range_begin;
+  int range_end;
+  bool sort_within_bins;
+
+ public:
+#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
+  // sort within bins (default false)
+  template <typename ExecutionSpace>
+  BinSort(const ExecutionSpace& exec, const_key_view_type keys_,
+          int range_begin_, int range_end_, BinSortOp bin_op_,
+          bool sort_within_bins_ = false)
+      : keys(keys_),
+        keys_rnd(keys_),
+        bin_op(bin_op_),
+        bin_offsets(),
+        bin_count_atomic(),
+        bin_count_const(),
+        sort_order(),
+        range_begin(range_begin_),
+        range_end(range_end_),
+        sort_within_bins(sort_within_bins_) {
+    static_assert(
+        Kokkos::SpaceAccessibility<ExecutionSpace,
+                                   typename Space::memory_space>::accessible,
+        "The provided execution space must be able to access the memory space "
+        "BinSort was initialized with!");
+    if (bin_op.max_bins() <= 0)
+      Kokkos::abort(
+          "The number of bins in the BinSortOp object must be greater than 0!");
+    bin_count_atomic = Kokkos::View<int*, Space>(
+        "Kokkos::SortImpl::BinSortFunctor::bin_count", bin_op.max_bins());
+    bin_count_const = bin_count_atomic;
+    bin_offsets =
+        offset_type(view_alloc(exec, WithoutInitializing,
+                               "Kokkos::SortImpl::BinSortFunctor::bin_offsets"),
+                    bin_op.max_bins());
+    sort_order =
+        offset_type(view_alloc(exec, WithoutInitializing,
+                               "Kokkos::SortImpl::BinSortFunctor::sort_order"),
+                    range_end - range_begin);
+  }
+
+  BinSort(const_key_view_type keys_, int range_begin_, int range_end_,
+          BinSortOp bin_op_, bool sort_within_bins_ = false)
+      : BinSort(exec_space{}, keys_, range_begin_, range_end_, bin_op_,
+                sort_within_bins_) {}
+
+  template <typename ExecutionSpace>
+  BinSort(const ExecutionSpace& exec, const_key_view_type keys_,
+          BinSortOp bin_op_, bool sort_within_bins_ = false)
+      : BinSort(exec, keys_, 0, keys_.extent(0), bin_op_, sort_within_bins_) {}
+
+  BinSort(const_key_view_type keys_, BinSortOp bin_op_,
+          bool sort_within_bins_ = false)
+      : BinSort(exec_space{}, keys_, bin_op_, sort_within_bins_) {}
+
+  //----------------------------------------
+  // Create the permutation vector, the bin_offset array and the bin_count
+  // array. Can be called again if keys changed
+  template <class ExecutionSpace>
+  void create_permute_vector(const ExecutionSpace& exec) {
+    static_assert(
+        Kokkos::SpaceAccessibility<ExecutionSpace,
+                                   typename Space::memory_space>::accessible,
+        "The provided execution space must be able to access the memory space "
+        "BinSort was initialized with!");
+
+    const size_t len = range_end - range_begin;
+    Kokkos::parallel_for(
+        "Kokkos::Sort::BinCount",
+        Kokkos::RangePolicy<ExecutionSpace, bin_count_tag>(exec, 0, len),
+        *this);
+    Kokkos::parallel_scan("Kokkos::Sort::BinOffset",
+                          Kokkos::RangePolicy<ExecutionSpace, bin_offset_tag>(
+                              exec, 0, bin_op.max_bins()),
+                          *this);
+
+    Kokkos::deep_copy(exec, bin_count_atomic, 0);
+    Kokkos::parallel_for(
+        "Kokkos::Sort::BinBinning",
+        Kokkos::RangePolicy<ExecutionSpace, bin_binning_tag>(exec, 0, len),
+        *this);
+
+    if (sort_within_bins)
+      Kokkos::parallel_for(
+          "Kokkos::Sort::BinSort",
+          Kokkos::RangePolicy<ExecutionSpace, bin_sort_bins_tag>(
+              exec, 0, bin_op.max_bins()),
+          *this);
+  }
+
+  // Create the permutation vector, the bin_offset array and the bin_count
+  // array. Can be called again if keys changed
+  void create_permute_vector() {
+    Kokkos::fence("Kokkos::Binsort::create_permute_vector: before");
+    exec_space e{};
+    create_permute_vector(e);
+    e.fence("Kokkos::Binsort::create_permute_vector: after");
+  }
+
+  // Sort a subset of a view with respect to the first dimension using the
+  // permutation array
+  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,
+        "The provided execution space must be able to access the memory space "
+        "BinSort was initialized with!");
+    static_assert(
+        Kokkos::SpaceAccessibility<
+            ExecutionSpace, typename ValuesViewType::memory_space>::accessible,
+        "The provided execution space must be able to access the memory space "
+        "of the View argument!");
+
+    const size_t len        = range_end - range_begin;
+    const size_t values_len = values_range_end - values_range_begin;
+    if (len != values_len) {
+      Kokkos::abort(
+          "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"),
+        values.rank_dynamic > 0 ? len : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 1 ? values.extent(1)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 2 ? values.extent(2)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 3 ? values.extent(3)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 4 ? values.extent(4)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 5 ? values.extent(5)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 6 ? values.extent(6)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        values.rank_dynamic > 7 ? values.extent(7)
+                                : KOKKOS_IMPL_CTOR_DEFAULT_ARG);
+
+    {
+      copy_permute_functor<scratch_view_type /* DstViewType */
+                           ,
+                           offset_type /* PermuteViewType */
+                           ,
+                           ValuesViewType /* SrcViewType */
+                           >
+          functor(sorted_values, sort_order, values,
+                  values_range_begin - range_begin);
+
+      parallel_for("Kokkos::Sort::CopyPermute",
+                   Kokkos::RangePolicy<ExecutionSpace>(exec, 0, len), functor);
+    }
+
+    {
+      copy_functor<ValuesViewType, scratch_view_type> functor(
+          values, range_begin, sorted_values);
+
+      parallel_for("Kokkos::Sort::Copy",
+                   Kokkos::RangePolicy<ExecutionSpace>(exec, 0, len), functor);
+    }
+  }
+
+  // Sort a subset of a view with respect to the first dimension using the
+  // permutation array
+  template <class ValuesViewType>
+  void sort(ValuesViewType const& values, int values_range_begin,
+            int values_range_end) const {
+    Kokkos::fence("Kokkos::Binsort::sort: before");
+    exec_space exec;
+    sort(exec, values, values_range_begin, values_range_end);
+    exec.fence("Kokkos::BinSort:sort: after");
+  }
+
+  template <class ExecutionSpace, class ValuesViewType>
+  void sort(ExecutionSpace const& exec, ValuesViewType const& values) const {
+    this->sort(exec, values, 0, /*values.extent(0)*/ range_end - range_begin);
+  }
+
+  template <class ValuesViewType>
+  void sort(ValuesViewType const& values) const {
+    this->sort(values, 0, /*values.extent(0)*/ range_end - range_begin);
+  }
+
+  // Get the permutation vector
+  KOKKOS_INLINE_FUNCTION
+  offset_type get_permute_vector() const { return sort_order; }
+
+  // Get the start offsets for each bin
+  KOKKOS_INLINE_FUNCTION
+  offset_type get_bin_offsets() const { return bin_offsets; }
+
+  // Get the count for each bin
+  KOKKOS_INLINE_FUNCTION
+  bin_count_type get_bin_count() const { return bin_count_const; }
+
+ public:
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const bin_count_tag& /*tag*/, const int i) const {
+    const int j = range_begin + i;
+    bin_count_atomic(bin_op.bin(keys, j))++;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const bin_offset_tag& /*tag*/, const int i,
+                  value_type& offset, const bool& final) const {
+    if (final) {
+      bin_offsets(i) = offset;
+    }
+    offset += bin_count_const(i);
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const bin_binning_tag& /*tag*/, const int i) const {
+    const int j     = range_begin + i;
+    const int bin   = bin_op.bin(keys, j);
+    const int count = bin_count_atomic(bin)++;
+
+    sort_order(bin_offsets(bin) + count) = j;
+  }
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const bin_sort_bins_tag& /*tag*/, const int i) const {
+    auto bin_size = bin_count_const(i);
+    if (bin_size <= 1) return;
+    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) {
+      KOKKOS_IF_ON_HOST(
+          (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;
+      }
+    }
+  }
+};
+
+}  // namespace Kokkos
+#endif
diff --git a/algorithms/src/sorting/Kokkos_NestedSortPublicAPI.hpp b/algorithms/src/sorting/Kokkos_NestedSortPublicAPI.hpp
new file mode 100644
index 0000000000..dd468e0734
--- /dev/null
+++ b/algorithms/src/sorting/Kokkos_NestedSortPublicAPI.hpp
@@ -0,0 +1,100 @@
+//@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_NESTED_SORT_PUBLIC_API_HPP_
+#define KOKKOS_NESTED_SORT_PUBLIC_API_HPP_
+
+#include "impl/Kokkos_NestedSortImpl.hpp"
+#include <Kokkos_Core.hpp>
+#include <std_algorithms/impl/Kokkos_HelperPredicates.hpp>
+
+namespace Kokkos {
+namespace Experimental {
+
+template <class TeamMember, class ViewType>
+KOKKOS_INLINE_FUNCTION void sort_team(const TeamMember& t,
+                                      const ViewType& view) {
+  Impl::sort_nested_impl(t, view, nullptr,
+                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
+                             typename ViewType::non_const_value_type>(),
+                         Impl::NestedRange<true>());
+}
+
+template <class TeamMember, class ViewType, class Comparator>
+KOKKOS_INLINE_FUNCTION void sort_team(const TeamMember& t, const ViewType& view,
+                                      const Comparator& comp) {
+  Impl::sort_nested_impl(t, view, nullptr, comp, Impl::NestedRange<true>());
+}
+
+template <class TeamMember, class KeyViewType, class ValueViewType>
+KOKKOS_INLINE_FUNCTION void sort_by_key_team(const TeamMember& t,
+                                             const KeyViewType& keyView,
+                                             const ValueViewType& valueView) {
+  Impl::sort_nested_impl(t, keyView, valueView,
+                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
+                             typename KeyViewType::non_const_value_type>(),
+                         Impl::NestedRange<true>());
+}
+
+template <class TeamMember, class KeyViewType, class ValueViewType,
+          class Comparator>
+KOKKOS_INLINE_FUNCTION void sort_by_key_team(const TeamMember& t,
+                                             const KeyViewType& keyView,
+                                             const ValueViewType& valueView,
+                                             const Comparator& comp) {
+  Impl::sort_nested_impl(t, keyView, valueView, comp,
+                         Impl::NestedRange<true>());
+}
+
+template <class TeamMember, class ViewType>
+KOKKOS_INLINE_FUNCTION void sort_thread(const TeamMember& t,
+                                        const ViewType& view) {
+  Impl::sort_nested_impl(t, view, nullptr,
+                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
+                             typename ViewType::non_const_value_type>(),
+                         Impl::NestedRange<false>());
+}
+
+template <class TeamMember, class ViewType, class Comparator>
+KOKKOS_INLINE_FUNCTION void sort_thread(const TeamMember& t,
+                                        const ViewType& view,
+                                        const Comparator& comp) {
+  Impl::sort_nested_impl(t, view, nullptr, comp, Impl::NestedRange<false>());
+}
+
+template <class TeamMember, class KeyViewType, class ValueViewType>
+KOKKOS_INLINE_FUNCTION void sort_by_key_thread(const TeamMember& t,
+                                               const KeyViewType& keyView,
+                                               const ValueViewType& valueView) {
+  Impl::sort_nested_impl(t, keyView, valueView,
+                         Experimental::Impl::StdAlgoLessThanBinaryPredicate<
+                             typename KeyViewType::non_const_value_type>(),
+                         Impl::NestedRange<false>());
+}
+
+template <class TeamMember, class KeyViewType, class ValueViewType,
+          class Comparator>
+KOKKOS_INLINE_FUNCTION void sort_by_key_thread(const TeamMember& t,
+                                               const KeyViewType& keyView,
+                                               const ValueViewType& valueView,
+                                               const Comparator& comp) {
+  Impl::sort_nested_impl(t, keyView, valueView, comp,
+                         Impl::NestedRange<false>());
+}
+
+}  // namespace Experimental
+}  // namespace Kokkos
+#endif
diff --git a/algorithms/src/sorting/Kokkos_SortByKeyPublicAPI.hpp b/algorithms/src/sorting/Kokkos_SortByKeyPublicAPI.hpp
new file mode 100644
index 0000000000..fc73eccad6
--- /dev/null
+++ b/algorithms/src/sorting/Kokkos_SortByKeyPublicAPI.hpp
@@ -0,0 +1,117 @@
+//@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_SORT_BY_KEY_PUBLIC_API_HPP_
+#define KOKKOS_SORT_BY_KEY_PUBLIC_API_HPP_
+
+#include "./impl/Kokkos_SortByKeyImpl.hpp"
+#include <Kokkos_Core.hpp>
+#include <algorithm>
+
+namespace Kokkos::Experimental {
+
+// ---------------------------------------------------------------
+// basic overloads
+// ---------------------------------------------------------------
+
+template <class ExecutionSpace, class KeysDataType, class... KeysProperties,
+          class ValuesDataType, class... ValuesProperties>
+void sort_by_key(
+    const ExecutionSpace& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values) {
+  // constraints
+  using KeysType   = Kokkos::View<KeysDataType, KeysProperties...>;
+  using ValuesType = Kokkos::View<ValuesDataType, ValuesProperties...>;
+  ::Kokkos::Impl::static_assert_is_admissible_to_kokkos_sort_by_key(keys);
+  ::Kokkos::Impl::static_assert_is_admissible_to_kokkos_sort_by_key(values);
+
+  static_assert(SpaceAccessibility<ExecutionSpace,
+                                   typename KeysType::memory_space>::accessible,
+                "Kokkos::sort: execution space instance is not able to access "
+                "the memory space of the keys View argument!");
+  static_assert(
+      SpaceAccessibility<ExecutionSpace,
+                         typename ValuesType::memory_space>::accessible,
+      "Kokkos::sort: execution space instance is not able to access "
+      "the memory space of the values View argument!");
+
+  static_assert(KeysType::static_extent(0) == 0 ||
+                ValuesType::static_extent(0) == 0 ||
+                KeysType::static_extent(0) == ValuesType::static_extent(0));
+  if (values.size() != keys.size())
+    Kokkos::abort((std::string("values and keys extents must be the same. The "
+                               "values extent is ") +
+                   std::to_string(values.size()) + ", and the keys extent is " +
+                   std::to_string(keys.size()) + ".")
+                      .c_str());
+
+  if (keys.extent(0) <= 1) {
+    return;
+  }
+
+  ::Kokkos::Impl::sort_by_key_device_view_without_comparator(exec, keys,
+                                                             values);
+}
+
+// ---------------------------------------------------------------
+// overloads supporting a custom comparator
+// ---------------------------------------------------------------
+
+template <class ExecutionSpace, class ComparatorType, class KeysDataType,
+          class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties>
+void sort_by_key(
+    const ExecutionSpace& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    const ComparatorType& comparator) {
+  // constraints
+  using KeysType   = Kokkos::View<KeysDataType, KeysProperties...>;
+  using ValuesType = Kokkos::View<ValuesDataType, ValuesProperties...>;
+  ::Kokkos::Impl::static_assert_is_admissible_to_kokkos_sort_by_key(keys);
+  ::Kokkos::Impl::static_assert_is_admissible_to_kokkos_sort_by_key(values);
+
+  static_assert(SpaceAccessibility<ExecutionSpace,
+                                   typename KeysType::memory_space>::accessible,
+                "Kokkos::sort: execution space instance is not able to access "
+                "the memory space of the keys View argument!");
+  static_assert(
+      SpaceAccessibility<ExecutionSpace,
+                         typename ValuesType::memory_space>::accessible,
+      "Kokkos::sort: execution space instance is not able to access "
+      "the memory space of the values View argument!");
+
+  static_assert(KeysType::static_extent(0) == 0 ||
+                ValuesType::static_extent(0) == 0 ||
+                KeysType::static_extent(0) == ValuesType::static_extent(0));
+  if (values.size() != keys.size())
+    Kokkos::abort((std::string("values and keys extents must be the same. The "
+                               "values extent is ") +
+                   std::to_string(values.size()) + ", and the keys extent is " +
+                   std::to_string(keys.size()) + ".")
+                      .c_str());
+
+  if (keys.extent(0) <= 1) {
+    return;
+  }
+
+  ::Kokkos::Impl::sort_by_key_device_view_with_comparator(exec, keys, values,
+                                                          comparator);
+}
+
+}  // namespace Kokkos::Experimental
+#endif
diff --git a/algorithms/src/sorting/Kokkos_SortPublicAPI.hpp b/algorithms/src/sorting/Kokkos_SortPublicAPI.hpp
new file mode 100644
index 0000000000..308e9e3a00
--- /dev/null
+++ b/algorithms/src/sorting/Kokkos_SortPublicAPI.hpp
@@ -0,0 +1,196 @@
+//@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_SORT_PUBLIC_API_HPP_
+#define KOKKOS_SORT_PUBLIC_API_HPP_
+
+#include "./impl/Kokkos_SortImpl.hpp"
+#include <std_algorithms/Kokkos_BeginEnd.hpp>
+#include <Kokkos_Core.hpp>
+#include <algorithm>
+
+namespace Kokkos {
+
+// ---------------------------------------------------------------
+// basic overloads
+// ---------------------------------------------------------------
+
+template <class ExecutionSpace, class DataType, class... Properties>
+void sort(const ExecutionSpace& exec,
+          const Kokkos::View<DataType, Properties...>& view) {
+  // constraints
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  using MemSpace = typename ViewType::memory_space;
+  static_assert(
+      ViewType::rank == 1 &&
+          (std::is_same_v<typename ViewType::array_layout, LayoutRight> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutLeft> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutStride>),
+      "Kokkos::sort without comparator: supports 1D Views with LayoutRight, "
+      "LayoutLeft or LayoutStride.");
+
+  static_assert(SpaceAccessibility<ExecutionSpace, MemSpace>::accessible,
+                "Kokkos::sort: execution space instance is not able to access "
+                "the memory space of the "
+                "View argument!");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  if constexpr (Impl::better_off_calling_std_sort_v<ExecutionSpace>) {
+    exec.fence("Kokkos::sort without comparator use std::sort");
+    auto first = ::Kokkos::Experimental::begin(view);
+    auto last  = ::Kokkos::Experimental::end(view);
+    std::sort(first, last);
+  } else {
+    Impl::sort_device_view_without_comparator(exec, view);
+  }
+}
+
+template <class DataType, class... Properties>
+void sort(const Kokkos::View<DataType, Properties...>& view) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(ViewType::rank == 1,
+                "Kokkos::sort: currently only supports rank-1 Views.");
+
+  Kokkos::fence("Kokkos::sort: before");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  typename ViewType::execution_space exec;
+  sort(exec, view);
+  exec.fence("Kokkos::sort: fence after sorting");
+}
+
+// ---------------------------------------------------------------
+// overloads supporting a custom comparator
+// ---------------------------------------------------------------
+template <class ExecutionSpace, class ComparatorType, class DataType,
+          class... Properties>
+void sort(const ExecutionSpace& exec,
+          const Kokkos::View<DataType, Properties...>& view,
+          const ComparatorType& comparator) {
+  // constraints
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  using MemSpace = typename ViewType::memory_space;
+  static_assert(
+      ViewType::rank == 1 &&
+          (std::is_same_v<typename ViewType::array_layout, LayoutRight> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutLeft> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutStride>),
+      "Kokkos::sort with comparator: supports 1D Views with LayoutRight, "
+      "LayoutLeft or LayoutStride.");
+
+  static_assert(SpaceAccessibility<ExecutionSpace, MemSpace>::accessible,
+                "Kokkos::sort: execution space instance is not able to access "
+                "the memory space of the View argument!");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  if constexpr (Impl::better_off_calling_std_sort_v<ExecutionSpace>) {
+    exec.fence("Kokkos::sort with comparator use std::sort");
+    auto first = ::Kokkos::Experimental::begin(view);
+    auto last  = ::Kokkos::Experimental::end(view);
+    std::sort(first, last, comparator);
+  } else {
+    Impl::sort_device_view_with_comparator(exec, view, comparator);
+  }
+}
+
+template <class ComparatorType, class DataType, class... Properties>
+void sort(const Kokkos::View<DataType, Properties...>& view,
+          const ComparatorType& comparator) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(
+      ViewType::rank == 1 &&
+          (std::is_same_v<typename ViewType::array_layout, LayoutRight> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutLeft> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutStride>),
+      "Kokkos::sort with comparator: supports 1D Views with LayoutRight, "
+      "LayoutLeft or LayoutStride.");
+
+  Kokkos::fence("Kokkos::sort with comparator: before");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  typename ViewType::execution_space exec;
+  sort(exec, view, comparator);
+  exec.fence("Kokkos::sort with comparator: fence after sorting");
+}
+
+// ---------------------------------------------------------------
+// overloads for sorting a view with a subrange
+// specified via integers begin, end
+// ---------------------------------------------------------------
+
+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) {
+  // view must be rank-1 because the Impl::min_max_functor
+  // used below only works for rank-1 views for now
+  static_assert(ViewType::rank == 1,
+                "Kokkos::sort: currently only supports rank-1 Views.");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  using range_policy = Kokkos::RangePolicy<typename ViewType::execution_space>;
+  using CompType     = BinOp1D<ViewType>;
+
+  Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> result;
+  Kokkos::MinMax<typename ViewType::non_const_value_type> reducer(result);
+
+  parallel_reduce("Kokkos::Sort::FindExtent", range_policy(exec, begin, end),
+                  Impl::min_max_functor<ViewType>(view), reducer);
+
+  if (result.min_val == result.max_val) return;
+
+  BinSort<ViewType, CompType> bin_sort(
+      exec, view, begin, end,
+      CompType((end - begin) / 2, result.min_val, result.max_val), true);
+
+  bin_sort.create_permute_vector(exec);
+  bin_sort.sort(exec, view, begin, end);
+}
+
+template <class ViewType>
+void sort(ViewType view, size_t const begin, size_t const end) {
+  // same constraints as the overload above which this gets dispatched to
+  static_assert(ViewType::rank == 1,
+                "Kokkos::sort: currently only supports rank-1 Views.");
+
+  Kokkos::fence("Kokkos::sort: before");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  typename ViewType::execution_space exec;
+  sort(exec, view, begin, end);
+  exec.fence("Kokkos::Sort: fence after sorting");
+}
+
+}  // namespace Kokkos
+#endif
diff --git a/algorithms/src/sorting/impl/Kokkos_CopyOpsForBinSortImpl.hpp b/algorithms/src/sorting/impl/Kokkos_CopyOpsForBinSortImpl.hpp
new file mode 100644
index 0000000000..07f5926d82
--- /dev/null
+++ b/algorithms/src/sorting/impl/Kokkos_CopyOpsForBinSortImpl.hpp
@@ -0,0 +1,61 @@
+//@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_COPY_OPS_FOR_BINSORT_IMPL_HPP_
+#define KOKKOS_COPY_OPS_FOR_BINSORT_IMPL_HPP_
+
+#include <Kokkos_Macros.hpp>
+#include <cstddef>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class DstViewType, class SrcViewType, int Rank = DstViewType::rank>
+struct CopyOp;
+
+template <class DstViewType, class SrcViewType>
+struct CopyOp<DstViewType, SrcViewType, 1> {
+  KOKKOS_INLINE_FUNCTION
+  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
+                   size_t i_src) {
+    dst(i_dst) = src(i_src);
+  }
+};
+
+template <class DstViewType, class SrcViewType>
+struct CopyOp<DstViewType, SrcViewType, 2> {
+  KOKKOS_INLINE_FUNCTION
+  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
+                   size_t i_src) {
+    for (int j = 0; j < (int)dst.extent(1); j++) dst(i_dst, j) = src(i_src, j);
+  }
+};
+
+template <class DstViewType, class SrcViewType>
+struct CopyOp<DstViewType, SrcViewType, 3> {
+  KOKKOS_INLINE_FUNCTION
+  static void copy(DstViewType const& dst, size_t i_dst, SrcViewType const& src,
+                   size_t i_src) {
+    for (int j = 0; j < dst.extent(1); j++)
+      for (int k = 0; k < dst.extent(2); k++)
+        dst(i_dst, j, k) = src(i_src, j, k);
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/algorithms/src/sorting/impl/Kokkos_NestedSortImpl.hpp b/algorithms/src/sorting/impl/Kokkos_NestedSortImpl.hpp
new file mode 100644
index 0000000000..2fe58272d9
--- /dev/null
+++ b/algorithms/src/sorting/impl/Kokkos_NestedSortImpl.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_NESTED_SORT_IMPL_HPP_
+#define KOKKOS_NESTED_SORT_IMPL_HPP_
+
+#include <Kokkos_Core.hpp>
+
+namespace Kokkos {
+namespace Experimental {
+namespace Impl {
+
+// true for TeamVectorRange, false for ThreadVectorRange
+template <bool teamLevel>
+struct NestedRange {};
+
+// Specialization for team-level
+template <>
+struct NestedRange<true> {
+  template <typename TeamMember, typename SizeType>
+  KOKKOS_FUNCTION static auto create(const TeamMember& t, SizeType len) {
+    return Kokkos::TeamVectorRange(t, len);
+  }
+  template <typename TeamMember>
+  KOKKOS_FUNCTION static void barrier(const TeamMember& t) {
+    t.team_barrier();
+  }
+};
+
+// Specialization for thread-level
+template <>
+struct NestedRange<false> {
+  template <typename TeamMember, typename SizeType>
+  KOKKOS_FUNCTION static auto create(const TeamMember& t, SizeType len) {
+    return Kokkos::ThreadVectorRange(t, len);
+  }
+  // Barrier is no-op, as vector lanes of a thread are implicitly synchronized
+  // after parallel region
+  template <typename TeamMember>
+  KOKKOS_FUNCTION static void barrier(const TeamMember&) {}
+};
+
+// When just doing sort (not sort_by_key), use nullptr_t for ValueViewType.
+// This only takes the NestedRange instance for template arg deduction.
+template <class TeamMember, class KeyViewType, class ValueViewType,
+          class Comparator, bool useTeamLevel>
+KOKKOS_INLINE_FUNCTION void sort_nested_impl(
+    const TeamMember& t, const KeyViewType& keyView,
+    [[maybe_unused]] const ValueViewType& valueView, const Comparator& comp,
+    const NestedRange<useTeamLevel>) {
+  using SizeType  = typename KeyViewType::size_type;
+  using KeyType   = typename KeyViewType::non_const_value_type;
+  using Range     = NestedRange<useTeamLevel>;
+  SizeType n      = keyView.extent(0);
+  SizeType npot   = 1;
+  SizeType levels = 0;
+  // FIXME: ceiling power-of-two is a common thing to need - make it a utility
+  while (npot < n) {
+    levels++;
+    npot <<= 1;
+  }
+  for (SizeType i = 0; i < levels; i++) {
+    for (SizeType j = 0; j <= i; j++) {
+      // n/2 pairs of items are compared in parallel
+      Kokkos::parallel_for(Range::create(t, npot / 2), [=](const SizeType k) {
+        // How big are the brown/pink boxes?
+        // (Terminology comes from Wikipedia diagram)
+        // https://commons.wikimedia.org/wiki/File:BitonicSort.svg#/media/File:BitonicSort.svg
+        SizeType boxSize = SizeType(2) << (i - j);
+        // Which box contains this thread?
+        SizeType boxID     = k >> (i - j);          // k * 2 / boxSize;
+        SizeType boxStart  = boxID << (1 + i - j);  // boxID * boxSize
+        SizeType boxOffset = k - (boxStart >> 1);   // k - boxID * boxSize / 2;
+        SizeType elem1     = boxStart + boxOffset;
+        // In first phase (j == 0, brown box): within a box, compare with the
+        // opposite value in the box.
+        // In later phases (j > 0, pink box): within a box, compare with fixed
+        // distance (boxSize / 2) apart.
+        SizeType elem2 = (j == 0) ? (boxStart + boxSize - 1 - boxOffset)
+                                  : (elem1 + boxSize / 2);
+        if (elem2 < n) {
+          KeyType key1 = keyView(elem1);
+          KeyType key2 = keyView(elem2);
+          if (comp(key2, key1)) {
+            keyView(elem1) = key2;
+            keyView(elem2) = key1;
+            if constexpr (!std::is_same_v<ValueViewType, std::nullptr_t>) {
+              Kokkos::kokkos_swap(valueView(elem1), valueView(elem2));
+            }
+          }
+        }
+      });
+      Range::barrier(t);
+    }
+  }
+}
+
+}  // namespace Impl
+}  // namespace Experimental
+}  // namespace Kokkos
+#endif
diff --git a/algorithms/src/sorting/impl/Kokkos_SortByKeyImpl.hpp b/algorithms/src/sorting/impl/Kokkos_SortByKeyImpl.hpp
new file mode 100644
index 0000000000..f11f807048
--- /dev/null
+++ b/algorithms/src/sorting/impl/Kokkos_SortByKeyImpl.hpp
@@ -0,0 +1,424 @@
+//@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_SORT_BY_KEY_FREE_FUNCS_IMPL_HPP_
+#define KOKKOS_SORT_BY_KEY_FREE_FUNCS_IMPL_HPP_
+
+#include <Kokkos_Core.hpp>
+
+#if defined(KOKKOS_ENABLE_CUDA)
+
+// Workaround for `Instruction 'shfl' without '.sync' is not supported on
+// .target sm_70 and higher from PTX ISA version 6.4`.
+// Also see https://github.com/NVIDIA/cub/pull/170.
+#if !defined(CUB_USE_COOPERATIVE_GROUPS)
+#define CUB_USE_COOPERATIVE_GROUPS
+#endif
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+
+#if defined(KOKKOS_COMPILER_CLANG)
+// Some versions of Clang fail to compile Thrust, failing with errors like
+// this:
+//    <snip>/thrust/system/cuda/detail/core/agent_launcher.h:557:11:
+//    error: use of undeclared identifier 'va_printf'
+// The exact combination of versions for Clang and Thrust (or CUDA) for this
+// failure was not investigated, however even very recent version combination
+// (Clang 10.0.0 and Cuda 10.0) demonstrated failure.
+//
+// Defining _CubLog here locally allows us to avoid that code path, however
+// disabling some debugging diagnostics
+#pragma push_macro("_CubLog")
+#ifdef _CubLog
+#undef _CubLog
+#endif
+#define _CubLog
+#include <thrust/device_ptr.h>
+#include <thrust/sort.h>
+#pragma pop_macro("_CubLog")
+#else
+#include <thrust/device_ptr.h>
+#include <thrust/sort.h>
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+#include <thrust/device_ptr.h>
+#include <thrust/sort.h>
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL) && \
+    (ONEDPL_VERSION_MAJOR > 2022 ||  \
+     (ONEDPL_VERSION_MAJOR == 2022 && ONEDPL_VERSION_MINOR >= 2))
+#define KOKKOS_ONEDPL_HAS_SORT_BY_KEY
+#include <oneapi/dpl/execution>
+#include <oneapi/dpl/algorithm>
+#endif
+
+namespace Kokkos::Impl {
+
+template <typename T>
+constexpr inline bool is_admissible_to_kokkos_sort_by_key =
+    ::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,
+                  Kokkos::LayoutRight>::value ||
+     std::is_same<typename T::traits::array_layout,
+                  Kokkos::LayoutStride>::value);
+
+template <class ViewType>
+KOKKOS_INLINE_FUNCTION constexpr void
+static_assert_is_admissible_to_kokkos_sort_by_key(const ViewType& /* view */) {
+  static_assert(is_admissible_to_kokkos_sort_by_key<ViewType>,
+                "Kokkos::sort_by_key only accepts 1D values View with "
+                "LayoutRight, LayoutLeft or LayoutStride.");
+}
+
+// For the fallback implementation for sort_by_key using Kokkos::sort, we need
+// to consider if Kokkos::sort defers to the fallback implementation that copies
+// the array to the host and uses std::sort, see
+// copy_to_host_run_stdsort_copy_back() in impl/Kokkos_SortImpl.hpp. If
+// sort_on_device_v is true, we assume that std::sort doesn't copy data.
+// Otherwise, we manually copy all data to the host and provide Kokkos::sort
+// with a host execution space.
+template <class ExecutionSpace, class Layout>
+inline constexpr bool sort_on_device_v = false;
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class Layout>
+inline constexpr bool sort_on_device_v<Kokkos::Cuda, Layout> = true;
+
+template <class KeysDataType, class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties, class... MaybeComparator>
+void sort_by_key_cudathrust(
+    const Kokkos::Cuda& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    MaybeComparator&&... maybeComparator) {
+  const auto policy = thrust::cuda::par.on(exec.cuda_stream());
+  auto keys_first   = ::Kokkos::Experimental::begin(keys);
+  auto keys_last    = ::Kokkos::Experimental::end(keys);
+  auto values_first = ::Kokkos::Experimental::begin(values);
+  thrust::sort_by_key(policy, keys_first, keys_last, values_first,
+                      std::forward<MaybeComparator>(maybeComparator)...);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+template <class Layout>
+inline constexpr bool sort_on_device_v<Kokkos::HIP, Layout> = true;
+
+template <class KeysDataType, class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties, class... MaybeComparator>
+void sort_by_key_rocthrust(
+    const Kokkos::HIP& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    MaybeComparator&&... maybeComparator) {
+  const auto policy = thrust::hip::par.on(exec.hip_stream());
+  auto keys_first   = ::Kokkos::Experimental::begin(keys);
+  auto keys_last    = ::Kokkos::Experimental::end(keys);
+  auto values_first = ::Kokkos::Experimental::begin(values);
+  thrust::sort_by_key(policy, keys_first, keys_last, values_first,
+                      std::forward<MaybeComparator>(maybeComparator)...);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class Layout>
+inline constexpr bool sort_on_device_v<Kokkos::Experimental::SYCL, Layout> =
+    std::is_same_v<Layout, Kokkos::LayoutLeft> ||
+    std::is_same_v<Layout, Kokkos::LayoutRight>;
+
+#ifdef KOKKOS_ONEDPL_HAS_SORT_BY_KEY
+template <class KeysDataType, class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties, class... MaybeComparator>
+void sort_by_key_onedpl(
+    const Kokkos::Experimental::SYCL& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    MaybeComparator&&... maybeComparator) {
+  if (keys.stride(0) != 1 && values.stride(0) != 1) {
+    Kokkos::abort(
+        "SYCL sort_by_key only supports rank-1 Views with stride(0) = 1.");
+  }
+
+  // Can't use Experimental::begin/end here since the oneDPL then assumes that
+  // the data is on the host.
+  auto queue  = exec.sycl_queue();
+  auto policy = oneapi::dpl::execution::make_device_policy(queue);
+  const int n = keys.extent(0);
+  oneapi::dpl::sort_by_key(policy, keys.data(), keys.data() + n, values.data(),
+                           std::forward<MaybeComparator>(maybeComparator)...);
+}
+#endif
+#endif
+
+template <typename ExecutionSpace, typename PermutationView, typename ViewType>
+void applyPermutation(const ExecutionSpace& space,
+                      const PermutationView& permutation,
+                      const ViewType& view) {
+  static_assert(std::is_integral<typename PermutationView::value_type>::value);
+
+  auto view_copy = Kokkos::create_mirror(
+      Kokkos::view_alloc(space, typename ExecutionSpace::memory_space{},
+                         Kokkos::WithoutInitializing),
+      view);
+  Kokkos::deep_copy(space, view_copy, view);
+  Kokkos::parallel_for(
+      "Kokkos::sort_by_key_via_sort::permute_" + view.label(),
+      Kokkos::RangePolicy<ExecutionSpace>(space, 0, view.extent(0)),
+      KOKKOS_LAMBDA(int i) { view(i) = view_copy(permutation(i)); });
+}
+
+// FIXME_NVCC: nvcc has trouble compiling lambdas inside a function with
+// variadic templates (sort_by_key_via_sort). Switch to using functors instead.
+template <typename Permute>
+struct IotaFunctor {
+  Permute _permute;
+  KOKKOS_FUNCTION void operator()(int i) const { _permute(i) = i; }
+};
+template <typename Keys>
+struct LessFunctor {
+  Keys _keys;
+  KOKKOS_FUNCTION bool operator()(int i, int j) const {
+    return _keys(i) < _keys(j);
+  }
+};
+
+// FIXME_NVCC+MSVC: We can't use a lambda instead of a functor which gave us
+// "For this host platform/dialect, an extended lambda cannot be defined inside
+// the 'if' or 'else' block of a constexpr if statement"
+template <typename Keys, typename Comparator>
+struct KeyComparisonFunctor {
+  Keys m_keys;
+  Comparator m_comparator;
+  KOKKOS_FUNCTION bool operator()(int i, int j) const {
+    return m_comparator(m_keys(i), m_keys(j));
+  }
+};
+
+template <class ExecutionSpace, class KeysDataType, class... KeysProperties,
+          class ValuesDataType, class... ValuesProperties,
+          class... MaybeComparator>
+void sort_by_key_via_sort(
+    const ExecutionSpace& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    MaybeComparator&&... maybeComparator) {
+  static_assert(sizeof...(MaybeComparator) <= 1);
+
+  auto const n = keys.size();
+
+  Kokkos::View<unsigned int*, ExecutionSpace> permute(
+      Kokkos::view_alloc(exec, Kokkos::WithoutInitializing,
+                         "Kokkos::sort_by_key_via_sort::permute"),
+      n);
+
+  // iota
+  Kokkos::parallel_for("Kokkos::sort_by_key_via_sort::iota",
+                       Kokkos::RangePolicy<ExecutionSpace>(exec, 0, n),
+                       IotaFunctor<decltype(permute)>{permute});
+
+  using Layout =
+      typename Kokkos::View<unsigned int*, ExecutionSpace>::array_layout;
+  if constexpr (!sort_on_device_v<ExecutionSpace, Layout>) {
+    auto host_keys = Kokkos::create_mirror_view(
+        Kokkos::view_alloc(Kokkos::HostSpace{}, Kokkos::WithoutInitializing),
+        keys);
+    auto host_permute = Kokkos::create_mirror_view(
+        Kokkos::view_alloc(Kokkos::HostSpace{}, Kokkos::WithoutInitializing),
+        permute);
+    Kokkos::deep_copy(exec, host_keys, keys);
+    Kokkos::deep_copy(exec, host_permute, permute);
+
+    exec.fence("Kokkos::Impl::sort_by_key_via_sort: before host sort");
+    Kokkos::DefaultHostExecutionSpace host_exec;
+
+    if constexpr (sizeof...(MaybeComparator) == 0) {
+      Kokkos::sort(host_exec, host_permute,
+                   LessFunctor<decltype(host_keys)>{host_keys});
+    } else {
+      auto keys_comparator =
+          std::get<0>(std::tuple<MaybeComparator...>(maybeComparator...));
+      Kokkos::sort(
+          host_exec, host_permute,
+          KeyComparisonFunctor<decltype(host_keys), decltype(keys_comparator)>{
+              host_keys, keys_comparator});
+    }
+    host_exec.fence("Kokkos::Impl::sort_by_key_via_sort: after host sort");
+    Kokkos::deep_copy(exec, permute, host_permute);
+  } else {
+#ifdef KOKKOS_ENABLE_SYCL
+    auto* raw_keys_in_comparator = keys.data();
+    auto stride                  = keys.stride(0);
+    if constexpr (sizeof...(MaybeComparator) == 0) {
+      Kokkos::sort(
+          exec, permute, KOKKOS_LAMBDA(int i, int j) {
+            return raw_keys_in_comparator[i * stride] <
+                   raw_keys_in_comparator[j * stride];
+          });
+    } else {
+      auto keys_comparator =
+          std::get<0>(std::tuple<MaybeComparator...>(maybeComparator...));
+      Kokkos::sort(
+          exec, permute, KOKKOS_LAMBDA(int i, int j) {
+            return keys_comparator(raw_keys_in_comparator[i * stride],
+                                   raw_keys_in_comparator[j * stride]);
+          });
+    }
+#else
+    if constexpr (sizeof...(MaybeComparator) == 0) {
+      Kokkos::sort(exec, permute, LessFunctor<decltype(keys)>{keys});
+    } else {
+      auto keys_comparator =
+          std::get<0>(std::tuple<MaybeComparator...>(maybeComparator...));
+      Kokkos::sort(
+          exec, permute,
+          KeyComparisonFunctor<decltype(keys), decltype(keys_comparator)>{
+              keys, keys_comparator});
+    }
+#endif
+  }
+
+  applyPermutation(exec, permute, keys);
+  applyPermutation(exec, permute, values);
+}
+
+// ------------------------------------------------------
+//
+// specialize cases for sorting by key without comparator
+//
+// ------------------------------------------------------
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class KeysDataType, class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties>
+void sort_by_key_device_view_without_comparator(
+    const Kokkos::Cuda& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values) {
+  sort_by_key_cudathrust(exec, keys, values);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+template <class KeysDataType, class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties>
+void sort_by_key_device_view_without_comparator(
+    const Kokkos::HIP& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values) {
+  sort_by_key_rocthrust(exec, keys, values);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class KeysDataType, class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties>
+void sort_by_key_device_view_without_comparator(
+    const Kokkos::Experimental::SYCL& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values) {
+#ifdef KOKKOS_ONEDPL_HAS_SORT_BY_KEY
+  if (keys.stride(0) == 1 && values.stride(0) == 1)
+    sort_by_key_onedpl(exec, keys, values);
+  else
+#endif
+    sort_by_key_via_sort(exec, keys, values);
+}
+#endif
+
+// fallback case
+template <class ExecutionSpace, class KeysDataType, class... KeysProperties,
+          class ValuesDataType, class... ValuesProperties>
+std::enable_if_t<Kokkos::is_execution_space<ExecutionSpace>::value>
+sort_by_key_device_view_without_comparator(
+    const ExecutionSpace& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values) {
+  sort_by_key_via_sort(exec, keys, values);
+}
+
+// ---------------------------------------------------
+//
+// specialize cases for sorting by key with comparator
+//
+// ---------------------------------------------------
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class ComparatorType, class KeysDataType, class... KeysProperties,
+          class ValuesDataType, class... ValuesProperties>
+void sort_by_key_device_view_with_comparator(
+    const Kokkos::Cuda& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    const ComparatorType& comparator) {
+  sort_by_key_cudathrust(exec, keys, values, comparator);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+template <class ComparatorType, class KeysDataType, class... KeysProperties,
+          class ValuesDataType, class... ValuesProperties>
+void sort_by_key_device_view_with_comparator(
+    const Kokkos::HIP& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    const ComparatorType& comparator) {
+  sort_by_key_rocthrust(exec, keys, values, comparator);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class ComparatorType, class KeysDataType, class... KeysProperties,
+          class ValuesDataType, class... ValuesProperties>
+void sort_by_key_device_view_with_comparator(
+    const Kokkos::Experimental::SYCL& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    const ComparatorType& comparator) {
+#ifdef KOKKOS_ONEDPL_HAS_SORT_BY_KEY
+  if (keys.stride(0) == 1 && values.stride(0) == 1)
+    sort_by_key_onedpl(exec, keys, values, comparator);
+  else
+#endif
+    sort_by_key_via_sort(exec, keys, values, comparator);
+}
+#endif
+
+// fallback case
+template <class ComparatorType, class ExecutionSpace, class KeysDataType,
+          class... KeysProperties, class ValuesDataType,
+          class... ValuesProperties>
+std::enable_if_t<Kokkos::is_execution_space<ExecutionSpace>::value>
+sort_by_key_device_view_with_comparator(
+    const ExecutionSpace& exec,
+    const Kokkos::View<KeysDataType, KeysProperties...>& keys,
+    const Kokkos::View<ValuesDataType, ValuesProperties...>& values,
+    const ComparatorType& comparator) {
+  sort_by_key_via_sort(exec, keys, values, comparator);
+}
+
+#undef KOKKOS_ONEDPL_HAS_SORT_BY_KEY
+
+}  // namespace Kokkos::Impl
+#endif
diff --git a/algorithms/src/sorting/impl/Kokkos_SortImpl.hpp b/algorithms/src/sorting/impl/Kokkos_SortImpl.hpp
new file mode 100644
index 0000000000..0894622891
--- /dev/null
+++ b/algorithms/src/sorting/impl/Kokkos_SortImpl.hpp
@@ -0,0 +1,416 @@
+//@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_SORT_FREE_FUNCS_IMPL_HPP_
+#define KOKKOS_SORT_FREE_FUNCS_IMPL_HPP_
+
+#include "../Kokkos_BinOpsPublicAPI.hpp"
+#include "../Kokkos_BinSortPublicAPI.hpp"
+#include <std_algorithms/Kokkos_BeginEnd.hpp>
+#include <std_algorithms/Kokkos_Copy.hpp>
+#include <Kokkos_Core.hpp>
+
+#if defined(KOKKOS_ENABLE_CUDA)
+
+// Workaround for `Instruction 'shfl' without '.sync' is not supported on
+// .target sm_70 and higher from PTX ISA version 6.4`.
+// Also see https://github.com/NVIDIA/cub/pull/170.
+#if !defined(CUB_USE_COOPERATIVE_GROUPS)
+#define CUB_USE_COOPERATIVE_GROUPS
+#endif
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+
+#if defined(KOKKOS_COMPILER_CLANG)
+// Some versions of Clang fail to compile Thrust, failing with errors like
+// this:
+//    <snip>/thrust/system/cuda/detail/core/agent_launcher.h:557:11:
+//    error: use of undeclared identifier 'va_printf'
+// The exact combination of versions for Clang and Thrust (or CUDA) for this
+// failure was not investigated, however even very recent version combination
+// (Clang 10.0.0 and Cuda 10.0) demonstrated failure.
+//
+// Defining _CubLog here locally allows us to avoid that code path, however
+// disabling some debugging diagnostics
+#pragma push_macro("_CubLog")
+#ifdef _CubLog
+#undef _CubLog
+#endif
+#define _CubLog
+#include <thrust/device_ptr.h>
+#include <thrust/sort.h>
+#pragma pop_macro("_CubLog")
+#else
+#include <thrust/device_ptr.h>
+#include <thrust/sort.h>
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+#include <thrust/device_ptr.h>
+#include <thrust/sort.h>
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+#include <oneapi/dpl/execution>
+#include <oneapi/dpl/algorithm>
+#endif
+
+namespace Kokkos {
+namespace Impl {
+
+template <class ExecutionSpace>
+struct better_off_calling_std_sort : std::false_type {};
+
+#if defined KOKKOS_ENABLE_SERIAL
+template <>
+struct better_off_calling_std_sort<Kokkos::Serial> : std::true_type {};
+#endif
+
+#if defined KOKKOS_ENABLE_OPENMP
+template <>
+struct better_off_calling_std_sort<Kokkos::OpenMP> : std::true_type {};
+#endif
+
+#if defined KOKKOS_ENABLE_THREADS
+template <>
+struct better_off_calling_std_sort<Kokkos::Threads> : std::true_type {};
+#endif
+
+#if defined KOKKOS_ENABLE_HPX
+template <>
+struct better_off_calling_std_sort<Kokkos::Experimental::HPX> : std::true_type {
+};
+#endif
+
+template <class T>
+inline constexpr bool better_off_calling_std_sort_v =
+    better_off_calling_std_sort<T>::value;
+
+template <class ViewType>
+struct min_max_functor {
+  using minmax_scalar =
+      Kokkos::MinMaxScalar<typename ViewType::non_const_value_type>;
+
+  ViewType view;
+  min_max_functor(const ViewType& view_) : view(view_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const size_t& i, minmax_scalar& minmax) const {
+    if (view(i) < minmax.min_val) minmax.min_val = view(i);
+    if (view(i) > minmax.max_val) minmax.max_val = view(i);
+  }
+};
+
+template <class ExecutionSpace, class DataType, class... Properties>
+void sort_via_binsort(const ExecutionSpace& exec,
+                      const Kokkos::View<DataType, Properties...>& view) {
+  // Although we are using BinSort below, which could work on rank-2 views,
+  // for now view must be rank-1 because the min_max_functor
+  // used below only works for rank-1 views
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(ViewType::rank == 1,
+                "Kokkos::sort: currently only supports rank-1 Views.");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  Kokkos::MinMaxScalar<typename ViewType::non_const_value_type> result;
+  Kokkos::MinMax<typename ViewType::non_const_value_type> reducer(result);
+  parallel_reduce("Kokkos::Sort::FindExtent",
+                  Kokkos::RangePolicy<typename ViewType::execution_space>(
+                      exec, 0, view.extent(0)),
+                  min_max_functor<ViewType>(view), reducer);
+  if (result.min_val == result.max_val) return;
+  // For integral types the number of bins may be larger than the range
+  // in which case we can exactly have one unique value per bin
+  // and then don't need to sort bins.
+  bool sort_in_bins = true;
+  // TODO: figure out better max_bins then this ...
+  int64_t max_bins = view.extent(0) / 2;
+  if (std::is_integral<typename ViewType::non_const_value_type>::value) {
+    // Cast to double to avoid possible overflow when using integer
+    auto const max_val = static_cast<double>(result.max_val);
+    auto const min_val = static_cast<double>(result.min_val);
+    // using 10M as the cutoff for special behavior (roughly 40MB for the count
+    // array)
+    if ((max_val - min_val) < 10000000) {
+      max_bins     = max_val - min_val + 1;
+      sort_in_bins = false;
+    }
+  }
+  if (std::is_floating_point<typename ViewType::non_const_value_type>::value) {
+    KOKKOS_ASSERT(std::isfinite(static_cast<double>(result.max_val) -
+                                static_cast<double>(result.min_val)));
+  }
+
+  using CompType = BinOp1D<ViewType>;
+  BinSort<ViewType, CompType> bin_sort(
+      view, CompType(max_bins, result.min_val, result.max_val), sort_in_bins);
+  bin_sort.create_permute_vector(exec);
+  bin_sort.sort(exec, view);
+}
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class DataType, class... Properties, class... MaybeComparator>
+void sort_cudathrust(const Cuda& space,
+                     const Kokkos::View<DataType, Properties...>& view,
+                     MaybeComparator&&... maybeComparator) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(ViewType::rank == 1,
+                "Kokkos::sort: currently only supports rank-1 Views.");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+  const auto exec = thrust::cuda::par.on(space.cuda_stream());
+  auto first      = ::Kokkos::Experimental::begin(view);
+  auto last       = ::Kokkos::Experimental::end(view);
+  thrust::sort(exec, first, last,
+               std::forward<MaybeComparator>(maybeComparator)...);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+template <class DataType, class... Properties, class... MaybeComparator>
+void sort_rocthrust(const HIP& space,
+                    const Kokkos::View<DataType, Properties...>& view,
+                    MaybeComparator&&... maybeComparator) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(ViewType::rank == 1,
+                "Kokkos::sort: currently only supports rank-1 Views.");
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+  const auto exec = thrust::hip::par.on(space.hip_stream());
+  auto first      = ::Kokkos::Experimental::begin(view);
+  auto last       = ::Kokkos::Experimental::end(view);
+  thrust::sort(exec, first, last,
+               std::forward<MaybeComparator>(maybeComparator)...);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class DataType, class... Properties, class... MaybeComparator>
+void sort_onedpl(const Kokkos::Experimental::SYCL& space,
+                 const Kokkos::View<DataType, Properties...>& view,
+                 MaybeComparator&&... maybeComparator) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(SpaceAccessibility<Kokkos::Experimental::SYCL,
+                                   typename ViewType::memory_space>::accessible,
+                "SYCL execution space is not able to access the memory space "
+                "of the View argument!");
+
+  static_assert(
+      (ViewType::rank == 1) &&
+          (std::is_same_v<typename ViewType::array_layout, LayoutRight> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutLeft> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutStride>),
+      "SYCL sort only supports contiguous rank-1 Views with LayoutLeft, "
+      "LayoutRight or LayoutStride"
+      "For the latter, this means the View must have stride(0) = 1, enforced "
+      "at runtime.");
+
+  if (view.stride(0) != 1) {
+    Kokkos::abort("SYCL sort only supports rank-1 Views with stride(0) = 1.");
+  }
+
+  if (view.extent(0) <= 1) {
+    return;
+  }
+
+  // Can't use Experimental::begin/end here since the oneDPL then assumes that
+  // the data is on the host.
+  auto queue  = space.sycl_queue();
+  auto policy = oneapi::dpl::execution::make_device_policy(queue);
+  const int n = view.extent(0);
+  oneapi::dpl::sort(policy, view.data(), view.data() + n,
+                    std::forward<MaybeComparator>(maybeComparator)...);
+}
+#endif
+
+template <class ExecutionSpace, class DataType, class... Properties,
+          class... MaybeComparator>
+void copy_to_host_run_stdsort_copy_back(
+    const ExecutionSpace& exec,
+    const Kokkos::View<DataType, Properties...>& view,
+    MaybeComparator&&... maybeComparator) {
+  namespace KE = ::Kokkos::Experimental;
+
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  using layout   = typename ViewType::array_layout;
+  if constexpr (std::is_same_v<LayoutStride, layout>) {
+    // for strided views we cannot just deep_copy from device to host,
+    // so we need to do a few more jumps
+    using view_value_type      = typename ViewType::non_const_value_type;
+    using view_exespace        = typename ViewType::execution_space;
+    using view_deep_copyable_t = Kokkos::View<view_value_type*, view_exespace>;
+    view_deep_copyable_t view_dc("view_dc", view.extent(0));
+    KE::copy(exec, view, view_dc);
+
+    // run sort on the mirror of view_dc
+    auto mv_h  = create_mirror_view_and_copy(Kokkos::HostSpace(), view_dc);
+    auto first = KE::begin(mv_h);
+    auto last  = KE::end(mv_h);
+    std::sort(first, last, std::forward<MaybeComparator>(maybeComparator)...);
+    Kokkos::deep_copy(exec, view_dc, mv_h);
+
+    // copy back to argument view
+    KE::copy(exec, KE::cbegin(view_dc), KE::cend(view_dc), KE::begin(view));
+  } else {
+    auto view_h = create_mirror_view_and_copy(Kokkos::HostSpace(), view);
+    auto first  = KE::begin(view_h);
+    auto last   = KE::end(view_h);
+    std::sort(first, last, std::forward<MaybeComparator>(maybeComparator)...);
+    Kokkos::deep_copy(exec, view, view_h);
+  }
+}
+
+// --------------------------------------------------
+//
+// specialize cases for sorting without comparator
+//
+// --------------------------------------------------
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class DataType, class... Properties>
+void sort_device_view_without_comparator(
+    const Cuda& exec, const Kokkos::View<DataType, Properties...>& view) {
+  sort_cudathrust(exec, view);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+template <class DataType, class... Properties>
+void sort_device_view_without_comparator(
+    const HIP& exec, const Kokkos::View<DataType, Properties...>& view) {
+  sort_rocthrust(exec, view);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class DataType, class... Properties>
+void sort_device_view_without_comparator(
+    const Kokkos::Experimental::SYCL& exec,
+    const Kokkos::View<DataType, Properties...>& view) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(
+      (ViewType::rank == 1) &&
+          (std::is_same_v<typename ViewType::array_layout, LayoutRight> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutLeft> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutStride>),
+      "sort_device_view_without_comparator: supports rank-1 Views "
+      "with LayoutLeft, LayoutRight or LayoutStride");
+
+  if (view.stride(0) == 1) {
+    sort_onedpl(exec, view);
+  } else {
+    copy_to_host_run_stdsort_copy_back(exec, view);
+  }
+}
+#endif
+
+// fallback case
+template <class ExecutionSpace, class DataType, class... Properties>
+std::enable_if_t<Kokkos::is_execution_space<ExecutionSpace>::value>
+sort_device_view_without_comparator(
+    const ExecutionSpace& exec,
+    const Kokkos::View<DataType, Properties...>& view) {
+  sort_via_binsort(exec, view);
+}
+
+// --------------------------------------------------
+//
+// specialize cases for sorting with comparator
+//
+// --------------------------------------------------
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <class ComparatorType, class DataType, class... Properties>
+void sort_device_view_with_comparator(
+    const Cuda& exec, const Kokkos::View<DataType, Properties...>& view,
+    const ComparatorType& comparator) {
+  sort_cudathrust(exec, view, comparator);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+template <class ComparatorType, class DataType, class... Properties>
+void sort_device_view_with_comparator(
+    const HIP& exec, const Kokkos::View<DataType, Properties...>& view,
+    const ComparatorType& comparator) {
+  sort_rocthrust(exec, view, comparator);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_ONEDPL)
+template <class ComparatorType, class DataType, class... Properties>
+void sort_device_view_with_comparator(
+    const Kokkos::Experimental::SYCL& exec,
+    const Kokkos::View<DataType, Properties...>& view,
+    const ComparatorType& comparator) {
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  static_assert(
+      (ViewType::rank == 1) &&
+          (std::is_same_v<typename ViewType::array_layout, LayoutRight> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutLeft> ||
+           std::is_same_v<typename ViewType::array_layout, LayoutStride>),
+      "sort_device_view_with_comparator: supports rank-1 Views "
+      "with LayoutLeft, LayoutRight or LayoutStride");
+
+  if (view.stride(0) == 1) {
+    sort_onedpl(exec, view, comparator);
+  } else {
+    copy_to_host_run_stdsort_copy_back(exec, view, comparator);
+  }
+}
+#endif
+
+template <class ExecutionSpace, class ComparatorType, class DataType,
+          class... Properties>
+std::enable_if_t<Kokkos::is_execution_space<ExecutionSpace>::value>
+sort_device_view_with_comparator(
+    const ExecutionSpace& exec,
+    const Kokkos::View<DataType, Properties...>& view,
+    const ComparatorType& comparator) {
+  // This is a fallback case if a more specialized overload does not exist:
+  // for now, this fallback copies data to host, runs std::sort
+  // and then copies data back. Potentially, this can later be changed
+  // with a better solution like our own quicksort on device or similar.
+
+  using ViewType = Kokkos::View<DataType, Properties...>;
+  using MemSpace = typename ViewType::memory_space;
+// Note with HIP unified memory this code path is still the right thing to do
+// if we end up here when RocThrust is not enabled.
+// The create_mirror_view_and_copy will do the right thing (no copy).
+#ifndef KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY
+  static_assert(!SpaceAccessibility<HostSpace, MemSpace>::accessible,
+                "Impl::sort_device_view_with_comparator: should not be called "
+                "on a view that is already accessible on the host");
+#endif
+
+  copy_to_host_run_stdsort_copy_back(exec, view, comparator);
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
+#endif
diff --git a/algorithms/src/std_algorithms/Kokkos_AdjacentDifference.hpp b/algorithms/src/std_algorithms/Kokkos_AdjacentDifference.hpp
index 38dcd1a674..f254686dba 100644
--- a/algorithms/src/std_algorithms/Kokkos_AdjacentDifference.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_AdjacentDifference.hpp
@@ -23,64 +23,85 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType>
-std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value,
-                 OutputIteratorType>
-adjacent_difference(const ExecutionSpace& ex, InputIteratorType first_from,
-                    InputIteratorType last_from,
-                    OutputIteratorType first_dest) {
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIteratorType,
+    typename OutputIteratorType,
+    std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value &&
+                         ::Kokkos::is_execution_space<ExecutionSpace>::value,
+                     int> = 0>
+OutputIteratorType adjacent_difference(const ExecutionSpace& ex,
+                                       InputIteratorType first_from,
+                                       InputIteratorType last_from,
+                                       OutputIteratorType first_dest) {
   using value_type1 = typename InputIteratorType::value_type;
   using value_type2 = typename OutputIteratorType::value_type;
   using binary_op =
       Impl::StdAdjacentDifferenceDefaultBinaryOpFunctor<value_type1,
                                                         value_type2>;
-  return Impl::adjacent_difference_impl(
+  return Impl::adjacent_difference_exespace_impl(
       "Kokkos::adjacent_difference_iterator_api", ex, first_from, last_from,
       first_dest, binary_op());
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOp>
-std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value,
-                 OutputIteratorType>
-adjacent_difference(const ExecutionSpace& ex, InputIteratorType first_from,
-                    InputIteratorType last_from, OutputIteratorType first_dest,
-                    BinaryOp bin_op) {
-  return Impl::adjacent_difference_impl(
+template <
+    typename ExecutionSpace, typename InputIteratorType,
+    typename OutputIteratorType, typename BinaryOp,
+    std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value &&
+                         ::Kokkos::is_execution_space<ExecutionSpace>::value,
+                     int> = 0>
+OutputIteratorType adjacent_difference(const ExecutionSpace& ex,
+                                       InputIteratorType first_from,
+                                       InputIteratorType last_from,
+                                       OutputIteratorType first_dest,
+                                       BinaryOp bin_op) {
+  return Impl::adjacent_difference_exespace_impl(
       "Kokkos::adjacent_difference_iterator_api", ex, first_from, last_from,
       first_dest, bin_op);
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType>
-std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value,
-                 OutputIteratorType>
-adjacent_difference(const std::string& label, const ExecutionSpace& ex,
-                    InputIteratorType first_from, InputIteratorType last_from,
-                    OutputIteratorType first_dest) {
+template <
+    typename ExecutionSpace, typename InputIteratorType,
+    typename OutputIteratorType,
+    std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value &&
+                         ::Kokkos::is_execution_space<ExecutionSpace>::value,
+                     int> = 0>
+OutputIteratorType adjacent_difference(const std::string& label,
+                                       const ExecutionSpace& ex,
+                                       InputIteratorType first_from,
+                                       InputIteratorType last_from,
+                                       OutputIteratorType first_dest) {
   using value_type1 = typename InputIteratorType::value_type;
   using value_type2 = typename OutputIteratorType::value_type;
   using binary_op =
       Impl::StdAdjacentDifferenceDefaultBinaryOpFunctor<value_type1,
                                                         value_type2>;
-  return Impl::adjacent_difference_impl(label, ex, first_from, last_from,
-                                        first_dest, binary_op());
+  return Impl::adjacent_difference_exespace_impl(
+      label, ex, first_from, last_from, first_dest, binary_op());
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOp>
-std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value,
-                 OutputIteratorType>
-adjacent_difference(const std::string& label, const ExecutionSpace& ex,
-                    InputIteratorType first_from, InputIteratorType last_from,
-                    OutputIteratorType first_dest, BinaryOp bin_op) {
-  return Impl::adjacent_difference_impl(label, ex, first_from, last_from,
-                                        first_dest, bin_op);
+template <
+    typename ExecutionSpace, typename InputIteratorType,
+    typename OutputIteratorType, typename BinaryOp,
+    std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value &&
+                         ::Kokkos::is_execution_space<ExecutionSpace>::value,
+                     int> = 0>
+OutputIteratorType adjacent_difference(const std::string& label,
+                                       const ExecutionSpace& ex,
+                                       InputIteratorType first_from,
+                                       InputIteratorType last_from,
+                                       OutputIteratorType first_dest,
+                                       BinaryOp bin_op) {
+  return Impl::adjacent_difference_exespace_impl(label, ex, first_from,
+                                                 last_from, first_dest, bin_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto adjacent_difference(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -96,13 +117,15 @@ auto adjacent_difference(
   using binary_op =
       Impl::StdAdjacentDifferenceDefaultBinaryOpFunctor<value_type1,
                                                         value_type2>;
-  return Impl::adjacent_difference_impl(
+  return Impl::adjacent_difference_exespace_impl(
       "Kokkos::adjacent_difference_view_api", ex, KE::cbegin(view_from),
       KE::cend(view_from), KE::begin(view_dest), binary_op());
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOp>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto adjacent_difference(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -111,13 +134,15 @@ auto adjacent_difference(
   namespace KE = ::Kokkos::Experimental;
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  return Impl::adjacent_difference_impl(
+  return Impl::adjacent_difference_exespace_impl(
       "Kokkos::adjacent_difference_view_api", ex, KE::cbegin(view_from),
       KE::cend(view_from), KE::begin(view_dest), bin_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto adjacent_difference(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -134,13 +159,15 @@ auto adjacent_difference(
       Impl::StdAdjacentDifferenceDefaultBinaryOpFunctor<value_type1,
                                                         value_type2>;
 
-  return Impl::adjacent_difference_impl(label, ex, KE::cbegin(view_from),
-                                        KE::cend(view_from),
-                                        KE::begin(view_dest), binary_op());
+  return Impl::adjacent_difference_exespace_impl(
+      label, ex, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), binary_op());
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOp>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto adjacent_difference(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -149,9 +176,85 @@ auto adjacent_difference(
   namespace KE = ::Kokkos::Experimental;
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  return Impl::adjacent_difference_impl(label, ex, KE::cbegin(view_from),
-                                        KE::cend(view_from),
-                                        KE::begin(view_dest), bin_op);
+  return Impl::adjacent_difference_exespace_impl(
+      label, ex, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), bin_op);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType,
+          std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value &&
+                               ::Kokkos::is_team_handle<TeamHandleType>::value,
+                           int> = 0>
+KOKKOS_FUNCTION OutputIteratorType adjacent_difference(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest) {
+  using value_type1 = typename InputIteratorType::value_type;
+  using value_type2 = typename OutputIteratorType::value_type;
+  using binary_op =
+      Impl::StdAdjacentDifferenceDefaultBinaryOpFunctor<value_type1,
+                                                        value_type2>;
+  return Impl::adjacent_difference_team_impl(teamHandle, first_from, last_from,
+                                             first_dest, binary_op());
+}
+
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp,
+          std::enable_if_t<!::Kokkos::is_view<InputIteratorType>::value &&
+                               ::Kokkos::is_team_handle<TeamHandleType>::value,
+                           int> = 0>
+KOKKOS_FUNCTION OutputIteratorType
+adjacent_difference(const TeamHandleType& teamHandle,
+                    InputIteratorType first_from, InputIteratorType last_from,
+                    OutputIteratorType first_dest, BinaryOp bin_op) {
+  return Impl::adjacent_difference_team_impl(teamHandle, first_from, last_from,
+                                             first_dest, bin_op);
+}
+
+template <
+    typename TeamHandleType, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto adjacent_difference(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest) {
+  namespace KE = ::Kokkos::Experimental;
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+
+  using view_type1  = ::Kokkos::View<DataType1, Properties1...>;
+  using view_type2  = ::Kokkos::View<DataType2, Properties2...>;
+  using value_type1 = typename view_type1::value_type;
+  using value_type2 = typename view_type2::value_type;
+  using binary_op =
+      Impl::StdAdjacentDifferenceDefaultBinaryOpFunctor<value_type1,
+                                                        value_type2>;
+  return Impl::adjacent_difference_team_impl(teamHandle, KE::cbegin(view_from),
+                                             KE::cend(view_from),
+                                             KE::begin(view_dest), binary_op());
+}
+
+template <
+    typename TeamHandleType, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOp,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto adjacent_difference(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    BinaryOp bin_op) {
+  namespace KE = ::Kokkos::Experimental;
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  return Impl::adjacent_difference_team_impl(teamHandle, KE::cbegin(view_from),
+                                             KE::cend(view_from),
+                                             KE::begin(view_dest), bin_op);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_AdjacentFind.hpp b/algorithms/src/std_algorithms/Kokkos_AdjacentFind.hpp
index 43c2b66010..ac476ca5bf 100644
--- a/algorithms/src/std_algorithms/Kokkos_AdjacentFind.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_AdjacentFind.hpp
@@ -23,71 +23,144 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set1
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType adjacent_find(const ExecutionSpace& ex, IteratorType first,
                            IteratorType last) {
-  return Impl::adjacent_find_impl("Kokkos::adjacent_find_iterator_api_default",
-                                  ex, first, last);
+  return Impl::adjacent_find_exespace_impl(
+      "Kokkos::adjacent_find_iterator_api_default", ex, first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType adjacent_find(const std::string& label, const ExecutionSpace& ex,
                            IteratorType first, IteratorType last) {
-  return Impl::adjacent_find_impl(label, ex, first, last);
+  return Impl::adjacent_find_exespace_impl(label, ex, first, last);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto adjacent_find(const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::adjacent_find_impl("Kokkos::adjacent_find_view_api_default", ex,
-                                  KE::begin(v), KE::end(v));
+  return Impl::adjacent_find_exespace_impl(
+      "Kokkos::adjacent_find_view_api_default", ex, KE::begin(v), KE::end(v));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto adjacent_find(const std::string& label, const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::adjacent_find_impl(label, ex, KE::begin(v), KE::end(v));
+  return Impl::adjacent_find_exespace_impl(label, ex, KE::begin(v), KE::end(v));
 }
 
 // overload set2
-template <class ExecutionSpace, class IteratorType, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    typename BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType adjacent_find(const ExecutionSpace& ex, IteratorType first,
                            IteratorType last, BinaryPredicateType pred) {
-  return Impl::adjacent_find_impl("Kokkos::adjacent_find_iterator_api_default",
-                                  ex, first, last, pred);
+  return Impl::adjacent_find_exespace_impl(
+      "Kokkos::adjacent_find_iterator_api_default", ex, first, last, pred);
 }
 
-template <class ExecutionSpace, class IteratorType, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    typename BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType adjacent_find(const std::string& label, const ExecutionSpace& ex,
                            IteratorType first, IteratorType last,
                            BinaryPredicateType pred) {
-  return Impl::adjacent_find_impl(label, ex, first, last, pred);
+  return Impl::adjacent_find_exespace_impl(label, ex, first, last, pred);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto adjacent_find(const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType, Properties...>& v,
                    BinaryPredicateType pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::adjacent_find_impl("Kokkos::adjacent_find_view_api_default", ex,
-                                  KE::begin(v), KE::end(v), pred);
+  return Impl::adjacent_find_exespace_impl(
+      "Kokkos::adjacent_find_view_api_default", ex, KE::begin(v), KE::end(v),
+      pred);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto adjacent_find(const std::string& label, const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType, Properties...>& v,
                    BinaryPredicateType pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::adjacent_find_impl(label, ex, KE::begin(v), KE::end(v), pred);
+  return Impl::adjacent_find_exespace_impl(label, ex, KE::begin(v), KE::end(v),
+                                           pred);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set1
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType adjacent_find(const TeamHandleType& teamHandle,
+                                           IteratorType first,
+                                           IteratorType last) {
+  return Impl::adjacent_find_team_impl(teamHandle, first, last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto adjacent_find(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::adjacent_find_team_impl(teamHandle, KE::begin(v), KE::end(v));
+}
+
+// overload set2
+template <typename TeamHandleType, typename IteratorType,
+          typename BinaryPredicateType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType adjacent_find(const TeamHandleType& teamHandle,
+                                           IteratorType first,
+                                           IteratorType last,
+                                           BinaryPredicateType pred) {
+  return Impl::adjacent_find_team_impl(teamHandle, first, last, pred);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename BinaryPredicateType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto adjacent_find(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v,
+    BinaryPredicateType pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::adjacent_find_team_impl(teamHandle, KE::begin(v), KE::end(v),
+                                       pred);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_AllOf.hpp b/algorithms/src/std_algorithms/Kokkos_AllOf.hpp
index 2ffec7e144..d6ed4c4a7e 100644
--- a/algorithms/src/std_algorithms/Kokkos_AllOf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_AllOf.hpp
@@ -23,41 +23,79 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class Predicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool all_of(const ExecutionSpace& ex, InputIterator first, InputIterator last,
             Predicate predicate) {
-  return Impl::all_of_impl("Kokkos::all_of_iterator_api_default", ex, first,
-                           last, predicate);
+  return Impl::all_of_exespace_impl("Kokkos::all_of_iterator_api_default", ex,
+                                    first, last, predicate);
 }
 
-template <class ExecutionSpace, class InputIterator, class Predicate>
+template <
+    typename ExecutionSpace, typename InputIterator, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool all_of(const std::string& label, const ExecutionSpace& ex,
             InputIterator first, InputIterator last, Predicate predicate) {
-  return Impl::all_of_impl(label, ex, first, last, predicate);
+  return Impl::all_of_exespace_impl(label, ex, first, last, predicate);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool all_of(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& v,
             Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::all_of_impl("Kokkos::all_of_view_api_default", ex, KE::cbegin(v),
-                           KE::cend(v), std::move(predicate));
+  return Impl::all_of_exespace_impl("Kokkos::all_of_view_api_default", ex,
+                                    KE::cbegin(v), KE::cend(v),
+                                    std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool all_of(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& v,
             Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::all_of_impl(label, ex, KE::cbegin(v), KE::cend(v),
-                           std::move(predicate));
+  return Impl::all_of_exespace_impl(label, ex, KE::cbegin(v), KE::cend(v),
+                                    std::move(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator, typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool all_of(const TeamHandleType& teamHandle,
+                            InputIterator first, InputIterator last,
+                            Predicate predicate) {
+  return Impl::all_of_team_impl(teamHandle, first, last, predicate);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool all_of(const TeamHandleType& teamHandle,
+                            const ::Kokkos::View<DataType, Properties...>& v,
+                            Predicate predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::all_of_team_impl(teamHandle, KE::cbegin(v), KE::cend(v),
+                                std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_AnyOf.hpp b/algorithms/src/std_algorithms/Kokkos_AnyOf.hpp
index 019c466c6d..82356e6598 100644
--- a/algorithms/src/std_algorithms/Kokkos_AnyOf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_AnyOf.hpp
@@ -23,41 +23,79 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class Predicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool any_of(const ExecutionSpace& ex, InputIterator first, InputIterator last,
             Predicate predicate) {
-  return Impl::any_of_impl("Kokkos::any_of_view_api_default", ex, first, last,
-                           predicate);
+  return Impl::any_of_exespace_impl("Kokkos::any_of_view_api_default", ex,
+                                    first, last, predicate);
 }
 
-template <class ExecutionSpace, class InputIterator, class Predicate>
+template <
+    typename ExecutionSpace, typename InputIterator, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool any_of(const std::string& label, const ExecutionSpace& ex,
             InputIterator first, InputIterator last, Predicate predicate) {
-  return Impl::any_of_impl(label, ex, first, last, predicate);
+  return Impl::any_of_exespace_impl(label, ex, first, last, predicate);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool any_of(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& v,
             Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::any_of_impl("Kokkos::any_of_view_api_default", ex, KE::cbegin(v),
-                           KE::cend(v), std::move(predicate));
+  return Impl::any_of_exespace_impl("Kokkos::any_of_view_api_default", ex,
+                                    KE::cbegin(v), KE::cend(v),
+                                    std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool any_of(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& v,
             Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::any_of_impl(label, ex, KE::cbegin(v), KE::cend(v),
-                           std::move(predicate));
+  return Impl::any_of_exespace_impl(label, ex, KE::cbegin(v), KE::cend(v),
+                                    std::move(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator, typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool any_of(const TeamHandleType& teamHandle,
+                            InputIterator first, InputIterator last,
+                            Predicate predicate) {
+  return Impl::any_of_team_impl(teamHandle, first, last, predicate);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool any_of(const TeamHandleType& teamHandle,
+                            const ::Kokkos::View<DataType, Properties...>& v,
+                            Predicate predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::any_of_team_impl(teamHandle, KE::cbegin(v), KE::cend(v),
+                                std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Copy.hpp b/algorithms/src/std_algorithms/Kokkos_Copy.hpp
index 028f3b66b2..c5406c72b0 100644
--- a/algorithms/src/std_algorithms/Kokkos_Copy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Copy.hpp
@@ -23,44 +23,83 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator copy(const ExecutionSpace& ex, InputIterator first,
                     InputIterator last, OutputIterator d_first) {
-  return Impl::copy_impl("Kokkos::copy_iterator_api_default", ex, first, last,
-                         d_first);
+  return Impl::copy_exespace_impl("Kokkos::copy_iterator_api_default", ex,
+                                  first, last, d_first);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator copy(const std::string& label, const ExecutionSpace& ex,
                     InputIterator first, InputIterator last,
                     OutputIterator d_first) {
-  return Impl::copy_impl(label, ex, first, last, d_first);
+  return Impl::copy_exespace_impl(label, ex, first, last, d_first);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy(const ExecutionSpace& ex,
           const ::Kokkos::View<DataType1, Properties1...>& source,
-          ::Kokkos::View<DataType2, Properties2...>& dest) {
+          const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::copy_impl("Kokkos::copy_view_api_default", ex,
-                         KE::cbegin(source), KE::cend(source), KE::begin(dest));
+  return Impl::copy_exespace_impl("Kokkos::copy_view_api_default", ex,
+                                  KE::cbegin(source), KE::cend(source),
+                                  KE::begin(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy(const std::string& label, const ExecutionSpace& ex,
           const ::Kokkos::View<DataType1, Properties1...>& source,
-          ::Kokkos::View<DataType2, Properties2...>& dest) {
+          const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::copy_exespace_impl(label, ex, KE::cbegin(source),
+                                  KE::cend(source), KE::begin(dest));
+}
+
+//
+// overload set accepting team handle
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator copy(const TeamHandleType& teamHandle,
+                                    InputIterator first, InputIterator last,
+                                    OutputIterator d_first) {
+  return Impl::copy_team_impl(teamHandle, first, last, d_first);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::copy_impl(label, ex, KE::cbegin(source), KE::cend(source),
-                         KE::begin(dest));
+  return Impl::copy_team_impl(teamHandle, KE::cbegin(source), KE::cend(source),
+                              KE::begin(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_CopyBackward.hpp b/algorithms/src/std_algorithms/Kokkos_CopyBackward.hpp
index deff6baf9a..82071a9362 100644
--- a/algorithms/src/std_algorithms/Kokkos_CopyBackward.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_CopyBackward.hpp
@@ -23,42 +23,81 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType2 copy_backward(const ExecutionSpace& ex, IteratorType1 first,
                             IteratorType1 last, IteratorType2 d_last) {
-  return Impl::copy_backward_impl("Kokkos::copy_backward_iterator_api_default",
-                                  ex, first, last, d_last);
+  return Impl::copy_backward_exespace_impl(
+      "Kokkos::copy_backward_iterator_api_default", ex, first, last, d_last);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType2 copy_backward(const std::string& label, const ExecutionSpace& ex,
                             IteratorType1 first, IteratorType1 last,
                             IteratorType2 d_last) {
-  return Impl::copy_backward_impl(label, ex, first, last, d_last);
+  return Impl::copy_backward_exespace_impl(label, ex, first, last, d_last);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy_backward(const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& source,
-                   ::Kokkos::View<DataType2, Properties2...>& dest) {
+                   const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::copy_backward_impl("Kokkos::copy_backward_view_api_default", ex,
-                                  cbegin(source), cend(source), end(dest));
+  return Impl::copy_backward_exespace_impl(
+      "Kokkos::copy_backward_view_api_default", ex, cbegin(source),
+      cend(source), end(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy_backward(const std::string& label, const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& source,
-                   ::Kokkos::View<DataType2, Properties2...>& dest) {
+                   const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::copy_backward_exespace_impl(label, ex, cbegin(source),
+                                           cend(source), end(dest));
+}
+
+//
+// overload set accepting team handle
+//
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType2 copy_backward(const TeamHandleType& teamHandle,
+                                            IteratorType1 first,
+                                            IteratorType1 last,
+                                            IteratorType2 d_last) {
+  return Impl::copy_backward_team_impl(teamHandle, first, last, d_last);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto copy_backward(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::copy_backward_impl(label, ex, cbegin(source), cend(source),
-                                  end(dest));
+  return Impl::copy_backward_team_impl(teamHandle, cbegin(source), cend(source),
+                                       end(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_CopyIf.hpp b/algorithms/src/std_algorithms/Kokkos_CopyIf.hpp
index 3db2fc074f..599fde5737 100644
--- a/algorithms/src/std_algorithms/Kokkos_CopyIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_CopyIf.hpp
@@ -23,46 +23,87 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class Predicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator copy_if(const ExecutionSpace& ex, InputIterator first,
                        InputIterator last, OutputIterator d_first,
                        Predicate pred) {
-  return Impl::copy_if_impl("Kokkos::copy_if_iterator_api_default", ex, first,
-                            last, d_first, std::move(pred));
+  return Impl::copy_if_exespace_impl("Kokkos::copy_if_iterator_api_default", ex,
+                                     first, last, d_first, std::move(pred));
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator copy_if(const std::string& label, const ExecutionSpace& ex,
                        InputIterator first, InputIterator last,
                        OutputIterator d_first, Predicate pred) {
-  return Impl::copy_if_impl(label, ex, first, last, d_first, std::move(pred));
+  return Impl::copy_if_exespace_impl(label, ex, first, last, d_first,
+                                     std::move(pred));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class Predicate>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy_if(const ExecutionSpace& ex,
              const ::Kokkos::View<DataType1, Properties1...>& source,
-             ::Kokkos::View<DataType2, Properties2...>& dest, Predicate pred) {
+             const ::Kokkos::View<DataType2, Properties2...>& dest,
+             Predicate pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::copy_if_impl("Kokkos::copy_if_view_api_default", ex,
-                            cbegin(source), cend(source), begin(dest),
-                            std::move(pred));
+  return Impl::copy_if_exespace_impl("Kokkos::copy_if_view_api_default", ex,
+                                     cbegin(source), cend(source), begin(dest),
+                                     std::move(pred));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class Predicate>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy_if(const std::string& label, const ExecutionSpace& ex,
              const ::Kokkos::View<DataType1, Properties1...>& source,
-             ::Kokkos::View<DataType2, Properties2...>& dest, Predicate pred) {
+             const ::Kokkos::View<DataType2, Properties2...>& dest,
+             Predicate pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::copy_if_exespace_impl(label, ex, cbegin(source), cend(source),
+                                     begin(dest), std::move(pred));
+}
+
+//
+// overload set accepting team handle
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator, typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator copy_if(const TeamHandleType& teamHandle,
+                                       InputIterator first, InputIterator last,
+                                       OutputIterator d_first, Predicate pred) {
+  return Impl::copy_if_team_impl(teamHandle, first, last, d_first,
+                                 std::move(pred));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto copy_if(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest, Predicate pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::copy_if_impl(label, ex, cbegin(source), cend(source),
-                            begin(dest), std::move(pred));
+  return Impl::copy_if_team_impl(teamHandle, cbegin(source), cend(source),
+                                 begin(dest), std::move(pred));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_CopyN.hpp b/algorithms/src/std_algorithms/Kokkos_CopyN.hpp
index a64f99b5c0..637d8d4cbc 100644
--- a/algorithms/src/std_algorithms/Kokkos_CopyN.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_CopyN.hpp
@@ -23,45 +23,83 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class Size,
-          class OutputIterator>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename Size,
+    typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator copy_n(const ExecutionSpace& ex, InputIterator first, Size count,
                       OutputIterator result) {
-  return Impl::copy_n_impl("Kokkos::copy_n_iterator_api_default", ex, first,
-                           count, result);
+  return Impl::copy_n_exespace_impl("Kokkos::copy_n_iterator_api_default", ex,
+                                    first, count, result);
 }
 
-template <class ExecutionSpace, class InputIterator, class Size,
-          class OutputIterator>
+template <
+    typename ExecutionSpace, typename InputIterator, typename Size,
+    typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator copy_n(const std::string& label, const ExecutionSpace& ex,
                       InputIterator first, Size count, OutputIterator result) {
-  return Impl::copy_n_impl(label, ex, first, count, result);
+  return Impl::copy_n_exespace_impl(label, ex, first, count, result);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class Size, class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename Size, typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy_n(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType1, Properties1...>& source, Size count,
-            ::Kokkos::View<DataType2, Properties2...>& dest) {
+            const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::copy_n_impl("Kokkos::copy_n_view_api_default", ex,
-                           KE::cbegin(source), count, KE::begin(dest));
+  return Impl::copy_n_exespace_impl("Kokkos::copy_n_view_api_default", ex,
+                                    KE::cbegin(source), count, KE::begin(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class Size, class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename Size, typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto copy_n(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType1, Properties1...>& source, Size count,
-            ::Kokkos::View<DataType2, Properties2...>& dest) {
+            const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::copy_n_exespace_impl(label, ex, KE::cbegin(source), count,
+                                    KE::begin(dest));
+}
+
+//
+// overload set accepting team handle
+//
+template <typename TeamHandleType, typename InputIterator, typename Size,
+          typename OutputIterator,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator copy_n(const TeamHandleType& teamHandle,
+                                      InputIterator first, Size count,
+                                      OutputIterator result) {
+  return Impl::copy_n_team_impl(teamHandle, first, count, result);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename Size, typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto copy_n(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source, Size count,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::copy_n_impl(label, ex, KE::cbegin(source), count,
-                           KE::begin(dest));
+  return Impl::copy_n_team_impl(teamHandle, KE::cbegin(source), count,
+                                KE::begin(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Count.hpp b/algorithms/src/std_algorithms/Kokkos_Count.hpp
index 3ac63467ec..f179e88bab 100644
--- a/algorithms/src/std_algorithms/Kokkos_Count.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Count.hpp
@@ -23,41 +23,81 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class T>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 typename IteratorType::difference_type count(const ExecutionSpace& ex,
                                              IteratorType first,
                                              IteratorType last,
                                              const T& value) {
-  return Impl::count_impl("Kokkos::count_iterator_api_default", ex, first, last,
-                          value);
+  return Impl::count_exespace_impl("Kokkos::count_iterator_api_default", ex,
+                                   first, last, value);
 }
 
-template <class ExecutionSpace, class IteratorType, class T>
+template <
+    typename ExecutionSpace, typename IteratorType, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 typename IteratorType::difference_type count(const std::string& label,
                                              const ExecutionSpace& ex,
                                              IteratorType first,
                                              IteratorType last,
                                              const T& value) {
-  return Impl::count_impl(label, ex, first, last, value);
+  return Impl::count_exespace_impl(label, ex, first, last, value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto count(const ExecutionSpace& ex,
            const ::Kokkos::View<DataType, Properties...>& v, const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::count_impl("Kokkos::count_view_api_default", ex, KE::cbegin(v),
-                          KE::cend(v), value);
+  return Impl::count_exespace_impl("Kokkos::count_view_api_default", ex,
+                                   KE::cbegin(v), KE::cend(v), value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto count(const std::string& label, const ExecutionSpace& ex,
            const ::Kokkos::View<DataType, Properties...>& v, const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::count_impl(label, ex, KE::cbegin(v), KE::cend(v), value);
+  return Impl::count_exespace_impl(label, ex, KE::cbegin(v), KE::cend(v),
+                                   value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+template <typename TeamHandleType, typename IteratorType, typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION typename IteratorType::difference_type count(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    const T& value) {
+  return Impl::count_team_impl(teamHandle, first, last, value);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto count(const TeamHandleType& teamHandle,
+                           const ::Kokkos::View<DataType, Properties...>& v,
+                           const T& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::count_team_impl(teamHandle, KE::cbegin(v), KE::cend(v), value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_CountIf.hpp b/algorithms/src/std_algorithms/Kokkos_CountIf.hpp
index b9731d378a..967cf75e7a 100644
--- a/algorithms/src/std_algorithms/Kokkos_CountIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_CountIf.hpp
@@ -23,46 +23,84 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class Predicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 typename IteratorType::difference_type count_if(const ExecutionSpace& ex,
                                                 IteratorType first,
                                                 IteratorType last,
                                                 Predicate predicate) {
-  return Impl::count_if_impl("Kokkos::count_if_iterator_api_default", ex, first,
-                             last, std::move(predicate));
+  return Impl::count_if_exespace_impl("Kokkos::count_if_iterator_api_default",
+                                      ex, first, last, std::move(predicate));
 }
 
-template <class ExecutionSpace, class IteratorType, class Predicate>
+template <
+    typename ExecutionSpace, typename IteratorType, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 typename IteratorType::difference_type count_if(const std::string& label,
                                                 const ExecutionSpace& ex,
                                                 IteratorType first,
                                                 IteratorType last,
                                                 Predicate predicate) {
-  return Impl::count_if_impl(label, ex, first, last, std::move(predicate));
+  return Impl::count_if_exespace_impl(label, ex, first, last,
+                                      std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto count_if(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& v,
               Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::count_if_impl("Kokkos::count_if_view_api_default", ex,
-                             KE::cbegin(v), KE::cend(v), std::move(predicate));
+  return Impl::count_if_exespace_impl("Kokkos::count_if_view_api_default", ex,
+                                      KE::cbegin(v), KE::cend(v),
+                                      std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto count_if(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& v,
               Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::count_if_impl(label, ex, KE::cbegin(v), KE::cend(v),
-                             std::move(predicate));
+  return Impl::count_if_exespace_impl(label, ex, KE::cbegin(v), KE::cend(v),
+                                      std::move(predicate));
+}
+
+//
+// overload set accepting team handle
+//
+template <typename TeamHandleType, typename IteratorType, typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION typename IteratorType::difference_type count_if(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    Predicate predicate) {
+  return Impl::count_if_team_impl(teamHandle, first, last,
+                                  std::move(predicate));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto count_if(const TeamHandleType& teamHandle,
+                              const ::Kokkos::View<DataType, Properties...>& v,
+                              Predicate predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::count_if_team_impl(teamHandle, KE::cbegin(v), KE::cend(v),
+                                  std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Equal.hpp b/algorithms/src/std_algorithms/Kokkos_Equal.hpp
index 37c0d75ef5..593c42f87e 100644
--- a/algorithms/src/std_algorithms/Kokkos_Equal.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Equal.hpp
@@ -23,145 +23,260 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
-      IteratorType2 first2) {
-  return Impl::equal_impl("Kokkos::equal_iterator_api_default", ex, first1,
-                          last1, first2);
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
-      IteratorType1 last1, IteratorType2 first2) {
-  return Impl::equal_impl(label, ex, first1, last1, first2);
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
-      IteratorType2 first2, BinaryPredicateType predicate) {
-  return Impl::equal_impl("Kokkos::equal_iterator_api_default", ex, first1,
-                          last1, first2, std::move(predicate));
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
-      IteratorType1 last1, IteratorType2 first2,
-      BinaryPredicateType predicate) {
-  return Impl::equal_impl(label, ex, first1, last1, first2,
-                          std::move(predicate));
-}
-
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+//
+// overload set accepting execution space
+//
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2> &&
+                               Kokkos::is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
+           IteratorType2 first2) {
+  return Impl::equal_exespace_impl("Kokkos::equal_iterator_api_default", ex,
+                                   first1, last1, first2);
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const std::string& label, const ExecutionSpace& ex,
+           IteratorType1 first1, IteratorType1 last1, IteratorType2 first2) {
+  return Impl::equal_exespace_impl(label, ex, first1, last1, first2);
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
+           IteratorType2 first2, BinaryPredicateType predicate) {
+  return Impl::equal_exespace_impl("Kokkos::equal_iterator_api_default", ex,
+                                   first1, last1, first2, std::move(predicate));
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const std::string& label, const ExecutionSpace& ex,
+           IteratorType1 first1, IteratorType1 last1, IteratorType2 first2,
+           BinaryPredicateType predicate) {
+  return Impl::equal_exespace_impl(label, ex, first1, last1, first2,
+                                   std::move(predicate));
+}
+
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool equal(const ExecutionSpace& ex,
            const ::Kokkos::View<DataType1, Properties1...>& view1,
-           ::Kokkos::View<DataType2, Properties2...>& view2) {
+           const ::Kokkos::View<DataType2, Properties2...>& view2) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::equal_impl("Kokkos::equal_view_api_default", ex,
-                          KE::cbegin(view1), KE::cend(view1),
-                          KE::cbegin(view2));
+  return Impl::equal_exespace_impl("Kokkos::equal_view_api_default", ex,
+                                   KE::cbegin(view1), KE::cend(view1),
+                                   KE::cbegin(view2));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool equal(const std::string& label, const ExecutionSpace& ex,
            const ::Kokkos::View<DataType1, Properties1...>& view1,
-           ::Kokkos::View<DataType2, Properties2...>& view2) {
+           const ::Kokkos::View<DataType2, Properties2...>& view2) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::equal_impl(label, ex, KE::cbegin(view1), KE::cend(view1),
-                          KE::cbegin(view2));
+  return Impl::equal_exespace_impl(label, ex, KE::cbegin(view1),
+                                   KE::cend(view1), KE::cbegin(view2));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool equal(const ExecutionSpace& ex,
            const ::Kokkos::View<DataType1, Properties1...>& view1,
-           ::Kokkos::View<DataType2, Properties2...>& view2,
+           const ::Kokkos::View<DataType2, Properties2...>& view2,
            BinaryPredicateType predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::equal_impl("Kokkos::equal_view_api_default", ex,
-                          KE::cbegin(view1), KE::cend(view1), KE::cbegin(view2),
-                          std::move(predicate));
+  return Impl::equal_exespace_impl("Kokkos::equal_view_api_default", ex,
+                                   KE::cbegin(view1), KE::cend(view1),
+                                   KE::cbegin(view2), std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool equal(const std::string& label, const ExecutionSpace& ex,
            const ::Kokkos::View<DataType1, Properties1...>& view1,
-           ::Kokkos::View<DataType2, Properties2...>& view2,
+           const ::Kokkos::View<DataType2, Properties2...>& view2,
+           BinaryPredicateType predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::equal_exespace_impl(label, ex, KE::cbegin(view1),
+                                   KE::cend(view1), KE::cbegin(view2),
+                                   std::move(predicate));
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
+           IteratorType2 first2, IteratorType2 last2) {
+  return Impl::equal_exespace_impl("Kokkos::equal_iterator_api_default", ex,
+                                   first1, last1, first2, last2);
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const std::string& label, const ExecutionSpace& ex,
+           IteratorType1 first1, IteratorType1 last1, IteratorType2 first2,
+           IteratorType2 last2) {
+  return Impl::equal_exespace_impl(label, ex, first1, last1, first2, last2);
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
+           IteratorType2 first2, IteratorType2 last2,
            BinaryPredicateType predicate) {
+  return Impl::equal_exespace_impl("Kokkos::equal_iterator_api_default", ex,
+                                   first1, last1, first2, last2,
+                                   std::move(predicate));
+}
+
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_execution_space_v<ExecutionSpace>,
+                           int> = 0>
+bool equal(const std::string& label, const ExecutionSpace& ex,
+           IteratorType1 first1, IteratorType1 last1, IteratorType2 first2,
+           IteratorType2 last2, BinaryPredicateType predicate) {
+  return Impl::equal_exespace_impl(label, ex, first1, last1, first2, last2,
+                                   std::move(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_team_handle_v<TeamHandleType>,
+                           int> = 0>
+KOKKOS_FUNCTION bool equal(const TeamHandleType& teamHandle,
+                           IteratorType1 first1, IteratorType1 last1,
+                           IteratorType2 first2) {
+  return Impl::equal_team_impl(teamHandle, first1, last1, first2);
+}
+
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_team_handle_v<TeamHandleType>,
+                           int> = 0>
+KOKKOS_FUNCTION bool equal(const TeamHandleType& teamHandle,
+                           IteratorType1 first1, IteratorType1 last1,
+                           IteratorType2 first2,
+                           BinaryPredicateType predicate) {
+  return Impl::equal_team_impl(teamHandle, first1, last1, first2,
+                               std::move(predicate));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool equal(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view1,
+    const ::Kokkos::View<DataType2, Properties2...>& view2) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::equal_impl(label, ex, KE::cbegin(view1), KE::cend(view1),
-                          KE::cbegin(view2), std::move(predicate));
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
-      IteratorType2 first2, IteratorType2 last2) {
-  return Impl::equal_impl("Kokkos::equal_iterator_api_default", ex, first1,
-                          last1, first2, last2);
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
-      IteratorType1 last1, IteratorType2 first2, IteratorType2 last2) {
-  return Impl::equal_impl(label, ex, first1, last1, first2, last2);
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
-      IteratorType2 first2, IteratorType2 last2,
-      BinaryPredicateType predicate) {
-  return Impl::equal_impl("Kokkos::equal_iterator_api_default", ex, first1,
-                          last1, first2, last2, std::move(predicate));
-}
-
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      IteratorType1, IteratorType2>::value,
-                  bool>
-equal(const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
-      IteratorType1 last1, IteratorType2 first2, IteratorType2 last2,
-      BinaryPredicateType predicate) {
-  return Impl::equal_impl(label, ex, first1, last1, first2, last2,
-                          std::move(predicate));
+  return Impl::equal_team_impl(teamHandle, KE::cbegin(view1), KE::cend(view1),
+                               KE::cbegin(view2));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool equal(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view1,
+    const ::Kokkos::View<DataType2, Properties2...>& view2,
+    BinaryPredicateType predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::equal_team_impl(teamHandle, KE::cbegin(view1), KE::cend(view1),
+                               KE::cbegin(view2), std::move(predicate));
+}
+
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_team_handle_v<TeamHandleType>,
+                           int> = 0>
+KOKKOS_FUNCTION bool equal(const TeamHandleType& teamHandle,
+                           IteratorType1 first1, IteratorType1 last1,
+                           IteratorType2 first2, IteratorType2 last2) {
+  return Impl::equal_team_impl(teamHandle, first1, last1, first2, last2);
+}
+
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators_v<
+                               IteratorType1, IteratorType2>&& ::Kokkos::
+                               is_team_handle_v<TeamHandleType>,
+                           int> = 0>
+KOKKOS_FUNCTION bool equal(const TeamHandleType& teamHandle,
+                           IteratorType1 first1, IteratorType1 last1,
+                           IteratorType2 first2, IteratorType2 last2,
+                           BinaryPredicateType predicate) {
+  return Impl::equal_team_impl(teamHandle, first1, last1, first2, last2,
+                               std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ExclusiveScan.hpp b/algorithms/src/std_algorithms/Kokkos_ExclusiveScan.hpp
index 4e05676c2c..ee3a105126 100644
--- a/algorithms/src/std_algorithms/Kokkos_ExclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ExclusiveScan.hpp
@@ -23,105 +23,130 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-exclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-               InputIteratorType last, OutputIteratorType first_dest,
-               ValueType init_value) {
-  static_assert(std::is_move_constructible<ValueType>::value,
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType exclusive_scan(const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  ValueType init_value) {
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
-  return Impl::exclusive_scan_default_op_impl(
+  return Impl::exclusive_scan_default_op_exespace_impl(
       "Kokkos::exclusive_scan_default_functors_iterator_api", ex, first, last,
-      first_dest, init_value);
+      first_dest, std::move(init_value));
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-exclusive_scan(const std::string& label, const ExecutionSpace& ex,
-               InputIteratorType first, InputIteratorType last,
-               OutputIteratorType first_dest, ValueType init_value) {
-  static_assert(std::is_move_constructible<ValueType>::value,
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType exclusive_scan(const std::string& label,
+                                  const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  ValueType init_value) {
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
-  return Impl::exclusive_scan_default_op_impl(label, ex, first, last,
-                                              first_dest, init_value);
+  return Impl::exclusive_scan_default_op_exespace_impl(
+      label, ex, first, last, first_dest, std::move(init_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto exclusive_scan(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
                     ValueType init_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
   namespace KE = ::Kokkos::Experimental;
-  return Impl::exclusive_scan_default_op_impl(
+  return Impl::exclusive_scan_default_op_exespace_impl(
       "Kokkos::exclusive_scan_default_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
-      init_value);
+      std::move(init_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto exclusive_scan(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
                     ValueType init_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
   namespace KE = ::Kokkos::Experimental;
-  return Impl::exclusive_scan_default_op_impl(label, ex, KE::cbegin(view_from),
-                                              KE::cend(view_from),
-                                              KE::begin(view_dest), init_value);
+  return Impl::exclusive_scan_default_op_exespace_impl(
+      label, ex, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), std::move(init_value));
 }
 
 // overload set 2
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType, class BinaryOpType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-exclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-               InputIteratorType last, OutputIteratorType first_dest,
-               ValueType init_value, BinaryOpType bop) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          typename BinaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType exclusive_scan(const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  ValueType init_value, BinaryOpType bop) {
   Impl::static_assert_is_not_openmptarget(ex);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
-  return Impl::exclusive_scan_custom_op_impl(
+  return Impl::exclusive_scan_custom_op_exespace_impl(
       "Kokkos::exclusive_scan_custom_functors_iterator_api", ex, first, last,
-      first_dest, init_value, bop);
+      first_dest, std::move(init_value), bop);
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType, class BinaryOpType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-exclusive_scan(const std::string& label, const ExecutionSpace& ex,
-               InputIteratorType first, InputIteratorType last,
-               OutputIteratorType first_dest, ValueType init_value,
-               BinaryOpType bop) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          typename BinaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType exclusive_scan(const std::string& label,
+                                  const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  ValueType init_value, BinaryOpType bop) {
   Impl::static_assert_is_not_openmptarget(ex);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
-  return Impl::exclusive_scan_custom_op_impl(label, ex, first, last, first_dest,
-                                             init_value, bop);
+  return Impl::exclusive_scan_custom_op_exespace_impl(
+      label, ex, first, last, first_dest, std::move(init_value), bop);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType,
-          class BinaryOpType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    typename BinaryOpType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto exclusive_scan(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -129,18 +154,20 @@ auto exclusive_scan(const ExecutionSpace& ex,
   Impl::static_assert_is_not_openmptarget(ex);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
   namespace KE = ::Kokkos::Experimental;
-  return Impl::exclusive_scan_custom_op_impl(
+  return Impl::exclusive_scan_custom_op_exespace_impl(
       "Kokkos::exclusive_scan_custom_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
-      init_value, bop);
+      std::move(init_value), bop);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType,
-          class BinaryOpType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    typename BinaryOpType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto exclusive_scan(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -148,12 +175,92 @@ auto exclusive_scan(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_not_openmptarget(ex);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
   namespace KE = ::Kokkos::Experimental;
-  return Impl::exclusive_scan_custom_op_impl(
+  return Impl::exclusive_scan_custom_op_exespace_impl(
       label, ex, KE::cbegin(view_from), KE::cend(view_from),
-      KE::begin(view_dest), init_value, bop);
+      KE::begin(view_dest), std::move(init_value), bop);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType> &&
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType
+exclusive_scan(const TeamHandleType& teamHandle, InputIteratorType first,
+               InputIteratorType last, OutputIteratorType first_dest,
+               ValueType init_value) {
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  return Impl::exclusive_scan_default_op_team_impl(
+      teamHandle, first, last, first_dest, std::move(init_value));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto exclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    ValueType init_value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::exclusive_scan_default_op_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), std::move(init_value));
+}
+
+// overload set 2
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          typename BinaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType> &&
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType
+exclusive_scan(const TeamHandleType& teamHandle, InputIteratorType first,
+               InputIteratorType last, OutputIteratorType first_dest,
+               ValueType init_value, BinaryOpType bop) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  return Impl::exclusive_scan_custom_op_team_impl(
+      teamHandle, first, last, first_dest, std::move(init_value), bop);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          typename BinaryOpType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto exclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    ValueType init_value, BinaryOpType bop) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::exclusive_scan_custom_op_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), std::move(init_value), bop);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Fill.hpp b/algorithms/src/std_algorithms/Kokkos_Fill.hpp
index 1e300a4c20..6d805ba1be 100644
--- a/algorithms/src/std_algorithms/Kokkos_Fill.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Fill.hpp
@@ -23,33 +23,67 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class T>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void fill(const ExecutionSpace& ex, IteratorType first, IteratorType last,
           const T& value) {
-  Impl::fill_impl("Kokkos::fill_iterator_api_default", ex, first, last, value);
+  Impl::fill_exespace_impl("Kokkos::fill_iterator_api_default", ex, first, last,
+                           value);
 }
 
-template <class ExecutionSpace, class IteratorType, class T>
+template <
+    typename ExecutionSpace, typename IteratorType, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void fill(const std::string& label, const ExecutionSpace& ex,
           IteratorType first, IteratorType last, const T& value) {
-  Impl::fill_impl(label, ex, first, last, value);
+  Impl::fill_exespace_impl(label, ex, first, last, value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void fill(const ExecutionSpace& ex,
           const ::Kokkos::View<DataType, Properties...>& view, const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-
-  Impl::fill_impl("Kokkos::fill_view_api_default", ex, begin(view), end(view),
-                  value);
+  Impl::fill_exespace_impl("Kokkos::fill_view_api_default", ex, begin(view),
+                           end(view), value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void fill(const std::string& label, const ExecutionSpace& ex,
           const ::Kokkos::View<DataType, Properties...>& view, const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::fill_exespace_impl(label, ex, begin(view), end(view), value);
+}
 
-  Impl::fill_impl(label, ex, begin(view), end(view), value);
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType, typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void fill(const TeamHandleType& th, IteratorType first,
+                          IteratorType last, const T& value) {
+  Impl::fill_team_impl(th, first, last, value);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void fill(const TeamHandleType& th,
+                          const ::Kokkos::View<DataType, Properties...>& view,
+                          const T& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::fill_team_impl(th, begin(view), end(view), value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_FillN.hpp b/algorithms/src/std_algorithms/Kokkos_FillN.hpp
index 02503dfd14..66b8cd66cc 100644
--- a/algorithms/src/std_algorithms/Kokkos_FillN.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_FillN.hpp
@@ -23,38 +23,72 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class SizeType, class T>
+template <
+    typename ExecutionSpace, typename IteratorType, typename SizeType,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType fill_n(const ExecutionSpace& ex, IteratorType first, SizeType n,
                     const T& value) {
-  return Impl::fill_n_impl("Kokkos::fill_n_iterator_api_default", ex, first, n,
-                           value);
+  return Impl::fill_n_exespace_impl("Kokkos::fill_n_iterator_api_default", ex,
+                                    first, n, value);
 }
 
-template <class ExecutionSpace, class IteratorType, class SizeType, class T>
+template <
+    typename ExecutionSpace, typename IteratorType, typename SizeType,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType fill_n(const std::string& label, const ExecutionSpace& ex,
                     IteratorType first, SizeType n, const T& value) {
-  return Impl::fill_n_impl(label, ex, first, n, value);
+  return Impl::fill_n_exespace_impl(label, ex, first, n, value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename SizeType, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto fill_n(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view, SizeType n,
             const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::fill_n_impl("Kokkos::fill_n_view_api_default", ex, begin(view),
-                           n, value);
+  return Impl::fill_n_exespace_impl("Kokkos::fill_n_view_api_default", ex,
+                                    begin(view), n, value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename SizeType, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto fill_n(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view, SizeType n,
             const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::fill_n_impl(label, ex, begin(view), n, value);
+  return Impl::fill_n_exespace_impl(label, ex, begin(view), n, value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType, typename SizeType,
+          typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType fill_n(const TeamHandleType& th,
+                                    IteratorType first, SizeType n,
+                                    const T& value) {
+  return Impl::fill_n_team_impl(th, first, n, value);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename SizeType, typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto fill_n(const TeamHandleType& th,
+                            const ::Kokkos::View<DataType, Properties...>& view,
+                            SizeType n, const T& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  return Impl::fill_n_team_impl(th, begin(view), n, value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Find.hpp b/algorithms/src/std_algorithms/Kokkos_Find.hpp
index 65b68cf931..e5e2b0e2b0 100644
--- a/algorithms/src/std_algorithms/Kokkos_Find.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Find.hpp
@@ -23,36 +23,76 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class T>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 InputIterator find(const ExecutionSpace& ex, InputIterator first,
                    InputIterator last, const T& value) {
-  return Impl::find_impl("Kokkos::find_iterator_api_default", ex, first, last,
-                         value);
+  return Impl::find_exespace_impl("Kokkos::find_iterator_api_default", ex,
+                                  first, last, value);
 }
 
-template <class ExecutionSpace, class InputIterator, class T>
+template <
+    typename ExecutionSpace, typename InputIterator, typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 InputIterator find(const std::string& label, const ExecutionSpace& ex,
                    InputIterator first, InputIterator last, const T& value) {
-  return Impl::find_impl(label, ex, first, last, value);
+  return Impl::find_exespace_impl(label, ex, first, last, value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find(const ExecutionSpace& ex,
           const ::Kokkos::View<DataType, Properties...>& view, const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_impl("Kokkos::find_view_api_default", ex, KE::begin(view),
-                         KE::end(view), value);
+  return Impl::find_exespace_impl("Kokkos::find_view_api_default", ex,
+                                  KE::begin(view), KE::end(view), value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class T>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename T,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find(const std::string& label, const ExecutionSpace& ex,
           const ::Kokkos::View<DataType, Properties...>& view, const T& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_impl(label, ex, KE::begin(view), KE::end(view), value);
+  return Impl::find_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                  value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator, typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION InputIterator find(const TeamHandleType& teamHandle,
+                                   InputIterator first, InputIterator last,
+                                   const T& value) {
+  return Impl::find_team_impl(teamHandle, first, last, value);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename T,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto find(const TeamHandleType& teamHandle,
+                          const ::Kokkos::View<DataType, Properties...>& view,
+                          const T& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                              value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_FindEnd.hpp b/algorithms/src/std_algorithms/Kokkos_FindEnd.hpp
index f6a38855eb..a4ec735fd5 100644
--- a/algorithms/src/std_algorithms/Kokkos_FindEnd.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_FindEnd.hpp
@@ -24,24 +24,34 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1: no binary predicate passed
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_end(const ExecutionSpace& ex, IteratorType1 first,
                        IteratorType1 last, IteratorType2 s_first,
                        IteratorType2 s_last) {
-  return Impl::find_end_impl("Kokkos::find_end_iterator_api_default", ex, first,
-                             last, s_first, s_last);
+  return Impl::find_end_exespace_impl("Kokkos::find_end_iterator_api_default",
+                                      ex, first, last, s_first, s_last);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_end(const std::string& label, const ExecutionSpace& ex,
                        IteratorType1 first, IteratorType1 last,
                        IteratorType2 s_first, IteratorType2 s_last) {
-  return Impl::find_end_impl(label, ex, first, last, s_first, s_last);
+  return Impl::find_end_exespace_impl(label, ex, first, last, s_first, s_last);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_end(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view,
               const ::Kokkos::View<DataType2, Properties2...>& s_view) {
@@ -49,13 +59,15 @@ auto find_end(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_end_impl("Kokkos::find_end_view_api_default", ex,
-                             KE::begin(view), KE::end(view), KE::begin(s_view),
-                             KE::end(s_view));
+  return Impl::find_end_exespace_impl("Kokkos::find_end_view_api_default", ex,
+                                      KE::begin(view), KE::end(view),
+                                      KE::begin(s_view), KE::end(s_view));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_end(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view,
               const ::Kokkos::View<DataType2, Properties2...>& s_view) {
@@ -63,31 +75,38 @@ auto find_end(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_end_impl(label, ex, KE::begin(view), KE::end(view),
-                             KE::begin(s_view), KE::end(s_view));
+  return Impl::find_end_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                      KE::begin(s_view), KE::end(s_view));
 }
 
 // overload set 2: binary predicate passed
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_end(const ExecutionSpace& ex, IteratorType1 first,
                        IteratorType1 last, IteratorType2 s_first,
                        IteratorType2 s_last, const BinaryPredicateType& pred) {
-  return Impl::find_end_impl("Kokkos::find_end_iterator_api_default", ex, first,
-                             last, s_first, s_last, pred);
+  return Impl::find_end_exespace_impl("Kokkos::find_end_iterator_api_default",
+                                      ex, first, last, s_first, s_last, pred);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_end(const std::string& label, const ExecutionSpace& ex,
                        IteratorType1 first, IteratorType1 last,
                        IteratorType2 s_first, IteratorType2 s_last,
                        const BinaryPredicateType& pred) {
-  return Impl::find_end_impl(label, ex, first, last, s_first, s_last, pred);
+  return Impl::find_end_exespace_impl(label, ex, first, last, s_first, s_last,
+                                      pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_end(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view,
               const ::Kokkos::View<DataType2, Properties2...>& s_view,
@@ -96,13 +115,15 @@ auto find_end(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_end_impl("Kokkos::find_end_view_api_default", ex,
-                             KE::begin(view), KE::end(view), KE::begin(s_view),
-                             KE::end(s_view), pred);
+  return Impl::find_end_exespace_impl("Kokkos::find_end_view_api_default", ex,
+                                      KE::begin(view), KE::end(view),
+                                      KE::begin(s_view), KE::end(s_view), pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_end(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view,
               const ::Kokkos::View<DataType2, Properties2...>& s_view,
@@ -111,8 +132,71 @@ auto find_end(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_end_impl(label, ex, KE::begin(view), KE::end(view),
-                             KE::begin(s_view), KE::end(s_view), pred);
+  return Impl::find_end_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                      KE::begin(s_view), KE::end(s_view), pred);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1: no binary predicate passed
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType1 find_end(const TeamHandleType& teamHandle,
+                                       IteratorType1 first, IteratorType1 last,
+                                       IteratorType2 s_first,
+                                       IteratorType2 s_last) {
+  return Impl::find_end_team_impl(teamHandle, first, last, s_first, s_last);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto find_end(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ::Kokkos::View<DataType2, Properties2...>& s_view) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_end_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                                  KE::begin(s_view), KE::end(s_view));
+}
+
+// overload set 2: binary predicate passed
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+
+KOKKOS_FUNCTION IteratorType1 find_end(const TeamHandleType& teamHandle,
+                                       IteratorType1 first, IteratorType1 last,
+                                       IteratorType2 s_first,
+                                       IteratorType2 s_last,
+                                       const BinaryPredicateType& pred) {
+  return Impl::find_end_team_impl(teamHandle, first, last, s_first, s_last,
+                                  pred);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto find_end(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ::Kokkos::View<DataType2, Properties2...>& s_view,
+    const BinaryPredicateType& pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_end_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                                  KE::begin(s_view), KE::end(s_view), pred);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_FindFirstOf.hpp b/algorithms/src/std_algorithms/Kokkos_FindFirstOf.hpp
index 6b0e4993ee..341a70e2f2 100644
--- a/algorithms/src/std_algorithms/Kokkos_FindFirstOf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_FindFirstOf.hpp
@@ -23,24 +23,36 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1: no binary predicate passed
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_first_of(const ExecutionSpace& ex, IteratorType1 first,
                             IteratorType1 last, IteratorType2 s_first,
                             IteratorType2 s_last) {
-  return Impl::find_first_of_impl("Kokkos::find_first_of_iterator_api_default",
-                                  ex, first, last, s_first, s_last);
+  return Impl::find_first_of_exespace_impl(
+      "Kokkos::find_first_of_iterator_api_default", ex, first, last, s_first,
+      s_last);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_first_of(const std::string& label, const ExecutionSpace& ex,
                             IteratorType1 first, IteratorType1 last,
                             IteratorType2 s_first, IteratorType2 s_last) {
-  return Impl::find_first_of_impl(label, ex, first, last, s_first, s_last);
+  return Impl::find_first_of_exespace_impl(label, ex, first, last, s_first,
+                                           s_last);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_first_of(const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& view,
                    const ::Kokkos::View<DataType2, Properties2...>& s_view) {
@@ -48,13 +60,15 @@ auto find_first_of(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_first_of_impl("Kokkos::find_first_of_view_api_default", ex,
-                                  KE::begin(view), KE::end(view),
-                                  KE::begin(s_view), KE::end(s_view));
+  return Impl::find_first_of_exespace_impl(
+      "Kokkos::find_first_of_view_api_default", ex, KE::begin(view),
+      KE::end(view), KE::begin(s_view), KE::end(s_view));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_first_of(const std::string& label, const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& view,
                    const ::Kokkos::View<DataType2, Properties2...>& s_view) {
@@ -62,33 +76,41 @@ auto find_first_of(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_first_of_impl(label, ex, KE::begin(view), KE::end(view),
-                                  KE::begin(s_view), KE::end(s_view));
+  return Impl::find_first_of_exespace_impl(label, ex, KE::begin(view),
+                                           KE::end(view), KE::begin(s_view),
+                                           KE::end(s_view));
 }
 
 // overload set 2: binary predicate passed
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_first_of(const ExecutionSpace& ex, IteratorType1 first,
                             IteratorType1 last, IteratorType2 s_first,
                             IteratorType2 s_last,
                             const BinaryPredicateType& pred) {
-  return Impl::find_first_of_impl("Kokkos::find_first_of_iterator_api_default",
-                                  ex, first, last, s_first, s_last, pred);
+  return Impl::find_first_of_exespace_impl(
+      "Kokkos::find_first_of_iterator_api_default", ex, first, last, s_first,
+      s_last, pred);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 find_first_of(const std::string& label, const ExecutionSpace& ex,
                             IteratorType1 first, IteratorType1 last,
                             IteratorType2 s_first, IteratorType2 s_last,
                             const BinaryPredicateType& pred) {
-  return Impl::find_first_of_impl(label, ex, first, last, s_first, s_last,
-                                  pred);
+  return Impl::find_first_of_exespace_impl(label, ex, first, last, s_first,
+                                           s_last, pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_first_of(const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& view,
                    const ::Kokkos::View<DataType2, Properties2...>& s_view,
@@ -97,13 +119,15 @@ auto find_first_of(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_first_of_impl("Kokkos::find_first_of_view_api_default", ex,
-                                  KE::begin(view), KE::end(view),
-                                  KE::begin(s_view), KE::end(s_view), pred);
+  return Impl::find_first_of_exespace_impl(
+      "Kokkos::find_first_of_view_api_default", ex, KE::begin(view),
+      KE::end(view), KE::begin(s_view), KE::end(s_view), pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto find_first_of(const std::string& label, const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& view,
                    const ::Kokkos::View<DataType2, Properties2...>& s_view,
@@ -112,8 +136,77 @@ auto find_first_of(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_first_of_impl(label, ex, KE::begin(view), KE::end(view),
-                                  KE::begin(s_view), KE::end(s_view), pred);
+  return Impl::find_first_of_exespace_impl(label, ex, KE::begin(view),
+                                           KE::end(view), KE::begin(s_view),
+                                           KE::end(s_view), pred);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1: no binary predicate passed
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType1 find_first_of(const TeamHandleType& teamHandle,
+                                            IteratorType1 first,
+                                            IteratorType1 last,
+                                            IteratorType2 s_first,
+                                            IteratorType2 s_last) {
+  return Impl::find_first_of_team_impl(teamHandle, first, last, s_first,
+                                       s_last);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto find_first_of(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ::Kokkos::View<DataType2, Properties2...>& s_view) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_first_of_team_impl(teamHandle, KE::begin(view),
+                                       KE::end(view), KE::begin(s_view),
+                                       KE::end(s_view));
+}
+
+// overload set 2: binary predicate passed
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+
+KOKKOS_FUNCTION IteratorType1 find_first_of(const TeamHandleType& teamHandle,
+                                            IteratorType1 first,
+                                            IteratorType1 last,
+                                            IteratorType2 s_first,
+                                            IteratorType2 s_last,
+                                            const BinaryPredicateType& pred) {
+  return Impl::find_first_of_team_impl(teamHandle, first, last, s_first, s_last,
+                                       pred);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto find_first_of(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ::Kokkos::View<DataType2, Properties2...>& s_view,
+    const BinaryPredicateType& pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_first_of_team_impl(teamHandle, KE::begin(view),
+                                       KE::end(view), KE::begin(s_view),
+                                       KE::end(s_view), pred);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_FindIf.hpp b/algorithms/src/std_algorithms/Kokkos_FindIf.hpp
index 911316a668..283fab7617 100644
--- a/algorithms/src/std_algorithms/Kokkos_FindIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_FindIf.hpp
@@ -23,42 +23,82 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class PredicateType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType find_if(const ExecutionSpace& ex, IteratorType first,
                      IteratorType last, PredicateType predicate) {
-  return Impl::find_if_or_not_impl<true>("Kokkos::find_if_iterator_api_default",
-                                         ex, first, last, std::move(predicate));
+  return Impl::find_if_or_not_exespace_impl<true>(
+      "Kokkos::find_if_iterator_api_default", ex, first, last,
+      std::move(predicate));
 }
 
-template <class ExecutionSpace, class IteratorType, class PredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType find_if(const std::string& label, const ExecutionSpace& ex,
                      IteratorType first, IteratorType last,
                      PredicateType predicate) {
-  return Impl::find_if_or_not_impl<true>(label, ex, first, last,
-                                         std::move(predicate));
+  return Impl::find_if_or_not_exespace_impl<true>(label, ex, first, last,
+                                                  std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto find_if(const ExecutionSpace& ex,
              const ::Kokkos::View<DataType, Properties...>& v,
              Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_if_or_not_impl<true>("Kokkos::find_if_view_api_default", ex,
-                                         KE::begin(v), KE::end(v),
-                                         std::move(predicate));
+  return Impl::find_if_or_not_exespace_impl<true>(
+      "Kokkos::find_if_view_api_default", ex, KE::begin(v), KE::end(v),
+      std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto find_if(const std::string& label, const ExecutionSpace& ex,
              const ::Kokkos::View<DataType, Properties...>& v,
              Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_if_or_not_impl<true>(label, ex, KE::begin(v), KE::end(v),
-                                         std::move(predicate));
+  return Impl::find_if_or_not_exespace_impl<true>(
+      label, ex, KE::begin(v), KE::end(v), std::move(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          typename PredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType find_if(const TeamHandleType& teamHandle,
+                                     IteratorType first, IteratorType last,
+                                     PredicateType predicate) {
+  return Impl::find_if_or_not_team_impl<true>(teamHandle, first, last,
+                                              std::move(predicate));
+}
+
+template <
+    typename TeamHandleType, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto find_if(const TeamHandleType& teamHandle,
+                             const ::Kokkos::View<DataType, Properties...>& v,
+                             Predicate predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_if_or_not_team_impl<true>(teamHandle, KE::begin(v),
+                                              KE::end(v), std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_FindIfNot.hpp b/algorithms/src/std_algorithms/Kokkos_FindIfNot.hpp
index 18294d7b7d..5e17a6f539 100644
--- a/algorithms/src/std_algorithms/Kokkos_FindIfNot.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_FindIfNot.hpp
@@ -23,45 +23,84 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class Predicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType find_if_not(const ExecutionSpace& ex, IteratorType first,
                          IteratorType last, Predicate predicate) {
-  return Impl::find_if_or_not_impl<false>(
+  return Impl::find_if_or_not_exespace_impl<false>(
       "Kokkos::find_if_not_iterator_api_default", ex, first, last,
       std::move(predicate));
 }
 
-template <class ExecutionSpace, class IteratorType, class Predicate>
+template <
+    typename ExecutionSpace, typename IteratorType, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType find_if_not(const std::string& label, const ExecutionSpace& ex,
                          IteratorType first, IteratorType last,
                          Predicate predicate) {
-  return Impl::find_if_or_not_impl<false>(label, ex, first, last,
-                                          std::move(predicate));
+  return Impl::find_if_or_not_exespace_impl<false>(label, ex, first, last,
+                                                   std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto find_if_not(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v,
                  Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_if_or_not_impl<false>(
+  return Impl::find_if_or_not_exespace_impl<false>(
       "Kokkos::find_if_not_view_api_default", ex, KE::begin(v), KE::end(v),
       std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Predicate,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto find_if_not(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v,
                  Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::find_if_or_not_impl<false>(label, ex, KE::begin(v), KE::end(v),
-                                          std::move(predicate));
+  return Impl::find_if_or_not_exespace_impl<false>(
+      label, ex, KE::begin(v), KE::end(v), std::move(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType, typename Predicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType find_if_not(const TeamHandleType& teamHandle,
+                                         IteratorType first, IteratorType last,
+                                         Predicate predicate) {
+  return Impl::find_if_or_not_team_impl<false>(teamHandle, first, last,
+                                               std::move(predicate));
+}
+
+template <
+    typename TeamHandleType, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto find_if_not(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, Predicate predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::find_if_or_not_team_impl<false>(
+      teamHandle, KE::begin(v), KE::end(v), std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ForEach.hpp b/algorithms/src/std_algorithms/Kokkos_ForEach.hpp
index d7b08e4842..05969be463 100644
--- a/algorithms/src/std_algorithms/Kokkos_ForEach.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ForEach.hpp
@@ -23,42 +23,79 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class UnaryFunctorType>
-UnaryFunctorType for_each(const std::string& label, const ExecutionSpace& ex,
-                          IteratorType first, IteratorType last,
-                          UnaryFunctorType functor) {
-  return Impl::for_each_impl(label, ex, first, last, std::move(functor));
+//
+// overload set accepting execution space
+//
+template <
+    class ExecutionSpace, class IteratorType, class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
+void for_each(const std::string& label, const ExecutionSpace& ex,
+              IteratorType first, IteratorType last, UnaryFunctorType functor) {
+  Impl::for_each_exespace_impl(label, ex, first, last, std::move(functor));
+}
+
+template <
+    class ExecutionSpace, class IteratorType, class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
+void for_each(const ExecutionSpace& ex, IteratorType first, IteratorType last,
+              UnaryFunctorType functor) {
+  Impl::for_each_exespace_impl("Kokkos::for_each_iterator_api_default", ex,
+                               first, last, std::move(functor));
 }
 
-template <class ExecutionSpace, class IteratorType, class UnaryFunctorType>
-UnaryFunctorType for_each(const ExecutionSpace& ex, IteratorType first,
-                          IteratorType last, UnaryFunctorType functor) {
-  return Impl::for_each_impl("Kokkos::for_each_iterator_api_default", ex, first,
-                             last, std::move(functor));
+template <
+    class ExecutionSpace, class DataType, class... Properties,
+    class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
+void for_each(const std::string& label, const ExecutionSpace& ex,
+              const ::Kokkos::View<DataType, Properties...>& v,
+              UnaryFunctorType functor) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  Impl::for_each_exespace_impl(label, ex, KE::begin(v), KE::end(v),
+                               std::move(functor));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class UnaryFunctorType>
-UnaryFunctorType for_each(const std::string& label, const ExecutionSpace& ex,
-                          const ::Kokkos::View<DataType, Properties...>& v,
-                          UnaryFunctorType functor) {
+template <
+    class ExecutionSpace, class DataType, class... Properties,
+    class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
+void for_each(const ExecutionSpace& ex,
+              const ::Kokkos::View<DataType, Properties...>& v,
+              UnaryFunctorType functor) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::for_each_impl(label, ex, KE::begin(v), KE::end(v),
-                             std::move(functor));
+  Impl::for_each_exespace_impl("Kokkos::for_each_view_api_default", ex,
+                               KE::begin(v), KE::end(v), std::move(functor));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+template <class TeamHandleType, class IteratorType, class UnaryFunctorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void for_each(const TeamHandleType& teamHandle,
+                              IteratorType first, IteratorType last,
+                              UnaryFunctorType functor) {
+  Impl::for_each_team_impl(teamHandle, first, last, std::move(functor));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class UnaryFunctorType>
-UnaryFunctorType for_each(const ExecutionSpace& ex,
-                          const ::Kokkos::View<DataType, Properties...>& v,
-                          UnaryFunctorType functor) {
+template <class TeamHandleType, class DataType, class... Properties,
+          class UnaryFunctorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void for_each(const TeamHandleType& teamHandle,
+                              const ::Kokkos::View<DataType, Properties...>& v,
+                              UnaryFunctorType functor) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::for_each_impl("Kokkos::for_each_view_api_default", ex,
-                             KE::begin(v), KE::end(v), std::move(functor));
+  Impl::for_each_team_impl(teamHandle, KE::begin(v), KE::end(v),
+                           std::move(functor));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ForEachN.hpp b/algorithms/src/std_algorithms/Kokkos_ForEachN.hpp
index f1769da05b..e6fbcad891 100644
--- a/algorithms/src/std_algorithms/Kokkos_ForEachN.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ForEachN.hpp
@@ -23,43 +23,87 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class SizeType,
-          class UnaryFunctorType>
+//
+// overload set accepting execution space
+//
+template <
+    class ExecutionSpace, class IteratorType, class SizeType,
+    class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType for_each_n(const std::string& label, const ExecutionSpace& ex,
                         IteratorType first, SizeType n,
                         UnaryFunctorType functor) {
-  return Impl::for_each_n_impl(label, ex, first, n, std::move(functor));
+  return Impl::for_each_n_exespace_impl(label, ex, first, n,
+                                        std::move(functor));
 }
 
-template <class ExecutionSpace, class IteratorType, class SizeType,
-          class UnaryFunctorType>
+template <
+    class ExecutionSpace, class IteratorType, class SizeType,
+    class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType for_each_n(const ExecutionSpace& ex, IteratorType first,
                         SizeType n, UnaryFunctorType functor) {
-  return Impl::for_each_n_impl("Kokkos::for_each_n_iterator_api_default", ex,
-                               first, n, std::move(functor));
+  return Impl::for_each_n_exespace_impl(
+      "Kokkos::for_each_n_iterator_api_default", ex, first, n,
+      std::move(functor));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class UnaryFunctorType>
+template <
+    class ExecutionSpace, class DataType, class... Properties, class SizeType,
+    class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto for_each_n(const std::string& label, const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType, Properties...>& v, SizeType n,
                 UnaryFunctorType functor) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::for_each_n_impl(label, ex, KE::begin(v), n, std::move(functor));
+  return Impl::for_each_n_exespace_impl(label, ex, KE::begin(v), n,
+                                        std::move(functor));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class UnaryFunctorType>
+template <
+    class ExecutionSpace, class DataType, class... Properties, class SizeType,
+    class UnaryFunctorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto for_each_n(const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType, Properties...>& v, SizeType n,
                 UnaryFunctorType functor) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::for_each_n_impl("Kokkos::for_each_n_view_api_default", ex,
-                               KE::begin(v), n, std::move(functor));
+  return Impl::for_each_n_exespace_impl("Kokkos::for_each_n_view_api_default",
+                                        ex, KE::begin(v), n,
+                                        std::move(functor));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+template <class TeamHandleType, class IteratorType, class SizeType,
+          class UnaryFunctorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType for_each_n(const TeamHandleType& teamHandle,
+                                        IteratorType first, SizeType n,
+                                        UnaryFunctorType functor) {
+  return Impl::for_each_n_team_impl(teamHandle, first, n, std::move(functor));
+}
+
+template <class TeamHandleType, class DataType, class... Properties,
+          class SizeType, class UnaryFunctorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto for_each_n(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, SizeType n,
+    UnaryFunctorType functor) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::for_each_n_team_impl(teamHandle, KE::begin(v), n,
+                                    std::move(functor));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Generate.hpp b/algorithms/src/std_algorithms/Kokkos_Generate.hpp
index 13e12783e0..a3295084ee 100644
--- a/algorithms/src/std_algorithms/Kokkos_Generate.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Generate.hpp
@@ -23,38 +23,68 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class Generator>
+//
+// overload set accepting execution space
+//
+template <typename ExecutionSpace, typename IteratorType, typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 void generate(const ExecutionSpace& ex, IteratorType first, IteratorType last,
               Generator g) {
-  Impl::generate_impl("Kokkos::generate_iterator_api_default", ex, first, last,
-                      std::move(g));
+  Impl::generate_exespace_impl("Kokkos::generate_iterator_api_default", ex,
+                               first, last, std::move(g));
 }
 
-template <class ExecutionSpace, class IteratorType, class Generator>
+template <typename ExecutionSpace, typename IteratorType, typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 void generate(const std::string& label, const ExecutionSpace& ex,
               IteratorType first, IteratorType last, Generator g) {
-  Impl::generate_impl(label, ex, first, last, std::move(g));
+  Impl::generate_exespace_impl(label, ex, first, last, std::move(g));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Generator>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 void generate(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& view,
               Generator g) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  Impl::generate_impl("Kokkos::generate_view_api_default", ex, begin(view),
-                      end(view), std::move(g));
+  Impl::generate_exespace_impl("Kokkos::generate_view_api_default", ex,
+                               begin(view), end(view), std::move(g));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Generator>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 void generate(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& view,
               Generator g) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  Impl::generate_impl(label, ex, begin(view), end(view), std::move(g));
+  Impl::generate_exespace_impl(label, ex, begin(view), end(view), std::move(g));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType, typename Generator,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void generate(const TeamHandleType& teamHandle,
+                              IteratorType first, IteratorType last,
+                              Generator g) {
+  Impl::generate_team_impl(teamHandle, first, last, std::move(g));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename Generator,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void generate(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, Generator g) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::generate_team_impl(teamHandle, begin(view), end(view), std::move(g));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_GenerateN.hpp b/algorithms/src/std_algorithms/Kokkos_GenerateN.hpp
index 4d17512228..e480062c23 100644
--- a/algorithms/src/std_algorithms/Kokkos_GenerateN.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_GenerateN.hpp
@@ -23,40 +23,75 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class Size, class Generator>
+//
+// overload set accepting execution space
+//
+template <typename ExecutionSpace, typename IteratorType, typename Size,
+          typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType generate_n(const ExecutionSpace& ex, IteratorType first,
                         Size count, Generator g) {
-  Impl::generate_n_impl("Kokkos::generate_n_iterator_api_default", ex, first,
-                        count, std::move(g));
-  return first + count;
+  return Impl::generate_n_exespace_impl(
+      "Kokkos::generate_n_iterator_api_default", ex, first, count,
+      std::move(g));
 }
 
-template <class ExecutionSpace, class IteratorType, class Size, class Generator>
+template <typename ExecutionSpace, typename IteratorType, typename Size,
+          typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType generate_n(const std::string& label, const ExecutionSpace& ex,
                         IteratorType first, Size count, Generator g) {
-  Impl::generate_n_impl(label, ex, first, count, std::move(g));
-  return first + count;
+  return Impl::generate_n_exespace_impl(label, ex, first, count, std::move(g));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class Size,
-          class Generator>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Size, typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto generate_n(const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType, Properties...>& view, Size count,
                 Generator g) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::generate_n_impl("Kokkos::generate_n_view_api_default", ex,
-                               begin(view), count, std::move(g));
+  return Impl::generate_n_exespace_impl("Kokkos::generate_n_view_api_default",
+                                        ex, begin(view), count, std::move(g));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties, class Size,
-          class Generator>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename Size, typename Generator,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto generate_n(const std::string& label, const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType, Properties...>& view, Size count,
                 Generator g) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::generate_n_impl(label, ex, begin(view), count, std::move(g));
+  return Impl::generate_n_exespace_impl(label, ex, begin(view), count,
+                                        std::move(g));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType, typename Size,
+          typename Generator,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType generate_n(const TeamHandleType& teamHandle,
+                                        IteratorType first, Size count,
+                                        Generator g) {
+  return Impl::generate_n_team_impl(teamHandle, first, count, std::move(g));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename Size, typename Generator,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto generate_n(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, Size count,
+    Generator g) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  return Impl::generate_n_team_impl(teamHandle, begin(view), count,
+                                    std::move(g));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_InclusiveScan.hpp b/algorithms/src/std_algorithms/Kokkos_InclusiveScan.hpp
index bcd731b850..a0e540b5e7 100644
--- a/algorithms/src/std_algorithms/Kokkos_InclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_InclusiveScan.hpp
@@ -23,33 +23,45 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-inclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-               InputIteratorType last, OutputIteratorType first_dest) {
-  return Impl::inclusive_scan_default_op_impl(
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType inclusive_scan(const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest) {
+  return Impl::inclusive_scan_default_op_exespace_impl(
       "Kokkos::inclusive_scan_default_functors_iterator_api", ex, first, last,
       first_dest);
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-inclusive_scan(const std::string& label, const ExecutionSpace& ex,
-               InputIteratorType first, InputIteratorType last,
-               OutputIteratorType first_dest) {
-  return Impl::inclusive_scan_default_op_impl(label, ex, first, last,
-                                              first_dest);
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType inclusive_scan(const std::string& label,
+                                  const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest) {
+  return Impl::inclusive_scan_default_op_exespace_impl(label, ex, first, last,
+                                                       first_dest);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto inclusive_scan(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -57,13 +69,15 @@ auto inclusive_scan(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::inclusive_scan_default_op_impl(
+  return Impl::inclusive_scan_default_op_exespace_impl(
       "Kokkos::inclusive_scan_default_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto inclusive_scan(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -71,39 +85,45 @@ auto inclusive_scan(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::inclusive_scan_default_op_impl(label, ex, KE::cbegin(view_from),
-                                              KE::cend(view_from),
-                                              KE::begin(view_dest));
+  return Impl::inclusive_scan_default_op_exespace_impl(
+      label, ex, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest));
 }
 
 // overload set 2 (accepting custom binary op)
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOp>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-inclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-               InputIteratorType last, OutputIteratorType first_dest,
-               BinaryOp binary_op) {
-  return Impl::inclusive_scan_custom_binary_op_impl(
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType inclusive_scan(const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  BinaryOp binary_op) {
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
       "Kokkos::inclusive_scan_custom_functors_iterator_api", ex, first, last,
       first_dest, binary_op);
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOp>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-inclusive_scan(const std::string& label, const ExecutionSpace& ex,
-               InputIteratorType first, InputIteratorType last,
-               OutputIteratorType first_dest, BinaryOp binary_op) {
-  return Impl::inclusive_scan_custom_binary_op_impl(label, ex, first, last,
-                                                    first_dest, binary_op);
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType inclusive_scan(
+    const std::string& label, const ExecutionSpace& ex, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest, BinaryOp binary_op) {
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
+      label, ex, first, last, first_dest, binary_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOp>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOp,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto inclusive_scan(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -111,14 +131,16 @@ auto inclusive_scan(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::inclusive_scan_custom_binary_op_impl(
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
       "Kokkos::inclusive_scan_custom_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
       binary_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOp>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOp,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto inclusive_scan(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -126,67 +148,192 @@ auto inclusive_scan(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::inclusive_scan_custom_binary_op_impl(
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
       label, ex, KE::cbegin(view_from), KE::cend(view_from),
       KE::begin(view_dest), binary_op);
 }
 
 // overload set 3
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOp, class ValueType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-inclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-               InputIteratorType last, OutputIteratorType first_dest,
-               BinaryOp binary_op, ValueType init_value) {
-  return Impl::inclusive_scan_custom_binary_op_impl(
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType inclusive_scan(const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  BinaryOp binary_op, ValueType init_value) {
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
       "Kokkos::inclusive_scan_custom_functors_iterator_api", ex, first, last,
-      first_dest, binary_op, init_value);
+      first_dest, binary_op, std::move(init_value));
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOp, class ValueType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-inclusive_scan(const std::string& label, const ExecutionSpace& ex,
-               InputIteratorType first, InputIteratorType last,
-               OutputIteratorType first_dest, BinaryOp binary_op,
-               ValueType init_value) {
-  return Impl::inclusive_scan_custom_binary_op_impl(
-      label, ex, first, last, first_dest, binary_op, init_value);
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType inclusive_scan(const std::string& label,
+                                  const ExecutionSpace& ex,
+                                  InputIteratorType first,
+                                  InputIteratorType last,
+                                  OutputIteratorType first_dest,
+                                  BinaryOp binary_op, ValueType init_value) {
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
+      label, ex, first, last, first_dest, binary_op, std::move(init_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOp,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOp,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto inclusive_scan(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
                     BinaryOp binary_op, ValueType init_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
   namespace KE = ::Kokkos::Experimental;
-  return Impl::inclusive_scan_custom_binary_op_impl(
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
       "Kokkos::inclusive_scan_custom_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
-      binary_op, init_value);
+      binary_op, std::move(init_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOp,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOp,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto inclusive_scan(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
                     BinaryOp binary_op, ValueType init_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
   namespace KE = ::Kokkos::Experimental;
-  return Impl::inclusive_scan_custom_binary_op_impl(
+  return Impl::inclusive_scan_custom_binary_op_exespace_impl(
       label, ex, KE::cbegin(view_from), KE::cend(view_from),
-      KE::begin(view_dest), binary_op, init_value);
+      KE::begin(view_dest), binary_op, std::move(init_value));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType
+inclusive_scan(const TeamHandleType& teamHandle, InputIteratorType first,
+               InputIteratorType last, OutputIteratorType first_dest) {
+  return Impl::inclusive_scan_default_op_team_impl(teamHandle, first, last,
+                                                   first_dest);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto inclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::inclusive_scan_default_op_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest));
+}
+
+// overload set 2 (accepting custom binary op)
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType inclusive_scan(
+    const TeamHandleType& teamHandle, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest, BinaryOp binary_op) {
+  return Impl::inclusive_scan_custom_binary_op_team_impl(
+      teamHandle, first, last, first_dest, binary_op);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto inclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    BinaryOp binary_op) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::inclusive_scan_custom_binary_op_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), binary_op);
+}
+
+// overload set 3
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOp, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+
+KOKKOS_FUNCTION OutputIteratorType
+inclusive_scan(const TeamHandleType& teamHandle, InputIteratorType first,
+               InputIteratorType last, OutputIteratorType first_dest,
+               BinaryOp binary_op, ValueType init_value) {
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  return Impl::inclusive_scan_custom_binary_op_team_impl(
+      teamHandle, first, last, first_dest, binary_op, std::move(init_value));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryOp,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto inclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    BinaryOp binary_op, ValueType init_value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::inclusive_scan_custom_binary_op_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), binary_op, std::move(init_value));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_IsPartitioned.hpp b/algorithms/src/std_algorithms/Kokkos_IsPartitioned.hpp
index 29d6be9e8b..42f20bc4ec 100644
--- a/algorithms/src/std_algorithms/Kokkos_IsPartitioned.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_IsPartitioned.hpp
@@ -23,39 +23,78 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class PredicateType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_partitioned(const ExecutionSpace& ex, IteratorType first,
                     IteratorType last, PredicateType p) {
-  return Impl::is_partitioned_impl(
+  return Impl::is_partitioned_exespace_impl(
       "Kokkos::is_partitioned_iterator_api_default", ex, first, last,
       std::move(p));
 }
 
-template <class ExecutionSpace, class IteratorType, class PredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_partitioned(const std::string& label, const ExecutionSpace& ex,
                     IteratorType first, IteratorType last, PredicateType p) {
-  return Impl::is_partitioned_impl(label, ex, first, last, std::move(p));
+  return Impl::is_partitioned_exespace_impl(label, ex, first, last,
+                                            std::move(p));
 }
 
-template <class ExecutionSpace, class PredicateType, class DataType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename PredicateType, typename DataType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_partitioned(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType, Properties...>& v,
                     PredicateType p) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::is_partitioned_impl("Kokkos::is_partitioned_view_api_default",
-                                   ex, cbegin(v), cend(v), std::move(p));
+  return Impl::is_partitioned_exespace_impl(
+      "Kokkos::is_partitioned_view_api_default", ex, cbegin(v), cend(v),
+      std::move(p));
 }
 
-template <class ExecutionSpace, class PredicateType, class DataType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename PredicateType, typename DataType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_partitioned(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType, Properties...>& v,
                     PredicateType p) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::is_partitioned_impl(label, ex, cbegin(v), cend(v), std::move(p));
+  return Impl::is_partitioned_exespace_impl(label, ex, cbegin(v), cend(v),
+                                            std::move(p));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          typename PredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool is_partitioned(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType last,
+                                    PredicateType p) {
+  return Impl::is_partitioned_team_impl(teamHandle, first, last, std::move(p));
+}
+
+template <typename TeamHandleType, typename PredicateType, typename DataType,
+          typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool is_partitioned(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, PredicateType p) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  return Impl::is_partitioned_team_impl(teamHandle, cbegin(v), cend(v),
+                                        std::move(p));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_IsSorted.hpp b/algorithms/src/std_algorithms/Kokkos_IsSorted.hpp
index f036254a02..2c676c3ff3 100644
--- a/algorithms/src/std_algorithms/Kokkos_IsSorted.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_IsSorted.hpp
@@ -23,55 +23,73 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const ExecutionSpace& ex, IteratorType first,
                IteratorType last) {
-  return Impl::is_sorted_impl("Kokkos::is_sorted_iterator_api_default", ex,
-                              first, last);
+  return Impl::is_sorted_exespace_impl("Kokkos::is_sorted_iterator_api_default",
+                                       ex, first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const std::string& label, const ExecutionSpace& ex,
                IteratorType first, IteratorType last) {
-  return Impl::is_sorted_impl(label, ex, first, last);
+  return Impl::is_sorted_exespace_impl(label, ex, first, last);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const ExecutionSpace& ex,
                const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_impl("Kokkos::is_sorted_view_api_default", ex,
-                              KE::cbegin(view), KE::cend(view));
+  return Impl::is_sorted_exespace_impl("Kokkos::is_sorted_view_api_default", ex,
+                                       KE::cbegin(view), KE::cend(view));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const std::string& label, const ExecutionSpace& ex,
                const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_impl(label, ex, KE::cbegin(view), KE::cend(view));
+  return Impl::is_sorted_exespace_impl(label, ex, KE::cbegin(view),
+                                       KE::cend(view));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const ExecutionSpace& ex, IteratorType first, IteratorType last,
                ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
-  return Impl::is_sorted_impl("Kokkos::is_sorted_iterator_api_default", ex,
-                              first, last, std::move(comp));
+  return Impl::is_sorted_exespace_impl("Kokkos::is_sorted_iterator_api_default",
+                                       ex, first, last, std::move(comp));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const std::string& label, const ExecutionSpace& ex,
                IteratorType first, IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
-  return Impl::is_sorted_impl(label, ex, first, last, std::move(comp));
+  return Impl::is_sorted_exespace_impl(label, ex, first, last, std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ComparatorType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const ExecutionSpace& ex,
                const ::Kokkos::View<DataType, Properties...>& view,
                ComparatorType comp) {
@@ -79,13 +97,15 @@ bool is_sorted(const ExecutionSpace& ex,
   Impl::static_assert_is_not_openmptarget(ex);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_impl("Kokkos::is_sorted_view_api_default", ex,
-                              KE::cbegin(view), KE::cend(view),
-                              std::move(comp));
+  return Impl::is_sorted_exespace_impl("Kokkos::is_sorted_view_api_default", ex,
+                                       KE::cbegin(view), KE::cend(view),
+                                       std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ComparatorType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool is_sorted(const std::string& label, const ExecutionSpace& ex,
                const ::Kokkos::View<DataType, Properties...>& view,
                ComparatorType comp) {
@@ -93,8 +113,56 @@ bool is_sorted(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_not_openmptarget(ex);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_impl(label, ex, KE::cbegin(view), KE::cend(view),
-                              std::move(comp));
+  return Impl::is_sorted_exespace_impl(label, ex, KE::cbegin(view),
+                                       KE::cend(view), std::move(comp));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool is_sorted(const TeamHandleType& teamHandle,
+                               IteratorType first, IteratorType last) {
+  return Impl::is_sorted_team_impl(teamHandle, first, last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool is_sorted(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::is_sorted_team_impl(teamHandle, KE::cbegin(view),
+                                   KE::cend(view));
+}
+
+template <typename TeamHandleType, typename IteratorType,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool is_sorted(const TeamHandleType& teamHandle,
+                               IteratorType first, IteratorType last,
+                               ComparatorType comp) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  return Impl::is_sorted_team_impl(teamHandle, first, last, std::move(comp));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool is_sorted(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, ComparatorType comp) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::is_sorted_team_impl(teamHandle, KE::cbegin(view), KE::cend(view),
+                                   std::move(comp));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_IsSortedUntil.hpp b/algorithms/src/std_algorithms/Kokkos_IsSortedUntil.hpp
index 276b3bb884..96a17b6785 100644
--- a/algorithms/src/std_algorithms/Kokkos_IsSortedUntil.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_IsSortedUntil.hpp
@@ -23,58 +23,78 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType is_sorted_until(const ExecutionSpace& ex, IteratorType first,
                              IteratorType last) {
-  return Impl::is_sorted_until_impl(
+  return Impl::is_sorted_until_exespace_impl(
       "Kokkos::is_sorted_until_iterator_api_default", ex, first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType is_sorted_until(const std::string& label, const ExecutionSpace& ex,
                              IteratorType first, IteratorType last) {
-  return Impl::is_sorted_until_impl(label, ex, first, last);
+  return Impl::is_sorted_until_exespace_impl(label, ex, first, last);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto is_sorted_until(const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_until_impl("Kokkos::is_sorted_until_view_api_default",
-                                    ex, KE::begin(view), KE::end(view));
+  return Impl::is_sorted_until_exespace_impl(
+      "Kokkos::is_sorted_until_view_api_default", ex, KE::begin(view),
+      KE::end(view));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto is_sorted_until(const std::string& label, const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_until_impl(label, ex, KE::begin(view), KE::end(view));
+  return Impl::is_sorted_until_exespace_impl(label, ex, KE::begin(view),
+                                             KE::end(view));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType is_sorted_until(const ExecutionSpace& ex, IteratorType first,
                              IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
-  return Impl::is_sorted_until_impl(
+  return Impl::is_sorted_until_exespace_impl(
       "Kokkos::is_sorted_until_iterator_api_default", ex, first, last,
       std::move(comp));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType is_sorted_until(const std::string& label, const ExecutionSpace& ex,
                              IteratorType first, IteratorType last,
                              ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::is_sorted_until_impl(label, ex, first, last, std::move(comp));
+  return Impl::is_sorted_until_exespace_impl(label, ex, first, last,
+                                             std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ComparatorType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto is_sorted_until(const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType, Properties...>& view,
                      ComparatorType comp) {
@@ -82,13 +102,15 @@ auto is_sorted_until(const ExecutionSpace& ex,
   Impl::static_assert_is_not_openmptarget(ex);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_until_impl("Kokkos::is_sorted_until_view_api_default",
-                                    ex, KE::begin(view), KE::end(view),
-                                    std::move(comp));
+  return Impl::is_sorted_until_exespace_impl(
+      "Kokkos::is_sorted_until_view_api_default", ex, KE::begin(view),
+      KE::end(view), std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ComparatorType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto is_sorted_until(const std::string& label, const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType, Properties...>& view,
                      ComparatorType comp) {
@@ -96,8 +118,57 @@ auto is_sorted_until(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_not_openmptarget(ex);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::is_sorted_until_impl(label, ex, KE::begin(view), KE::end(view),
-                                    std::move(comp));
+  return Impl::is_sorted_until_exespace_impl(label, ex, KE::begin(view),
+                                             KE::end(view), std::move(comp));
+}
+
+//
+// overload set accepting team handle
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType is_sorted_until(const TeamHandleType& teamHandle,
+                                             IteratorType first,
+                                             IteratorType last) {
+  return Impl::is_sorted_until_team_impl(teamHandle, first, last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto is_sorted_until(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::is_sorted_until_team_impl(teamHandle, KE::begin(view),
+                                         KE::end(view));
+}
+
+template <typename TeamHandleType, typename IteratorType,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType is_sorted_until(const TeamHandleType& teamHandle,
+                                             IteratorType first,
+                                             IteratorType last,
+                                             ComparatorType comp) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  return Impl::is_sorted_until_team_impl(teamHandle, first, last,
+                                         std::move(comp));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto is_sorted_until(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, ComparatorType comp) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::is_sorted_until_team_impl(teamHandle, KE::begin(view),
+                                         KE::end(view), std::move(comp));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_IterSwap.hpp b/algorithms/src/std_algorithms/Kokkos_IterSwap.hpp
index a796a306dd..5bb2d1039d 100644
--- a/algorithms/src/std_algorithms/Kokkos_IterSwap.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_IterSwap.hpp
@@ -19,7 +19,6 @@
 
 #include <Kokkos_Core.hpp>
 #include "impl/Kokkos_Constraints.hpp"
-#include "Kokkos_Swap.hpp"
 
 namespace Kokkos {
 namespace Experimental {
@@ -33,7 +32,7 @@ struct StdIterSwapFunctor {
   KOKKOS_FUNCTION
   void operator()(int i) const {
     (void)i;
-    ::Kokkos::Experimental::swap(*m_a, *m_b);
+    ::Kokkos::kokkos_swap(*m_a, *m_b);
   }
 
   KOKKOS_FUNCTION
@@ -58,6 +57,16 @@ void iter_swap(IteratorType1 a, IteratorType2 b) {
   Impl::iter_swap_impl(a, b);
 }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+template <class T>
+KOKKOS_DEPRECATED_WITH_COMMENT("Use Kokkos::kokkos_swap instead!")
+KOKKOS_FUNCTION
+    void swap(T& a, T& b) noexcept(::Kokkos::kokkos_swap(std::declval<T&>(),
+                                                         std::declval<T&>())) {
+  ::Kokkos::kokkos_swap(a, b);
+}
+#endif
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_LexicographicalCompare.hpp b/algorithms/src/std_algorithms/Kokkos_LexicographicalCompare.hpp
index 0a77ef629f..e13479c370 100644
--- a/algorithms/src/std_algorithms/Kokkos_LexicographicalCompare.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_LexicographicalCompare.hpp
@@ -23,101 +23,181 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+//
+// overload set accepting execution space
+//
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(const ExecutionSpace& ex, IteratorType1 first1,
                              IteratorType1 last1, IteratorType2 first2,
                              IteratorType2 last2) {
-  return Impl::lexicographical_compare_impl(
+  return Impl::lexicographical_compare_exespace_impl(
       "Kokkos::lexicographical_compare_iterator_api_default", ex, first1, last1,
       first2, last2);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(const std::string& label, const ExecutionSpace& ex,
                              IteratorType1 first1, IteratorType1 last1,
                              IteratorType2 first2, IteratorType2 last2) {
-  return Impl::lexicographical_compare_impl(label, ex, first1, last1, first2,
-                                            last2);
+  return Impl::lexicographical_compare_exespace_impl(label, ex, first1, last1,
+                                                     first2, last2);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view1,
-    ::Kokkos::View<DataType2, Properties2...>& view2) {
+    const ::Kokkos::View<DataType2, Properties2...>& view2) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::lexicographical_compare_impl(
+  return Impl::lexicographical_compare_exespace_impl(
       "Kokkos::lexicographical_compare_view_api_default", ex, KE::cbegin(view1),
       KE::cend(view1), KE::cbegin(view2), KE::cend(view2));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view1,
-    ::Kokkos::View<DataType2, Properties2...>& view2) {
+    const ::Kokkos::View<DataType2, Properties2...>& view2) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::lexicographical_compare_impl(label, ex, KE::cbegin(view1),
-                                            KE::cend(view1), KE::cbegin(view2),
-                                            KE::cend(view2));
+  return Impl::lexicographical_compare_exespace_impl(
+      label, ex, KE::cbegin(view1), KE::cend(view1), KE::cbegin(view2),
+      KE::cend(view2));
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class ComparatorType>
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    class ComparatorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(const ExecutionSpace& ex, IteratorType1 first1,
                              IteratorType1 last1, IteratorType2 first2,
                              IteratorType2 last2, ComparatorType comp) {
-  return Impl::lexicographical_compare_impl(
+  return Impl::lexicographical_compare_exespace_impl(
       "Kokkos::lexicographical_compare_iterator_api_default", ex, first1, last1,
       first2, last2, comp);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class ComparatorType>
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    class ComparatorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(const std::string& label, const ExecutionSpace& ex,
                              IteratorType1 first1, IteratorType1 last1,
                              IteratorType2 first2, IteratorType2 last2,
                              ComparatorType comp) {
-  return Impl::lexicographical_compare_impl(label, ex, first1, last1, first2,
-                                            last2, comp);
+  return Impl::lexicographical_compare_exespace_impl(label, ex, first1, last1,
+                                                     first2, last2, comp);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ComparatorType>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2, class ComparatorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view1,
-    ::Kokkos::View<DataType2, Properties2...>& view2, ComparatorType comp) {
+    const ::Kokkos::View<DataType2, Properties2...>& view2,
+    ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::lexicographical_compare_impl(
+  return Impl::lexicographical_compare_exespace_impl(
       "Kokkos::lexicographical_compare_view_api_default", ex, KE::cbegin(view1),
       KE::cend(view1), KE::cbegin(view2), KE::cend(view2), comp);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ComparatorType>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2, class ComparatorType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool lexicographical_compare(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view1,
-    ::Kokkos::View<DataType2, Properties2...>& view2, ComparatorType comp) {
+    const ::Kokkos::View<DataType2, Properties2...>& view2,
+    ComparatorType comp) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::lexicographical_compare_exespace_impl(
+      label, ex, KE::cbegin(view1), KE::cend(view1), KE::cbegin(view2),
+      KE::cend(view2), comp);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool lexicographical_compare(const TeamHandleType& teamHandle,
+                                             IteratorType1 first1,
+                                             IteratorType1 last1,
+                                             IteratorType2 first2,
+                                             IteratorType2 last2) {
+  return Impl::lexicographical_compare_team_impl(teamHandle, first1, last1,
+                                                 first2, last2);
+}
+
+template <class TeamHandleType, class DataType1, class... Properties1,
+          class DataType2, class... Properties2,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool lexicographical_compare(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view1,
+    const ::Kokkos::View<DataType2, Properties2...>& view2) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::lexicographical_compare_team_impl(
+      teamHandle, KE::cbegin(view1), KE::cend(view1), KE::cbegin(view2),
+      KE::cend(view2));
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class ComparatorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool lexicographical_compare(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2, ComparatorType comp) {
+  return Impl::lexicographical_compare_team_impl(teamHandle, first1, last1,
+                                                 first2, last2, comp);
+}
+
+template <class TeamHandleType, class DataType1, class... Properties1,
+          class DataType2, class... Properties2, class ComparatorType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION bool lexicographical_compare(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view1,
+    const ::Kokkos::View<DataType2, Properties2...>& view2,
+    ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::lexicographical_compare_impl(label, ex, KE::cbegin(view1),
-                                            KE::cend(view1), KE::cbegin(view2),
-                                            KE::cend(view2), comp);
+  return Impl::lexicographical_compare_team_impl(
+      teamHandle, KE::cbegin(view1), KE::cend(view1), KE::cbegin(view2),
+      KE::cend(view2), comp);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_MaxElement.hpp b/algorithms/src/std_algorithms/Kokkos_MaxElement.hpp
index 2c1374f700..d16bac5bfc 100644
--- a/algorithms/src/std_algorithms/Kokkos_MaxElement.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_MaxElement.hpp
@@ -23,81 +23,148 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const ExecutionSpace& ex, IteratorType first,
                  IteratorType last) {
-  return Impl::min_or_max_element_impl<MaxFirstLoc>(
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLoc>(
       "Kokkos::max_element_iterator_api_default", ex, first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const std::string& label, const ExecutionSpace& ex,
                  IteratorType first, IteratorType last) {
-  return Impl::min_or_max_element_impl<MaxFirstLoc>(label, ex, first, last);
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLoc>(label, ex, first,
+                                                             last);
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const ExecutionSpace& ex, IteratorType first,
                  IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MaxFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLocCustomComparator>(
       "Kokkos::max_element_iterator_api_default", ex, first, last,
       std::move(comp));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const std::string& label, const ExecutionSpace& ex,
                  IteratorType first, IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MaxFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLocCustomComparator>(
       label, ex, first, last, std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::min_or_max_element_impl<MaxFirstLoc>(
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLoc>(
       "Kokkos::max_element_view_api_default", ex, begin(v), end(v));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::min_or_max_element_impl<MaxFirstLoc>(label, ex, begin(v),
-                                                    end(v));
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLoc>(label, ex,
+                                                             begin(v), end(v));
 }
 
-template <class ExecutionSpace, class DataType, class ComparatorType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename ComparatorType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v,
                  ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MaxFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLocCustomComparator>(
       "Kokkos::max_element_view_api_default", ex, begin(v), end(v),
       std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class ComparatorType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename ComparatorType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto max_element(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v,
                  ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MaxFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MaxFirstLocCustomComparator>(
       label, ex, begin(v), end(v), std::move(comp));
 }
 
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto max_element(const TeamHandleType& teamHandle,
+                                 IteratorType first, IteratorType last) {
+  return Impl::min_or_max_element_team_impl<MaxFirstLoc>(teamHandle, first,
+                                                         last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto max_element(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  return Impl::min_or_max_element_team_impl<MaxFirstLoc>(teamHandle, begin(v),
+                                                         end(v));
+}
+
+template <typename TeamHandleType, typename IteratorType,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto max_element(const TeamHandleType& teamHandle,
+                                 IteratorType first, IteratorType last,
+                                 ComparatorType comp) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  return Impl::min_or_max_element_team_impl<MaxFirstLocCustomComparator>(
+      teamHandle, first, last, std::move(comp));
+}
+
+template <typename TeamHandleType, typename DataType, typename ComparatorType,
+          typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto max_element(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, ComparatorType comp) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  return Impl::min_or_max_element_team_impl<MaxFirstLocCustomComparator>(
+      teamHandle, begin(v), end(v), std::move(comp));
+}
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_MinElement.hpp b/algorithms/src/std_algorithms/Kokkos_MinElement.hpp
index 1d03b7c962..2a53fce3e2 100644
--- a/algorithms/src/std_algorithms/Kokkos_MinElement.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_MinElement.hpp
@@ -23,81 +23,148 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const ExecutionSpace& ex, IteratorType first,
                  IteratorType last) {
-  return Impl::min_or_max_element_impl<MinFirstLoc>(
+  return Impl::min_or_max_element_exespace_impl<MinFirstLoc>(
       "Kokkos::min_element_iterator_api_default", ex, first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const std::string& label, const ExecutionSpace& ex,
                  IteratorType first, IteratorType last) {
-  return Impl::min_or_max_element_impl<MinFirstLoc>(label, ex, first, last);
+  return Impl::min_or_max_element_exespace_impl<MinFirstLoc>(label, ex, first,
+                                                             last);
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const ExecutionSpace& ex, IteratorType first,
                  IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MinFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MinFirstLocCustomComparator>(
       "Kokkos::min_element_iterator_api_default", ex, first, last,
       std::move(comp));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const std::string& label, const ExecutionSpace& ex,
                  IteratorType first, IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MinFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MinFirstLocCustomComparator>(
       label, ex, first, last, std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::min_or_max_element_impl<MinFirstLoc>(
+  return Impl::min_or_max_element_exespace_impl<MinFirstLoc>(
       "Kokkos::min_element_view_api_default", ex, begin(v), end(v));
 }
 
-template <class ExecutionSpace, class DataType, class ComparatorType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename ComparatorType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v,
                  ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MinFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MinFirstLocCustomComparator>(
       "Kokkos::min_element_view_api_default", ex, begin(v), end(v),
       std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::min_or_max_element_impl<MinFirstLoc>(label, ex, begin(v),
-                                                    end(v));
+  return Impl::min_or_max_element_exespace_impl<MinFirstLoc>(label, ex,
+                                                             begin(v), end(v));
 }
 
-template <class ExecutionSpace, class DataType, class ComparatorType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename ComparatorType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto min_element(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& v,
                  ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::min_or_max_element_impl<MinFirstLocCustomComparator>(
+  return Impl::min_or_max_element_exespace_impl<MinFirstLocCustomComparator>(
       label, ex, begin(v), end(v), std::move(comp));
 }
 
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto min_element(const TeamHandleType& teamHandle,
+                                 IteratorType first, IteratorType last) {
+  return Impl::min_or_max_element_team_impl<MinFirstLoc>(teamHandle, first,
+                                                         last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto min_element(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  return Impl::min_or_max_element_team_impl<MinFirstLoc>(teamHandle, begin(v),
+                                                         end(v));
+}
+
+template <typename TeamHandleType, typename IteratorType,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto min_element(const TeamHandleType& teamHandle,
+                                 IteratorType first, IteratorType last,
+                                 ComparatorType comp) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  return Impl::min_or_max_element_team_impl<MinFirstLocCustomComparator>(
+      teamHandle, first, last, std::move(comp));
+}
+
+template <typename TeamHandleType, typename DataType, typename ComparatorType,
+          typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto min_element(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, ComparatorType comp) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  return Impl::min_or_max_element_team_impl<MinFirstLocCustomComparator>(
+      teamHandle, begin(v), end(v), std::move(comp));
+}
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_MinMaxElement.hpp b/algorithms/src/std_algorithms/Kokkos_MinMaxElement.hpp
index d481b499cc..c3a1f73ef6 100644
--- a/algorithms/src/std_algorithms/Kokkos_MinMaxElement.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_MinMaxElement.hpp
@@ -23,82 +23,151 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const ExecutionSpace& ex, IteratorType first,
                     IteratorType last) {
-  return Impl::minmax_element_impl<MinMaxFirstLastLoc>(
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLoc>(
       "Kokkos::minmax_element_iterator_api_default", ex, first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const std::string& label, const ExecutionSpace& ex,
                     IteratorType first, IteratorType last) {
-  return Impl::minmax_element_impl<MinMaxFirstLastLoc>(label, ex, first, last);
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLoc>(label, ex,
+                                                                first, last);
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const ExecutionSpace& ex, IteratorType first,
                     IteratorType last, ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::minmax_element_impl<MinMaxFirstLastLocCustomComparator>(
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLocCustomComparator>(
       "Kokkos::minmax_element_iterator_api_default", ex, first, last,
       std::move(comp));
 }
 
-template <class ExecutionSpace, class IteratorType, class ComparatorType>
+template <
+    typename ExecutionSpace, typename IteratorType, typename ComparatorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const std::string& label, const ExecutionSpace& ex,
                     IteratorType first, IteratorType last,
                     ComparatorType comp) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::minmax_element_impl<MinMaxFirstLastLocCustomComparator>(
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLocCustomComparator>(
       label, ex, first, last, std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::minmax_element_impl<MinMaxFirstLastLoc>(
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLoc>(
       "Kokkos::minmax_element_view_api_default", ex, begin(v), end(v));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType, Properties...>& v) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
-  return Impl::minmax_element_impl<MinMaxFirstLastLoc>(label, ex, begin(v),
-                                                       end(v));
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLoc>(
+      label, ex, begin(v), end(v));
 }
 
-template <class ExecutionSpace, class DataType, class ComparatorType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename ComparatorType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType, Properties...>& v,
                     ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::minmax_element_impl<MinMaxFirstLastLocCustomComparator>(
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLocCustomComparator>(
       "Kokkos::minmax_element_view_api_default", ex, begin(v), end(v),
       std::move(comp));
 }
 
-template <class ExecutionSpace, class DataType, class ComparatorType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename ComparatorType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto minmax_element(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType, Properties...>& v,
                     ComparatorType comp) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::minmax_element_impl<MinMaxFirstLastLocCustomComparator>(
+  return Impl::minmax_element_exespace_impl<MinMaxFirstLastLocCustomComparator>(
       label, ex, begin(v), end(v), std::move(comp));
 }
 
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto minmax_element(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType last) {
+  return Impl::minmax_element_team_impl<MinMaxFirstLastLoc>(teamHandle, first,
+                                                            last);
+}
+
+template <typename TeamHandleType, typename IteratorType,
+          typename ComparatorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto minmax_element(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType last,
+                                    ComparatorType comp) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+
+  return Impl::minmax_element_team_impl<MinMaxFirstLastLocCustomComparator>(
+      teamHandle, first, last, std::move(comp));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto minmax_element(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  return Impl::minmax_element_team_impl<MinMaxFirstLastLoc>(teamHandle,
+                                                            begin(v), end(v));
+}
+
+template <typename TeamHandleType, typename DataType, typename ComparatorType,
+          typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto minmax_element(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, ComparatorType comp) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+
+  return Impl::minmax_element_team_impl<MinMaxFirstLastLocCustomComparator>(
+      teamHandle, begin(v), end(v), std::move(comp));
+}
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_Mismatch.hpp b/algorithms/src/std_algorithms/Kokkos_Mismatch.hpp
index 13c994ca90..090afe69e3 100644
--- a/algorithms/src/std_algorithms/Kokkos_Mismatch.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Mismatch.hpp
@@ -30,46 +30,60 @@ namespace Experimental {
 //
 // makes API ambiguous (with the overload accepting views).
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+//
+// overload set accepting execution space
+//
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 ::Kokkos::pair<IteratorType1, IteratorType2> mismatch(const ExecutionSpace& ex,
                                                       IteratorType1 first1,
                                                       IteratorType1 last1,
                                                       IteratorType2 first2,
                                                       IteratorType2 last2) {
-  return Impl::mismatch_impl("Kokkos::mismatch_iterator_api_default", ex,
-                             first1, last1, first2, last2);
+  return Impl::mismatch_exespace_impl("Kokkos::mismatch_iterator_api_default",
+                                      ex, first1, last1, first2, last2);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    class BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 ::Kokkos::pair<IteratorType1, IteratorType2> mismatch(
     const ExecutionSpace& ex, IteratorType1 first1, IteratorType1 last1,
     IteratorType2 first2, IteratorType2 last2,
     BinaryPredicateType&& predicate) {
-  return Impl::mismatch_impl("Kokkos::mismatch_iterator_api_default", ex,
-                             first1, last1, first2, last2,
-                             std::forward<BinaryPredicateType>(predicate));
+  return Impl::mismatch_exespace_impl(
+      "Kokkos::mismatch_iterator_api_default", ex, first1, last1, first2, last2,
+      std::forward<BinaryPredicateType>(predicate));
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 ::Kokkos::pair<IteratorType1, IteratorType2> mismatch(
     const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
     IteratorType1 last1, IteratorType2 first2, IteratorType2 last2) {
-  return Impl::mismatch_impl(label, ex, first1, last1, first2, last2);
+  return Impl::mismatch_exespace_impl(label, ex, first1, last1, first2, last2);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    class ExecutionSpace, class IteratorType1, class IteratorType2,
+    class BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 ::Kokkos::pair<IteratorType1, IteratorType2> mismatch(
     const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
     IteratorType1 last1, IteratorType2 first2, IteratorType2 last2,
     BinaryPredicateType&& predicate) {
-  return Impl::mismatch_impl(label, ex, first1, last1, first2, last2,
-                             std::forward<BinaryPredicateType>(predicate));
+  return Impl::mismatch_exespace_impl(
+      label, ex, first1, last1, first2, last2,
+      std::forward<BinaryPredicateType>(predicate));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto mismatch(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view1,
               const ::Kokkos::View<DataType2, Properties2...>& view2) {
@@ -77,13 +91,15 @@ auto mismatch(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::mismatch_impl("Kokkos::mismatch_view_api_default", ex,
-                             KE::begin(view1), KE::end(view1), KE::begin(view2),
-                             KE::end(view2));
+  return Impl::mismatch_exespace_impl("Kokkos::mismatch_view_api_default", ex,
+                                      KE::begin(view1), KE::end(view1),
+                                      KE::begin(view2), KE::end(view2));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2, class BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto mismatch(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view1,
               const ::Kokkos::View<DataType2, Properties2...>& view2,
@@ -92,14 +108,16 @@ auto mismatch(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::mismatch_impl("Kokkos::mismatch_view_api_default", ex,
-                             KE::begin(view1), KE::end(view1), KE::begin(view2),
-                             KE::end(view2),
-                             std::forward<BinaryPredicateType>(predicate));
+  return Impl::mismatch_exespace_impl(
+      "Kokkos::mismatch_view_api_default", ex, KE::begin(view1), KE::end(view1),
+      KE::begin(view2), KE::end(view2),
+      std::forward<BinaryPredicateType>(predicate));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto mismatch(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view1,
               const ::Kokkos::View<DataType2, Properties2...>& view2) {
@@ -107,12 +125,15 @@ auto mismatch(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::mismatch_impl(label, ex, KE::begin(view1), KE::end(view1),
-                             KE::begin(view2), KE::end(view2));
+  return Impl::mismatch_exespace_impl(label, ex, KE::begin(view1),
+                                      KE::end(view1), KE::begin(view2),
+                                      KE::end(view2));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    class ExecutionSpace, class DataType1, class... Properties1,
+    class DataType2, class... Properties2, class BinaryPredicateType,
+    std::enable_if_t<Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto mismatch(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType1, Properties1...>& view1,
               const ::Kokkos::View<DataType2, Properties2...>& view2,
@@ -121,9 +142,65 @@ auto mismatch(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::mismatch_impl(label, ex, KE::begin(view1), KE::end(view1),
-                             KE::begin(view2), KE::end(view2),
-                             std::forward<BinaryPredicateType>(predicate));
+  return Impl::mismatch_exespace_impl(
+      label, ex, KE::begin(view1), KE::end(view1), KE::begin(view2),
+      KE::end(view2), std::forward<BinaryPredicateType>(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION ::Kokkos::pair<IteratorType1, IteratorType2> mismatch(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2) {
+  return Impl::mismatch_team_impl(teamHandle, first1, last1, first2, last2);
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION ::Kokkos::pair<IteratorType1, IteratorType2> mismatch(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2,
+    BinaryPredicateType&& predicate) {
+  return Impl::mismatch_team_impl(teamHandle, first1, last1, first2, last2,
+                                  std::forward<BinaryPredicateType>(predicate));
+}
+
+template <class TeamHandleType, class DataType1, class... Properties1,
+          class DataType2, class... Properties2,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto mismatch(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view1,
+    const ::Kokkos::View<DataType2, Properties2...>& view2) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::mismatch_team_impl(teamHandle, KE::begin(view1), KE::end(view1),
+                                  KE::begin(view2), KE::end(view2));
+}
+
+template <class TeamHandleType, class DataType1, class... Properties1,
+          class DataType2, class... Properties2, class BinaryPredicateType,
+          std::enable_if_t<Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto mismatch(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view1,
+    const ::Kokkos::View<DataType2, Properties2...>& view2,
+    BinaryPredicateType&& predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view2);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::mismatch_team_impl(teamHandle, KE::begin(view1), KE::end(view1),
+                                  KE::begin(view2), KE::end(view2),
+                                  std::forward<BinaryPredicateType>(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Move.hpp b/algorithms/src/std_algorithms/Kokkos_Move.hpp
index d49acd9f70..ac308ea184 100644
--- a/algorithms/src/std_algorithms/Kokkos_Move.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Move.hpp
@@ -23,41 +23,81 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator move(const ExecutionSpace& ex, InputIterator first,
                     InputIterator last, OutputIterator d_first) {
-  return Impl::move_impl("Kokkos::move_iterator_api_default", ex, first, last,
-                         d_first);
+  return Impl::move_exespace_impl("Kokkos::move_iterator_api_default", ex,
+                                  first, last, d_first);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator move(const std::string& label, const ExecutionSpace& ex,
                     InputIterator first, InputIterator last,
                     OutputIterator d_first) {
-  return Impl::move_impl(label, ex, first, last, d_first);
+  return Impl::move_exespace_impl(label, ex, first, last, d_first);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto move(const ExecutionSpace& ex,
           const ::Kokkos::View<DataType1, Properties1...>& source,
-          ::Kokkos::View<DataType2, Properties2...>& dest) {
+          const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::move_impl("Kokkos::move_view_api_default", ex, begin(source),
-                         end(source), begin(dest));
+  return Impl::move_exespace_impl("Kokkos::move_view_api_default", ex,
+                                  begin(source), end(source), begin(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto move(const std::string& label, const ExecutionSpace& ex,
           const ::Kokkos::View<DataType1, Properties1...>& source,
-          ::Kokkos::View<DataType2, Properties2...>& dest) {
+          const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::move_exespace_impl(label, ex, begin(source), end(source),
+                                  begin(dest));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator move(const TeamHandleType& teamHandle,
+                                    InputIterator first, InputIterator last,
+                                    OutputIterator d_first) {
+  return Impl::move_team_impl(teamHandle, first, last, d_first);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto move(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::move_impl(label, ex, begin(source), end(source), begin(dest));
+  return Impl::move_team_impl(teamHandle, begin(source), end(source),
+                              begin(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_MoveBackward.hpp b/algorithms/src/std_algorithms/Kokkos_MoveBackward.hpp
index 60d50fa881..2789ab2179 100644
--- a/algorithms/src/std_algorithms/Kokkos_MoveBackward.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_MoveBackward.hpp
@@ -23,42 +23,83 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType2 move_backward(const ExecutionSpace& ex, IteratorType1 first,
                             IteratorType1 last, IteratorType2 d_last) {
-  return Impl::move_backward_impl("Kokkos::move_backward_iterator_api_default",
-                                  ex, first, last, d_last);
+  return Impl::move_backward_exespace_impl(
+      "Kokkos::move_backward_iterator_api_default", ex, first, last, d_last);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto move_backward(const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& source,
-                   ::Kokkos::View<DataType2, Properties2...>& dest) {
+                   const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::move_backward_impl("Kokkos::move_backward_view_api_default", ex,
-                                  begin(source), end(source), end(dest));
+  return Impl::move_backward_exespace_impl(
+      "Kokkos::move_backward_view_api_default", ex, begin(source), end(source),
+      end(dest));
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType2 move_backward(const std::string& label, const ExecutionSpace& ex,
                             IteratorType1 first, IteratorType1 last,
                             IteratorType2 d_last) {
-  return Impl::move_backward_impl(label, ex, first, last, d_last);
+  return Impl::move_backward_exespace_impl(label, ex, first, last, d_last);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto move_backward(const std::string& label, const ExecutionSpace& ex,
                    const ::Kokkos::View<DataType1, Properties1...>& source,
-                   ::Kokkos::View<DataType2, Properties2...>& dest) {
+                   const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::move_backward_exespace_impl(label, ex, begin(source),
+                                           end(source), end(dest));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType2 move_backward(const TeamHandleType& teamHandle,
+                                            IteratorType1 first,
+                                            IteratorType1 last,
+                                            IteratorType2 d_last) {
+  return Impl::move_backward_team_impl(teamHandle, first, last, d_last);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto move_backward(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::move_backward_impl(label, ex, begin(source), end(source),
-                                  end(dest));
+  return Impl::move_backward_team_impl(teamHandle, begin(source), end(source),
+                                       end(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_NoneOf.hpp b/algorithms/src/std_algorithms/Kokkos_NoneOf.hpp
index cf5de3b72b..f7baab3fc0 100644
--- a/algorithms/src/std_algorithms/Kokkos_NoneOf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_NoneOf.hpp
@@ -23,41 +23,80 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class Predicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool none_of(const ExecutionSpace& ex, IteratorType first, IteratorType last,
              Predicate predicate) {
-  return Impl::none_of_impl("Kokkos::none_of_iterator_api_default", ex, first,
-                            last, predicate);
+  return Impl::none_of_exespace_impl("Kokkos::none_of_iterator_api_default", ex,
+                                     first, last, predicate);
 }
 
-template <class ExecutionSpace, class IteratorType, class Predicate>
+template <
+    typename ExecutionSpace, typename IteratorType, typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool none_of(const std::string& label, const ExecutionSpace& ex,
              IteratorType first, IteratorType last, Predicate predicate) {
-  return Impl::none_of_impl(label, ex, first, last, predicate);
+  return Impl::none_of_exespace_impl(label, ex, first, last, predicate);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool none_of(const ExecutionSpace& ex,
              const ::Kokkos::View<DataType, Properties...>& v,
              Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::none_of_impl("Kokkos::none_of_view_api_default", ex,
-                            KE::cbegin(v), KE::cend(v), std::move(predicate));
+  return Impl::none_of_exespace_impl("Kokkos::none_of_view_api_default", ex,
+                                     KE::cbegin(v), KE::cend(v),
+                                     std::move(predicate));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class Predicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename Predicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 bool none_of(const std::string& label, const ExecutionSpace& ex,
              const ::Kokkos::View<DataType, Properties...>& v,
              Predicate predicate) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::none_of_impl(label, ex, KE::cbegin(v), KE::cend(v),
-                            std::move(predicate));
+  return Impl::none_of_exespace_impl(label, ex, KE::cbegin(v), KE::cend(v),
+                                     std::move(predicate));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType, typename Predicate>
+KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, bool>
+    none_of(const TeamHandleType& teamHandle, IteratorType first,
+            IteratorType last, Predicate predicate) {
+  return Impl::none_of_team_impl(teamHandle, first, last, predicate);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename Predicate>
+KOKKOS_FUNCTION
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, bool>
+    none_of(const TeamHandleType& teamHandle,
+            const ::Kokkos::View<DataType, Properties...>& v,
+            Predicate predicate) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::none_of_team_impl(teamHandle, KE::cbegin(v), KE::cend(v),
+                                 std::move(predicate));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_PartitionCopy.hpp b/algorithms/src/std_algorithms/Kokkos_PartitionCopy.hpp
index 38c0a35b62..a1feee8d6d 100644
--- a/algorithms/src/std_algorithms/Kokkos_PartitionCopy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_PartitionCopy.hpp
@@ -23,57 +23,103 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorTrueType, class OutputIteratorFalseType,
-          class PredicateType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIteratorType,
+    typename OutputIteratorTrueType, typename OutputIteratorFalseType,
+    typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 ::Kokkos::pair<OutputIteratorTrueType, OutputIteratorFalseType> partition_copy(
     const ExecutionSpace& ex, InputIteratorType from_first,
     InputIteratorType from_last, OutputIteratorTrueType to_first_true,
     OutputIteratorFalseType to_first_false, PredicateType p) {
-  return Impl::partition_copy_impl(
+  return Impl::partition_copy_exespace_impl(
       "Kokkos::partition_copy_iterator_api_default", ex, from_first, from_last,
       to_first_true, to_first_false, std::move(p));
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorTrueType, class OutputIteratorFalseType,
-          class PredicateType>
+template <
+    typename ExecutionSpace, typename InputIteratorType,
+    typename OutputIteratorTrueType, typename OutputIteratorFalseType,
+    typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 ::Kokkos::pair<OutputIteratorTrueType, OutputIteratorFalseType> partition_copy(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType from_first, InputIteratorType from_last,
     OutputIteratorTrueType to_first_true,
     OutputIteratorFalseType to_first_false, PredicateType p) {
-  return Impl::partition_copy_impl(label, ex, from_first, from_last,
-                                   to_first_true, to_first_false, std::move(p));
+  return Impl::partition_copy_exespace_impl(label, ex, from_first, from_last,
+                                            to_first_true, to_first_false,
+                                            std::move(p));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class DataType3,
-          class... Properties3, class PredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename DataType3,
+    typename... Properties3, typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto partition_copy(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
     const ::Kokkos::View<DataType2, Properties2...>& view_dest_true,
     const ::Kokkos::View<DataType3, Properties3...>& view_dest_false,
     PredicateType p) {
-  return Impl::partition_copy_impl("Kokkos::partition_copy_view_api_default",
-                                   ex, cbegin(view_from), cend(view_from),
-                                   begin(view_dest_true),
-                                   begin(view_dest_false), std::move(p));
+  return Impl::partition_copy_exespace_impl(
+      "Kokkos::partition_copy_view_api_default", ex, cbegin(view_from),
+      cend(view_from), begin(view_dest_true), begin(view_dest_false),
+      std::move(p));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class DataType3,
-          class... Properties3, class PredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename DataType3,
+    typename... Properties3, typename PredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto partition_copy(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
     const ::Kokkos::View<DataType2, Properties2...>& view_dest_true,
     const ::Kokkos::View<DataType3, Properties3...>& view_dest_false,
     PredicateType p) {
-  return Impl::partition_copy_impl(label, ex, cbegin(view_from),
-                                   cend(view_from), begin(view_dest_true),
-                                   begin(view_dest_false), std::move(p));
+  return Impl::partition_copy_exespace_impl(
+      label, ex, cbegin(view_from), cend(view_from), begin(view_dest_true),
+      begin(view_dest_false), std::move(p));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorTrueType, typename OutputIteratorFalseType,
+          typename PredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION ::Kokkos::pair<OutputIteratorTrueType, OutputIteratorFalseType>
+partition_copy(const TeamHandleType& teamHandle, InputIteratorType from_first,
+               InputIteratorType from_last,
+               OutputIteratorTrueType to_first_true,
+               OutputIteratorFalseType to_first_false, PredicateType p) {
+  return Impl::partition_copy_team_impl(teamHandle, from_first, from_last,
+                                        to_first_true, to_first_false,
+                                        std::move(p));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename DataType3,
+          typename... Properties3, typename PredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto partition_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest_true,
+    const ::Kokkos::View<DataType3, Properties3...>& view_dest_false,
+    PredicateType p) {
+  return Impl::partition_copy_team_impl(teamHandle, cbegin(view_from),
+                                        cend(view_from), begin(view_dest_true),
+                                        begin(view_dest_false), std::move(p));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_PartitionPoint.hpp b/algorithms/src/std_algorithms/Kokkos_PartitionPoint.hpp
index 24798e377e..60cbeeda87 100644
--- a/algorithms/src/std_algorithms/Kokkos_PartitionPoint.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_PartitionPoint.hpp
@@ -23,38 +23,78 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType, class UnaryPredicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType, typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType partition_point(const ExecutionSpace& ex, IteratorType first,
                              IteratorType last, UnaryPredicate p) {
-  return Impl::partition_point_impl(
+  return Impl::partition_point_exespace_impl(
       "Kokkos::partitioned_point_iterator_api_default", ex, first, last,
       std::move(p));
 }
 
-template <class ExecutionSpace, class IteratorType, class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename IteratorType, typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType partition_point(const std::string& label, const ExecutionSpace& ex,
                              IteratorType first, IteratorType last,
                              UnaryPredicate p) {
-  return Impl::partition_point_impl(label, ex, first, last, std::move(p));
+  return Impl::partition_point_exespace_impl(label, ex, first, last,
+                                             std::move(p));
 }
 
-template <class ExecutionSpace, class UnaryPredicate, class DataType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename UnaryPredicate, typename DataType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto partition_point(const std::string& label, const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType, Properties...>& v,
                      UnaryPredicate p) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
-  return Impl::partition_point_impl(label, ex, begin(v), end(v), std::move(p));
+  return Impl::partition_point_exespace_impl(label, ex, begin(v), end(v),
+                                             std::move(p));
 }
 
-template <class ExecutionSpace, class UnaryPredicate, class DataType,
-          class... Properties>
+template <
+    typename ExecutionSpace, typename UnaryPredicate, typename DataType,
+    typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto partition_point(const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType, Properties...>& v,
                      UnaryPredicate p) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
-  return Impl::partition_point_impl("Kokkos::partition_point_view_api_default",
-                                    ex, begin(v), end(v), std::move(p));
+  return Impl::partition_point_exespace_impl(
+      "Kokkos::partition_point_view_api_default", ex, begin(v), end(v),
+      std::move(p));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          typename UnaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType partition_point(const TeamHandleType& teamHandle,
+                                             IteratorType first,
+                                             IteratorType last,
+                                             UnaryPredicate p) {
+  return Impl::partition_point_team_impl(teamHandle, first, last, std::move(p));
+}
+
+template <typename TeamHandleType, typename UnaryPredicate, typename DataType,
+          typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto partition_point(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& v, UnaryPredicate p) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(v);
+  return Impl::partition_point_team_impl(teamHandle, begin(v), end(v),
+                                         std::move(p));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Reduce.hpp b/algorithms/src/std_algorithms/Kokkos_Reduce.hpp
index a31fa1497a..b84f00f8bb 100644
--- a/algorithms/src/std_algorithms/Kokkos_Reduce.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Reduce.hpp
@@ -23,28 +23,38 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 //
 // overload set 1
 //
-template <class ExecutionSpace, class IteratorType>
+template <typename ExecutionSpace, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 typename IteratorType::value_type reduce(const ExecutionSpace& ex,
                                          IteratorType first,
                                          IteratorType last) {
-  return Impl::reduce_default_functors_impl(
+  return Impl::reduce_default_functors_exespace_impl(
       "Kokkos::reduce_default_functors_iterator_api", ex, first, last,
       typename IteratorType::value_type());
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <typename ExecutionSpace, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 typename IteratorType::value_type reduce(const std::string& label,
                                          const ExecutionSpace& ex,
                                          IteratorType first,
                                          IteratorType last) {
-  return Impl::reduce_default_functors_impl(
+  return Impl::reduce_default_functors_exespace_impl(
       label, ex, first, last, typename IteratorType::value_type());
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto reduce(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view) {
   namespace KE = ::Kokkos::Experimental;
@@ -53,12 +63,14 @@ auto reduce(const ExecutionSpace& ex,
   using view_type  = ::Kokkos::View<DataType, Properties...>;
   using value_type = typename view_type::value_type;
 
-  return Impl::reduce_default_functors_impl(
+  return Impl::reduce_default_functors_exespace_impl(
       "Kokkos::reduce_default_functors_view_api", ex, KE::cbegin(view),
       KE::cend(view), value_type());
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto reduce(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view) {
   namespace KE = ::Kokkos::Experimental;
@@ -67,37 +79,43 @@ auto reduce(const std::string& label, const ExecutionSpace& ex,
   using view_type  = ::Kokkos::View<DataType, Properties...>;
   using value_type = typename view_type::value_type;
 
-  return Impl::reduce_default_functors_impl(label, ex, KE::cbegin(view),
-                                            KE::cend(view), value_type());
+  return Impl::reduce_default_functors_exespace_impl(
+      label, ex, KE::cbegin(view), KE::cend(view), value_type());
 }
 
 //
 // overload set2:
 //
-template <class ExecutionSpace, class IteratorType, class ValueType>
+template <typename ExecutionSpace, typename IteratorType, typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const ExecutionSpace& ex, IteratorType first,
                  IteratorType last, ValueType init_reduction_value) {
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::reduce_default_functors_impl(
+  return Impl::reduce_default_functors_exespace_impl(
       "Kokkos::reduce_default_functors_iterator_api", ex, first, last,
       init_reduction_value);
 }
 
-template <class ExecutionSpace, class IteratorType, class ValueType>
+template <typename ExecutionSpace, typename IteratorType, typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const std::string& label, const ExecutionSpace& ex,
                  IteratorType first, IteratorType last,
                  ValueType init_reduction_value) {
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::reduce_default_functors_impl(label, ex, first, last,
-                                            init_reduction_value);
+  return Impl::reduce_default_functors_exespace_impl(label, ex, first, last,
+                                                     init_reduction_value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& view,
                  ValueType init_reduction_value) {
@@ -107,13 +125,15 @@ ValueType reduce(const ExecutionSpace& ex,
   namespace KE = ::Kokkos::Experimental;
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::reduce_default_functors_impl(
+  return Impl::reduce_default_functors_exespace_impl(
       "Kokkos::reduce_default_functors_view_api", ex, KE::cbegin(view),
       KE::cend(view), init_reduction_value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& view,
                  ValueType init_reduction_value) {
@@ -123,40 +143,46 @@ ValueType reduce(const std::string& label, const ExecutionSpace& ex,
   namespace KE = ::Kokkos::Experimental;
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::reduce_default_functors_impl(
+  return Impl::reduce_default_functors_exespace_impl(
       label, ex, KE::cbegin(view), KE::cend(view), init_reduction_value);
 }
 
 //
 // overload set 3
 //
-template <class ExecutionSpace, class IteratorType, class ValueType,
-          class BinaryOp>
+template <typename ExecutionSpace, typename IteratorType, typename ValueType,
+          typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const ExecutionSpace& ex, IteratorType first,
                  IteratorType last, ValueType init_reduction_value,
                  BinaryOp joiner) {
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::reduce_custom_functors_impl(
+  return Impl::reduce_custom_functors_exespace_impl(
       "Kokkos::reduce_default_functors_iterator_api", ex, first, last,
       init_reduction_value, joiner);
 }
 
-template <class ExecutionSpace, class IteratorType, class ValueType,
-          class BinaryOp>
+template <typename ExecutionSpace, typename IteratorType, typename ValueType,
+          typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const std::string& label, const ExecutionSpace& ex,
                  IteratorType first, IteratorType last,
                  ValueType init_reduction_value, BinaryOp joiner) {
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::reduce_custom_functors_impl(label, ex, first, last,
-                                           init_reduction_value, joiner);
+  return Impl::reduce_custom_functors_exespace_impl(
+      label, ex, first, last, init_reduction_value, joiner);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType, class BinaryOp>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename ValueType, typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& view,
                  ValueType init_reduction_value, BinaryOp joiner) {
@@ -166,13 +192,15 @@ ValueType reduce(const ExecutionSpace& ex,
   namespace KE = ::Kokkos::Experimental;
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::reduce_custom_functors_impl(
+  return Impl::reduce_custom_functors_exespace_impl(
       "Kokkos::reduce_custom_functors_view_api", ex, KE::cbegin(view),
       KE::cend(view), init_reduction_value, joiner);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType, class BinaryOp>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename ValueType, typename BinaryOp,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType reduce(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& view,
                  ValueType init_reduction_value, BinaryOp joiner) {
@@ -182,9 +210,114 @@ ValueType reduce(const std::string& label, const ExecutionSpace& ex,
   namespace KE = ::Kokkos::Experimental;
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::reduce_custom_functors_impl(label, ex, KE::cbegin(view),
-                                           KE::cend(view), init_reduction_value,
-                                           joiner);
+  return Impl::reduce_custom_functors_exespace_impl(
+      label, ex, KE::cbegin(view), KE::cend(view), init_reduction_value,
+      joiner);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+//
+// overload set 1
+//
+template <
+    typename TeamHandleType, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION typename IteratorType::value_type reduce(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last) {
+  return Impl::reduce_default_functors_team_impl(
+      teamHandle, first, last, typename IteratorType::value_type());
+}
+
+template <
+    typename TeamHandleType, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto reduce(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view) {
+  namespace KE = ::Kokkos::Experimental;
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  using view_type  = ::Kokkos::View<DataType, Properties...>;
+  using value_type = typename view_type::value_type;
+
+  return Impl::reduce_default_functors_team_impl(teamHandle, KE::cbegin(view),
+                                                 KE::cend(view), value_type());
+}
+
+//
+// overload set2:
+//
+template <
+    typename TeamHandleType, typename IteratorType, typename ValueType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType reduce(const TeamHandleType& teamHandle,
+                                 IteratorType first, IteratorType last,
+                                 ValueType init_reduction_value) {
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  return Impl::reduce_default_functors_team_impl(teamHandle, first, last,
+                                                 init_reduction_value);
+}
+
+template <
+    typename TeamHandleType, typename DataType, typename... Properties,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType
+reduce(const TeamHandleType& teamHandle,
+       const ::Kokkos::View<DataType, Properties...>& view,
+       ValueType init_reduction_value) {
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  namespace KE = ::Kokkos::Experimental;
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  return Impl::reduce_default_functors_team_impl(
+      teamHandle, KE::cbegin(view), KE::cend(view), init_reduction_value);
+}
+
+//
+// overload set 3
+//
+template <
+    typename TeamHandleType, typename IteratorType, typename ValueType,
+    typename BinaryOp,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType reduce(const TeamHandleType& teamHandle,
+                                 IteratorType first, IteratorType last,
+                                 ValueType init_reduction_value,
+                                 BinaryOp joiner) {
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  return Impl::reduce_custom_functors_team_impl(teamHandle, first, last,
+                                                init_reduction_value, joiner);
+}
+
+template <
+    typename TeamHandleType, typename DataType, typename... Properties,
+    typename ValueType, typename BinaryOp,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType
+reduce(const TeamHandleType& teamHandle,
+       const ::Kokkos::View<DataType, Properties...>& view,
+       ValueType init_reduction_value, BinaryOp joiner) {
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  namespace KE = ::Kokkos::Experimental;
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  return Impl::reduce_custom_functors_team_impl(teamHandle, KE::cbegin(view),
+                                                KE::cend(view),
+                                                init_reduction_value, joiner);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Remove.hpp b/algorithms/src/std_algorithms/Kokkos_Remove.hpp
index c8602d2f53..8a429d8d51 100644
--- a/algorithms/src/std_algorithms/Kokkos_Remove.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Remove.hpp
@@ -23,38 +23,74 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class Iterator, class ValueType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename Iterator, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 Iterator remove(const ExecutionSpace& ex, Iterator first, Iterator last,
                 const ValueType& value) {
-  return Impl::remove_impl("Kokkos::remove_iterator_api_default", ex, first,
-                           last, value);
+  return Impl::remove_exespace_impl("Kokkos::remove_iterator_api_default", ex,
+                                    first, last, value);
 }
 
-template <class ExecutionSpace, class Iterator, class ValueType>
+template <
+    typename ExecutionSpace, typename Iterator, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 Iterator remove(const std::string& label, const ExecutionSpace& ex,
                 Iterator first, Iterator last, const ValueType& value) {
-  return Impl::remove_impl(label, ex, first, last, value);
+  return Impl::remove_exespace_impl(label, ex, first, last, value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view,
             const ValueType& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::remove_impl("Kokkos::remove_iterator_api_default", ex,
-                           ::Kokkos::Experimental::begin(view),
-                           ::Kokkos::Experimental::end(view), value);
+  return Impl::remove_exespace_impl("Kokkos::remove_iterator_api_default", ex,
+                                    ::Kokkos::Experimental::begin(view),
+                                    ::Kokkos::Experimental::end(view), value);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view,
             const ValueType& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::remove_impl(label, ex, ::Kokkos::Experimental::begin(view),
-                           ::Kokkos::Experimental::end(view), value);
+  return Impl::remove_exespace_impl(label, ex,
+                                    ::Kokkos::Experimental::begin(view),
+                                    ::Kokkos::Experimental::end(view), value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename Iterator, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION Iterator remove(const TeamHandleType& teamHandle,
+                                Iterator first, Iterator last,
+                                const ValueType& value) {
+  return Impl::remove_team_impl(teamHandle, first, last, value);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto remove(const TeamHandleType& teamHandle,
+                            const ::Kokkos::View<DataType, Properties...>& view,
+                            const ValueType& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  return Impl::remove_team_impl(teamHandle, ::Kokkos::Experimental::begin(view),
+                                ::Kokkos::Experimental::end(view), value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_RemoveCopy.hpp b/algorithms/src/std_algorithms/Kokkos_RemoveCopy.hpp
index c2c06f6202..4b8fa9fe07 100644
--- a/algorithms/src/std_algorithms/Kokkos_RemoveCopy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_RemoveCopy.hpp
@@ -23,26 +23,36 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class ValueType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator remove_copy(const ExecutionSpace& ex, InputIterator first_from,
                            InputIterator last_from, OutputIterator first_dest,
                            const ValueType& value) {
-  return Impl::remove_copy_impl("Kokkos::remove_copy_iterator_api_default", ex,
-                                first_from, last_from, first_dest, value);
+  return Impl::remove_copy_exespace_impl(
+      "Kokkos::remove_copy_iterator_api_default", ex, first_from, last_from,
+      first_dest, value);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator remove_copy(const std::string& label, const ExecutionSpace& ex,
                            InputIterator first_from, InputIterator last_from,
                            OutputIterator first_dest, const ValueType& value) {
-  return Impl::remove_copy_impl(label, ex, first_from, last_from, first_dest,
-                                value);
+  return Impl::remove_copy_exespace_impl(label, ex, first_from, last_from,
+                                         first_dest, value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove_copy(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& view_from,
                  const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -50,15 +60,17 @@ auto remove_copy(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
 
-  return Impl::remove_copy_impl("Kokkos::remove_copy_iterator_api_default", ex,
-                                ::Kokkos::Experimental::cbegin(view_from),
-                                ::Kokkos::Experimental::cend(view_from),
-                                ::Kokkos::Experimental::begin(view_dest),
-                                value);
+  return Impl::remove_copy_exespace_impl(
+      "Kokkos::remove_copy_iterator_api_default", ex,
+      ::Kokkos::Experimental::cbegin(view_from),
+      ::Kokkos::Experimental::cend(view_from),
+      ::Kokkos::Experimental::begin(view_dest), value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove_copy(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& view_from,
                  const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -66,12 +78,46 @@ auto remove_copy(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
 
-  return Impl::remove_copy_impl(
+  return Impl::remove_copy_exespace_impl(
       label, ex, ::Kokkos::Experimental::cbegin(view_from),
       ::Kokkos::Experimental::cend(view_from),
       ::Kokkos::Experimental::begin(view_dest), value);
 }
 
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator remove_copy(const TeamHandleType& teamHandle,
+                                           InputIterator first_from,
+                                           InputIterator last_from,
+                                           OutputIterator first_dest,
+                                           const ValueType& value) {
+  return Impl::remove_copy_team_impl(teamHandle, first_from, last_from,
+                                     first_dest, value);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto remove_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    const ValueType& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+
+  return Impl::remove_copy_team_impl(
+      teamHandle, ::Kokkos::Experimental::cbegin(view_from),
+      ::Kokkos::Experimental::cend(view_from),
+      ::Kokkos::Experimental::begin(view_dest), value);
+}
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_RemoveCopyIf.hpp b/algorithms/src/std_algorithms/Kokkos_RemoveCopyIf.hpp
index 6d642ed6f0..45e2b54bb6 100644
--- a/algorithms/src/std_algorithms/Kokkos_RemoveCopyIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_RemoveCopyIf.hpp
@@ -23,30 +23,39 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class UnaryPredicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator remove_copy_if(const ExecutionSpace& ex,
                               InputIterator first_from, InputIterator last_from,
                               OutputIterator first_dest,
                               const UnaryPredicate& pred) {
-  return Impl::remove_copy_if_impl(
+  return Impl::remove_copy_if_exespace_impl(
       "Kokkos::remove_copy_if_iterator_api_default", ex, first_from, last_from,
       first_dest, pred);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator remove_copy_if(const std::string& label,
                               const ExecutionSpace& ex,
                               InputIterator first_from, InputIterator last_from,
                               OutputIterator first_dest,
                               const UnaryPredicate& pred) {
-  return Impl::remove_copy_if_impl(label, ex, first_from, last_from, first_dest,
-                                   pred);
+  return Impl::remove_copy_if_exespace_impl(label, ex, first_from, last_from,
+                                            first_dest, pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove_copy_if(const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -54,15 +63,17 @@ auto remove_copy_if(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
 
-  return Impl::remove_copy_if_impl(
+  return Impl::remove_copy_if_exespace_impl(
       "Kokkos::remove_copy_if_iterator_api_default", ex,
       ::Kokkos::Experimental::cbegin(view_from),
       ::Kokkos::Experimental::cend(view_from),
       ::Kokkos::Experimental::begin(view_dest), pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove_copy_if(const std::string& label, const ExecutionSpace& ex,
                     const ::Kokkos::View<DataType1, Properties1...>& view_from,
                     const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -70,12 +81,46 @@ auto remove_copy_if(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
 
-  return Impl::remove_copy_if_impl(
+  return Impl::remove_copy_if_exespace_impl(
       label, ex, ::Kokkos::Experimental::cbegin(view_from),
       ::Kokkos::Experimental::cend(view_from),
       ::Kokkos::Experimental::begin(view_dest), pred);
 }
 
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator, typename UnaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator remove_copy_if(const TeamHandleType& teamHandle,
+                                              InputIterator first_from,
+                                              InputIterator last_from,
+                                              OutputIterator first_dest,
+                                              const UnaryPredicate& pred) {
+  return Impl::remove_copy_if_team_impl(teamHandle, first_from, last_from,
+                                        first_dest, pred);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename UnaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto remove_copy_if(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    const UnaryPredicate& pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+
+  return Impl::remove_copy_if_team_impl(
+      teamHandle, ::Kokkos::Experimental::cbegin(view_from),
+      ::Kokkos::Experimental::cend(view_from),
+      ::Kokkos::Experimental::begin(view_dest), pred);
+}
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_RemoveIf.hpp b/algorithms/src/std_algorithms/Kokkos_RemoveIf.hpp
index 4062e8d373..38461a37f2 100644
--- a/algorithms/src/std_algorithms/Kokkos_RemoveIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_RemoveIf.hpp
@@ -23,39 +23,77 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class Iterator, class UnaryPredicate>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename Iterator, typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 Iterator remove_if(const ExecutionSpace& ex, Iterator first, Iterator last,
                    UnaryPredicate pred) {
-  return Impl::remove_if_impl("Kokkos::remove_if_iterator_api_default", ex,
-                              first, last, pred);
+  return Impl::remove_if_exespace_impl("Kokkos::remove_if_iterator_api_default",
+                                       ex, first, last, pred);
 }
 
-template <class ExecutionSpace, class Iterator, class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename Iterator, typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 Iterator remove_if(const std::string& label, const ExecutionSpace& ex,
                    Iterator first, Iterator last, UnaryPredicate pred) {
-  return Impl::remove_if_impl(label, ex, first, last, pred);
+  return Impl::remove_if_exespace_impl(label, ex, first, last, pred);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove_if(const ExecutionSpace& ex,
                const ::Kokkos::View<DataType, Properties...>& view,
                UnaryPredicate pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::remove_if_impl("Kokkos::remove_if_iterator_api_default", ex,
-                              ::Kokkos::Experimental::begin(view),
-                              ::Kokkos::Experimental::end(view), pred);
+  return Impl::remove_if_exespace_impl("Kokkos::remove_if_iterator_api_default",
+                                       ex, ::Kokkos::Experimental::begin(view),
+                                       ::Kokkos::Experimental::end(view), pred);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class UnaryPredicate>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename UnaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto remove_if(const std::string& label, const ExecutionSpace& ex,
                const ::Kokkos::View<DataType, Properties...>& view,
                UnaryPredicate pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::remove_if_impl(label, ex, ::Kokkos::Experimental::begin(view),
-                              ::Kokkos::Experimental::end(view), pred);
+  return Impl::remove_if_exespace_impl(label, ex,
+                                       ::Kokkos::Experimental::begin(view),
+                                       ::Kokkos::Experimental::end(view), pred);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename Iterator, typename UnaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION Iterator remove_if(const TeamHandleType& teamHandle,
+                                   Iterator first, Iterator last,
+                                   UnaryPredicate pred) {
+  return Impl::remove_if_team_impl(teamHandle, first, last, pred);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename UnaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto remove_if(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, UnaryPredicate pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  return Impl::remove_if_team_impl(teamHandle,
+                                   ::Kokkos::Experimental::begin(view),
+                                   ::Kokkos::Experimental::end(view), pred);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Replace.hpp b/algorithms/src/std_algorithms/Kokkos_Replace.hpp
index 4d1490ded0..29afc4f0c2 100644
--- a/algorithms/src/std_algorithms/Kokkos_Replace.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Replace.hpp
@@ -23,40 +23,77 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class Iterator, class ValueType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename Iterator, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace(const ExecutionSpace& ex, Iterator first, Iterator last,
              const ValueType& old_value, const ValueType& new_value) {
-  return Impl::replace_impl("Kokkos::replace_iterator_api", ex, first, last,
-                            old_value, new_value);
+  Impl::replace_exespace_impl("Kokkos::replace_iterator_api", ex, first, last,
+                              old_value, new_value);
 }
 
-template <class ExecutionSpace, class Iterator, class ValueType>
+template <
+    typename ExecutionSpace, typename Iterator, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace(const std::string& label, const ExecutionSpace& ex, Iterator first,
              Iterator last, const ValueType& old_value,
              const ValueType& new_value) {
-  return Impl::replace_impl(label, ex, first, last, old_value, new_value);
+  Impl::replace_exespace_impl(label, ex, first, last, old_value, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace(const ExecutionSpace& ex,
              const ::Kokkos::View<DataType1, Properties1...>& view,
              const ValueType& old_value, const ValueType& new_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_impl("Kokkos::replace_view_api", ex, KE::begin(view),
-                            KE::end(view), old_value, new_value);
+  Impl::replace_exespace_impl("Kokkos::replace_view_api", ex, KE::begin(view),
+                              KE::end(view), old_value, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace(const std::string& label, const ExecutionSpace& ex,
              const ::Kokkos::View<DataType1, Properties1...>& view,
              const ValueType& old_value, const ValueType& new_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_impl(label, ex, KE::begin(view), KE::end(view),
-                            old_value, new_value);
+  Impl::replace_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                              old_value, new_value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename Iterator, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void replace(const TeamHandleType& teamHandle, Iterator first,
+                             Iterator last, const ValueType& old_value,
+                             const ValueType& new_value) {
+  Impl::replace_team_impl(teamHandle, first, last, old_value, new_value);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void replace(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ValueType& old_value, const ValueType& new_value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  namespace KE = ::Kokkos::Experimental;
+  Impl::replace_team_impl(teamHandle, KE::begin(view), KE::end(view), old_value,
+                          new_value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ReplaceCopy.hpp b/algorithms/src/std_algorithms/Kokkos_ReplaceCopy.hpp
index e7f464e4bd..04d5767e89 100644
--- a/algorithms/src/std_algorithms/Kokkos_ReplaceCopy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ReplaceCopy.hpp
@@ -23,30 +23,39 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class ValueType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator replace_copy(const ExecutionSpace& ex, InputIterator first_from,
                             InputIterator last_from, OutputIterator first_dest,
                             const ValueType& old_value,
                             const ValueType& new_value) {
-  return Impl::replace_copy_impl("Kokkos::replace_copy_iterator_api", ex,
-                                 first_from, last_from, first_dest, old_value,
-                                 new_value);
+  return Impl::replace_copy_exespace_impl("Kokkos::replace_copy_iterator_api",
+                                          ex, first_from, last_from, first_dest,
+                                          old_value, new_value);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator replace_copy(const std::string& label, const ExecutionSpace& ex,
                             InputIterator first_from, InputIterator last_from,
                             OutputIterator first_dest,
                             const ValueType& old_value,
                             const ValueType& new_value) {
-  return Impl::replace_copy_impl(label, ex, first_from, last_from, first_dest,
-                                 old_value, new_value);
+  return Impl::replace_copy_exespace_impl(label, ex, first_from, last_from,
+                                          first_dest, old_value, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto replace_copy(const ExecutionSpace& ex,
                   const ::Kokkos::View<DataType1, Properties1...>& view_from,
                   const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -54,13 +63,15 @@ auto replace_copy(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_copy_impl("Kokkos::replace_copy_view_api", ex,
-                                 KE::cbegin(view_from), KE::cend(view_from),
-                                 KE::begin(view_dest), old_value, new_value);
+  return Impl::replace_copy_exespace_impl(
+      "Kokkos::replace_copy_view_api", ex, KE::cbegin(view_from),
+      KE::cend(view_from), KE::begin(view_dest), old_value, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto replace_copy(const std::string& label, const ExecutionSpace& ex,
                   const ::Kokkos::View<DataType1, Properties1...>& view_from,
                   const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -68,9 +79,43 @@ auto replace_copy(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_copy_impl(label, ex, KE::cbegin(view_from),
-                                 KE::cend(view_from), KE::begin(view_dest),
-                                 old_value, new_value);
+  return Impl::replace_copy_exespace_impl(
+      label, ex, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), old_value, new_value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator replace_copy(const TeamHandleType& teamHandle,
+                                            InputIterator first_from,
+                                            InputIterator last_from,
+                                            OutputIterator first_dest,
+                                            const ValueType& old_value,
+                                            const ValueType& new_value) {
+  return Impl::replace_copy_team_impl(teamHandle, first_from, last_from,
+                                      first_dest, old_value, new_value);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto replace_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    const ValueType& old_value, const ValueType& new_value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::replace_copy_team_impl(teamHandle, KE::cbegin(view_from),
+                                      KE::cend(view_from), KE::begin(view_dest),
+                                      old_value, new_value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ReplaceCopyIf.hpp b/algorithms/src/std_algorithms/Kokkos_ReplaceCopyIf.hpp
index 71ae8f8452..b87163f194 100644
--- a/algorithms/src/std_algorithms/Kokkos_ReplaceCopyIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ReplaceCopyIf.hpp
@@ -23,33 +23,42 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class PredicateType, class ValueType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename PredicateType, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator replace_copy_if(const ExecutionSpace& ex,
                                InputIterator first_from,
                                InputIterator last_from,
                                OutputIterator first_dest, PredicateType pred,
                                const ValueType& new_value) {
-  return Impl::replace_copy_if_impl("Kokkos::replace_copy_if_iterator_api", ex,
-                                    first_from, last_from, first_dest, pred,
-                                    new_value);
+  return Impl::replace_copy_if_exespace_impl(
+      "Kokkos::replace_copy_if_iterator_api", ex, first_from, last_from,
+      first_dest, pred, new_value);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class PredicateType, class ValueType>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename PredicateType, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator replace_copy_if(const std::string& label,
                                const ExecutionSpace& ex,
                                InputIterator first_from,
                                InputIterator last_from,
                                OutputIterator first_dest, PredicateType pred,
                                const ValueType& new_value) {
-  return Impl::replace_copy_if_impl(label, ex, first_from, last_from,
-                                    first_dest, pred, new_value);
+  return Impl::replace_copy_if_exespace_impl(label, ex, first_from, last_from,
+                                             first_dest, pred, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class PredicateType,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename PredicateType,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto replace_copy_if(const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType1, Properties1...>& view_from,
                      const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -57,14 +66,16 @@ auto replace_copy_if(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_copy_if_impl("Kokkos::replace_copy_if_view_api", ex,
-                                    KE::cbegin(view_from), KE::cend(view_from),
-                                    KE::begin(view_dest), pred, new_value);
+  return Impl::replace_copy_if_exespace_impl(
+      "Kokkos::replace_copy_if_view_api", ex, KE::cbegin(view_from),
+      KE::cend(view_from), KE::begin(view_dest), pred, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class PredicateType,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename PredicateType,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto replace_copy_if(const std::string& label, const ExecutionSpace& ex,
                      const ::Kokkos::View<DataType1, Properties1...>& view_from,
                      const ::Kokkos::View<DataType2, Properties2...>& view_dest,
@@ -72,9 +83,44 @@ auto replace_copy_if(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_copy_if_impl(label, ex, KE::cbegin(view_from),
-                                    KE::cend(view_from), KE::begin(view_dest),
-                                    pred, new_value);
+  return Impl::replace_copy_if_exespace_impl(
+      label, ex, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), pred, new_value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator, typename PredicateType, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator replace_copy_if(const TeamHandleType& teamHandle,
+                                               InputIterator first_from,
+                                               InputIterator last_from,
+                                               OutputIterator first_dest,
+                                               PredicateType pred,
+                                               const ValueType& new_value) {
+  return Impl::replace_copy_if_team_impl(teamHandle, first_from, last_from,
+                                         first_dest, pred, new_value);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename PredicateType,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto replace_copy_if(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    PredicateType pred, const ValueType& new_value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::replace_copy_if_team_impl(teamHandle, KE::cbegin(view_from),
+                                         KE::cend(view_from),
+                                         KE::begin(view_dest), pred, new_value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ReplaceIf.hpp b/algorithms/src/std_algorithms/Kokkos_ReplaceIf.hpp
index 7f06540e06..73af1f16f0 100644
--- a/algorithms/src/std_algorithms/Kokkos_ReplaceIf.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ReplaceIf.hpp
@@ -23,43 +23,82 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class Predicate,
-          class ValueType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename Predicate,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace_if(const ExecutionSpace& ex, InputIterator first,
                 InputIterator last, Predicate pred,
                 const ValueType& new_value) {
-  return Impl::replace_if_impl("Kokkos::replace_if_iterator_api", ex, first,
-                               last, pred, new_value);
+  Impl::replace_if_exespace_impl("Kokkos::replace_if_iterator_api", ex, first,
+                                 last, pred, new_value);
 }
 
-template <class ExecutionSpace, class InputIterator, class Predicate,
-          class ValueType>
+template <
+    typename ExecutionSpace, typename InputIterator, typename Predicate,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace_if(const std::string& label, const ExecutionSpace& ex,
                 InputIterator first, InputIterator last, Predicate pred,
                 const ValueType& new_value) {
-  return Impl::replace_if_impl(label, ex, first, last, pred, new_value);
+  Impl::replace_if_exespace_impl(label, ex, first, last, pred, new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class Predicate, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename Predicate, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace_if(const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType1, Properties1...>& view,
                 Predicate pred, const ValueType& new_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_if_impl("Kokkos::replace_if_view_api", ex,
-                               KE::begin(view), KE::end(view), pred, new_value);
+  Impl::replace_if_exespace_impl("Kokkos::replace_if_view_api", ex,
+                                 KE::begin(view), KE::end(view), pred,
+                                 new_value);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class Predicate, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename Predicate, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void replace_if(const std::string& label, const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType1, Properties1...>& view,
                 Predicate pred, const ValueType& new_value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::replace_if_impl(label, ex, KE::begin(view), KE::end(view), pred,
-                               new_value);
+  Impl::replace_if_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                 pred, new_value);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator, typename Predicate,
+          typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void replace_if(const TeamHandleType& teamHandle,
+                                InputIterator first, InputIterator last,
+                                Predicate pred, const ValueType& new_value) {
+  Impl::replace_if_team_impl(teamHandle, first, last, pred, new_value);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename Predicate, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void replace_if(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view, Predicate pred,
+    const ValueType& new_value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  namespace KE = ::Kokkos::Experimental;
+  Impl::replace_if_team_impl(teamHandle, KE::begin(view), KE::end(view), pred,
+                             new_value);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Reverse.hpp b/algorithms/src/std_algorithms/Kokkos_Reverse.hpp
index 9f2fc5f3cc..a0786d3a2e 100644
--- a/algorithms/src/std_algorithms/Kokkos_Reverse.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Reverse.hpp
@@ -23,34 +23,67 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void reverse(const ExecutionSpace& ex, InputIterator first,
              InputIterator last) {
-  return Impl::reverse_impl("Kokkos::reverse_iterator_api_default", ex, first,
-                            last);
+  return Impl::reverse_exespace_impl("Kokkos::reverse_iterator_api_default", ex,
+                                     first, last);
 }
 
-template <class ExecutionSpace, class InputIterator>
+template <
+    typename ExecutionSpace, typename InputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void reverse(const std::string& label, const ExecutionSpace& ex,
              InputIterator first, InputIterator last) {
-  return Impl::reverse_impl(label, ex, first, last);
+  return Impl::reverse_exespace_impl(label, ex, first, last);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void reverse(const ExecutionSpace& ex,
              const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::reverse_impl("Kokkos::reverse_view_api_default", ex,
-                            KE::begin(view), KE::end(view));
+  return Impl::reverse_exespace_impl("Kokkos::reverse_view_api_default", ex,
+                                     KE::begin(view), KE::end(view));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 void reverse(const std::string& label, const ExecutionSpace& ex,
              const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::reverse_impl(label, ex, KE::begin(view), KE::end(view));
+  return Impl::reverse_exespace_impl(label, ex, KE::begin(view), KE::end(view));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void reverse(const TeamHandleType& teamHandle,
+                             InputIterator first, InputIterator last) {
+  return Impl::reverse_team_impl(teamHandle, first, last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION void reverse(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::reverse_team_impl(teamHandle, KE::begin(view), KE::end(view));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ReverseCopy.hpp b/algorithms/src/std_algorithms/Kokkos_ReverseCopy.hpp
index 279bb22086..66f39c4eaa 100644
--- a/algorithms/src/std_algorithms/Kokkos_ReverseCopy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ReverseCopy.hpp
@@ -23,42 +23,83 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator reverse_copy(const ExecutionSpace& ex, InputIterator first,
                             InputIterator last, OutputIterator d_first) {
-  return Impl::reverse_copy_impl("Kokkos::reverse_copy_iterator_api_default",
-                                 ex, first, last, d_first);
+  return Impl::reverse_copy_exespace_impl(
+      "Kokkos::reverse_copy_iterator_api_default", ex, first, last, d_first);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator reverse_copy(const std::string& label, const ExecutionSpace& ex,
                             InputIterator first, InputIterator last,
                             OutputIterator d_first) {
-  return Impl::reverse_copy_impl(label, ex, first, last, d_first);
+  return Impl::reverse_copy_exespace_impl(label, ex, first, last, d_first);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto reverse_copy(const ExecutionSpace& ex,
                   const ::Kokkos::View<DataType1, Properties1...>& source,
-                  ::Kokkos::View<DataType2, Properties2...>& dest) {
+                  const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::reverse_copy_impl("Kokkos::reverse_copy_view_api_default", ex,
-                                 cbegin(source), cend(source), begin(dest));
+  return Impl::reverse_copy_exespace_impl(
+      "Kokkos::reverse_copy_view_api_default", ex, cbegin(source), cend(source),
+      begin(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto reverse_copy(const std::string& label, const ExecutionSpace& ex,
                   const ::Kokkos::View<DataType1, Properties1...>& source,
-                  ::Kokkos::View<DataType2, Properties2...>& dest) {
+                  const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::reverse_copy_exespace_impl(label, ex, cbegin(source),
+                                          cend(source), begin(dest));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator reverse_copy(const TeamHandleType& teamHandle,
+                                            InputIterator first,
+                                            InputIterator last,
+                                            OutputIterator d_first) {
+  return Impl::reverse_copy_team_impl(teamHandle, first, last, d_first);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto reverse_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::reverse_copy_impl(label, ex, cbegin(source), cend(source),
-                                 begin(dest));
+  return Impl::reverse_copy_team_impl(teamHandle, cbegin(source), cend(source),
+                                      begin(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Rotate.hpp b/algorithms/src/std_algorithms/Kokkos_Rotate.hpp
index 738e9bf137..aff04b47d6 100644
--- a/algorithms/src/std_algorithms/Kokkos_Rotate.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Rotate.hpp
@@ -23,36 +23,71 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType rotate(const ExecutionSpace& ex, IteratorType first,
                     IteratorType n_first, IteratorType last) {
-  return Impl::rotate_impl("Kokkos::rotate_iterator_api_default", ex, first,
-                           n_first, last);
+  return Impl::rotate_exespace_impl("Kokkos::rotate_iterator_api_default", ex,
+                                    first, n_first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType rotate(const std::string& label, const ExecutionSpace& ex,
                     IteratorType first, IteratorType n_first,
                     IteratorType last) {
-  return Impl::rotate_impl(label, ex, first, n_first, last);
+  return Impl::rotate_exespace_impl(label, ex, first, n_first, last);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto rotate(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view,
             std::size_t n_location) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::rotate_impl("Kokkos::rotate_view_api_default", ex, begin(view),
-                           begin(view) + n_location, end(view));
+  return Impl::rotate_exespace_impl("Kokkos::rotate_view_api_default", ex,
+                                    begin(view), begin(view) + n_location,
+                                    end(view));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto rotate(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view,
             std::size_t n_location) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::rotate_impl(label, ex, begin(view), begin(view) + n_location,
-                           end(view));
+  return Impl::rotate_exespace_impl(label, ex, begin(view),
+                                    begin(view) + n_location, end(view));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType rotate(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType n_first,
+                                    IteratorType last) {
+  return Impl::rotate_team_impl(teamHandle, first, n_first, last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto rotate(const TeamHandleType& teamHandle,
+                            const ::Kokkos::View<DataType, Properties...>& view,
+                            std::size_t n_location) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  return Impl::rotate_team_impl(teamHandle, begin(view),
+                                begin(view) + n_location, end(view));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_RotateCopy.hpp b/algorithms/src/std_algorithms/Kokkos_RotateCopy.hpp
index f5d826c4bb..cce37fccfa 100644
--- a/algorithms/src/std_algorithms/Kokkos_RotateCopy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_RotateCopy.hpp
@@ -23,23 +23,34 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator rotate_copy(const ExecutionSpace& ex, InputIterator first,
                            InputIterator n_first, InputIterator last,
                            OutputIterator d_first) {
-  return Impl::rotate_copy_impl("Kokkos::rotate_copy_iterator_api_default", ex,
-                                first, n_first, last, d_first);
+  return Impl::rotate_copy_exespace_impl(
+      "Kokkos::rotate_copy_iterator_api_default", ex, first, n_first, last,
+      d_first);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator rotate_copy(const std::string& label, const ExecutionSpace& ex,
                            InputIterator first, InputIterator n_first,
                            InputIterator last, OutputIterator d_first) {
-  return Impl::rotate_copy_impl(label, ex, first, n_first, last, d_first);
+  return Impl::rotate_copy_exespace_impl(label, ex, first, n_first, last,
+                                         d_first);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto rotate_copy(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
                  std::size_t n_location,
@@ -47,13 +58,15 @@ auto rotate_copy(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::rotate_copy_impl("Kokkos::rotate_copy_view_api_default", ex,
-                                cbegin(source), cbegin(source) + n_location,
-                                cend(source), begin(dest));
+  return Impl::rotate_copy_exespace_impl(
+      "Kokkos::rotate_copy_view_api_default", ex, cbegin(source),
+      cbegin(source) + n_location, cend(source), begin(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto rotate_copy(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
                  std::size_t n_location,
@@ -61,9 +74,41 @@ auto rotate_copy(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::rotate_copy_impl(label, ex, cbegin(source),
-                                cbegin(source) + n_location, cend(source),
-                                begin(dest));
+  return Impl::rotate_copy_exespace_impl(label, ex, cbegin(source),
+                                         cbegin(source) + n_location,
+                                         cend(source), begin(dest));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator rotate_copy(const TeamHandleType& teamHandle,
+                                           InputIterator first,
+                                           InputIterator n_first,
+                                           InputIterator last,
+                                           OutputIterator d_first) {
+  return Impl::rotate_copy_team_impl(teamHandle, first, n_first, last, d_first);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto rotate_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    std::size_t n_location,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::rotate_copy_team_impl(teamHandle, cbegin(source),
+                                     cbegin(source) + n_location, cend(source),
+                                     begin(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Search.hpp b/algorithms/src/std_algorithms/Kokkos_Search.hpp
index b1154b297e..43258a484e 100644
--- a/algorithms/src/std_algorithms/Kokkos_Search.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Search.hpp
@@ -23,24 +23,34 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1: no binary predicate passed
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 search(const ExecutionSpace& ex, IteratorType1 first,
                      IteratorType1 last, IteratorType2 s_first,
                      IteratorType2 s_last) {
-  return Impl::search_impl("Kokkos::search_iterator_api_default", ex, first,
-                           last, s_first, s_last);
+  return Impl::search_exespace_impl("Kokkos::search_iterator_api_default", ex,
+                                    first, last, s_first, s_last);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 search(const std::string& label, const ExecutionSpace& ex,
                      IteratorType1 first, IteratorType1 last,
                      IteratorType2 s_first, IteratorType2 s_last) {
-  return Impl::search_impl(label, ex, first, last, s_first, s_last);
+  return Impl::search_exespace_impl(label, ex, first, last, s_first, s_last);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto search(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType1, Properties1...>& view,
             const ::Kokkos::View<DataType2, Properties2...>& s_view) {
@@ -48,13 +58,15 @@ auto search(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_impl("Kokkos::search_view_api_default", ex,
-                           KE::begin(view), KE::end(view), KE::begin(s_view),
-                           KE::end(s_view));
+  return Impl::search_exespace_impl("Kokkos::search_view_api_default", ex,
+                                    KE::begin(view), KE::end(view),
+                                    KE::begin(s_view), KE::end(s_view));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto search(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType1, Properties1...>& view,
             const ::Kokkos::View<DataType2, Properties2...>& s_view) {
@@ -62,31 +74,38 @@ auto search(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_impl(label, ex, KE::begin(view), KE::end(view),
-                           KE::begin(s_view), KE::end(s_view));
+  return Impl::search_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                    KE::begin(s_view), KE::end(s_view));
 }
 
 // overload set 2: binary predicate passed
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 search(const ExecutionSpace& ex, IteratorType1 first,
                      IteratorType1 last, IteratorType2 s_first,
                      IteratorType2 s_last, const BinaryPredicateType& pred) {
-  return Impl::search_impl("Kokkos::search_iterator_api_default", ex, first,
-                           last, s_first, s_last, pred);
+  return Impl::search_exespace_impl("Kokkos::search_iterator_api_default", ex,
+                                    first, last, s_first, s_last, pred);
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType1 search(const std::string& label, const ExecutionSpace& ex,
                      IteratorType1 first, IteratorType1 last,
                      IteratorType2 s_first, IteratorType2 s_last,
                      const BinaryPredicateType& pred) {
-  return Impl::search_impl(label, ex, first, last, s_first, s_last, pred);
+  return Impl::search_exespace_impl(label, ex, first, last, s_first, s_last,
+                                    pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto search(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType1, Properties1...>& view,
             const ::Kokkos::View<DataType2, Properties2...>& s_view,
@@ -95,13 +114,15 @@ auto search(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_impl("Kokkos::search_view_api_default", ex,
-                           KE::begin(view), KE::end(view), KE::begin(s_view),
-                           KE::end(s_view), pred);
+  return Impl::search_exespace_impl("Kokkos::search_view_api_default", ex,
+                                    KE::begin(view), KE::end(view),
+                                    KE::begin(s_view), KE::end(s_view), pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicateType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto search(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType1, Properties1...>& view,
             const ::Kokkos::View<DataType2, Properties2...>& s_view,
@@ -110,8 +131,70 @@ auto search(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_impl(label, ex, KE::begin(view), KE::end(view),
-                           KE::begin(s_view), KE::end(s_view), pred);
+  return Impl::search_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                    KE::begin(s_view), KE::end(s_view), pred);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1: no binary predicate passed
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType1 search(const TeamHandleType& teamHandle,
+                                     IteratorType1 first, IteratorType1 last,
+                                     IteratorType2 s_first,
+                                     IteratorType2 s_last) {
+  return Impl::search_team_impl(teamHandle, first, last, s_first, s_last);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto search(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ::Kokkos::View<DataType2, Properties2...>& s_view) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::search_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                                KE::begin(s_view), KE::end(s_view));
+}
+
+// overload set 2: binary predicate passed
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2, typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+
+KOKKOS_FUNCTION IteratorType1 search(const TeamHandleType& teamHandle,
+                                     IteratorType1 first, IteratorType1 last,
+                                     IteratorType2 s_first,
+                                     IteratorType2 s_last,
+                                     const BinaryPredicateType& pred) {
+  return Impl::search_team_impl(teamHandle, first, last, s_first, s_last, pred);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          typename BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto search(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view,
+    const ::Kokkos::View<DataType2, Properties2...>& s_view,
+    const BinaryPredicateType& pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(s_view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::search_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                                KE::begin(s_view), KE::end(s_view), pred);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_SearchN.hpp b/algorithms/src/std_algorithms/Kokkos_SearchN.hpp
index a649c8f205..0f8aa5f1c1 100644
--- a/algorithms/src/std_algorithms/Kokkos_SearchN.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_SearchN.hpp
@@ -23,68 +23,86 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1: no binary predicate passed
-template <class ExecutionSpace, class IteratorType, class SizeType,
-          class ValueType>
+template <
+    class ExecutionSpace, class IteratorType, class SizeType, class ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType search_n(const ExecutionSpace& ex, IteratorType first,
                       IteratorType last, SizeType count,
                       const ValueType& value) {
-  return Impl::search_n_impl("Kokkos::search_n_iterator_api_default", ex, first,
-                             last, count, value);
+  return Impl::search_n_exespace_impl("Kokkos::search_n_iterator_api_default",
+                                      ex, first, last, count, value);
 }
 
-template <class ExecutionSpace, class IteratorType, class SizeType,
-          class ValueType>
+template <
+    class ExecutionSpace, class IteratorType, class SizeType, class ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType search_n(const std::string& label, const ExecutionSpace& ex,
                       IteratorType first, IteratorType last, SizeType count,
                       const ValueType& value) {
-  return Impl::search_n_impl(label, ex, first, last, count, value);
+  return Impl::search_n_exespace_impl(label, ex, first, last, count, value);
 }
 
 template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class ValueType>
+          class SizeType, class ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto search_n(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& view,
               SizeType count, const ValueType& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_n_impl("Kokkos::search_n_view_api_default", ex,
-                             KE::begin(view), KE::end(view), count, value);
+  return Impl::search_n_exespace_impl("Kokkos::search_n_view_api_default", ex,
+                                      KE::begin(view), KE::end(view), count,
+                                      value);
 }
 
 template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class ValueType>
+          class SizeType, class ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto search_n(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& view,
               SizeType count, const ValueType& value) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_n_impl(label, ex, KE::begin(view), KE::end(view), count,
-                             value);
+  return Impl::search_n_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                      count, value);
 }
 
 // overload set 2: binary predicate passed
-template <class ExecutionSpace, class IteratorType, class SizeType,
-          class ValueType, class BinaryPredicateType>
+template <
+    class ExecutionSpace, class IteratorType, class SizeType, class ValueType,
+    class BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType search_n(const ExecutionSpace& ex, IteratorType first,
                       IteratorType last, SizeType count, const ValueType& value,
                       const BinaryPredicateType& pred) {
-  return Impl::search_n_impl("Kokkos::search_n_iterator_api_default", ex, first,
-                             last, count, value, pred);
+  return Impl::search_n_exespace_impl("Kokkos::search_n_iterator_api_default",
+                                      ex, first, last, count, value, pred);
 }
 
-template <class ExecutionSpace, class IteratorType, class SizeType,
-          class ValueType, class BinaryPredicateType>
+template <
+    class ExecutionSpace, class IteratorType, class SizeType, class ValueType,
+    class BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType search_n(const std::string& label, const ExecutionSpace& ex,
                       IteratorType first, IteratorType last, SizeType count,
                       const ValueType& value, const BinaryPredicateType& pred) {
-  return Impl::search_n_impl(label, ex, first, last, count, value, pred);
+  return Impl::search_n_exespace_impl(label, ex, first, last, count, value,
+                                      pred);
 }
 
 template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class ValueType, class BinaryPredicateType>
+          class SizeType, class ValueType, class BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto search_n(const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& view,
               SizeType count, const ValueType& value,
@@ -92,13 +110,15 @@ auto search_n(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_n_impl("Kokkos::search_n_view_api_default", ex,
-                             KE::begin(view), KE::end(view), count, value,
-                             pred);
+  return Impl::search_n_exespace_impl("Kokkos::search_n_view_api_default", ex,
+                                      KE::begin(view), KE::end(view), count,
+                                      value, pred);
 }
 
 template <class ExecutionSpace, class DataType, class... Properties,
-          class SizeType, class ValueType, class BinaryPredicateType>
+          class SizeType, class ValueType, class BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 auto search_n(const std::string& label, const ExecutionSpace& ex,
               const ::Kokkos::View<DataType, Properties...>& view,
               SizeType count, const ValueType& value,
@@ -106,8 +126,65 @@ auto search_n(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
   namespace KE = ::Kokkos::Experimental;
-  return Impl::search_n_impl(label, ex, KE::begin(view), KE::end(view), count,
-                             value, pred);
+  return Impl::search_n_exespace_impl(label, ex, KE::begin(view), KE::end(view),
+                                      count, value, pred);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1: no binary predicate passed
+template <class TeamHandleType, class IteratorType, class SizeType,
+          class ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType search_n(const TeamHandleType& teamHandle,
+                                      IteratorType first, IteratorType last,
+                                      SizeType count, const ValueType& value) {
+  return Impl::search_n_team_impl(teamHandle, first, last, count, value);
+}
+
+template <
+    class TeamHandleType, class DataType, class... Properties, class SizeType,
+    class ValueType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto search_n(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, SizeType count,
+    const ValueType& value) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::search_n_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                                  count, value);
+}
+
+// overload set 2: binary predicate passed
+template <class TeamHandleType, class IteratorType, class SizeType,
+          class ValueType, class BinaryPredicateType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType search_n(const TeamHandleType& teamHandle,
+                                      IteratorType first, IteratorType last,
+                                      SizeType count, const ValueType& value,
+                                      const BinaryPredicateType& pred) {
+  return Impl::search_n_team_impl(teamHandle, first, last, count, value, pred);
+}
+
+template <
+    class TeamHandleType, class DataType, class... Properties, class SizeType,
+    class ValueType, class BinaryPredicateType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto search_n(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view, SizeType count,
+    const ValueType& value, const BinaryPredicateType& pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::search_n_team_impl(teamHandle, KE::begin(view), KE::end(view),
+                                  count, value, pred);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ShiftLeft.hpp b/algorithms/src/std_algorithms/Kokkos_ShiftLeft.hpp
index 4b91a17ab8..b3e04a3b97 100644
--- a/algorithms/src/std_algorithms/Kokkos_ShiftLeft.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ShiftLeft.hpp
@@ -23,36 +23,70 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType shift_left(const ExecutionSpace& ex, IteratorType first,
                         IteratorType last,
                         typename IteratorType::difference_type n) {
-  return Impl::shift_left_impl("Kokkos::shift_left_iterator_api_default", ex,
-                               first, last, n);
+  return Impl::shift_left_exespace_impl(
+      "Kokkos::shift_left_iterator_api_default", ex, first, last, n);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType shift_left(const std::string& label, const ExecutionSpace& ex,
                         IteratorType first, IteratorType last,
                         typename IteratorType::difference_type n) {
-  return Impl::shift_left_impl(label, ex, first, last, n);
+  return Impl::shift_left_exespace_impl(label, ex, first, last, n);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto shift_left(const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType, Properties...>& view,
                 typename decltype(begin(view))::difference_type n) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::shift_left_impl("Kokkos::shift_left_view_api_default", ex,
-                               begin(view), end(view), n);
+  return Impl::shift_left_exespace_impl("Kokkos::shift_left_view_api_default",
+                                        ex, begin(view), end(view), n);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto shift_left(const std::string& label, const ExecutionSpace& ex,
                 const ::Kokkos::View<DataType, Properties...>& view,
                 typename decltype(begin(view))::difference_type n) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::shift_left_impl(label, ex, begin(view), end(view), n);
+  return Impl::shift_left_exespace_impl(label, ex, begin(view), end(view), n);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType
+shift_left(const TeamHandleType& teamHandle, IteratorType first,
+           IteratorType last, typename IteratorType::difference_type n) {
+  return Impl::shift_left_team_impl(teamHandle, first, last, n);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto shift_left(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view,
+    typename decltype(begin(view))::difference_type n) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  return Impl::shift_left_team_impl(teamHandle, begin(view), end(view), n);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_ShiftRight.hpp b/algorithms/src/std_algorithms/Kokkos_ShiftRight.hpp
index 2ea50fd74e..0f7ed53948 100644
--- a/algorithms/src/std_algorithms/Kokkos_ShiftRight.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_ShiftRight.hpp
@@ -23,36 +23,70 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType>
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType shift_right(const ExecutionSpace& ex, IteratorType first,
                          IteratorType last,
                          typename IteratorType::difference_type n) {
-  return Impl::shift_right_impl("Kokkos::shift_right_iterator_api_default", ex,
-                                first, last, n);
+  return Impl::shift_right_exespace_impl(
+      "Kokkos::shift_right_iterator_api_default", ex, first, last, n);
 }
 
-template <class ExecutionSpace, class IteratorType>
+template <
+    typename ExecutionSpace, typename IteratorType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType shift_right(const std::string& label, const ExecutionSpace& ex,
                          IteratorType first, IteratorType last,
                          typename IteratorType::difference_type n) {
-  return Impl::shift_right_impl(label, ex, first, last, n);
+  return Impl::shift_right_exespace_impl(label, ex, first, last, n);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto shift_right(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& view,
                  typename decltype(begin(view))::difference_type n) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::shift_right_impl("Kokkos::shift_right_view_api_default", ex,
-                                begin(view), end(view), n);
+  return Impl::shift_right_exespace_impl("Kokkos::shift_right_view_api_default",
+                                         ex, begin(view), end(view), n);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto shift_right(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType, Properties...>& view,
                  typename decltype(begin(view))::difference_type n) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::shift_right_impl(label, ex, begin(view), end(view), n);
+  return Impl::shift_right_exespace_impl(label, ex, begin(view), end(view), n);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType
+shift_right(const TeamHandleType& teamHandle, IteratorType first,
+            IteratorType last, typename IteratorType::difference_type n) {
+  return Impl::shift_right_team_impl(teamHandle, first, last, n);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto shift_right(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view,
+    typename decltype(begin(view))::difference_type n) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+  return Impl::shift_right_team_impl(teamHandle, begin(view), end(view), n);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_SwapRanges.hpp b/algorithms/src/std_algorithms/Kokkos_SwapRanges.hpp
index 5fbf045318..d66763d304 100644
--- a/algorithms/src/std_algorithms/Kokkos_SwapRanges.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_SwapRanges.hpp
@@ -23,44 +23,84 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+//
+// overload set accepting execution space
+//
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType2 swap_ranges(const ExecutionSpace& ex, IteratorType1 first1,
                           IteratorType1 last1, IteratorType2 first2) {
-  return Impl::swap_ranges_impl("Kokkos::swap_ranges_iterator_api_default", ex,
-                                first1, last1, first2);
+  return Impl::swap_ranges_exespace_impl(
+      "Kokkos::swap_ranges_iterator_api_default", ex, first1, last1, first2);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto swap_ranges(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
-                 ::Kokkos::View<DataType2, Properties2...>& dest) {
+                 const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
   assert(source.extent(0) == dest.extent(0));
-  return Impl::swap_ranges_impl("Kokkos::swap_ranges_view_api_default", ex,
-                                begin(source), end(source), begin(dest));
+  return Impl::swap_ranges_exespace_impl("Kokkos::swap_ranges_view_api_default",
+                                         ex, begin(source), end(source),
+                                         begin(dest));
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2>
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 IteratorType2 swap_ranges(const std::string& label, const ExecutionSpace& ex,
                           IteratorType1 first1, IteratorType1 last1,
                           IteratorType2 first2) {
-  return Impl::swap_ranges_impl(label, ex, first1, last1, first2);
+  return Impl::swap_ranges_exespace_impl(label, ex, first1, last1, first2);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto swap_ranges(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
-                 ::Kokkos::View<DataType2, Properties2...>& dest) {
+                 const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  assert(source.extent(0) == dest.extent(0));
+  return Impl::swap_ranges_exespace_impl(label, ex, begin(source), end(source),
+                                         begin(dest));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType1,
+          typename IteratorType2,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION IteratorType2 swap_ranges(const TeamHandleType& teamHandle,
+                                          IteratorType1 first1,
+                                          IteratorType1 last1,
+                                          IteratorType2 first2) {
+  return Impl::swap_ranges_team_impl(teamHandle, first1, last1, first2);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto swap_ranges(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
   assert(source.extent(0) == dest.extent(0));
-  return Impl::swap_ranges_impl(label, ex, begin(source), end(source),
-                                begin(dest));
+  return Impl::swap_ranges_team_impl(teamHandle, begin(source), end(source),
+                                     begin(dest));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_Transform.hpp b/algorithms/src/std_algorithms/Kokkos_Transform.hpp
index 27dee30426..84cbed524d 100644
--- a/algorithms/src/std_algorithms/Kokkos_Transform.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Transform.hpp
@@ -23,113 +23,200 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class UnaryOperation>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      InputIterator, OutputIterator>::value,
-                  OutputIterator>
-transform(const ExecutionSpace& ex, InputIterator first1, InputIterator last1,
-          OutputIterator d_first, UnaryOperation unary_op) {
-  return Impl::transform_impl("Kokkos::transform_iterator_api_default", ex,
-                              first1, last1, d_first, std::move(unary_op));
+//
+// overload set accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename UnaryOperation,
+    std::enable_if_t<Impl::are_iterators_v<InputIterator, OutputIterator> &&
+                         is_execution_space_v<ExecutionSpace>,
+                     int> = 0>
+OutputIterator transform(const ExecutionSpace& ex, InputIterator first1,
+                         InputIterator last1, OutputIterator d_first,
+                         UnaryOperation unary_op) {
+  return Impl::transform_exespace_impl("Kokkos::transform_iterator_api_default",
+                                       ex, first1, last1, d_first,
+                                       std::move(unary_op));
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class UnaryOperation>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      InputIterator, OutputIterator>::value,
-                  OutputIterator>
-transform(const std::string& label, const ExecutionSpace& ex,
-          InputIterator first1, InputIterator last1, OutputIterator d_first,
-          UnaryOperation unary_op) {
-  return Impl::transform_impl(label, ex, first1, last1, d_first,
-                              std::move(unary_op));
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename UnaryOperation,
+    std::enable_if_t<Impl::are_iterators_v<InputIterator, OutputIterator> &&
+                         is_execution_space_v<ExecutionSpace>,
+                     int> = 0>
+OutputIterator transform(const std::string& label, const ExecutionSpace& ex,
+                         InputIterator first1, InputIterator last1,
+                         OutputIterator d_first, UnaryOperation unary_op) {
+  return Impl::transform_exespace_impl(label, ex, first1, last1, d_first,
+                                       std::move(unary_op));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class UnaryOperation>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename UnaryOperation,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform(const ExecutionSpace& ex,
                const ::Kokkos::View<DataType1, Properties1...>& source,
-               ::Kokkos::View<DataType2, Properties2...>& dest,
+               const ::Kokkos::View<DataType2, Properties2...>& dest,
                UnaryOperation unary_op) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::transform_impl("Kokkos::transform_view_api_default", ex,
-                              begin(source), end(source), begin(dest),
-                              std::move(unary_op));
+  return Impl::transform_exespace_impl("Kokkos::transform_view_api_default", ex,
+                                       begin(source), end(source), begin(dest),
+                                       std::move(unary_op));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class UnaryOperation>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename UnaryOperation,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform(const std::string& label, const ExecutionSpace& ex,
                const ::Kokkos::View<DataType1, Properties1...>& source,
-               ::Kokkos::View<DataType2, Properties2...>& dest,
+               const ::Kokkos::View<DataType2, Properties2...>& dest,
                UnaryOperation unary_op) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::transform_impl(label, ex, begin(source), end(source),
-                              begin(dest), std::move(unary_op));
+  return Impl::transform_exespace_impl(label, ex, begin(source), end(source),
+                                       begin(dest), std::move(unary_op));
 }
 
-template <class ExecutionSpace, class InputIterator1, class InputIterator2,
-          class OutputIterator, class BinaryOperation>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      InputIterator1, InputIterator2, OutputIterator>::value,
-                  OutputIterator>
-transform(const ExecutionSpace& ex, InputIterator1 first1, InputIterator1 last1,
-          InputIterator2 first2, OutputIterator d_first,
-          BinaryOperation binary_op) {
-  return Impl::transform_impl("Kokkos::transform_iterator_api_default", ex,
-                              first1, last1, first2, d_first,
-                              std::move(binary_op));
+template <
+    typename ExecutionSpace, typename InputIterator1, typename InputIterator2,
+    typename OutputIterator, typename BinaryOperation,
+    std::enable_if_t<
+        Impl::are_iterators_v<InputIterator1, InputIterator2, OutputIterator> &&
+            is_execution_space_v<ExecutionSpace>,
+        int> = 0>
+OutputIterator transform(const ExecutionSpace& ex, InputIterator1 first1,
+                         InputIterator1 last1, InputIterator2 first2,
+                         OutputIterator d_first, BinaryOperation binary_op) {
+  return Impl::transform_exespace_impl("Kokkos::transform_iterator_api_default",
+                                       ex, first1, last1, first2, d_first,
+                                       std::move(binary_op));
 }
 
-template <class ExecutionSpace, class InputIterator1, class InputIterator2,
-          class OutputIterator, class BinaryOperation>
-std::enable_if_t< ::Kokkos::Experimental::Impl::are_iterators<
-                      InputIterator1, InputIterator2, OutputIterator>::value,
-                  OutputIterator>
-transform(const std::string& label, const ExecutionSpace& ex,
-          InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
-          OutputIterator d_first, BinaryOperation binary_op) {
-  return Impl::transform_impl(label, ex, first1, last1, first2, d_first,
-                              std::move(binary_op));
+template <
+    typename ExecutionSpace, typename InputIterator1, typename InputIterator2,
+    typename OutputIterator, typename BinaryOperation,
+    std::enable_if_t<
+        Impl::are_iterators_v<InputIterator1, InputIterator2, OutputIterator> &&
+            is_execution_space_v<ExecutionSpace>,
+        int> = 0>
+OutputIterator transform(const std::string& label, const ExecutionSpace& ex,
+                         InputIterator1 first1, InputIterator1 last1,
+                         InputIterator2 first2, OutputIterator d_first,
+                         BinaryOperation binary_op) {
+  return Impl::transform_exespace_impl(label, ex, first1, last1, first2,
+                                       d_first, std::move(binary_op));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class DataType3,
-          class... Properties3, class BinaryOperation>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename DataType3,
+          typename... Properties3, typename BinaryOperation,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform(const ExecutionSpace& ex,
                const ::Kokkos::View<DataType1, Properties1...>& source1,
                const ::Kokkos::View<DataType2, Properties2...>& source2,
-               ::Kokkos::View<DataType3, Properties3...>& dest,
+               const ::Kokkos::View<DataType3, Properties3...>& dest,
                BinaryOperation binary_op) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source2);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::transform_impl("Kokkos::transform_view_api_default", ex,
-                              begin(source1), end(source1), begin(source2),
-                              begin(dest), std::move(binary_op));
+  return Impl::transform_exespace_impl(
+      "Kokkos::transform_view_api_default", ex, begin(source1), end(source1),
+      begin(source2), begin(dest), std::move(binary_op));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class DataType3,
-          class... Properties3, class BinaryOperation>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename DataType3,
+          typename... Properties3, typename BinaryOperation,
+          std::enable_if_t<is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform(const std::string& label, const ExecutionSpace& ex,
                const ::Kokkos::View<DataType1, Properties1...>& source1,
                const ::Kokkos::View<DataType2, Properties2...>& source2,
-               ::Kokkos::View<DataType3, Properties3...>& dest,
+               const ::Kokkos::View<DataType3, Properties3...>& dest,
                BinaryOperation binary_op) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source1);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source2);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::transform_impl(label, ex, begin(source1), end(source1),
-                              begin(source2), begin(dest),
-                              std::move(binary_op));
+  return Impl::transform_exespace_impl(label, ex, begin(source1), end(source1),
+                                       begin(source2), begin(dest),
+                                       std::move(binary_op));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <
+    typename TeamHandleType, typename InputIterator, typename OutputIterator,
+    typename UnaryOperation,
+    std::enable_if_t<Impl::are_iterators_v<InputIterator, OutputIterator> &&
+                         is_team_handle_v<TeamHandleType>,
+                     int> = 0>
+KOKKOS_FUNCTION OutputIterator transform(const TeamHandleType& teamHandle,
+                                         InputIterator first1,
+                                         InputIterator last1,
+                                         OutputIterator d_first,
+                                         UnaryOperation unary_op) {
+  return Impl::transform_team_impl(teamHandle, first1, last1, d_first,
+                                   std::move(unary_op));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename UnaryOperation,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto transform(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest,
+    UnaryOperation unary_op) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::transform_team_impl(teamHandle, begin(source), end(source),
+                                   begin(dest), std::move(unary_op));
+}
+
+template <
+    typename TeamHandleType, typename InputIterator1, typename InputIterator2,
+    typename OutputIterator, typename BinaryOperation,
+    std::enable_if_t<
+        Impl::are_iterators_v<InputIterator1, InputIterator2, OutputIterator> &&
+            is_team_handle_v<TeamHandleType>,
+        int> = 0>
+KOKKOS_FUNCTION OutputIterator transform(const TeamHandleType& teamHandle,
+                                         InputIterator1 first1,
+                                         InputIterator1 last1,
+                                         InputIterator2 first2,
+                                         OutputIterator d_first,
+                                         BinaryOperation binary_op) {
+  return Impl::transform_team_impl(teamHandle, first1, last1, first2, d_first,
+                                   std::move(binary_op));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename DataType3,
+          typename... Properties3, typename BinaryOperation,
+          std::enable_if_t<is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto transform(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source1,
+    const ::Kokkos::View<DataType2, Properties2...>& source2,
+    const ::Kokkos::View<DataType3, Properties3...>& dest,
+    BinaryOperation binary_op) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source1);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source2);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::transform_team_impl(teamHandle, begin(source1), end(source1),
+                                   begin(source2), begin(dest),
+                                   std::move(binary_op));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_TransformExclusiveScan.hpp b/algorithms/src/std_algorithms/Kokkos_TransformExclusiveScan.hpp
index 9d85aee06f..37fc0f860e 100644
--- a/algorithms/src/std_algorithms/Kokkos_TransformExclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_TransformExclusiveScan.hpp
@@ -23,44 +23,52 @@
 namespace Kokkos {
 namespace Experimental {
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType, class BinaryOpType,
-          class UnaryOpType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-transform_exclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-                         InputIteratorType last, OutputIteratorType first_dest,
-                         ValueType init_value, BinaryOpType binary_op,
-                         UnaryOpType unary_op) {
+//
+// overload set accepting execution space
+//
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          typename BinaryOpType, typename UnaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType transform_exclusive_scan(
+    const ExecutionSpace& ex, InputIteratorType first, InputIteratorType last,
+    OutputIteratorType first_dest, ValueType init_value, BinaryOpType binary_op,
+    UnaryOpType unary_op) {
   Impl::static_assert_is_not_openmptarget(ex);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
-  return Impl::transform_exclusive_scan_impl(
+  return Impl::transform_exclusive_scan_exespace_impl(
       "Kokkos::transform_exclusive_scan_custom_functors_iterator_api", ex,
-      first, last, first_dest, init_value, binary_op, unary_op);
+      first, last, first_dest, std::move(init_value), binary_op, unary_op);
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType, class BinaryOpType,
-          class UnaryOpType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-transform_exclusive_scan(const std::string& label, const ExecutionSpace& ex,
-                         InputIteratorType first, InputIteratorType last,
-                         OutputIteratorType first_dest, ValueType init_value,
-                         BinaryOpType binary_op, UnaryOpType unary_op) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          typename BinaryOpType, typename UnaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType transform_exclusive_scan(
+    const std::string& label, const ExecutionSpace& ex, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest, ValueType init_value,
+    BinaryOpType binary_op, UnaryOpType unary_op) {
   Impl::static_assert_is_not_openmptarget(ex);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
-  return Impl::transform_exclusive_scan_impl(label, ex, first, last, first_dest,
-                                             init_value, binary_op, unary_op);
+  return Impl::transform_exclusive_scan_exespace_impl(
+      label, ex, first, last, first_dest, std::move(init_value), binary_op,
+      unary_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType,
-          class BinaryOpType, class UnaryOpType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    typename BinaryOpType, typename UnaryOpType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform_exclusive_scan(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -69,18 +77,20 @@ auto transform_exclusive_scan(
   Impl::static_assert_is_not_openmptarget(ex);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
   namespace KE = ::Kokkos::Experimental;
-  return Impl::transform_exclusive_scan_impl(
+  return Impl::transform_exclusive_scan_exespace_impl(
       "Kokkos::transform_exclusive_scan_custom_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
-      init_value, binary_op, unary_op);
+      std::move(init_value), binary_op, unary_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType,
-          class BinaryOpType, class UnaryOpType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    typename BinaryOpType, typename UnaryOpType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform_exclusive_scan(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -89,12 +99,56 @@ auto transform_exclusive_scan(
   Impl::static_assert_is_not_openmptarget(ex);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
-  static_assert(std::is_move_constructible<ValueType>::value,
+  static_assert(std::is_move_constructible_v<ValueType>,
                 "ValueType must be move constructible.");
   namespace KE = ::Kokkos::Experimental;
-  return Impl::transform_exclusive_scan_impl(
+  return Impl::transform_exclusive_scan_exespace_impl(
       label, ex, KE::cbegin(view_from), KE::cend(view_from),
-      KE::begin(view_dest), init_value, binary_op, unary_op);
+      KE::begin(view_dest), std::move(init_value), binary_op, unary_op);
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename ValueType,
+          typename BinaryOpType, typename UnaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType transform_exclusive_scan(
+    const TeamHandleType& teamHandle, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest, ValueType init_value,
+    BinaryOpType binary_op, UnaryOpType unary_op) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  return Impl::transform_exclusive_scan_team_impl(
+      teamHandle, first, last, first_dest, std::move(init_value), binary_op,
+      unary_op);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          typename BinaryOpType, typename UnaryOpType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto transform_exclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    ValueType init_value, BinaryOpType binary_op, UnaryOpType unary_op) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::transform_exclusive_scan_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), std::move(init_value), binary_op, unary_op);
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_TransformInclusiveScan.hpp b/algorithms/src/std_algorithms/Kokkos_TransformInclusiveScan.hpp
index 7489af7e37..5f694dbfd9 100644
--- a/algorithms/src/std_algorithms/Kokkos_TransformInclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_TransformInclusiveScan.hpp
@@ -23,40 +23,53 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // overload set 1 (no init value)
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOpType, class UnaryOpType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-transform_inclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-                         InputIteratorType last, OutputIteratorType first_dest,
-                         BinaryOpType binary_op, UnaryOpType unary_op) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOpType,
+          typename UnaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType transform_inclusive_scan(const ExecutionSpace& ex,
+                                            InputIteratorType first,
+                                            InputIteratorType last,
+                                            OutputIteratorType first_dest,
+                                            BinaryOpType binary_op,
+                                            UnaryOpType unary_op) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::transform_inclusive_scan_impl(
+  return Impl::transform_inclusive_scan_exespace_impl(
       "Kokkos::transform_inclusive_scan_custom_functors_iterator_api", ex,
       first, last, first_dest, binary_op, unary_op);
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOpType, class UnaryOpType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-transform_inclusive_scan(const std::string& label, const ExecutionSpace& ex,
-                         InputIteratorType first, InputIteratorType last,
-                         OutputIteratorType first_dest, BinaryOpType binary_op,
-                         UnaryOpType unary_op) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOpType,
+          typename UnaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType transform_inclusive_scan(
+    const std::string& label, const ExecutionSpace& ex, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op) {
   Impl::static_assert_is_not_openmptarget(ex);
 
-  return Impl::transform_inclusive_scan_impl(label, ex, first, last, first_dest,
-                                             binary_op, unary_op);
+  return Impl::transform_inclusive_scan_exespace_impl(
+      label, ex, first, last, first_dest, binary_op, unary_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOpType,
-          class UnaryOpType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOpType,
+    typename UnaryOpType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform_inclusive_scan(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -66,15 +79,17 @@ auto transform_inclusive_scan(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::transform_inclusive_scan_impl(
+  return Impl::transform_inclusive_scan_exespace_impl(
       "Kokkos::transform_inclusive_scan_custom_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
       binary_op, unary_op);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOpType,
-          class UnaryOpType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOpType,
+    typename UnaryOpType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform_inclusive_scan(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -84,46 +99,59 @@ auto transform_inclusive_scan(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
   namespace KE = ::Kokkos::Experimental;
-  return Impl::transform_inclusive_scan_impl(
+  return Impl::transform_inclusive_scan_exespace_impl(
       label, ex, KE::cbegin(view_from), KE::cend(view_from),
       KE::begin(view_dest), binary_op, unary_op);
 }
 
 // overload set 2 (init value)
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOpType, class UnaryOpType,
-          class ValueType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-transform_inclusive_scan(const ExecutionSpace& ex, InputIteratorType first,
-                         InputIteratorType last, OutputIteratorType first_dest,
-                         BinaryOpType binary_op, UnaryOpType unary_op,
-                         ValueType init_value) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOpType,
+          typename UnaryOpType, typename ValueType,
+
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType transform_inclusive_scan(
+    const ExecutionSpace& ex, InputIteratorType first, InputIteratorType last,
+    OutputIteratorType first_dest, BinaryOpType binary_op, UnaryOpType unary_op,
+    ValueType init_value) {
   Impl::static_assert_is_not_openmptarget(ex);
-  return Impl::transform_inclusive_scan_impl(
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  return Impl::transform_inclusive_scan_exespace_impl(
       "Kokkos::transform_inclusive_scan_custom_functors_iterator_api", ex,
-      first, last, first_dest, binary_op, unary_op, init_value);
+      first, last, first_dest, binary_op, unary_op, std::move(init_value));
 }
 
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class BinaryOpType, class UnaryOpType,
-          class ValueType>
-std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
-                     InputIteratorType, OutputIteratorType>::value,
-                 OutputIteratorType>
-transform_inclusive_scan(const std::string& label, const ExecutionSpace& ex,
-                         InputIteratorType first, InputIteratorType last,
-                         OutputIteratorType first_dest, BinaryOpType binary_op,
-                         UnaryOpType unary_op, ValueType init_value) {
+template <typename ExecutionSpace, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOpType,
+          typename UnaryOpType, typename ValueType,
+
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType>&& ::
+                  Kokkos::is_execution_space_v<ExecutionSpace>,
+              int> = 0>
+OutputIteratorType transform_inclusive_scan(
+    const std::string& label, const ExecutionSpace& ex, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op, ValueType init_value) {
   Impl::static_assert_is_not_openmptarget(ex);
-  return Impl::transform_inclusive_scan_impl(label, ex, first, last, first_dest,
-                                             binary_op, unary_op, init_value);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  return Impl::transform_inclusive_scan_exespace_impl(
+      label, ex, first, last, first_dest, binary_op, unary_op,
+      std::move(init_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOpType,
-          class UnaryOpType, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOpType,
+    typename UnaryOpType, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform_inclusive_scan(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -132,16 +160,21 @@ auto transform_inclusive_scan(
   Impl::static_assert_is_not_openmptarget(ex);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
   namespace KE = ::Kokkos::Experimental;
-  return Impl::transform_inclusive_scan_impl(
+  return Impl::transform_inclusive_scan_exespace_impl(
       "Kokkos::transform_inclusive_scan_custom_functors_view_api", ex,
       KE::cbegin(view_from), KE::cend(view_from), KE::begin(view_dest),
-      binary_op, unary_op, init_value);
+      binary_op, unary_op, std::move(init_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryOpType,
-          class UnaryOpType, class ValueType>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryOpType,
+    typename UnaryOpType, typename ValueType,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto transform_inclusive_scan(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& view_from,
@@ -150,10 +183,97 @@ auto transform_inclusive_scan(
   Impl::static_assert_is_not_openmptarget(ex);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
   namespace KE = ::Kokkos::Experimental;
-  return Impl::transform_inclusive_scan_impl(
+  return Impl::transform_inclusive_scan_exespace_impl(
       label, ex, KE::cbegin(view_from), KE::cend(view_from),
-      KE::begin(view_dest), binary_op, unary_op, init_value);
+      KE::begin(view_dest), binary_op, unary_op, std::move(init_value));
+}
+
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// overload set 1 (no init value)
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOpType,
+          typename UnaryOpType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType> &&
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType transform_inclusive_scan(
+    const TeamHandleType& teamHandle, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+
+  return Impl::transform_inclusive_scan_team_impl(
+      teamHandle, first, last, first_dest, binary_op, unary_op);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryOpType,
+          typename UnaryOpType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto transform_inclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::transform_inclusive_scan_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), binary_op, unary_op);
+}
+
+// overload set 2 (init value)
+template <typename TeamHandleType, typename InputIteratorType,
+          typename OutputIteratorType, typename BinaryOpType,
+          typename UnaryOpType, typename ValueType,
+          std::enable_if_t<
+              Impl::are_iterators_v<InputIteratorType, OutputIteratorType> &&
+                  Kokkos::is_team_handle_v<TeamHandleType>,
+              int> = 0>
+KOKKOS_FUNCTION OutputIteratorType transform_inclusive_scan(
+    const TeamHandleType& teamHandle, InputIteratorType first,
+    InputIteratorType last, OutputIteratorType first_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op, ValueType init_value) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  return Impl::transform_inclusive_scan_team_impl(
+      teamHandle, first, last, first_dest, binary_op, unary_op,
+      std::move(init_value));
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryOpType,
+          typename UnaryOpType, typename ValueType,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto transform_inclusive_scan(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& view_from,
+    const ::Kokkos::View<DataType2, Properties2...>& view_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op, ValueType init_value) {
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_from);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view_dest);
+  static_assert(std::is_move_constructible_v<ValueType>,
+                "ValueType must be move constructible.");
+
+  namespace KE = ::Kokkos::Experimental;
+  return Impl::transform_inclusive_scan_team_impl(
+      teamHandle, KE::cbegin(view_from), KE::cend(view_from),
+      KE::begin(view_dest), binary_op, unary_op, std::move(init_value));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_TransformReduce.hpp b/algorithms/src/std_algorithms/Kokkos_TransformReduce.hpp
index b5ec9066d2..101f5113f6 100644
--- a/algorithms/src/std_algorithms/Kokkos_TransformReduce.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_TransformReduce.hpp
@@ -23,34 +23,44 @@
 namespace Kokkos {
 namespace Experimental {
 
+//
+// overload set accepting execution space
+//
+
 // ----------------------------
 // overload set1:
 // no custom functors passed, so equivalent to
 // transform_reduce(first1, last1, first2, init, plus<>(), multiplies<>());
 // ----------------------------
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class ValueType>
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType transform_reduce(const ExecutionSpace& ex, IteratorType1 first1,
                            IteratorType1 last1, IteratorType2 first2,
                            ValueType init_reduction_value) {
-  return Impl::transform_reduce_default_functors_impl(
+  return Impl::transform_reduce_default_functors_exespace_impl(
       "Kokkos::transform_reduce_default_functors_iterator_api", ex, first1,
       last1, first2, std::move(init_reduction_value));
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class ValueType>
+template <typename ExecutionSpace, typename IteratorType1,
+          typename IteratorType2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType transform_reduce(const std::string& label, const ExecutionSpace& ex,
                            IteratorType1 first1, IteratorType1 last1,
                            IteratorType2 first2,
                            ValueType init_reduction_value) {
-  return Impl::transform_reduce_default_functors_impl(
+  return Impl::transform_reduce_default_functors_exespace_impl(
       label, ex, first1, last1, first2, std::move(init_reduction_value));
 }
 
 // overload1 accepting views
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType transform_reduce(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& first_view,
@@ -60,14 +70,16 @@ ValueType transform_reduce(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(first_view);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(second_view);
 
-  return Impl::transform_reduce_default_functors_impl(
+  return Impl::transform_reduce_default_functors_exespace_impl(
       "Kokkos::transform_reduce_default_functors_iterator_api", ex,
       KE::cbegin(first_view), KE::cend(first_view), KE::cbegin(second_view),
       std::move(init_reduction_value));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType transform_reduce(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& first_view,
@@ -77,7 +89,7 @@ ValueType transform_reduce(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(first_view);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(second_view);
 
-  return Impl::transform_reduce_default_functors_impl(
+  return Impl::transform_reduce_default_functors_exespace_impl(
       label, ex, KE::cbegin(first_view), KE::cend(first_view),
       KE::cbegin(second_view), std::move(init_reduction_value));
 }
@@ -95,8 +107,11 @@ ValueType transform_reduce(
 // https://en.cppreference.com/w/cpp/algorithm/transform_reduce
 
 // api accepting iterators
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class ValueType, class BinaryJoinerType, class BinaryTransform>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename ValueType, typename BinaryJoinerType, typename BinaryTransform,
+    std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value, int> =
+        0>
 ValueType transform_reduce(const ExecutionSpace& ex, IteratorType1 first1,
                            IteratorType1 last1, IteratorType2 first2,
                            ValueType init_reduction_value,
@@ -105,14 +120,17 @@ ValueType transform_reduce(const ExecutionSpace& ex, IteratorType1 first1,
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       "Kokkos::transform_reduce_custom_functors_iterator_api", ex, first1,
       last1, first2, std::move(init_reduction_value), std::move(joiner),
       std::move(transformer));
 }
 
-template <class ExecutionSpace, class IteratorType1, class IteratorType2,
-          class ValueType, class BinaryJoinerType, class BinaryTransform>
+template <
+    typename ExecutionSpace, typename IteratorType1, typename IteratorType2,
+    typename ValueType, typename BinaryJoinerType, typename BinaryTransform,
+    std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value, int> =
+        0>
 ValueType transform_reduce(const std::string& label, const ExecutionSpace& ex,
                            IteratorType1 first1, IteratorType1 last1,
                            IteratorType2 first2, ValueType init_reduction_value,
@@ -121,15 +139,17 @@ ValueType transform_reduce(const std::string& label, const ExecutionSpace& ex,
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       label, ex, first1, last1, first2, std::move(init_reduction_value),
       std::move(joiner), std::move(transformer));
 }
 
 // accepting views
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType,
-          class BinaryJoinerType, class BinaryTransform>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          typename BinaryJoinerType, typename BinaryTransform,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType transform_reduce(
     const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& first_view,
@@ -143,16 +163,18 @@ ValueType transform_reduce(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(first_view);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(second_view);
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       "Kokkos::transform_reduce_custom_functors_view_api", ex,
       KE::cbegin(first_view), KE::cend(first_view), KE::cbegin(second_view),
       std::move(init_reduction_value), std::move(joiner),
       std::move(transformer));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class ValueType,
-          class BinaryJoinerType, class BinaryTransform>
+template <typename ExecutionSpace, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename ValueType,
+          typename BinaryJoinerType, typename BinaryTransform,
+          std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
 ValueType transform_reduce(
     const std::string& label, const ExecutionSpace& ex,
     const ::Kokkos::View<DataType1, Properties1...>& first_view,
@@ -166,7 +188,7 @@ ValueType transform_reduce(
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(first_view);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(second_view);
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       label, ex, KE::cbegin(first_view), KE::cend(first_view),
       KE::cbegin(second_view), std::move(init_reduction_value),
       std::move(joiner), std::move(transformer));
@@ -176,43 +198,50 @@ ValueType transform_reduce(
 // overload set3:
 //
 // accepting iterators
-template <class ExecutionSpace, class IteratorType, class ValueType,
-          class BinaryJoinerType, class UnaryTransform>
-// need this to avoid ambiguous call
-std::enable_if_t<
-    ::Kokkos::Experimental::Impl::are_iterators<IteratorType>::value, ValueType>
-transform_reduce(const ExecutionSpace& ex, IteratorType first1,
-                 IteratorType last1, ValueType init_reduction_value,
-                 BinaryJoinerType joiner, UnaryTransform transformer) {
+template <typename ExecutionSpace, typename IteratorType, typename ValueType,
+          typename BinaryJoinerType, typename UnaryTransform,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
+                               IteratorType>::value &&
+                               is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
+ValueType transform_reduce(const ExecutionSpace& ex, IteratorType first1,
+                           IteratorType last1, ValueType init_reduction_value,
+                           BinaryJoinerType joiner,
+                           UnaryTransform transformer) {
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       "Kokkos::transform_reduce_custom_functors_iterator_api", ex, first1,
       last1, std::move(init_reduction_value), std::move(joiner),
       std::move(transformer));
 }
 
-template <class ExecutionSpace, class IteratorType, class ValueType,
-          class BinaryJoinerType, class UnaryTransform>
-// need this to avoid ambiguous call
-std::enable_if_t<
-    ::Kokkos::Experimental::Impl::are_iterators<IteratorType>::value, ValueType>
-transform_reduce(const std::string& label, const ExecutionSpace& ex,
-                 IteratorType first1, IteratorType last1,
-                 ValueType init_reduction_value, BinaryJoinerType joiner,
-                 UnaryTransform transformer) {
+template <typename ExecutionSpace, typename IteratorType, typename ValueType,
+          typename BinaryJoinerType, typename UnaryTransform,
+          std::enable_if_t<::Kokkos::Experimental::Impl::are_iterators<
+                               IteratorType>::value &&
+                               is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
+ValueType transform_reduce(const std::string& label, const ExecutionSpace& ex,
+                           IteratorType first1, IteratorType last1,
+                           ValueType init_reduction_value,
+                           BinaryJoinerType joiner,
+                           UnaryTransform transformer) {
   static_assert(std::is_move_constructible<ValueType>::value,
                 "ValueType must be move constructible.");
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       label, ex, first1, last1, std::move(init_reduction_value),
       std::move(joiner), std::move(transformer));
 }
 
 // accepting views
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType, class BinaryJoinerType, class UnaryTransform>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ValueType, typename BinaryJoinerType, typename UnaryTransform,
+    std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value, int> =
+        0>
 ValueType transform_reduce(const ExecutionSpace& ex,
                            const ::Kokkos::View<DataType, Properties...>& view,
                            ValueType init_reduction_value,
@@ -224,14 +253,17 @@ ValueType transform_reduce(const ExecutionSpace& ex,
 
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       "Kokkos::transform_reduce_custom_functors_view_api", ex, KE::cbegin(view),
       KE::cend(view), std::move(init_reduction_value), std::move(joiner),
       std::move(transformer));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class ValueType, class BinaryJoinerType, class UnaryTransform>
+template <
+    typename ExecutionSpace, typename DataType, typename... Properties,
+    typename ValueType, typename BinaryJoinerType, typename UnaryTransform,
+    std::enable_if_t<::Kokkos::is_execution_space<ExecutionSpace>::value, int> =
+        0>
 ValueType transform_reduce(const std::string& label, const ExecutionSpace& ex,
                            const ::Kokkos::View<DataType, Properties...>& view,
                            ValueType init_reduction_value,
@@ -243,12 +275,154 @@ ValueType transform_reduce(const std::string& label, const ExecutionSpace& ex,
 
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
 
-  return Impl::transform_reduce_custom_functors_impl(
+  return Impl::transform_reduce_custom_functors_exespace_impl(
       label, ex, KE::cbegin(view), KE::cend(view),
       std::move(init_reduction_value), std::move(joiner),
       std::move(transformer));
 }
 
+//
+// overload set accepting a team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+
+// ----------------------------
+// overload set1:
+// no custom functors passed, so equivalent to
+// transform_reduce(first1, last1, first2, init, plus<>(), multiplies<>());
+// ----------------------------
+template <
+    typename TeamHandleType, typename IteratorType1, typename IteratorType2,
+    typename ValueType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType transform_reduce(const TeamHandleType& teamHandle,
+                                           IteratorType1 first1,
+                                           IteratorType1 last1,
+                                           IteratorType2 first2,
+                                           ValueType init_reduction_value) {
+  return Impl::transform_reduce_default_functors_team_impl(
+      teamHandle, first1, last1, first2, std::move(init_reduction_value));
+}
+
+// overload1 accepting views
+template <
+    typename TeamHandleType, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType
+transform_reduce(const TeamHandleType& teamHandle,
+                 const ::Kokkos::View<DataType1, Properties1...>& first_view,
+                 const ::Kokkos::View<DataType2, Properties2...>& second_view,
+                 ValueType init_reduction_value) {
+  namespace KE = ::Kokkos::Experimental;
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(first_view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(second_view);
+
+  return Impl::transform_reduce_default_functors_team_impl(
+      teamHandle, KE::cbegin(first_view), KE::cend(first_view),
+      KE::cbegin(second_view), std::move(init_reduction_value));
+}
+
+//
+// overload set2:
+// accepts a custom transform and joiner functor
+//
+
+// Note the std refers to the arg BinaryReductionOp
+// but in the Kokkos naming convention, it corresponds
+// to a "joiner" that knows how to join two values
+// NOTE: "joiner/transformer" need to be commutative.
+
+// https://en.cppreference.com/w/cpp/algorithm/transform_reduce
+
+// api accepting iterators
+template <
+    typename TeamHandleType, typename IteratorType1, typename IteratorType2,
+    typename ValueType, typename BinaryJoinerType, typename BinaryTransform,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType transform_reduce(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, ValueType init_reduction_value,
+    BinaryJoinerType joiner, BinaryTransform transformer) {
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  return Impl::transform_reduce_custom_functors_team_impl(
+      teamHandle, first1, last1, first2, std::move(init_reduction_value),
+      std::move(joiner), std::move(transformer));
+}
+
+// accepting views
+template <
+    typename TeamHandleType, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename ValueType,
+    typename BinaryJoinerType, typename BinaryTransform,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType
+transform_reduce(const TeamHandleType& teamHandle,
+                 const ::Kokkos::View<DataType1, Properties1...>& first_view,
+                 const ::Kokkos::View<DataType2, Properties2...>& second_view,
+                 ValueType init_reduction_value, BinaryJoinerType joiner,
+                 BinaryTransform transformer) {
+  namespace KE = ::Kokkos::Experimental;
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(first_view);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(second_view);
+
+  return Impl::transform_reduce_custom_functors_team_impl(
+      teamHandle, KE::cbegin(first_view), KE::cend(first_view),
+      KE::cbegin(second_view), std::move(init_reduction_value),
+      std::move(joiner), std::move(transformer));
+}
+
+//
+// overload set3:
+//
+// accepting iterators
+template <typename TeamHandleType, typename IteratorType, typename ValueType,
+          typename BinaryJoinerType, typename UnaryTransform,
+          std::enable_if_t<Impl::are_iterators<IteratorType>::value &&
+                               is_team_handle<TeamHandleType>::value,
+                           int> = 0>
+KOKKOS_FUNCTION ValueType transform_reduce(const TeamHandleType& teamHandle,
+                                           IteratorType first1,
+                                           IteratorType last1,
+                                           ValueType init_reduction_value,
+                                           BinaryJoinerType joiner,
+                                           UnaryTransform transformer) {
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  return Impl::transform_reduce_custom_functors_team_impl(
+      teamHandle, first1, last1, std::move(init_reduction_value),
+      std::move(joiner), std::move(transformer));
+}
+
+// accepting views
+template <
+    typename TeamHandleType, typename DataType, typename... Properties,
+    typename ValueType, typename BinaryJoinerType, typename UnaryTransform,
+    std::enable_if_t<::Kokkos::is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION ValueType
+transform_reduce(const TeamHandleType& teamHandle,
+                 const ::Kokkos::View<DataType, Properties...>& view,
+                 ValueType init_reduction_value, BinaryJoinerType joiner,
+                 UnaryTransform transformer) {
+  namespace KE = ::Kokkos::Experimental;
+  static_assert(std::is_move_constructible<ValueType>::value,
+                "ValueType must be move constructible.");
+
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
+
+  return Impl::transform_reduce_custom_functors_team_impl(
+      teamHandle, KE::cbegin(view), KE::cend(view),
+      std::move(init_reduction_value), std::move(joiner),
+      std::move(transformer));
+}
+
 }  // namespace Experimental
 }  // namespace Kokkos
 
diff --git a/algorithms/src/std_algorithms/Kokkos_Unique.hpp b/algorithms/src/std_algorithms/Kokkos_Unique.hpp
index b47ecffb20..2d56315f61 100644
--- a/algorithms/src/std_algorithms/Kokkos_Unique.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_Unique.hpp
@@ -23,71 +23,132 @@
 namespace Kokkos {
 namespace Experimental {
 
-// note: the enable_if below is to avoid "call to ... is ambiguous"
-// for example in the unit test when using a variadic function
-
-// overload set1
-template <class ExecutionSpace, class IteratorType>
-std::enable_if_t<!::Kokkos::is_view<IteratorType>::value, IteratorType> unique(
-    const ExecutionSpace& ex, IteratorType first, IteratorType last) {
-  return Impl::unique_impl("Kokkos::unique_iterator_api_default", ex, first,
-                           last);
+//
+// overload set1: default predicate, accepting execution space
+//
+template <typename ExecutionSpace, typename IteratorType,
+          std::enable_if_t<Impl::is_iterator_v<IteratorType> &&
+                               is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
+IteratorType unique(const ExecutionSpace& ex, IteratorType first,
+                    IteratorType last) {
+  return Impl::unique_exespace_impl("Kokkos::unique_iterator_api_default", ex,
+                                    first, last);
 }
 
-template <class ExecutionSpace, class IteratorType>
-std::enable_if_t<!::Kokkos::is_view<IteratorType>::value, IteratorType> unique(
-    const std::string& label, const ExecutionSpace& ex, IteratorType first,
-    IteratorType last) {
-  return Impl::unique_impl(label, ex, first, last);
+template <typename ExecutionSpace, typename IteratorType,
+          std::enable_if_t<Impl::is_iterator_v<IteratorType> &&
+                               is_execution_space<ExecutionSpace>::value,
+                           int> = 0>
+IteratorType unique(const std::string& label, const ExecutionSpace& ex,
+                    IteratorType first, IteratorType last) {
+  return Impl::unique_exespace_impl(label, ex, first, last);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          std::enable_if_t<is_execution_space<ExecutionSpace>::value, int> = 0>
 auto unique(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return ::Kokkos::Experimental::unique("Kokkos::unique_view_api_default", ex,
-                                        begin(view), end(view));
+  return Impl::unique_exespace_impl("Kokkos::unique_view_api_default", ex,
+                                    begin(view), end(view));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          std::enable_if_t<is_execution_space<ExecutionSpace>::value, int> = 0>
 auto unique(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return ::Kokkos::Experimental::unique(label, ex, begin(view), end(view));
+  return Impl::unique_exespace_impl(label, ex, begin(view), end(view));
 }
 
-// overload set2
-template <class ExecutionSpace, class IteratorType, class BinaryPredicate>
+//
+// overload set2: custom predicate, accepting execution space
+//
+template <typename ExecutionSpace, typename IteratorType,
+          typename BinaryPredicate,
+          std::enable_if_t<is_execution_space<ExecutionSpace>::value, int> = 0>
 IteratorType unique(const ExecutionSpace& ex, IteratorType first,
                     IteratorType last, BinaryPredicate pred) {
-  return Impl::unique_impl("Kokkos::unique_iterator_api_default", ex, first,
-                           last, pred);
+  return Impl::unique_exespace_impl("Kokkos::unique_iterator_api_default", ex,
+                                    first, last, pred);
 }
 
-template <class ExecutionSpace, class IteratorType, class BinaryPredicate>
+template <typename ExecutionSpace, typename IteratorType,
+          typename BinaryPredicate,
+          std::enable_if_t<is_execution_space<ExecutionSpace>::value, int> = 0>
 IteratorType unique(const std::string& label, const ExecutionSpace& ex,
                     IteratorType first, IteratorType last,
                     BinaryPredicate pred) {
-  return Impl::unique_impl(label, ex, first, last, pred);
+  return Impl::unique_exespace_impl(label, ex, first, last, pred);
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class BinaryPredicate>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename BinaryPredicate,
+          std::enable_if_t<is_execution_space<ExecutionSpace>::value, int> = 0>
 auto unique(const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view,
             BinaryPredicate pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::unique_impl("Kokkos::unique_view_api_default", ex, begin(view),
-                           end(view), std::move(pred));
+  return Impl::unique_exespace_impl("Kokkos::unique_view_api_default", ex,
+                                    begin(view), end(view), std::move(pred));
 }
 
-template <class ExecutionSpace, class DataType, class... Properties,
-          class BinaryPredicate>
+template <typename ExecutionSpace, typename DataType, typename... Properties,
+          typename BinaryPredicate,
+          std::enable_if_t<is_execution_space<ExecutionSpace>::value, int> = 0>
 auto unique(const std::string& label, const ExecutionSpace& ex,
             const ::Kokkos::View<DataType, Properties...>& view,
             BinaryPredicate pred) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(view);
-  return Impl::unique_impl(label, ex, begin(view), end(view), std::move(pred));
+  return Impl::unique_exespace_impl(label, ex, begin(view), end(view),
+                                    std::move(pred));
+}
+
+//
+// overload set3: default predicate, accepting team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          std::enable_if_t<Impl::is_iterator_v<IteratorType> &&
+                               is_team_handle<TeamHandleType>::value,
+                           int> = 0>
+KOKKOS_FUNCTION IteratorType unique(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType last) {
+  return Impl::unique_team_impl(teamHandle, first, last);
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          std::enable_if_t<is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto unique(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType, Properties...>& view) {
+  return Impl::unique_team_impl(teamHandle, begin(view), end(view));
+}
+
+//
+// overload set4: custom predicate, accepting team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename IteratorType,
+          typename BinaryPredicate,
+          std::enable_if_t<is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION IteratorType unique(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType last,
+                                    BinaryPredicate pred) {
+  return Impl::unique_team_impl(teamHandle, first, last, std::move(pred));
+}
+
+template <typename TeamHandleType, typename DataType, typename... Properties,
+          typename BinaryPredicate,
+          std::enable_if_t<is_team_handle<TeamHandleType>::value, int> = 0>
+KOKKOS_FUNCTION auto unique(const TeamHandleType& teamHandle,
+                            const ::Kokkos::View<DataType, Properties...>& view,
+                            BinaryPredicate pred) {
+  return Impl::unique_team_impl(teamHandle, begin(view), end(view),
+                                std::move(pred));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/Kokkos_UniqueCopy.hpp b/algorithms/src/std_algorithms/Kokkos_UniqueCopy.hpp
index bd2451c220..4a32d7e095 100644
--- a/algorithms/src/std_algorithms/Kokkos_UniqueCopy.hpp
+++ b/algorithms/src/std_algorithms/Kokkos_UniqueCopy.hpp
@@ -23,67 +23,90 @@
 namespace Kokkos {
 namespace Experimental {
 
-// overload set1
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
-std::enable_if_t<!::Kokkos::is_view<InputIterator>::value, OutputIterator>
-unique_copy(const ExecutionSpace& ex, InputIterator first, InputIterator last,
-            OutputIterator d_first) {
-  return Impl::unique_copy_impl("Kokkos::unique_copy_iterator_api_default", ex,
-                                first, last, d_first);
+//
+// overload set1: default predicate, accepting execution space
+//
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<Impl::are_iterators_v<InputIterator, OutputIterator> &&
+                         is_execution_space_v<ExecutionSpace>,
+                     int> = 0>
+OutputIterator unique_copy(const ExecutionSpace& ex, InputIterator first,
+                           InputIterator last, OutputIterator d_first) {
+  return Impl::unique_copy_exespace_impl(
+      "Kokkos::unique_copy_iterator_api_default", ex, first, last, d_first);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator>
-std::enable_if_t<!::Kokkos::is_view<InputIterator>::value, OutputIterator>
-unique_copy(const std::string& label, const ExecutionSpace& ex,
-            InputIterator first, InputIterator last, OutputIterator d_first) {
-  return Impl::unique_copy_impl(label, ex, first, last, d_first);
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<Impl::are_iterators_v<InputIterator, OutputIterator> &&
+                         is_execution_space_v<ExecutionSpace>,
+                     int> = 0>
+OutputIterator unique_copy(const std::string& label, const ExecutionSpace& ex,
+                           InputIterator first, InputIterator last,
+                           OutputIterator d_first) {
+  return Impl::unique_copy_exespace_impl(label, ex, first, last, d_first);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto unique_copy(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
                  const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return ::Kokkos::Experimental::unique_copy(
-      "Kokkos::unique_copy_view_api_default", ex, cbegin(source), cend(source),
-      begin(dest));
+  return Impl::unique_copy_exespace_impl("Kokkos::unique_copy_view_api_default",
+                                         ex, cbegin(source), cend(source),
+                                         begin(dest));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto unique_copy(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
                  const ::Kokkos::View<DataType2, Properties2...>& dest) {
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return ::Kokkos::Experimental::unique_copy(label, ex, cbegin(source),
-                                             cend(source), begin(dest));
+  return Impl::unique_copy_exespace_impl(label, ex, cbegin(source),
+                                         cend(source), begin(dest));
 }
 
-// overload set2
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class BinaryPredicate>
+//
+// overload set2: custom predicate, accepting execution space
+//
+
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename BinaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator unique_copy(const ExecutionSpace& ex, InputIterator first,
                            InputIterator last, OutputIterator d_first,
                            BinaryPredicate pred) {
-  return Impl::unique_copy_impl("Kokkos::unique_copy_iterator_api_default", ex,
-                                first, last, d_first, pred);
+  return Impl::unique_copy_exespace_impl(
+      "Kokkos::unique_copy_iterator_api_default", ex, first, last, d_first,
+      pred);
 }
 
-template <class ExecutionSpace, class InputIterator, class OutputIterator,
-          class BinaryPredicate>
+template <
+    typename ExecutionSpace, typename InputIterator, typename OutputIterator,
+    typename BinaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 OutputIterator unique_copy(const std::string& label, const ExecutionSpace& ex,
                            InputIterator first, InputIterator last,
                            OutputIterator d_first, BinaryPredicate pred) {
-  return Impl::unique_copy_impl(label, ex, first, last, d_first, pred);
+  return Impl::unique_copy_exespace_impl(label, ex, first, last, d_first, pred);
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicate>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto unique_copy(const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
                  const ::Kokkos::View<DataType2, Properties2...>& dest,
@@ -91,13 +114,15 @@ auto unique_copy(const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::unique_copy_impl("Kokkos::unique_copy_view_api_default", ex,
-                                cbegin(source), cend(source), begin(dest),
-                                std::move(pred));
+  return Impl::unique_copy_exespace_impl("Kokkos::unique_copy_view_api_default",
+                                         ex, cbegin(source), cend(source),
+                                         begin(dest), std::move(pred));
 }
 
-template <class ExecutionSpace, class DataType1, class... Properties1,
-          class DataType2, class... Properties2, class BinaryPredicate>
+template <
+    typename ExecutionSpace, typename DataType1, typename... Properties1,
+    typename DataType2, typename... Properties2, typename BinaryPredicate,
+    std::enable_if_t<::Kokkos::is_execution_space_v<ExecutionSpace>, int> = 0>
 auto unique_copy(const std::string& label, const ExecutionSpace& ex,
                  const ::Kokkos::View<DataType1, Properties1...>& source,
                  const ::Kokkos::View<DataType2, Properties2...>& dest,
@@ -105,8 +130,70 @@ auto unique_copy(const std::string& label, const ExecutionSpace& ex,
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
   Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
 
-  return Impl::unique_copy_impl(label, ex, cbegin(source), cend(source),
-                                begin(dest), std::move(pred));
+  return Impl::unique_copy_exespace_impl(
+      label, ex, cbegin(source), cend(source), begin(dest), std::move(pred));
+}
+
+//
+// overload set3: default predicate, accepting team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <
+    typename TeamHandleType, typename InputIterator, typename OutputIterator,
+    std::enable_if_t<Impl::are_iterators_v<InputIterator, OutputIterator> &&
+                         Kokkos::is_team_handle_v<TeamHandleType>,
+                     int> = 0>
+KOKKOS_FUNCTION OutputIterator unique_copy(const TeamHandleType& teamHandle,
+                                           InputIterator first,
+                                           InputIterator last,
+                                           OutputIterator d_first) {
+  return Impl::unique_copy_team_impl(teamHandle, first, last, d_first);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto unique_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::unique_copy_team_impl(teamHandle, cbegin(source), cend(source),
+                                     begin(dest));
+}
+
+//
+// overload set4: custom predicate, accepting team handle
+// Note: for now omit the overloads accepting a label
+// since they cause issues on device because of the string allocation.
+//
+template <typename TeamHandleType, typename InputIterator,
+          typename OutputIterator, typename BinaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION OutputIterator unique_copy(const TeamHandleType& teamHandle,
+                                           InputIterator first,
+                                           InputIterator last,
+                                           OutputIterator d_first,
+                                           BinaryPredicate pred) {
+  return Impl::unique_copy_team_impl(teamHandle, first, last, d_first, pred);
+}
+
+template <typename TeamHandleType, typename DataType1, typename... Properties1,
+          typename DataType2, typename... Properties2, typename BinaryPredicate,
+          std::enable_if_t<::Kokkos::is_team_handle_v<TeamHandleType>, int> = 0>
+KOKKOS_FUNCTION auto unique_copy(
+    const TeamHandleType& teamHandle,
+    const ::Kokkos::View<DataType1, Properties1...>& source,
+    const ::Kokkos::View<DataType2, Properties2...>& dest,
+    BinaryPredicate pred) {
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(source);
+  Impl::static_assert_is_admissible_to_kokkos_std_algorithms(dest);
+
+  return Impl::unique_copy_team_impl(teamHandle, cbegin(source), cend(source),
+                                     begin(dest), std::move(pred));
 }
 
 }  // namespace Experimental
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentDifference.hpp b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentDifference.hpp
index 8a474508d7..9f7fcf94fe 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentDifference.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentDifference.hpp
@@ -63,14 +63,15 @@ struct StdAdjacentDiffFunctor {
         m_op(std::move(op)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class BinaryOp>
-OutputIteratorType adjacent_difference_impl(const std::string& label,
-                                            const ExecutionSpace& ex,
-                                            InputIteratorType first_from,
-                                            InputIteratorType last_from,
-                                            OutputIteratorType first_dest,
-                                            BinaryOp bin_op) {
+OutputIteratorType adjacent_difference_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex,
+    InputIteratorType first_from, InputIteratorType last_from,
+    OutputIteratorType first_dest, BinaryOp bin_op) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
   Impl::static_assert_iterators_have_matching_difference_type(first_from,
@@ -81,25 +82,60 @@ OutputIteratorType adjacent_difference_impl(const std::string& label,
     return first_dest;
   }
 
-  // aliases
-  using value_type    = typename OutputIteratorType::value_type;
-  using aux_view_type = ::Kokkos::View<value_type*, ExecutionSpace>;
-  using functor_t =
-      StdAdjacentDiffFunctor<InputIteratorType, OutputIteratorType, BinaryOp>;
+#ifdef KOKKOS_ENABLE_DEBUG
+  // check for overlapping iterators
+  Impl::expect_no_overlap(first_from, last_from, first_dest);
+#endif
 
   // run
   const auto num_elements =
       Kokkos::Experimental::distance(first_from, last_from);
-  aux_view_type aux_view("aux_view", num_elements);
-  ::Kokkos::parallel_for(label,
-                         RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         functor_t(first_from, first_dest, bin_op));
+  ::Kokkos::parallel_for(
+      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      StdAdjacentDiffFunctor(first_from, first_dest, bin_op));
   ex.fence("Kokkos::adjacent_difference: fence after operation");
 
   // return
   return first_dest + num_elements;
 }
 
+//
+// team impl
+//
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class BinaryOp>
+KOKKOS_FUNCTION OutputIteratorType adjacent_difference_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    BinaryOp bin_op) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  if (first_from == last_from) {
+    return first_dest;
+  }
+
+#ifdef KOKKOS_ENABLE_DEBUG
+  // check for overlapping iterators
+  Impl::expect_no_overlap(first_from, last_from, first_dest);
+#endif
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_for(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      StdAdjacentDiffFunctor(first_from, first_dest, bin_op));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
index dd785e603b..f30b7be06a 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_AdjacentFind.hpp
@@ -27,9 +27,9 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class IteratorType, class ReducerType,
-          class PredicateType>
+template <class IteratorType, class ReducerType, class PredicateType>
 struct StdAdjacentFindFunctor {
+  using index_type     = typename IteratorType::difference_type;
   using red_value_type = typename ReducerType::value_type;
 
   IteratorType m_first;
@@ -37,13 +37,13 @@ struct StdAdjacentFindFunctor {
   PredicateType m_p;
 
   KOKKOS_FUNCTION
-  void operator()(const IndexType i, red_value_type& red_value) const {
+  void operator()(const index_type i, red_value_type& red_value) const {
     const auto& my_value   = m_first[i];
     const auto& next_value = m_first[i + 1];
     const bool are_equal   = m_p(my_value, next_value);
 
     // FIXME_NVHPC using a ternary operator causes problems
-    red_value_type value = {::Kokkos::reduction_identity<IndexType>::min()};
+    red_value_type value = {::Kokkos::reduction_identity<index_type>::min()};
     if (are_equal) {
       value.min_loc_true = i;
     }
@@ -59,10 +59,14 @@ struct StdAdjacentFindFunctor {
         m_p(std::move(p)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType, class PredicateType>
-IteratorType adjacent_find_impl(const std::string& label,
-                                const ExecutionSpace& ex, IteratorType first,
-                                IteratorType last, PredicateType pred) {
+IteratorType adjacent_find_exespace_impl(const std::string& label,
+                                         const ExecutionSpace& ex,
+                                         IteratorType first, IteratorType last,
+                                         PredicateType pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -76,8 +80,6 @@ IteratorType adjacent_find_impl(const std::string& label,
   using index_type           = typename IteratorType::difference_type;
   using reducer_type         = FirstLoc<index_type>;
   using reduction_value_type = typename reducer_type::value_type;
-  using func_t = StdAdjacentFindFunctor<index_type, IteratorType, reducer_type,
-                                        PredicateType>;
 
   reduction_value_type red_result;
   reducer_type reducer(red_result);
@@ -86,7 +88,8 @@ IteratorType adjacent_find_impl(const std::string& label,
   // each index i in the reduction checks i and (i+1).
   ::Kokkos::parallel_reduce(
       label, RangePolicy<ExecutionSpace>(ex, 0, num_elements - 1),
-      func_t(first, reducer, pred), reducer);
+      // use CTAD
+      StdAdjacentFindFunctor(first, reducer, pred), reducer);
 
   // fence not needed because reducing into scalar
   if (red_result.min_loc_true ==
@@ -98,12 +101,62 @@ IteratorType adjacent_find_impl(const std::string& label,
 }
 
 template <class ExecutionSpace, class IteratorType>
-IteratorType adjacent_find_impl(const std::string& label,
-                                const ExecutionSpace& ex, IteratorType first,
-                                IteratorType last) {
+IteratorType adjacent_find_exespace_impl(const std::string& label,
+                                         const ExecutionSpace& ex,
+                                         IteratorType first,
+                                         IteratorType last) {
+  using value_type     = typename IteratorType::value_type;
+  using default_pred_t = StdAlgoEqualBinaryPredicate<value_type>;
+  return adjacent_find_exespace_impl(label, ex, first, last, default_pred_t());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType, class PredicateType>
+KOKKOS_FUNCTION IteratorType
+adjacent_find_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                        IteratorType last, PredicateType pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+
+  if (num_elements <= 1) {
+    return last;
+  }
+
+  using index_type           = typename IteratorType::difference_type;
+  using reducer_type         = FirstLoc<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+
+  // note that we use below num_elements-1 because
+  // each index i in the reduction checks i and (i+1).
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements - 1),
+                            // use CTAD
+                            StdAdjacentFindFunctor(first, reducer, pred),
+                            reducer);
+
+  teamHandle.team_barrier();
+
+  if (red_result.min_loc_true ==
+      ::Kokkos::reduction_identity<index_type>::min()) {
+    return last;
+  } else {
+    return first + red_result.min_loc_true;
+  }
+}
+
+template <class TeamHandleType, class IteratorType>
+KOKKOS_FUNCTION IteratorType adjacent_find_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last) {
   using value_type     = typename IteratorType::value_type;
   using default_pred_t = StdAlgoEqualBinaryPredicate<value_type>;
-  return adjacent_find_impl(label, ex, first, last, default_pred_t());
+  return adjacent_find_team_impl(teamHandle, first, last, default_pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_AllOfAnyOfNoneOf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_AllOfAnyOfNoneOf.hpp
index ad562070a0..bdc050f9c1 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_AllOfAnyOfNoneOf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_AllOfAnyOfNoneOf.hpp
@@ -23,23 +23,58 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class InputIterator, class Predicate>
-bool all_of_impl(const std::string& label, const ExecutionSpace& ex,
-                 InputIterator first, InputIterator last, Predicate predicate) {
-  return (find_if_or_not_impl<false>(label, ex, first, last, predicate) ==
-          last);
+bool all_of_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                          InputIterator first, InputIterator last,
+                          Predicate predicate) {
+  return (find_if_or_not_exespace_impl<false>(label, ex, first, last,
+                                              predicate) == last);
 }
 
 template <class ExecutionSpace, class InputIterator, class Predicate>
-bool any_of_impl(const std::string& label, const ExecutionSpace& ex,
-                 InputIterator first, InputIterator last, Predicate predicate) {
-  return (find_if_or_not_impl<true>(label, ex, first, last, predicate) != last);
+bool any_of_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                          InputIterator first, InputIterator last,
+                          Predicate predicate) {
+  return (find_if_or_not_exespace_impl<true>(label, ex, first, last,
+                                             predicate) != last);
 }
 
 template <class ExecutionSpace, class IteratorType, class Predicate>
-bool none_of_impl(const std::string& label, const ExecutionSpace& ex,
-                  IteratorType first, IteratorType last, Predicate predicate) {
-  return (find_if_or_not_impl<true>(label, ex, first, last, predicate) == last);
+bool none_of_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                           IteratorType first, IteratorType last,
+                           Predicate predicate) {
+  return (find_if_or_not_exespace_impl<true>(label, ex, first, last,
+                                             predicate) == last);
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class InputIterator, class Predicate>
+KOKKOS_FUNCTION bool all_of_team_impl(const TeamHandleType& teamHandle,
+                                      InputIterator first, InputIterator last,
+                                      Predicate predicate) {
+  return (find_if_or_not_team_impl<false>(teamHandle, first, last, predicate) ==
+          last);
+}
+
+template <class TeamHandleType, class InputIterator, class Predicate>
+KOKKOS_FUNCTION bool any_of_team_impl(const TeamHandleType& teamHandle,
+                                      InputIterator first, InputIterator last,
+                                      Predicate predicate) {
+  return (find_if_or_not_team_impl<true>(teamHandle, first, last, predicate) !=
+          last);
+}
+
+template <class TeamHandleType, class IteratorType, class Predicate>
+KOKKOS_FUNCTION bool none_of_team_impl(const TeamHandleType& teamHandle,
+                                       IteratorType first, IteratorType last,
+                                       Predicate predicate) {
+  return (find_if_or_not_team_impl<true>(teamHandle, first, last, predicate) ==
+          last);
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp
index 0376100410..54bb13e25b 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Constraints.hpp
@@ -24,18 +24,21 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
+template <class T>
+class RandomAccessIterator;
+
 template <typename T, typename enable = void>
 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 &&
-                         (std::is_same<typename T::traits::array_layout,
-                                       Kokkos::LayoutLeft>::value ||
-                          std::is_same<typename T::traits::array_layout,
-                                       Kokkos::LayoutRight>::value ||
-                          std::is_same<typename T::traits::array_layout,
-                                       Kokkos::LayoutStride>::value)> >
+    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,
+                                      Kokkos::LayoutRight>::value ||
+                         std::is_same<typename T::traits::array_layout,
+                                      Kokkos::LayoutStride>::value)>>
     : std::true_type {};
 
 template <class ViewType>
@@ -55,6 +58,21 @@ using iterator_category_t = typename T::iterator_category;
 template <class T>
 using is_iterator = Kokkos::is_detected<iterator_category_t, T>;
 
+template <class T>
+inline constexpr bool is_iterator_v = is_iterator<T>::value;
+
+template <typename ViewType>
+struct is_kokkos_iterator : std::false_type {};
+
+template <typename ViewType>
+struct is_kokkos_iterator<RandomAccessIterator<ViewType>> {
+  static constexpr bool value =
+      is_admissible_to_kokkos_std_algorithms<ViewType>::value;
+};
+
+template <class T>
+inline constexpr bool is_kokkos_iterator_v = is_kokkos_iterator<T>::value;
+
 //
 // are_iterators
 //
@@ -63,15 +81,18 @@ struct are_iterators;
 
 template <class T>
 struct are_iterators<T> {
-  static constexpr bool value = is_iterator<T>::value;
+  static constexpr bool value = is_iterator_v<T>;
 };
 
 template <class Head, class... Tail>
 struct are_iterators<Head, Tail...> {
   static constexpr bool value =
-      are_iterators<Head>::value && are_iterators<Tail...>::value;
+      are_iterators<Head>::value && (are_iterators<Tail>::value && ... && true);
 };
 
+template <class... Ts>
+inline constexpr bool are_iterators_v = are_iterators<Ts...>::value;
+
 //
 // are_random_access_iterators
 //
@@ -81,17 +102,21 @@ struct are_random_access_iterators;
 template <class T>
 struct are_random_access_iterators<T> {
   static constexpr bool value =
-      is_iterator<T>::value &&
-      std::is_base_of<std::random_access_iterator_tag,
-                      typename T::iterator_category>::value;
+      is_iterator_v<T> && std::is_base_of<std::random_access_iterator_tag,
+                                          typename T::iterator_category>::value;
 };
 
 template <class Head, class... Tail>
 struct are_random_access_iterators<Head, Tail...> {
-  static constexpr bool value = are_random_access_iterators<Head>::value &&
-                                are_random_access_iterators<Tail...>::value;
+  static constexpr bool value =
+      are_random_access_iterators<Head>::value &&
+      (are_random_access_iterators<Tail>::value && ... && true);
 };
 
+template <class... Ts>
+inline constexpr bool are_random_access_iterators_v =
+    are_random_access_iterators<Ts...>::value;
+
 //
 // iterators_are_accessible_from
 //
@@ -113,16 +138,18 @@ struct iterators_are_accessible_from<ExeSpace, Head, Tail...> {
       iterators_are_accessible_from<ExeSpace, Tail...>::value;
 };
 
-template <class ExecutionSpace, class... IteratorTypes>
+template <class ExecutionSpaceOrTeamHandleType, class... IteratorTypes>
 KOKKOS_INLINE_FUNCTION constexpr void
-static_assert_random_access_and_accessible(const ExecutionSpace& /* ex */,
-                                           IteratorTypes... /* iterators */) {
+static_assert_random_access_and_accessible(
+    const ExecutionSpaceOrTeamHandleType& /* ex_or_th*/,
+    IteratorTypes... /* iterators */) {
   static_assert(
       are_random_access_iterators<IteratorTypes...>::value,
       "Currently, Kokkos standard algorithms require random access iterators.");
-  static_assert(
-      iterators_are_accessible_from<ExecutionSpace, IteratorTypes...>::value,
-      "Incompatible view/iterator and execution space");
+  static_assert(iterators_are_accessible_from<
+                    typename ExecutionSpaceOrTeamHandleType::execution_space,
+                    IteratorTypes...>::value,
+                "Incompatible view/iterator and execution space");
 }
 
 //
@@ -182,10 +209,10 @@ struct not_openmptarget {
 #endif
 };
 
-template <class ExecutionSpace>
+template <class ExecutionSpaceOrTeamHandleType>
 KOKKOS_INLINE_FUNCTION constexpr void static_assert_is_not_openmptarget(
-    const ExecutionSpace&) {
-  static_assert(not_openmptarget<ExecutionSpace>::value,
+    const ExecutionSpaceOrTeamHandleType& /*ex_or_th*/) {
+  static_assert(not_openmptarget<ExecutionSpaceOrTeamHandleType>::value,
                 "Currently, Kokkos standard algorithms do not support custom "
                 "comparators in OpenMPTarget");
 }
@@ -194,7 +221,8 @@ KOKKOS_INLINE_FUNCTION constexpr void static_assert_is_not_openmptarget(
 // valid range
 //
 template <class IteratorType>
-void expect_valid_range(IteratorType first, IteratorType last) {
+KOKKOS_INLINE_FUNCTION void expect_valid_range(IteratorType first,
+                                               IteratorType last) {
   // this is a no-op for release
   KOKKOS_EXPECTS(last >= first);
   // avoid compiler complaining when KOKKOS_EXPECTS is no-op
@@ -202,6 +230,38 @@ void expect_valid_range(IteratorType first, IteratorType last) {
   (void)last;
 }
 
+//
+// Check if kokkos iterators are overlapping
+//
+template <typename IteratorType1, typename IteratorType2>
+KOKKOS_INLINE_FUNCTION void expect_no_overlap(
+    [[maybe_unused]] IteratorType1 first, [[maybe_unused]] IteratorType1 last,
+    [[maybe_unused]] IteratorType2 s_first) {
+  if constexpr (is_kokkos_iterator_v<IteratorType1> &&
+                is_kokkos_iterator_v<IteratorType2>) {
+    auto const view1 = first.view();
+    auto const view2 = s_first.view();
+
+    std::size_t stride1  = view1.stride(0);
+    std::size_t stride2  = view2.stride(0);
+    ptrdiff_t first_diff = view1.data() - view2.data();
+
+    // FIXME If strides are not identical, checks may not be made
+    // with the cost of O(1)
+    // Currently, checks are made only if strides are identical
+    // If first_diff == 0, there is already an overlap
+    if (stride1 == stride2 || first_diff == 0) {
+      [[maybe_unused]] bool is_no_overlap  = (first_diff % stride1);
+      auto* first_pointer1                 = view1.data();
+      auto* first_pointer2                 = view2.data();
+      [[maybe_unused]] auto* last_pointer1 = first_pointer1 + (last - first);
+      [[maybe_unused]] auto* last_pointer2 = first_pointer2 + (last - first);
+      KOKKOS_EXPECTS(first_pointer1 >= last_pointer2 ||
+                     last_pointer1 <= first_pointer2 || is_no_overlap);
+    }
+  }
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_CopyBackward.hpp b/algorithms/src/std_algorithms/impl/Kokkos_CopyBackward.hpp
index b3adbc5e2d..0f68c9e978 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_CopyBackward.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_CopyBackward.hpp
@@ -27,16 +27,18 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class IteratorType1, class IteratorType2>
+template <class IteratorType1, class IteratorType2>
 struct StdCopyBackwardFunctor {
-  static_assert(std::is_signed<IndexType>::value,
-                "Kokkos: StdCopyBackwardFunctor requires signed index type");
+  // we can use difference type from IteratorType1 since
+  // the calling functions below already static assert that
+  // the iterators have matching difference type
+  using index_type = typename IteratorType1::difference_type;
 
   IteratorType1 m_last;
   IteratorType2 m_dest_last;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const { m_dest_last[-i - 1] = m_last[-i - 1]; }
+  void operator()(index_type i) const { m_dest_last[-i - 1] = m_last[-i - 1]; }
 
   KOKKOS_FUNCTION
   StdCopyBackwardFunctor(IteratorType1 _last, IteratorType2 _dest_last)
@@ -44,30 +46,51 @@ struct StdCopyBackwardFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-IteratorType2 copy_backward_impl(const std::string& label,
-                                 const ExecutionSpace& ex, IteratorType1 first,
-                                 IteratorType1 last, IteratorType2 d_last) {
+IteratorType2 copy_backward_exespace_impl(const std::string& label,
+                                          const ExecutionSpace& ex,
+                                          IteratorType1 first,
+                                          IteratorType1 last,
+                                          IteratorType2 d_last) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_last);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_last);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using index_type = typename IteratorType1::difference_type;
-  using func_t =
-      StdCopyBackwardFunctor<index_type, IteratorType1, IteratorType2>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(last, d_last));
+                         // use CTAD
+                         StdCopyBackwardFunctor(last, d_last));
   ex.fence("Kokkos::copy_backward: fence after operation");
 
   // return
   return d_last - num_elements;
 }
 
+//
+// team-level impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION IteratorType2
+copy_backward_team_impl(const TeamHandleType& teamHandle, IteratorType1 first,
+                        IteratorType1 last, IteratorType2 d_last) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_last);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_last);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         // use CTAD
+                         StdCopyBackwardFunctor(last, d_last));
+  teamHandle.team_barrier();
+
+  // return
+  return d_last - num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_CopyCopyN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_CopyCopyN.hpp
index 1b120c46d0..86e99ecbd0 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_CopyCopyN.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_CopyCopyN.hpp
@@ -27,13 +27,18 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIterator, class OutputIterator>
+template <class InputIterator, class OutputIterator>
 struct StdCopyFunctor {
+  // we can use difference type from InputIterator since
+  // the calling functions below already static assert that
+  // the iterators have matching difference type
+  using index_type = typename InputIterator::difference_type;
+
   InputIterator m_first;
   OutputIterator m_dest_first;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const { m_dest_first[i] = m_first[i]; }
+  void operator()(index_type i) const { m_dest_first[i] = m_first[i]; }
 
   KOKKOS_FUNCTION
   StdCopyFunctor(InputIterator _first, OutputIterator _dest_first)
@@ -41,23 +46,20 @@ struct StdCopyFunctor {
 };
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator>
-OutputIterator copy_impl(const std::string& label, const ExecutionSpace& ex,
-                         InputIterator first, InputIterator last,
-                         OutputIterator d_first) {
+OutputIterator copy_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, InputIterator first,
+                                  InputIterator last, OutputIterator d_first) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using index_type = typename InputIterator::difference_type;
-  using func_t     = StdCopyFunctor<index_type, InputIterator, OutputIterator>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first, d_first));
+                         // use CTAD
+                         StdCopyFunctor(first, d_first));
   ex.fence("Kokkos::copy: fence after operation");
 
   // return
@@ -66,16 +68,61 @@ OutputIterator copy_impl(const std::string& label, const ExecutionSpace& ex,
 
 template <class ExecutionSpace, class InputIterator, class Size,
           class OutputIterator>
-OutputIterator copy_n_impl(const std::string& label, const ExecutionSpace& ex,
-                           InputIterator first_from, Size count,
-                           OutputIterator first_dest) {
+OutputIterator copy_n_exespace_impl(const std::string& label,
+                                    const ExecutionSpace& ex,
+                                    InputIterator first_from, Size count,
+                                    OutputIterator first_dest) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
   Impl::static_assert_iterators_have_matching_difference_type(first_from,
                                                               first_dest);
 
   if (count > 0) {
-    return copy_impl(label, ex, first_from, first_from + count, first_dest);
+    return copy_exespace_impl(label, ex, first_from, first_from + count,
+                              first_dest);
+  } else {
+    return first_dest;
+  }
+}
+
+//
+// team-level impl
+//
+template <class TeamHandleType, class InputIterator, class OutputIterator>
+KOKKOS_FUNCTION OutputIterator copy_team_impl(const TeamHandleType& teamHandle,
+                                              InputIterator first,
+                                              InputIterator last,
+                                              OutputIterator d_first) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         // use CTAD
+                         StdCopyFunctor(first, d_first));
+  teamHandle.team_barrier();
+
+  // return
+  return d_first + num_elements;
+}
+
+template <class TeamHandleType, class InputIterator, class Size,
+          class OutputIterator>
+KOKKOS_FUNCTION OutputIterator
+copy_n_team_impl(const TeamHandleType& teamHandle, InputIterator first_from,
+                 Size count, OutputIterator first_dest) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+
+  if (count > 0) {
+    return copy_team_impl(teamHandle, first_from, first_from + count,
+                          first_dest);
   } else {
     return first_dest;
   }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_CopyIf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_CopyIf.hpp
index 3c0c4f7e9b..ad7b8bb8ca 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_CopyIf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_CopyIf.hpp
@@ -20,6 +20,7 @@
 #include <Kokkos_Core.hpp>
 #include "Kokkos_Constraints.hpp"
 #include "Kokkos_HelperPredicates.hpp"
+#include "Kokkos_MustUseKokkosSingleInTeam.hpp"
 #include <std_algorithms/Kokkos_Distance.hpp>
 #include <string>
 
@@ -27,8 +28,10 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class FirstFrom, class FirstDest, class PredType>
+template <class FirstFrom, class FirstDest, class PredType>
 struct StdCopyIfFunctor {
+  using index_type = typename FirstFrom::difference_type;
+
   FirstFrom m_first_from;
   FirstDest m_first_dest;
   PredType m_pred;
@@ -40,7 +43,7 @@ struct StdCopyIfFunctor {
         m_pred(std::move(pred)) {}
 
   KOKKOS_FUNCTION
-  void operator()(const IndexType i, IndexType& update,
+  void operator()(const index_type i, index_type& update,
                   const bool final_pass) const {
     const auto& myval = m_first_from[i];
     if (final_pass) {
@@ -57,9 +60,11 @@ struct StdCopyIfFunctor {
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator,
           class PredicateType>
-OutputIterator copy_if_impl(const std::string& label, const ExecutionSpace& ex,
-                            InputIterator first, InputIterator last,
-                            OutputIterator d_first, PredicateType pred) {
+OutputIterator copy_if_exespace_impl(const std::string& label,
+                                     const ExecutionSpace& ex,
+                                     InputIterator first, InputIterator last,
+                                     OutputIterator d_first,
+                                     PredicateType pred) {
   /*
     To explain the impl, suppose that our data is:
 
@@ -90,23 +95,68 @@ OutputIterator copy_if_impl(const std::string& label, const ExecutionSpace& ex,
   if (first == last) {
     return d_first;
   } else {
-    // aliases
-    using index_type = typename InputIterator::difference_type;
-    using func_type  = StdCopyIfFunctor<index_type, InputIterator,
-                                       OutputIterator, PredicateType>;
-
     // run
     const auto num_elements = Kokkos::Experimental::distance(first, last);
-    index_type count        = 0;
+
+    typename InputIterator::difference_type count = 0;
     ::Kokkos::parallel_scan(label,
                             RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                            func_type(first, d_first, pred), count);
+                            // use CTAD
+                            StdCopyIfFunctor(first, d_first, pred), count);
 
     // fence not needed because of the scan accumulating into count
     return d_first + count;
   }
 }
 
+template <class TeamHandleType, class InputIterator, class OutputIterator,
+          class PredicateType>
+KOKKOS_FUNCTION OutputIterator copy_if_team_impl(
+    const TeamHandleType& teamHandle, InputIterator first, InputIterator last,
+    OutputIterator d_first, PredicateType pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    return d_first;
+  }
+
+  const std::size_t num_elements = Kokkos::Experimental::distance(first, last);
+  if constexpr (stdalgo_must_use_kokkos_single_for_team_scan_v<
+                    typename TeamHandleType::execution_space>) {
+    std::size_t count = 0;
+    Kokkos::single(
+        Kokkos::PerTeam(teamHandle),
+        [=](std::size_t& lcount) {
+          lcount = 0;
+          for (std::size_t i = 0; i < num_elements; ++i) {
+            const auto& myval = first[i];
+            if (pred(myval)) {
+              d_first[lcount++] = myval;
+            }
+          }
+        },
+        count);
+    // no barrier needed since single above broadcasts to all members
+    return d_first + count;
+
+  } else {
+    typename InputIterator::difference_type count = 0;
+    ::Kokkos::parallel_scan(TeamThreadRange(teamHandle, 0, num_elements),
+                            StdCopyIfFunctor(first, d_first, pred), count);
+    // no barrier needed because of the scan accumulating into count
+    return d_first + count;
+  }
+
+#if defined KOKKOS_COMPILER_INTEL ||                                  \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_CountCountIf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_CountCountIf.hpp
index 18b8c46359..9b6b403aa4 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_CountCountIf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_CountCountIf.hpp
@@ -46,37 +46,65 @@ struct StdCountIfFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType, class Predicate>
-typename IteratorType::difference_type count_if_impl(const std::string& label,
-                                                     const ExecutionSpace& ex,
-                                                     IteratorType first,
-                                                     IteratorType last,
-                                                     Predicate predicate) {
+typename IteratorType::difference_type count_if_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType first,
+    IteratorType last, Predicate predicate) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using func_t = StdCountIfFunctor<IteratorType, Predicate>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   typename IteratorType::difference_type count = 0;
   ::Kokkos::parallel_reduce(label,
                             RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                            func_t(first, predicate), count);
+                            // use CTAD
+                            StdCountIfFunctor(first, predicate), count);
   ex.fence("Kokkos::count_if: fence after operation");
 
   return count;
 }
 
 template <class ExecutionSpace, class IteratorType, class T>
-auto count_impl(const std::string& label, const ExecutionSpace& ex,
-                IteratorType first, IteratorType last, const T& value) {
-  return count_if_impl(
+auto count_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                         IteratorType first, IteratorType last,
+                         const T& value) {
+  return count_if_exespace_impl(
       label, ex, first, last,
       ::Kokkos::Experimental::Impl::StdAlgoEqualsValUnaryPredicate<T>(value));
 }
 
+//
+// team-level impl
+//
+template <class TeamHandleType, class IteratorType, class Predicate>
+KOKKOS_FUNCTION typename IteratorType::difference_type count_if_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    Predicate predicate) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  typename IteratorType::difference_type count = 0;
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            // use CTAD
+                            StdCountIfFunctor(first, predicate), count);
+  teamHandle.team_barrier();
+
+  return count;
+}
+
+template <class TeamHandleType, class IteratorType, class T>
+KOKKOS_FUNCTION auto count_team_impl(const TeamHandleType& teamHandle,
+                                     IteratorType first, IteratorType last,
+                                     const T& value) {
+  return count_if_team_impl(
+      teamHandle, first, last,
+      ::Kokkos::Experimental::Impl::StdAlgoEqualsValUnaryPredicate<T>(value));
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Equal.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Equal.hpp
index e045080d4a..62b7d226f6 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Equal.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Equal.hpp
@@ -27,15 +27,16 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class IteratorType1, class IteratorType2,
-          class BinaryPredicateType>
+template <class IteratorType1, class IteratorType2, class BinaryPredicateType>
 struct StdEqualFunctor {
+  using index_type = typename IteratorType1::difference_type;
+
   IteratorType1 m_first1;
   IteratorType2 m_first2;
   BinaryPredicateType m_predicate;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i, std::size_t& lsum) const {
+  void operator()(index_type i, std::size_t& lsum) const {
     if (!m_predicate(m_first1[i], m_first2[i])) {
       lsum = 1;
     }
@@ -49,67 +50,130 @@ struct StdEqualFunctor {
         m_predicate(std::move(_predicate)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class BinaryPredicateType>
-bool equal_impl(const std::string& label, const ExecutionSpace& ex,
-                IteratorType1 first1, IteratorType1 last1, IteratorType2 first2,
-                BinaryPredicateType predicate) {
+bool equal_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                         IteratorType1 first1, IteratorType1 last1,
+                         IteratorType2 first2, BinaryPredicateType predicate) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first1, first2);
   Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
   Impl::expect_valid_range(first1, last1);
 
-  // aliases
-  using index_type = typename IteratorType1::difference_type;
-  using func_t     = StdEqualFunctor<index_type, IteratorType1, IteratorType2,
-                                 BinaryPredicateType>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first1, last1);
   std::size_t different   = 0;
-  ::Kokkos::parallel_reduce(label,
-                            RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                            func_t(first1, first2, predicate), different);
+  ::Kokkos::parallel_reduce(
+      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      StdEqualFunctor(first1, first2, predicate), different);
   ex.fence("Kokkos::equal: fence after operation");
 
   return !different;
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-bool equal_impl(const std::string& label, const ExecutionSpace& ex,
-                IteratorType1 first1, IteratorType1 last1,
-                IteratorType2 first2) {
+bool equal_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                         IteratorType1 first1, IteratorType1 last1,
+                         IteratorType2 first2) {
   using value_type1 = typename IteratorType1::value_type;
   using value_type2 = typename IteratorType2::value_type;
   using pred_t      = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
-  return equal_impl(label, ex, first1, last1, first2, pred_t());
+  return equal_exespace_impl(label, ex, first1, last1, first2, pred_t());
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class BinaryPredicateType>
-bool equal_impl(const std::string& label, const ExecutionSpace& ex,
-                IteratorType1 first1, IteratorType1 last1, IteratorType2 first2,
-                IteratorType2 last2, BinaryPredicateType predicate) {
+bool equal_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                         IteratorType1 first1, IteratorType1 last1,
+                         IteratorType2 first2, IteratorType2 last2,
+                         BinaryPredicateType predicate) {
   const auto d1 = ::Kokkos::Experimental::distance(first1, last1);
   const auto d2 = ::Kokkos::Experimental::distance(first2, last2);
   if (d1 != d2) {
     return false;
   }
 
-  return equal_impl(label, ex, first1, last1, first2, predicate);
+  return equal_exespace_impl(label, ex, first1, last1, first2, predicate);
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-bool equal_impl(const std::string& label, const ExecutionSpace& ex,
-                IteratorType1 first1, IteratorType1 last1, IteratorType2 first2,
-                IteratorType2 last2) {
+bool equal_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                         IteratorType1 first1, IteratorType1 last1,
+                         IteratorType2 first2, IteratorType2 last2) {
+  Impl::expect_valid_range(first1, last1);
+  Impl::expect_valid_range(first2, last2);
+
+  using value_type1 = typename IteratorType1::value_type;
+  using value_type2 = typename IteratorType2::value_type;
+  using pred_t      = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+  return equal_exespace_impl(label, ex, first1, last1, first2, last2, pred_t());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType>
+KOKKOS_FUNCTION bool equal_team_impl(const TeamHandleType& teamHandle,
+                                     IteratorType1 first1, IteratorType1 last1,
+                                     IteratorType2 first2,
+                                     BinaryPredicateType predicate) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
+  Impl::expect_valid_range(first1, last1);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first1, last1);
+  std::size_t different   = 0;
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            StdEqualFunctor(first1, first2, predicate),
+                            different);
+  teamHandle.team_barrier();
+
+  return !different;
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION bool equal_team_impl(const TeamHandleType& teamHandle,
+                                     IteratorType1 first1, IteratorType1 last1,
+                                     IteratorType2 first2) {
+  using value_type1 = typename IteratorType1::value_type;
+  using value_type2 = typename IteratorType2::value_type;
+  using pred_t      = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+  return equal_team_impl(teamHandle, first1, last1, first2, pred_t());
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType>
+KOKKOS_FUNCTION bool equal_team_impl(const TeamHandleType& teamHandle,
+                                     IteratorType1 first1, IteratorType1 last1,
+                                     IteratorType2 first2, IteratorType2 last2,
+                                     BinaryPredicateType predicate) {
+  const auto d1 = ::Kokkos::Experimental::distance(first1, last1);
+  const auto d2 = ::Kokkos::Experimental::distance(first2, last2);
+  if (d1 != d2) {
+    return false;
+  }
+
+  return equal_team_impl(teamHandle, first1, last1, first2, predicate);
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION bool equal_team_impl(const TeamHandleType& teamHandle,
+                                     IteratorType1 first1, IteratorType1 last1,
+                                     IteratorType2 first2,
+                                     IteratorType2 last2) {
   Impl::expect_valid_range(first1, last1);
   Impl::expect_valid_range(first2, last2);
 
   using value_type1 = typename IteratorType1::value_type;
   using value_type2 = typename IteratorType2::value_type;
   using pred_t      = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
-  return equal_impl(label, ex, first1, last1, first2, last2, pred_t());
+  return equal_team_impl(teamHandle, first1, last1, first2, last2, pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp
index 71f13e490a..6da992b4bb 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ExclusiveScan.hpp
@@ -22,6 +22,7 @@
 #include "Kokkos_HelperPredicates.hpp"
 #include "Kokkos_ValueWrapperForNoNeutralElement.hpp"
 #include "Kokkos_IdentityReferenceUnaryFunctor.hpp"
+#include "Kokkos_FunctorsForExclusiveScan.hpp"
 #include <std_algorithms/Kokkos_TransformExclusiveScan.hpp>
 #include <std_algorithms/Kokkos_Distance.hpp>
 #include <string>
@@ -30,127 +31,15 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
-          class FirstDest>
-struct ExclusiveScanDefaultFunctorForKnownNeutralElement {
-  using execution_space = ExeSpace;
-
-  ValueType m_init_value;
-  FirstFrom m_first_from;
-  FirstDest m_first_dest;
-
-  KOKKOS_FUNCTION
-  ExclusiveScanDefaultFunctorForKnownNeutralElement(ValueType init,
-                                                    FirstFrom first_from,
-                                                    FirstDest first_dest)
-      : m_init_value(std::move(init)),
-        m_first_from(std::move(first_from)),
-        m_first_dest(std::move(first_dest)) {}
-
-  KOKKOS_FUNCTION
-  void operator()(const IndexType i, ValueType& update,
-                  const bool final_pass) const {
-    if (final_pass) m_first_dest[i] = update + m_init_value;
-    update += m_first_from[i];
-  }
-};
-
-template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
-          class FirstDest>
-struct ExclusiveScanDefaultFunctor {
-  using execution_space = ExeSpace;
-  using value_type =
-      ::Kokkos::Experimental::Impl::ValueWrapperForNoNeutralElement<ValueType>;
-
-  ValueType m_init_value;
-  FirstFrom m_first_from;
-  FirstDest m_first_dest;
-
-  KOKKOS_FUNCTION
-  ExclusiveScanDefaultFunctor(ValueType init, FirstFrom first_from,
-                              FirstDest first_dest)
-      : m_init_value(std::move(init)),
-        m_first_from(std::move(first_from)),
-        m_first_dest(std::move(first_dest)) {}
-
-  KOKKOS_FUNCTION
-  void operator()(const IndexType i, value_type& update,
-                  const bool final_pass) const {
-    if (final_pass) {
-      if (i == 0) {
-        m_first_dest[i] = m_init_value;
-      } else {
-        m_first_dest[i] = update.val + m_init_value;
-      }
-    }
-
-    const auto tmp = value_type{m_first_from[i], false};
-    this->join(update, tmp);
-  }
-
-  KOKKOS_FUNCTION
-  void init(value_type& update) const {
-    update.val        = {};
-    update.is_initial = true;
-  }
-
-  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;
-    } else {
-      update.val = update.val + input.val;
-    }
-  }
-};
-
+//
+// exespace impl
+//
 template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType, class BinaryOpType>
-OutputIteratorType exclusive_scan_custom_op_impl(
+          class OutputIteratorType, class ValueType>
+OutputIteratorType exclusive_scan_default_op_exespace_impl(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType first_from, InputIteratorType last_from,
-    OutputIteratorType first_dest, ValueType init_value, BinaryOpType bop) {
-  // checks
-  Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
-  Impl::static_assert_iterators_have_matching_difference_type(first_from,
-                                                              first_dest);
-  Impl::expect_valid_range(first_from, last_from);
-
-  // aliases
-  using index_type    = typename InputIteratorType::difference_type;
-  using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<ValueType>;
-  using func_type =
-      TransformExclusiveScanFunctor<ExecutionSpace, index_type, ValueType,
-                                    InputIteratorType, OutputIteratorType,
-                                    BinaryOpType, unary_op_type>;
-
-  // run
-  const auto num_elements =
-      Kokkos::Experimental::distance(first_from, last_from);
-  ::Kokkos::parallel_scan(
-      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-      func_type(init_value, first_from, first_dest, bop, unary_op_type()));
-  ex.fence("Kokkos::exclusive_scan_custom_op: fence after operation");
-
-  // return
-  return first_dest + num_elements;
-}
-
-template <typename ValueType>
-using ex_scan_has_reduction_identity_sum_t =
-    decltype(Kokkos::reduction_identity<ValueType>::sum());
-
-template <class ExecutionSpace, class InputIteratorType,
-          class OutputIteratorType, class ValueType>
-OutputIteratorType exclusive_scan_default_op_impl(const std::string& label,
-                                                  const ExecutionSpace& ex,
-                                                  InputIteratorType first_from,
-                                                  InputIteratorType last_from,
-                                                  OutputIteratorType first_dest,
-                                                  ValueType init_value) {
+    OutputIteratorType first_dest, ValueType init_value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
   Impl::static_assert_iterators_have_matching_difference_type(first_from,
@@ -184,17 +73,122 @@ OutputIteratorType exclusive_scan_default_op_impl(const std::string& label,
       ExclusiveScanDefaultFunctorForKnownNeutralElement<
           ExecutionSpace, index_type, ValueType, InputIteratorType,
           OutputIteratorType>,
-      ExclusiveScanDefaultFunctor<ExecutionSpace, index_type, ValueType,
-                                  InputIteratorType, OutputIteratorType>>;
+      ExclusiveScanDefaultFunctorWithValueWrapper<ExecutionSpace, index_type,
+                                                  ValueType, InputIteratorType,
+                                                  OutputIteratorType>>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(
+      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      func_type(std::move(init_value), first_from, first_dest));
+
+  ex.fence("Kokkos::exclusive_scan_default_op: fence after operation");
+
+  return first_dest + num_elements;
+}
+
+template <class ExecutionSpace, class InputIteratorType,
+          class OutputIteratorType, class ValueType, class BinaryOpType>
+OutputIteratorType exclusive_scan_custom_op_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex,
+    InputIteratorType first_from, InputIteratorType last_from,
+    OutputIteratorType first_dest, ValueType init_value, BinaryOpType bop) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  // aliases
+  using index_type    = typename InputIteratorType::difference_type;
+  using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<ValueType>;
+  using func_type     = TransformExclusiveScanFunctorWithValueWrapper<
+      ExecutionSpace, index_type, ValueType, InputIteratorType,
+      OutputIteratorType, BinaryOpType, unary_op_type>;
 
   // run
   const auto num_elements =
       Kokkos::Experimental::distance(first_from, last_from);
   ::Kokkos::parallel_scan(label,
                           RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                          func_type(init_value, first_from, first_dest));
+                          func_type(std::move(init_value), first_from,
+                                    first_dest, bop, unary_op_type()));
+  ex.fence("Kokkos::exclusive_scan_custom_op: fence after operation");
 
-  ex.fence("Kokkos::exclusive_scan_default_op: fence after operation");
+  // return
+  return first_dest + num_elements;
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class ValueType>
+KOKKOS_FUNCTION OutputIteratorType exclusive_scan_default_op_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    ValueType init_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  static_assert(
+      ::Kokkos::is_detected_v<ex_scan_has_reduction_identity_sum_t, ValueType>,
+      "The team-level impl of Kokkos::Experimental::exclusive_scan currently "
+      "does not support types without reduction identity");
+
+  // aliases
+  using exe_space  = typename TeamHandleType::execution_space;
+  using index_type = typename InputIteratorType::difference_type;
+  using func_type  = ExclusiveScanDefaultFunctorForKnownNeutralElement<
+      exe_space, index_type, ValueType, InputIteratorType, OutputIteratorType>;
+
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      func_type(std::move(init_value), first_from, first_dest));
+  teamHandle.team_barrier();
+  return first_dest + num_elements;
+}
+
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class ValueType, class BinaryOpType>
+KOKKOS_FUNCTION OutputIteratorType exclusive_scan_custom_op_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    ValueType init_value, BinaryOpType bop) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  static_assert(
+      ::Kokkos::is_detected_v<ex_scan_has_reduction_identity_sum_t, ValueType>,
+      "The team-level impl of Kokkos::Experimental::exclusive_scan currently "
+      "does not support types without reduction identity");
+
+  // aliases
+  using exe_space     = typename TeamHandleType::execution_space;
+  using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<ValueType>;
+  using index_type    = typename InputIteratorType::difference_type;
+  using func_type     = TransformExclusiveScanFunctorWithoutValueWrapper<
+      exe_space, index_type, ValueType, InputIteratorType, OutputIteratorType,
+      BinaryOpType, unary_op_type>;
+
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(TeamThreadRange(teamHandle, 0, num_elements),
+                          func_type(std::move(init_value), first_from,
+                                    first_dest, bop, unary_op_type()));
+  teamHandle.team_barrier();
 
   return first_dest + num_elements;
 }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FillFillN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FillFillN.hpp
index 316d865f31..972e57f2cc 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FillFillN.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FillFillN.hpp
@@ -41,9 +41,12 @@ struct StdFillFunctor {
       : m_first(std::move(_first)), m_value(std::move(_value)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType, class T>
-void fill_impl(const std::string& label, const ExecutionSpace& ex,
-               IteratorType first, IteratorType last, const T& value) {
+void fill_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                        IteratorType first, IteratorType last, const T& value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -52,13 +55,14 @@ void fill_impl(const std::string& label, const ExecutionSpace& ex,
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         StdFillFunctor<IteratorType, T>(first, value));
+                         StdFillFunctor(first, value));
   ex.fence("Kokkos::fill: fence after operation");
 }
 
 template <class ExecutionSpace, class IteratorType, class SizeType, class T>
-IteratorType fill_n_impl(const std::string& label, const ExecutionSpace& ex,
-                         IteratorType first, SizeType n, const T& value) {
+IteratorType fill_n_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, IteratorType first,
+                                  SizeType n, const T& value) {
   auto last = first + n;
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -67,7 +71,40 @@ IteratorType fill_n_impl(const std::string& label, const ExecutionSpace& ex,
     return first;
   }
 
-  fill_impl(label, ex, first, last, value);
+  fill_exespace_impl(label, ex, first, last, value);
+  return last;
+}
+
+//
+// team-level impl
+//
+template <class TeamHandleType, class IteratorType, class T>
+KOKKOS_FUNCTION void fill_team_impl(const TeamHandleType& teamHandle,
+                                    IteratorType first, IteratorType last,
+                                    const T& value) {
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdFillFunctor(first, value));
+
+  teamHandle.team_barrier();
+}
+
+template <class TeamHandleType, class IteratorType, class SizeType, class T>
+KOKKOS_FUNCTION IteratorType fill_n_team_impl(const TeamHandleType& teamHandle,
+                                              IteratorType first, SizeType n,
+                                              const T& value) {
+  auto last = first + n;
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  if (n <= 0) {
+    return first;
+  }
+
+  fill_team_impl(teamHandle, first, last, value);
   return last;
 }
 
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
index 3ec64fa43d..1f1ec5e54f 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FindEnd.hpp
@@ -80,12 +80,17 @@ struct StdFindEndFunctor {
         m_p(std::move(p)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class BinaryPredicateType>
-IteratorType1 find_end_impl(const std::string& label, const ExecutionSpace& ex,
-                            IteratorType1 first, IteratorType1 last,
-                            IteratorType2 s_first, IteratorType2 s_last,
-                            const BinaryPredicateType& pred) {
+IteratorType1 find_end_exespace_impl(const std::string& label,
+                                     const ExecutionSpace& ex,
+                                     IteratorType1 first, IteratorType1 last,
+                                     IteratorType2 s_first,
+                                     IteratorType2 s_last,
+                                     const BinaryPredicateType& pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, s_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, s_first);
@@ -97,7 +102,6 @@ IteratorType1 find_end_impl(const std::string& label, const ExecutionSpace& ex,
   const auto num_elements = KE::distance(first, last);
   const auto s_count      = KE::distance(s_first, s_last);
   KOKKOS_EXPECTS(num_elements >= s_count);
-  (void)s_count;  // needed when macro above is a no-op
 
   if (s_first == s_last) {
     return last;
@@ -109,7 +113,8 @@ IteratorType1 find_end_impl(const std::string& label, const ExecutionSpace& ex,
 
   // special case where the two ranges have equal size
   if (num_elements == s_count) {
-    const auto equal_result = equal_impl(label, ex, first, last, s_first, pred);
+    const auto equal_result =
+        equal_exespace_impl(label, ex, first, last, s_first, pred);
     return (equal_result) ? first : last;
   } else {
     using index_type           = typename IteratorType1::difference_type;
@@ -148,14 +153,97 @@ IteratorType1 find_end_impl(const std::string& label, const ExecutionSpace& ex,
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-IteratorType1 find_end_impl(const std::string& label, const ExecutionSpace& ex,
-                            IteratorType1 first, IteratorType1 last,
-                            IteratorType2 s_first, IteratorType2 s_last) {
+IteratorType1 find_end_exespace_impl(const std::string& label,
+                                     const ExecutionSpace& ex,
+                                     IteratorType1 first, IteratorType1 last,
+                                     IteratorType2 s_first,
+                                     IteratorType2 s_last) {
+  using value_type1    = typename IteratorType1::value_type;
+  using value_type2    = typename IteratorType2::value_type;
+  using predicate_type = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+  return find_end_exespace_impl(label, ex, first, last, s_first, s_last,
+                                predicate_type());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType>
+KOKKOS_FUNCTION IteratorType1
+find_end_team_impl(const TeamHandleType& teamHandle, IteratorType1 first,
+                   IteratorType1 last, IteratorType2 s_first,
+                   IteratorType2 s_last, const BinaryPredicateType& pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, s_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, s_first);
+  Impl::expect_valid_range(first, last);
+  Impl::expect_valid_range(s_first, s_last);
+
+  // the target sequence should not be larger than the range [first, last)
+  namespace KE            = ::Kokkos::Experimental;
+  const auto num_elements = KE::distance(first, last);
+  const auto s_count      = KE::distance(s_first, s_last);
+  KOKKOS_EXPECTS(num_elements >= s_count);
+
+  if (s_first == s_last) {
+    return last;
+  }
+
+  if (first == last) {
+    return last;
+  }
+
+  // special case where the two ranges have equal size
+  if (num_elements == s_count) {
+    const auto equal_result =
+        equal_team_impl(teamHandle, first, last, s_first, pred);
+    return (equal_result) ? first : last;
+  } else {
+    using index_type           = typename IteratorType1::difference_type;
+    using reducer_type         = LastLoc<index_type>;
+    using reduction_value_type = typename reducer_type::value_type;
+    using func_t = StdFindEndFunctor<index_type, IteratorType1, IteratorType2,
+                                     reducer_type, BinaryPredicateType>;
+
+    // run
+    reduction_value_type red_result;
+    reducer_type reducer(red_result);
+
+    // decide the size of the range policy of the par_red:
+    // note that the last feasible index to start looking is the index
+    // whose distance from the "last" is equal to the sequence count.
+    // the +1 is because we need to include that location too.
+    const auto range_size = num_elements - s_count + 1;
+
+    // run par reduce
+    ::Kokkos::parallel_reduce(
+        TeamThreadRange(teamHandle, 0, range_size),
+        func_t(first, last, s_first, s_last, reducer, pred), reducer);
+
+    teamHandle.team_barrier();
+
+    // decide and return
+    if (red_result.max_loc_true ==
+        ::Kokkos::reduction_identity<index_type>::max()) {
+      // if here, a subrange has not been found
+      return last;
+    } else {
+      // a location has been found
+      return first + red_result.max_loc_true;
+    }
+  }
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION IteratorType1 find_end_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first, IteratorType1 last,
+    IteratorType2 s_first, IteratorType2 s_last) {
   using value_type1    = typename IteratorType1::value_type;
   using value_type2    = typename IteratorType2::value_type;
   using predicate_type = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
-  return find_end_impl(label, ex, first, last, s_first, s_last,
-                       predicate_type());
+  return find_end_team_impl(teamHandle, first, last, s_first, s_last,
+                            predicate_type());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
index 5f22d2ad13..145e235b9d 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FindFirstOf.hpp
@@ -71,13 +71,15 @@ struct StdFindFirstOfFunctor {
         m_p(std::move(p)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class BinaryPredicateType>
-IteratorType1 find_first_of_impl(const std::string& label,
-                                 const ExecutionSpace& ex, IteratorType1 first,
-                                 IteratorType1 last, IteratorType2 s_first,
-                                 IteratorType2 s_last,
-                                 const BinaryPredicateType& pred) {
+IteratorType1 find_first_of_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType1 first,
+    IteratorType1 last, IteratorType2 s_first, IteratorType2 s_last,
+    const BinaryPredicateType& pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, s_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, s_first);
@@ -116,15 +118,71 @@ IteratorType1 find_first_of_impl(const std::string& label,
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-IteratorType1 find_first_of_impl(const std::string& label,
-                                 const ExecutionSpace& ex, IteratorType1 first,
-                                 IteratorType1 last, IteratorType2 s_first,
-                                 IteratorType2 s_last) {
+IteratorType1 find_first_of_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType1 first,
+    IteratorType1 last, IteratorType2 s_first, IteratorType2 s_last) {
+  using value_type1    = typename IteratorType1::value_type;
+  using value_type2    = typename IteratorType2::value_type;
+  using predicate_type = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+  return find_first_of_exespace_impl(label, ex, first, last, s_first, s_last,
+                                     predicate_type());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType>
+KOKKOS_FUNCTION IteratorType1
+find_first_of_team_impl(const TeamHandleType& teamHandle, IteratorType1 first,
+                        IteratorType1 last, IteratorType2 s_first,
+                        IteratorType2 s_last, const BinaryPredicateType& pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, s_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, s_first);
+  Impl::expect_valid_range(first, last);
+  Impl::expect_valid_range(s_first, s_last);
+
+  if ((s_first == s_last) || (first == last)) {
+    return last;
+  }
+
+  using index_type           = typename IteratorType1::difference_type;
+  using reducer_type         = FirstLoc<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+  using func_t = StdFindFirstOfFunctor<index_type, IteratorType1, IteratorType2,
+                                       reducer_type, BinaryPredicateType>;
+
+  // run
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            func_t(first, s_first, s_last, reducer, pred),
+                            reducer);
+
+  teamHandle.team_barrier();
+
+  // decide and return
+  if (red_result.min_loc_true ==
+      ::Kokkos::reduction_identity<index_type>::min()) {
+    // if here, nothing found
+    return last;
+  } else {
+    // a location has been found
+    return first + red_result.min_loc_true;
+  }
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION IteratorType1 find_first_of_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first, IteratorType1 last,
+    IteratorType2 s_first, IteratorType2 s_last) {
   using value_type1    = typename IteratorType1::value_type;
   using value_type2    = typename IteratorType2::value_type;
   using predicate_type = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
-  return find_first_of_impl(label, ex, first, last, s_first, s_last,
-                            predicate_type());
+  return find_first_of_team_impl(teamHandle, first, last, s_first, s_last,
+                                 predicate_type());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
index 9c0b0c0ccd..8fffb59094 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FindIfOrNot.hpp
@@ -61,11 +61,15 @@ struct StdFindIfOrNotFunctor {
         m_p(std::move(p)) {}
 };
 
+//
+// exespace impl
+//
 template <bool is_find_if, class ExecutionSpace, class IteratorType,
           class PredicateType>
-IteratorType find_if_or_not_impl(const std::string& label,
-                                 const ExecutionSpace& ex, IteratorType first,
-                                 IteratorType last, PredicateType pred) {
+IteratorType find_if_or_not_exespace_impl(const std::string& label,
+                                          const ExecutionSpace& ex,
+                                          IteratorType first, IteratorType last,
+                                          PredicateType pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(
       ex, first);  // only need one It per type
@@ -104,14 +108,68 @@ IteratorType find_if_or_not_impl(const std::string& label,
 }
 
 template <class ExecutionSpace, class InputIterator, class T>
-InputIterator find_impl(const std::string& label, ExecutionSpace ex,
-                        InputIterator first, InputIterator last,
-                        const T& value) {
-  return find_if_or_not_impl<true>(
+InputIterator find_exespace_impl(const std::string& label, ExecutionSpace ex,
+                                 InputIterator first, InputIterator last,
+                                 const T& value) {
+  return find_if_or_not_exespace_impl<true>(
       label, ex, first, last,
       ::Kokkos::Experimental::Impl::StdAlgoEqualsValUnaryPredicate<T>(value));
 }
 
+//
+// team impl
+//
+template <bool is_find_if, class TeamHandleType, class IteratorType,
+          class PredicateType>
+KOKKOS_FUNCTION IteratorType
+find_if_or_not_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                         IteratorType last, PredicateType pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(
+      teamHandle, first);  // only need one It per type
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    return last;
+  }
+
+  // aliases
+  using index_type           = typename IteratorType::difference_type;
+  using reducer_type         = FirstLoc<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+  using func_t = StdFindIfOrNotFunctor<is_find_if, index_type, IteratorType,
+                                       reducer_type, PredicateType>;
+
+  // run
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            func_t(first, reducer, pred), reducer);
+
+  teamHandle.team_barrier();
+
+  // decide and return
+  if (red_result.min_loc_true ==
+      ::Kokkos::reduction_identity<index_type>::min()) {
+    // here, it means a valid loc has not been found,
+    return last;
+  } else {
+    // a location has been found
+    return first + red_result.min_loc_true;
+  }
+}
+
+template <class TeamHandleType, class InputIterator, class T>
+KOKKOS_FUNCTION InputIterator find_team_impl(const TeamHandleType& teamHandle,
+                                             InputIterator first,
+                                             InputIterator last,
+                                             const T& value) {
+  return find_if_or_not_team_impl<true>(
+      teamHandle, first, last,
+      ::Kokkos::Experimental::Impl::StdAlgoEqualsValUnaryPredicate<T>(value));
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ForEachForEachN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ForEachForEachN.hpp
index f9a6ff2e99..99cc4a1cf3 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ForEachForEachN.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ForEachForEachN.hpp
@@ -41,29 +41,28 @@ struct StdForEachFunctor {
       : m_first(std::move(_first)), m_functor(std::move(_functor)) {}
 };
 
-template <class ExecutionSpace, class IteratorType, class UnaryFunctorType>
-UnaryFunctorType for_each_impl(const std::string& label,
-                               const ExecutionSpace& ex, IteratorType first,
-                               IteratorType last, UnaryFunctorType functor) {
+template <class HandleType, class IteratorType, class UnaryFunctorType>
+void for_each_exespace_impl(const std::string& label, const HandleType& handle,
+                            IteratorType first, IteratorType last,
+                            UnaryFunctorType functor) {
   // checks
-  Impl::static_assert_random_access_and_accessible(ex, first);
+  Impl::static_assert_random_access_and_accessible(handle, first);
   Impl::expect_valid_range(first, last);
 
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(
-      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      label, RangePolicy<HandleType>(handle, 0, num_elements),
       StdForEachFunctor<IteratorType, UnaryFunctorType>(first, functor));
-  ex.fence("Kokkos::for_each: fence after operation");
-
-  return functor;
+  handle.fence("Kokkos::for_each: fence after operation");
 }
 
 template <class ExecutionSpace, class IteratorType, class SizeType,
           class UnaryFunctorType>
-IteratorType for_each_n_impl(const std::string& label, const ExecutionSpace& ex,
-                             IteratorType first, SizeType n,
-                             UnaryFunctorType functor) {
+IteratorType for_each_n_exespace_impl(const std::string& label,
+                                      const ExecutionSpace& ex,
+                                      IteratorType first, SizeType n,
+                                      UnaryFunctorType functor) {
   auto last = first + n;
   Impl::static_assert_random_access_and_accessible(ex, first, last);
   Impl::expect_valid_range(first, last);
@@ -72,8 +71,45 @@ IteratorType for_each_n_impl(const std::string& label, const ExecutionSpace& ex,
     return first;
   }
 
-  for_each_impl(label, ex, first, last, std::move(functor));
-  // no neeed to fence since for_each_impl fences already
+  for_each_exespace_impl(label, ex, first, last, std::move(functor));
+  // no need to fence since for_each_exespace_impl fences already
+
+  return last;
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType, class UnaryFunctorType>
+KOKKOS_FUNCTION void for_each_team_impl(const TeamHandleType& teamHandle,
+                                        IteratorType first, IteratorType last,
+                                        UnaryFunctorType functor) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      StdForEachFunctor<IteratorType, UnaryFunctorType>(first, functor));
+  teamHandle.team_barrier();
+}
+
+template <class TeamHandleType, class IteratorType, class SizeType,
+          class UnaryFunctorType>
+KOKKOS_FUNCTION IteratorType
+for_each_n_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                     SizeType n, UnaryFunctorType functor) {
+  auto last = first + n;
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, last);
+  Impl::expect_valid_range(first, last);
+
+  if (n == 0) {
+    return first;
+  }
+
+  for_each_team_impl(teamHandle, first, last, std::move(functor));
+  // no need to fence since for_each_team_impl fences already
 
   return last;
 }
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_FunctorsForExclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_FunctorsForExclusiveScan.hpp
new file mode 100644
index 0000000000..5a7fe16984
--- /dev/null
+++ b/algorithms/src/std_algorithms/impl/Kokkos_FunctorsForExclusiveScan.hpp
@@ -0,0 +1,221 @@
+//@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_STD_ALGORITHMS_FUNCTORS_FOR_EXCLUSIVE_SCAN_IMPL_HPP
+#define KOKKOS_STD_ALGORITHMS_FUNCTORS_FOR_EXCLUSIVE_SCAN_IMPL_HPP
+
+#include <Kokkos_Core.hpp>
+#include "Kokkos_ValueWrapperForNoNeutralElement.hpp"
+
+namespace Kokkos {
+namespace Experimental {
+namespace Impl {
+
+template <typename ValueType>
+using ex_scan_has_reduction_identity_sum_t =
+    decltype(Kokkos::reduction_identity<ValueType>::sum());
+
+template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
+          class FirstDest>
+struct ExclusiveScanDefaultFunctorForKnownNeutralElement {
+  using execution_space = ExeSpace;
+  ValueType m_init_value;
+  FirstFrom m_first_from;
+  FirstDest m_first_dest;
+
+  KOKKOS_FUNCTION
+  ExclusiveScanDefaultFunctorForKnownNeutralElement(ValueType init,
+                                                    FirstFrom first_from,
+                                                    FirstDest first_dest)
+      : m_init_value(std::move(init)),
+        m_first_from(std::move(first_from)),
+        m_first_dest(std::move(first_dest)) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const IndexType i, ValueType& update,
+                  const bool final_pass) const {
+    const auto tmp = m_first_from[i];
+    if (final_pass) m_first_dest[i] = update + m_init_value;
+    update += tmp;
+  }
+};
+
+template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
+          class FirstDest>
+struct ExclusiveScanDefaultFunctorWithValueWrapper {
+  using execution_space = ExeSpace;
+  using value_type =
+      ::Kokkos::Experimental::Impl::ValueWrapperForNoNeutralElement<ValueType>;
+  ValueType m_init_value;
+  FirstFrom m_first_from;
+  FirstDest m_first_dest;
+
+  KOKKOS_FUNCTION
+  ExclusiveScanDefaultFunctorWithValueWrapper(ValueType init,
+                                              FirstFrom first_from,
+                                              FirstDest first_dest)
+      : m_init_value(std::move(init)),
+        m_first_from(std::move(first_from)),
+        m_first_dest(std::move(first_dest)) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const IndexType i, value_type& update,
+                  const bool final_pass) const {
+    const auto tmp = value_type{m_first_from[i], false};
+    if (final_pass) {
+      if (i == 0) {
+        m_first_dest[i] = m_init_value;
+      } else {
+        m_first_dest[i] = update.val + m_init_value;
+      }
+    }
+
+    this->join(update, tmp);
+  }
+
+  KOKKOS_FUNCTION
+  void init(value_type& update) const {
+    update.val        = {};
+    update.is_initial = true;
+  }
+
+  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;
+    } else {
+      update.val = update.val + input.val;
+    }
+  }
+};
+
+template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
+          class FirstDest, class BinaryOpType, class UnaryOpType>
+struct TransformExclusiveScanFunctorWithValueWrapper {
+  using execution_space = ExeSpace;
+  using value_type =
+      ::Kokkos::Experimental::Impl::ValueWrapperForNoNeutralElement<ValueType>;
+
+  ValueType m_init_value;
+  FirstFrom m_first_from;
+  FirstDest m_first_dest;
+  BinaryOpType m_binary_op;
+  UnaryOpType m_unary_op;
+
+  KOKKOS_FUNCTION
+  TransformExclusiveScanFunctorWithValueWrapper(ValueType init,
+                                                FirstFrom first_from,
+                                                FirstDest first_dest,
+                                                BinaryOpType bop,
+                                                UnaryOpType uop)
+      : m_init_value(std::move(init)),
+        m_first_from(std::move(first_from)),
+        m_first_dest(std::move(first_dest)),
+        m_binary_op(std::move(bop)),
+        m_unary_op(std::move(uop)) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const IndexType i, value_type& update,
+                  const bool final_pass) const {
+    const auto tmp = value_type{m_unary_op(m_first_from[i]), false};
+    if (final_pass) {
+      if (i == 0) {
+        // for both ExclusiveScan and TransformExclusiveScan,
+        // init is unmodified
+        m_first_dest[i] = m_init_value;
+      } else {
+        m_first_dest[i] = m_binary_op(update.val, m_init_value);
+      }
+    }
+
+    this->join(update, tmp);
+  }
+
+  KOKKOS_FUNCTION void init(value_type& value) const {
+    value.val        = {};
+    value.is_initial = true;
+  }
+
+  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 {
+      update.val = m_binary_op(update.val, input.val);
+    }
+    update.is_initial = false;
+  }
+};
+
+template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
+          class FirstDest, class BinaryOpType, class UnaryOpType>
+struct TransformExclusiveScanFunctorWithoutValueWrapper {
+  using execution_space = ExeSpace;
+
+  ValueType m_init_value;
+  FirstFrom m_first_from;
+  FirstDest m_first_dest;
+  BinaryOpType m_binary_op;
+  UnaryOpType m_unary_op;
+
+  KOKKOS_FUNCTION
+  TransformExclusiveScanFunctorWithoutValueWrapper(ValueType init,
+                                                   FirstFrom first_from,
+                                                   FirstDest first_dest,
+                                                   BinaryOpType bop,
+                                                   UnaryOpType uop)
+      : m_init_value(std::move(init)),
+        m_first_from(std::move(first_from)),
+        m_first_dest(std::move(first_dest)),
+        m_binary_op(std::move(bop)),
+        m_unary_op(std::move(uop)) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const IndexType i, ValueType& update,
+                  const bool final_pass) const {
+    const auto tmp = ValueType{m_unary_op(m_first_from[i])};
+    if (final_pass) {
+      if (i == 0) {
+        // for both ExclusiveScan and TransformExclusiveScan,
+        // init is unmodified
+        m_first_dest[i] = m_init_value;
+      } else {
+        m_first_dest[i] = m_binary_op(update, m_init_value);
+      }
+    }
+
+    this->join(update, tmp);
+  }
+
+  KOKKOS_FUNCTION
+  void init(ValueType& update) const { update = {}; }
+
+  KOKKOS_FUNCTION
+  void join(ValueType& update, const ValueType& input) const {
+    update = m_binary_op(update, input);
+  }
+};
+
+}  // namespace Impl
+}  // namespace Experimental
+}  // namespace Kokkos
+
+#endif
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_GenerateGenerateN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_GenerateGenerateN.hpp
index 228390bdff..157de1125e 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_GenerateGenerateN.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_GenerateGenerateN.hpp
@@ -41,32 +41,65 @@ struct StdGenerateFunctor {
       : m_first(std::move(_first)), m_generator(std::move(_g)) {}
 };
 
+//
+// generate impl
+//
 template <class ExecutionSpace, class IteratorType, class Generator>
-void generate_impl(const std::string& label, const ExecutionSpace& ex,
-                   IteratorType first, IteratorType last, Generator g) {
+void generate_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                            IteratorType first, IteratorType last,
+                            Generator g) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using func_t = StdGenerateFunctor<IteratorType, Generator>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first, g));
+                         StdGenerateFunctor(first, g));
   ex.fence("Kokkos::generate: fence after operation");
 }
 
+template <class TeamHandleType, class IteratorType, class Generator>
+KOKKOS_FUNCTION void generate_team_impl(const TeamHandleType& teamHandle,
+                                        IteratorType first, IteratorType last,
+                                        Generator g) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdGenerateFunctor(first, g));
+  teamHandle.team_barrier();
+}
+
+//
+// generate_n impl
+//
 template <class ExecutionSpace, class IteratorType, class Size, class Generator>
-IteratorType generate_n_impl(const std::string& label, const ExecutionSpace& ex,
-                             IteratorType first, Size count, Generator g) {
+IteratorType generate_n_exespace_impl(const std::string& label,
+                                      const ExecutionSpace& ex,
+                                      IteratorType first, Size count,
+                                      Generator g) {
+  if (count <= 0) {
+    return first;
+  }
+
+  generate_exespace_impl(label, ex, first, first + count, g);
+  return first + count;
+}
+
+template <class TeamHandleType, class IteratorType, class Size, class Generator>
+KOKKOS_FUNCTION IteratorType
+generate_n_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                     Size count, Generator g) {
   if (count <= 0) {
     return first;
   }
 
-  generate_impl(label, ex, first, first + count, g);
+  generate_team_impl(teamHandle, first, first + count, g);
   return first + count;
 }
 
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp
index ecd6ff39cd..0b4acec0fe 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_InclusiveScan.hpp
@@ -101,9 +101,12 @@ struct InclusiveScanDefaultFunctor {
   }
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType>
-OutputIteratorType inclusive_scan_default_op_impl(
+OutputIteratorType inclusive_scan_default_op_exespace_impl(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType first_from, InputIteratorType last_from,
     OutputIteratorType first_dest) {
@@ -143,7 +146,7 @@ OutputIteratorType inclusive_scan_default_op_impl(
 // -------------------------------------------------------------
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class BinaryOpType>
-OutputIteratorType inclusive_scan_custom_binary_op_impl(
+OutputIteratorType inclusive_scan_custom_binary_op_exespace_impl(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType first_from, InputIteratorType last_from,
     OutputIteratorType first_dest, BinaryOpType binary_op) {
@@ -158,7 +161,7 @@ OutputIteratorType inclusive_scan_custom_binary_op_impl(
   using value_type =
       std::remove_const_t<typename InputIteratorType::value_type>;
   using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<value_type>;
-  using func_type     = TransformInclusiveScanNoInitValueFunctor<
+  using func_type     = ExeSpaceTransformInclusiveScanNoInitValueFunctor<
       ExecutionSpace, index_type, value_type, InputIteratorType,
       OutputIteratorType, BinaryOpType, unary_op_type>;
 
@@ -179,7 +182,7 @@ OutputIteratorType inclusive_scan_custom_binary_op_impl(
 // -------------------------------------------------------------
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class BinaryOpType, class ValueType>
-OutputIteratorType inclusive_scan_custom_binary_op_impl(
+OutputIteratorType inclusive_scan_custom_binary_op_exespace_impl(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType first_from, InputIteratorType last_from,
     OutputIteratorType first_dest, BinaryOpType binary_op,
@@ -193,7 +196,7 @@ OutputIteratorType inclusive_scan_custom_binary_op_impl(
   // aliases
   using index_type    = typename InputIteratorType::difference_type;
   using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<ValueType>;
-  using func_type     = TransformInclusiveScanWithInitValueFunctor<
+  using func_type     = ExeSpaceTransformInclusiveScanWithInitValueFunctor<
       ExecutionSpace, index_type, ValueType, InputIteratorType,
       OutputIteratorType, BinaryOpType, unary_op_type>;
 
@@ -203,13 +206,142 @@ OutputIteratorType inclusive_scan_custom_binary_op_impl(
   ::Kokkos::parallel_scan(label,
                           RangePolicy<ExecutionSpace>(ex, 0, num_elements),
                           func_type(first_from, first_dest, binary_op,
-                                    unary_op_type(), init_value));
+                                    unary_op_type(), std::move(init_value)));
   ex.fence("Kokkos::inclusive_scan_custom_binary_op: fence after operation");
 
   // return
   return first_dest + num_elements;
 }
 
+//
+// team impl
+//
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType>
+KOKKOS_FUNCTION OutputIteratorType inclusive_scan_default_op_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  using value_type =
+      std::remove_const_t<typename InputIteratorType::value_type>;
+
+  // #if defined(KOKKOS_ENABLE_CUDA)
+
+  using exe_space  = typename TeamHandleType::execution_space;
+  using index_type = typename InputIteratorType::difference_type;
+  using func_type  = std::conditional_t<
+      ::Kokkos::is_detected<in_scan_has_reduction_identity_sum_t,
+                            value_type>::value,
+      InclusiveScanDefaultFunctorForKnownIdentityElement<
+          exe_space, index_type, value_type, InputIteratorType,
+          OutputIteratorType>,
+      InclusiveScanDefaultFunctor<exe_space, index_type, value_type,
+                                  InputIteratorType, OutputIteratorType>>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(TeamThreadRange(teamHandle, 0, num_elements),
+                          func_type(first_from, first_dest));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
+// -------------------------------------------------------------
+// inclusive_scan_custom_binary_op_impl
+// -------------------------------------------------------------
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class BinaryOpType>
+KOKKOS_FUNCTION OutputIteratorType inclusive_scan_custom_binary_op_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    BinaryOpType binary_op) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  using value_type =
+      std::remove_const_t<typename InputIteratorType::value_type>;
+
+  static_assert(
+      ::Kokkos::is_detected_v<ex_scan_has_reduction_identity_sum_t, value_type>,
+      "At the moment inclusive_scan doesn't support types without reduction "
+      "identity");
+
+  // #if defined(KOKKOS_ENABLE_CUDA)
+
+  // aliases
+  using exe_space     = typename TeamHandleType::execution_space;
+  using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<value_type>;
+  using func_type     = TeamTransformInclusiveScanNoInitValueFunctor<
+      exe_space, value_type, InputIteratorType, OutputIteratorType,
+      BinaryOpType, unary_op_type>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+
+  ::Kokkos::parallel_scan(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      func_type(first_from, first_dest, binary_op, unary_op_type()));
+  teamHandle.team_barrier();
+
+  return first_dest + num_elements;
+}
+
+// -------------------------------------------------------------
+// inclusive_scan_custom_binary_op_impl with init_value
+// -------------------------------------------------------------
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class BinaryOpType, class ValueType>
+KOKKOS_FUNCTION OutputIteratorType inclusive_scan_custom_binary_op_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    BinaryOpType binary_op, ValueType init_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  static_assert(
+      ::Kokkos::is_detected_v<ex_scan_has_reduction_identity_sum_t, ValueType>,
+      "At the moment inclusive_scan doesn't support types without reduction "
+      "identity");
+
+  // #if defined(KOKKOS_ENABLE_CUDA)
+
+  // aliases
+  using exe_space     = typename TeamHandleType::execution_space;
+  using unary_op_type = StdNumericScanIdentityReferenceUnaryFunctor<ValueType>;
+  using func_type     = TeamTransformInclusiveScanWithInitValueFunctor<
+      exe_space, ValueType, InputIteratorType, OutputIteratorType, BinaryOpType,
+      unary_op_type>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(TeamThreadRange(teamHandle, 0, num_elements),
+                          func_type(first_from, first_dest, binary_op,
+                                    unary_op_type(), std::move(init_value)));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp b/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
index 0fe2d246ff..281efca36b 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_IsPartitioned.hpp
@@ -62,9 +62,9 @@ struct StdIsPartitionedFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType, class PredicateType>
-bool is_partitioned_impl(const std::string& label, const ExecutionSpace& ex,
-                         IteratorType first, IteratorType last,
-                         PredicateType pred) {
+bool is_partitioned_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, IteratorType first,
+                                  IteratorType last, PredicateType pred) {
   // true if all elements in the range [first, last) that satisfy
   // the predicate "pred" appear before all elements that don't.
   // Also returns true if [first, last) is empty.
@@ -97,6 +97,7 @@ bool is_partitioned_impl(const std::string& label, const ExecutionSpace& ex,
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_reduce(label,
                             RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+
                             func_t(first, reducer, pred), reducer);
 
   // fence not needed because reducing into scalar
@@ -109,8 +110,72 @@ bool is_partitioned_impl(const std::string& label, const ExecutionSpace& ex,
 
   if (red_result.max_loc_true != red_id_max &&
       red_result.min_loc_false != red_id_min) {
+    // this occurs when the reduction yields nontrivial values
     return red_result.max_loc_true < red_result.min_loc_false;
+  } else if (red_result.max_loc_true == red_id_max &&
+             red_result.min_loc_false == 0) {
+    // this occurs when all values do NOT satisfy
+    // the predicate, and this corner case should also be true
+    return true;
+  } else if (first + red_result.max_loc_true == --last) {
+    // this occurs when all values satisfy the predicate,
+    // this corner case should also be true
+    return true;
+  } else {
+    return false;
+  }
+}
+
+template <class TeamHandleType, class IteratorType, class PredicateType>
+KOKKOS_FUNCTION bool is_partitioned_team_impl(const TeamHandleType& teamHandle,
+                                              IteratorType first,
+                                              IteratorType last,
+                                              PredicateType pred) {
+  /* see exespace impl for the description of the impl */
+
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // trivial case
+  if (first == last) {
+    return true;
+  }
+
+  // aliases
+  using index_type           = typename IteratorType::difference_type;
+  using reducer_type         = StdIsPartitioned<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+  using func_t =
+      StdIsPartitionedFunctor<IteratorType, reducer_type, PredicateType>;
+
+  // run
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            func_t(first, reducer, pred), reducer);
+
+  // fence not needed because reducing into scalar
+
+  // decide and return
+  constexpr index_type red_id_min =
+      ::Kokkos::reduction_identity<index_type>::min();
+  constexpr index_type red_id_max =
+      ::Kokkos::reduction_identity<index_type>::max();
+
+  if (red_result.max_loc_true != red_id_max &&
+      red_result.min_loc_false != red_id_min) {
+    // this occurs when the reduction yields nontrivial values
+    return red_result.max_loc_true < red_result.min_loc_false;
+  } else if (red_result.max_loc_true == red_id_max &&
+             red_result.min_loc_false == 0) {
+    // this occurs when all values do NOT satisfy
+    // the predicate, and this corner case should also be true
+    return true;
   } else if (first + red_result.max_loc_true == --last) {
+    // this occurs when all values satisfy the predicate,
+    // this corner case should also be true
     return true;
   } else {
     return false;
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_IsSorted.hpp b/algorithms/src/std_algorithms/impl/Kokkos_IsSorted.hpp
index 4696821586..b2c912848a 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_IsSorted.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_IsSorted.hpp
@@ -48,10 +48,13 @@ struct StdIsSortedFunctor {
       : m_first(std::move(_first1)), m_comparator(std::move(comparator)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType, class ComparatorType>
-bool is_sorted_impl(const std::string& label, const ExecutionSpace& ex,
-                    IteratorType first, IteratorType last,
-                    ComparatorType comp) {
+bool is_sorted_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                             IteratorType first, IteratorType last,
+                             ComparatorType comp) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -75,11 +78,49 @@ bool is_sorted_impl(const std::string& label, const ExecutionSpace& ex,
 }
 
 template <class ExecutionSpace, class IteratorType>
-bool is_sorted_impl(const std::string& label, const ExecutionSpace& ex,
-                    IteratorType first, IteratorType last) {
+bool is_sorted_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                             IteratorType first, IteratorType last) {
+  using value_type = typename IteratorType::value_type;
+  using pred_t     = Impl::StdAlgoLessThanBinaryPredicate<value_type>;
+  return is_sorted_exespace_impl(label, ex, first, last, pred_t());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType, class ComparatorType>
+KOKKOS_FUNCTION bool is_sorted_team_impl(const TeamHandleType& teamHandle,
+                                         IteratorType first, IteratorType last,
+                                         ComparatorType comp) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  if (num_elements <= 1) {
+    return true;
+  }
+
+  // use num_elements-1 because each index handles i and i+1
+  const auto num_elements_minus_one = num_elements - 1;
+
+  // result is incremented by one if sorting breaks at index i
+  std::size_t result = 0;
+  ::Kokkos::parallel_reduce(
+      TeamThreadRange(teamHandle, 0, num_elements_minus_one),
+      // use CTAD here
+      StdIsSortedFunctor(first, std::move(comp)), result);
+
+  return result == 0;
+}
+
+template <class TeamHandleType, class IteratorType>
+KOKKOS_FUNCTION bool is_sorted_team_impl(const TeamHandleType& teamHandle,
+                                         IteratorType first,
+                                         IteratorType last) {
   using value_type = typename IteratorType::value_type;
   using pred_t     = Impl::StdAlgoLessThanBinaryPredicate<value_type>;
-  return is_sorted_impl(label, ex, first, last, pred_t());
+  return is_sorted_team_impl(teamHandle, first, last, pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp b/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp
index 2a0c112bf5..d33580ca53 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_IsSortedUntil.hpp
@@ -54,10 +54,15 @@ struct StdIsSortedUntilFunctor {
         m_reducer(std::move(reducer)) {}
 };
 
+//
+// overloads accepting exespace
+//
 template <class ExecutionSpace, class IteratorType, class ComparatorType>
-IteratorType is_sorted_until_impl(const std::string& label,
-                                  const ExecutionSpace& ex, IteratorType first,
-                                  IteratorType last, ComparatorType comp) {
+IteratorType is_sorted_until_exespace_impl(const std::string& label,
+                                           const ExecutionSpace& ex,
+                                           IteratorType first,
+                                           IteratorType last,
+                                           ComparatorType comp) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -81,7 +86,6 @@ IteratorType is_sorted_until_impl(const std::string& label,
       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,
@@ -98,12 +102,66 @@ IteratorType is_sorted_until_impl(const std::string& label,
 }
 
 template <class ExecutionSpace, class IteratorType>
-IteratorType is_sorted_until_impl(const std::string& label,
-                                  const ExecutionSpace& ex, IteratorType first,
-                                  IteratorType last) {
+IteratorType is_sorted_until_exespace_impl(const std::string& label,
+                                           const ExecutionSpace& ex,
+                                           IteratorType first,
+                                           IteratorType last) {
+  using value_type = typename IteratorType::value_type;
+  using pred_t     = Impl::StdAlgoLessThanBinaryPredicate<value_type>;
+  return is_sorted_until_exespace_impl(label, ex, first, last, pred_t());
+}
+
+//
+// overloads accepting team handle
+//
+template <class ExecutionSpace, class IteratorType, class ComparatorType>
+KOKKOS_FUNCTION IteratorType
+is_sorted_until_team_impl(const ExecutionSpace& teamHandle, IteratorType first,
+                          IteratorType last, ComparatorType comp) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+
+  // trivial case
+  if (num_elements <= 1) {
+    return last;
+  }
+
+  /*
+    Do a par_reduce computing the *min* index that breaks the sorting.
+    If one such index is found, then the range is sorted until that element,
+    if no such index is found, then it means the range is sorted until the end.
+  */
+  using index_type = typename IteratorType::difference_type;
+  index_type red_result;
+  index_type red_result_init;
+  ::Kokkos::Min<index_type> reducer(red_result);
+  reducer.init(red_result_init);
+  ::Kokkos::parallel_reduce(  // use num_elements-1 because each index handles i
+                              // and i+1
+      TeamThreadRange(teamHandle, 0, num_elements - 1),
+      StdIsSortedUntilFunctor(first, comp, reducer), reducer);
+  teamHandle.team_barrier();
+
+  /* If the reduction result is equal to the initial value,
+     and it means the range is sorted until the end */
+  if (red_result == red_result_init) {
+    return last;
+  } else {
+    /* If  such 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 + (red_result + 1);
+  }
+}
+
+template <class ExecutionSpace, class IteratorType>
+KOKKOS_FUNCTION IteratorType is_sorted_until_team_impl(
+    const ExecutionSpace& teamHandle, IteratorType first, IteratorType last) {
   using value_type = typename IteratorType::value_type;
   using pred_t     = Impl::StdAlgoLessThanBinaryPredicate<value_type>;
-  return is_sorted_until_impl(label, ex, first, last, pred_t());
+  return is_sorted_until_team_impl(teamHandle, first, last, pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp b/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
index ad7f59232e..b95a66c3bd 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_LexicographicalCompare.hpp
@@ -84,13 +84,15 @@ struct StdLexicographicalCompareFunctor {
         m_comparator(std::move(_comp)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class ComparatorType>
-bool lexicographical_compare_impl(const std::string& label,
-                                  const ExecutionSpace& ex,
-                                  IteratorType1 first1, IteratorType1 last1,
-                                  IteratorType2 first2, IteratorType2 last2,
-                                  ComparatorType comp) {
+bool lexicographical_compare_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
+    IteratorType1 last1, IteratorType2 first2, IteratorType2 last2,
+    ComparatorType comp) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first1, first2);
   Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
@@ -139,16 +141,84 @@ bool lexicographical_compare_impl(const std::string& label,
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-bool lexicographical_compare_impl(const std::string& label,
-                                  const ExecutionSpace& ex,
-                                  IteratorType1 first1, IteratorType1 last1,
-                                  IteratorType2 first2, IteratorType2 last2) {
+bool lexicographical_compare_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
+    IteratorType1 last1, IteratorType2 first2, IteratorType2 last2) {
+  using value_type_1 = typename IteratorType1::value_type;
+  using value_type_2 = typename IteratorType2::value_type;
+  using predicate_t =
+      Impl::StdAlgoLessThanBinaryPredicate<value_type_1, value_type_2>;
+  return lexicographical_compare_exespace_impl(label, ex, first1, last1, first2,
+                                               last2, predicate_t());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class ComparatorType>
+KOKKOS_FUNCTION bool lexicographical_compare_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2, ComparatorType comp) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
+  Impl::expect_valid_range(first1, last1);
+  Impl::expect_valid_range(first2, last2);
+
+  // aliases
+  using index_type           = typename IteratorType1::difference_type;
+  using reducer_type         = FirstLoc<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  // run
+  const auto d1    = Kokkos::Experimental::distance(first1, last1);
+  const auto d2    = Kokkos::Experimental::distance(first2, last2);
+  const auto range = Kokkos::min(d1, d2);
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+  using func1_t =
+      StdLexicographicalCompareFunctor<index_type, IteratorType1, IteratorType2,
+                                       reducer_type, ComparatorType>;
+
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, range),
+                            func1_t(first1, first2, reducer, comp), reducer);
+
+  teamHandle.team_barrier();
+
+  // no mismatch
+  if (red_result.min_loc_true ==
+      ::Kokkos::reduction_identity<index_type>::min()) {
+    auto new_last1 = first1 + range;
+    auto new_last2 = first2 + range;
+    bool is_prefix = (new_last1 == last1) && (new_last2 != last2);
+    return is_prefix;
+  }
+
+  // check mismatched
+  int less      = 0;
+  auto it1      = first1 + red_result.min_loc_true;
+  auto it2      = first2 + red_result.min_loc_true;
+  using func2_t = StdCompareFunctor<index_type, IteratorType1, IteratorType2,
+                                    ComparatorType>;
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, 1),
+                            func2_t(it1, it2, comp), less);
+
+  teamHandle.team_barrier();
+
+  return static_cast<bool>(less);
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION bool lexicographical_compare_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2) {
   using value_type_1 = typename IteratorType1::value_type;
   using value_type_2 = typename IteratorType2::value_type;
   using predicate_t =
       Impl::StdAlgoLessThanBinaryPredicate<value_type_1, value_type_2>;
-  return lexicographical_compare_impl(label, ex, first1, last1, first2, last2,
-                                      predicate_t());
+  return lexicographical_compare_team_impl(teamHandle, first1, last1, first2,
+                                           last2, predicate_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_MinMaxMinmaxElement.hpp b/algorithms/src/std_algorithms/impl/Kokkos_MinMaxMinmaxElement.hpp
index 048420f7a8..2f51db03b4 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_MinMaxMinmaxElement.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_MinMaxMinmaxElement.hpp
@@ -63,12 +63,16 @@ struct StdMinMaxElemFunctor {
       : m_first(std::move(first)), m_reducer(std::move(reducer)) {}
 };
 
+//
+// exespace impl
+//
 template <template <class... Args> class ReducerType, class ExecutionSpace,
           class IteratorType, class... Args>
-IteratorType min_or_max_element_impl(const std::string& label,
-                                     const ExecutionSpace& ex,
-                                     IteratorType first, IteratorType last,
-                                     Args&&... args) {
+IteratorType min_or_max_element_exespace_impl(const std::string& label,
+                                              const ExecutionSpace& ex,
+                                              IteratorType first,
+                                              IteratorType last,
+                                              Args&&... args) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -100,7 +104,7 @@ IteratorType min_or_max_element_impl(const std::string& label,
 
 template <template <class... Args> class ReducerType, class ExecutionSpace,
           class IteratorType, class... Args>
-::Kokkos::pair<IteratorType, IteratorType> minmax_element_impl(
+::Kokkos::pair<IteratorType, IteratorType> minmax_element_exespace_impl(
     const std::string& label, const ExecutionSpace& ex, IteratorType first,
     IteratorType last, Args&&... args) {
   // checks
@@ -132,6 +136,75 @@ ::Kokkos::pair<IteratorType, IteratorType> minmax_element_impl(
   return {first + red_result.min_loc, first + red_result.max_loc};
 }
 
+//
+// team level impl
+//
+template <template <class... Args> class ReducerType, class TeamHandleType,
+          class IteratorType, class... Args>
+KOKKOS_FUNCTION IteratorType min_or_max_element_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    Args&&... args) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    return last;
+  }
+
+  // aliases
+  using index_type           = typename IteratorType::difference_type;
+  using value_type           = typename IteratorType::value_type;
+  using reducer_type         = ReducerType<value_type, index_type, Args...>;
+  using reduction_value_type = typename reducer_type::value_type;
+  using func_t = StdMinOrMaxElemFunctor<IteratorType, reducer_type>;
+
+  // run
+  reduction_value_type red_result;
+  reducer_type reducer(red_result, std::forward<Args>(args)...);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            func_t(first, reducer), reducer);
+  teamHandle.team_barrier();
+  // maybe the barrier is not needed since reducing into scalar?
+
+  // return
+  return first + red_result.loc;
+}
+
+template <template <class... Args> class ReducerType, class TeamHandleType,
+          class IteratorType, class... Args>
+KOKKOS_FUNCTION ::Kokkos::pair<IteratorType, IteratorType>
+minmax_element_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                         IteratorType last, Args&&... args) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    return {first, first};
+  }
+
+  // aliases
+  using index_type           = typename IteratorType::difference_type;
+  using value_type           = typename IteratorType::value_type;
+  using reducer_type         = ReducerType<value_type, index_type, Args...>;
+  using reduction_value_type = typename reducer_type::value_type;
+  using func_t               = StdMinMaxElemFunctor<IteratorType, reducer_type>;
+
+  // run
+  reduction_value_type red_result;
+  reducer_type reducer(red_result, std::forward<Args>(args)...);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            func_t(first, reducer), reducer);
+  teamHandle.team_barrier();
+  // maybe the barrier is not needed since reducing into scalar?
+
+  // return
+  return {first + red_result.min_loc, first + red_result.max_loc};
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
index b742684467..dfe96aaf58 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Mismatch.hpp
@@ -27,9 +27,10 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class IteratorType1, class IteratorType2,
-          class ReducerType, class BinaryPredicateType>
+template <class IteratorType1, class IteratorType2, class ReducerType,
+          class BinaryPredicateType>
 struct StdMismatchRedFunctor {
+  using index_type     = typename IteratorType1::difference_type;
   using red_value_type = typename ReducerType::value_type;
 
   IteratorType1 m_first1;
@@ -38,14 +39,14 @@ struct StdMismatchRedFunctor {
   BinaryPredicateType m_predicate;
 
   KOKKOS_FUNCTION
-  void operator()(const IndexType i, red_value_type& red_value) const {
+  void operator()(const index_type i, red_value_type& red_value) const {
     const auto& my_value1 = m_first1[i];
     const auto& my_value2 = m_first2[i];
 
     // 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()};
+      rv = {::Kokkos::reduction_identity<index_type>::min()};
     }
 
     m_reducer.join(red_value, rv);
@@ -60,9 +61,12 @@ struct StdMismatchRedFunctor {
         m_predicate(std::move(predicate)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class BinaryPredicateType>
-::Kokkos::pair<IteratorType1, IteratorType2> mismatch_impl(
+::Kokkos::pair<IteratorType1, IteratorType2> mismatch_exespace_impl(
     const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
     IteratorType1 last1, IteratorType2 first2, IteratorType2 last2,
     BinaryPredicateType predicate) {
@@ -77,9 +81,6 @@ ::Kokkos::pair<IteratorType1, IteratorType2> mismatch_impl(
   using index_type           = typename IteratorType1::difference_type;
   using reducer_type         = FirstLoc<index_type>;
   using reduction_value_type = typename reducer_type::value_type;
-  using functor_type =
-      StdMismatchRedFunctor<index_type, IteratorType1, IteratorType2,
-                            reducer_type, BinaryPredicateType>;
 
   // trivial case: note that this is important,
   // for OpenMPTarget, omitting special handling of
@@ -96,7 +97,9 @@ ::Kokkos::pair<IteratorType1, IteratorType2> mismatch_impl(
   reducer_type reducer(red_result);
   ::Kokkos::parallel_reduce(
       label, RangePolicy<ExecutionSpace>(ex, 0, num_elemen_par_reduce),
-      functor_type(first1, first2, reducer, std::move(predicate)), reducer);
+      // use CTAD
+      StdMismatchRedFunctor(first1, first2, reducer, std::move(predicate)),
+      reducer);
 
   // fence not needed because reducing into scalar
 
@@ -119,13 +122,83 @@ ::Kokkos::pair<IteratorType1, IteratorType2> mismatch_impl(
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-::Kokkos::pair<IteratorType1, IteratorType2> mismatch_impl(
+::Kokkos::pair<IteratorType1, IteratorType2> mismatch_exespace_impl(
     const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
     IteratorType1 last1, IteratorType2 first2, IteratorType2 last2) {
   using value_type1 = typename IteratorType1::value_type;
   using value_type2 = typename IteratorType2::value_type;
   using pred_t      = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
-  return mismatch_impl(label, ex, first1, last1, first2, last2, pred_t());
+  return mismatch_exespace_impl(label, ex, first1, last1, first2, last2,
+                                pred_t());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType>
+KOKKOS_FUNCTION ::Kokkos::pair<IteratorType1, IteratorType2> mismatch_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2, BinaryPredicateType predicate) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
+  Impl::expect_valid_range(first1, last1);
+  Impl::expect_valid_range(first2, last2);
+
+  // aliases
+  using return_type          = ::Kokkos::pair<IteratorType1, IteratorType2>;
+  using index_type           = typename IteratorType1::difference_type;
+  using reducer_type         = FirstLoc<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  // trivial case: note that this is important,
+  // for OpenMPTarget, omitting special handling of
+  // the trivial case was giving all sorts of strange stuff.
+  const auto num_e1 = last1 - first1;
+  const auto num_e2 = last2 - first2;
+  if (num_e1 == 0 || num_e2 == 0) {
+    return return_type(first1, first2);
+  }
+
+  // run
+  const auto num_elemen_par_reduce = (num_e1 <= num_e2) ? num_e1 : num_e2;
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+  ::Kokkos::parallel_reduce(
+      TeamThreadRange(teamHandle, 0, num_elemen_par_reduce),
+      // use CTAD
+      StdMismatchRedFunctor(first1, first2, reducer, std::move(predicate)),
+      reducer);
+
+  teamHandle.team_barrier();
+
+  // decide and return
+  constexpr auto red_min = ::Kokkos::reduction_identity<index_type>::min();
+  if (red_result.min_loc_true == red_min) {
+    // in here means mismatch has not been found
+    if (num_e1 == num_e2) {
+      return return_type(last1, last2);
+    } else if (num_e1 < num_e2) {
+      return return_type(last1, first2 + num_e1);
+    } else {
+      return return_type(first1 + num_e2, last2);
+    }
+  } else {
+    // in here means mismatch has been found
+    return return_type(first1 + red_result.min_loc_true,
+                       first2 + red_result.min_loc_true);
+  }
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION ::Kokkos::pair<IteratorType1, IteratorType2> mismatch_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, IteratorType2 last2) {
+  using value_type1 = typename IteratorType1::value_type;
+  using value_type2 = typename IteratorType2::value_type;
+  using pred_t      = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+  return mismatch_team_impl(teamHandle, first1, last1, first2, last2, pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Move.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Move.hpp
index 01086d1772..5110c51d41 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Move.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Move.hpp
@@ -37,14 +37,15 @@ struct StdMoveFunctor {
     m_dest_first[i] = std::move(m_first[i]);
   }
 
-  StdMoveFunctor(InputIterator _first, OutputIterator _dest_first)
+  KOKKOS_FUNCTION StdMoveFunctor(InputIterator _first,
+                                 OutputIterator _dest_first)
       : m_first(std::move(_first)), m_dest_first(std::move(_dest_first)) {}
 };
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator>
-OutputIterator move_impl(const std::string& label, const ExecutionSpace& ex,
-                         InputIterator first, InputIterator last,
-                         OutputIterator d_first) {
+OutputIterator move_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, InputIterator first,
+                                  InputIterator last, OutputIterator d_first) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
@@ -65,6 +66,30 @@ OutputIterator move_impl(const std::string& label, const ExecutionSpace& ex,
   return d_first + num_elements;
 }
 
+template <class TeamHandleType, class InputIterator, class OutputIterator>
+KOKKOS_FUNCTION OutputIterator move_team_impl(const TeamHandleType& teamHandle,
+                                              InputIterator first,
+                                              InputIterator last,
+                                              OutputIterator d_first) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+
+  // aliases
+  using index_type = typename InputIterator::difference_type;
+  using func_t     = StdMoveFunctor<index_type, InputIterator, OutputIterator>;
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         func_t(first, d_first));
+  teamHandle.team_barrier();
+
+  // return
+  return d_first + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_MoveBackward.hpp b/algorithms/src/std_algorithms/impl/Kokkos_MoveBackward.hpp
index 9a28c3fb4a..9075562d46 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_MoveBackward.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_MoveBackward.hpp
@@ -27,48 +27,66 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class IteratorType1, class IteratorType2>
+template <class IteratorType1, class IteratorType2>
 struct StdMoveBackwardFunctor {
-  static_assert(std::is_signed<IndexType>::value,
+  using index_type = typename IteratorType1::difference_type;
+  static_assert(std::is_signed<index_type>::value,
                 "Kokkos: StdMoveBackwardFunctor requires signed index type");
 
   IteratorType1 m_last;
   IteratorType2 m_dest_last;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const {
+  void operator()(index_type i) const {
     m_dest_last[-i - 1] = std::move(m_last[-i - 1]);
   }
 
+  KOKKOS_FUNCTION
   StdMoveBackwardFunctor(IteratorType1 _last, IteratorType2 _dest_last)
       : m_last(std::move(_last)), m_dest_last(std::move(_dest_last)) {}
 };
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-IteratorType2 move_backward_impl(const std::string& label,
-                                 const ExecutionSpace& ex, IteratorType1 first,
-                                 IteratorType1 last, IteratorType2 d_last) {
+IteratorType2 move_backward_exespace_impl(const std::string& label,
+                                          const ExecutionSpace& ex,
+                                          IteratorType1 first,
+                                          IteratorType1 last,
+                                          IteratorType2 d_last) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_last);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_last);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using index_type = typename IteratorType1::difference_type;
-  using func_t =
-      StdMoveBackwardFunctor<index_type, IteratorType1, IteratorType2>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(last, d_last));
+                         StdMoveBackwardFunctor(last, d_last));
   ex.fence("Kokkos::move_backward: fence after operation");
 
   // return
   return d_last - num_elements;
 }
 
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION IteratorType2
+move_backward_team_impl(const TeamHandleType& teamHandle, IteratorType1 first,
+                        IteratorType1 last, IteratorType2 d_last) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_last);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_last);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdMoveBackwardFunctor(last, d_last));
+  teamHandle.team_barrier();
+
+  // return
+  return d_last - num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_MustUseKokkosSingleInTeam.hpp b/algorithms/src/std_algorithms/impl/Kokkos_MustUseKokkosSingleInTeam.hpp
new file mode 100644
index 0000000000..162c72c2db
--- /dev/null
+++ b/algorithms/src/std_algorithms/impl/Kokkos_MustUseKokkosSingleInTeam.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_STD_ALGORITHMS_MUSTUSEKOKKOSSINGLEINTEAM_HPP
+#define KOKKOS_STD_ALGORITHMS_MUSTUSEKOKKOSSINGLEINTEAM_HPP
+
+#include <Kokkos_Core.hpp>
+
+namespace Kokkos {
+namespace Experimental {
+namespace Impl {
+
+template <typename T>
+struct stdalgo_must_use_kokkos_single_for_team_scan : std::false_type {};
+
+// the following do not support the overload for team-level scan
+// accepting an "out" value to store the scan result
+
+// FIXME_OPENACC
+#if defined(KOKKOS_ENABLE_OPENACC)
+template <>
+struct stdalgo_must_use_kokkos_single_for_team_scan<
+    Kokkos::Experimental::OpenACC> : std::true_type {};
+#endif
+
+template <typename T>
+inline constexpr bool stdalgo_must_use_kokkos_single_for_team_scan_v =
+    stdalgo_must_use_kokkos_single_for_team_scan<T>::value;
+
+}  // namespace Impl
+}  // namespace Experimental
+}  // namespace Kokkos
+
+#endif
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp b/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp
index 54f7c5b612..35e9cfa53e 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_PartitionCopy.hpp
@@ -33,10 +33,11 @@ struct StdPartitionCopyScalar {
   ValueType false_count_;
 };
 
-template <class IndexType, class FirstFrom, class FirstDestTrue,
-          class FirstDestFalse, class PredType>
+template <class FirstFrom, class FirstDestTrue, class FirstDestFalse,
+          class PredType>
 struct StdPartitionCopyFunctor {
-  using value_type = StdPartitionCopyScalar<IndexType>;
+  using index_type = typename FirstFrom::difference_type;
+  using value_type = StdPartitionCopyScalar<index_type>;
 
   FirstFrom m_first_from;
   FirstDestTrue m_first_dest_true;
@@ -52,7 +53,7 @@ struct StdPartitionCopyFunctor {
         m_pred(std::move(pred)) {}
 
   KOKKOS_FUNCTION
-  void operator()(const IndexType i, value_type& update,
+  void operator()(const index_type i, value_type& update,
                   const bool final_pass) const {
     const auto& myval = m_first_from[i];
     if (final_pass) {
@@ -87,11 +88,12 @@ template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorTrueType, class OutputIteratorFalseType,
           class PredicateType>
 ::Kokkos::pair<OutputIteratorTrueType, OutputIteratorFalseType>
-partition_copy_impl(const std::string& label, const ExecutionSpace& ex,
-                    InputIteratorType from_first, InputIteratorType from_last,
-                    OutputIteratorTrueType to_first_true,
-                    OutputIteratorFalseType to_first_false,
-                    PredicateType pred) {
+partition_copy_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                             InputIteratorType from_first,
+                             InputIteratorType from_last,
+                             OutputIteratorTrueType to_first_true,
+                             OutputIteratorFalseType to_first_false,
+                             PredicateType pred) {
   // impl uses a scan, this is similar how we implemented copy_if
 
   // checks
@@ -105,12 +107,9 @@ partition_copy_impl(const std::string& label, const ExecutionSpace& ex,
     return {to_first_true, to_first_false};
   }
 
-  // aliases
-  using index_type = typename InputIteratorType::difference_type;
   using func_type =
-      StdPartitionCopyFunctor<index_type, InputIteratorType,
-                              OutputIteratorTrueType, OutputIteratorFalseType,
-                              PredicateType>;
+      StdPartitionCopyFunctor<InputIteratorType, OutputIteratorTrueType,
+                              OutputIteratorFalseType, PredicateType>;
 
   // run
   const auto num_elements =
@@ -126,6 +125,55 @@ partition_copy_impl(const std::string& label, const ExecutionSpace& ex,
           to_first_false + counts.false_count_};
 }
 
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorTrueType, class OutputIteratorFalseType,
+          class PredicateType>
+KOKKOS_FUNCTION ::Kokkos::pair<OutputIteratorTrueType, OutputIteratorFalseType>
+partition_copy_team_impl(const TeamHandleType& teamHandle,
+                         InputIteratorType from_first,
+                         InputIteratorType from_last,
+                         OutputIteratorTrueType to_first_true,
+                         OutputIteratorFalseType to_first_false,
+                         PredicateType pred) {
+  // impl uses a scan, this is similar how we implemented copy_if
+
+  // checks
+  Impl::static_assert_random_access_and_accessible(
+      teamHandle, from_first, to_first_true, to_first_false);
+  Impl::static_assert_iterators_have_matching_difference_type(
+      from_first, to_first_true, to_first_false);
+  Impl::expect_valid_range(from_first, from_last);
+
+  if (from_first == from_last) {
+    return {to_first_true, to_first_false};
+  }
+
+  const std::size_t num_elements =
+      Kokkos::Experimental::distance(from_first, from_last);
+
+  // FIXME: there is no parallel_scan overload that accepts TeamThreadRange and
+  // return_value, so temporarily serial implementation is used
+  using counts_t  = ::Kokkos::pair<std::size_t, std::size_t>;
+  counts_t counts = {};
+  Kokkos::single(
+      Kokkos::PerTeam(teamHandle),
+      [=](counts_t& lcounts) {
+        lcounts = {};
+        for (std::size_t i = 0; i < num_elements; ++i) {
+          const auto& myval = from_first[i];
+          if (pred(myval)) {
+            to_first_true[lcounts.first++] = myval;
+          } else {
+            to_first_false[lcounts.second++] = myval;
+          }
+        }
+      },
+      counts);
+  // no barrier needed since single above broadcasts to all members
+
+  return {to_first_true + counts.first, to_first_false + counts.second};
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp b/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
index c9517f6977..7ec7061e31 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_PartitionPoint.hpp
@@ -58,9 +58,11 @@ struct StdPartitionPointFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType, class PredicateType>
-IteratorType partition_point_impl(const std::string& label,
-                                  const ExecutionSpace& ex, IteratorType first,
-                                  IteratorType last, PredicateType pred) {
+IteratorType partition_point_exespace_impl(const std::string& label,
+                                           const ExecutionSpace& ex,
+                                           IteratorType first,
+                                           IteratorType last,
+                                           PredicateType pred) {
   // locates the end of the first partition, that is, the first
   // element that does not satisfy p or last if all elements satisfy p.
   // Implementation below finds the first location where p is false.
@@ -100,6 +102,43 @@ IteratorType partition_point_impl(const std::string& label,
   }
 }
 
+template <class TeamHandleType, class IteratorType, class PredicateType>
+KOKKOS_FUNCTION IteratorType
+partition_point_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                          IteratorType last, PredicateType pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    return first;
+  }
+
+  // aliases
+  using index_type           = typename IteratorType::difference_type;
+  using reducer_type         = StdPartitionPoint<index_type>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  // run
+  reduction_value_type red_result;
+  reducer_type reducer(red_result);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            StdPartitionPointFunctor(first, reducer, pred),
+                            reducer);
+
+  // fence not needed because reducing into scalar
+
+  // decide and return
+  if (red_result.min_loc_false ==
+      ::Kokkos::reduction_identity<index_type>::min()) {
+    // if all elements are true, return last
+    return last;
+  } else {
+    return first + red_result.min_loc_false;
+  }
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_RandomAccessIterator.hpp b/algorithms/src/std_algorithms/impl/Kokkos_RandomAccessIterator.hpp
index 5c9854b87d..5bce89e98f 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_RandomAccessIterator.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_RandomAccessIterator.hpp
@@ -59,6 +59,30 @@ class RandomAccessIterator< ::Kokkos::View<DataType, Args...> > {
                                                 ptrdiff_t current_index)
       : m_view(view), m_current_index(current_index) {}
 
+#ifndef KOKKOS_ENABLE_CXX17  // C++20 and beyond
+  template <class OtherViewType>
+  requires(std::is_constructible_v<view_type, OtherViewType>) KOKKOS_FUNCTION
+      explicit(!std::is_convertible_v<OtherViewType, view_type>)
+          RandomAccessIterator(const RandomAccessIterator<OtherViewType>& other)
+      : m_view(other.m_view), m_current_index(other.m_current_index) {}
+#else
+  template <
+      class OtherViewType,
+      std::enable_if_t<std::is_constructible_v<view_type, OtherViewType> &&
+                           !std::is_convertible_v<OtherViewType, view_type>,
+                       int> = 0>
+  KOKKOS_FUNCTION explicit RandomAccessIterator(
+      const RandomAccessIterator<OtherViewType>& other)
+      : m_view(other.m_view), m_current_index(other.m_current_index) {}
+
+  template <class OtherViewType,
+            std::enable_if_t<std::is_convertible_v<OtherViewType, view_type>,
+                             int> = 0>
+  KOKKOS_FUNCTION RandomAccessIterator(
+      const RandomAccessIterator<OtherViewType>& other)
+      : m_view(other.m_view), m_current_index(other.m_current_index) {}
+#endif
+
   KOKKOS_FUNCTION
   iterator_type& operator++() {
     ++m_current_index;
@@ -152,9 +176,16 @@ class RandomAccessIterator< ::Kokkos::View<DataType, Args...> > {
   KOKKOS_FUNCTION
   reference operator*() const { return m_view(m_current_index); }
 
+  KOKKOS_FUNCTION
+  view_type view() const { return m_view; }
+
  private:
   view_type m_view;
   ptrdiff_t m_current_index = 0;
+
+  // Needed for the converting constructor accepting another iterator
+  template <class>
+  friend class RandomAccessIterator;
 };
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Reduce.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Reduce.hpp
index 45a0de3727..ab01cdd804 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Reduce.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Reduce.hpp
@@ -72,16 +72,22 @@ struct StdReduceFunctor {
       : m_first(std::move(first)), m_reducer(std::move(reducer)) {}
 };
 
-//------------------------------
-// reduce_custom_functors_impl
-//------------------------------
+template <typename ValueType>
+using has_reduction_identity_sum_t =
+    decltype(Kokkos::reduction_identity<ValueType>::sum());
+
+//
+// exespace impl
+//
+
+//-------------------------------------
+// reduce_custom_functors_exespace_impl
+//-------------------------------------
 template <class ExecutionSpace, class IteratorType, class ValueType,
           class JoinerType>
-ValueType reduce_custom_functors_impl(const std::string& label,
-                                      const ExecutionSpace& ex,
-                                      IteratorType first, IteratorType last,
-                                      ValueType init_reduction_value,
-                                      JoinerType joiner) {
+ValueType reduce_custom_functors_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType first,
+    IteratorType last, ValueType init_reduction_value, JoinerType joiner) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::static_assert_is_not_openmptarget(ex);
@@ -95,7 +101,6 @@ ValueType reduce_custom_functors_impl(const std::string& label,
   // aliases
   using reducer_type =
       ReducerWithArbitraryJoinerNoNeutralElement<ValueType, JoinerType>;
-  using functor_type         = StdReduceFunctor<IteratorType, reducer_type>;
   using reduction_value_type = typename reducer_type::value_type;
 
   // run
@@ -104,21 +109,16 @@ ValueType reduce_custom_functors_impl(const std::string& label,
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_reduce(label,
                             RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                            functor_type(first, reducer), reducer);
+                            StdReduceFunctor(first, reducer), reducer);
 
   // fence not needed since reducing into scalar
   return joiner(result.val, init_reduction_value);
 }
 
-template <typename ValueType>
-using has_reduction_identity_sum_t =
-    decltype(Kokkos::reduction_identity<ValueType>::sum());
-
 template <class ExecutionSpace, class IteratorType, class ValueType>
-ValueType reduce_default_functors_impl(const std::string& label,
-                                       const ExecutionSpace& ex,
-                                       IteratorType first, IteratorType last,
-                                       ValueType init_reduction_value) {
+ValueType reduce_default_functors_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType first,
+    IteratorType last, ValueType init_reduction_value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::static_assert_is_not_openmptarget(ex);
@@ -146,11 +146,88 @@ ValueType reduce_default_functors_impl(const std::string& label,
     return tmp;
   } else {
     using joiner_type = Impl::StdReduceDefaultJoinFunctor<value_type>;
-    return reduce_custom_functors_impl(
+    return reduce_custom_functors_exespace_impl(
         label, ex, first, last, std::move(init_reduction_value), joiner_type());
   }
 }
 
+//
+// team impl
+//
+
+//---------------------------------
+// reduce_custom_functors_team_impl
+//---------------------------------
+template <class TeamHandleType, class IteratorType, class ValueType,
+          class JoinerType>
+KOKKOS_FUNCTION ValueType reduce_custom_functors_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    ValueType init_reduction_value, JoinerType joiner) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    // init is returned, unmodified
+    return init_reduction_value;
+  }
+
+  // aliases
+  using reducer_type =
+      ReducerWithArbitraryJoinerNoNeutralElement<ValueType, JoinerType>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  // run
+  reduction_value_type result;
+  reducer_type reducer(result, joiner);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            StdReduceFunctor(first, reducer), reducer);
+
+  teamHandle.team_barrier();
+
+  return joiner(result.val, init_reduction_value);
+}
+
+template <class TeamHandleType, class IteratorType, class ValueType>
+KOKKOS_FUNCTION ValueType reduce_default_functors_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    ValueType init_reduction_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::expect_valid_range(first, last);
+
+  using value_type = Kokkos::Impl::remove_cvref_t<ValueType>;
+
+  if (::Kokkos::is_detected<has_reduction_identity_sum_t, value_type>::value) {
+    if (first == last) {
+      // init is returned, unmodified
+      return init_reduction_value;
+    }
+
+    using functor_type =
+        Impl::StdReduceDefaultFunctor<IteratorType, value_type>;
+
+    // run
+    value_type tmp;
+    const auto num_elements = Kokkos::Experimental::distance(first, last);
+    ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                              functor_type{first}, tmp);
+
+    teamHandle.team_barrier();
+
+    tmp += init_reduction_value;
+    return tmp;
+  } else {
+    using joiner_type = Impl::StdReduceDefaultJoinFunctor<value_type>;
+    return reduce_custom_functors_team_impl(teamHandle, first, last,
+                                            std::move(init_reduction_value),
+                                            joiner_type());
+  }
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_RemoveAllVariants.hpp b/algorithms/src/std_algorithms/impl/Kokkos_RemoveAllVariants.hpp
index bda6470199..456df43aed 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_RemoveAllVariants.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_RemoveAllVariants.hpp
@@ -46,15 +46,14 @@ struct StdRemoveIfStage1Functor {
   void operator()(const IndexType i, IndexType& update,
                   const bool final_pass) const {
     auto& myval = m_first_from[i];
-    if (final_pass) {
-      if (!m_must_remove(myval)) {
+
+    if (!m_must_remove(myval)) {
+      if (final_pass) {
         // calling move here is ok because we are inside final pass
         // we are calling move assign as specified by the std
         m_first_dest[update] = std::move(myval);
       }
-    }
 
-    if (!m_must_remove(myval)) {
       update += 1;
     }
   }
@@ -76,10 +75,14 @@ struct StdRemoveIfStage2Functor {
   }
 };
 
+//
+// remove if
+//
 template <class ExecutionSpace, class IteratorType, class UnaryPredicateType>
-IteratorType remove_if_impl(const std::string& label, const ExecutionSpace& ex,
-                            IteratorType first, IteratorType last,
-                            UnaryPredicateType pred) {
+IteratorType remove_if_exespace_impl(const std::string& label,
+                                     const ExecutionSpace& ex,
+                                     IteratorType first, IteratorType last,
+                                     UnaryPredicateType pred) {
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
 
@@ -104,7 +107,9 @@ IteratorType remove_if_impl(const std::string& label, const ExecutionSpace& ex,
     // create helper tmp view
     using value_type    = typename IteratorType::value_type;
     using tmp_view_type = Kokkos::View<value_type*, ExecutionSpace>;
-    tmp_view_type tmp_view("std_remove_if_tmp_view", keep_count);
+    tmp_view_type tmp_view(Kokkos::view_alloc(Kokkos::WithoutInitializing, ex,
+                                              "std_remove_if_tmp_view"),
+                           keep_count);
     using tmp_readwrite_iterator_type = decltype(begin(tmp_view));
 
     // in stage 1, *move* all elements to keep from original range to tmp
@@ -139,19 +144,71 @@ IteratorType remove_if_impl(const std::string& label, const ExecutionSpace& ex,
   }
 }
 
+template <class TeamHandleType, class IteratorType, class UnaryPredicateType>
+KOKKOS_FUNCTION IteratorType
+remove_if_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                    IteratorType last, UnaryPredicateType pred) {
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    return last;
+  } else {
+    const auto remove_count =
+        ::Kokkos::Experimental::count_if(teamHandle, first, last, pred);
+    const std::size_t num_elements =
+        ::Kokkos::Experimental::distance(first, last);
+
+    if (remove_count > 0) {
+      std::size_t count = 0;
+      Kokkos::single(
+          Kokkos::PerTeam(teamHandle),
+          [=](std::size_t& lcount) {
+            lcount = 0;
+            for (std::size_t i = 0; i < num_elements; ++i) {
+              if (!pred(first[i])) {
+                first[lcount++] = std::move(first[i]);
+              }
+            }
+          },
+          count);
+    }
+    // no barrier needed since single above broadcasts to all members
+
+    return first + num_elements - remove_count;
+  }
+}
+
+//
+// remove
+//
 template <class ExecutionSpace, class IteratorType, class ValueType>
-auto remove_impl(const std::string& label, const ExecutionSpace& ex,
-                 IteratorType first, IteratorType last,
-                 const ValueType& value) {
+auto remove_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                          IteratorType first, IteratorType last,
+                          const ValueType& value) {
+  using predicate_type = StdAlgoEqualsValUnaryPredicate<ValueType>;
+  return remove_if_exespace_impl(label, ex, first, last, predicate_type(value));
+}
+
+template <class TeamHandleType, class IteratorType, class ValueType>
+KOKKOS_FUNCTION auto remove_team_impl(const TeamHandleType& teamHandle,
+                                      IteratorType first, IteratorType last,
+                                      const ValueType& value) {
   using predicate_type = StdAlgoEqualsValUnaryPredicate<ValueType>;
-  return remove_if_impl(label, ex, first, last, predicate_type(value));
+  return remove_if_team_impl(teamHandle, first, last, predicate_type(value));
 }
 
+//
+// remove_copy
+//
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class ValueType>
-auto remove_copy_impl(const std::string& label, const ExecutionSpace& ex,
-                      InputIteratorType first_from, InputIteratorType last_from,
-                      OutputIteratorType first_dest, const ValueType& value) {
+auto remove_copy_exespace_impl(const std::string& label,
+                               const ExecutionSpace& ex,
+                               InputIteratorType first_from,
+                               InputIteratorType last_from,
+                               OutputIteratorType first_dest,
+                               const ValueType& value) {
   // this is like copy_if except that we need to *ignore* the elements
   // that match the value, so we can solve this as follows:
 
@@ -160,13 +217,32 @@ auto remove_copy_impl(const std::string& label, const ExecutionSpace& ex,
                                          first_dest, predicate_type(value));
 }
 
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class ValueType>
+KOKKOS_FUNCTION auto remove_copy_team_impl(const TeamHandleType& teamHandle,
+                                           InputIteratorType first_from,
+                                           InputIteratorType last_from,
+                                           OutputIteratorType first_dest,
+                                           const ValueType& value) {
+  // this is like copy_if except that we need to *ignore* the elements
+  // that match the value, so we can solve this as follows:
+
+  using predicate_type = StdAlgoNotEqualsValUnaryPredicate<ValueType>;
+  return ::Kokkos::Experimental::copy_if(teamHandle, first_from, last_from,
+                                         first_dest, predicate_type(value));
+}
+
+//
+// remove_copy_if
+//
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class UnaryPredicate>
-auto remove_copy_if_impl(const std::string& label, const ExecutionSpace& ex,
-                         InputIteratorType first_from,
-                         InputIteratorType last_from,
-                         OutputIteratorType first_dest,
-                         const UnaryPredicate& pred) {
+auto remove_copy_if_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex,
+                                  InputIteratorType first_from,
+                                  InputIteratorType last_from,
+                                  OutputIteratorType first_dest,
+                                  const UnaryPredicate& pred) {
   // this is like copy_if except that we need to *ignore* the elements
   // satisfying the pred, so we can solve this as follows:
 
@@ -177,6 +253,20 @@ auto remove_copy_if_impl(const std::string& label, const ExecutionSpace& ex,
                                          first_dest, pred_wrapper_type(pred));
 }
 
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class UnaryPredicate>
+KOKKOS_FUNCTION auto remove_copy_if_team_impl(const TeamHandleType& teamHandle,
+                                              InputIteratorType first_from,
+                                              InputIteratorType last_from,
+                                              OutputIteratorType first_dest,
+                                              const UnaryPredicate& pred) {
+  using value_type = typename InputIteratorType::value_type;
+  using pred_wrapper_type =
+      StdAlgoNegateUnaryPredicateWrapper<value_type, UnaryPredicate>;
+  return ::Kokkos::Experimental::copy_if(teamHandle, first_from, last_from,
+                                         first_dest, pred_wrapper_type(pred));
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Replace.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Replace.hpp
index e3a6b538f4..5b5e4147d6 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Replace.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Replace.hpp
@@ -50,24 +50,38 @@ struct StdReplaceFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType, class ValueType>
-void replace_impl(const std::string& label, const ExecutionSpace& ex,
-                  IteratorType first, IteratorType last,
-                  const ValueType& old_value, const ValueType& new_value) {
+void replace_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                           IteratorType first, IteratorType last,
+                           const ValueType& old_value,
+                           const ValueType& new_value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using func_t = StdReplaceFunctor<IteratorType, ValueType>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first, old_value, new_value));
+                         StdReplaceFunctor(first, old_value, new_value));
   ex.fence("Kokkos::replace: fence after operation");
 }
 
+template <class TeamHandleType, class IteratorType, class ValueType>
+KOKKOS_FUNCTION void replace_team_impl(const TeamHandleType& teamHandle,
+                                       IteratorType first, IteratorType last,
+                                       const ValueType& old_value,
+                                       const ValueType& new_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdReplaceFunctor(first, old_value, new_value));
+  teamHandle.team_barrier();
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopy.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopy.hpp
index 729cf89311..61ffa9fd93 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopy.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopy.hpp
@@ -58,35 +58,56 @@ struct StdReplaceCopyFunctor {
 
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class ValueType>
-OutputIteratorType replace_copy_impl(const std::string& label,
-                                     const ExecutionSpace& ex,
-                                     InputIteratorType first_from,
-                                     InputIteratorType last_from,
-                                     OutputIteratorType first_dest,
-                                     const ValueType& old_value,
-                                     const ValueType& new_value) {
+OutputIteratorType replace_copy_exespace_impl(const std::string& label,
+                                              const ExecutionSpace& ex,
+                                              InputIteratorType first_from,
+                                              InputIteratorType last_from,
+                                              OutputIteratorType first_dest,
+                                              const ValueType& old_value,
+                                              const ValueType& new_value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
   Impl::static_assert_iterators_have_matching_difference_type(first_from,
                                                               first_dest);
   Impl::expect_valid_range(first_from, last_from);
 
-  // aliases
-  using func_t =
-      StdReplaceCopyFunctor<InputIteratorType, OutputIteratorType, ValueType>;
-
   // run
   const auto num_elements =
       Kokkos::Experimental::distance(first_from, last_from);
-  ::Kokkos::parallel_for(label,
-                         RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first_from, first_dest, old_value, new_value));
+  ::Kokkos::parallel_for(
+      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      StdReplaceCopyFunctor(first_from, first_dest, old_value, new_value));
   ex.fence("Kokkos::replace_copy: fence after operation");
 
   // return
   return first_dest + num_elements;
 }
 
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class ValueType>
+KOKKOS_FUNCTION OutputIteratorType replace_copy_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    const ValueType& old_value, const ValueType& new_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_for(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      StdReplaceCopyFunctor(first_from, first_dest, old_value, new_value));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopyIf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopyIf.hpp
index dca7e7f6a5..2cc38d1d0e 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopyIf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ReplaceCopyIf.hpp
@@ -27,16 +27,18 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIterator, class OutputIterator,
-          class PredicateType, class ValueType>
+template <class InputIterator, class OutputIterator, class PredicateType,
+          class ValueType>
 struct StdReplaceIfCopyFunctor {
+  using index_type = typename InputIterator::difference_type;
+
   InputIterator m_first_from;
   OutputIterator m_first_dest;
   PredicateType m_pred;
   ValueType m_new_value;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const {
+  void operator()(index_type i) const {
     const auto& myvalue_from = m_first_from[i];
 
     if (m_pred(myvalue_from)) {
@@ -57,37 +59,62 @@ struct StdReplaceIfCopyFunctor {
 
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class PredicateType, class ValueType>
-OutputIteratorType replace_copy_if_impl(const std::string& label,
-                                        const ExecutionSpace& ex,
-                                        InputIteratorType first_from,
-                                        InputIteratorType last_from,
-                                        OutputIteratorType first_dest,
-                                        PredicateType pred,
-                                        const ValueType& new_value) {
+OutputIteratorType replace_copy_if_exespace_impl(const std::string& label,
+                                                 const ExecutionSpace& ex,
+                                                 InputIteratorType first_from,
+                                                 InputIteratorType last_from,
+                                                 OutputIteratorType first_dest,
+                                                 PredicateType pred,
+                                                 const ValueType& new_value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
   Impl::static_assert_iterators_have_matching_difference_type(first_from,
                                                               first_dest);
   Impl::expect_valid_range(first_from, last_from);
 
-  // aliases
-  using index_type = typename InputIteratorType::difference_type;
-  using func_t =
-      StdReplaceIfCopyFunctor<index_type, InputIteratorType, OutputIteratorType,
-                              PredicateType, ValueType>;
-
   // run
   const auto num_elements =
       Kokkos::Experimental::distance(first_from, last_from);
-  ::Kokkos::parallel_for(
-      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-      func_t(first_from, first_dest, std::move(pred), new_value));
+  ::Kokkos::parallel_for(label,
+                         RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+                         // use CTAD
+                         StdReplaceIfCopyFunctor(first_from, first_dest,
+                                                 std::move(pred), new_value));
   ex.fence("Kokkos::replace_copy_if: fence after operation");
 
   // return
   return first_dest + num_elements;
 }
 
+//
+// team-level impl
+//
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class PredicateType, class ValueType>
+KOKKOS_FUNCTION OutputIteratorType replace_copy_if_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    PredicateType pred, const ValueType& new_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         // use CTAD
+                         StdReplaceIfCopyFunctor(first_from, first_dest,
+                                                 std::move(pred), new_value));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ReplaceIf.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ReplaceIf.hpp
index 54b6e1c528..61e8abf44c 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ReplaceIf.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ReplaceIf.hpp
@@ -52,24 +52,40 @@ struct StdReplaceIfFunctor {
 
 template <class ExecutionSpace, class IteratorType, class PredicateType,
           class ValueType>
-void replace_if_impl(const std::string& label, const ExecutionSpace& ex,
-                     IteratorType first, IteratorType last, PredicateType pred,
-                     const ValueType& new_value) {
+void replace_if_exespace_impl(const std::string& label,
+                              const ExecutionSpace& ex, IteratorType first,
+                              IteratorType last, PredicateType pred,
+                              const ValueType& new_value) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using func_t = StdReplaceIfFunctor<IteratorType, PredicateType, ValueType>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
-  ::Kokkos::parallel_for(label,
-                         RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first, std::move(pred), new_value));
+  ::Kokkos::parallel_for(
+      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      StdReplaceIfFunctor(first, std::move(pred), new_value));
   ex.fence("Kokkos::replace_if: fence after operation");
 }
 
+template <class TeamHandleType, class IteratorType, class PredicateType,
+          class ValueType>
+KOKKOS_FUNCTION void replace_if_team_impl(const TeamHandleType& teamHandle,
+                                          IteratorType first, IteratorType last,
+                                          PredicateType pred,
+                                          const ValueType& new_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      StdReplaceIfFunctor(first, std::move(pred), new_value));
+  teamHandle.team_barrier();
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp
index 7c75899cb8..b4046c7645 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Reverse.hpp
@@ -21,7 +21,6 @@
 #include "Kokkos_Constraints.hpp"
 #include "Kokkos_HelperPredicates.hpp"
 #include <std_algorithms/Kokkos_Distance.hpp>
-#include <std_algorithms/Kokkos_Swap.hpp>
 #include <string>
 
 namespace Kokkos {
@@ -39,34 +38,50 @@ struct StdReverseFunctor {
 
   KOKKOS_FUNCTION
   void operator()(index_type i) const {
-    ::Kokkos::Experimental::swap(m_first[i], m_last[-i - 1]);
+    ::Kokkos::kokkos_swap(m_first[i], m_last[-i - 1]);
   }
 
+  KOKKOS_FUNCTION
   StdReverseFunctor(InputIterator first, InputIterator last)
       : m_first(std::move(first)), m_last(std::move(last)) {}
 };
 
 template <class ExecutionSpace, class InputIterator>
-void reverse_impl(const std::string& label, const ExecutionSpace& ex,
-                  InputIterator first, InputIterator last) {
+void reverse_exespace_impl(const std::string& label, const ExecutionSpace& ex,
+                           InputIterator first, InputIterator last) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using func_t = StdReverseFunctor<InputIterator>;
-
   // run
   if (last >= first + 2) {
     // only need half
     const auto num_elements = Kokkos::Experimental::distance(first, last) / 2;
     ::Kokkos::parallel_for(label,
                            RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                           func_t(first, last));
+                           StdReverseFunctor(first, last));
     ex.fence("Kokkos::reverse: fence after operation");
   }
 }
 
+template <class TeamHandleType, class InputIterator>
+KOKKOS_FUNCTION void reverse_team_impl(const TeamHandleType& teamHandle,
+                                       InputIterator first,
+                                       InputIterator last) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  if (last >= first + 2) {
+    // only need half
+    const auto num_elements = Kokkos::Experimental::distance(first, last) / 2;
+    ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                           StdReverseFunctor(first, last));
+    teamHandle.team_barrier();
+  }
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ReverseCopy.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ReverseCopy.hpp
index 6dd52813e0..dd20d90e39 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ReverseCopy.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ReverseCopy.hpp
@@ -27,46 +27,64 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIterator, class OutputIterator>
+template <class InputIterator, class OutputIterator>
 struct StdReverseCopyFunctor {
-  static_assert(std::is_signed<IndexType>::value,
+  using index_type = typename InputIterator::difference_type;
+  static_assert(std::is_signed<index_type>::value,
                 "Kokkos: StdReverseCopyFunctor requires signed index type");
 
   InputIterator m_last;
   OutputIterator m_dest_first;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const { m_dest_first[i] = m_last[-1 - i]; }
+  void operator()(index_type i) const { m_dest_first[i] = m_last[-1 - i]; }
 
+  KOKKOS_FUNCTION
   StdReverseCopyFunctor(InputIterator _last, OutputIterator _dest_first)
       : m_last(std::move(_last)), m_dest_first(std::move(_dest_first)) {}
 };
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator>
-OutputIterator reverse_copy_impl(const std::string& label,
-                                 const ExecutionSpace& ex, InputIterator first,
-                                 InputIterator last, OutputIterator d_first) {
+OutputIterator reverse_copy_exespace_impl(const std::string& label,
+                                          const ExecutionSpace& ex,
+                                          InputIterator first,
+                                          InputIterator last,
+                                          OutputIterator d_first) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
   Impl::expect_valid_range(first, last);
 
-  // aliases
-  using index_type = typename InputIterator::difference_type;
-  using func_t =
-      StdReverseCopyFunctor<index_type, InputIterator, OutputIterator>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(last, d_first));
+                         StdReverseCopyFunctor(last, d_first));
   ex.fence("Kokkos::reverse_copy: fence after operation");
 
   // return
   return d_first + num_elements;
 }
 
+template <class TeamHandleType, class InputIterator, class OutputIterator>
+KOKKOS_FUNCTION OutputIterator
+reverse_copy_team_impl(const TeamHandleType& teamHandle, InputIterator first,
+                       InputIterator last, OutputIterator d_first) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdReverseCopyFunctor(last, d_first));
+  teamHandle.team_barrier();
+
+  // return
+  return d_first + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Rotate.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Rotate.hpp
index 3aa1ab5d40..7a4cb8e325 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Rotate.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Rotate.hpp
@@ -20,6 +20,7 @@
 #include <Kokkos_Core.hpp>
 #include "Kokkos_Constraints.hpp"
 #include "Kokkos_HelperPredicates.hpp"
+#include "Kokkos_Reverse.hpp"
 #include <std_algorithms/Kokkos_Move.hpp>
 #include <std_algorithms/Kokkos_Distance.hpp>
 #include <string>
@@ -165,15 +166,17 @@ IteratorType rotate_with_pivot_in_right_half(const std::string& label,
 }
 
 template <class ExecutionSpace, class IteratorType>
-IteratorType rotate_impl(const std::string& label, const ExecutionSpace& ex,
-                         IteratorType first, IteratorType n_first,
-                         IteratorType last) {
+IteratorType rotate_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, IteratorType first,
+                                  IteratorType n_first, IteratorType last) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
   Impl::expect_valid_range(first, n_first);
   Impl::expect_valid_range(n_first, last);
 
+  // might be worth checking if for exespace we should do
+  // something similar to what we do for team since it avoids a new allocation
   namespace KE                     = ::Kokkos::Experimental;
   const auto num_elements          = KE::distance(first, last);
   const auto n_distance_from_first = KE::distance(first, n_first);
@@ -184,6 +187,31 @@ IteratorType rotate_impl(const std::string& label, const ExecutionSpace& ex,
   }
 }
 
+template <class TeamHandleType, class IteratorType>
+KOKKOS_FUNCTION IteratorType rotate_team_impl(const TeamHandleType& teamHandle,
+                                              IteratorType first,
+                                              IteratorType n_first,
+                                              IteratorType last) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+  Impl::expect_valid_range(first, n_first);
+  Impl::expect_valid_range(n_first, last);
+
+  namespace KE = ::Kokkos::Experimental;
+
+  auto result = first + (last - n_first);
+  // first reverse the whole range
+  KE::Impl::reverse_team_impl(teamHandle, first, last);
+  // re-reverse each piece
+  KE::Impl::reverse_team_impl(teamHandle, first, result);
+  KE::Impl::reverse_team_impl(teamHandle, result, last);
+
+  // no need for barrier here since reverse already calls it
+
+  return result;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_RotateCopy.hpp b/algorithms/src/std_algorithms/impl/Kokkos_RotateCopy.hpp
index 28023cc4df..f22dae2de4 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_RotateCopy.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_RotateCopy.hpp
@@ -27,16 +27,18 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIterator, class OutputIterator>
+template <class InputIterator, class OutputIterator>
 struct StdRotateCopyFunctor {
+  using index_type = typename InputIterator::difference_type;
+
   InputIterator m_first;
   InputIterator m_last;
   InputIterator m_first_n;
   OutputIterator m_dest_first;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const {
-    const IndexType shift = m_last - m_first_n;
+  void operator()(index_type i) const {
+    const index_type shift = m_last - m_first_n;
 
     if (i < shift) {
       m_dest_first[i] = m_first_n[i];
@@ -45,6 +47,7 @@ struct StdRotateCopyFunctor {
     }
   }
 
+  KOKKOS_FUNCTION
   StdRotateCopyFunctor(InputIterator first, InputIterator last,
                        InputIterator first_n, OutputIterator dest_first)
       : m_first(std::move(first)),
@@ -54,10 +57,9 @@ struct StdRotateCopyFunctor {
 };
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator>
-OutputIterator rotate_copy_impl(const std::string& label,
-                                const ExecutionSpace& ex, InputIterator first,
-                                InputIterator n_first, InputIterator last,
-                                OutputIterator d_first) {
+OutputIterator rotate_copy_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, InputIterator first,
+    InputIterator n_first, InputIterator last, OutputIterator d_first) {
   /*
     algorithm is implemented as follows:
 
@@ -97,16 +99,11 @@ OutputIterator rotate_copy_impl(const std::string& label,
     return d_first;
   }
 
-  // aliases
-  using index_type = typename InputIterator::difference_type;
-  using func_type =
-      StdRotateCopyFunctor<index_type, InputIterator, OutputIterator>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first, last);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_type(first, last, n_first, d_first));
+                         StdRotateCopyFunctor(first, last, n_first, d_first));
 
   ex.fence("Kokkos::rotate_copy: fence after operation");
 
@@ -114,6 +111,32 @@ OutputIterator rotate_copy_impl(const std::string& label,
   return d_first + num_elements;
 }
 
+template <class TeamHandleType, class InputIterator, class OutputIterator>
+KOKKOS_FUNCTION OutputIterator rotate_copy_team_impl(
+    const TeamHandleType& teamHandle, InputIterator first,
+    InputIterator n_first, InputIterator last, OutputIterator d_first) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+  Impl::expect_valid_range(first, n_first);
+  Impl::expect_valid_range(n_first, last);
+
+  if (first == last) {
+    return d_first;
+  }
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdRotateCopyFunctor(first, last, n_first, d_first));
+
+  teamHandle.team_barrier();
+
+  // return
+  return d_first + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
index 2780151f29..fa04350eb5 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Search.hpp
@@ -81,12 +81,16 @@ struct StdSearchFunctor {
         m_p(std::move(p)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class BinaryPredicateType>
-IteratorType1 search_impl(const std::string& label, const ExecutionSpace& ex,
-                          IteratorType1 first, IteratorType1 last,
-                          IteratorType2 s_first, IteratorType2 s_last,
-                          const BinaryPredicateType& pred) {
+IteratorType1 search_exespace_impl(const std::string& label,
+                                   const ExecutionSpace& ex,
+                                   IteratorType1 first, IteratorType1 last,
+                                   IteratorType2 s_first, IteratorType2 s_last,
+                                   const BinaryPredicateType& pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, s_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, s_first);
@@ -98,7 +102,6 @@ IteratorType1 search_impl(const std::string& label, const ExecutionSpace& ex,
   const auto num_elements = KE::distance(first, last);
   const auto s_count      = KE::distance(s_first, s_last);
   KOKKOS_EXPECTS(num_elements >= s_count);
-  (void)s_count;  // needed when macro above is a no-op
 
   if (s_first == s_last) {
     return first;
@@ -110,7 +113,8 @@ IteratorType1 search_impl(const std::string& label, const ExecutionSpace& ex,
 
   // special case where the two ranges have equal size
   if (num_elements == s_count) {
-    const auto equal_result = equal_impl(label, ex, first, last, s_first, pred);
+    const auto equal_result =
+        equal_exespace_impl(label, ex, first, last, s_first, pred);
     return (equal_result) ? first : last;
   } else {
     using index_type           = typename IteratorType1::difference_type;
@@ -149,13 +153,99 @@ IteratorType1 search_impl(const std::string& label, const ExecutionSpace& ex,
 }
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-IteratorType1 search_impl(const std::string& label, const ExecutionSpace& ex,
-                          IteratorType1 first, IteratorType1 last,
-                          IteratorType2 s_first, IteratorType2 s_last) {
+IteratorType1 search_exespace_impl(const std::string& label,
+                                   const ExecutionSpace& ex,
+                                   IteratorType1 first, IteratorType1 last,
+                                   IteratorType2 s_first,
+                                   IteratorType2 s_last) {
+  using value_type1    = typename IteratorType1::value_type;
+  using value_type2    = typename IteratorType2::value_type;
+  using predicate_type = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+  return search_exespace_impl(label, ex, first, last, s_first, s_last,
+                              predicate_type());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class BinaryPredicateType>
+KOKKOS_FUNCTION IteratorType1
+search_team_impl(const TeamHandleType& teamHandle, IteratorType1 first,
+                 IteratorType1 last, IteratorType2 s_first,
+                 IteratorType2 s_last, const BinaryPredicateType& pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, s_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, s_first);
+  Impl::expect_valid_range(first, last);
+  Impl::expect_valid_range(s_first, s_last);
+
+  // the target sequence should not be larger than the range [first, last)
+  namespace KE            = ::Kokkos::Experimental;
+  const auto num_elements = KE::distance(first, last);
+  const auto s_count      = KE::distance(s_first, s_last);
+  KOKKOS_EXPECTS(num_elements >= s_count);
+
+  if (s_first == s_last) {
+    return first;
+  }
+
+  if (first == last) {
+    return last;
+  }
+
+  // special case where the two ranges have equal size
+  if (num_elements == s_count) {
+    const auto equal_result =
+        equal_team_impl(teamHandle, first, last, s_first, pred);
+    return (equal_result) ? first : last;
+  } else {
+    using index_type           = typename IteratorType1::difference_type;
+    using reducer_type         = FirstLoc<index_type>;
+    using reduction_value_type = typename reducer_type::value_type;
+    using func_t = StdSearchFunctor<index_type, IteratorType1, IteratorType2,
+                                    reducer_type, BinaryPredicateType>;
+
+    // run
+    reduction_value_type red_result;
+    reducer_type reducer(red_result);
+
+    // decide the size of the range policy of the par_red:
+    // note that the last feasible index to start looking is the index
+    // whose distance from the "last" is equal to the sequence count.
+    // the +1 is because we need to include that location too.
+    const auto range_size = num_elements - s_count + 1;
+
+    // run par reduce
+    ::Kokkos::parallel_reduce(
+        TeamThreadRange(teamHandle, 0, range_size),
+        func_t(first, last, s_first, s_last, reducer, pred), reducer);
+
+    teamHandle.team_barrier();
+
+    // decide and return
+    if (red_result.min_loc_true ==
+        ::Kokkos::reduction_identity<index_type>::min()) {
+      // location has not been found
+      return last;
+    } else {
+      // location has been found
+      return first + red_result.min_loc_true;
+    }
+  }
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION IteratorType1 search_team_impl(const TeamHandleType& teamHandle,
+                                               IteratorType1 first,
+                                               IteratorType1 last,
+                                               IteratorType2 s_first,
+                                               IteratorType2 s_last) {
   using value_type1    = typename IteratorType1::value_type;
   using value_type2    = typename IteratorType2::value_type;
   using predicate_type = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
-  return search_impl(label, ex, first, last, s_first, s_last, predicate_type());
+  return search_team_impl(teamHandle, first, last, s_first, s_last,
+                          predicate_type());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp b/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
index 98640136d4..0910f952c0 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_SearchN.hpp
@@ -79,12 +79,16 @@ struct StdSearchNFunctor {
         m_p(std::move(p)) {}
 };
 
+//
+// exespace impl
+//
 template <class ExecutionSpace, class IteratorType, class SizeType,
           class ValueType, class BinaryPredicateType>
-IteratorType search_n_impl(const std::string& label, const ExecutionSpace& ex,
-                           IteratorType first, IteratorType last,
-                           SizeType count, const ValueType& value,
-                           const BinaryPredicateType& pred) {
+IteratorType search_n_exespace_impl(const std::string& label,
+                                    const ExecutionSpace& ex,
+                                    IteratorType first, IteratorType last,
+                                    SizeType count, const ValueType& value,
+                                    const BinaryPredicateType& pred) {
   // checks
   static_assert_random_access_and_accessible(ex, first);
   expect_valid_range(first, last);
@@ -104,7 +108,7 @@ IteratorType search_n_impl(const std::string& label, const ExecutionSpace& ex,
   if ((std::size_t)num_elements == (std::size_t)count) {
     using equal_to_value = StdAlgoEqualsValUnaryPredicate<ValueType>;
     const auto satisfies =
-        all_of_impl(label, ex, first, last, equal_to_value(value));
+        all_of_exespace_impl(label, ex, first, last, equal_to_value(value));
     return (satisfies) ? first : last;
   } else {
     // aliases
@@ -146,9 +150,106 @@ IteratorType search_n_impl(const std::string& label, const ExecutionSpace& ex,
 
 template <class ExecutionSpace, class IteratorType, class SizeType,
           class ValueType>
-IteratorType search_n_impl(const std::string& label, const ExecutionSpace& ex,
-                           IteratorType first, IteratorType last,
-                           SizeType count, const ValueType& value) {
+IteratorType search_n_exespace_impl(const std::string& label,
+                                    const ExecutionSpace& ex,
+                                    IteratorType first, IteratorType last,
+                                    SizeType count, const ValueType& value) {
+  using iter_value_type = typename IteratorType::value_type;
+  using predicate_type =
+      StdAlgoEqualBinaryPredicate<iter_value_type, ValueType>;
+
+  /* above we use <iter_value_type, ValueType> for the predicate_type
+     to be consistent with the standard, which says:
+
+     "
+     The signature of the predicate function should be equivalent to:
+
+        bool pred(const Type1 &a, const Type2 &b);
+
+     The type Type1 must be such that an object of type ForwardIt can be
+     dereferenced and then implicitly converted to Type1. The type Type2 must be
+     such that an object of type T can be implicitly converted to Type2.
+     "
+
+     In our case, IteratorType = ForwardIt, and ValueType = T.
+   */
+
+  return search_n_exespace_impl(label, ex, first, last, count, value,
+                                predicate_type());
+}
+
+//
+// team impl
+//
+template <class TeamHandleType, class IteratorType, class SizeType,
+          class ValueType, class BinaryPredicateType>
+KOKKOS_FUNCTION IteratorType search_n_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    SizeType count, const ValueType& value, const BinaryPredicateType& pred) {
+  // checks
+  static_assert_random_access_and_accessible(teamHandle, first);
+  expect_valid_range(first, last);
+  KOKKOS_EXPECTS((std::ptrdiff_t)count >= 0);
+
+  // count should not be larger than the range [first, last)
+  namespace KE            = ::Kokkos::Experimental;
+  const auto num_elements = KE::distance(first, last);
+  // cast things to avoid compiler warning
+  KOKKOS_EXPECTS((std::size_t)num_elements >= (std::size_t)count);
+
+  if (first == last) {
+    return first;
+  }
+
+  // special case where num elements in [first, last) == count
+  if ((std::size_t)num_elements == (std::size_t)count) {
+    using equal_to_value = StdAlgoEqualsValUnaryPredicate<ValueType>;
+    const auto satisfies =
+        all_of_team_impl(teamHandle, first, last, equal_to_value(value));
+    return (satisfies) ? first : last;
+  } else {
+    // aliases
+    using index_type           = typename IteratorType::difference_type;
+    using reducer_type         = FirstLoc<index_type>;
+    using reduction_value_type = typename reducer_type::value_type;
+    using func_t =
+        StdSearchNFunctor<index_type, IteratorType, SizeType, ValueType,
+                          reducer_type, BinaryPredicateType>;
+
+    // run
+    reduction_value_type red_result;
+    reducer_type reducer(red_result);
+
+    // decide the size of the range policy of the par_red:
+    // the last feasible index to start looking is the index
+    // whose distance from the "last" is equal to count.
+    // the +1 is because we need to include that location too.
+    const auto range_size = num_elements - count + 1;
+
+    // run par reduce
+    ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, range_size),
+                              func_t(first, last, count, value, reducer, pred),
+                              reducer);
+
+    teamHandle.team_barrier();
+
+    // decide and return
+    if (red_result.min_loc_true ==
+        ::Kokkos::reduction_identity<index_type>::min()) {
+      // location has not been found
+      return last;
+    } else {
+      // location has been found
+      return first + red_result.min_loc_true;
+    }
+  }
+}
+
+template <class TeamHandleType, class IteratorType, class SizeType,
+          class ValueType>
+KOKKOS_FUNCTION IteratorType
+search_n_team_impl(const TeamHandleType& teamHandle, IteratorType first,
+                   IteratorType last, SizeType count, const ValueType& value) {
   using iter_value_type = typename IteratorType::value_type;
   using predicate_type =
       StdAlgoEqualBinaryPredicate<iter_value_type, ValueType>;
@@ -169,7 +270,8 @@ IteratorType search_n_impl(const std::string& label, const ExecutionSpace& ex,
      In our case, IteratorType = ForwardIt, and ValueType = T.
    */
 
-  return search_n_impl(label, ex, first, last, count, value, predicate_type());
+  return search_n_team_impl(teamHandle, first, last, count, value,
+                            predicate_type());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ShiftLeft.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ShiftLeft.hpp
index 7a33762f17..9414748507 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ShiftLeft.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ShiftLeft.hpp
@@ -29,9 +29,9 @@ namespace Experimental {
 namespace Impl {
 
 template <class ExecutionSpace, class IteratorType>
-IteratorType shift_left_impl(const std::string& label, const ExecutionSpace& ex,
-                             IteratorType first, IteratorType last,
-                             typename IteratorType::difference_type n) {
+IteratorType shift_left_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType first,
+    IteratorType last, typename IteratorType::difference_type n) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -104,6 +104,41 @@ IteratorType shift_left_impl(const std::string& label, const ExecutionSpace& ex,
   return last - n;
 }
 
+template <class TeamHandleType, class IteratorType>
+KOKKOS_FUNCTION IteratorType shift_left_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    typename IteratorType::difference_type n) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+  KOKKOS_EXPECTS(n >= 0);
+
+  // handle trivial cases
+  if (n == 0) {
+    return last;
+  }
+
+  if (n >= Kokkos::Experimental::distance(first, last)) {
+    return first;
+  }
+
+  // we cannot use here a new allocation like we do for the
+  // execution space impl because for this team impl we are
+  // within a parallel region, so for now we solve serially
+
+  using difference_type = typename IteratorType::difference_type;
+  const difference_type numElementsToMove =
+      ::Kokkos::Experimental::distance(first + n, last);
+  Kokkos::single(Kokkos::PerTeam(teamHandle), [=]() {
+    for (difference_type i = 0; i < numElementsToMove; ++i) {
+      first[i] = std::move(first[i + n]);
+    }
+  });
+  teamHandle.team_barrier();
+
+  return last - n;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_ShiftRight.hpp b/algorithms/src/std_algorithms/impl/Kokkos_ShiftRight.hpp
index 2b0a4bb524..0414e6f1c2 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_ShiftRight.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_ShiftRight.hpp
@@ -29,10 +29,9 @@ namespace Experimental {
 namespace Impl {
 
 template <class ExecutionSpace, class IteratorType>
-IteratorType shift_right_impl(const std::string& label,
-                              const ExecutionSpace& ex, IteratorType first,
-                              IteratorType last,
-                              typename IteratorType::difference_type n) {
+IteratorType shift_right_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, IteratorType first,
+    IteratorType last, typename IteratorType::difference_type n) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -104,6 +103,41 @@ IteratorType shift_right_impl(const std::string& label,
   return first + n;
 }
 
+template <class TeamHandleType, class IteratorType>
+KOKKOS_FUNCTION IteratorType shift_right_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    typename IteratorType::difference_type n) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+  KOKKOS_EXPECTS(n >= 0);
+
+  // handle trivial cases
+  if (n == 0) {
+    return first;
+  }
+
+  if (n >= Kokkos::Experimental::distance(first, last)) {
+    return last;
+  }
+
+  // we cannot use here a new allocation like we do for the
+  // execution space impl because for this team impl we are
+  // within a parallel region, so for now we solve serially
+
+  using difference_type = typename IteratorType::difference_type;
+  const difference_type numElementsToMove =
+      ::Kokkos::Experimental::distance(first, last - n);
+  Kokkos::single(Kokkos::PerTeam(teamHandle), [=]() {
+    for (difference_type i = 0; i < numElementsToMove; ++i) {
+      last[-i - 1] = std::move(last[-n - i - 1]);
+    }
+  });
+  teamHandle.team_barrier();
+
+  return first + n;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp b/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp
index a5e4786d04..930a14ac48 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_SwapRanges.hpp
@@ -21,21 +21,21 @@
 #include "Kokkos_Constraints.hpp"
 #include "Kokkos_HelperPredicates.hpp"
 #include <std_algorithms/Kokkos_Distance.hpp>
-#include <std_algorithms/Kokkos_Swap.hpp>
 #include <string>
 
 namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class IteratorType1, class IteratorType2>
+template <class IteratorType1, class IteratorType2>
 struct StdSwapRangesFunctor {
+  using index_type = typename IteratorType1::difference_type;
   IteratorType1 m_first1;
   IteratorType2 m_first2;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const {
-    ::Kokkos::Experimental::swap(m_first1[i], m_first2[i]);
+  void operator()(index_type i) const {
+    ::Kokkos::kokkos_swap(m_first1[i], m_first2[i]);
   }
 
   KOKKOS_FUNCTION
@@ -44,30 +44,48 @@ struct StdSwapRangesFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2>
-IteratorType2 swap_ranges_impl(const std::string& label,
-                               const ExecutionSpace& ex, IteratorType1 first1,
-                               IteratorType1 last1, IteratorType2 first2) {
+IteratorType2 swap_ranges_exespace_impl(const std::string& label,
+                                        const ExecutionSpace& ex,
+                                        IteratorType1 first1,
+                                        IteratorType1 last1,
+                                        IteratorType2 first2) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first1, first2);
   Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
   Impl::expect_valid_range(first1, last1);
 
-  // aliases
-  using index_type = typename IteratorType1::difference_type;
-  using func_t = StdSwapRangesFunctor<index_type, IteratorType1, IteratorType2>;
-
   // run
   const auto num_elements_to_swap =
       Kokkos::Experimental::distance(first1, last1);
   ::Kokkos::parallel_for(
       label, RangePolicy<ExecutionSpace>(ex, 0, num_elements_to_swap),
-      func_t(first1, first2));
+      StdSwapRangesFunctor(first1, first2));
   ex.fence("Kokkos::swap_ranges: fence after operation");
 
   // return
   return first2 + num_elements_to_swap;
 }
 
+template <class TeamHandleType, class IteratorType1, class IteratorType2>
+KOKKOS_FUNCTION IteratorType2
+swap_ranges_team_impl(const TeamHandleType& teamHandle, IteratorType1 first1,
+                      IteratorType1 last1, IteratorType2 first2) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
+  Impl::expect_valid_range(first1, last1);
+
+  // run
+  const auto num_elements_to_swap =
+      Kokkos::Experimental::distance(first1, last1);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements_to_swap),
+                         StdSwapRangesFunctor(first1, first2));
+  teamHandle.team_barrier();
+
+  // return
+  return first2 + num_elements_to_swap;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Transform.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Transform.hpp
index 840e9d2054..c7e0573324 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Transform.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Transform.hpp
@@ -27,15 +27,19 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIterator, class OutputIterator,
-          class UnaryFunctorType>
+template <class InputIterator, class OutputIterator, class UnaryFunctorType>
 struct StdTransformFunctor {
+  // we can use difference type from InputIterator since
+  // the impl functions calling this functor already
+  // static assert that the iterators have matching difference type
+  using index_type = typename InputIterator::difference_type;
+
   InputIterator m_first;
   OutputIterator m_d_first;
   UnaryFunctorType m_unary_op;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const { m_d_first[i] = m_unary_op(m_first[i]); }
+  void operator()(index_type i) const { m_d_first[i] = m_unary_op(m_first[i]); }
 
   KOKKOS_FUNCTION
   StdTransformFunctor(InputIterator _first, OutputIterator _m_d_first,
@@ -45,16 +49,21 @@ struct StdTransformFunctor {
         m_unary_op(std::move(_functor)) {}
 };
 
-template <class IndexType, class InputIterator1, class InputIterator2,
-          class OutputIterator, class BinaryFunctorType>
+template <class InputIterator1, class InputIterator2, class OutputIterator,
+          class BinaryFunctorType>
 struct StdTransformBinaryFunctor {
+  // we can use difference type from InputIterator1 since
+  // the impl functions calling this functor already
+  // static assert that the iterators have matching difference type
+  using index_type = typename InputIterator1::difference_type;
+
   InputIterator1 m_first1;
   InputIterator2 m_first2;
   OutputIterator m_d_first;
   BinaryFunctorType m_binary_op;
 
   KOKKOS_FUNCTION
-  void operator()(IndexType i) const {
+  void operator()(index_type i) const {
     m_d_first[i] = m_binary_op(m_first1[i], m_first2[i]);
   }
 
@@ -70,25 +79,19 @@ struct StdTransformBinaryFunctor {
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator,
           class UnaryOperation>
-OutputIterator transform_impl(const std::string& label,
-                              const ExecutionSpace& ex, InputIterator first1,
-                              InputIterator last1, OutputIterator d_first,
-                              UnaryOperation unary_op) {
+OutputIterator transform_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, InputIterator first1,
+    InputIterator last1, OutputIterator d_first, UnaryOperation unary_op) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first1, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first1, d_first);
   Impl::expect_valid_range(first1, last1);
 
-  // aliases
-  using index_type = typename InputIterator::difference_type;
-  using func_t = StdTransformFunctor<index_type, InputIterator, OutputIterator,
-                                     UnaryOperation>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first1, last1);
   ::Kokkos::parallel_for(label,
                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first1, d_first, unary_op));
+                         StdTransformFunctor(first1, d_first, unary_op));
   ex.fence("Kokkos::transform: fence after operation");
 
   // return
@@ -97,32 +100,72 @@ OutputIterator transform_impl(const std::string& label,
 
 template <class ExecutionSpace, class InputIterator1, class InputIterator2,
           class OutputIterator, class BinaryOperation>
-OutputIterator transform_impl(const std::string& label,
-                              const ExecutionSpace& ex, InputIterator1 first1,
-                              InputIterator1 last1, InputIterator2 first2,
-                              OutputIterator d_first,
-                              BinaryOperation binary_op) {
+OutputIterator transform_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, InputIterator1 first1,
+    InputIterator1 last1, InputIterator2 first2, OutputIterator d_first,
+    BinaryOperation binary_op) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first1, first2, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first1, first2,
                                                               d_first);
   Impl::expect_valid_range(first1, last1);
 
-  // aliases
-  using index_type = typename InputIterator1::difference_type;
-  using func_t =
-      StdTransformBinaryFunctor<index_type, InputIterator1, InputIterator2,
-                                OutputIterator, BinaryOperation>;
-
   // run
   const auto num_elements = Kokkos::Experimental::distance(first1, last1);
-  ::Kokkos::parallel_for(label,
-                         RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-                         func_t(first1, first2, d_first, binary_op));
+  ::Kokkos::parallel_for(
+      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+      StdTransformBinaryFunctor(first1, first2, d_first, binary_op));
   ex.fence("Kokkos::transform: fence after operation");
   return d_first + num_elements;
 }
 
+//
+// team-level impl
+//
+
+template <class TeamHandleType, class InputIterator, class OutputIterator,
+          class UnaryOperation>
+KOKKOS_FUNCTION OutputIterator transform_team_impl(
+    const TeamHandleType& teamHandle, InputIterator first1, InputIterator last1,
+    OutputIterator d_first, UnaryOperation unary_op) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, d_first);
+  Impl::expect_valid_range(first1, last1);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first1, last1);
+  ::Kokkos::parallel_for(TeamThreadRange(teamHandle, 0, num_elements),
+                         StdTransformFunctor(first1, d_first, unary_op));
+  teamHandle.team_barrier();
+
+  // return
+  return d_first + num_elements;
+}
+
+template <class TeamHandleType, class InputIterator1, class InputIterator2,
+          class OutputIterator, class BinaryOperation>
+KOKKOS_FUNCTION OutputIterator
+transform_team_impl(const TeamHandleType& teamHandle, InputIterator1 first1,
+                    InputIterator1 last1, InputIterator2 first2,
+                    OutputIterator d_first, BinaryOperation binary_op) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2,
+                                                   d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2,
+                                                              d_first);
+  Impl::expect_valid_range(first1, last1);
+
+  // run
+  const auto num_elements = Kokkos::Experimental::distance(first1, last1);
+  ::Kokkos::parallel_for(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      StdTransformBinaryFunctor(first1, first2, d_first, binary_op));
+  teamHandle.team_barrier();
+
+  return d_first + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp
index 3bb337de36..d832f8849d 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_TransformExclusiveScan.hpp
@@ -21,6 +21,7 @@
 #include "Kokkos_Constraints.hpp"
 #include "Kokkos_HelperPredicates.hpp"
 #include "Kokkos_ValueWrapperForNoNeutralElement.hpp"
+#include "Kokkos_FunctorsForExclusiveScan.hpp"
 #include <std_algorithms/Kokkos_Distance.hpp>
 #include <string>
 
@@ -28,69 +29,13 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
-          class FirstDest, class BinaryOpType, class UnaryOpType>
-struct TransformExclusiveScanFunctor {
-  using execution_space = ExeSpace;
-  using value_type =
-      ::Kokkos::Experimental::Impl::ValueWrapperForNoNeutralElement<ValueType>;
-
-  ValueType m_init_value;
-  FirstFrom m_first_from;
-  FirstDest m_first_dest;
-  BinaryOpType m_binary_op;
-  UnaryOpType m_unary_op;
-
-  KOKKOS_FUNCTION
-  TransformExclusiveScanFunctor(ValueType init, FirstFrom first_from,
-                                FirstDest first_dest, BinaryOpType bop,
-                                UnaryOpType uop)
-      : m_init_value(std::move(init)),
-        m_first_from(std::move(first_from)),
-        m_first_dest(std::move(first_dest)),
-        m_binary_op(std::move(bop)),
-        m_unary_op(std::move(uop)) {}
-
-  KOKKOS_FUNCTION
-  void operator()(const IndexType i, value_type& update,
-                  const bool final_pass) const {
-    if (final_pass) {
-      if (i == 0) {
-        // for both ExclusiveScan and TransformExclusiveScan,
-        // init is unmodified
-        m_first_dest[i] = m_init_value;
-      } else {
-        m_first_dest[i] = m_binary_op(update.val, m_init_value);
-      }
-    }
-
-    const auto tmp = value_type{m_unary_op(m_first_from[i]), false};
-    this->join(update, tmp);
-  }
-
-  KOKKOS_FUNCTION
-  void init(value_type& update) const {
-    update.val        = {};
-    update.is_initial = true;
-  }
-
-  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 {
-      update.val = m_binary_op(update.val, input.val);
-    }
-    update.is_initial = false;
-  }
-};
-
+//
+// exespace impl
+//
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class ValueType, class BinaryOpType,
           class UnaryOpType>
-OutputIteratorType transform_exclusive_scan_impl(
+OutputIteratorType transform_exclusive_scan_exespace_impl(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType first_from, InputIteratorType last_from,
     OutputIteratorType first_dest, ValueType init_value, BinaryOpType bop,
@@ -103,23 +48,70 @@ OutputIteratorType transform_exclusive_scan_impl(
 
   // aliases
   using index_type = typename InputIteratorType::difference_type;
-  using func_type =
-      TransformExclusiveScanFunctor<ExecutionSpace, index_type, ValueType,
-                                    InputIteratorType, OutputIteratorType,
-                                    BinaryOpType, UnaryOpType>;
+
+  using func_type = std::conditional_t<
+      ::Kokkos::is_detected<ex_scan_has_reduction_identity_sum_t,
+                            ValueType>::value,
+      TransformExclusiveScanFunctorWithoutValueWrapper<
+          ExecutionSpace, index_type, ValueType, InputIteratorType,
+          OutputIteratorType, BinaryOpType, UnaryOpType>,
+      TransformExclusiveScanFunctorWithValueWrapper<
+          ExecutionSpace, index_type, ValueType, InputIteratorType,
+          OutputIteratorType, BinaryOpType, UnaryOpType> >;
 
   // run
   const auto num_elements =
       Kokkos::Experimental::distance(first_from, last_from);
   ::Kokkos::parallel_scan(
       label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-      func_type(init_value, first_from, first_dest, bop, uop));
+      func_type(std::move(init_value), first_from, first_dest, bop, uop));
   ex.fence("Kokkos::transform_exclusive_scan: fence after operation");
 
   // return
   return first_dest + num_elements;
 }
 
+//
+// team impl
+//
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class ValueType, class BinaryOpType,
+          class UnaryOpType>
+KOKKOS_FUNCTION OutputIteratorType transform_exclusive_scan_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    ValueType init_value, BinaryOpType bop, UnaryOpType uop) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  static_assert(
+      ::Kokkos::is_detected_v<ex_scan_has_reduction_identity_sum_t, ValueType>,
+      "The team-level impl of Kokkos::Experimental::transform_exclusive_scan "
+      "currently does not support types without reduction identity");
+
+  // aliases
+  using exe_space  = typename TeamHandleType::execution_space;
+  using index_type = typename InputIteratorType::difference_type;
+  using func_type  = TransformExclusiveScanFunctorWithoutValueWrapper<
+      exe_space, index_type, ValueType, InputIteratorType, OutputIteratorType,
+      BinaryOpType, UnaryOpType>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      func_type(std::move(init_value), first_from, first_dest, bop, uop));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp b/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp
index 05f8589086..dc432573ee 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_TransformInclusiveScan.hpp
@@ -31,7 +31,7 @@ namespace Impl {
 
 template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
           class FirstDest, class BinaryOpType, class UnaryOpType>
-struct TransformInclusiveScanNoInitValueFunctor {
+struct ExeSpaceTransformInclusiveScanNoInitValueFunctor {
   using execution_space = ExeSpace;
   using value_type      = ValueWrapperForNoNeutralElement<ValueType>;
 
@@ -41,9 +41,10 @@ struct TransformInclusiveScanNoInitValueFunctor {
   UnaryOpType m_unary_op;
 
   KOKKOS_FUNCTION
-  TransformInclusiveScanNoInitValueFunctor(FirstFrom first_from,
-                                           FirstDest first_dest,
-                                           BinaryOpType bop, UnaryOpType uop)
+  ExeSpaceTransformInclusiveScanNoInitValueFunctor(FirstFrom first_from,
+                                                   FirstDest first_dest,
+                                                   BinaryOpType bop,
+                                                   UnaryOpType uop)
       : m_first_from(std::move(first_from)),
         m_first_dest(std::move(first_dest)),
         m_binary_op(std::move(bop)),
@@ -80,7 +81,7 @@ struct TransformInclusiveScanNoInitValueFunctor {
 
 template <class ExeSpace, class IndexType, class ValueType, class FirstFrom,
           class FirstDest, class BinaryOpType, class UnaryOpType>
-struct TransformInclusiveScanWithInitValueFunctor {
+struct ExeSpaceTransformInclusiveScanWithInitValueFunctor {
   using execution_space = ExeSpace;
   using value_type      = ValueWrapperForNoNeutralElement<ValueType>;
 
@@ -91,10 +92,11 @@ struct TransformInclusiveScanWithInitValueFunctor {
   ValueType m_init;
 
   KOKKOS_FUNCTION
-  TransformInclusiveScanWithInitValueFunctor(FirstFrom first_from,
-                                             FirstDest first_dest,
-                                             BinaryOpType bop, UnaryOpType uop,
-                                             ValueType init)
+  ExeSpaceTransformInclusiveScanWithInitValueFunctor(FirstFrom first_from,
+                                                     FirstDest first_dest,
+                                                     BinaryOpType bop,
+                                                     UnaryOpType uop,
+                                                     ValueType init)
       : m_first_from(std::move(first_from)),
         m_first_dest(std::move(first_dest)),
         m_binary_op(std::move(bop)),
@@ -131,18 +133,20 @@ struct TransformInclusiveScanWithInitValueFunctor {
   }
 };
 
+//
+// exespace impl
+//
+
 // -------------------------------------------------------------
-// transform_inclusive_scan_impl without init_value
+// transform_inclusive_scan_exespace_impl without init_value
 // -------------------------------------------------------------
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class BinaryOpType, class UnaryOpType>
-OutputIteratorType transform_inclusive_scan_impl(const std::string& label,
-                                                 const ExecutionSpace& ex,
-                                                 InputIteratorType first_from,
-                                                 InputIteratorType last_from,
-                                                 OutputIteratorType first_dest,
-                                                 BinaryOpType binary_op,
-                                                 UnaryOpType unary_op) {
+OutputIteratorType transform_inclusive_scan_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex,
+    InputIteratorType first_from, InputIteratorType last_from,
+    OutputIteratorType first_dest, BinaryOpType binary_op,
+    UnaryOpType unary_op) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first_from, first_dest);
   Impl::static_assert_iterators_have_matching_difference_type(first_from,
@@ -153,7 +157,7 @@ OutputIteratorType transform_inclusive_scan_impl(const std::string& label,
   using index_type = typename InputIteratorType::difference_type;
   using value_type =
       std::remove_const_t<typename InputIteratorType::value_type>;
-  using func_type = TransformInclusiveScanNoInitValueFunctor<
+  using func_type = ExeSpaceTransformInclusiveScanNoInitValueFunctor<
       ExecutionSpace, index_type, value_type, InputIteratorType,
       OutputIteratorType, BinaryOpType, UnaryOpType>;
 
@@ -170,12 +174,12 @@ OutputIteratorType transform_inclusive_scan_impl(const std::string& label,
 }
 
 // -------------------------------------------------------------
-// transform_inclusive_scan_impl with init_value
+// transform_inclusive_scan_exespace_impl with init_value
 // -------------------------------------------------------------
 template <class ExecutionSpace, class InputIteratorType,
           class OutputIteratorType, class BinaryOpType, class UnaryOpType,
           class ValueType>
-OutputIteratorType transform_inclusive_scan_impl(
+OutputIteratorType transform_inclusive_scan_exespace_impl(
     const std::string& label, const ExecutionSpace& ex,
     InputIteratorType first_from, InputIteratorType last_from,
     OutputIteratorType first_dest, BinaryOpType binary_op, UnaryOpType unary_op,
@@ -188,22 +192,182 @@ OutputIteratorType transform_inclusive_scan_impl(
 
   // aliases
   using index_type = typename InputIteratorType::difference_type;
-  using func_type  = TransformInclusiveScanWithInitValueFunctor<
+  using func_type  = ExeSpaceTransformInclusiveScanWithInitValueFunctor<
       ExecutionSpace, index_type, ValueType, InputIteratorType,
       OutputIteratorType, BinaryOpType, UnaryOpType>;
 
   // run
   const auto num_elements =
       Kokkos::Experimental::distance(first_from, last_from);
-  ::Kokkos::parallel_scan(
-      label, RangePolicy<ExecutionSpace>(ex, 0, num_elements),
-      func_type(first_from, first_dest, binary_op, unary_op, init_value));
+  ::Kokkos::parallel_scan(label,
+                          RangePolicy<ExecutionSpace>(ex, 0, num_elements),
+                          func_type(first_from, first_dest, binary_op, unary_op,
+                                    std::move(init_value)));
   ex.fence("Kokkos::transform_inclusive_scan: fence after operation");
 
   // return
   return first_dest + num_elements;
 }
 
+//
+// team impl
+//
+
+template <class ExeSpace, class ValueType, class FirstFrom, class FirstDest,
+          class BinaryOpType, class UnaryOpType>
+struct TeamTransformInclusiveScanNoInitValueFunctor {
+  using execution_space = ExeSpace;
+  using index_type      = typename FirstFrom::difference_type;
+
+  FirstFrom m_first_from;
+  FirstDest m_first_dest;
+  BinaryOpType m_binary_op;
+  UnaryOpType m_unary_op;
+
+  KOKKOS_FUNCTION
+  TeamTransformInclusiveScanNoInitValueFunctor(FirstFrom first_from,
+                                               FirstDest first_dest,
+                                               BinaryOpType bop,
+                                               UnaryOpType uop)
+      : m_first_from(std::move(first_from)),
+        m_first_dest(std::move(first_dest)),
+        m_binary_op(std::move(bop)),
+        m_unary_op(std::move(uop)) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const index_type i, ValueType& update,
+                  const bool final_pass) const {
+    const auto tmp = ValueType{m_unary_op(m_first_from[i])};
+    this->join(update, tmp);
+    if (final_pass) {
+      m_first_dest[i] = update;
+    }
+  }
+
+  KOKKOS_FUNCTION
+  void init(ValueType& update) const { update = {}; }
+
+  KOKKOS_FUNCTION
+  void join(ValueType& update, const ValueType& input) const {
+    update = m_binary_op(update, input);
+  }
+};
+
+template <class ExeSpace, class ValueType, class FirstFrom, class FirstDest,
+          class BinaryOpType, class UnaryOpType>
+struct TeamTransformInclusiveScanWithInitValueFunctor {
+  using execution_space = ExeSpace;
+  using index_type      = typename FirstFrom::difference_type;
+
+  FirstFrom m_first_from;
+  FirstDest m_first_dest;
+  BinaryOpType m_binary_op;
+  UnaryOpType m_unary_op;
+  ValueType m_init;
+
+  KOKKOS_FUNCTION
+  TeamTransformInclusiveScanWithInitValueFunctor(FirstFrom first_from,
+                                                 FirstDest first_dest,
+                                                 BinaryOpType bop,
+                                                 UnaryOpType uop,
+                                                 ValueType init)
+      : m_first_from(std::move(first_from)),
+        m_first_dest(std::move(first_dest)),
+        m_binary_op(std::move(bop)),
+        m_unary_op(std::move(uop)),
+        m_init(std::move(init)) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const index_type i, ValueType& update,
+                  const bool final_pass) const {
+    const auto tmp = ValueType{m_unary_op(m_first_from[i])};
+    this->join(update, tmp);
+
+    if (final_pass) {
+      m_first_dest[i] = m_binary_op(update, m_init);
+    }
+  }
+
+  KOKKOS_FUNCTION
+  void init(ValueType& update) const { update = {}; }
+
+  KOKKOS_FUNCTION
+  void join(ValueType& update, const ValueType& input) const {
+    update = m_binary_op(update, input);
+  }
+};
+
+// -------------------------------------------------------------
+// transform_inclusive_scan_team_impl without init_value
+// -------------------------------------------------------------
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class BinaryOpType, class UnaryOpType>
+KOKKOS_FUNCTION OutputIteratorType transform_inclusive_scan_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  // aliases
+  using exe_space = typename TeamHandleType::execution_space;
+  using value_type =
+      std::remove_const_t<typename InputIteratorType::value_type>;
+  using func_type = TeamTransformInclusiveScanNoInitValueFunctor<
+      exe_space, value_type, InputIteratorType, OutputIteratorType,
+      BinaryOpType, UnaryOpType>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(
+      TeamThreadRange(teamHandle, 0, num_elements),
+      func_type(first_from, first_dest, binary_op, unary_op));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
+// -------------------------------------------------------------
+// transform_inclusive_scan_team_impl with init_value
+// -------------------------------------------------------------
+template <class TeamHandleType, class InputIteratorType,
+          class OutputIteratorType, class BinaryOpType, class UnaryOpType,
+          class ValueType>
+KOKKOS_FUNCTION OutputIteratorType transform_inclusive_scan_team_impl(
+    const TeamHandleType& teamHandle, InputIteratorType first_from,
+    InputIteratorType last_from, OutputIteratorType first_dest,
+    BinaryOpType binary_op, UnaryOpType unary_op, ValueType init_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first_from,
+                                                   first_dest);
+  Impl::static_assert_iterators_have_matching_difference_type(first_from,
+                                                              first_dest);
+  Impl::expect_valid_range(first_from, last_from);
+
+  // aliases
+  using exe_space = typename TeamHandleType::execution_space;
+  using func_type = TeamTransformInclusiveScanWithInitValueFunctor<
+      exe_space, ValueType, InputIteratorType, OutputIteratorType, BinaryOpType,
+      UnaryOpType>;
+
+  // run
+  const auto num_elements =
+      Kokkos::Experimental::distance(first_from, last_from);
+  ::Kokkos::parallel_scan(TeamThreadRange(teamHandle, 0, num_elements),
+                          func_type(first_from, first_dest, binary_op, unary_op,
+                                    std::move(init_value)));
+  teamHandle.team_barrier();
+
+  // return
+  return first_dest + num_elements;
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_TransformReduce.hpp b/algorithms/src/std_algorithms/impl/Kokkos_TransformReduce.hpp
index 03771056a2..79bdf98915 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_TransformReduce.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_TransformReduce.hpp
@@ -110,9 +110,13 @@ struct StdTransformReduceTwoIntervalsFunctor {
 //
 //------------------------------
 
+//
+// exespace impl
+//
+
 template <class ExecutionSpace, class IteratorType, class ValueType,
           class JoinerType, class UnaryTransformerType>
-ValueType transform_reduce_custom_functors_impl(
+ValueType transform_reduce_custom_functors_exespace_impl(
     const std::string& label, const ExecutionSpace& ex, IteratorType first,
     IteratorType last, ValueType init_reduction_value, JoinerType joiner,
     UnaryTransformerType transformer) {
@@ -151,7 +155,7 @@ ValueType transform_reduce_custom_functors_impl(
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class ValueType, class JoinerType, class BinaryTransformerType>
-ValueType transform_reduce_custom_functors_impl(
+ValueType transform_reduce_custom_functors_exespace_impl(
     const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
     IteratorType1 last1, IteratorType2 first2, ValueType init_reduction_value,
     JoinerType joiner, BinaryTransformerType transformer) {
@@ -191,7 +195,7 @@ ValueType transform_reduce_custom_functors_impl(
 
 template <class ExecutionSpace, class IteratorType1, class IteratorType2,
           class ValueType>
-ValueType transform_reduce_default_functors_impl(
+ValueType transform_reduce_default_functors_exespace_impl(
     const std::string& label, const ExecutionSpace& ex, IteratorType1 first1,
     IteratorType1 last1, IteratorType2 first2, ValueType init_reduction_value) {
   // checks
@@ -205,11 +209,115 @@ ValueType transform_reduce_default_functors_impl(
       Impl::StdTranformReduceDefaultBinaryTransformFunctor<ValueType>;
   using joiner_type = Impl::StdTranformReduceDefaultJoinFunctor<ValueType>;
 
-  return transform_reduce_custom_functors_impl(
+  return transform_reduce_custom_functors_exespace_impl(
       label, ex, first1, last1, first2, std::move(init_reduction_value),
       joiner_type(), transformer_type());
 }
 
+//
+// team impl
+//
+
+template <class TeamHandleType, class IteratorType, class ValueType,
+          class JoinerType, class UnaryTransformerType>
+KOKKOS_FUNCTION ValueType transform_reduce_custom_functors_team_impl(
+    const TeamHandleType& teamHandle, IteratorType first, IteratorType last,
+    ValueType init_reduction_value, JoinerType joiner,
+    UnaryTransformerType transformer) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::expect_valid_range(first, last);
+
+  if (first == last) {
+    // init is returned, unmodified
+    return init_reduction_value;
+  }
+
+  // aliases
+  using reducer_type =
+      ReducerWithArbitraryJoinerNoNeutralElement<ValueType, JoinerType>;
+  using functor_type =
+      StdTransformReduceSingleIntervalFunctor<IteratorType, reducer_type,
+                                              UnaryTransformerType>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  // run
+  reduction_value_type result;
+  reducer_type reducer(result, joiner);
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            functor_type(first, reducer, transformer), reducer);
+
+  teamHandle.team_barrier();
+
+  // as per standard, transform is not applied to the init value
+  // https://en.cppreference.com/w/cpp/algorithm/transform_reduce
+  return joiner(result.val, init_reduction_value);
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class ValueType, class JoinerType, class BinaryTransformerType>
+KOKKOS_FUNCTION ValueType transform_reduce_custom_functors_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, ValueType init_reduction_value, JoinerType joiner,
+    BinaryTransformerType transformer) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
+  Impl::expect_valid_range(first1, last1);
+
+  if (first1 == last1) {
+    // init is returned, unmodified
+    return init_reduction_value;
+  }
+
+  // aliases
+  using index_type = typename IteratorType1::difference_type;
+  using reducer_type =
+      ReducerWithArbitraryJoinerNoNeutralElement<ValueType, JoinerType>;
+  using functor_type =
+      StdTransformReduceTwoIntervalsFunctor<index_type, IteratorType1,
+                                            IteratorType2, reducer_type,
+                                            BinaryTransformerType>;
+  using reduction_value_type = typename reducer_type::value_type;
+
+  // run
+  reduction_value_type result;
+  reducer_type reducer(result, joiner);
+
+  const auto num_elements = Kokkos::Experimental::distance(first1, last1);
+  ::Kokkos::parallel_reduce(TeamThreadRange(teamHandle, 0, num_elements),
+                            functor_type(first1, first2, reducer, transformer),
+                            reducer);
+
+  teamHandle.team_barrier();
+
+  return joiner(result.val, init_reduction_value);
+}
+
+template <class TeamHandleType, class IteratorType1, class IteratorType2,
+          class ValueType>
+KOKKOS_FUNCTION ValueType transform_reduce_default_functors_team_impl(
+    const TeamHandleType& teamHandle, IteratorType1 first1, IteratorType1 last1,
+    IteratorType2 first2, ValueType init_reduction_value) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first1, first2);
+  Impl::static_assert_is_not_openmptarget(teamHandle);
+  Impl::static_assert_iterators_have_matching_difference_type(first1, first2);
+  Impl::expect_valid_range(first1, last1);
+
+  // aliases
+  using transformer_type =
+      Impl::StdTranformReduceDefaultBinaryTransformFunctor<ValueType>;
+  using joiner_type = Impl::StdTranformReduceDefaultJoinFunctor<ValueType>;
+
+  return transform_reduce_custom_functors_team_impl(
+      teamHandle, first1, last1, first2, std::move(init_reduction_value),
+      joiner_type(), transformer_type());
+}
+
 }  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_Unique.hpp b/algorithms/src/std_algorithms/impl/Kokkos_Unique.hpp
index 4bab551563..2863582458 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_Unique.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_Unique.hpp
@@ -29,9 +29,10 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIt, class OutputIt,
-          class BinaryPredicateType>
+template <class InputIt, class OutputIt, class BinaryPredicateType>
 struct StdUniqueFunctor {
+  using index_type = typename InputIt::difference_type;
+
   InputIt m_first_from;
   InputIt m_last_from;
   OutputIt m_first_dest;
@@ -46,7 +47,7 @@ struct StdUniqueFunctor {
         m_pred(std::move(pred)) {}
 
   KOKKOS_FUNCTION
-  void operator()(const IndexType i, IndexType& update,
+  void operator()(const index_type i, index_type& update,
                   const bool final_pass) const {
     auto& val_i         = m_first_from[i];
     const auto& val_ip1 = m_first_from[i + 1];
@@ -64,9 +65,9 @@ struct StdUniqueFunctor {
 };
 
 template <class ExecutionSpace, class IteratorType, class PredicateType>
-IteratorType unique_impl(const std::string& label, const ExecutionSpace& ex,
-                         IteratorType first, IteratorType last,
-                         PredicateType pred) {
+IteratorType unique_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, IteratorType first,
+                                  IteratorType last, PredicateType pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first);
   Impl::expect_valid_range(first, last);
@@ -104,27 +105,25 @@ IteratorType unique_impl(const std::string& label, const ExecutionSpace& ex,
       // using the same algorithm used for unique_copy but we now move things
       using value_type    = typename IteratorType::value_type;
       using tmp_view_type = Kokkos::View<value_type*, ExecutionSpace>;
-      tmp_view_type tmp_view("std_unique_tmp_view", num_elements_to_explore);
+      tmp_view_type tmp_view(Kokkos::view_alloc(ex, Kokkos::WithoutInitializing,
+                                                "std_unique_tmp_view"),
+                             num_elements_to_explore);
 
       // scan extent is: num_elements_to_explore - 1
       // for same reason as the one explained in unique_copy
       const auto scan_size = num_elements_to_explore - 1;
       auto tmp_first       = ::Kokkos::Experimental::begin(tmp_view);
-      using output_it      = decltype(tmp_first);
 
       using index_type = typename IteratorType::difference_type;
-      using func_type =
-          StdUniqueFunctor<index_type, IteratorType, output_it, PredicateType>;
       index_type count = 0;
       ::Kokkos::parallel_scan(
           label, RangePolicy<ExecutionSpace>(ex, 0, scan_size),
-          func_type(it_found, last, tmp_first, pred), count);
+          StdUniqueFunctor(it_found, last, tmp_first, pred), count);
 
       // move last element too, for the same reason as the unique_copy
-      auto unused_r =
-          Impl::move_impl("Kokkos::move_from_unique", ex, it_found + scan_size,
-                          last, tmp_first + count);
-      (void)unused_r;  // r1 not used
+      [[maybe_unused]] auto unused_r = Impl::move_exespace_impl(
+          "Kokkos::move_from_unique", ex, it_found + scan_size, last,
+          tmp_first + count);
 
       // ----------
       // step 3
@@ -151,11 +150,69 @@ IteratorType unique_impl(const std::string& label, const ExecutionSpace& ex,
 }
 
 template <class ExecutionSpace, class IteratorType>
-IteratorType unique_impl(const std::string& label, const ExecutionSpace& ex,
-                         IteratorType first, IteratorType last) {
+IteratorType unique_exespace_impl(const std::string& label,
+                                  const ExecutionSpace& ex, IteratorType first,
+                                  IteratorType last) {
   using value_type    = typename IteratorType::value_type;
   using binary_pred_t = StdAlgoEqualBinaryPredicate<value_type>;
-  return unique_impl(label, ex, first, last, binary_pred_t());
+  return unique_exespace_impl(label, ex, first, last, binary_pred_t());
+}
+
+//
+// team level
+//
+template <class TeamHandleType, class IteratorType, class PredicateType>
+KOKKOS_FUNCTION IteratorType unique_team_impl(const TeamHandleType& teamHandle,
+                                              IteratorType first,
+                                              IteratorType last,
+                                              PredicateType pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  // branch for trivial vs non trivial case
+  const auto num_elements = Kokkos::Experimental::distance(first, last);
+  if (num_elements == 0) {
+    return first;
+  } else if (num_elements == 1) {
+    return last;
+  } else {
+    // FIXME: for the execution-space-based impl we used an auxiliary
+    // allocation, but for the team level we cannot do the same, so do this
+    // serially for now and later figure out if this can be done in parallel
+
+    std::size_t count = 0;
+    Kokkos::single(
+        Kokkos::PerTeam(teamHandle),
+        [=](std::size_t& lcount) {
+          IteratorType result = first;
+          IteratorType lfirst = first;
+          while (++lfirst != last) {
+            if (!pred(*result, *lfirst) && ++result != lfirst) {
+              *result = std::move(*lfirst);
+            }
+          }
+          lcount = Kokkos::Experimental::distance(first, result);
+        },
+        count);
+    // no barrier needed since single above broadcasts to all members
+
+    // +1 is needed because we want one element past the end
+    return first + count + 1;
+  }
+}
+
+template <class TeamHandleType, class IteratorType>
+KOKKOS_FUNCTION IteratorType unique_team_impl(const TeamHandleType& teamHandle,
+                                              IteratorType first,
+                                              IteratorType last) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first);
+  Impl::expect_valid_range(first, last);
+
+  using binary_pred_t =
+      StdAlgoEqualBinaryPredicate<typename IteratorType::value_type>;
+  return unique_team_impl(teamHandle, first, last, binary_pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/src/std_algorithms/impl/Kokkos_UniqueCopy.hpp b/algorithms/src/std_algorithms/impl/Kokkos_UniqueCopy.hpp
index d0aa1ed1d0..710d04805d 100644
--- a/algorithms/src/std_algorithms/impl/Kokkos_UniqueCopy.hpp
+++ b/algorithms/src/std_algorithms/impl/Kokkos_UniqueCopy.hpp
@@ -20,6 +20,7 @@
 #include <Kokkos_Core.hpp>
 #include "Kokkos_Constraints.hpp"
 #include "Kokkos_HelperPredicates.hpp"
+#include "Kokkos_MustUseKokkosSingleInTeam.hpp"
 #include "Kokkos_CopyCopyN.hpp"
 #include <std_algorithms/Kokkos_Distance.hpp>
 #include <string>
@@ -28,9 +29,9 @@ namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
-template <class IndexType, class InputIt, class OutputIt,
-          class BinaryPredicateType>
+template <class InputIt, class OutputIt, class BinaryPredicateType>
 struct StdUniqueCopyFunctor {
+  using index_type = typename InputIt::difference_type;
   InputIt m_first_from;
   InputIt m_last_from;
   OutputIt m_first_dest;
@@ -45,7 +46,7 @@ struct StdUniqueCopyFunctor {
         m_pred(std::move(pred)) {}
 
   KOKKOS_FUNCTION
-  void operator()(const IndexType i, IndexType& update,
+  void operator()(const index_type i, std::size_t& update,
                   const bool final_pass) const {
     const auto& val_i   = m_first_from[i];
     const auto& val_ip1 = m_first_from[i + 1];
@@ -64,10 +65,9 @@ struct StdUniqueCopyFunctor {
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator,
           class PredicateType>
-OutputIterator unique_copy_impl(const std::string& label,
-                                const ExecutionSpace& ex, InputIterator first,
-                                InputIterator last, OutputIterator d_first,
-                                PredicateType pred) {
+OutputIterator unique_copy_exespace_impl(
+    const std::string& label, const ExecutionSpace& ex, InputIterator first,
+    InputIterator last, OutputIterator d_first, PredicateType pred) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
@@ -78,38 +78,120 @@ OutputIterator unique_copy_impl(const std::string& label,
   if (num_elements == 0) {
     return d_first;
   } else if (num_elements == 1) {
-    return Impl::copy_impl("Kokkos::copy_from_unique_copy", ex, first, last,
-                           d_first);
+    return Impl::copy_exespace_impl("Kokkos::copy_from_unique_copy", ex, first,
+                                    last, d_first);
   } else {
-    // aliases
-    using index_type = typename InputIterator::difference_type;
-    using func_type  = StdUniqueCopyFunctor<index_type, InputIterator,
-                                           OutputIterator, PredicateType>;
-
     // note here that we run scan for num_elements - 1
     // because of the way we implement this, the last element is always needed.
     // We avoid performing checks inside functor that we are within limits
     // and run a "safe" scan and then copy the last element.
     const auto scan_size = num_elements - 1;
-    index_type count     = 0;
-    ::Kokkos::parallel_scan(label,
-                            RangePolicy<ExecutionSpace>(ex, 0, scan_size),
-                            func_type(first, last, d_first, pred), count);
-
-    return Impl::copy_impl("Kokkos::copy_from_unique_copy", ex,
-                           first + scan_size, last, d_first + count);
+    std::size_t count    = 0;
+    ::Kokkos::parallel_scan(
+        label, RangePolicy<ExecutionSpace>(ex, 0, scan_size),
+        // use CTAD
+        StdUniqueCopyFunctor(first, last, d_first, pred), count);
+
+    return Impl::copy_exespace_impl("Kokkos::copy_from_unique_copy", ex,
+                                    first + scan_size, last, d_first + count);
   }
 }
 
 template <class ExecutionSpace, class InputIterator, class OutputIterator>
-OutputIterator unique_copy_impl(const std::string& label,
-                                const ExecutionSpace& ex, InputIterator first,
-                                InputIterator last, OutputIterator d_first) {
+OutputIterator unique_copy_exespace_impl(const std::string& label,
+                                         const ExecutionSpace& ex,
+                                         InputIterator first,
+                                         InputIterator last,
+                                         OutputIterator d_first) {
   // checks
   Impl::static_assert_random_access_and_accessible(ex, first, d_first);
   Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
   Impl::expect_valid_range(first, last);
 
+  // aliases
+  using value_type1   = typename InputIterator::value_type;
+  using value_type2   = typename OutputIterator::value_type;
+  using binary_pred_t = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
+
+  // run
+  return unique_copy_exespace_impl(label, ex, first, last, d_first,
+                                   binary_pred_t());
+}
+
+//
+// team level
+//
+
+template <class TeamHandleType, class InputIterator, class OutputIterator,
+          class PredicateType>
+KOKKOS_FUNCTION OutputIterator unique_copy_team_impl(
+    const TeamHandleType& teamHandle, InputIterator first, InputIterator last,
+    OutputIterator d_first, PredicateType pred) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+
+  // branch for trivial vs non trivial case
+  const std::size_t num_elements = Kokkos::Experimental::distance(first, last);
+  if (num_elements == 0) {
+    return d_first;
+  } else if (num_elements == 1) {
+    d_first[0] = first[0];
+    return d_first + 1;
+  }
+
+  else {
+    if constexpr (stdalgo_must_use_kokkos_single_for_team_scan_v<
+                      typename TeamHandleType::execution_space>) {
+      std::size_t count = 0;
+      Kokkos::single(
+          Kokkos::PerTeam(teamHandle),
+          [=](std::size_t& lcount) {
+            lcount = 0;
+            for (std::size_t i = 0; i < num_elements - 1; ++i) {
+              const auto& val_i   = first[i];
+              const auto& val_ip1 = first[i + 1];
+              if (!pred(val_i, val_ip1)) {
+                d_first[lcount++] = val_i;
+              }
+            }
+            // we need to copy the last element always
+            d_first[lcount++] = first[num_elements - 1];
+          },
+          count);
+      // no barrier needed since single above broadcasts to all members
+
+      return d_first + count;
+    } else {
+      const auto scan_size = num_elements - 1;
+      std::size_t count    = 0;
+      ::Kokkos::parallel_scan(TeamThreadRange(teamHandle, 0, scan_size),
+                              StdUniqueCopyFunctor(first, last, d_first, pred),
+                              count);
+      // no barrier needed since reducing into count
+
+      return Impl::copy_team_impl(teamHandle, first + scan_size, last,
+                                  d_first + count);
+    }
+
+#if defined KOKKOS_COMPILER_INTEL ||                                  \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+    __builtin_unreachable();
+#endif
+  }
+}
+
+template <class TeamHandleType, class InputIterator, class OutputIterator>
+KOKKOS_FUNCTION OutputIterator
+unique_copy_team_impl(const TeamHandleType& teamHandle, InputIterator first,
+                      InputIterator last, OutputIterator d_first) {
+  // checks
+  Impl::static_assert_random_access_and_accessible(teamHandle, first, d_first);
+  Impl::static_assert_iterators_have_matching_difference_type(first, d_first);
+  Impl::expect_valid_range(first, last);
+
   // aliases
   using value_type1 = typename InputIterator::value_type;
   using value_type2 = typename OutputIterator::value_type;
@@ -118,7 +200,8 @@ OutputIterator unique_copy_impl(const std::string& label,
   using binary_pred_t = StdAlgoEqualBinaryPredicate<value_type1, value_type2>;
 
   // run
-  return unique_copy_impl(label, ex, first, last, d_first, binary_pred_t());
+  return unique_copy_team_impl(teamHandle, first, last, d_first,
+                               binary_pred_t());
 }
 
 }  // namespace Impl
diff --git a/algorithms/unit_tests/CMakeLists.txt b/algorithms/unit_tests/CMakeLists.txt
index 92d9f072c1..db184bc8a9 100644
--- a/algorithms/unit_tests/CMakeLists.txt
+++ b/algorithms/unit_tests/CMakeLists.txt
@@ -25,6 +25,8 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
     set(ALGO_SORT_SOURCES)
     foreach(SOURCE_Input
 	TestSort
+	TestSortByKey
+	TestSortCustomComp
 	TestBinSortA
 	TestBinSortB
 	TestNestedSort
@@ -56,35 +58,37 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
       configure_file(${dir}/dummy.cpp ${file})
       list(APPEND ALGO_RANDOM_SOURCES ${file})
     endforeach()
+  endif()
+endforeach()
 
-    # ------------------------------------------
-    # std set A
-    # ------------------------------------------
-    set(STDALGO_SOURCES_A)
-    foreach(Name
+# ------------------------------------------
+# std set A
+# ------------------------------------------
+set(STDALGO_SOURCES_A)
+foreach(Name
 	StdReducers
 	StdAlgorithmsConstraints
 	RandomAccessIterator
-	)
-      list(APPEND STDALGO_SOURCES_A Test${Name}.cpp)
-    endforeach()
+  )
+  list(APPEND STDALGO_SOURCES_A Test${Name}.cpp)
+endforeach()
 
-    # ------------------------------------------
-    # std set B
-    # ------------------------------------------
-    set(STDALGO_SOURCES_B)
-    foreach(Name
+# ------------------------------------------
+# std set B
+# ------------------------------------------
+set(STDALGO_SOURCES_B)
+foreach(Name
 	StdAlgorithmsCommon
 	StdAlgorithmsMinMaxElementOps
-	)
-      list(APPEND STDALGO_SOURCES_B Test${Name}.cpp)
-    endforeach()
+  )
+  list(APPEND STDALGO_SOURCES_B Test${Name}.cpp)
+endforeach()
 
-    # ------------------------------------------
-    # std set C
-    # ------------------------------------------
-    set(STDALGO_SOURCES_C)
-    foreach(Name
+# ------------------------------------------
+# std set C
+# ------------------------------------------
+set(STDALGO_SOURCES_C)
+foreach(Name
 	StdAlgorithmsCommon
 	StdAlgorithmsLexicographicalCompare
 	StdAlgorithmsForEach
@@ -99,15 +103,15 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
 	StdAlgorithmsSearch_n
 	StdAlgorithmsMismatch
 	StdAlgorithmsMoveBackward
-	)
-      list(APPEND STDALGO_SOURCES_C Test${Name}.cpp)
-    endforeach()
+  )
+  list(APPEND STDALGO_SOURCES_C Test${Name}.cpp)
+endforeach()
 
-    # ------------------------------------------
-    # std set D
-    # ------------------------------------------
-    set(STDALGO_SOURCES_D)
-    foreach(Name
+# ------------------------------------------
+# std set D
+# ------------------------------------------
+set(STDALGO_SOURCES_D)
+foreach(Name
 	StdAlgorithmsCommon
 	StdAlgorithmsModOps
 	StdAlgorithmsModSeqOps
@@ -127,15 +131,15 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
 	StdAlgorithmsReverse
 	StdAlgorithmsShiftLeft
 	StdAlgorithmsShiftRight
-	)
-      list(APPEND STDALGO_SOURCES_D Test${Name}.cpp)
-    endforeach()
+  )
+  list(APPEND STDALGO_SOURCES_D Test${Name}.cpp)
+endforeach()
 
-    # ------------------------------------------
-    # std set E
-    # ------------------------------------------
-    set(STDALGO_SOURCES_E)
-    foreach(Name
+# ------------------------------------------
+# std set E
+# ------------------------------------------
+set(STDALGO_SOURCES_E)
+foreach(Name
 	StdAlgorithmsCommon
 	StdAlgorithmsIsSorted
 	StdAlgorithmsIsSortedUntil
@@ -148,13 +152,235 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;HIP;SYCL;OpenMPTarget)
 	StdAlgorithmsTransformUnaryOp
 	StdAlgorithmsTransformExclusiveScan
 	StdAlgorithmsTransformInclusiveScan
-	)
-      list(APPEND STDALGO_SOURCES_E Test${Name}.cpp)
-    endforeach()
+  )
+  list(APPEND STDALGO_SOURCES_E Test${Name}.cpp)
+endforeach()
 
-  endif()
+# ------------------------------------------
+# std team Q
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_Q)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamInclusiveScan
+	StdAlgorithmsTeamTransformInclusiveScan
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_Q Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team P
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_P)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamExclusiveScan
+	StdAlgorithmsTeamTransformExclusiveScan
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_P Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team M
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_M)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamTransformUnaryOp
+	StdAlgorithmsTeamTransformBinaryOp
+	StdAlgorithmsTeamGenerate
+	StdAlgorithmsTeamGenerate_n
+	StdAlgorithmsTeamSwapRanges
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_M Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team L
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_L)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamIsSorted
+	StdAlgorithmsTeamIsSortedUntil
+	StdAlgorithmsTeamIsPartitioned
+	StdAlgorithmsTeamPartitionCopy
+	StdAlgorithmsTeamPartitionPoint
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_L Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team I
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_I)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamUnique
+	StdAlgorithmsTeamAdjacentDifference
+	StdAlgorithmsTeamReduce
+	StdAlgorithmsTeamTransformReduce
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_I Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team H
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_H)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamCopy
+	StdAlgorithmsTeamCopy_n
+	StdAlgorithmsTeamCopyBackward
+	StdAlgorithmsTeamCopyIf
+	StdAlgorithmsTeamUniqueCopy
+	StdAlgorithmsTeamRemove
+	StdAlgorithmsTeamRemoveIf
+	StdAlgorithmsTeamRemoveCopy
+	StdAlgorithmsTeamRemoveCopyIf
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_H Test${Name}.cpp)
 endforeach()
 
+# ------------------------------------------
+# std team G
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_G)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamMove
+	StdAlgorithmsTeamMoveBackward
+	StdAlgorithmsTeamShiftLeft
+	StdAlgorithmsTeamShiftRight
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_G Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team F
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_F)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamReverse
+	StdAlgorithmsTeamReverseCopy
+	StdAlgorithmsTeamRotate
+	StdAlgorithmsTeamRotateCopy
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_F Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team E
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_E)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamFill
+	StdAlgorithmsTeamFill_n
+	StdAlgorithmsTeamReplace
+	StdAlgorithmsTeamReplaceIf
+	StdAlgorithmsTeamReplaceCopy
+	StdAlgorithmsTeamReplaceCopyIf
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_E Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team D
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_D)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamMinElement
+	StdAlgorithmsTeamMaxElement
+	StdAlgorithmsTeamMinMaxElement
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_D Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team C
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_C)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamFind
+	StdAlgorithmsTeamFindIf
+	StdAlgorithmsTeamFindIfNot
+	StdAlgorithmsTeamAllOf
+	StdAlgorithmsTeamAnyOf
+	StdAlgorithmsTeamNoneOf
+	StdAlgorithmsTeamSearchN
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_C Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team B
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_B)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamEqual
+	StdAlgorithmsTeamSearch
+	StdAlgorithmsTeamFindEnd
+	StdAlgorithmsTeamFindFirstOf
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_B Test${Name}.cpp)
+endforeach()
+
+# ------------------------------------------
+# std team A
+# ------------------------------------------
+set(STDALGO_TEAM_SOURCES_A)
+foreach(Name
+	StdAlgorithmsCommon
+	StdAlgorithmsTeamAdjacentFind
+	StdAlgorithmsTeamCount
+	StdAlgorithmsTeamCountIf
+	StdAlgorithmsTeamForEach
+	StdAlgorithmsTeamForEachN
+	StdAlgorithmsTeamLexicographicalCompare
+	StdAlgorithmsTeamMismatch
+  )
+  list(APPEND STDALGO_TEAM_SOURCES_A Test${Name}.cpp)
+endforeach()
+
+# FIXME_OPENMPTARGET - remove sort test as it leads to ICE with clang/16 and above at compile time.
+if(KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL "Clang" AND KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0.0)
+    list(REMOVE_ITEM ALGO_SORT_SOURCES
+    TestSort.cpp
+  )
+endif()
+
+# FIXME_OPENMPTARGET remove tests for OpenMPTarget because in these cases
+# the impl needs to use either Kokkos or tailored reducers
+# which results in runtime memory errors.
+if(KOKKOS_ENABLE_OPENMPTARGET)
+  list(REMOVE_ITEM STDALGO_TEAM_SOURCES_L
+    TestStdAlgorithmsTeamIsPartitioned.cpp
+    TestStdAlgorithmsTeamPartitionPoint.cpp
+    TestStdAlgorithmsTeamPartitionCopy.cpp
+  )
+endif()
+
+# FIXME_OPENMPTARGET need to remove tests for OpenMPTarget because
+# in these cases the impl needs to use either Kokkos or
+# tailored reducers which results in runtime memory errors.
+if(KOKKOS_ENABLE_OPENMPTARGET)
+  list(REMOVE_ITEM STDALGO_TEAM_SOURCES_C
+    TestStdAlgorithmsTeamFind.cpp
+    TestStdAlgorithmsTeamFindIf.cpp
+    TestStdAlgorithmsTeamFindIfNot.cpp
+    TestStdAlgorithmsTeamAllOf.cpp
+    TestStdAlgorithmsTeamAnyOf.cpp
+    TestStdAlgorithmsTeamNoneOf.cpp
+    TestStdAlgorithmsTeamSearchN.cpp
+  )
+endif()
+
 # 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
@@ -164,6 +390,7 @@ if(NOT (KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM
     UnitTest_Sort
     SOURCES
     UnitTestMain.cpp
+    TestStdAlgorithmsCommon.cpp
     ${ALGO_SORT_SOURCES}
   )
 
@@ -175,7 +402,7 @@ if(NOT (KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM
   )
 endif()
 
-# FIXME_OPENMPTARGET These tests cause internal compiler errors as of 09/01/22
+# 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)
   list(REMOVE_ITEM STDALGO_SOURCES_D
@@ -190,6 +417,30 @@ if(KOKKOS_ENABLE_OPENMPTARGET AND KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM)
   )
 endif()
 
+# FIXME_OPENMPTARGET remove tests for OpenMPTarget
+# causing failures for various reasons
+if(KOKKOS_ENABLE_OPENMPTARGET)
+  # the following use either Kokkos or tailored reducers
+  # which results in runtime memory errors.
+  list(REMOVE_ITEM STDALGO_TEAM_SOURCES_B
+    TestStdAlgorithmsTeamFindEnd.cpp
+    TestStdAlgorithmsTeamFindFirstOf.cpp
+    TestStdAlgorithmsTeamSearch.cpp
+  )
+
+  list(REMOVE_ITEM STDALGO_TEAM_SOURCES_A
+    TestStdAlgorithmsTeamAdjacentFind.cpp
+    TestStdAlgorithmsTeamLexicographicalCompare.cpp
+    TestStdAlgorithmsTeamMismatch.cpp
+  )
+
+  # this causes an illegal memory access if team_members_have_matching_result
+  # is called
+  list(REMOVE_ITEM STDALGO_TEAM_SOURCES_M
+    TestStdAlgorithmsTeamTransformBinaryOp.cpp
+  )
+endif()
+
 foreach(ID A;B;C;D;E)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
     AlgorithmsUnitTest_StdSet_${ID}
@@ -199,6 +450,15 @@ foreach(ID A;B;C;D;E)
     )
 endforeach()
 
+foreach(ID A;B;C;D;E;F;G;H;I;L;M;P;Q)
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    AlgorithmsUnitTest_StdSet_Team_${ID}
+    SOURCES
+    UnitTestMain.cpp
+    ${STDALGO_TEAM_SOURCES_${ID}}
+    )
+endforeach()
+
 # 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))
diff --git a/algorithms/unit_tests/Makefile b/algorithms/unit_tests/Makefile
index 9e0f1d60a0..d3946c149b 100644
--- a/algorithms/unit_tests/Makefile
+++ b/algorithms/unit_tests/Makefile
@@ -27,42 +27,48 @@ 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 "$(H)include <Test"${device}"_Category.hpp>" > Test$(device).cpp); \
+     $(shell echo "$(H)include <TestRandom.hpp>" >> Test$(device).cpp); \
+     $(shell echo "$(H)include <TestSort.hpp>" >> Test$(device).cpp); \
+     $(shell echo "$(H)include <TestBinSortA.hpp>" >> Test$(device).cpp); \
+     $(shell echo "$(H)include <TestBinSortB.hpp>" >> Test$(device).cpp); \
+     $(shell echo "$(H)include <TestNestedSort.hpp>" >> Test$(device).cpp); \
+     $(shell echo "$(H)include <TestSortCustomComp.hpp>" >> Test$(device).cpp); \
    ) \
 )
 
 ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
-	OBJ_CUDA = TestCuda.o UnitTestMain.o gtest-all.o
+	OBJ_CUDA = TestCuda.o TestStdAlgorithmsCommon.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_Cuda
 	TEST_TARGETS += test-cuda
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
-	OBJ_HIP = TestHIP.o UnitTestMain.o gtest-all.o
+	OBJ_HIP = TestHIP.o TestStdAlgorithmsCommon.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_HIP
 	TEST_TARGETS += test-hip
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
-	OBJ_THREADS = TestThreads.o UnitTestMain.o gtest-all.o
+	OBJ_THREADS = TestThreads.o TestStdAlgorithmsCommon.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_Threads
 	TEST_TARGETS += test-threads
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
-	OBJ_OPENMP = TestOpenMP.o UnitTestMain.o gtest-all.o
+	OBJ_OPENMP = TestOpenMP.o TestStdAlgorithmsCommon.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_OpenMP
 	TEST_TARGETS += test-openmp
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
-	OBJ_HPX = TestHPX.o UnitTestMain.o gtest-all.o
+	OBJ_HPX = TestHPX.o TestStdAlgorithmsCommon.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_HPX
 	TEST_TARGETS += test-hpx
 endif
 
 ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
-	OBJ_SERIAL = TestSerial.o UnitTestMain.o gtest-all.o
+	OBJ_SERIAL = TestSerial.o TestStdAlgorithmsCommon.o UnitTestMain.o gtest-all.o
 	TARGETS += KokkosAlgorithms_UnitTest_Serial
 	TEST_TARGETS += test-serial
 endif
diff --git a/algorithms/unit_tests/TestBinSortA.hpp b/algorithms/unit_tests/TestBinSortA.hpp
index 46f6486cdc..dd3569e671 100644
--- a/algorithms/unit_tests/TestBinSortA.hpp
+++ b/algorithms/unit_tests/TestBinSortA.hpp
@@ -223,18 +223,8 @@ TEST(TEST_CATEGORY, BinSortGenericTests) {
   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_3D_sort_impl<ExecutionSpace, key_type>(N);
+  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>();
diff --git a/algorithms/unit_tests/TestBinSortB.hpp b/algorithms/unit_tests/TestBinSortB.hpp
index 0707411f59..a90224bf31 100644
--- a/algorithms/unit_tests/TestBinSortB.hpp
+++ b/algorithms/unit_tests/TestBinSortB.hpp
@@ -22,77 +22,13 @@
 #include <Kokkos_Random.hpp>
 #include <Kokkos_Sort.hpp>
 #include <Kokkos_StdAlgorithms.hpp>
-#include <TestStdAlgorithmsHelperFunctors.hpp>
+#include <TestStdAlgorithmsCommon.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) {
@@ -171,9 +107,9 @@ void test_on_view_with_stride(std::size_t numRows, std::size_t indB,
 
   Kokkos::Random_XorShift64_Pool<ExecutionSpace> pool(73931);
   Kokkos::fill_random(v, pool, ValueType(545));
-  auto v_before_sort_h = create_host_space_copy(v);
+  auto v_before_sort_h = stdalgos::create_host_space_copy(v);
   sorter.sort(exec, v, indB, indE);
-  auto v_after_sort_h = create_host_space_copy(v);
+  auto v_after_sort_h = stdalgos::create_host_space_copy(v);
 
   for (size_t i = 0; i < v.extent(0); ++i) {
     // if i within [indB,indE), the sorting was done
diff --git a/algorithms/unit_tests/TestRandom.hpp b/algorithms/unit_tests/TestRandom.hpp
index e9dc3327a6..472af1403b 100644
--- a/algorithms/unit_tests/TestRandom.hpp
+++ b/algorithms/unit_tests/TestRandom.hpp
@@ -27,6 +27,9 @@
 #include <Kokkos_Random.hpp>
 #include <cmath>
 #include <chrono>
+#include <vector>
+#include <algorithm>
+#include <numeric>
 
 namespace Test {
 namespace AlgoRandomImpl {
@@ -469,6 +472,73 @@ struct TestDynRankView {
   }
 };
 
+template <class ExecutionSpace, class GeneratorPool>
+struct generate_random_stream {
+  using ViewType = Kokkos::View<uint64_t**, ExecutionSpace>;
+
+  ViewType vals;
+  GeneratorPool rand_pool;
+  int samples;
+
+  generate_random_stream(ViewType vals_, GeneratorPool rand_pool_, int samples_)
+      : vals(vals_), rand_pool(rand_pool_), samples(samples_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i) const {
+    typename GeneratorPool::generator_type rand_gen = rand_pool.get_state();
+
+    for (int k = 0; k < samples; k++) vals(i, k) = rand_gen.urand64();
+
+    rand_pool.free_state(rand_gen);
+  }
+};
+
+// NOTE: this doesn't test the statistical independence of multiple streams
+// generated by a Random pool, it only tests for complete duplicates.
+template <class ExecutionSpace, class Pool>
+void test_duplicate_stream() {
+  using ViewType = Kokkos::View<uint64_t**, ExecutionSpace>;
+
+  // Heuristic to create a "large enough" number of streams.
+  int n_streams = ExecutionSpace{}.concurrency() * 4;
+  int samples   = 8;
+
+  Pool rand_pool(42);
+  ViewType vals_d("Vals", n_streams, samples);
+
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecutionSpace>(0, n_streams),
+      generate_random_stream<ExecutionSpace, Pool>(vals_d, rand_pool, samples));
+
+  auto vals_h =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, vals_d);
+
+  /*
+  To quickly find streams that are identical, we sort them by the first number,
+  if that's equal then the second and so on. We then test each neighbor pair
+  for duplicates.
+  */
+  std::vector<size_t> indices(n_streams);
+  std::iota(indices.begin(), indices.end(), 0);
+
+  auto comparator = [&](size_t i, size_t j) {
+    for (int k = 0; k < samples; k++) {
+      if (vals_h(i, k) != vals_h(j, k)) return vals_h(i, k) < vals_h(j, k);
+    }
+    return false;
+  };
+  std::sort(indices.begin(), indices.end(), comparator);
+
+  for (int i = 0; i < n_streams - 1; i++) {
+    int idx1 = indices[i];
+    int idx2 = indices[i + 1];
+
+    int k = 0;
+    while (k < samples && vals_h(idx1, k) == vals_h(idx2, k)) k++;
+    ASSERT_LT(k, samples) << "Duplicate streams found";
+  }
+}
+
 }  // namespace AlgoRandomImpl
 
 TEST(TEST_CATEGORY, Random_XorShift64) {
@@ -509,5 +579,27 @@ TEST(TEST_CATEGORY, Random_XorShift1024_0) {
       .run();
 }
 
+TEST(TEST_CATEGORY, Multi_streams) {
+  using ExecutionSpace = TEST_EXECSPACE;
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+  if constexpr (std::is_same_v<ExecutionSpace,
+                               Kokkos::Experimental::OpenMPTarget>) {
+    GTEST_SKIP() << "Libomptarget error";  // FIXME_OPENMPTARGET
+  }
+#endif
+
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  if constexpr (std::is_same_v<ExecutionSpace, Kokkos::Experimental::SYCL>) {
+    GTEST_SKIP() << "Failing on NVIDIA GPUs";  // FIXME_SYCL
+  }
+#endif
+
+  using Pool64   = Kokkos::Random_XorShift64_Pool<ExecutionSpace>;
+  using Pool1024 = Kokkos::Random_XorShift1024_Pool<ExecutionSpace>;
+
+  AlgoRandomImpl::test_duplicate_stream<ExecutionSpace, Pool64>();
+  AlgoRandomImpl::test_duplicate_stream<ExecutionSpace, Pool1024>();
+}
+
 }  // namespace Test
 #endif
diff --git a/algorithms/unit_tests/TestRandomAccessIterator.cpp b/algorithms/unit_tests/TestRandomAccessIterator.cpp
index fd3a875b1e..7d484136b6 100644
--- a/algorithms/unit_tests/TestRandomAccessIterator.cpp
+++ b/algorithms/unit_tests/TestRandomAccessIterator.cpp
@@ -46,6 +46,44 @@ TEST_F(random_access_iterator_test, constructor) {
   EXPECT_TRUE(true);
 }
 
+TEST_F(random_access_iterator_test, constructiblity) {
+  auto first_d  = KE::begin(m_dynamic_view);
+  auto cfirst_d = KE::cbegin(m_dynamic_view);
+
+  static_assert(std::is_constructible_v<decltype(cfirst_d), decltype(first_d)>);
+  static_assert(
+      !std::is_constructible_v<decltype(first_d), decltype(cfirst_d)>);
+  [[maybe_unused]] decltype(cfirst_d) tmp_cfirst_d(first_d);
+
+  auto first_s  = KE::begin(m_static_view);
+  auto cfirst_s = KE::cbegin(m_static_view);
+
+  static_assert(std::is_constructible_v<decltype(cfirst_s), decltype(first_s)>);
+  static_assert(
+      !std::is_constructible_v<decltype(first_s), decltype(cfirst_s)>);
+  [[maybe_unused]] decltype(cfirst_s) tmp_cfirst_s(first_s);
+
+  auto first_st  = KE::begin(m_strided_view);
+  auto cfirst_st = KE::cbegin(m_strided_view);
+
+  static_assert(
+      std::is_constructible_v<decltype(cfirst_st), decltype(first_st)>);
+  static_assert(
+      !std::is_constructible_v<decltype(first_st), decltype(cfirst_st)>);
+  [[maybe_unused]] decltype(cfirst_st) tmp_cfirst_st(first_st);
+
+  // [FIXME] Better to have tests for the explicit specifier with an expression.
+  // As soon as View converting constructors are re-implemented with a
+  // conditional explicit, we may add those tests.
+  static_assert(std::is_constructible_v<decltype(first_s), decltype(first_d)>);
+  static_assert(std::is_constructible_v<decltype(first_st), decltype(first_d)>);
+  static_assert(std::is_constructible_v<decltype(first_d), decltype(first_s)>);
+  static_assert(std::is_constructible_v<decltype(first_st), decltype(first_s)>);
+  static_assert(std::is_constructible_v<decltype(first_d), decltype(first_st)>);
+  static_assert(std::is_constructible_v<decltype(first_s), decltype(first_st)>);
+  EXPECT_TRUE(true);
+}
+
 template <class IteratorType, class ValueType>
 void test_random_access_it_verify(IteratorType it, ValueType gold_value) {
   using view_t = Kokkos::View<typename IteratorType::value_type>;
@@ -217,5 +255,16 @@ TEST_F(random_access_iterator_test, distance) {
   ASSERT_EQ(m_dynamic_view.extent(0), size_t(KE::distance(first, last)));
 }
 
+TEST_F(random_access_iterator_test, traits_helpers) {
+  using T1_t = KE::Impl::RandomAccessIterator<static_view_t>;
+  using T2_t = KE::Impl::RandomAccessIterator<dyn_view_t>;
+  using T3_t = KE::Impl::RandomAccessIterator<strided_view_t>;
+
+  namespace KE = Kokkos::Experimental;
+  static_assert(KE::Impl::are_iterators_v<T1_t, T2_t, T3_t>);
+  static_assert(KE::Impl::are_random_access_iterators_v<T1_t, T2_t, T3_t>);
+  static_assert(!KE::Impl::are_iterators_v<int, T2_t, T3_t>);
+}
+
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestSortByKey.hpp b/algorithms/unit_tests/TestSortByKey.hpp
new file mode 100644
index 0000000000..9e5bd4a574
--- /dev/null
+++ b/algorithms/unit_tests/TestSortByKey.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
+
+#ifndef KOKKOS_ALGORITHMS_UNITTESTS_TEST_SORT_BY_KEY_HPP
+#define KOKKOS_ALGORITHMS_UNITTESTS_TEST_SORT_BY_KEY_HPP
+
+#include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
+#include <Kokkos_Random.hpp>
+#include <Kokkos_Sort.hpp>
+
+#include <utility>  // pair
+
+namespace Test {
+namespace SortImpl {
+
+struct Less {
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION bool operator()(const ValueType &lhs,
+                                         const ValueType &rhs) const {
+    return lhs < rhs;
+  }
+};
+
+struct Greater {
+  template <class ValueType>
+  KOKKOS_INLINE_FUNCTION bool operator()(const ValueType &lhs,
+                                         const ValueType &rhs) const {
+    return lhs > rhs;
+  }
+};
+
+template <class ExecutionSpace, class Keys, class Permute,
+          class Comparator = Less>
+struct is_sorted_by_key_struct {
+  Keys keys;
+  Keys keys_orig;
+  Permute permute;
+  Comparator comparator;
+
+  is_sorted_by_key_struct(Keys keys_, Keys keys_orig_, Permute permute_,
+                          Comparator comparator_ = Comparator{})
+      : keys(keys_),
+        keys_orig(keys_orig_),
+        permute(permute_),
+        comparator(comparator_) {}
+  KOKKOS_INLINE_FUNCTION
+  void operator()(int i, unsigned int &count) const {
+    if (i < keys.extent_int(0) - 1 && comparator(keys(i + 1), keys(i))) ++count;
+    if (keys(i) != keys_orig(permute(i))) ++count;
+  }
+};
+
+template <typename ExecutionSpace, typename ViewType>
+void iota(ExecutionSpace const &space, ViewType const &v,
+          typename ViewType::value_type value = 0) {
+  using ValueType = typename ViewType::value_type;
+  Kokkos::parallel_for(
+      "Kokkos::Algorithms::iota",
+      Kokkos::RangePolicy<ExecutionSpace>(space, 0, v.extent(0)),
+      KOKKOS_LAMBDA(int i) { v(i) = value + (ValueType)i; });
+}
+
+}  // namespace SortImpl
+
+TEST(TEST_CATEGORY, SortByKeyEmptyView) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  // does not matter if we use int or something else
+  Kokkos::View<int *, ExecutionSpace> keys("keys", 0);
+  Kokkos::View<float *, ExecutionSpace> values("values", 0);
+
+  ASSERT_NO_THROW(
+      Kokkos::Experimental::sort_by_key(ExecutionSpace(), keys, values));
+}
+
+// Test #7036
+TEST(TEST_CATEGORY, SortByKeyEmptyViewHost) {
+  using ExecutionSpace = Kokkos::DefaultHostExecutionSpace;
+
+  // does not matter if we use int or something else
+  Kokkos::View<int *, ExecutionSpace> keys("keys", 0);
+  Kokkos::View<float *, ExecutionSpace> values("values", 0);
+
+  ASSERT_NO_THROW(
+      Kokkos::Experimental::sort_by_key(ExecutionSpace(), keys, values));
+}
+
+TEST(TEST_CATEGORY, SortByKey) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using MemorySpace    = typename ExecutionSpace::memory_space;
+
+  ExecutionSpace space{};
+
+  for (auto keys_vector : {std::vector<int>{36, 19, 25, 17, 3, 7, 1, 2, 9},
+                           std::vector<int>{36, 19, 25, 17, 3, 9, 1, 2, 7},
+                           std::vector<int>{100, 19, 36, 17, 3, 25, 1, 2, 7},
+                           std::vector<int>{15, 5, 11, 3, 4, 8}}) {
+    auto const n = keys_vector.size();
+
+    auto keys = Kokkos::create_mirror_view_and_copy(
+        MemorySpace{},
+        Kokkos::View<int *, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>(
+            keys_vector.data(), n));
+
+    auto keys_orig = Kokkos::create_mirror(space, keys);
+    Kokkos::deep_copy(space, keys_orig, keys);
+
+    Kokkos::View<int *, ExecutionSpace> permute("permute", n);
+    SortImpl::iota(space, permute);
+
+    Kokkos::Experimental::sort_by_key(space, keys, permute);
+
+    unsigned int sort_fails = 0;
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<ExecutionSpace>(space, 0, n),
+        SortImpl::is_sorted_by_key_struct<ExecutionSpace, decltype(keys),
+                                          decltype(permute)>(keys, keys_orig,
+                                                             permute),
+        sort_fails);
+
+    ASSERT_EQ(sort_fails, 0u);
+  }
+}
+
+TEST(TEST_CATEGORY, SortByKeyWithComparator) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using MemorySpace    = typename ExecutionSpace::memory_space;
+
+  ExecutionSpace space{};
+
+  SortImpl::Greater comparator;
+
+  for (auto keys_vector : {std::vector<int>{36, 19, 25, 17, 3, 7, 1, 2, 9},
+                           std::vector<int>{36, 19, 25, 17, 3, 9, 1, 2, 7},
+                           std::vector<int>{100, 19, 36, 17, 3, 25, 1, 2, 7},
+                           std::vector<int>{15, 5, 11, 3, 4, 8}}) {
+    auto const n = keys_vector.size();
+
+    auto keys = Kokkos::create_mirror_view_and_copy(
+        MemorySpace{},
+        Kokkos::View<int *, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>(
+            keys_vector.data(), n));
+
+    auto keys_orig = Kokkos::create_mirror(space, keys);
+    Kokkos::deep_copy(space, keys_orig, keys);
+
+    Kokkos::View<int *, ExecutionSpace> permute("permute", n);
+    SortImpl::iota(space, permute);
+
+    Kokkos::Experimental::sort_by_key(space, keys, permute, comparator);
+
+    unsigned int sort_fails = 0;
+    Kokkos::parallel_reduce(
+        Kokkos::RangePolicy<ExecutionSpace>(space, 0, n),
+        SortImpl::is_sorted_by_key_struct<ExecutionSpace, decltype(keys),
+                                          decltype(permute), SortImpl::Greater>(
+            keys, keys_orig, permute, comparator),
+        sort_fails);
+
+    ASSERT_EQ(sort_fails, 0u);
+  }
+}
+
+TEST(TEST_CATEGORY, SortByKeyStaticExtents) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  ExecutionSpace space{};
+
+  Kokkos::View<int[10], ExecutionSpace> keys("keys");
+
+  Kokkos::View<int[10], ExecutionSpace> values_static("values_static");
+  ASSERT_NO_THROW(
+      Kokkos::Experimental::sort_by_key(space, keys, values_static));
+
+  Kokkos::View<int *, ExecutionSpace> values_dynamic("values_dynamic", 10);
+  ASSERT_NO_THROW(
+      Kokkos::Experimental::sort_by_key(space, keys, values_dynamic));
+}
+
+template <typename ExecutionSpace, typename Keys, typename Values>
+void buildViewsForStrided(ExecutionSpace const &space, int n, Keys &keys,
+                          Values &values) {
+  Kokkos::parallel_for(
+      "create_data",
+      Kokkos::MDRangePolicy<Kokkos::Rank<3>, ExecutionSpace>(space, {0, 0, 0},
+                                                             {n, n, n}),
+      KOKKOS_LAMBDA(int i, int j, int k) {
+        keys(i, j, k)   = n - i;
+        values(i, j, k) = j;
+      });
+}
+
+TEST(TEST_CATEGORY, SortByKeyWithStrides) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  ExecutionSpace space{};
+
+  auto const n = 10;
+
+  Kokkos::View<int ***, ExecutionSpace> keys("keys", n, n, n);
+  Kokkos::View<int ***, ExecutionSpace> values("values", n, n, n);
+  buildViewsForStrided(space, n, keys, values);
+
+  auto keys_sub   = Kokkos::subview(keys, Kokkos::ALL(), 1, 2);
+  auto values_sub = Kokkos::subview(values, 4, Kokkos::ALL(), 6);
+
+  auto keys_orig = Kokkos::create_mirror(space, keys_sub);
+  Kokkos::deep_copy(space, keys_orig, keys_sub);
+
+  Kokkos::Experimental::sort_by_key(space, keys_sub, values_sub);
+
+  unsigned int sort_fails = 0;
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecutionSpace>(space, 0, n),
+      SortImpl::is_sorted_by_key_struct<ExecutionSpace, decltype(keys_sub),
+                                        decltype(values_sub)>(
+          keys_sub, keys_orig, values_sub),
+      sort_fails);
+
+  ASSERT_EQ(sort_fails, 0u);
+}
+
+TEST(TEST_CATEGORY, SortByKeyKeysLargerThanValues) {
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  // does not matter if we use int or something else
+  Kokkos::View<int *, ExecutionSpace> keys("keys", 3);
+  Kokkos::View<float *, ExecutionSpace> values("values", 1);
+
+  ASSERT_DEATH(
+      Kokkos::Experimental::sort_by_key(ExecutionSpace(), keys, values),
+      "values and keys extents must be the same");
+  ASSERT_DEATH(Kokkos::Experimental::sort_by_key(ExecutionSpace(), keys, values,
+                                                 SortImpl::Greater{}),
+               "values and keys extents must be the same");
+}
+
+}  // namespace Test
+#endif
diff --git a/algorithms/unit_tests/TestSortCustomComp.hpp b/algorithms/unit_tests/TestSortCustomComp.hpp
new file mode 100644
index 0000000000..a29ee1edec
--- /dev/null
+++ b/algorithms/unit_tests/TestSortCustomComp.hpp
@@ -0,0 +1,133 @@
+//@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_SORT_CUSTOM_COMP_HPP
+#define KOKKOS_ALGORITHMS_UNITTESTS_TEST_SORT_CUSTOM_COMP_HPP
+
+#include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
+#include <Kokkos_Random.hpp>
+#include <Kokkos_Sort.hpp>
+#include <TestStdAlgorithmsCommon.hpp>
+
+namespace {
+namespace SortWithComp {
+
+template <class ExecutionSpace, class LayoutTagType, class ValueType>
+auto create_random_view_and_host_clone(
+    LayoutTagType LayoutTag, std::size_t n,
+    Kokkos::pair<ValueType, ValueType> bounds, const std::string& label,
+    std::size_t seedIn = 12371) {
+  using namespace ::Test::stdalgos;
+
+  using mem_space = typename ExecutionSpace::memory_space;
+  auto dataView   = create_view<ValueType, mem_space>(LayoutTag, n, label);
+
+  // dataView might not be deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to dataView
+
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  // randomly fill the view
+  Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+      seedIn);
+  Kokkos::fill_random(dataView_dc_h, pool, bounds.first, bounds.second);
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+  // use CTAD
+  CopyFunctor F1(dataView_dc, dataView);
+  Kokkos::RangePolicy<ExecutionSpace> policy(0, dataView.extent(0));
+  Kokkos::parallel_for("copy", policy, F1);
+
+  return std::make_pair(dataView, dataView_dc_h);
+}
+
+template <class T>
+struct MyComp {
+  KOKKOS_FUNCTION
+  bool operator()(T a, T b) const {
+    // we return a>b on purpose here, rather than doing a<b
+    return a > b;
+  }
+};
+
+// clang-format off
+template <class ExecutionSpace, class Tag, class ValueType>
+void run_all_scenarios(int api)
+{
+  using comp_t = MyComp<ValueType>;
+
+  const std::vector<std::size_t> my_scenarios = {0, 1, 2, 9, 1003, 51513};
+  for (std::size_t N : my_scenarios)
+  {
+    auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone<ExecutionSpace>(
+        Tag{}, N, Kokkos::pair<ValueType, ValueType>{-1045, 565},
+        "dataView");
+
+    namespace KE = Kokkos::Experimental;
+
+    if (api == 0) {
+      Kokkos::sort(dataView, comp_t{});
+      std::sort(KE::begin(dataViewBeforeOp_h), KE::end(dataViewBeforeOp_h),
+                comp_t{});
+    }
+
+    else if (api == 1) {
+      auto exespace = ExecutionSpace();
+      Kokkos::sort(exespace, dataView, comp_t{});
+      std::sort(KE::begin(dataViewBeforeOp_h), KE::end(dataViewBeforeOp_h),
+                comp_t{});
+      exespace.fence();
+    }
+
+    auto dataView_h = Test::stdalgos::create_host_space_copy(dataView);
+    Test::stdalgos::compare_views(dataViewBeforeOp_h, dataView_h);
+
+    // To actually check that Kokkos::sort used the custom
+    // comparator MyComp, we should have a result in non-ascending order.
+    // We can verify this by running std::is_sorted and if that returns
+    // false, then it means everything ran as expected.
+    // Note: std::is_sorted returns true for ranges of length one,
+    // so this check makes sense only when N >= 2.
+    if (N >= 2){
+      ASSERT_FALSE(std::is_sorted( KE::cbegin(dataView_h), KE::cend(dataView_h)));
+    }
+  }
+}
+
+TEST(TEST_CATEGORY, SortWithCustomComparator) {
+  using ExeSpace = TEST_EXECSPACE;
+  using namespace ::Test::stdalgos;
+  for (int api = 0; api < 2; api++) {
+    run_all_scenarios<ExeSpace, DynamicTag, int>(api);
+    run_all_scenarios<ExeSpace, DynamicTag, double>(api);
+    run_all_scenarios<ExeSpace, DynamicLayoutLeftTag, int>(api);
+    run_all_scenarios<ExeSpace, DynamicLayoutLeftTag, double>(api);
+    run_all_scenarios<ExeSpace, DynamicLayoutRightTag, int>(api);
+    run_all_scenarios<ExeSpace, DynamicLayoutRightTag, double>(api);
+    run_all_scenarios<ExeSpace, StridedThreeTag, int>(api);
+    run_all_scenarios<ExeSpace, StridedThreeTag, double>(api);
+  }
+}
+
+}  // namespace SortWithComp
+}  // namespace anonym
+#endif
diff --git a/algorithms/unit_tests/TestStdAlgorithmsCommon.cpp b/algorithms/unit_tests/TestStdAlgorithmsCommon.cpp
index 39a508bb8f..833145bdb4 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsCommon.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsCommon.cpp
@@ -21,9 +21,23 @@ namespace stdalgos {
 
 std::string view_tag_to_string(DynamicTag) { return "dynamic_view"; }
 
+std::string view_tag_to_string(DynamicLayoutLeftTag) {
+  return "dynamic_layout_left_view";
+}
+
+std::string view_tag_to_string(DynamicLayoutRightTag) {
+  return "dynamic_layout_right_view";
+}
+
 std::string view_tag_to_string(StridedTwoTag) { return "stride2_view"; }
 
 std::string view_tag_to_string(StridedThreeTag) { return "stride3_view"; }
 
+std::string view_tag_to_string(StridedTwoRowsTag) { return "stride2rows_view"; }
+
+std::string view_tag_to_string(StridedThreeRowsTag) {
+  return "stride3rows_view";
+}
+
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp b/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp
index 5b30b9eda7..67052e2f9d 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsCommon.hpp
@@ -18,7 +18,9 @@
 #define KOKKOS_ALGORITHMS_UNITTESTS_TEST_STD_ALGOS_COMMON_HPP
 
 #include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
 #include <Kokkos_StdAlgorithms.hpp>
+#include <Kokkos_Random.hpp>
 #include <TestStdAlgorithmsHelperFunctors.hpp>
 #include <utility>
 #include <numeric>
@@ -29,10 +31,30 @@ namespace stdalgos {
 
 using exespace = Kokkos::DefaultExecutionSpace;
 
+//
+// tags
+//
 struct DynamicTag {};
+struct DynamicLayoutLeftTag {};
+struct DynamicLayoutRightTag {};
+
+// these are for rank-1
 struct StridedTwoTag {};
 struct StridedThreeTag {};
 
+// these are for rank-2
+struct StridedTwoRowsTag {};
+struct StridedThreeRowsTag {};
+
+#ifndef _WIN32
+const std::vector<int> teamSizesToTest = {1, 2, 23, 77, 123};
+#else
+// avoid timeouts in AppVeyor CI
+const std::vector<int> teamSizesToTest = {1, 2, 23};
+#endif
+
+// map of scenarios where the key is a description
+// and the value is the extent
 const std::map<std::string, std::size_t> default_scenarios = {
     {"empty", 0},          {"one-element", 1}, {"two-elements-a", 2},
     {"two-elements-b", 2}, {"small-a", 9},     {"small-b", 13},
@@ -41,51 +63,460 @@ const std::map<std::string, std::size_t> default_scenarios = {
 
 // see cpp file for these functions
 std::string view_tag_to_string(DynamicTag);
+std::string view_tag_to_string(DynamicLayoutLeftTag);
+std::string view_tag_to_string(DynamicLayoutRightTag);
 std::string view_tag_to_string(StridedTwoTag);
 std::string view_tag_to_string(StridedThreeTag);
+std::string view_tag_to_string(StridedTwoRowsTag);
+std::string view_tag_to_string(StridedThreeRowsTag);
+
+//
+// overload set for create_view for rank1
+//
 
-template <class ValueType>
+// dynamic
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
 auto create_view(DynamicTag, std::size_t ext, const std::string label) {
-  using view_t = Kokkos::View<ValueType*>;
+  using view_t = Kokkos::View<ValueType*, MemSpace>;
   view_t view{label + "_" + view_tag_to_string(DynamicTag{}), ext};
   return view;
 }
 
-template <class ValueType>
+// dynamic layout left
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(DynamicLayoutLeftTag, std::size_t ext,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType*, Kokkos::LayoutLeft, MemSpace>;
+  view_t view{label + "_" + view_tag_to_string(DynamicLayoutLeftTag{}), ext};
+  return view;
+}
+
+// dynamic layout right
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(DynamicLayoutRightTag, std::size_t ext,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType*, Kokkos::LayoutRight, MemSpace>;
+  view_t view{label + "_" + view_tag_to_string(DynamicLayoutRightTag{}), ext};
+  return view;
+}
+
+// stride2
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
 auto create_view(StridedTwoTag, std::size_t ext, const std::string label) {
-  using view_t = Kokkos::View<ValueType*, Kokkos::LayoutStride>;
+  using view_t = Kokkos::View<ValueType*, Kokkos::LayoutStride, MemSpace>;
   Kokkos::LayoutStride layout{ext, 2};
-  view_t view{label + "_" + view_tag_to_string(DynamicTag{}), layout};
+  view_t view{label + "_" + view_tag_to_string(StridedTwoTag{}), layout};
   return view;
 }
 
-template <class ValueType>
+// stride3
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
 auto create_view(StridedThreeTag, std::size_t ext, const std::string label) {
-  using view_t = Kokkos::View<ValueType*, Kokkos::LayoutStride>;
+  using view_t = Kokkos::View<ValueType*, Kokkos::LayoutStride, MemSpace>;
   Kokkos::LayoutStride layout{ext, 3};
-  view_t view{label + "_" + view_tag_to_string(DynamicTag{}), layout};
+  view_t view{label + "_" + view_tag_to_string(StridedThreeTag{}), layout};
+  return view;
+}
+
+//
+// overload set for create_view for rank2
+//
+
+// dynamic
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(DynamicTag, std::size_t ext0, std::size_t ext1,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType**, MemSpace>;
+  view_t view{label + "_" + view_tag_to_string(DynamicTag{}), ext0, ext1};
+  return view;
+}
+
+// dynamic layout left
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(DynamicLayoutLeftTag, std::size_t ext0, std::size_t ext1,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType**, Kokkos::LayoutLeft, MemSpace>;
+  view_t view{label + "_" + view_tag_to_string(DynamicLayoutLeftTag{}), ext0,
+              ext1};
+  return view;
+}
+
+// dynamic layout right
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(DynamicLayoutRightTag, std::size_t ext0, std::size_t ext1,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType**, Kokkos::LayoutRight, MemSpace>;
+  view_t view{label + "_" + view_tag_to_string(DynamicLayoutRightTag{}), ext0,
+              ext1};
+  return view;
+}
+
+// stride2rows
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(StridedTwoRowsTag, std::size_t ext0, std::size_t ext1,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType**, Kokkos::LayoutStride, MemSpace>;
+  Kokkos::LayoutStride layout{ext0, 2, ext1, ext0 * 2};
+  view_t view{label + "_" + view_tag_to_string(StridedTwoRowsTag{}), layout};
+  return view;
+}
+
+// stride3rows
+template <class ValueType,
+          class MemSpace = typename Kokkos::DefaultExecutionSpace::memory_space>
+auto create_view(StridedThreeRowsTag, std::size_t ext0, std::size_t ext1,
+                 const std::string label) {
+  using view_t = Kokkos::View<ValueType**, Kokkos::LayoutStride, MemSpace>;
+  Kokkos::LayoutStride layout{ext0, 3, ext1, ext0 * 3};
+  view_t view{label + "_" + view_tag_to_string(StridedThreeRowsTag{}), layout};
   return view;
 }
 
 template <class ViewType>
 auto create_deep_copyable_compatible_view_with_same_extent(ViewType view) {
-  const std::size_t ext      = view.extent(0);
-  using view_value_type      = typename ViewType::value_type;
-  using view_exespace        = typename ViewType::execution_space;
-  using view_deep_copyable_t = Kokkos::View<view_value_type*, view_exespace>;
-  view_deep_copyable_t view_dc("view_dc", ext);
-  return view_dc;
+  using view_value_type  = typename ViewType::value_type;
+  using view_exespace    = typename ViewType::execution_space;
+  const std::size_t ext0 = view.extent(0);
+  if constexpr (ViewType::rank == 1) {
+    using view_deep_copyable_t = Kokkos::View<view_value_type*, view_exespace>;
+    return view_deep_copyable_t{"view_dc", ext0};
+  } else {
+    static_assert(ViewType::rank == 2, "Only rank 1 or 2 supported.");
+    using view_deep_copyable_t = Kokkos::View<view_value_type**, view_exespace>;
+    const std::size_t ext1     = view.extent(1);
+    return view_deep_copyable_t{"view_dc", ext0, ext1};
+  }
+
+  // this is needed for intel to avoid
+  // error #1011: missing return statement at end of non-void function
+#if defined KOKKOS_COMPILER_INTEL ||                                  \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 
 template <class ViewType>
 auto create_deep_copyable_compatible_clone(ViewType view) {
   auto view_dc    = create_deep_copyable_compatible_view_with_same_extent(view);
   using view_dc_t = decltype(view_dc);
-  CopyFunctor<ViewType, view_dc_t> F1(view, view_dc);
-  Kokkos::parallel_for("copy", view.extent(0), F1);
+  using exe_space = typename view_dc_t::execution_space;
+  if constexpr (ViewType::rank == 1) {
+    CopyFunctor<ViewType, view_dc_t> F1(view, view_dc);
+    Kokkos::RangePolicy<exe_space> policy(0, view.extent(0));
+    Kokkos::parallel_for("copy", policy, F1);
+
+  } else {
+    static_assert(ViewType::rank == 2, "Only rank 1 or 2 supported.");
+    CopyFunctorRank2<ViewType, view_dc_t> F1(view, view_dc);
+    Kokkos::RangePolicy<exe_space> policy(0, view.extent(0) * view.extent(1));
+    Kokkos::parallel_for("copy", policy, F1);
+  }
   return view_dc;
 }
 
+//
+// others
+//
+
+template <class TeamHandleType, class ValueType1, class ValueType2>
+KOKKOS_FUNCTION bool team_members_have_matching_result(
+    const TeamHandleType& teamHandle, const ValueType1 memberValueIn,
+    const ValueType2 targetIn) {
+  using T             = std::common_type_t<ValueType1, ValueType2>;
+  const T memberValue = memberValueIn;
+  const T target      = targetIn;
+
+  // set accum to 1 if a mismach is found
+  const bool mismatch = memberValue != target;
+  int accum           = static_cast<int>(mismatch);
+  teamHandle.team_reduce(Kokkos::Sum<int>(accum));
+  return (accum == 0);
+}
+
+template <class ValueType1, class ValueType2>
+auto make_bounds(const ValueType1& lower, const ValueType2 upper) {
+  return Kokkos::pair<ValueType1, ValueType2>{lower, upper};
+}
+
+// libstdc++ as provided by GCC 8 does not have reduce, transform_reduce,
+// exclusive_scan, inclusive_scan, transform_exclusive_scan,
+// transform_inclusive_scan and for GCC 9.1, 9.2 fails to compile them for
+// missing overload not accepting policy so use here simplified versions of
+// them, only for testing purpose
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+
+template <class InputIterator, class ValueType, class BinaryOp>
+ValueType testing_reduce(InputIterator first, InputIterator last,
+                         ValueType initIn, BinaryOp binOp) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+
+  while (last - first >= 4) {
+    ValueType v1 = binOp(first[0], first[1]);
+    ValueType v2 = binOp(first[2], first[3]);
+    ValueType v3 = binOp(v1, v2);
+    init         = binOp(init, v3);
+    first += 4;
+  }
+
+  for (; first != last; ++first) {
+    init = binOp(init, *first);
+  }
+
+  return init;
+}
+
+template <class InputIterator, class ValueType>
+ValueType testing_reduce(InputIterator first, InputIterator last,
+                         ValueType init) {
+  return testing_reduce(
+      first, last, init,
+      [](const ValueType& lhs, const ValueType& rhs) { return lhs + rhs; });
+}
+
+template <class InputIterator>
+auto testing_reduce(InputIterator first, InputIterator last) {
+  using ValueType = typename InputIterator::value_type;
+  return testing_reduce(
+      first, last, ValueType{},
+      [](const ValueType& lhs, const ValueType& rhs) { return lhs + rhs; });
+}
+
+template <class InputIterator1, class InputIterator2, class ValueType,
+          class BinaryJoiner, class BinaryTransform>
+ValueType testing_transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                                   InputIterator2 first2, ValueType initIn,
+                                   BinaryJoiner binJoiner,
+                                   BinaryTransform binTransform) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+
+  while (last1 - first1 >= 4) {
+    ValueType v1 = binJoiner(binTransform(first1[0], first2[0]),
+                             binTransform(first1[1], first2[1]));
+
+    ValueType v2 = binJoiner(binTransform(first1[2], first2[2]),
+                             binTransform(first1[3], first2[3]));
+
+    ValueType v3 = binJoiner(v1, v2);
+    init         = binJoiner(init, v3);
+
+    first1 += 4;
+    first2 += 4;
+  }
+
+  for (; first1 != last1; ++first1, ++first2) {
+    init = binJoiner(init, binTransform(*first1, *first2));
+  }
+
+  return init;
+}
+
+template <class InputIterator1, class InputIterator2, class ValueType>
+ValueType testing_transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                                   InputIterator2 first2, ValueType init) {
+  return testing_transform_reduce(
+      first1, last1, first2, init,
+      [](const ValueType& lhs, const ValueType& rhs) { return lhs + rhs; },
+      [](const ValueType& lhs, const ValueType& rhs) { return lhs * rhs; });
+}
+
+template <class InputIterator, class ValueType, class BinaryJoiner,
+          class UnaryTransform>
+ValueType testing_transform_reduce(InputIterator first, InputIterator last,
+                                   ValueType initIn, BinaryJoiner binJoiner,
+                                   UnaryTransform unaryTransform) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+
+  while (last - first >= 4) {
+    ValueType v1 =
+        binJoiner(unaryTransform(first[0]), unaryTransform(first[1]));
+    ValueType v2 =
+        binJoiner(unaryTransform(first[2]), unaryTransform(first[3]));
+    ValueType v3 = binJoiner(v1, v2);
+    init         = binJoiner(init, v3);
+    first += 4;
+  }
+
+  for (; first != last; ++first) {
+    init = binJoiner(init, unaryTransform(*first));
+  }
+
+  return init;
+}
+
+/*
+   EXCLUSIVE_SCAN
+ */
+template <class InputIterator, class OutputIterator, class ValueType,
+          class BinaryOp>
+OutputIterator testing_exclusive_scan(InputIterator first, InputIterator last,
+                                      OutputIterator result, ValueType initIn,
+                                      BinaryOp binOp) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+
+  while (first != last) {
+    auto v = init;
+    init   = binOp(init, *first);
+    ++first;
+    *result++ = v;
+  }
+
+  return result;
+}
+
+template <class InputIterator, class OutputIterator, class ValueType>
+OutputIterator testing_exclusive_scan(InputIterator first, InputIterator last,
+                                      OutputIterator result, ValueType init) {
+  return testing_exclusive_scan(
+      first, last, result, init,
+      [](const ValueType& lhs, const ValueType& rhs) { return lhs + rhs; });
+}
+
+/*
+   INCLUSIVE_SCAN
+ */
+template <class InputIterator, class OutputIterator, class BinaryOp,
+          class ValueType>
+OutputIterator testing_inclusive_scan(InputIterator first, InputIterator last,
+                                      OutputIterator result, BinaryOp binOp,
+                                      ValueType initIn) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+  for (; first != last; ++first) {
+    init      = binOp(init, *first);
+    *result++ = init;
+  }
+
+  return result;
+}
+
+template <class InputIterator, class OutputIterator, class BinaryOp>
+OutputIterator testing_inclusive_scan(InputIterator first, InputIterator last,
+                                      OutputIterator result, BinaryOp bop) {
+  if (first != last) {
+    auto init = *first;
+    *result++ = init;
+    ++first;
+    if (first != last) {
+      result = testing_inclusive_scan(first, last, result, bop, init);
+    }
+  }
+  return result;
+}
+
+template <class InputIterator, class OutputIterator>
+OutputIterator testing_inclusive_scan(InputIterator first, InputIterator last,
+                                      OutputIterator result) {
+  using ValueType = typename InputIterator::value_type;
+  return testing_inclusive_scan(
+      first, last, result,
+      [](const ValueType& lhs, const ValueType& rhs) { return lhs + rhs; });
+}
+
+/*
+   TRANSFORM_EXCLUSIVE_SCAN
+ */
+template <class InputIterator, class OutputIterator, class ValueType,
+          class BinaryOp, class UnaryOp>
+OutputIterator testing_transform_exclusive_scan(
+    InputIterator first, InputIterator last, OutputIterator result,
+    ValueType initIn, BinaryOp binOp, UnaryOp unaryOp) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+
+  while (first != last) {
+    auto v = init;
+    init   = binOp(init, unaryOp(*first));
+    ++first;
+    *result++ = v;
+  }
+
+  return result;
+}
+
+template <class InputIterator, class OutputIterator, class BinaryOp,
+          class UnaryOp, class ValueType>
+OutputIterator testing_transform_inclusive_scan(InputIterator first,
+                                                InputIterator last,
+                                                OutputIterator result,
+                                                BinaryOp binOp, UnaryOp unaryOp,
+                                                ValueType initIn) {
+  using value_type = std::remove_const_t<ValueType>;
+  value_type init  = initIn;
+
+  for (; first != last; ++first) {
+    init      = binOp(init, unaryOp(*first));
+    *result++ = init;
+  }
+
+  return result;
+}
+
+template <class InputIterator, class OutputIterator, class BinaryOp,
+          class UnaryOp>
+OutputIterator testing_transform_inclusive_scan(InputIterator first,
+                                                InputIterator last,
+                                                OutputIterator result,
+                                                BinaryOp binOp,
+                                                UnaryOp unaryOp) {
+  if (first != last) {
+    auto init = unaryOp(*first);
+    *result++ = init;
+    ++first;
+    if (first != last) {
+      result = testing_transform_inclusive_scan(first, last, result, binOp,
+                                                unaryOp, init);
+    }
+  }
+
+  return result;
+}
+
+#endif
+
+template <class LayoutTagType, class ValueType>
+auto create_random_view_and_host_clone(
+    LayoutTagType LayoutTag, std::size_t numRows, std::size_t numCols,
+    Kokkos::pair<ValueType, ValueType> bounds, const std::string& label,
+    std::size_t seedIn = 12371) {
+  // construct in memory space associated with default exespace
+  auto dataView = create_view<ValueType>(LayoutTag, numRows, numCols, label);
+
+  // dataView might not deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  // randomly fill the view
+  Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+      seedIn);
+  Kokkos::fill_random(dataView_dc_h, pool, bounds.first, bounds.second);
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(dataView_dc, dataView);
+  Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1), F1);
+
+  return std::make_pair(dataView, dataView_dc_h);
+}
+
 template <class ViewType>
 auto create_host_space_copy(ViewType view) {
   auto view_dc = create_deep_copyable_compatible_clone(view);
@@ -175,6 +606,31 @@ compare_views(ViewType1 expected, const ViewType2 actual) {
   }
 }
 
+template <class ViewType1, class ViewType2>
+void expect_equal_host_views(ViewType1 A, const ViewType2 B) {
+  static_assert(
+      ViewType1::rank == 2 && ViewType2::rank == 2 &&
+          std::is_same_v<typename ViewType1::memory_space, Kokkos::HostSpace> &&
+          std::is_same_v<typename ViewType2::memory_space, Kokkos::HostSpace>,
+      "Expected 2-dimensional host view.");
+  ASSERT_EQ(A.extent(0), B.extent(0));
+  ASSERT_EQ(A.extent(1), B.extent(1));
+
+  constexpr bool values_are_floast =
+      std::is_floating_point_v<typename ViewType1::value_type> ||
+      std::is_floating_point_v<typename ViewType2::value_type>;
+
+  for (std::size_t i = 0; i < A.extent(0); i++) {
+    for (std::size_t j = 0; j < A.extent(1); j++) {
+      if constexpr (values_are_floast) {
+        EXPECT_FLOAT_EQ(A(i, j), B(i, j));
+      } else {
+        ASSERT_EQ(A(i, j), B(i, j));
+      }
+    }
+  }
+}
+
 template <class ViewType>
 void fill_zero(ViewType a) {
   const auto functor = FillZeroFunctor<ViewType>(a);
diff --git a/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp b/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp
index 386d533f7a..2a4525a8c3 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsConstraints.cpp
@@ -81,5 +81,114 @@ TEST(std_algorithms, is_admissible_to_std_algorithms) {
                strided_view_3d_t>::value);
 }
 
+TEST(std_algorithms, expect_no_overlap) {
+  namespace KE     = Kokkos::Experimental;
+  using value_type = double;
+
+  static constexpr size_t extent0 = 13;
+
+  //-------------
+  // 1d views
+  //-------------
+  using static_view_1d_t = Kokkos::View<value_type[extent0]>;
+  [[maybe_unused]] static_view_1d_t static_view_1d{
+      "std-algo-test-1d-contiguous-view-static"};
+
+  using dyn_view_1d_t = Kokkos::View<value_type*>;
+  [[maybe_unused]] dyn_view_1d_t dynamic_view_1d{
+      "std-algo-test-1d-contiguous-view-dynamic", extent0};
+
+  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};
+
+// Overlapping because iterators are identical
+#if defined(KOKKOS_ENABLE_DEBUG)
+  auto first_s = KE::begin(static_view_1d);
+  auto last_s  = first_s + extent0;
+  EXPECT_DEATH({ KE::Impl::expect_no_overlap(first_s, last_s, first_s); },
+               "Kokkos contract violation:.*");
+
+  auto first_d = KE::begin(dynamic_view_1d);
+  auto last_d  = first_d + extent0;
+  EXPECT_DEATH({ KE::Impl::expect_no_overlap(first_d, last_d, first_d); },
+               "Kokkos contract violation:.*");
+
+  auto first_st = KE::begin(strided_view_1d);
+  auto last_st  = first_st + extent0;
+  EXPECT_DEATH({ KE::Impl::expect_no_overlap(first_st, last_st, first_st); },
+               "Kokkos contract violation:.*");
+#endif
+
+  // Ranges are overlapped
+  static constexpr size_t sub_extent0 = 6, offset0 = 3;
+  std::pair<size_t, size_t> range0(0, sub_extent0),
+      range1(offset0, offset0 + sub_extent0);
+#if defined(KOKKOS_ENABLE_DEBUG)
+  auto static_view_1d_0 = Kokkos::subview(static_view_1d, range0);
+  auto static_view_1d_1 = Kokkos::subview(static_view_1d, range1);
+  auto first_s0         = KE::begin(static_view_1d_0);  // [0, 6)
+  auto last_s0          = first_s0 + static_view_1d_0.extent(0);
+  auto first_s1         = KE::begin(static_view_1d_1);  // [3, 9)
+  EXPECT_DEATH({ KE::Impl::expect_no_overlap(first_s0, last_s0, first_s1); },
+               "Kokkos contract violation:.*");
+
+  auto dynamic_view_1d_0 = Kokkos::subview(dynamic_view_1d, range0);
+  auto dynamic_view_1d_1 = Kokkos::subview(dynamic_view_1d, range1);
+  auto first_d0          = KE::begin(dynamic_view_1d_0);  // [0, 6)
+  auto last_d0           = first_d0 + dynamic_view_1d_0.extent(0);
+  auto first_d1          = KE::begin(dynamic_view_1d_1);  // [3, 9)
+  EXPECT_DEATH({ KE::Impl::expect_no_overlap(first_d0, last_d0, first_d1); },
+               "Kokkos contract violation:.*");
+#endif
+
+  auto strided_view_1d_0 = Kokkos::subview(strided_view_1d, range0);
+  auto strided_view_1d_1 = Kokkos::subview(strided_view_1d, range1);
+  auto first_st0         = KE::begin(strided_view_1d_0);  // [0, 12)
+  auto last_st0          = first_st0 + strided_view_1d_0.extent(0);
+  auto first_st1         = KE::begin(strided_view_1d_1);  // [3, 15)
+  // Does not overlap since offset (=3) is not divisible by stride (=2)
+  EXPECT_NO_THROW(
+      { KE::Impl::expect_no_overlap(first_st0, last_st0, first_st1); });
+
+  // Iterating over the same range without overlapping
+  Kokkos::View<value_type[2][extent0], Kokkos::LayoutLeft> static_view_2d{
+      "std-algo-test-2d-contiguous-view-static"};
+  auto sub_static_view_1d_0 = Kokkos::subview(static_view_2d, 0, Kokkos::ALL);
+  auto sub_static_view_1d_1 = Kokkos::subview(static_view_2d, 1, Kokkos::ALL);
+  auto sub_first_s0         = KE::begin(sub_static_view_1d_0);  // 0, 2, 4, ...
+  auto sub_last_s0          = sub_first_s0 + sub_static_view_1d_0.extent(0);
+  auto sub_first_s1         = KE::begin(sub_static_view_1d_1);  // 1, 3, 5, ...
+
+  EXPECT_NO_THROW({
+    KE::Impl::expect_no_overlap(sub_first_s0, sub_last_s0, sub_first_s1);
+  });
+
+  Kokkos::View<value_type**, Kokkos::LayoutLeft> dynamic_view_2d{
+      "std-algo-test-2d-contiguous-view-dynamic", 2, extent0};
+  auto sub_dynamic_view_1d_0 = Kokkos::subview(dynamic_view_2d, 0, Kokkos::ALL);
+  auto sub_dynamic_view_1d_1 = Kokkos::subview(dynamic_view_2d, 1, Kokkos::ALL);
+  auto sub_first_d0 = KE::begin(sub_dynamic_view_1d_0);  // 0, 2, 4, ...
+  auto sub_last_d0  = sub_first_d0 + sub_dynamic_view_1d_0.extent(0);
+  auto sub_first_d1 = KE::begin(sub_dynamic_view_1d_1);  // 1, 3, 5, ...
+
+  EXPECT_NO_THROW({
+    KE::Impl::expect_no_overlap(sub_first_d0, sub_last_d0, sub_first_d1);
+  });
+
+  Kokkos::LayoutStride layout2d{2, 3, extent0, 2 * 3};
+  Kokkos::View<value_type**, Kokkos::LayoutStride> strided_view_2d{
+      "std-algo-test-2d-contiguous-view-strided", layout2d};
+  auto sub_strided_view_1d_0 = Kokkos::subview(strided_view_2d, 0, Kokkos::ALL);
+  auto sub_strided_view_1d_1 = Kokkos::subview(strided_view_2d, 1, Kokkos::ALL);
+  auto sub_first_st0 = KE::begin(sub_strided_view_1d_0);  // 0, 6, 12, ...
+  auto sub_last_st0  = sub_first_st0 + sub_strided_view_1d_0.extent(0);
+  auto sub_first_st1 = KE::begin(sub_strided_view_1d_1);  // 1, 7, 13, ...
+
+  EXPECT_NO_THROW({
+    KE::Impl::expect_no_overlap(sub_first_st0, sub_last_st0, sub_first_st1);
+  });
+}
+
 }  // namespace stdalgos
 }  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp
index 799de8b0c4..b364c53a88 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsExclusiveScan.cpp
@@ -16,6 +16,7 @@
 
 #include <TestStdAlgorithmsCommon.hpp>
 #include <utility>
+#include <iomanip>
 
 namespace Test {
 namespace stdalgos {
@@ -132,47 +133,6 @@ void my_host_exclusive_scan(it1 first, it1 last, it2 dest, ValType init,
   }
 }
 
-template <class ViewType1, class ViewType2, class ValueType, class BinaryOp>
-void verify_data(ViewType1 data_view,  // contains data
-                 ViewType2 test_view,  // the view to test
-                 ValueType init_value, BinaryOp bop) {
-  //! always careful because views might not be deep copyable
-
-  auto data_view_dc = create_deep_copyable_compatible_clone(data_view);
-  auto data_view_h =
-      create_mirror_view_and_copy(Kokkos::HostSpace(), data_view_dc);
-
-  using gold_view_value_type = typename ViewType2::value_type;
-  Kokkos::View<gold_view_value_type*, Kokkos::HostSpace> gold_h(
-      "goldh", data_view.extent(0));
-  my_host_exclusive_scan(KE::cbegin(data_view_h), KE::cend(data_view_h),
-                         KE::begin(gold_h), init_value, bop);
-
-  auto test_view_dc = create_deep_copyable_compatible_clone(test_view);
-  auto test_view_h =
-      create_mirror_view_and_copy(Kokkos::HostSpace(), test_view_dc);
-  if (test_view_h.extent(0) > 0) {
-    for (std::size_t i = 0; i < test_view_h.extent(0); ++i) {
-      // std::cout << i << " " << std::setprecision(15) << data_view_h(i) << " "
-      //           << 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) {
-        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)));
-        if (error > 1e-10) {
-          std::cout << i << " " << std::setprecision(15) << data_view_h(i)
-                    << " " << gold_h(i) << " " << test_view_h(i) << " "
-                    << std::abs(static_cast<double>(gold_h(i) - test_view_h(i)))
-                    << std::endl;
-        }
-        EXPECT_LT(error, 1e-10);
-      }
-    }
-  }
-}
-
 template <class ValueType>
 struct MultiplyFunctor {
   KOKKOS_INLINE_FUNCTION
@@ -189,107 +149,153 @@ struct SumFunctor {
   }
 };
 
+struct VerifyData {
+  template <class ViewType1, class ViewType2, class ValueType, class BinaryOp>
+  void operator()(ViewType1 data_view,  // contains data
+                  ViewType2 test_view,  // the view to test
+                  ValueType init_value, BinaryOp bop) {
+    //! always careful because views might not be deep copyable
+
+    auto data_view_dc = create_deep_copyable_compatible_clone(data_view);
+    auto data_view_h =
+        create_mirror_view_and_copy(Kokkos::HostSpace(), data_view_dc);
+
+    using gold_view_value_type = typename ViewType2::value_type;
+    Kokkos::View<gold_view_value_type*, Kokkos::HostSpace> gold_h(
+        "goldh", data_view.extent(0));
+    my_host_exclusive_scan(KE::cbegin(data_view_h), KE::cend(data_view_h),
+                           KE::begin(gold_h), init_value, bop);
+
+    auto test_view_dc = create_deep_copyable_compatible_clone(test_view);
+    auto test_view_h =
+        create_mirror_view_and_copy(Kokkos::HostSpace(), test_view_dc);
+    if (test_view_h.extent(0) > 0) {
+      for (std::size_t i = 0; i < test_view_h.extent(0); ++i) {
+        if (std::is_same<gold_view_value_type, int>::value) {
+          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)));
+          ASSERT_LT(error, 1e-10) << i << " " << std::setprecision(15) << error
+                                  << static_cast<double>(test_view_h(i)) << " "
+                                  << static_cast<double>(gold_h(i));
+        }
+      }
+    }
+  }
+
+  template <class ViewType1, class ViewType2, class ValueType>
+  void operator()(ViewType1 data_view,  // contains data
+                  ViewType2 test_view,  // the view to test
+                  ValueType init_value) {
+    (*this)(data_view, test_view, init_value, SumFunctor<ValueType>());
+  }
+};
+
 std::string value_type_to_string(int) { return "int"; }
 
 std::string value_type_to_string(double) { return "double"; }
 
-template <class Tag, class ValueType, class InfoType>
-void run_single_scenario_default_op(const InfoType& scenario_info,
-                                    ValueType init_value) {
-  using default_op           = SumFunctor<ValueType>;
+template <class Tag, class ValueType, class InfoType, class... OpOrEmpty>
+void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
+                         OpOrEmpty... empty_or_op) {
   const auto name            = std::get<0>(scenario_info);
   const std::size_t view_ext = std::get<1>(scenario_info);
-  // std::cout << "exclusive_scan default op: " << name << ", "
-  //           << view_tag_to_string(Tag{}) << ", "
-  //           << value_type_to_string(ValueType()) << ", "
-  //           << "init = " << init_value << std::endl;
 
   auto view_dest = create_view<ValueType>(Tag{}, view_ext, "exclusive_scan");
   auto view_from = create_view<ValueType>(Tag{}, view_ext, "exclusive_scan");
   fill_view(view_from, name);
+  // view_dest is filled with zeros before calling the algorithm everytime to
+  // ensure the algorithm does something meaningful
 
   {
     fill_zero(view_dest);
     auto r = KE::exclusive_scan(exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest),
-                                init_value);
+                                init_value, empty_or_op...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, default_op());
+    VerifyData()(view_from, view_dest, init_value, empty_or_op...);
   }
 
   {
     fill_zero(view_dest);
     auto r = KE::exclusive_scan("label", exespace(), KE::cbegin(view_from),
                                 KE::cend(view_from), KE::begin(view_dest),
-                                init_value);
+                                init_value, empty_or_op...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, default_op());
+    VerifyData()(view_from, view_dest, init_value, empty_or_op...);
   }
 
   {
     fill_zero(view_dest);
-    auto r = KE::exclusive_scan(exespace(), view_from, view_dest, init_value);
+    auto r = KE::exclusive_scan(exespace(), view_from, view_dest, init_value,
+                                empty_or_op...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, default_op());
+    VerifyData()(view_from, view_dest, init_value, empty_or_op...);
   }
 
   {
     fill_zero(view_dest);
     auto r = KE::exclusive_scan("label", exespace(), view_from, view_dest,
-                                init_value);
+                                init_value, empty_or_op...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, default_op());
+    VerifyData()(view_from, view_dest, init_value, empty_or_op...);
   }
 
   Kokkos::fence();
 }
 
-template <class Tag, class ValueType, class InfoType, class BinaryOp>
-void run_single_scenario_custom_op(const InfoType& scenario_info,
-                                   ValueType init_value, BinaryOp bop) {
+template <class Tag, class ValueType, class InfoType, class... OpOrEmpty>
+void run_single_scenario_inplace(const InfoType& scenario_info,
+                                 ValueType init_value,
+                                 OpOrEmpty... empty_or_op) {
   const auto name            = std::get<0>(scenario_info);
   const std::size_t view_ext = std::get<1>(scenario_info);
-  // std::cout << "exclusive_scan custom op: " << name << ", "
-  //           << view_tag_to_string(Tag{}) << ", "
-  //           << value_type_to_string(ValueType()) << ", "
-  //           << "init = " << init_value << std::endl;
 
-  auto view_dest = create_view<ValueType>(Tag{}, view_ext, "exclusive_scan");
-  auto view_from = create_view<ValueType>(Tag{}, view_ext, "exclusive_scan");
-  fill_view(view_from, name);
+  // since here we call the in-place operation, we need to use two views:
+  // view1: filled according to what the scenario asks for and is not modified
+  // view2: filled according to what the scenario asks for and used for the
+  // in-place op Therefore, after the op is done, view2 should contain the
+  // result of doing exclusive scan NOTE: view2 is filled below every time
+  // because the algorithm acts in place
+
+  auto view1 =
+      create_view<ValueType>(Tag{}, view_ext, "exclusive_scan_inplace_view1");
+  fill_view(view1, name);
 
+  auto view2 =
+      create_view<ValueType>(Tag{}, view_ext, "exclusive_scan_inplace_view2");
   {
-    fill_zero(view_dest);
-    auto r = KE::exclusive_scan(exespace(), KE::cbegin(view_from),
-                                KE::cend(view_from), KE::begin(view_dest),
-                                init_value, bop);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, bop);
+    fill_view(view2, name);
+    auto r = KE::exclusive_scan(exespace(), KE::cbegin(view2), KE::cend(view2),
+                                KE::begin(view2), init_value, empty_or_op...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, init_value, empty_or_op...);
   }
 
   {
-    fill_zero(view_dest);
-    auto r = KE::exclusive_scan("label", exespace(), KE::cbegin(view_from),
-                                KE::cend(view_from), KE::begin(view_dest),
-                                init_value, bop);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, bop);
+    fill_view(view2, name);
+    auto r = KE::exclusive_scan("label", exespace(), KE::cbegin(view2),
+                                KE::cend(view2), KE::begin(view2), init_value,
+                                empty_or_op...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, init_value, empty_or_op...);
   }
 
   {
-    fill_zero(view_dest);
-    auto r =
-        KE::exclusive_scan(exespace(), view_from, view_dest, init_value, bop);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, bop);
+    fill_view(view2, name);
+    auto r = KE::exclusive_scan(exespace(), view2, view2, init_value,
+                                empty_or_op...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, init_value, empty_or_op...);
   }
 
   {
-    fill_zero(view_dest);
-    auto r = KE::exclusive_scan("label", exespace(), view_from, view_dest,
-                                init_value, bop);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, init_value, bop);
+    fill_view(view2, name);
+    auto r = KE::exclusive_scan("label", exespace(), view2, view2, init_value,
+                                empty_or_op...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, init_value, empty_or_op...);
   }
 
   Kokkos::fence();
@@ -303,34 +309,39 @@ void run_exclusive_scan_all_scenarios() {
       {"medium", 1103},      {"large", 10513}};
 
   for (const auto& it : scenarios) {
-    run_single_scenario_default_op<Tag, ValueType>(it, ValueType{0});
-    run_single_scenario_default_op<Tag, ValueType>(it, ValueType{1});
-    run_single_scenario_default_op<Tag, ValueType>(it, ValueType{-2});
-    run_single_scenario_default_op<Tag, ValueType>(it, ValueType{3});
+    run_single_scenario<Tag, ValueType>(it, ValueType{0});
+    run_single_scenario<Tag, ValueType>(it, ValueType{1});
+    run_single_scenario<Tag, ValueType>(it, ValueType{-2});
+    run_single_scenario<Tag, ValueType>(it, ValueType{3});
+
+    run_single_scenario_inplace<Tag, ValueType>(it, ValueType{0});
+    run_single_scenario_inplace<Tag, ValueType>(it, ValueType{-2});
 
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
     // custom multiply op is only run for small views otherwise it overflows
     if (it.first == "small-a" || it.first == "small-b") {
       using custom_bop_t = MultiplyFunctor<ValueType>;
-      run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{0},
-                                                    custom_bop_t());
-      run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{1},
-                                                    custom_bop_t());
-      run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{-2},
-                                                    custom_bop_t());
-      run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{3},
-                                                    custom_bop_t());
-    }
+      run_single_scenario<Tag, ValueType>(it, ValueType{0}, custom_bop_t());
+      run_single_scenario<Tag, ValueType>(it, ValueType{1}, custom_bop_t());
+      run_single_scenario<Tag, ValueType>(it, ValueType{-2}, custom_bop_t());
+      run_single_scenario<Tag, ValueType>(it, ValueType{3}, custom_bop_t());
 
-    using custom_bop_t = SumFunctor<ValueType>;
-    run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{0},
-                                                  custom_bop_t());
-    run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{1},
+      run_single_scenario_inplace<Tag, ValueType>(it, ValueType{0},
                                                   custom_bop_t());
-    run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{-2},
-                                                  custom_bop_t());
-    run_single_scenario_custom_op<Tag, ValueType>(it, ValueType{3},
+      run_single_scenario_inplace<Tag, ValueType>(it, ValueType{-2},
                                                   custom_bop_t());
+    }
+
+    using custom_bop_t = SumFunctor<ValueType>;
+    run_single_scenario<Tag, ValueType>(it, ValueType{0}, custom_bop_t());
+    run_single_scenario<Tag, ValueType>(it, ValueType{1}, custom_bop_t());
+    run_single_scenario<Tag, ValueType>(it, ValueType{-2}, custom_bop_t());
+    run_single_scenario<Tag, ValueType>(it, ValueType{3}, custom_bop_t());
+
+    run_single_scenario_inplace<Tag, ValueType>(it, ValueType{0},
+                                                custom_bop_t());
+    run_single_scenario_inplace<Tag, ValueType>(it, ValueType{-2},
+                                                custom_bop_t());
 #endif
   }
 }
@@ -348,8 +359,9 @@ 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>;
+  using functor_type =
+      Kokkos::Experimental::Impl::ExclusiveScanDefaultFunctorWithValueWrapper<
+          exespace, int, int, view_type, view_type>;
   functor_type functor(dummy, dummy_view, dummy_view);
   using value_type = functor_type::value_type;
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsHelperFunctors.hpp b/algorithms/unit_tests/TestStdAlgorithmsHelperFunctors.hpp
index a2a31f1f65..8dbd6cd7e3 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsHelperFunctors.hpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsHelperFunctors.hpp
@@ -37,6 +37,24 @@ struct CopyFunctor {
   void operator()(int i) const { m_view_to(i) = m_view_from(i); }
 };
 
+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 ItTypeFrom, class ViewTypeTo>
 struct CopyFromIteratorFunctor {
   ItTypeFrom m_it_from;
@@ -121,7 +139,7 @@ struct EqualsValFunctor {
   bool operator()(const ValueType val) const { return val == m_value; }
 };
 
-template <class ValueType1, class ValueType2>
+template <class ValueType1, class ValueType2 = ValueType1>
 struct CustomLessThanComparator {
   KOKKOS_INLINE_FUNCTION
   bool operator()(const ValueType1& a, const ValueType2& b) const {
diff --git a/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp
index 8e60a43e5f..a08a737210 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsInclusiveScan.cpp
@@ -16,6 +16,7 @@
 
 #include <TestStdAlgorithmsCommon.hpp>
 #include <utility>
+#include <iomanip>
 
 namespace Test {
 namespace stdalgos {
@@ -143,51 +144,6 @@ void my_host_inclusive_scan(it1 first, it1 last, it2 dest, BinOp bop,
   }
 }
 
-template <class ViewType1, class ViewType2, class BinaryOp, class... Args>
-void verify_data(ViewType1 data_view,  // contains data
-                 ViewType2 test_view,  // the view to test
-                 BinaryOp bop, Args... args /* copy on purpose */) {
-  //! always careful because views might not be deep copyable
-
-  auto data_view_dc = create_deep_copyable_compatible_clone(data_view);
-  auto data_view_h =
-      create_mirror_view_and_copy(Kokkos::HostSpace(), data_view_dc);
-
-  using gold_view_value_type = typename ViewType2::value_type;
-  Kokkos::View<gold_view_value_type*, Kokkos::HostSpace> gold_h(
-      "goldh", data_view.extent(0));
-  my_host_inclusive_scan(KE::cbegin(data_view_h), KE::cend(data_view_h),
-                         KE::begin(gold_h), bop, args...);
-
-  auto test_view_dc = create_deep_copyable_compatible_clone(test_view);
-  auto test_view_h =
-      create_mirror_view_and_copy(Kokkos::HostSpace(), test_view_dc);
-
-  const auto ext = test_view_h.extent(0);
-  if (ext > 0) {
-    for (std::size_t i = 0; i < ext; ++i) {
-      // std::cout << i << " " << std::setprecision(15) << data_view_h(i) << " "
-      //           << 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) {
-        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)));
-        if (error > 1e-10) {
-          std::cout << i << " " << std::setprecision(15) << data_view_h(i)
-                    << " " << gold_h(i) << " " << test_view_h(i) << " "
-                    << std::abs(static_cast<double>(gold_h(i) - test_view_h(i)))
-                    << std::endl;
-        }
-        EXPECT_LT(error, 1e-10);
-      }
-    }
-    // std::cout << " last el: " << test_view_h(ext-1) << std::endl;
-  }
-}
-
 template <class ValueType>
 struct MultiplyFunctor {
   KOKKOS_INLINE_FUNCTION
@@ -204,107 +160,151 @@ struct SumFunctor {
   }
 };
 
+struct VerifyData {
+  template <class ViewType1, class ViewType2, class BinaryOp, class... Args>
+  void operator()(ViewType1 data_view,  // contains data
+                  ViewType2 test_view,  // the view to test
+                  BinaryOp bop, Args... args /* copy on purpose */) {
+    //! always careful because views might not be deep copyable
+
+    auto data_view_dc = create_deep_copyable_compatible_clone(data_view);
+    auto data_view_h =
+        create_mirror_view_and_copy(Kokkos::HostSpace(), data_view_dc);
+
+    using gold_view_value_type = typename ViewType2::value_type;
+    Kokkos::View<gold_view_value_type*, Kokkos::HostSpace> gold_h(
+        "goldh", data_view.extent(0));
+    my_host_inclusive_scan(KE::cbegin(data_view_h), KE::cend(data_view_h),
+                           KE::begin(gold_h), bop, args...);
+
+    auto test_view_dc = create_deep_copyable_compatible_clone(test_view);
+    auto test_view_h =
+        create_mirror_view_and_copy(Kokkos::HostSpace(), test_view_dc);
+
+    const auto ext = test_view_h.extent(0);
+    if (ext > 0) {
+      for (std::size_t i = 0; i < ext; ++i) {
+        if (std::is_same<gold_view_value_type, int>::value) {
+          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)));
+          ASSERT_LT(error, 1e-10) << i << " " << std::setprecision(15) << error
+                                  << static_cast<double>(test_view_h(i)) << " "
+                                  << static_cast<double>(gold_h(i));
+        }
+      }
+    }
+  }
+
+  template <class ViewType1, class ViewType2>
+  void operator()(ViewType1 data_view,  // contains data
+                  ViewType2 test_view)  // the view to test
+  {
+    using value_type = typename ViewType1::non_const_value_type;
+    (*this)(data_view, test_view, SumFunctor<value_type>());
+  }
+};
+
 std::string value_type_to_string(int) { return "int"; }
 std::string value_type_to_string(double) { return "double"; }
 
-template <class Tag, class ValueType, class InfoType>
-void run_single_scenario_default_op(const InfoType& scenario_info) {
-  using default_op           = SumFunctor<ValueType>;
+template <class Tag, class ValueType, class InfoType, class... Args>
+void run_single_scenario(const InfoType& scenario_info,
+                         Args... args /* copy on purpose */) {
   const auto name            = std::get<0>(scenario_info);
   const std::size_t view_ext = std::get<1>(scenario_info);
-  // std::cout << "inclusive_scan default op: " << name << ", "
-  //           << view_tag_to_string(Tag{}) << ", "
-  //           << value_type_to_string(ValueType()) << std::endl;
 
   auto view_dest = create_view<ValueType>(Tag{}, view_ext, "inclusive_scan");
   auto view_from = create_view<ValueType>(Tag{}, view_ext, "inclusive_scan");
   fill_view(view_from, name);
+  // view_dest is filled with zeros before calling the algorithm everytime to
+  // ensure the algorithm does something meaningful
 
   {
     fill_zero(view_dest);
-    auto r = KE::inclusive_scan(exespace(), KE::cbegin(view_from),
-                                KE::cend(view_from), KE::begin(view_dest));
+    auto r =
+        KE::inclusive_scan(exespace(), KE::cbegin(view_from),
+                           KE::cend(view_from), KE::begin(view_dest), args...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, default_op());
+    VerifyData()(view_from, view_dest, args...);
   }
 
   {
     fill_zero(view_dest);
-    auto r = KE::inclusive_scan("label", exespace(), KE::cbegin(view_from),
-                                KE::cend(view_from), KE::begin(view_dest));
+    auto r =
+        KE::inclusive_scan("label", exespace(), KE::cbegin(view_from),
+                           KE::cend(view_from), KE::begin(view_dest), args...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, default_op());
+    VerifyData()(view_from, view_dest, args...);
   }
 
   {
     fill_zero(view_dest);
-    auto r = KE::inclusive_scan(exespace(), view_from, view_dest);
+    auto r = KE::inclusive_scan(exespace(), view_from, view_dest, args...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, default_op());
+    VerifyData()(view_from, view_dest, args...);
   }
 
   {
     fill_zero(view_dest);
-    auto r = KE::inclusive_scan("label", exespace(), view_from, view_dest);
+    auto r =
+        KE::inclusive_scan("label", exespace(), view_from, view_dest, args...);
     ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, default_op());
+    VerifyData()(view_from, view_dest, args...);
   }
 
   Kokkos::fence();
 }
 
-template <class Tag, class ValueType, class InfoType, class BinaryOp,
-          class... Args>
-void run_single_scenario_custom_op(const InfoType& scenario_info, BinaryOp bop,
-                                   Args... args /* copy on purpose */) {
+template <class Tag, class ValueType, class InfoType, class... Args>
+void run_single_scenario_inplace(const InfoType& scenario_info,
+                                 Args... args /* copy on purpose */) {
   const auto name            = std::get<0>(scenario_info);
   const std::size_t view_ext = std::get<1>(scenario_info);
 
-  // if (1 == sizeof...(Args)) {
-  //   std::cout << "inclusive_scan custom op and init value: " << name << ", "
-  //             << view_tag_to_string(Tag{}) << ", "
-  //             << value_type_to_string(ValueType()) << ", " << std::endl;
-  // } else {
-  //   std::cout << "inclusive_scan custom op: " << name << ", "
-  //             << view_tag_to_string(Tag{}) << ", "
-  //             << value_type_to_string(ValueType()) << ", " << std::endl;
-  // }
+  // since here we call the in-place operation, we need to use two views:
+  // view1: filled according to what the scenario asks for and is not modified
+  // view2: filled according to what the scenario asks for and used for the
+  // in-place op Therefore, after the op is done, view_2 should contain the
+  // result of doing exclusive scan NOTE: view2 is filled below every time
+  // because the algorithm acts in place
 
-  auto view_dest = create_view<ValueType>(Tag{}, view_ext, "inclusive_scan");
-  auto view_from = create_view<ValueType>(Tag{}, view_ext, "inclusive_scan");
-  fill_view(view_from, name);
+  auto view1 =
+      create_view<ValueType>(Tag{}, view_ext, "inclusive_scan_inplace_view1");
+  fill_view(view1, name);
+
+  auto view2 =
+      create_view<ValueType>(Tag{}, view_ext, "inclusive_scan_inplace_view2");
 
   {
-    fill_zero(view_dest);
-    auto r = KE::inclusive_scan(exespace(), KE::cbegin(view_from),
-                                KE::cend(view_from), KE::begin(view_dest), bop,
-                                args...);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, bop, args...);
+    fill_view(view2, name);
+    auto r = KE::inclusive_scan(exespace(), KE::cbegin(view2), KE::cend(view2),
+                                KE::begin(view2), args...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, args...);
   }
 
   {
-    fill_zero(view_dest);
-    auto r = KE::inclusive_scan("label", exespace(), KE::cbegin(view_from),
-                                KE::cend(view_from), KE::begin(view_dest), bop,
-                                args...);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, bop, args...);
+    fill_view(view2, name);
+    auto r = KE::inclusive_scan("label", exespace(), KE::cbegin(view2),
+                                KE::cend(view2), KE::begin(view2), args...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, args...);
   }
 
   {
-    fill_zero(view_dest);
-    auto r = KE::inclusive_scan(exespace(), view_from, view_dest, bop, args...);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, bop, args...);
+    fill_view(view2, name);
+    auto r = KE::inclusive_scan(exespace(), view2, view2, args...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, args...);
   }
 
   {
-    fill_zero(view_dest);
-    auto r = KE::inclusive_scan("label", exespace(), view_from, view_dest, bop,
-                                args...);
-    ASSERT_EQ(r, KE::end(view_dest));
-    verify_data(view_from, view_dest, bop, args...);
+    fill_view(view2, name);
+    auto r = KE::inclusive_scan("label", exespace(), view2, view2, args...);
+    ASSERT_EQ(r, KE::end(view2));
+    VerifyData()(view1, view2, args...);
   }
 
   Kokkos::fence();
@@ -318,27 +318,35 @@ void run_inclusive_scan_all_scenarios() {
       {"medium-a", 313},     {"medium-b", 1103}, {"large", 10513}};
 
   for (const auto& it : scenarios) {
-    run_single_scenario_default_op<Tag, ValueType>(it);
+    run_single_scenario<Tag, ValueType>(it);
+    run_single_scenario_inplace<Tag, ValueType>(it);
 
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
     // the sum custom op is always run
     using sum_binary_op = SumFunctor<ValueType>;
     sum_binary_op sbop;
-    run_single_scenario_custom_op<Tag, ValueType>(it, sbop);
-    run_single_scenario_custom_op<Tag, ValueType>(it, sbop, ValueType{0});
-    run_single_scenario_custom_op<Tag, ValueType>(it, sbop, ValueType{1});
-    run_single_scenario_custom_op<Tag, ValueType>(it, sbop, ValueType{-2});
-    run_single_scenario_custom_op<Tag, ValueType>(it, sbop, ValueType{3});
+    run_single_scenario<Tag, ValueType>(it, sbop);
+    run_single_scenario<Tag, ValueType>(it, sbop, ValueType{0});
+    run_single_scenario<Tag, ValueType>(it, sbop, ValueType{1});
+    run_single_scenario<Tag, ValueType>(it, sbop, ValueType{-2});
+    run_single_scenario<Tag, ValueType>(it, sbop, ValueType{3});
+
+    run_single_scenario_inplace<Tag, ValueType>(it, sbop, ValueType{0});
+    run_single_scenario_inplace<Tag, ValueType>(it, sbop, ValueType{-2});
 
     // custom multiply only for small views to avoid overflows
     if (it.first == "small-a" || it.first == "small-b") {
       using mult_binary_op = MultiplyFunctor<ValueType>;
       mult_binary_op mbop;
-      run_single_scenario_custom_op<Tag, ValueType>(it, mbop);
-      run_single_scenario_custom_op<Tag, ValueType>(it, mbop, ValueType{0});
-      run_single_scenario_custom_op<Tag, ValueType>(it, mbop, ValueType{1});
-      run_single_scenario_custom_op<Tag, ValueType>(it, mbop, ValueType{-2});
-      run_single_scenario_custom_op<Tag, ValueType>(it, mbop, ValueType{3});
+      run_single_scenario<Tag, ValueType>(it, mbop);
+      run_single_scenario<Tag, ValueType>(it, mbop, ValueType{0});
+      run_single_scenario<Tag, ValueType>(it, mbop, ValueType{1});
+      run_single_scenario<Tag, ValueType>(it, mbop, ValueType{-2});
+      run_single_scenario<Tag, ValueType>(it, mbop, ValueType{3});
+
+      run_single_scenario_inplace<Tag, ValueType>(it, mbop);
+      run_single_scenario_inplace<Tag, ValueType>(it, mbop, ValueType{0});
+      run_single_scenario_inplace<Tag, ValueType>(it, mbop, ValueType{-2});
     }
 #endif
   }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsIsSorted.cpp b/algorithms/unit_tests/TestStdAlgorithmsIsSorted.cpp
index f31d49e06b..75d4f0afeb 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsIsSorted.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsIsSorted.cpp
@@ -146,7 +146,7 @@ void run_single_scenario(const InfoType& scenario_info) {
   resultsA[3]     = KE::is_sorted("label", exespace(), view);
   const auto allA = std::all_of(resultsA.cbegin(), resultsA.cend(),
                                 [=](bool v) { return v == gold; });
-  EXPECT_TRUE(allA);
+  EXPECT_TRUE(allA) << name << ", " << view_tag_to_string(Tag{});
 
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
   CustomLessThanComparator<ValueType, ValueType> comp;
@@ -159,7 +159,7 @@ void run_single_scenario(const InfoType& scenario_info) {
   resultsB[3]     = KE::is_sorted("label", exespace(), view, comp);
   const auto allB = std::all_of(resultsB.cbegin(), resultsB.cend(),
                                 [=](bool v) { return v == gold; });
-  EXPECT_TRUE(allB);
+  EXPECT_TRUE(allB) << name << ", " << view_tag_to_string(Tag{});
 #endif
 
   Kokkos::fence();
@@ -173,9 +173,6 @@ void run_is_sorted_all_scenarios() {
       {"medium-a", 1003},    {"medium-b", 1003}, {"large-a", 101513},
       {"large-b", 101513}};
 
-  std::cout << "is_sorted: " << view_tag_to_string(Tag{})
-            << ", all overloads \n";
-
   for (const auto& it : scenarios) {
     run_single_scenario<Tag, ValueType>(it);
   }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp b/algorithms/unit_tests/TestStdAlgorithmsIsSortedUntil.cpp
index dcfe8ad67e..29ac7cc9bc 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);
-  ASSERT_EQ(r1, gold);
-  ASSERT_EQ(r2, gold);
-  ASSERT_EQ(r3, gold);
-  ASSERT_EQ(r4, gold);
+  ASSERT_EQ(r1, gold) << name << ", " << view_tag_to_string(Tag{});
+  ASSERT_EQ(r2, gold) << name << ", " << view_tag_to_string(Tag{});
+  ASSERT_EQ(r3, gold) << name << ", " << view_tag_to_string(Tag{});
+  ASSERT_EQ(r4, gold) << name << ", " << view_tag_to_string(Tag{});
 
 #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
 
-  ASSERT_EQ(r1, gold);
-  ASSERT_EQ(r2, gold);
-  ASSERT_EQ(r3, gold);
-  ASSERT_EQ(r4, gold);
+  ASSERT_EQ(r1, gold) << name << ", " << view_tag_to_string(Tag{});
+  ASSERT_EQ(r2, gold) << name << ", " << view_tag_to_string(Tag{});
+  ASSERT_EQ(r3, gold) << name << ", " << view_tag_to_string(Tag{});
+  ASSERT_EQ(r4, gold) << name << ", " << view_tag_to_string(Tag{});
 
   Kokkos::fence();
 }
@@ -176,9 +176,6 @@ void run_is_sorted_until_all_scenarios() {
       {"medium-a", 1003},    {"medium-b", 1003}, {"large-a", 101513},
       {"large-b", 101513}};
 
-  std::cout << "is_sorted_until: " << view_tag_to_string(Tag{})
-            << ", all overloads \n";
-
   for (const auto& it : scenarios) {
     run_single_scenario<Tag, ValueType>(it);
   }
diff --git a/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp
index 4604764097..1b1a02f39c 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsModOps.cpp
@@ -48,7 +48,7 @@ struct MyMovableType {
 TEST(std_algorithms_mod_ops_test, move) {
   MyMovableType a;
   using move_t = decltype(std::move(a));
-  static_assert(std::is_rvalue_reference<move_t>::value, "");
+  static_assert(std::is_rvalue_reference<move_t>::value);
 
   // move constr
   MyMovableType b(std::move(a));
@@ -70,7 +70,7 @@ struct StdAlgoModSeqOpsTestMove {
   void operator()(const int index) const {
     typename ViewType::value_type a{11};
     using move_t = decltype(std::move(a));
-    static_assert(std::is_rvalue_reference<move_t>::value, "");
+    static_assert(std::is_rvalue_reference<move_t>::value);
     m_view(index) = std::move(a);
   }
 
@@ -89,50 +89,6 @@ TEST(std_algorithms_mod_ops_test, move_within_parfor) {
   }
 }
 
-// ------------
-// swap
-// ------------
-TEST(std_algorithms_mod_ops_test, swap) {
-  {
-    int a = 1;
-    int b = 2;
-    KE::swap(a, b);
-    ASSERT_EQ(a, 2);
-    ASSERT_EQ(b, 1);
-  }
-
-  {
-    double a = 3.;
-    double b = 1.;
-    KE::swap(a, b);
-    EXPECT_DOUBLE_EQ(a, 1.);
-    EXPECT_DOUBLE_EQ(b, 3.);
-  }
-}
-
-template <class ViewType>
-struct StdAlgoModSeqOpsTestSwap {
-  ViewType m_view;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const int index) const {
-    typename ViewType::value_type newval{11};
-    KE::swap(m_view(index), newval);
-  }
-
-  StdAlgoModSeqOpsTestSwap(ViewType aIn) : m_view(aIn) {}
-};
-
-TEST(std_algorithms_mod_ops_test, swap_within_parfor) {
-  auto a = create_view<double>(stdalgos::DynamicTag{}, 10, "a");
-  StdAlgoModSeqOpsTestSwap<decltype(a)> fnc(a);
-  Kokkos::parallel_for(a.extent(0), fnc);
-  auto a_h = Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), a);
-  for (std::size_t i = 0; i < a.extent(0); ++i) {
-    EXPECT_DOUBLE_EQ(a_h(0), 11.);
-  }
-}
-
 // ------------
 // iter_swap
 // ------------
diff --git a/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp
index f169fd9ce8..a36c9db2b9 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsPartitionCopy.cpp
@@ -110,11 +110,9 @@ void verify_data(const std::string& name, ResultType my_result,
                  ViewTypeDestFalse view_dest_false, PredType pred) {
   using value_type = typename ViewTypeFrom::value_type;
   static_assert(
-      std::is_same<value_type, typename ViewTypeDestTrue::value_type>::value,
-      "");
+      std::is_same<value_type, typename ViewTypeDestTrue::value_type>::value);
   static_assert(
-      std::is_same<value_type, typename ViewTypeDestFalse::value_type>::value,
-      "");
+      std::is_same<value_type, typename ViewTypeDestFalse::value_type>::value);
 
   const std::size_t ext = view_from.extent(0);
 
diff --git a/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp b/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
index 33a1326c47..0c6e9df047 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsPartitioningOps.cpp
@@ -127,7 +127,7 @@ struct std_algorithms_partitioning_test : public std_algorithms_test {
       case Mixed: return false;
       case NegativeFirst: return true;
       case AllNegative: return true;
-      case AllPositive: return false;
+      case AllPositive: return true;
       case NegativeLast: return false;
       case SingleNegative: return true;
       default: return false;
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamAdjacentDifference.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamAdjacentDifference.cpp
new file mode 100644
index 0000000000..c388cadc9b
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamAdjacentDifference.cpp
@@ -0,0 +1,220 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamAdjacentDifference {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION constexpr ValueType operator()(
+      const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class BinaryOp>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  BinaryOp m_binaryOp;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               BinaryOp binaryOp)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_binaryOp(std::move(binaryOp)) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it    = KE::adjacent_difference(member, KE::cbegin(myRowViewFrom),
+                                          KE::cend(myRowViewFrom),
+                                          KE::begin(myRowViewDest));
+        resultDist = KE::distance(KE::begin(myRowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::adjacent_difference(member, KE::cbegin(myRowViewFrom),
+                                          KE::cend(myRowViewFrom),
+                                          KE::begin(myRowViewDest), m_binaryOp);
+        resultDist = KE::distance(KE::begin(myRowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+
+      case 2: {
+        auto it = KE::adjacent_difference(member, myRowViewFrom, myRowViewDest);
+        resultDist = KE::distance(KE::begin(myRowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+
+      case 3: {
+        auto it = KE::adjacent_difference(member, myRowViewFrom, myRowViewDest,
+                                          m_binaryOp);
+        resultDist = KE::distance(KE::begin(myRowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level adjacent_difference
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [sourceView, sourceViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result
+  // of its adjacent_difference call, and then we check
+  // that these match what we expect
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // adjacent_difference returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the beginning
+  // of the interval that team operates on and then we check that these
+  // distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId, PlusFunctor<ValueType>{});
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(sourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+    switch (apiId) {
+      case 0:
+      case 2: {
+        auto it = std::adjacent_difference(KE::begin(rowFrom), KE::end(rowFrom),
+                                           KE::begin(rowDest));
+
+        const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+        break;
+      }
+
+      case 1:
+      case 3: {
+        auto it = std::adjacent_difference(KE::begin(rowFrom), KE::end(rowFrom),
+                                           KE::begin(rowDest),
+                                           PlusFunctor<ValueType>{});
+
+        const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+        break;
+      }
+    }
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(destView);
+  expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_adjacent_difference_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamAdjacentDifference
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamAdjacentFind.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamAdjacentFind.cpp
new file mode 100644
index 0000000000..95f2934e01
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamAdjacentFind.cpp
@@ -0,0 +1,256 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamAdjacentFind {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct IsEqualFunctor {
+  KOKKOS_INLINE_FUNCTION constexpr bool operator()(const ValueType& lhs,
+                                                   const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  BinaryPredType m_binaryPred;
+
+  TestFunctorA(const DataViewType dataView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               BinaryPredType binaryPred)
+      : m_dataView(dataView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_binaryPred(binaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        const auto it = KE::adjacent_find(member, KE::cbegin(myRowViewFrom),
+                                          KE::cend(myRowViewFrom));
+        resultDist    = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+
+      case 1: {
+        const auto it = KE::adjacent_find(member, myRowViewFrom);
+        resultDist    = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+
+      case 2: {
+        const auto it =
+            KE::adjacent_find(member, KE::cbegin(myRowViewFrom),
+                              KE::cend(myRowViewFrom), m_binaryPred);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+
+      case 3: {
+        const auto it = KE::adjacent_find(member, myRowViewFrom, m_binaryPred);
+        resultDist    = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool ensureAdjacentFindCanFind, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level adjacent_find
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // If ensureAdjacentFindCanFind == true ensure there are two consecutive equal
+  // elements in each row
+
+  // dataView might not deep copyable (e.g. strided layout) so to prepare it
+  // correctly, we make a new view that is for sure deep copyable, modify it on
+  // the host, deep copy to device and then launch a kernel to copy to dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  if (ensureAdjacentFindCanFind && numCols > 1) {
+    for (std::size_t i = 0; i < numTeams; ++i) {
+      const auto j = numCols / 2;
+
+      dataView_dc_h(i, j - 1) = dataView_dc_h(i, j);
+    }
+  }
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+
+  CopyFunctorRank2 cpFun(dataView_dc, dataView);
+  Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1), cpFun);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // adjacent_find returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the beginning
+  // of the interval that team operates on and then we check that these
+  // distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  IsEqualFunctor<ValueType> binaryPred;
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, apiId,
+                   binaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom            = Kokkos::subview(dataView_dc_h, i, Kokkos::ALL());
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+    const std::size_t beginEndDist = KE::distance(rowFromBegin, rowFromEnd);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const auto it = std::adjacent_find(rowFromBegin, rowFromEnd);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        if (numCols == 1) {
+          ASSERT_EQ(distancesView_h(i), beginEndDist);
+        } else if (ensureAdjacentFindCanFind) {
+          EXPECT_NE(distancesView_h(i), beginEndDist);
+        }
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const auto it =
+            std::adjacent_find(rowFromBegin, rowFromEnd, binaryPred);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        if (numCols == 1) {
+          ASSERT_EQ(distancesView_h(i), beginEndDist);
+        } else if (ensureAdjacentFindCanFind) {
+          EXPECT_NE(distancesView_h(i), beginEndDist);
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool ensureAdjacentFindCanFind) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(ensureAdjacentFindCanFind, numTeams,
+                                     numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_adjacent_find_team_test,
+     two_consecutive_equal_elements_exist) {
+  constexpr bool ensureAdjacentFindCanFind = true;
+
+  run_all_scenarios<DynamicTag, double>(ensureAdjacentFindCanFind);
+  run_all_scenarios<StridedTwoRowsTag, int>(ensureAdjacentFindCanFind);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(ensureAdjacentFindCanFind);
+}
+
+TEST(std_algorithms_adjacent_find_team_test,
+     two_consecutive_equal_elements_might_exist) {
+  constexpr bool ensureAdjacentFindCanFind = false;
+
+  run_all_scenarios<DynamicTag, double>(ensureAdjacentFindCanFind);
+  run_all_scenarios<StridedTwoRowsTag, int>(ensureAdjacentFindCanFind);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(ensureAdjacentFindCanFind);
+}
+
+}  // namespace TeamAdjacentFind
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamAllOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamAllOf.cpp
new file mode 100644
index 0000000000..7b3dca330a
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamAllOf.cpp
@@ -0,0 +1,165 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamAllOf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class DataViewType, class AlllOfResultsViewType,
+          class IntraTeamSentinelView, class UnaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  AlllOfResultsViewType m_allOfResultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  UnaryPredType m_unaryPred;
+
+  TestFunctorA(const DataViewType dataView,
+               const AlllOfResultsViewType allOfResultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               UnaryPredType unaryPred)
+      : m_dataView(dataView),
+        m_allOfResultsView(allOfResultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_unaryPred(unaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    bool result        = false;
+
+    switch (m_apiPick) {
+      case 0: {
+        result = KE::all_of(member, KE::cbegin(myRowViewFrom),
+                            KE::cend(myRowViewFrom), m_unaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_allOfResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 1: {
+        result = KE::all_of(member, myRowViewFrom, m_unaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_allOfResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_allOfResultsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level all_of
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result of its all_of call,
+  // and then we check that these match what we expect
+  Kokkos::View<bool*> allOfResultsView("allOfResultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  GreaterThanValueFunctor unaryPred{lowerBound - 1};
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, allOfResultsView, intraTeamSentinelView, apiId,
+                   unaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto allOfResultsView_h      = create_host_space_copy(allOfResultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const bool result =
+        std::all_of(KE::cbegin(rowFrom), KE::cend(rowFrom), unaryPred);
+    ASSERT_EQ(result, allOfResultsView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_all_of_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamAllOf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamAnyOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamAnyOf.cpp
new file mode 100644
index 0000000000..f99617008e
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamAnyOf.cpp
@@ -0,0 +1,165 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamAnyOf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class DataViewType, class AnyOfResultsViewType,
+          class IntraTeamSentinelView, class UnaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  AnyOfResultsViewType m_anyOfResultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  UnaryPredType m_unaryPred;
+
+  TestFunctorA(const DataViewType dataView,
+               const AnyOfResultsViewType anyOfResultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               UnaryPredType unaryPred)
+      : m_dataView(dataView),
+        m_anyOfResultsView(anyOfResultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_unaryPred(unaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    bool result        = false;
+
+    switch (m_apiPick) {
+      case 0: {
+        result = KE::any_of(member, KE::cbegin(myRowViewFrom),
+                            KE::cend(myRowViewFrom), m_unaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_anyOfResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 1: {
+        result = KE::any_of(member, myRowViewFrom, m_unaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_anyOfResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_anyOfResultsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level any_of
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result of its any_of call,
+  // and then we check that these match what we expect
+  Kokkos::View<bool*> anyOfResultsView("anyOfResultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  GreaterThanValueFunctor unaryPred{lowerBound};
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, anyOfResultsView, intraTeamSentinelView, apiId,
+                   unaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto anyOfResultsView_h      = create_host_space_copy(anyOfResultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const bool result =
+        std::any_of(KE::cbegin(rowFrom), KE::cend(rowFrom), unaryPred);
+    ASSERT_EQ(result, anyOfResultsView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_any_of_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamAnyOf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamCopy.cpp
new file mode 100644
index 0000000000..e24ac37bf0
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamCopy.cpp
@@ -0,0 +1,157 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::copy(member, KE::begin(myRowViewFrom),
+                         KE::end(myRowViewFrom), KE::begin(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::copy(member, myRowViewFrom, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill a source view and copy into a destination view.
+     The operation is done via a team parfor with one row per team.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  // make a host copy of the destination view that should be unchanged after the
+  // op
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // KE::copy returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  for (std::size_t i = 0; i < destViewBeforeOp_h.extent(0); ++i) {
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    for (std::size_t j = 0; j < destViewBeforeOp_h.extent(1); ++j) {
+      ASSERT_EQ(destViewBeforeOp_h(i, j), ValueType(0));
+      EXPECT_TRUE(destViewAfterOp_h(i, j) != destViewBeforeOp_h(i, j));
+    }
+    // each team should return an iterator past the last column
+    EXPECT_TRUE(distancesView_h(i) == numCols);
+  }
+
+  expect_equal_host_views(cloneOfSourceViewBeforeOp_h, destViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_copy_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamCopyBackward.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamCopyBackward.cpp
new file mode 100644
index 0000000000..c17c1810de
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamCopyBackward.cpp
@@ -0,0 +1,168 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamCopybackward {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::copy_backward(member, KE::cbegin(myRowViewFrom),
+                            KE::cend(myRowViewFrom), KE::end(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::copy_backward(member, myRowViewFrom, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill a source view and copy_backward into a destination view.
+     The operation is done via a team parfor with one row per team.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view: for a meaningful test, the destination
+  // view must have more columns that than the source view so that we
+  // can check that the elements are copied into the right place
+  constexpr std::size_t extra = 10;
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols + extra);
+  // make a host copy of the destination view that should be unchanged after the
+  // op
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // copy_backward returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  for (std::size_t i = 0; i < destViewAfterOp_h.extent(0); ++i) {
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+    // first extra num of columns should be unchanged
+    for (std::size_t j = 0; j < extra; ++j) {
+      EXPECT_TRUE(destViewAfterOp_h(i, j) == destViewBeforeOp_h(i, j));
+    }
+
+    // after extra # of column (inclusive) should match the source view
+    for (std::size_t j = extra; j < destViewBeforeOp_h.extent(1); ++j) {
+      EXPECT_TRUE(cloneOfSourceViewBeforeOp_h(i, j - extra) ==
+                  destViewAfterOp_h(i, j));
+    }
+
+    // each team should have returned an interator whose distance
+    // from the beginning of the row should satisfy this
+    EXPECT_TRUE(distancesView_h(i) == extra);
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_copy_backward_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamCopybackward
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamCopyIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamCopyIf.cpp
new file mode 100644
index 0000000000..7c3c465dc8
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamCopyIf.cpp
@@ -0,0 +1,180 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamCopyIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class ValueType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  ValueType m_threshold;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType threshold, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_threshold(threshold),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::copy_if(member, KE::begin(myRowViewFrom), KE::end(myRowViewFrom),
+                      KE::begin(myRowViewDest), predicate);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::copy_if(member, myRowViewFrom, myRowViewDest, predicate);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level copy_if where only the values strictly
+     greater than a threshold are copied into a new view
+   */
+
+  const auto threshold = static_cast<ValueType>(151);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  auto [sourceView, sourceViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols,
+      Kokkos::pair<ValueType, ValueType>{5, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // copy_if returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   threshold, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(sourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto it      = std::copy_if(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                           KE::begin(rowDest), predicate);
+    const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(destView);
+  expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_copy_if_team_test, test) {
+// FIXME_OPENMPTARGET
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  GTEST_SKIP() << "the test is known to fail with OpenMPTarget on Intel GPUs";
+#endif
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamCopyIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamCopy_n.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamCopy_n.cpp
new file mode 100644
index 0000000000..7cbc788f8e
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamCopy_n.cpp
@@ -0,0 +1,176 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamCopy_n {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_copyCount;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType fromView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t copyCount, int apiPick)
+      : m_sourceView(fromView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_copyCount(copyCount),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::copy_n(member, KE::begin(myRowViewFrom), m_copyCount,
+                           KE::begin(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it = KE::copy_n(member, myRowViewFrom, m_copyCount, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t copyCount,
+            int apiId) {
+  /* description:
+     randomly fill a source view and copy a copyCount set of values
+     for each row into a destination view. The operation is done via
+     a team parfor with one row per team.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  // make a host copy of destView, should be unchanged after the op
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // copy_n returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   copyCount, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  for (std::size_t i = 0; i < destViewBeforeOp_h.extent(0); ++i) {
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    for (std::size_t j = 0; j < copyCount; ++j) {
+      ASSERT_EQ(destViewAfterOp_h(i, j), cloneOfSourceViewBeforeOp_h(i, j));
+    }
+    for (std::size_t j = copyCount; j < numCols; ++j) {
+      EXPECT_TRUE(destViewAfterOp_h(i, j) == destViewBeforeOp_h(i, j));
+    }
+    // each team should return an iterator past the last column
+    EXPECT_TRUE(distancesView_h(i) == copyCount);
+  }
+}
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  // prepare a map where, for a given set of num cols
+  // we provide a list of counts of elements to copy
+  // key = num of columns,
+  // value = list of num of elemenents to copy
+  const std::map<int, std::vector<int>> scenarios = {
+      {0, {0}},
+      {2, {0, 1, 2}},
+      {6, {0, 1, 2, 5}},
+      {13, {0, 1, 2, 8, 11}},
+      {56, {0, 1, 2, 8, 11, 33, 56}},
+      {123, {0, 1, 11, 33, 56, 89, 112}}};
+
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& scenario : scenarios) {
+      const std::size_t numCols = scenario.first;
+      for (int copyCount : scenario.second) {
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, copyCount, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_copy_n_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamCopy_n
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamCount.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamCount.cpp
new file mode 100644
index 0000000000..922424afbd
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamCount.cpp
@@ -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
+
+#include <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamCount {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class ValuesViewType, class CountsViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  ValuesViewType m_valuesView;
+  CountsViewType m_countsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const ValuesViewType valuesView,
+               const CountsViewType countsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_valuesView(valuesView),
+        m_countsView(countsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+    const auto value    = m_valuesView(rowIndex);
+    auto rowView        = Kokkos::subview(m_view, rowIndex, Kokkos::ALL());
+    std::size_t result  = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        result =
+            KE::count(member, KE::cbegin(rowView), KE::cend(rowView), value);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_countsView(rowIndex) = result; });
+
+        break;
+      }
+
+      case 1: {
+        result = KE::count(member, rowView, value);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_countsView(rowIndex) = result; });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_countsView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool searched_value_exist, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level count
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+
+  // Boundaries choosen so that every drawn number is at least once in the given
+  // row
+  const ValueType lowerBound = numCols / 4;
+  const ValueType upperBound = 1 + numCols * 3 / 4;
+  const auto bounds          = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // If searched_value_exist == true, we want to ensure that count result is >
+  // 0, so we randomly pick a value to look for from a given row.
+  //
+  // If searched_value_exist == false, we want to ensure that count returns 0,
+  // so we pick a value that's outside of view boundaries.
+  Kokkos::View<ValueType*> valuesView("valuesView", numTeams);
+  auto valuesView_h = create_mirror_view(Kokkos::HostSpace(), valuesView);
+
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+
+  if (searched_value_exist) {
+    Kokkos::View<std::size_t*, Kokkos::DefaultHostExecutionSpace> randomIndices(
+        "randomIndices", numTeams);
+    Kokkos::fill_random(randomIndices, pool, 0, numCols);
+
+    for (std::size_t i = 0; i < numTeams; ++i) {
+      const std::size_t j = randomIndices(i);
+      valuesView_h(i)     = dataViewBeforeOp_h(i, j);
+    }
+  } else {
+    Kokkos::fill_random(valuesView_h, pool, upperBound, upperBound * 2);
+  }
+
+  Kokkos::deep_copy(valuesView, valuesView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result of its count
+  // call, and then we check that these match what we expect
+  Kokkos::View<std::size_t*> countsView("countsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, valuesView, countsView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto countsView_h            = create_host_space_copy(countsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  if (searched_value_exist) {
+    for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+      auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+      const auto rowFromBegin = KE::cbegin(rowFrom);
+      const auto rowFromEnd   = KE::cend(rowFrom);
+      const auto val          = valuesView_h(i);
+
+      const std::size_t result = std::count(rowFromBegin, rowFromEnd, val);
+      ASSERT_EQ(result, countsView_h(i));
+      ASSERT_TRUE(intraTeamSentinelView_h(i));
+    }
+  } else {
+    for (std::size_t i = 0; i < countsView.extent(0); ++i) {
+      constexpr std::size_t zero = 0;
+      ASSERT_EQ(countsView_h(i), zero);
+      ASSERT_TRUE(intraTeamSentinelView_h(i));
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool searchedValueExist) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(searchedValueExist, numTeams, numCols,
+                                     apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_count_team_test, count_returns_nonzero) {
+  constexpr bool searchedValueExist = true;
+  run_all_scenarios<DynamicTag, double>(searchedValueExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(searchedValueExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(searchedValueExist);
+}
+
+TEST(std_algorithms_count_team_test, count_returns_zero) {
+  constexpr bool searchedValueExist = false;
+  run_all_scenarios<DynamicTag, double>(searchedValueExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(searchedValueExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(searchedValueExist);
+}
+
+}  // namespace TeamCount
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamCountIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamCountIf.cpp
new file mode 100644
index 0000000000..5a9be4cd11
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamCountIf.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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamCountIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class ViewType, class CountsViewType, class IntraTeamSentinelView,
+          class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  CountsViewType m_countsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  ValueType m_threshold;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const CountsViewType countsView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType threshold, int apiPick)
+      : m_view(view),
+        m_countsView(countsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_threshold(threshold),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    std::size_t myCount   = 0;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      myCount = KE::count_if(member, KE::begin(myRowView), KE::end(myRowView),
+                             predicate);
+
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_countsView(myRowIndex) = myCount; });
+    } else if (m_apiPick == 1) {
+      myCount = KE::count_if(member, myRowView, predicate);
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_countsView(myRowIndex) = myCount; });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, myCount, m_countsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level count_if where only the values
+     strictly greater than a threshold are counted
+   */
+
+  const auto threshold = static_cast<ValueType>(151);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(LayoutTag{}, numTeams, numCols, bounds,
+                                        "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result
+  // of its count_if call, and then we check
+  // that these match what we expect
+  Kokkos::View<std::size_t*> countsView("countsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, countsView, intraTeamSentinelView, threshold,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto countsView_h            = create_host_space_copy(countsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    std::size_t goldCountForRow = 0;
+    for (std::size_t j = 0; j < cloneOfDataViewBeforeOp_h.extent(1); ++j) {
+      if (cloneOfDataViewBeforeOp_h(i, j) > threshold) {
+        goldCountForRow++;
+      }
+    }
+    ASSERT_EQ(goldCountForRow, countsView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_count_if_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamCountIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamEqual.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamEqual.cpp
new file mode 100644
index 0000000000..82cce0b384
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamEqual.cpp
@@ -0,0 +1,278 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamEqual {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct EqualFunctor {
+  KOKKOS_INLINE_FUNCTION bool operator()(const ValueType& lhs,
+                                         const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class CompViewType, class ResultsViewType,
+          class IntraTeamSentinelView, class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  CompViewType m_compView;
+  ResultsViewType m_resultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  BinaryPredType m_binaryPred;
+
+  TestFunctorA(const DataViewType dataView, const CompViewType compView,
+               const ResultsViewType resultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               BinaryPredType binaryPred)
+      : m_dataView(dataView),
+        m_compView(compView),
+        m_resultsView(resultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_binaryPred(binaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto rowData         = Kokkos::subview(m_dataView, rowIndex, Kokkos::ALL());
+    const auto dataBegin = KE::cbegin(rowData);
+    const auto dataEnd   = KE::cend(rowData);
+
+    auto rowComp         = Kokkos::subview(m_compView, rowIndex, Kokkos::ALL());
+    const auto compBegin = KE::cbegin(rowComp);
+    const auto compEnd   = KE::cend(rowComp);
+
+    bool result = false;
+    switch (m_apiPick) {
+      case 0: {
+        result = KE::equal(member, dataBegin, dataEnd, compBegin);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 1: {
+        result = KE::equal(member, dataBegin, dataEnd, compBegin, m_binaryPred);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 2: {
+        result = KE::equal(member, rowData, rowComp);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 3: {
+        result = KE::equal(member, rowData, rowComp, m_binaryPred);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+
+        break;
+      }
+
+      case 4: {
+        result = KE::equal(member, dataBegin, dataEnd, compBegin, compEnd);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 5: {
+        result = KE::equal(member, dataBegin, dataEnd, compBegin, compEnd,
+                           m_binaryPred);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_resultsView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool viewsAreEqual, std::size_t numTeams, std::size_t numCols,
+            int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level equal
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // create a view to compare it with dataView. If viewsAreEqual == true,
+  // compView is a copy of dataView. If viewsAreEqual == false, compView is
+  // randomly filled
+  auto compView   = create_deep_copyable_compatible_clone(dataView);
+  auto compView_h = create_mirror_view(Kokkos::HostSpace(), compView);
+  if (viewsAreEqual) {
+    Kokkos::deep_copy(compView_h, dataViewBeforeOp_h);
+  } else {
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(lowerBound * upperBound);
+    Kokkos::fill_random(compView_h, pool, lowerBound, upperBound);
+  }
+
+  Kokkos::deep_copy(compView, compView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the view to store results of equal()
+  Kokkos::View<bool*> resultsView("resultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  EqualFunctor<ValueType> binaryPred{};
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, compView, resultsView, intraTeamSentinelView,
+                   apiId, binaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto resultsView_h           = create_host_space_copy(resultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowData = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const auto dataBegin = KE::cbegin(rowData);
+    const auto dataEnd   = KE::cend(rowData);
+
+    auto rowComp         = Kokkos::subview(compView_h, i, Kokkos::ALL());
+    const auto compBegin = KE::cbegin(rowComp);
+    const auto compEnd   = KE::cend(rowComp);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    switch (apiId) {
+      case 0:
+      case 2: {
+        const bool result = std::equal(dataBegin, dataEnd, compBegin);
+
+        if (viewsAreEqual) {
+          EXPECT_TRUE(resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 1:
+      case 3: {
+        const bool result =
+            std::equal(dataBegin, dataEnd, compBegin, binaryPred);
+
+        if (viewsAreEqual) {
+          EXPECT_TRUE(resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 4: {
+        const bool result = std::equal(dataBegin, dataEnd, compBegin, compEnd);
+
+        if (viewsAreEqual) {
+          EXPECT_TRUE(resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 5: {
+        const bool result =
+            std::equal(dataBegin, dataEnd, compBegin, compEnd, binaryPred);
+
+        if (viewsAreEqual) {
+          EXPECT_TRUE(resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool viewsAreEqual) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3, 4, 5}) {
+        test_A<LayoutTag, ValueType>(viewsAreEqual, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_equal_team_test, views_are_equal) {
+  constexpr bool viewsAreEqual = true;
+  run_all_scenarios<DynamicTag, double>(viewsAreEqual);
+  run_all_scenarios<StridedTwoRowsTag, int>(viewsAreEqual);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(viewsAreEqual);
+}
+
+TEST(std_algorithms_equal_team_test, views_are_not_equal) {
+  constexpr bool viewsAreEqual = false;
+  run_all_scenarios<DynamicTag, double>(viewsAreEqual);
+  run_all_scenarios<StridedTwoRowsTag, int>(viewsAreEqual);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(viewsAreEqual);
+}
+
+}  // namespace TeamEqual
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamExclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamExclusiveScan.cpp
new file mode 100644
index 0000000000..7cb9851087
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamExclusiveScan.cpp
@@ -0,0 +1,272 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamExclusiveScan {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION constexpr ValueType operator()(
+      const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class InitValuesViewType,
+          class BinaryOpType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  InitValuesViewType m_initValuesView;
+  BinaryOpType m_binaryOp;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               const InitValuesViewType initValuesView, BinaryOpType binaryOp,
+               int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_initValuesView(initValuesView),
+        m_binaryOp(binaryOp),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto rowViewSrc    = Kokkos::subview(m_sourceView, rowIndex, Kokkos::ALL());
+    auto rowViewDest   = Kokkos::subview(m_destView, rowIndex, Kokkos::ALL());
+    const auto initVal = m_initValuesView(rowIndex);
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it    = KE::exclusive_scan(member, KE::cbegin(rowViewSrc),
+                                     KE::cend(rowViewSrc),
+                                     KE::begin(rowViewDest), initVal);
+        resultDist = KE::distance(KE::begin(rowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 1: {
+        auto it = KE::exclusive_scan(member, rowViewSrc, rowViewDest, initVal);
+        resultDist = KE::distance(KE::begin(rowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+
+      case 2: {
+        auto it = KE::exclusive_scan(
+            member, KE::cbegin(rowViewSrc), KE::cend(rowViewSrc),
+            KE::begin(rowViewDest), initVal, m_binaryOp);
+        resultDist = KE::distance(KE::begin(rowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 3: {
+        auto it = KE::exclusive_scan(member, rowViewSrc, rowViewDest, initVal,
+                                     m_binaryOp);
+        resultDist = KE::distance(KE::begin(rowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+#endif
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+struct InPlace {};
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level exclusive_scan
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [sourceView, sourceViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // exclusive_scan returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the beginning
+  // of the interval that team operates on and then we check that these
+  // distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  PlusFunctor<ValueType> binaryOp;
+
+  // Create view of reduce init values to be used by test cases
+  Kokkos::View<ValueType*, Kokkos::DefaultHostExecutionSpace> initValuesView_h(
+      "initValuesView_h", numTeams);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(initValuesView_h, pool, lowerBound, upperBound);
+
+  auto initValuesView =
+      Kokkos::create_mirror_view_and_copy(space_t(), initValuesView_h);
+
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    TestFunctorA fnc(sourceView, sourceView, distancesView,
+                     intraTeamSentinelView, initValuesView, binaryOp, apiId);
+    Kokkos::parallel_for(policy, fnc);
+  } else {
+    TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                     initValuesView, binaryOp, apiId);
+    Kokkos::parallel_for(policy, fnc);
+  }
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto rowFrom   = Kokkos::subview(sourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowDest   = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto initValue = initValuesView_h(i);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+// libstdc++ as provided by GCC 8 does not have exclusive_scan and
+// for GCC 9.1, 9.2 fails to compile for missing overload not accepting policy
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+#define exclusive_scan testing_exclusive_scan
+#else
+#define exclusive_scan std::exclusive_scan
+#endif
+    switch (apiId) {
+      case 0:
+      case 1: {
+        auto it = exclusive_scan(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                                 KE::begin(rowDest), initValue);
+        const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+        break;
+      }
+
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+      case 2:
+      case 3: {
+        auto it = exclusive_scan(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                                 KE::begin(rowDest), initValue, binaryOp);
+        const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+#endif
+    }
+
+#undef exclusive_scan
+  }
+
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    auto dataViewAfterOp_h = create_host_space_copy(sourceView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  } else {
+    auto dataViewAfterOp_h = create_host_space_copy(destView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  }
+}
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+      for (int apiId : {0, 1, 2, 3}) {
+#else
+      for (int apiId : {0, 1}) {
+#endif
+        test_A<LayoutTag, ValueType, InPlaceOrVoid>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_exclusive_scan_team_test, test) {
+// FIXME_OPENMPTARGET
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  GTEST_SKIP() << "the test is known to fail with OpenMPTarget on Intel GPUs";
+#endif
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+
+  run_all_scenarios<DynamicTag, double, InPlace>();
+  run_all_scenarios<StridedTwoRowsTag, int, InPlace>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned, InPlace>();
+}
+
+}  // namespace TeamExclusiveScan
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFill.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFill.cpp
new file mode 100644
index 0000000000..bd3ef3bd67
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFill.cpp
@@ -0,0 +1,106 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFill {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType>
+struct TestFunctorA {
+  ViewType m_view;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, int apiPick)
+      : m_view(view), m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto leagueRank = member.league_rank();
+    const auto myRowIndex = leagueRank;
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+
+    if (m_apiPick == 0) {
+      KE::fill(member, KE::begin(myRowView), KE::end(myRowView), leagueRank);
+    } else if (m_apiPick == 1) {
+      KE::fill(member, myRowView, leagueRank);
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     create a rank-2 view, randomly fill with non trivial numbers
+     and do a team-level KE::fill where each team fills
+     with its league_rank value the row it is responsible for
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, _] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols,
+      Kokkos::pair<ValueType, ValueType>{11, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  // each row should be filled with the row index
+  // since the league_rank of a team here coincides with row index
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataViewAfterOp_h.extent(1); ++j) {
+      EXPECT_TRUE(dataViewAfterOp_h(i, j) == static_cast<ValueType>(i));
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_fill_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamFill
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFill_n.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFill_n.cpp
new file mode 100644
index 0000000000..0a97f15c17
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFill_n.cpp
@@ -0,0 +1,176 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFill_n {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_fillCount;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t fillCount, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_fillCount(fillCount),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto leagueRank = member.league_rank();
+    const auto myRowIndex = leagueRank;
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::fill_n(member, KE::begin(myRowView), m_fillCount, leagueRank);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::fill_n(member, myRowView, m_fillCount, leagueRank);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t fillCount,
+            int apiId) {
+  /* description:
+     create a rank-2 view, run a team parfor with one row per team,
+     such that n elements of each row are filled up with the league_rank value
+     of the team in charge of it, while the other elements in the row
+     are left unchanged
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{5, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // fill_n returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expected value
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, fillCount,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+    // check that values match what we expect
+    for (std::size_t j = 0; j < fillCount; ++j) {
+      ASSERT_EQ(dataViewAfterOp_h(i, j), ValueType(i));
+    }
+    // all other elements should be unchanged from before op
+    for (std::size_t j = fillCount; j < numCols; ++j) {
+      ASSERT_EQ(dataViewAfterOp_h(i, j), cloneOfDataViewBeforeOp_h(i, j));
+    }
+
+    // check that returned iterators are correct
+    if (fillCount > 0) {
+      ASSERT_EQ(distancesView_h(i), std::size_t(fillCount));
+    } else {
+      ASSERT_EQ(distancesView_h(i), std::size_t(0));
+    }
+  }
+}
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  // prepare a map where, for a given set of num cols
+  // we provide a list of counts of elements to fill
+  // key = num of columns,
+  // value = list of num of elemenents to fill
+  const std::map<int, std::vector<int>> scenarios = {
+      {0, {0}},
+      {2, {0, 1, 2}},
+      {6, {0, 1, 2, 5}},
+      {13, {0, 1, 2, 8, 11}},
+      {56, {0, 1, 2, 8, 11, 33, 56}},
+      {123, {0, 1, 11, 33, 56, 89, 112}}};
+
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& scenario : scenarios) {
+      const std::size_t numCols = scenario.first;
+      for (int numFills : scenario.second) {
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, numFills, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_fill_n_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamFill_n
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFind.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFind.cpp
new file mode 100644
index 0000000000..430e4917e0
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFind.cpp
@@ -0,0 +1,212 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFind {
+
+namespace KE = Kokkos::Experimental;
+
+template <class DataViewType, class SearchedValuesViewType,
+          class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  SearchedValuesViewType m_searchedValuesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView,
+               const SearchedValuesViewType searchedValuesView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_dataView(dataView),
+        m_searchedValuesView(searchedValuesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    const auto searchedValue = m_searchedValuesView(myRowIndex);
+    ptrdiff_t resultDist     = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it    = KE::find(member, KE::cbegin(myRowViewFrom),
+                           KE::cend(myRowViewFrom), searchedValue);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::find(member, myRowViewFrom, searchedValue);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool searchedValuesExist, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level find
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // find returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // If searchedValuesExist == true we want to ensure that each value we're
+  // looking for exists in dataView. To do that, for each numTeams, a random j
+  // index from a range [0, numCols) is used to obtain a value from dataView.
+  //
+  // If searchedValuesExist == false we want to ensure the opposite, so every
+  // value is less than a lower bound of dataView.
+  Kokkos::View<ValueType*> searchedValuesView("searchValuesView", numTeams);
+  auto searchedValuesView_h =
+      create_mirror_view(Kokkos::HostSpace(), searchedValuesView);
+
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+
+  if (searchedValuesExist) {
+    Kokkos::View<std::size_t*, Kokkos::DefaultHostExecutionSpace> randomIndices(
+        "randomIndices", numTeams);
+
+    Kokkos::fill_random(randomIndices, pool, 0, numCols);
+
+    for (std::size_t i = 0; i < numTeams; ++i) {
+      const std::size_t j     = randomIndices(i);
+      searchedValuesView_h(i) = dataViewBeforeOp_h(i, j);
+    }
+  } else {
+    Kokkos::fill_random(searchedValuesView_h, pool, 0, lowerBound);
+  }
+
+  Kokkos::deep_copy(searchedValuesView, searchedValuesView_h);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, searchedValuesView, distancesView,
+                   intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+
+    auto it = std::find(rowFromBegin, rowFromEnd, searchedValuesView_h(i));
+
+    const std::size_t stdDistance      = KE::distance(rowFromBegin, it);
+    const std::size_t beginEndDistance = KE::distance(rowFromBegin, rowFromEnd);
+
+    if (searchedValuesExist) {
+      EXPECT_LT(stdDistance, beginEndDistance);
+    } else {
+      ASSERT_EQ(stdDistance, beginEndDistance);
+    }
+
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool searchedValuesExist) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(searchedValuesExist, numTeams, numCols,
+                                     apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_find_team_test, searched_values_exist) {
+  constexpr bool searchedValuesExist = true;
+
+  run_all_scenarios<DynamicTag, double>(searchedValuesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(searchedValuesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(searchedValuesExist);
+}
+
+TEST(std_algorithms_find_team_test, searched_values_do_not_exist) {
+  constexpr bool searchedValuesExist = false;
+
+  run_all_scenarios<DynamicTag, double>(searchedValuesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(searchedValuesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(searchedValuesExist);
+}
+
+}  // namespace TeamFind
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFindEnd.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFindEnd.cpp
new file mode 100644
index 0000000000..83eca33569
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFindEnd.cpp
@@ -0,0 +1,271 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFindEnd {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct EqualFunctor {
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class SearchedSequencesViewType,
+          class DistancesViewType, class IntraTeamSentinelView,
+          class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  SearchedSequencesViewType m_searchedSequencesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  BinaryPredType m_binaryPred;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView,
+               const SearchedSequencesViewType searchedSequencesView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               BinaryPredType binaryPred, int apiPick)
+      : m_dataView(dataView),
+        m_searchedSequencesView(searchedSequencesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_binaryPred(binaryPred),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    auto myRowSearchedSeqView =
+        Kokkos::subview(m_searchedSequencesView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it = KE::find_end(
+            member, KE::cbegin(myRowViewFrom), KE::cend(myRowViewFrom),
+            KE::cbegin(myRowSearchedSeqView), KE::cend(myRowSearchedSeqView));
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::find_end(member, myRowViewFrom, myRowSearchedSeqView);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 2: {
+        auto it    = KE::find_end(member, KE::cbegin(myRowViewFrom),
+                               KE::cend(myRowViewFrom),
+                               KE::cbegin(myRowSearchedSeqView),
+                               KE::cend(myRowSearchedSeqView), m_binaryPred);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 3: {
+        auto it    = KE::find_end(member, myRowViewFrom, myRowSearchedSeqView,
+                               m_binaryPred);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool sequencesExist, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level find_end
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // create a view that stores a sequence to found in dataView. If
+  // sequencesExist == true it is filled base on dataView content, to allow
+  // find_end to actually find anything. If sequencesExist == false it is filled
+  // with random values greater than upperBound
+  const auto halfCols    = (numCols + 1) / 2;
+  const auto quarterCols = halfCols / 2;
+
+  Kokkos::View<ValueType**> searchedSequencesView(
+      "searchedSequencesView", numTeams, halfCols - quarterCols);
+  auto searchedSequencesView_h = create_host_space_copy(searchedSequencesView);
+
+  if (sequencesExist) {
+    for (std::size_t i = 0; i < searchedSequencesView_h.extent(0); ++i) {
+      for (std::size_t js = 0, jd = quarterCols; jd < halfCols; ++js, ++jd) {
+        searchedSequencesView_h(i, js) = dataViewBeforeOp_h(i, jd);
+      }
+    }
+  } else {
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(lowerBound * upperBound);
+    Kokkos::fill_random(searchedSequencesView_h, pool, upperBound,
+                        upperBound * 2);
+  }
+
+  Kokkos::deep_copy(searchedSequencesView, searchedSequencesView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // find_end returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  EqualFunctor<ValueType> binaryPred;
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, searchedSequencesView, distancesView,
+                   intraTeamSentinelView, binaryPred, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+
+    auto rowSearchedSeq =
+        Kokkos::subview(searchedSequencesView_h, i, Kokkos::ALL());
+
+    std::size_t stdDistance = std::numeric_limits<std::size_t>::max();
+    const std::size_t beginEndDistance = KE::distance(rowFromBegin, rowFromEnd);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    switch (apiId) {
+      case 0:
+      case 1: {
+        auto it =
+            std::find_end(rowFromBegin, rowFromEnd, KE::cbegin(rowSearchedSeq),
+                          KE::cend(rowSearchedSeq));
+        stdDistance = KE::distance(rowFromBegin, it);
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        auto it =
+            std::find_end(rowFromBegin, rowFromEnd, KE::cbegin(rowSearchedSeq),
+                          KE::cend(rowSearchedSeq), binaryPred);
+        stdDistance = KE::distance(rowFromBegin, it);
+
+        break;
+      }
+    }
+
+    if (sequencesExist) {
+      EXPECT_LT(stdDistance, beginEndDistance);
+    } else {
+      ASSERT_EQ(stdDistance, beginEndDistance);
+    }
+
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool sequencesExist) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(sequencesExist, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_find_end_team_test, sequences_exist) {
+  constexpr bool sequencesExist = true;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+TEST(std_algorithms_find_end_team_test, sequences_do_not_exist) {
+  constexpr bool sequencesExist = false;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+}  // namespace TeamFindEnd
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFindFirstOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFindFirstOf.cpp
new file mode 100644
index 0000000000..e992882e91
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFindFirstOf.cpp
@@ -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
+
+#include <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFindFirstOf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct EqualFunctor {
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class SearchedSequencesViewType,
+          class DistancesViewType, class IntraTeamSentinelView,
+          class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  SearchedSequencesViewType m_searchedSequencesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  BinaryPredType m_binaryPred;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView,
+               const SearchedSequencesViewType searchedSequencesView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               BinaryPredType binaryPred, int apiPick)
+      : m_dataView(dataView),
+        m_searchedSequencesView(searchedSequencesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_binaryPred(binaryPred),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    auto myRowSearchedSeqView =
+        Kokkos::subview(m_searchedSequencesView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it = KE::find_first_of(
+            member, KE::cbegin(myRowViewFrom), KE::cend(myRowViewFrom),
+            KE::cbegin(myRowSearchedSeqView), KE::cend(myRowSearchedSeqView));
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        auto it =
+            KE::find_first_of(member, myRowViewFrom, myRowSearchedSeqView);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 2: {
+        auto it = KE::find_first_of(
+            member, KE::cbegin(myRowViewFrom), KE::cend(myRowViewFrom),
+            KE::cbegin(myRowSearchedSeqView), KE::cend(myRowSearchedSeqView),
+            m_binaryPred);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 3: {
+        auto it = KE::find_first_of(member, myRowViewFrom, myRowSearchedSeqView,
+                                    m_binaryPred);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool sequencesExist, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level find_first_of
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // create a view that stores a sequence to found a value from in dataView. If
+  // sequencesExist == true it is filled base on dataView content, to allow
+  // find_first_of to actually find anything. If sequencesExist == false it is
+  // filled with random values greater than upperBound
+  const std::size_t halfCols = (numCols > 1) ? ((numCols + 1) / 2) : (1);
+  const std::size_t seqSize  = (numCols > 1) ? (std::log2(numCols)) : (1);
+
+  Kokkos::View<ValueType**> searchedSequencesView("searchedSequencesView",
+                                                  numTeams, seqSize);
+  auto searchedSequencesView_h = create_host_space_copy(searchedSequencesView);
+
+  if (sequencesExist) {
+    const std::size_t dataBegin = halfCols - seqSize;
+    for (std::size_t i = 0; i < searchedSequencesView_h.extent(0); ++i) {
+      for (std::size_t js = 0, jd = dataBegin; js < seqSize; ++js, ++jd) {
+        searchedSequencesView_h(i, js) = dataViewBeforeOp_h(i, jd);
+      }
+    }
+  } else {
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(lowerBound * upperBound);
+    Kokkos::fill_random(searchedSequencesView_h, pool, upperBound,
+                        upperBound * 2);
+  }
+
+  Kokkos::deep_copy(searchedSequencesView, searchedSequencesView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // find_first_of returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  EqualFunctor<ValueType> binaryPred;
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, searchedSequencesView, distancesView,
+                   intraTeamSentinelView, binaryPred, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowSearchedSeq =
+        Kokkos::subview(searchedSequencesView_h, i, Kokkos::ALL());
+
+    const auto rowFromBegin     = KE::cbegin(rowFrom);
+    const auto rowFromEnd       = KE::cend(rowFrom);
+    const auto rowSearchedBegin = KE::cbegin(rowSearchedSeq);
+    const auto rowSearchedEnd   = KE::cend(rowSearchedSeq);
+
+    const std::size_t beginEndDistance = KE::distance(rowFromBegin, rowFromEnd);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    switch (apiId) {
+      case 0:
+      case 1: {
+        auto it = std::find_first_of(rowFromBegin, rowFromEnd, rowSearchedBegin,
+                                     rowSearchedEnd);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        if (sequencesExist) {
+          EXPECT_LT(distancesView_h(i), beginEndDistance);
+        } else {
+          ASSERT_EQ(distancesView_h(i), beginEndDistance);
+        }
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        auto it = std::find_first_of(rowFromBegin, rowFromEnd, rowSearchedBegin,
+                                     rowSearchedEnd, binaryPred);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        if (sequencesExist) {
+          EXPECT_LT(distancesView_h(i), beginEndDistance);
+        } else {
+          ASSERT_EQ(distancesView_h(i), beginEndDistance);
+        }
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool sequencesExist) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(sequencesExist, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_find_first_of_team_test, sequences_exist) {
+  constexpr bool sequencesExist = true;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+TEST(std_algorithms_find_first_of_team_test, sequences_do_not_exist) {
+  constexpr bool sequencesExist = false;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+}  // namespace TeamFindFirstOf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFindIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFindIf.cpp
new file mode 100644
index 0000000000..ee4bbed7a3
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFindIf.cpp
@@ -0,0 +1,241 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFindIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterEqualFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterEqualFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val >= m_val); }
+};
+
+template <class DataViewType, class GreaterThanValuesViewType,
+          class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  GreaterThanValuesViewType m_greaterThanValuesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView,
+               const GreaterThanValuesViewType greaterThanValuesView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_dataView(dataView),
+        m_greaterThanValuesView(greaterThanValuesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    const auto val     = m_greaterThanValuesView(myRowIndex);
+    // FIXME_INTEL
+#if defined(KOKKOS_COMPILER_INTEL) && (1900 == KOKKOS_COMPILER_INTEL)
+    GreaterEqualFunctor<
+        typename GreaterThanValuesViewType::non_const_value_type>
+        unaryPred{val};
+#else
+    GreaterEqualFunctor unaryPred{val};
+#endif
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it    = KE::find_if(member, KE::cbegin(myRowViewFrom),
+                              KE::cend(myRowViewFrom), unaryPred);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::find_if(member, myRowViewFrom, unaryPred);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool predicatesReturnTrue, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level find_if
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // find_if returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // If predicatesReturnTrue == true, we want to ensure that eventually, for
+  // some value from each of dataView's row, predicate GreaterEqualFunctor will
+  // return true. To do that, for each numTeams, a random j index from a range
+  // [0, numCols) is used to obtain a value from dataView, and later that value
+  // is used for creating concrete GreaterEqualFunctor predicate.
+  //
+  // If predicatesReturnTrue == false we want to ensure the opposite, so every
+  // value is randomly picked from range [upperBound, upperBound*2).
+  Kokkos::View<ValueType*> greaterEqualValuesView("greaterEqualValuesView",
+                                                  numTeams);
+  auto greaterEqualValuesView_h =
+      create_mirror_view(Kokkos::HostSpace(), greaterEqualValuesView);
+
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+
+  if (predicatesReturnTrue) {
+    Kokkos::View<std::size_t*, Kokkos::DefaultHostExecutionSpace> randomIndices(
+        "randomIndices", numTeams);
+    Kokkos::fill_random(randomIndices, pool, 0, numCols);
+
+    for (std::size_t i = 0; i < numTeams; ++i) {
+      const std::size_t j         = randomIndices(i);
+      greaterEqualValuesView_h(i) = dataViewBeforeOp_h(i, j);
+    }
+  } else {
+    Kokkos::fill_random(greaterEqualValuesView_h, pool, upperBound,
+                        upperBound * 2);
+  }
+
+  Kokkos::deep_copy(greaterEqualValuesView, greaterEqualValuesView_h);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, greaterEqualValuesView, distancesView,
+                   intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+    const auto val          = greaterEqualValuesView_h(i);
+    // FIXME_INTEL
+#if defined(KOKKOS_COMPILER_INTEL) && (1900 == KOKKOS_COMPILER_INTEL)
+    const GreaterEqualFunctor<ValueType> unaryPred{val};
+#else
+    const GreaterEqualFunctor unaryPred{val};
+#endif
+
+    auto it = std::find_if(rowFromBegin, rowFromEnd, unaryPred);
+
+    const std::size_t stdDistance      = KE::distance(rowFromBegin, it);
+    const std::size_t beginEndDistance = KE::distance(rowFromBegin, rowFromEnd);
+
+    if (predicatesReturnTrue) {
+      EXPECT_LT(stdDistance, beginEndDistance);
+    } else {
+      ASSERT_EQ(stdDistance, beginEndDistance);
+    }
+
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool predicatesReturnTrue) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(predicatesReturnTrue, numTeams, numCols,
+                                     apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_find_if_team_test, predicates_return_true) {
+  constexpr bool predicatesReturnTrue = true;
+
+  run_all_scenarios<DynamicTag, double>(predicatesReturnTrue);
+  run_all_scenarios<StridedTwoRowsTag, int>(predicatesReturnTrue);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(predicatesReturnTrue);
+}
+
+TEST(std_algorithms_find_if_team_test, predicates_return_false) {
+  constexpr bool predicatesReturnTrue = false;
+
+  run_all_scenarios<DynamicTag, double>(predicatesReturnTrue);
+  run_all_scenarios<StridedTwoRowsTag, int>(predicatesReturnTrue);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(predicatesReturnTrue);
+}
+
+}  // namespace TeamFindIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamFindIfNot.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamFindIfNot.cpp
new file mode 100644
index 0000000000..b9448c1a3e
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamFindIfNot.cpp
@@ -0,0 +1,236 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamFindIfNot {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterEqualFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterEqualFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val >= m_val); }
+};
+
+template <class DataViewType, class GreaterThanValuesViewType,
+          class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  GreaterThanValuesViewType m_greaterThanValuesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView,
+               const GreaterThanValuesViewType greaterThanValuesView,
+               DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_dataView(dataView),
+        m_greaterThanValuesView(greaterThanValuesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    const auto val     = m_greaterThanValuesView(myRowIndex);
+    // FIXME_INTEL
+#if defined(KOKKOS_COMPILER_INTEL) && (1900 == KOKKOS_COMPILER_INTEL)
+    GreaterEqualFunctor<
+        typename GreaterThanValuesViewType::non_const_value_type>
+        unaryPred{val};
+#else
+    GreaterEqualFunctor unaryPred{val};
+#endif
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it    = KE::find_if_not(member, KE::cbegin(myRowViewFrom),
+                                  KE::cend(myRowViewFrom), unaryPred);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::find_if_not(member, myRowViewFrom, unaryPred);
+        resultDist = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool predicatesReturnTrue, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level find_if_not
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // find_if_not returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // If predicatesReturnTrue == true, we want to ensure that for each dataView's
+  // row find_if_not always returns end iterator. To do that,
+  // GreaterEqualFunctor predicate created for each row must return true for
+  // every value in that row, so it needs to compare each value with value
+  // smaller than lowerBound.
+  //
+  // If predicatesReturnTrue == false we want to ensure the opposite -
+  // GreaterEqualFunctor needs to return false for every value of each
+  // dataView's row, so the predicate is constructed with value randomly picked
+  // from range [upperBound, upperBound*2).
+  Kokkos::View<ValueType*> greaterEqualValuesView("greaterEqualValuesView",
+                                                  numTeams);
+  auto greaterEqualValuesView_h =
+      create_mirror_view(Kokkos::HostSpace(), greaterEqualValuesView);
+
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+
+  if (predicatesReturnTrue) {
+    Kokkos::fill_random(greaterEqualValuesView_h, pool, 0, lowerBound);
+  } else {
+    Kokkos::fill_random(greaterEqualValuesView_h, pool, upperBound,
+                        upperBound * 2);
+  }
+
+  Kokkos::deep_copy(greaterEqualValuesView, greaterEqualValuesView_h);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, greaterEqualValuesView, distancesView,
+                   intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+    const auto val          = greaterEqualValuesView_h(i);
+    // FIXME_INTEL
+#if defined(KOKKOS_COMPILER_INTEL) && (1900 == KOKKOS_COMPILER_INTEL)
+    const GreaterEqualFunctor<ValueType> unaryPred{val};
+#else
+    const GreaterEqualFunctor unaryPred{val};
+#endif
+
+    auto it = std::find_if_not(rowFromBegin, rowFromEnd, unaryPred);
+
+    const std::size_t stdDistance      = KE::distance(rowFromBegin, it);
+    const std::size_t beginEndDistance = KE::distance(rowFromBegin, rowFromEnd);
+
+    if (predicatesReturnTrue) {
+      ASSERT_EQ(stdDistance, beginEndDistance);
+    } else {
+      EXPECT_LT(stdDistance, beginEndDistance);
+    }
+
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool predicatesReturnTrue) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(predicatesReturnTrue, numTeams, numCols,
+                                     apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_find_if_not_team_test, predicates_return_true) {
+  constexpr bool predicatesReturnTrue = true;
+
+  run_all_scenarios<DynamicTag, double>(predicatesReturnTrue);
+  run_all_scenarios<StridedTwoRowsTag, int>(predicatesReturnTrue);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(predicatesReturnTrue);
+}
+
+TEST(std_algorithms_find_if_not_team_test, predicates_return_false) {
+  constexpr bool predicatesReturnTrue = false;
+
+  run_all_scenarios<DynamicTag, double>(predicatesReturnTrue);
+  run_all_scenarios<StridedTwoRowsTag, int>(predicatesReturnTrue);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(predicatesReturnTrue);
+}
+
+}  // namespace TeamFindIfNot
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamForEach.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamForEach.cpp
new file mode 100644
index 0000000000..26e00c21e5
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamForEach.cpp
@@ -0,0 +1,126 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamForEach {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PrefixIncrementFunctor {
+  KOKKOS_INLINE_FUNCTION
+  void operator()(ValueType& val) const { ++val; }
+};
+
+template <class DataViewType, class UnaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  int m_apiPick;
+  UnaryPredType m_unaryPred;
+
+  TestFunctorA(const DataViewType dataView, int apiPick,
+               UnaryPredType unaryPred)
+      : m_dataView(dataView), m_apiPick(apiPick), m_unaryPred(unaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+
+    switch (m_apiPick) {
+      case 0: {
+        KE::for_each(member, KE::begin(myRowViewFrom), KE::end(myRowViewFrom),
+                     m_unaryPred);
+        break;
+      }
+
+      case 1: {
+        KE::for_each(member, myRowViewFrom, m_unaryPred);
+        break;
+      }
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level for_each
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, _] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // for_each modifies dataView, so make a separated host copy of if
+  auto dataViewBeforeOp_h = create_host_space_copy(dataView);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  PrefixIncrementFunctor<ValueType> unaryPred;
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, apiId, unaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataViewAfterOp_h.extent(1); ++j) {
+      ASSERT_DOUBLE_EQ(dataViewBeforeOp_h(i, j) + 1, dataViewAfterOp_h(i, j));
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_for_each_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamForEach
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamForEachN.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamForEachN.cpp
new file mode 100644
index 0000000000..0f4793490f
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamForEachN.cpp
@@ -0,0 +1,144 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamForEachN {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PrefixIncrementFunctor {
+  KOKKOS_INLINE_FUNCTION
+  void operator()(ValueType& val) const { ++val; }
+};
+
+template <class DataViewType, class NViewType, class UnaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  NViewType m_nView;
+  int m_apiPick;
+  UnaryPredType m_unaryPred;
+
+  TestFunctorA(const DataViewType dataView, const NViewType nView, int apiPick,
+               UnaryPredType unaryPred)
+      : m_dataView(dataView),
+        m_nView(nView),
+        m_apiPick(apiPick),
+        m_unaryPred(unaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    const auto n          = m_nView(myRowIndex);
+
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+
+    switch (m_apiPick) {
+      case 0: {
+        KE::for_each_n(member, KE::begin(myRowViewFrom), n, m_unaryPred);
+        break;
+      }
+
+      case 1: {
+        KE::for_each_n(member, myRowViewFrom, n, m_unaryPred);
+        break;
+      }
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level for_each_n
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, _] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // for_each modifies dataView, so make a separated host copy of if
+  auto dataViewBeforeOp_h = create_host_space_copy(dataView);
+
+  Kokkos::View<std::size_t*> nView("nView", numTeams);
+  auto nView_h = create_host_space_copy(nView);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(nView_h, pool, 0, numCols);
+
+  Kokkos::deep_copy(nView, nView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  PrefixIncrementFunctor<ValueType> unaryPred;
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, nView, apiId, unaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0, n = 0; j < dataViewAfterOp_h.extent(1); ++j, ++n) {
+      if (n < nView_h(i)) {
+        ASSERT_DOUBLE_EQ(dataViewBeforeOp_h(i, j) + 1, dataViewAfterOp_h(i, j));
+      } else {
+        ASSERT_DOUBLE_EQ(dataViewBeforeOp_h(i, j), dataViewAfterOp_h(i, j));
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_for_each_n_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamForEachN
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamGenerate.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamGenerate.cpp
new file mode 100644
index 0000000000..28c10c95d2
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamGenerate.cpp
@@ -0,0 +1,116 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamGenerate {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct Generator {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()() const { return static_cast<ValueType>(23); }
+};
+
+template <class ViewType>
+struct TestFunctorA {
+  ViewType m_view;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, int apiPick)
+      : m_view(view), m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+
+    using value_type = typename ViewType::value_type;
+    if (m_apiPick == 0) {
+      KE::generate(member, KE::begin(myRowView), KE::end(myRowView),
+                   Generator<value_type>());
+    } else if (m_apiPick == 1) {
+      KE::generate(member, myRowView, Generator<value_type>());
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill a view and then do a team-level generate
+     with one team per row to assign to each element a value
+     produced via a generator functor
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range. Pick range so that it does NOT
+  // contain the value produced by the generator (see top of file)
+  // otherwise test check below is ill-posed
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{105, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataViewAfterOp_h.extent(1); ++j) {
+      EXPECT_TRUE(dataViewAfterOp_h(i, j) == static_cast<ValueType>(23));
+      EXPECT_TRUE(dataViewAfterOp_h(i, j) != cloneOfDataViewBeforeOp_h(i, j));
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 51153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_generate_team_test, test_unary_op) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamGenerate
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamGenerate_n.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamGenerate_n.cpp
new file mode 100644
index 0000000000..4b66dd9131
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamGenerate_n.cpp
@@ -0,0 +1,179 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamGenerate_n {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GenerateFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()() const { return static_cast<ValueType>(23); }
+};
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_count;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t count, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_count(count),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto leagueRank = member.league_rank();
+    const auto myRowIndex = leagueRank;
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    using value_type = typename ViewType::value_type;
+    if (m_apiPick == 0) {
+      auto it = KE::generate_n(member, KE::begin(myRowView), m_count,
+                               GenerateFunctor<value_type>());
+
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::generate_n(member, myRowView, m_count,
+                               GenerateFunctor<value_type>());
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t count,
+            int apiId) {
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range. Pick range so that it does NOT
+  // contain the value produced by the generator (see top of file)
+  // otherwise test check below is ill-posed
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{105, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expected value
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, count,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    // check that values match what we expect
+    for (std::size_t j = 0; j < count; ++j) {
+      ASSERT_EQ(dataViewAfterOp_h(i, j), static_cast<ValueType>(23));
+      EXPECT_TRUE(dataViewAfterOp_h(i, j) != cloneOfDataViewBeforeOp_h(i, j));
+    }
+    // all other elements should be unchanged from before op
+    for (std::size_t j = count; j < numCols; ++j) {
+      ASSERT_EQ(dataViewAfterOp_h(i, j), cloneOfDataViewBeforeOp_h(i, j));
+    }
+
+    // check that returned iterators are correct
+    if (count > 0) {
+      ASSERT_EQ(distancesView_h(i), std::size_t(count));
+    } else {
+      ASSERT_EQ(distancesView_h(i), std::size_t(0));
+    }
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  // prepare a map where, for a given set of num cols
+  // we provide a list of counts of elements to generate
+  // key = num of columns
+  // value = list of num of elemenents to generate
+  const std::map<int, std::vector<int>> scenarios = {
+      {0, {0}},
+      {2, {0, 1, 2}},
+      {6, {0, 1, 2, 5}},
+      {13, {0, 1, 2, 8, 11}},
+      {56, {0, 1, 2, 8, 11, 33, 56}},
+      {123, {0, 1, 11, 33, 56, 89, 112}}};
+
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& scenario : scenarios) {
+      const std::size_t numCols = scenario.first;
+      for (int countToGenerate : scenario.second) {
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, countToGenerate, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_generate_n_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamGenerate_n
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamInclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamInclusiveScan.cpp
new file mode 100644
index 0000000000..b5f4cdd612
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamInclusiveScan.cpp
@@ -0,0 +1,297 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include "std_algorithms/Kokkos_BeginEnd.hpp"
+
+namespace Test {
+namespace stdalgos {
+namespace TeamInclusiveScan {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION constexpr ValueType operator()(
+      const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class InitValuesViewType,
+          class BinaryOpType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  InitValuesViewType m_initValuesView;
+  BinaryOpType m_binaryOp;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               const InitValuesViewType initValuesView, BinaryOpType binaryOp,
+               int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_initValuesView(initValuesView),
+        m_binaryOp(binaryOp),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto srcRow      = Kokkos::subview(m_sourceView, rowIndex, Kokkos::ALL());
+    const auto first = KE::cbegin(srcRow);
+    const auto last  = KE::cend(srcRow);
+    auto destRow     = Kokkos::subview(m_destView, rowIndex, Kokkos::ALL());
+    const auto firstDest = KE::begin(destRow);
+
+    const auto initVal   = m_initValuesView(rowIndex);
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it    = KE::inclusive_scan(member, first, last, firstDest);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::inclusive_scan(member, srcRow, destRow);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 2: {
+        auto it =
+            KE::inclusive_scan(member, first, last, firstDest, m_binaryOp);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 3: {
+        auto it    = KE::inclusive_scan(member, srcRow, destRow, m_binaryOp);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 4: {
+        auto it = KE::inclusive_scan(member, first, last, firstDest, m_binaryOp,
+                                     initVal);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 5: {
+        auto it =
+            KE::inclusive_scan(member, srcRow, destRow, m_binaryOp, initVal);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+struct InPlace {};
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level inclusive_scan
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [sourceView, sourceViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // inclusive_scan returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the beginning
+  // of the interval that team operates on and then we check that these
+  // distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  PlusFunctor<ValueType> binaryOp;
+
+  // Create view of reduce init values to be used by test cases
+  Kokkos::View<ValueType*, Kokkos::DefaultHostExecutionSpace> initValuesView_h(
+      "initValuesView_h", numTeams);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(initValuesView_h, pool, lowerBound, upperBound);
+
+  auto initValuesView =
+      Kokkos::create_mirror_view_and_copy(space_t(), initValuesView_h);
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    TestFunctorA fnc(sourceView, sourceView, distancesView,
+                     intraTeamSentinelView, initValuesView, binaryOp, apiId);
+    Kokkos::parallel_for(policy, fnc);
+  } else {
+    TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                     initValuesView, binaryOp, apiId);
+    Kokkos::parallel_for(policy, fnc);
+  }
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto srcRow    = Kokkos::subview(sourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto first     = KE::begin(srcRow);
+    auto last      = KE::end(srcRow);
+    auto destRow   = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto firstDest = KE::begin(destRow);
+    auto initValue = initValuesView_h(i);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+// libstdc++ as provided by GCC 8 does not have inclusive_scan and
+// for GCC 9.1, 9.2 fails to compile for missing overload not accepting policy
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+#define inclusive_scan testing_inclusive_scan
+#else
+#define inclusive_scan std::inclusive_scan
+#endif
+
+    switch (apiId) {
+      case 0:
+      case 1: {
+        auto it                       = inclusive_scan(first, last, firstDest);
+        const std::size_t stdDistance = KE::distance(firstDest, it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        auto it = inclusive_scan(first, last, firstDest, binaryOp);
+        const std::size_t stdDistance = KE::distance(firstDest, it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+
+      case 4:
+      case 5: {
+        auto it = inclusive_scan(first, last, firstDest, binaryOp, initValue);
+        const std::size_t stdDistance = KE::distance(firstDest, it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+    }
+
+#undef inclusive_scan
+  }
+
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    auto dataViewAfterOp_h = create_host_space_copy(sourceView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  } else {
+    auto dataViewAfterOp_h = create_host_space_copy(destView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  }
+}
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3, 4, 5}) {
+        test_A<LayoutTag, ValueType, InPlaceOrVoid>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_inclusive_scan_team_test, test) {
+// FIXME_OPENMPTARGET
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  GTEST_SKIP() << "the test is known to fail with OpenMPTarget on Intel GPUs";
+#endif
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+
+  run_all_scenarios<DynamicTag, double, InPlace>();
+  run_all_scenarios<StridedTwoRowsTag, int, InPlace>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned, InPlace>();
+}
+
+}  // namespace TeamInclusiveScan
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamIsPartitioned.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamIsPartitioned.cpp
new file mode 100644
index 0000000000..21da333e75
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamIsPartitioned.cpp
@@ -0,0 +1,255 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamIsPartitioned {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int a, int b, std::size_t seedIn) : m_dist(a, b) {
+    m_gen.seed(seedIn);
+  }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class ViewType, class ReturnViewType, class IntraTeamSentinelView,
+          class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  ReturnViewType m_returnsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  ValueType m_threshold;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const ReturnViewType returnsView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType threshold, int apiPick)
+      : m_view(view),
+        m_returnsView(returnsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_threshold(threshold),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    bool result           = false;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      result = KE::is_partitioned(member, KE::cbegin(myRowView),
+                                  KE::cend(myRowView), predicate);
+
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_returnsView(myRowIndex) = result; });
+    } else if (m_apiPick == 1) {
+      result = KE::is_partitioned(member, myRowView, predicate);
+
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_returnsView(myRowIndex) = result; });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_returnsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId,
+            const std::string& sIn) {
+  /* description:
+     use a rank-2 view randomly filled with values in a range (a,b)
+     and run a team-level is_partitioned with predicate = IsGreaterThanValue
+     where threshold is set to a number larger than b above
+   */
+  const auto threshold           = static_cast<ValueType>(1103);
+  const auto valueForSureGreater = static_cast<ValueType>(2103);
+  const auto valueForSureSmaller = static_cast<ValueType>(111);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto dataView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "dataView");
+
+  // dataView might not deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  if (sIn == "trivialEmpty") {
+    // do nothing
+  }
+
+  else if (sIn == "allTrue") {
+    // randomly fill with values greater than threshold
+    // so that all elements in each row satisfy the predicate
+    // so this counts as being partitioned
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    Kokkos::fill_random(dataView_dc_h, pool, ValueType(2001), ValueType(2501));
+  }
+
+  else if (sIn == "allFalse") {
+    // randomly fill the view with values smaller than threshold
+    // and even in this case each row counts as partitioned
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    Kokkos::fill_random(dataView_dc_h, pool, ValueType(0), ValueType(101));
+  }
+
+  else if (sIn == "random") {
+    // randomly select a location and make all values before that
+    // larger than threshol and all values after to be smaller than threshold
+    // so that this picked location does partition the range
+    UnifDist<int> indexProducer(0, numCols - 1, 3432779);
+    for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+      const std::size_t a = indexProducer();
+      for (std::size_t j = 0; j < a; ++j) {
+        dataView_dc_h(i, j) = valueForSureGreater;
+      }
+      for (std::size_t j = a; j < numCols; ++j) {
+        dataView_dc_h(i, j) = valueForSureSmaller;
+      }
+    }
+  }
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(dataView_dc, dataView);
+  Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result
+  // and then we check that these match what we expect
+  Kokkos::View<bool*> returnView("returnView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, returnView, intraTeamSentinelView, threshold,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto returnView_h            = create_host_space_copy(returnView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+
+  for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(dataView_dc_h, i, Kokkos::ALL());
+    const bool stdResult =
+        std::is_partitioned(KE::cbegin(myRow), KE::cend(myRow), predicate);
+    // our result must match std
+    EXPECT_TRUE(stdResult == returnView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  // dataView should remain unchanged
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(dataView_dc_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const std::string& name, const std::vector<int>& cols) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : cols) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId, name);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_is_partitioned_team_test, empty) {
+  const std::string name      = "trivialEmpty";
+  const std::vector<int> cols = {0};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_is_partitioned_team_test, all_true) {
+  const std::string name      = "allTrue";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_is_partitioned_team_test, all_false) {
+  const std::string name      = "allFalse";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_is_partitioned_team_test, random) {
+  const std::string name      = "random";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+}  // namespace TeamIsPartitioned
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamIsSorted.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamIsSorted.cpp
new file mode 100644
index 0000000000..850e80dde1
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamIsSorted.cpp
@@ -0,0 +1,209 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamIsSorted {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class ReturnViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  ReturnViewType m_returnsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const ReturnViewType returnsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_returnsView(returnsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    bool result           = false;
+
+    if (m_apiPick == 0) {
+      result =
+          KE::is_sorted(member, KE::cbegin(myRowView), KE::cend(myRowView));
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_returnsView(myRowIndex) = result; });
+    } else if (m_apiPick == 1) {
+      result = KE::is_sorted(member, myRowView);
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_returnsView(myRowIndex) = result; });
+    }
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+    else if (m_apiPick == 2) {
+      using value_type = typename ViewType::value_type;
+      result = KE::is_sorted(member, KE::cbegin(myRowView), KE::cend(myRowView),
+                             CustomLessThanComparator<value_type>{});
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_returnsView(myRowIndex) = result; });
+    } else if (m_apiPick == 3) {
+      using value_type = typename ViewType::value_type;
+      result           = KE::is_sorted(member, myRowView,
+                             CustomLessThanComparator<value_type>{});
+      Kokkos::single(Kokkos::PerTeam(member),
+                     [=, *this]() { m_returnsView(myRowIndex) = result; });
+    }
+#endif
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_returnsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId,
+            bool makeDataSortedOnPurpose) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level is_sorted
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto dataView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "dataView");
+
+  // dataView might not deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  if (makeDataSortedOnPurpose) {
+    for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+      for (std::size_t j = 0; j < dataView_dc_h.extent(1); ++j) {
+        dataView_dc_h(i, j) = ValueType(j);
+      }
+    }
+  } else {
+    // randomly fill the view
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(45234977);
+    Kokkos::fill_random(dataView_dc_h, pool, ValueType{5}, ValueType{1545});
+  }
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(dataView_dc, dataView);
+  Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result
+  // and then we check that these match what we expect
+  Kokkos::View<bool*> returnView("returnView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, returnView, intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto returnView_h            = create_host_space_copy(returnView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(dataView_dc_h, i, Kokkos::ALL());
+
+    bool stdResult;
+    if (apiId <= 1) {
+      stdResult = std::is_sorted(KE::cbegin(myRow), KE::cend(myRow));
+    } else {
+      stdResult = std::is_sorted(KE::cbegin(myRow), KE::cend(myRow),
+                                 CustomLessThanComparator<ValueType>{});
+    }
+
+    // our result must match std
+    EXPECT_TRUE(stdResult == returnView_h(i));
+
+    // check also since we know in advance when data is really sorted.
+    // note that we have to be careful because when we have only
+    // 0, 1 columns, then the data is sorted by definition
+    // and when we have 2 columns it is very likely it is sorted
+    // so only do the following check for large enough cols count
+    if (numCols <= 1) {
+      EXPECT_TRUE(stdResult == true);
+    } else if (numCols > 10) {
+      EXPECT_TRUE(stdResult == makeDataSortedOnPurpose);
+    }
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  // dataView should remain unchanged
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(dataView_dc_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(bool makeDataSortedOnPurpose) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 5153}) {
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+      for (int apiId : {0, 1, 2, 3}) {
+#else
+      for (int apiId : {0, 1}) {
+#endif
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId,
+                                     makeDataSortedOnPurpose);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_is_sorted_team_test,
+     test_data_almost_certainly_not_sorted) {
+  run_all_scenarios<DynamicTag, double>(false);
+  run_all_scenarios<StridedTwoRowsTag, double>(false);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(false);
+}
+
+TEST(std_algorithms_is_sorted_team_test, test_data_certainly_sorted) {
+  run_all_scenarios<DynamicTag, double>(true);
+  run_all_scenarios<StridedTwoRowsTag, double>(true);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(true);
+}
+
+}  // namespace TeamIsSorted
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamIsSortedUntil.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamIsSortedUntil.cpp
new file mode 100644
index 0000000000..e3b95527c7
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamIsSortedUntil.cpp
@@ -0,0 +1,275 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamIsSortedUntil {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int a, int b, std::size_t seedIn) : m_dist(a, b) {
+    m_gen.seed(seedIn);
+  }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto leagueRank = member.league_rank();
+    const auto myRowIndex = leagueRank;
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::is_sorted_until(member, KE::cbegin(myRowView),
+                                    KE::cend(myRowView));
+      resultDist = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::is_sorted_until(member, myRowView);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+    else if (m_apiPick == 2) {
+      using value_type = typename ViewType::value_type;
+      auto it          = KE::is_sorted_until(member, KE::cbegin(myRowView),
+                                    KE::cend(myRowView),
+                                    CustomLessThanComparator<value_type>{});
+      resultDist       = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 3) {
+      using value_type = typename ViewType::value_type;
+      auto it          = KE::is_sorted_until(member, myRowView,
+                                    CustomLessThanComparator<value_type>{});
+      resultDist       = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+#endif
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId,
+            const std::string& sIn) {
+  /* description:
+     use a rank-2 view and run a team-level is_sorted_until
+     for various trivial and non trivial scenarios
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto dataView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "dataView");
+
+  // dataView might not deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  if (sIn == "trivialEmpty" || sIn == "trivialOneElement") {
+    // do not do anything
+  }
+
+  else if (sIn == "nontrivialUntilLast") {
+    for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+      for (std::size_t j = 0; j < dataView_dc_h.extent(1); ++j) {
+        dataView_dc_h(i, j) = ValueType(j);
+      }
+    }
+  }
+
+  else if (sIn == "nontrivialRandom") {
+    // randomly fill the view
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    // make the range tight so that we have low likelihood of having
+    // sorted data by chance for small num of cols
+    Kokkos::fill_random(dataView_dc_h, pool, ValueType(113), ValueType(120));
+
+    /* pick randomly a location 0 < a < numCols-1/2
+       annd fill data so that:
+       - from 0 to a: is sorted
+       - from a to a+3: not sorted
+       - from a+3 to numCols-1: is sorted
+       this allows us to exercise that the algorithm returns
+       the larest sorted interval starting from 0
+    */
+    assert(numCols > 10);
+    const std::size_t midPoint = numCols / 2;
+
+    UnifDist<int> randPoolA(0, midPoint, 3432779);
+    for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+      const std::size_t a = randPoolA();
+      for (std::size_t j = 0; j < a; ++j) {
+        dataView_dc_h(i, j) = ValueType(j);
+      }
+      for (std::size_t j = a + 3; j < numCols; ++j) {
+        dataView_dc_h(i, j) = ValueType(j);
+      }
+    }
+  }
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(dataView_dc, dataView);
+  Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(dataView_dc_h, i, Kokkos::ALL());
+
+    std::size_t stdDistance = 0;
+    if (apiId <= 1) {
+      auto it     = std::is_sorted_until(KE::cbegin(myRow), KE::cend(myRow));
+      stdDistance = KE::distance(KE::cbegin(myRow), it);
+    } else {
+      auto it     = std::is_sorted_until(KE::cbegin(myRow), KE::cend(myRow),
+                                     CustomLessThanComparator<ValueType>{});
+      stdDistance = KE::distance(KE::cbegin(myRow), it);
+    }
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  // dataView should remain unchanged
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(dataView_dc_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const std::string& name, const std::vector<int>& cols) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : cols) {
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+      for (int apiId : {0, 1, 2, 3}) {
+#else
+      for (int apiId : {0, 1}) {
+#endif
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId, name);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_is_sorted_until_team_test, test_trivialA) {
+  const std::string name      = "trivialEmpty";
+  const std::vector<int> cols = {0};
+
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_is_sorted_until_team_test, test_trivialB) {
+  const std::string name      = "trivialOneElement";
+  const std::vector<int> cols = {1};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_is_sorted_until_team_test, test_nontrivialA) {
+  const std::string name      = "nontrivialUntilLast";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_is_sorted_until_team_test, test_nontrivialB) {
+  const std::string name      = "nontrivialRandom";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+}  // namespace TeamIsSortedUntil
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamLexicographicalCompare.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamLexicographicalCompare.cpp
new file mode 100644
index 0000000000..c377b9fec8
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamLexicographicalCompare.cpp
@@ -0,0 +1,286 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamLexicographicalCompare {
+
+namespace KE = Kokkos::Experimental;
+
+enum class TestCaseType { ViewsAreEqual, FirstIsLess, FirstIsGreater };
+
+template <class ValueType>
+struct LessFunctor {
+  KOKKOS_INLINE_FUNCTION bool operator()(const ValueType& lhs,
+                                         const ValueType& rhs) const {
+    return lhs < rhs;
+  }
+};
+
+template <class DataViewType, class CompViewType, class ResultsViewType,
+          class IntraTeamSentinelView, class BinaryCompType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  CompViewType m_compView;
+  ResultsViewType m_resultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  BinaryCompType m_binaryComp;
+
+  TestFunctorA(const DataViewType dataView, const CompViewType compView,
+               const ResultsViewType resultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               BinaryCompType binaryComp)
+      : m_dataView(dataView),
+        m_compView(compView),
+        m_resultsView(resultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_binaryComp(binaryComp) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto rowData         = Kokkos::subview(m_dataView, rowIndex, Kokkos::ALL());
+    const auto dataBegin = KE::cbegin(rowData);
+    const auto dataEnd   = KE::cend(rowData);
+
+    auto rowComp         = Kokkos::subview(m_compView, rowIndex, Kokkos::ALL());
+    const auto compBegin = KE::cbegin(rowComp);
+    const auto compEnd   = KE::cend(rowComp);
+
+    bool result = false;
+    switch (m_apiPick) {
+      case 0: {
+        result = KE::lexicographical_compare(member, dataBegin, dataEnd,
+                                             compBegin, compEnd);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 1: {
+        result = KE::lexicographical_compare(member, rowData, rowComp);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 2: {
+        result = KE::lexicographical_compare(member, dataBegin, dataEnd,
+                                             compBegin, compEnd, m_binaryComp);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 3: {
+        result =
+            KE::lexicographical_compare(member, rowData, rowComp, m_binaryComp);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_resultsView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const TestCaseType testCase, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level lexicographical_compare
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // create a view to compare it with dataView. If testCase == ViewsAreEqual,
+  // compView is a copy of dataView. If testCase == FirstIsLess, we want the
+  // dataView to be lexicographically less (and compView - greater). If testCase
+  // == FirstIsGreater, we want the dataView to be lexicographically greater
+  // (and compView - less).
+  auto compEqualView   = create_deep_copyable_compatible_clone(dataView);
+  auto compEqualView_h = create_mirror_view(Kokkos::HostSpace(), compEqualView);
+  Kokkos::deep_copy(compEqualView_h, dataViewBeforeOp_h);
+  const auto middle = numCols / 2;
+  switch (testCase) {
+    case TestCaseType::ViewsAreEqual: {
+      // Do nothing - deep_copy was already done
+      break;
+    }
+
+    case TestCaseType::FirstIsLess: {
+      for (std::size_t i = 0; i < compEqualView_h.extent(0); ++i) {
+        compEqualView_h(i, middle) += 1;
+      }
+
+      break;
+    }
+
+    case TestCaseType::FirstIsGreater: {
+      for (std::size_t i = 0; i < compEqualView_h.extent(0); ++i) {
+        compEqualView_h(i, middle) -= 1;
+      }
+
+      break;
+    }
+  }
+
+  Kokkos::deep_copy(compEqualView, compEqualView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the view to store results of equal()
+  Kokkos::View<bool*> resultsView("resultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  LessFunctor<ValueType> binaryComp{};
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, compEqualView, resultsView, intraTeamSentinelView,
+                   apiId, binaryComp);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto resultsView_h           = create_host_space_copy(resultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowData = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const auto dataBegin = KE::cbegin(rowData);
+    const auto dataEnd   = KE::cend(rowData);
+
+    auto rowComp         = Kokkos::subview(compEqualView_h, i, Kokkos::ALL());
+    const auto compBegin = KE::cbegin(rowComp);
+    const auto compEnd   = KE::cend(rowComp);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const bool result = std::lexicographical_compare(dataBegin, dataEnd,
+                                                         compBegin, compEnd);
+
+        switch (testCase) {
+          case TestCaseType::ViewsAreEqual:
+          case TestCaseType::FirstIsGreater: {
+            EXPECT_FALSE(resultsView_h(i));
+            ASSERT_EQ(result, resultsView_h(i));
+            break;
+          }
+
+          case TestCaseType::FirstIsLess: {
+            EXPECT_TRUE(resultsView_h(i));
+            ASSERT_EQ(result, resultsView_h(i));
+            break;
+          }
+        }
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const bool result = std::lexicographical_compare(
+            dataBegin, dataEnd, compBegin, compEnd, binaryComp);
+
+        switch (testCase) {
+          case TestCaseType::ViewsAreEqual:
+          case TestCaseType::FirstIsGreater: {
+            EXPECT_FALSE(resultsView_h(i));
+            ASSERT_EQ(result, resultsView_h(i));
+            break;
+          }
+
+          case TestCaseType::FirstIsLess: {
+            EXPECT_TRUE(resultsView_h(i));
+            ASSERT_EQ(result, resultsView_h(i));
+            break;
+          }
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const TestCaseType testCase) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(testCase, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_lexicographical_compare_team_test, views_are_equal) {
+  constexpr TestCaseType testCaseType = TestCaseType::ViewsAreEqual;
+  run_all_scenarios<DynamicTag, double>(testCaseType);
+  run_all_scenarios<StridedTwoRowsTag, int>(testCaseType);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(testCaseType);
+}
+
+TEST(std_algorithms_lexicographical_compare_team_test, first_view_is_less) {
+  constexpr TestCaseType testCaseType = TestCaseType::FirstIsLess;
+  run_all_scenarios<DynamicTag, double>(testCaseType);
+  run_all_scenarios<StridedTwoRowsTag, int>(testCaseType);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(testCaseType);
+}
+
+TEST(std_algorithms_lexicographical_compare_team_test, first_view_is_greater) {
+  constexpr TestCaseType testCaseType = TestCaseType::FirstIsGreater;
+  run_all_scenarios<DynamicTag, double>(testCaseType);
+  run_all_scenarios<StridedTwoRowsTag, int>(testCaseType);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(testCaseType);
+}
+
+}  // namespace TeamLexicographicalCompare
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamMaxElement.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamMaxElement.cpp
new file mode 100644
index 0000000000..283525dbd1
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamMaxElement.cpp
@@ -0,0 +1,182 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamMaxElement {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::max_element(member, KE::cbegin(myRowView), KE::cend(myRowView));
+      resultDist = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 1) {
+      auto it    = KE::max_element(member, myRowView);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+    else if (m_apiPick == 2) {
+      using value_type = typename ViewType::value_type;
+      auto it =
+          KE::max_element(member, KE::cbegin(myRowView), KE::cend(myRowView),
+                          CustomLessThanComparator<value_type>{});
+      resultDist = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 3) {
+      using value_type = typename ViewType::value_type;
+      auto it          = KE::max_element(member, myRowView,
+                                CustomLessThanComparator<value_type>{});
+      resultDist       = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+#endif
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team-level KE::max_element on a rank-2 view where
+     data is filled randomly and we use one team per row.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{0, 1153}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+
+    std::size_t stdDistance = 0;
+    if (apiId <= 1) {
+      auto it     = std::max_element(KE::cbegin(myRow), KE::cend(myRow));
+      stdDistance = KE::distance(KE::cbegin(myRow), it);
+    } else {
+      auto it     = std::max_element(KE::cbegin(myRow), KE::cend(myRow),
+                                 CustomLessThanComparator<value_type>{});
+      stdDistance = KE::distance(KE::cbegin(myRow), it);
+    }
+
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  // dataView should remain unchanged
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 5113}) {
+      // for OpenMPTarget we need to avod api accepting a custom
+      // comparator because it is not supported
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_max_element_team_test, test) {
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+  run_all_scenarios<DynamicTag, int>();
+  run_all_scenarios<StridedTwoRowsTag, double>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+#endif
+}
+
+}  // namespace TeamMaxElement
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamMinElement.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamMinElement.cpp
new file mode 100644
index 0000000000..8579b48315
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamMinElement.cpp
@@ -0,0 +1,181 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamMinElement {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::min_element(member, KE::cbegin(myRowView), KE::cend(myRowView));
+      resultDist = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 1) {
+      auto it    = KE::min_element(member, myRowView);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+    else if (m_apiPick == 2) {
+      using value_type = typename ViewType::value_type;
+      auto it =
+          KE::min_element(member, KE::cbegin(myRowView), KE::cend(myRowView),
+                          CustomLessThanComparator<value_type>{});
+      resultDist = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 3) {
+      using value_type = typename ViewType::value_type;
+      auto it          = KE::min_element(member, myRowView,
+                                CustomLessThanComparator<value_type>{});
+      resultDist       = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+#endif
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team-level KE::min_element on a rank-2 view where
+     data is filled randomly and we use one team per row.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{0, 1153}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+
+    std::size_t stdDistance = 0;
+    if (apiId <= 1) {
+      auto it     = std::min_element(KE::cbegin(myRow), KE::cend(myRow));
+      stdDistance = KE::distance(KE::cbegin(myRow), it);
+    } else {
+      auto it     = std::min_element(KE::cbegin(myRow), KE::cend(myRow),
+                                 CustomLessThanComparator<value_type>{});
+      stdDistance = KE::distance(KE::cbegin(myRow), it);
+    }
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  // dataView should remain unchanged
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 5113}) {
+      // for OpenMPTarget we need to avod api accepting a custom
+      // comparator because it is not supported
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_min_element_team_test, test) {
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+  run_all_scenarios<DynamicTag, int>();
+  run_all_scenarios<StridedTwoRowsTag, double>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+#endif
+}
+
+}  // namespace TeamMinElement
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamMinMaxElement.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamMinMaxElement.cpp
new file mode 100644
index 0000000000..51010fdff5
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamMinMaxElement.cpp
@@ -0,0 +1,200 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamMinMaxElement {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist1 = 0;
+    ptrdiff_t resultDist2 = 0;
+
+    if (m_apiPick == 0) {
+      auto itPair = KE::minmax_element(member, KE::cbegin(myRowView),
+                                       KE::cend(myRowView));
+      resultDist1 = KE::distance(KE::cbegin(myRowView), itPair.first);
+      resultDist2 = KE::distance(KE::cbegin(myRowView), itPair.second);
+
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex, 0) = resultDist1;
+        m_distancesView(myRowIndex, 1) = resultDist2;
+      });
+    }
+
+    else if (m_apiPick == 1) {
+      auto itPair = KE::minmax_element(member, myRowView);
+      resultDist1 = KE::distance(KE::begin(myRowView), itPair.first);
+      resultDist2 = KE::distance(KE::begin(myRowView), itPair.second);
+
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex, 0) = resultDist1;
+        m_distancesView(myRowIndex, 1) = resultDist2;
+      });
+    }
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+    else if (m_apiPick == 2) {
+      using value_type = typename ViewType::value_type;
+      auto itPair =
+          KE::minmax_element(member, KE::cbegin(myRowView), KE::cend(myRowView),
+                             CustomLessThanComparator<value_type>{});
+      resultDist1 = KE::distance(KE::cbegin(myRowView), itPair.first);
+      resultDist2 = KE::distance(KE::cbegin(myRowView), itPair.second);
+
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex, 0) = resultDist1;
+        m_distancesView(myRowIndex, 1) = resultDist2;
+      });
+    }
+
+    else if (m_apiPick == 3) {
+      using value_type = typename ViewType::value_type;
+      auto itPair      = KE::minmax_element(member, myRowView,
+                                       CustomLessThanComparator<value_type>{});
+      resultDist1      = KE::distance(KE::begin(myRowView), itPair.first);
+      resultDist2      = KE::distance(KE::begin(myRowView), itPair.second);
+
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex, 0) = resultDist1;
+        m_distancesView(myRowIndex, 1) = resultDist2;
+      });
+    }
+#endif
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck1 = team_members_have_matching_result(
+        member, resultDist1, m_distancesView(myRowIndex, 0));
+    const bool intraTeamCheck2 = team_members_have_matching_result(
+        member, resultDist2, m_distancesView(myRowIndex, 1));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck1 && intraTeamCheck2;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team-level KE::minmax_element on a rank-2 view where
+     data is filled randomly and we use one team per row.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{0, 1153}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned value from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t**> distancesView("distancesView", numTeams, 2);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+
+    std::size_t stdDistance[2];
+    if (apiId <= 1) {
+      auto itPair    = std::minmax_element(KE::cbegin(myRow), KE::cend(myRow));
+      stdDistance[0] = KE::distance(KE::cbegin(myRow), itPair.first);
+      stdDistance[1] = KE::distance(KE::cbegin(myRow), itPair.second);
+    } else {
+      auto itPair    = std::minmax_element(KE::cbegin(myRow), KE::cend(myRow),
+                                        CustomLessThanComparator<value_type>{});
+      stdDistance[0] = KE::distance(KE::cbegin(myRow), itPair.first);
+      stdDistance[1] = KE::distance(KE::cbegin(myRow), itPair.second);
+    }
+
+    ASSERT_EQ(stdDistance[0], distancesView_h(i, 0));
+    ASSERT_EQ(stdDistance[1], distancesView_h(i, 1));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  // dataView should remain unchanged
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 5113}) {
+      // for OpenMPTarget we need to avod api accepting a custom
+      // comparator because it is not supported
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_minmax_element_team_test, test) {
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+  run_all_scenarios<DynamicTag, int>();
+  run_all_scenarios<StridedTwoRowsTag, double>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+#endif
+}
+
+}  // namespace TeamMinMaxElement
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamMismatch.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamMismatch.cpp
new file mode 100644
index 0000000000..84269511d8
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamMismatch.cpp
@@ -0,0 +1,283 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamMismatch {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct EqualFunctor {
+  KOKKOS_INLINE_FUNCTION bool operator()(const ValueType& lhs,
+                                         const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class CompViewType, class ResultsViewType,
+          class IntraTeamSentinelView, class BinaryOpType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  CompViewType m_compView;
+  ResultsViewType m_resultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  BinaryOpType m_binaryOp;
+
+  TestFunctorA(const DataViewType dataView, const CompViewType compView,
+               const ResultsViewType resultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               BinaryOpType binaryOp)
+      : m_dataView(dataView),
+        m_compView(compView),
+        m_resultsView(resultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_binaryOp(binaryOp) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto rowData   = Kokkos::subview(m_dataView, rowIndex, Kokkos::ALL());
+    auto dataBegin = KE::begin(rowData);
+    auto dataEnd   = KE::end(rowData);
+
+    auto rowComp   = Kokkos::subview(m_compView, rowIndex, Kokkos::ALL());
+    auto compBegin = KE::begin(rowComp);
+    auto compEnd   = KE::end(rowComp);
+
+    ptrdiff_t dataDist = 0;
+    ptrdiff_t compDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto [dataIt, compIt] =
+            KE::mismatch(member, dataBegin, dataEnd, compBegin, compEnd);
+
+        dataDist = KE::distance(dataBegin, dataIt);
+        compDist = KE::distance(compBegin, compIt);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_resultsView(rowIndex) = Kokkos::make_pair(dataDist, compDist);
+        });
+
+        break;
+      }
+
+      case 1: {
+        const auto [dataIt, compIt] = KE::mismatch(
+            member, dataBegin, dataEnd, compBegin, compEnd, m_binaryOp);
+
+        dataDist = KE::distance(dataBegin, dataIt);
+        compDist = KE::distance(compBegin, compIt);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_resultsView(rowIndex) = Kokkos::make_pair(dataDist, compDist);
+        });
+
+        break;
+      }
+
+      case 2: {
+        const auto [dataIt, compIt] = KE::mismatch(member, rowData, rowComp);
+
+        dataDist = KE::distance(dataBegin, dataIt);
+        compDist = KE::distance(compBegin, compIt);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_resultsView(rowIndex) = Kokkos::make_pair(dataDist, compDist);
+        });
+
+        break;
+      }
+
+      case 3: {
+        const auto [dataIt, compIt] =
+            KE::mismatch(member, rowData, rowComp, m_binaryOp);
+
+        dataDist = KE::distance(dataBegin, dataIt);
+        compDist = KE::distance(compBegin, compIt);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_resultsView(rowIndex) = Kokkos::make_pair(dataDist, compDist);
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck1 = team_members_have_matching_result(
+        member, dataDist, m_resultsView(rowIndex).first);
+    const bool intraTeamCheck2 = team_members_have_matching_result(
+        member, compDist, m_resultsView(rowIndex).second);
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck1 && intraTeamCheck2;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool viewsAreEqual, std::size_t numTeams, std::size_t numCols,
+            int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level mismatch
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // create a view to compare it with dataView. If viewsAreEqual == true,
+  // compView is a copy of dataView. If viewsAreEqual == false, compView is
+  // randomly filled
+  auto compView   = create_deep_copyable_compatible_clone(dataView);
+  auto compView_h = create_mirror_view(Kokkos::HostSpace(), compView);
+  if (viewsAreEqual) {
+    Kokkos::deep_copy(compView_h, dataViewBeforeOp_h);
+  } else {
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(lowerBound * upperBound);
+    Kokkos::fill_random(compView_h, pool, lowerBound, upperBound);
+  }
+
+  Kokkos::deep_copy(compView, compView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the view to store results of mismatch()
+  Kokkos::View<Kokkos::pair<std::size_t, std::size_t>*> resultsView(
+      "resultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  EqualFunctor<ValueType> binaryPred{};
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, compView, resultsView, intraTeamSentinelView,
+                   apiId, binaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto resultsView_h           = create_host_space_copy(resultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+    auto rowData = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+
+    const auto dataBegin = KE::cbegin(rowData);
+    const auto dataEnd   = KE::cend(rowData);
+
+    const std::size_t dataBeginEndDist = KE::distance(dataBegin, dataEnd);
+
+    auto rowComp = Kokkos::subview(compView_h, i, Kokkos::ALL());
+
+    const auto compBegin = KE::cbegin(rowComp);
+    const auto compEnd   = KE::cend(rowComp);
+
+    const std::size_t compBeginEndDist = KE::distance(compBegin, compEnd);
+
+    switch (apiId) {
+      case 0:
+      case 2: {
+        const auto [dataIt, compIt] =
+            std::mismatch(dataBegin, dataEnd, compBegin, compEnd);
+
+        const std::size_t dataDist = KE::distance(dataBegin, dataIt);
+        const std::size_t compDist = KE::distance(compBegin, compIt);
+
+        if (viewsAreEqual) {
+          ASSERT_EQ(dataBeginEndDist, resultsView_h(i).first);
+          ASSERT_EQ(compBeginEndDist, resultsView_h(i).second);
+        } else {
+          ASSERT_EQ(dataDist, resultsView_h(i).first);
+          ASSERT_EQ(compDist, resultsView_h(i).second);
+        }
+
+        break;
+      }
+
+      case 1:
+      case 3: {
+        const auto [dataIt, compIt] =
+            std::mismatch(dataBegin, dataEnd, compBegin, compEnd, binaryPred);
+
+        const std::size_t dataDist = KE::distance(dataBegin, dataIt);
+        const std::size_t compDist = KE::distance(compBegin, compIt);
+
+        if (viewsAreEqual) {
+          ASSERT_EQ(dataBeginEndDist, resultsView_h(i).first);
+          ASSERT_EQ(compBeginEndDist, resultsView_h(i).second);
+        } else {
+          ASSERT_EQ(dataDist, resultsView_h(i).first);
+          ASSERT_EQ(compDist, resultsView_h(i).second);
+        }
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool viewsAreEqual) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(viewsAreEqual, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_mismatch_team_test, views_are_equal) {
+  constexpr bool viewsAreEqual = true;
+  run_all_scenarios<DynamicTag, double>(viewsAreEqual);
+  run_all_scenarios<StridedTwoRowsTag, int>(viewsAreEqual);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(viewsAreEqual);
+}
+
+TEST(std_algorithms_mismatch_team_test, views_are_not_equal) {
+  constexpr bool viewsAreEqual = false;
+  run_all_scenarios<DynamicTag, double>(viewsAreEqual);
+  run_all_scenarios<StridedTwoRowsTag, int>(viewsAreEqual);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(viewsAreEqual);
+}
+
+}  // namespace TeamMismatch
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamMove.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamMove.cpp
new file mode 100644
index 0000000000..1122d6d554
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamMove.cpp
@@ -0,0 +1,161 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamMove {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::move(member, KE::begin(myRowViewFrom),
+                         KE::end(myRowViewFrom), KE::begin(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 1) {
+      auto it    = KE::move(member, myRowViewFrom, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill a source view, do team level KE::move into a destination
+     view.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  // make host copy of destView that should remain unchanged
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  // KE::move has been applied to sourceView, so we should
+  // NOT use sourceView henceforth, becuase all its elements
+  // have been moved from.
+
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < destViewBeforeOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < destViewBeforeOp_h.extent(1); ++j) {
+      ASSERT_EQ(destViewBeforeOp_h(i, j), ValueType(0));
+      EXPECT_TRUE(destViewAfterOp_h(i, j) != destViewBeforeOp_h(i, j));
+    }
+    // each team should return an iterator past the last column
+    EXPECT_TRUE(distancesView_h(i) == numCols);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  expect_equal_host_views(cloneOfSourceViewBeforeOp_h, destViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_move_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamMove
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamMoveBackward.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamMoveBackward.cpp
new file mode 100644
index 0000000000..eb46f0301f
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamMoveBackward.cpp
@@ -0,0 +1,170 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamMovebackward {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::move_backward(member, KE::cbegin(myRowViewFrom),
+                            KE::cend(myRowViewFrom), KE::end(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::move_backward(member, myRowViewFrom, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill a source view and do team KE::move_backward
+     into a destination view. The operation is done via a
+     team parfor with one row per team.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view: for a meaningful test, the destination
+  // view must have more columns that than the source view so that we
+  // can check that the elements are copied into the right place
+  constexpr std::size_t extra = 10;
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols + extra);
+  // make host copy of destView that should remain unchanged
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  // KE::move_backwar has been applied to sourceView, so we should
+  // NOT use sourceView henceforth, becuase all its elements
+  // have been moved from.
+
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < destViewAfterOp_h.extent(0); ++i) {
+    // first extra num of columns should be unchanged
+    for (std::size_t j = 0; j < extra; ++j) {
+      EXPECT_TRUE(destViewAfterOp_h(i, j) == destViewBeforeOp_h(i, j));
+    }
+
+    // after extra # of column (inclusive) should match the source view
+    for (std::size_t j = extra; j < destViewBeforeOp_h.extent(1); ++j) {
+      EXPECT_TRUE(cloneOfSourceViewBeforeOp_h(i, j - extra) ==
+                  destViewAfterOp_h(i, j));
+    }
+
+    // each team should have returned an interator whose distance
+    // from the beginning of the row should satisfy this
+    EXPECT_TRUE(distancesView_h(i) == extra);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_move_backward_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamMovebackward
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamNoneOf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamNoneOf.cpp
new file mode 100644
index 0000000000..373c6c662b
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamNoneOf.cpp
@@ -0,0 +1,165 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamNoneOf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class DataViewType, class NoneOfResultsViewType,
+          class IntraTeamSentinelView, class UnaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  NoneOfResultsViewType m_noneOfResultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  UnaryPredType m_unaryPred;
+
+  TestFunctorA(const DataViewType dataView,
+               const NoneOfResultsViewType noneOfResultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               UnaryPredType unaryPred)
+      : m_dataView(dataView),
+        m_noneOfResultsView(noneOfResultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_unaryPred(unaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    bool result        = false;
+
+    switch (m_apiPick) {
+      case 0: {
+        result = KE::none_of(member, KE::cbegin(myRowViewFrom),
+                             KE::cend(myRowViewFrom), m_unaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_noneOfResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 1: {
+        result = KE::none_of(member, myRowViewFrom, m_unaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_noneOfResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_noneOfResultsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level none_of
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result of its none_of
+  // call, and then we check that these match what we expect
+  Kokkos::View<bool*> noneOfResultsView("noneOfResultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  GreaterThanValueFunctor unaryPred{upperBound};
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, noneOfResultsView, intraTeamSentinelView, apiId,
+                   unaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto noneOfResultsView_h     = create_host_space_copy(noneOfResultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    const bool result =
+        std::none_of(KE::cbegin(rowFrom), KE::cend(rowFrom), unaryPred);
+    ASSERT_EQ(result, noneOfResultsView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_none_of_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamNoneOf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamPartitionCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamPartitionCopy.cpp
new file mode 100644
index 0000000000..78ab6bf1f8
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamPartitionCopy.cpp
@@ -0,0 +1,313 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamPartitionCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int a, int b, std::size_t seedIn) : m_dist(a, b) {
+    m_gen.seed(seedIn);
+  }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class ValueType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+
+  DestViewType m_destTrueView;
+  DestViewType m_destFalseView;
+
+  DistancesViewType m_distancesTrueView;
+  DistancesViewType m_distancesFalseView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+
+  ValueType m_threshold;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destTrueView,
+               const DestViewType destFalseView,
+               const DistancesViewType distancesTrueView,
+               const DistancesViewType distancesFalseView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType threshold, int apiPick)
+      : m_sourceView(sourceView),
+        m_destTrueView(destTrueView),
+        m_destFalseView(destFalseView),
+        m_distancesTrueView(distancesTrueView),
+        m_distancesFalseView(distancesFalseView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_threshold(threshold),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+
+    auto myRowViewDestTrue =
+        Kokkos::subview(m_destTrueView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDestFalse =
+        Kokkos::subview(m_destFalseView, myRowIndex, Kokkos::ALL());
+
+    ptrdiff_t resultDist1 = 0;
+    ptrdiff_t resultDist2 = 0;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      const auto result = KE::partition_copy(
+          member, KE::cbegin(myRowViewFrom), KE::cend(myRowViewFrom),
+          KE::begin(myRowViewDestTrue), KE::begin(myRowViewDestFalse),
+          predicate);
+      resultDist1 = KE::distance(KE::begin(myRowViewDestTrue), result.first);
+      resultDist2 = KE::distance(KE::begin(myRowViewDestFalse), result.second);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesTrueView(myRowIndex)  = resultDist1;
+        m_distancesFalseView(myRowIndex) = resultDist2;
+      });
+    }
+
+    else if (m_apiPick == 1) {
+      const auto result =
+          KE::partition_copy(member, myRowViewFrom, myRowViewDestTrue,
+                             myRowViewDestFalse, predicate);
+      resultDist1 = KE::distance(KE::begin(myRowViewDestTrue), result.first);
+      resultDist2 = KE::distance(KE::begin(myRowViewDestFalse), result.second);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesTrueView(myRowIndex)  = resultDist1;
+        m_distancesFalseView(myRowIndex) = resultDist2;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck1 = team_members_have_matching_result(
+        member, resultDist1, m_distancesTrueView(myRowIndex));
+    const bool intraTeamCheck2 = team_members_have_matching_result(
+        member, resultDist2, m_distancesFalseView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck1 && intraTeamCheck2;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId,
+            const std::string& sIn) {
+  /* description:
+     use a rank-2 view randomly filled with values in a range (a,b)
+     and run a team-level partition_copy with predicate = IsGreaterThanValue
+     where threshold is set to a number larger than b above
+   */
+  const auto threshold           = static_cast<ValueType>(1103);
+  const auto valueForSureGreater = static_cast<ValueType>(2103);
+  const auto valueForSureSmaller = static_cast<ValueType>(111);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto sourceView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "sourceView");
+
+  // sourceView might not deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to sourceView
+  auto sourceView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(sourceView);
+  auto sourceView_dc_h = create_mirror_view(Kokkos::HostSpace(), sourceView_dc);
+
+  if (sIn == "trivialEmpty") {
+    // do nothing
+  }
+
+  else if (sIn == "allTrue") {
+    // randomly fill with values greater than threshold
+    // so that all elements in each row satisfy the predicate
+    // so this counts as being partitioned
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    Kokkos::fill_random(sourceView_dc_h, pool, ValueType(2001),
+                        ValueType(2501));
+  }
+
+  else if (sIn == "allFalse") {
+    // randomly fill the view with values smaller than threshold
+    // and even in this case each row counts as partitioned
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    Kokkos::fill_random(sourceView_dc_h, pool, ValueType(0), ValueType(101));
+  }
+
+  else if (sIn == "random") {
+    // randomly select a location and make all values before that
+    // larger than threshol and all values after to be smaller than threshold
+    // so that this picked location does partition the range
+    UnifDist<int> indexProducer(0, numCols - 1, 3432779);
+    for (std::size_t i = 0; i < sourceView_dc_h.extent(0); ++i) {
+      const std::size_t a = indexProducer();
+      for (std::size_t j = 0; j < a; ++j) {
+        sourceView_dc_h(i, j) = valueForSureGreater;
+      }
+      for (std::size_t j = a; j < numCols; ++j) {
+        sourceView_dc_h(i, j) = valueForSureSmaller;
+      }
+    }
+  }
+
+  // copy to sourceView_dc and then to sourceView
+  Kokkos::deep_copy(sourceView_dc, sourceView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(sourceView_dc, sourceView);
+  Kokkos::parallel_for("copy", sourceView.extent(0) * sourceView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the destination views
+  Kokkos::View<ValueType**> destTrueView("destViewTrue", numTeams, numCols);
+  Kokkos::View<ValueType**> destFalseView("destViewFalse", numTeams, numCols);
+
+  // to verify that things work, each team stores the result
+  // and then we check that these match what we expect
+  Kokkos::View<std::size_t*> distancesTrueView("distancesTrue", numTeams);
+  Kokkos::View<std::size_t*> distancesFalseView("distancesFalse", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destTrueView, destFalseView, distancesTrueView,
+                   distancesFalseView, intraTeamSentinelView, threshold, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesTrueView_h     = create_host_space_copy(distancesTrueView);
+  auto distancesFalseView_h    = create_host_space_copy(distancesFalseView);
+  auto sourceViewAfterOp_h     = create_host_space_copy(sourceView);
+  auto destTrueViewAfterOp_h   = create_host_space_copy(destTrueView);
+  auto destFalseViewAfterOp_h  = create_host_space_copy(destFalseView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestTrueView(
+      "stdDestTrueView", numTeams, numCols);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestFalseView(
+      "stdDestFalseView", numTeams, numCols);
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+
+  for (std::size_t i = 0; i < sourceView_dc_h.extent(0); ++i) {
+    auto myRowSource    = Kokkos::subview(sourceView_dc_h, i, Kokkos::ALL());
+    auto myRowDestTrue  = Kokkos::subview(stdDestTrueView, i, Kokkos::ALL());
+    auto myRowDestFalse = Kokkos::subview(stdDestFalseView, i, Kokkos::ALL());
+
+    const auto stdResult = std::partition_copy(
+        KE::cbegin(myRowSource), KE::cend(myRowSource),
+        KE::begin(myRowDestTrue), KE::begin(myRowDestFalse), predicate);
+    // our result must match std
+    const std::size_t stdDistanceTrue =
+        KE::distance(KE::begin(myRowDestTrue), stdResult.first);
+    const std::size_t stdDistanceFalse =
+        KE::distance(KE::begin(myRowDestFalse), stdResult.second);
+    ASSERT_EQ(stdDistanceTrue, distancesTrueView_h(i));
+    ASSERT_EQ(stdDistanceFalse, distancesFalseView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  expect_equal_host_views(sourceView_dc_h, sourceViewAfterOp_h);
+  expect_equal_host_views(destTrueViewAfterOp_h, stdDestTrueView);
+  expect_equal_host_views(destFalseViewAfterOp_h, stdDestFalseView);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const std::string& name, const std::vector<int>& cols) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : cols) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId, name);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_partition_copy_team_test, empty) {
+  const std::string name      = "trivialEmpty";
+  const std::vector<int> cols = {0};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_partition_copy_team_test, all_true) {
+  const std::string name      = "allTrue";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_partition_copy_team_test, all_false) {
+  const std::string name      = "allFalse";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_partition_copy_team_test, random) {
+  const std::string name      = "random";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+}  // namespace TeamPartitionCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamPartitionPoint.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamPartitionPoint.cpp
new file mode 100644
index 0000000000..370e91cc1f
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamPartitionPoint.cpp
@@ -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
+
+#include <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamPartitionPoint {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int a, int b, std::size_t seedIn) : m_dist(a, b) {
+    m_gen.seed(seedIn);
+  }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView,
+          class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  ValueType m_threshold;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType threshold, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_threshold(threshold),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      const auto it = KE::partition_point(member, KE::cbegin(myRowView),
+                                          KE::cend(myRowView), predicate);
+      resultDist    = KE::distance(KE::cbegin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    else if (m_apiPick == 1) {
+      const auto it = KE::partition_point(member, myRowView, predicate);
+      resultDist    = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId,
+            const std::string& sIn) {
+  /* description:
+     use a rank-2 view randomly filled with values in a range (a,b)
+     and run a team-level (one team per row) partition_point with
+     predicate = IsGreaterThanValue
+     where threshold is set to a number larger than b above
+   */
+  const auto threshold           = static_cast<ValueType>(1103);
+  const auto valueForSureGreater = static_cast<ValueType>(2103);
+  const auto valueForSureSmaller = static_cast<ValueType>(111);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto dataView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "dataView");
+
+  // dataView might not deep copyable (e.g. strided layout) so to
+  // randomize it, we make a new view that is for sure deep copyable,
+  // modify it on the host, deep copy to device and then launch
+  // a kernel to copy to dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  if (sIn == "trivialEmpty") {
+    // do nothing
+  }
+
+  else if (sIn == "allTrue") {
+    // randomly fill with values greater than threshold
+    // so that all elements in each row satisfy the predicate
+    // so this counts as being partitioned
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    Kokkos::fill_random(dataView_dc_h, pool, ValueType(2001), ValueType(2501));
+  }
+
+  else if (sIn == "allFalse") {
+    // randomly fill the view with values smaller than threshold
+    // and even in this case each row counts as partitioned
+    Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+        452377);
+    Kokkos::fill_random(dataView_dc_h, pool, ValueType(0), ValueType(101));
+  }
+
+  else if (sIn == "random") {
+    // randomly select a location and make all values before that
+    // larger than threshol and all values after to be smaller than threshold
+    // so that this picked location does partition the range
+    UnifDist<int> indexProducer(0, numCols - 1, 3432779);
+    for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+      const std::size_t a = indexProducer();
+      for (std::size_t j = 0; j < a; ++j) {
+        dataView_dc_h(i, j) = valueForSureGreater;
+      }
+      for (std::size_t j = a; j < numCols; ++j) {
+        dataView_dc_h(i, j) = valueForSureSmaller;
+      }
+    }
+  }
+
+  // copy to dataView_dc and then to dataView
+  Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(dataView_dc, dataView);
+  Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result
+  // and then we check that these match what we expect
+  Kokkos::View<std::size_t*> distancesView("distances", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, threshold,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+
+  for (std::size_t i = 0; i < dataView_dc_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(dataView_dc_h, i, Kokkos::ALL());
+    const auto stdResult =
+        std::partition_point(KE::cbegin(myRow), KE::cend(myRow), predicate);
+
+    // our result must match std
+    const std::size_t stdDistance = KE::distance(KE::cbegin(myRow), stdResult);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+  expect_equal_host_views(dataView_dc_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const std::string& name, const std::vector<int>& cols) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : cols) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId, name);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_partition_point_team_test, empty) {
+  const std::string name      = "trivialEmpty";
+  const std::vector<int> cols = {0};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_partition_point_team_test, all_true) {
+  const std::string name      = "allTrue";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_partition_point_team_test, all_false) {
+  const std::string name      = "allFalse";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+TEST(std_algorithms_partition_point_team_test, random) {
+  const std::string name      = "random";
+  const std::vector<int> cols = {13, 101, 1444, 5153};
+  run_all_scenarios<DynamicTag, double>(name, cols);
+  run_all_scenarios<StridedTwoRowsTag, double>(name, cols);
+  run_all_scenarios<StridedThreeRowsTag, int>(name, cols);
+}
+
+}  // namespace TeamPartitionPoint
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReduce.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReduce.cpp
new file mode 100644
index 0000000000..eb00d9e083
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReduce.cpp
@@ -0,0 +1,272 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReduce {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class DataViewType, class ReductionInitValuesViewType,
+          class ReduceResultsViewType, class IntraTeamSentinelView,
+          class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  ReductionInitValuesViewType m_reductionInitValuesView;
+  ReduceResultsViewType m_reduceResultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+  BinaryPredType m_binaryPred;
+
+  TestFunctorA(const DataViewType dataView,
+               const ReductionInitValuesViewType reductionInitValuesView,
+               const ReduceResultsViewType reduceResultsView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick,
+               BinaryPredType binaryPred)
+      : m_dataView(dataView),
+        m_reductionInitValuesView(reductionInitValuesView),
+        m_reduceResultsView(reduceResultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick),
+        m_binaryPred(binaryPred) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+
+    const auto rowFromBegin     = KE::cbegin(myRowViewFrom);
+    const auto rowFromEnd       = KE::cend(myRowViewFrom);
+    const auto initReductionVal = m_reductionInitValuesView(myRowIndex);
+    typename ReduceResultsViewType::non_const_value_type result = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        result = KE::reduce(member, rowFromBegin, rowFromEnd);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_reduceResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 1: {
+        result = KE::reduce(member, myRowViewFrom);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_reduceResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 2: {
+        result = KE::reduce(member, rowFromBegin, rowFromEnd, initReductionVal);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_reduceResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 3: {
+        result = KE::reduce(member, myRowViewFrom, initReductionVal);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_reduceResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 4: {
+        result = KE::reduce(member, rowFromBegin, rowFromEnd, initReductionVal,
+                            m_binaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_reduceResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+
+      case 5: {
+        result =
+            KE::reduce(member, myRowViewFrom, initReductionVal, m_binaryPred);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_reduceResultsView(myRowIndex) = result;
+        });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_reduceResultsView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level reduce
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // Create view of reduce init values to be used by test cases
+  Kokkos::View<ValueType*, Kokkos::DefaultHostExecutionSpace>
+      reductionInitValuesView_h("reductionInitValuesView_h", numTeams);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(reductionInitValuesView_h, pool, lowerBound, upperBound);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result of its reduce
+  // call, and then we check that these match what we expect
+  Kokkos::View<ValueType*> reduceResultsView("reduceResultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  PlusFunctor<ValueType> binaryPred;
+
+  // use CTAD for functor
+  auto reductionInitValuesView =
+      Kokkos::create_mirror_view_and_copy(space_t(), reductionInitValuesView_h);
+  TestFunctorA fnc(dataView, reductionInitValuesView, reduceResultsView,
+                   intraTeamSentinelView, apiId, binaryPred);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+
+  auto reduceResultsView_h     = create_host_space_copy(reduceResultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+    const auto initVal      = reductionInitValuesView_h(i);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+    // libstdc++ as provided by GCC 8 does not have reduce, transform_reduce,
+    // exclusive_scan, inclusive_scan, transform_exclusive_scan,
+    // transform_inclusive_scan and for GCC 9.1, 9.2 fails to compile them for
+    // missing overload not accepting policy
+
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+#define reduce testing_reduce
+#else
+#define reduce std::reduce
+#endif
+
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const ValueType result = reduce(rowFromBegin, rowFromEnd);
+        if constexpr (std::is_floating_point_v<ValueType>) {
+          EXPECT_FLOAT_EQ(result, reduceResultsView_h(i));
+        } else {
+          ASSERT_EQ(result, reduceResultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const ValueType result = reduce(rowFromBegin, rowFromEnd, initVal);
+        if constexpr (std::is_floating_point_v<ValueType>) {
+          EXPECT_FLOAT_EQ(result, reduceResultsView_h(i));
+        } else {
+          ASSERT_EQ(result, reduceResultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 4:
+      case 5: {
+        const ValueType result =
+            reduce(rowFromBegin, rowFromEnd, initVal, binaryPred);
+        if constexpr (std::is_floating_point_v<ValueType>) {
+          EXPECT_FLOAT_EQ(result, reduceResultsView_h(i));
+        } else {
+          ASSERT_EQ(result, reduceResultsView_h(i));
+        }
+
+        break;
+      }
+    }
+
+#undef reduce
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3, 4, 5}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_reduce_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReduce
+}  // namespace stdalgos
+}  // namespace Test
+
+#endif
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamRemove.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamRemove.cpp
new file mode 100644
index 0000000000..fb9c70391b
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamRemove.cpp
@@ -0,0 +1,182 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamRemove {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int b, std::size_t seedIn) : m_dist(0, b) { m_gen.seed(seedIn); }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView,
+          class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  ValueType m_targetValue;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, ValueType oldVal,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_targetValue(oldVal),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::remove(member, KE::begin(myRowView), KE::end(myRowView),
+                           m_targetValue);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::remove(member, myRowView, m_targetValue);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     set a random subset of each row of a rank-2 view
+     to a target value and run a team-level KE::remove
+     with one team per row to remove all those elements.
+   */
+
+  const auto targetVal = static_cast<ValueType>(531);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // Create a view in the memory space associated with default exespace with as
+  // many rows as the number of teams and fill it with random values from an
+  // arbitrary range. Pick range so that some of the values are equal to target.
+  auto [dataView, dataView_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols,
+      Kokkos::pair<ValueType, ValueType>{targetVal - 1, targetVal + 1},
+      "dataView");
+
+  // note that we need to count how many elements are equal
+  // to targetVal because the dataView was origianlly filled
+  // with random values
+  std::vector<std::size_t> perRowRealCount(numTeams);
+  for (std::size_t i = 0; i < dataView_h.extent(0); ++i) {
+    std::size_t realCount = 0;
+    for (std::size_t j = 0; j < dataView_h.extent(1); ++j) {
+      if (dataView_h(i, j) == targetVal) {
+        realCount++;
+      }
+    }
+    perRowRealCount[i] = realCount;
+  }
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, targetVal, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check against std
+  // -----------------------------------------------
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(dataView_h, i, Kokkos::ALL());
+    auto stdIt = std::remove(KE::begin(myRow), KE::end(myRow), targetVal);
+    const std::size_t stdDistance = KE::distance(KE::begin(myRow), stdIt);
+    ASSERT_EQ(distancesView_h(i), stdDistance);
+    ASSERT_EQ(distancesView_h(i), numCols - perRowRealCount[i]);
+
+    for (std::size_t j = 0; j < distancesView_h(i); ++j) {
+      ASSERT_EQ(dataViewAfterOp_h(i, j), dataView_h(i, j));
+    }
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_remove_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamRemove
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveCopy.cpp
new file mode 100644
index 0000000000..6bb0d24998
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveCopy.cpp
@@ -0,0 +1,226 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamRemoveCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int b, std::size_t seedIn) : m_dist(0, b) { m_gen.seed(seedIn); }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class ValueType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  ValueType m_targetValue;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               ValueType targetVal, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_targetValue(targetVal),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::remove_copy(member, KE::cbegin(myRowViewFrom),
+                                KE::cend(myRowViewFrom),
+                                KE::begin(myRowViewDest), m_targetValue);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it =
+          KE::remove_copy(member, myRowViewFrom, myRowViewDest, m_targetValue);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     set a random subset of each row of a rank-2 view
+     to a target value and run a team-level KE::remove_copy
+     to a destination view with one team per row to remove all those elements.
+   */
+
+  const auto targetVal = static_cast<ValueType>(531);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto sourceView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "dataView");
+
+  // sourceView might not deep copyable (e.g. strided layout) so to fill it
+  // we make a new view that is for sure deep copyable, modify it on the host
+  // deep copy to device and then launch copy kernel to sourceView
+  auto sourceView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(sourceView);
+  auto sourceView_dc_h = create_mirror_view(Kokkos::HostSpace(), sourceView_dc);
+
+  Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace> pool(
+      45234399);
+  Kokkos::fill_random(sourceView_dc_h, pool, ValueType(0), ValueType(1177));
+
+  // for each row, randomly select columns, fill with targetVal
+  std::vector<std::size_t> perRowRealCount(numTeams);
+  const std::size_t maxColInd = numCols > 0 ? numCols - 1 : 0;
+  UnifDist<int> colCountProducer(maxColInd, 3123377);
+  UnifDist<int> colIndicesProducer(maxColInd, 455225);
+  for (std::size_t i = 0; i < sourceView_dc_h.extent(0); ++i) {
+    const std::size_t currCount = colCountProducer();
+    std::vector<std::size_t> colIndForThisRow(currCount);
+    for (std::size_t j = 0; j < currCount; ++j) {
+      const auto colInd          = colIndicesProducer();
+      sourceView_dc_h(i, colInd) = targetVal;
+      colIndForThisRow[j]        = colInd;
+    }
+
+    // note that we need to count how many elements are equal
+    // to targetVal because the sourceView was origianlly filled
+    // with random values so it could be that we have more matches
+    // than what we manually set above
+    std::size_t realCount = 0;
+    for (std::size_t j = 0; j < sourceView_dc_h.extent(1); ++j) {
+      if (sourceView_dc_h(i, j) == targetVal) {
+        realCount++;
+      }
+    }
+    perRowRealCount[i] = realCount;
+  }
+
+  // copy to sourceView_dc and then to sourceView
+  Kokkos::deep_copy(sourceView_dc, sourceView_dc_h);
+  CopyFunctorRank2 F1(sourceView_dc, sourceView);
+  Kokkos::parallel_for("copy", sourceView.extent(0) * sourceView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, targetVal, distancesView,
+                   intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check against std
+  // -----------------------------------------------
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < destViewAfterOp_h.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(sourceView_dc_h, i, Kokkos::ALL());
+    auto rowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+
+    auto stdIt = std::remove_copy(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                                  KE::begin(rowDest), targetVal);
+    const std::size_t stdDistance = KE::distance(KE::begin(rowDest), stdIt);
+
+    EXPECT_TRUE(distancesView_h(i) == stdDistance);
+    // EXPECT_TRUE(distancesView_h(i) == numCols - perRowRealCount[i]);
+    for (std::size_t j = 0; j < distancesView_h(i); ++j) {
+      EXPECT_TRUE(destViewAfterOp_h(i, j) == stdDestView(i, j));
+    }
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_remove_copy_team_test, test) {
+// FIXME_OPENMPTARGET
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  GTEST_SKIP() << "the test is known to fail with OpenMPTarget on Intel GPUs";
+#endif
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamRemoveCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveCopyIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveCopyIf.cpp
new file mode 100644
index 0000000000..cff9aa178a
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveCopyIf.cpp
@@ -0,0 +1,182 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamRemoveCopyIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class ValueType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  ValueType m_threshold;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               ValueType threshold, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_threshold(threshold),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      auto it    = KE::remove_copy_if(member, KE::cbegin(myRowViewFrom),
+                                   KE::cend(myRowViewFrom),
+                                   KE::begin(myRowViewDest), predicate);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it =
+          KE::remove_copy_if(member, myRowViewFrom, myRowViewDest, predicate);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled,
+     and run a team-level remove_copy_if where the values copied
+     are those strictly greater than a threshold.
+   */
+
+  const auto threshold = static_cast<ValueType>(531);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{5, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, threshold, distancesView,
+                   intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check against std
+  // -----------------------------------------------
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+  for (std::size_t i = 0; i < destViewAfterOp_h.extent(0); ++i) {
+    auto rowFrom =
+        Kokkos::subview(cloneOfSourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+
+    auto stdIt = std::remove_copy_if(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                                     KE::begin(rowDest), predicate);
+    const std::size_t stdDistance = KE::distance(KE::begin(rowDest), stdIt);
+
+    EXPECT_TRUE(distancesView_h(i) == stdDistance);
+    for (std::size_t j = 0; j < distancesView_h(i); ++j) {
+      EXPECT_TRUE(destViewAfterOp_h(i, j) == stdDestView(i, j));
+    }
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_remove_copy_if_team_test, test) {
+// FIXME_OPENMPTARGET
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  GTEST_SKIP() << "the test is known to fail with OpenMPTarget on Intel GPUs";
+#endif
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamRemoveCopyIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveIf.cpp
new file mode 100644
index 0000000000..3dd7cb764c
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamRemoveIf.cpp
@@ -0,0 +1,166 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamRemoveIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView,
+          class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  ValueType m_threshold;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, ValueType threshold,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_threshold(threshold),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      auto it = KE::remove_if(member, KE::begin(myRowView), KE::end(myRowView),
+                              predicate);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::remove_if(member, myRowView, predicate);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level remove_if for values strictly
+     greater than a threshold.
+   */
+
+  const auto threshold = static_cast<ValueType>(151);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{5, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, threshold, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check against std
+  // -----------------------------------------------
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+  auto dataViewAfterOp_h       = create_host_space_copy(dataView);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+    auto stdIt = std::remove_if(KE::begin(myRow), KE::end(myRow), predicate);
+    const std::size_t stdDistance = KE::distance(KE::begin(myRow), stdIt);
+    EXPECT_TRUE(distancesView_h(i) == stdDistance);
+
+    for (std::size_t j = 0; j < distancesView_h(i); ++j) {
+      EXPECT_TRUE(dataViewAfterOp_h(i, j) == cloneOfDataViewBeforeOp_h(i, j));
+    }
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_remove_if_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamRemoveIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReplace.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReplace.cpp
new file mode 100644
index 0000000000..fddc0f3b5b
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReplace.cpp
@@ -0,0 +1,135 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReplace {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int b, std::size_t seedIn) : m_dist(0, b) { m_gen.seed(seedIn); }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class ViewType, class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  ValueType m_targetValue;
+  ValueType m_newValue;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, ValueType oldVal, ValueType newVal,
+               int apiPick)
+      : m_view(view),
+        m_targetValue(oldVal),
+        m_newValue(newVal),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+
+    if (m_apiPick == 0) {
+      KE::replace(member, KE::begin(myRowView), KE::end(myRowView),
+                  m_targetValue, m_newValue);
+    } else if (m_apiPick == 1) {
+      KE::replace(member, myRowView, m_targetValue, m_newValue);
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     Randomly fill a view with some elements equal to a target value that we
+     want to replace with a new value. Do the operation via a team parfor with
+     one row per team.
+   */
+
+  const auto targetVal = static_cast<ValueType>(531);
+  const auto newVal    = static_cast<ValueType>(123);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // Create a view in the memory space associated with default exespace with as
+  // many rows as the number of teams and fill it with random values from an
+  // arbitrary range. Pick range so that some of the values are equal to target.
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols,
+      Kokkos::pair<ValueType, ValueType>{targetVal - 1, targetVal + 1},
+      "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, targetVal, newVal, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // conditions for test passing:
+  // - the target elements are replaced with the new value
+  // - all other elements are unchanged
+  // -----------------------------------------------
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataViewAfterOp_h.extent(1); ++j) {
+      const auto correctVal = (dataViewBeforeOp_h(i, j) == targetVal)
+                                  ? newVal
+                                  : dataViewBeforeOp_h(i, j);
+      ASSERT_EQ(dataViewAfterOp_h(i, j), correctVal)
+          << "i, j = " << i << ", " << j;
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_replace_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReplace
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceCopy.cpp
new file mode 100644
index 0000000000..70dbf10574
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceCopy.cpp
@@ -0,0 +1,204 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReplaceCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int b, std::size_t seedIn) : m_dist(0, b) { m_gen.seed(seedIn); }
+
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class ValueType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  ValueType m_targetValue;
+  ValueType m_newValue;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType targetVal, ValueType newVal, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_targetValue(targetVal),
+        m_newValue(newVal),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it = KE::replace_copy(
+          member, KE::begin(myRowViewFrom), KE::end(myRowViewFrom),
+          KE::begin(myRowViewDest), m_targetValue, m_newValue);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::replace_copy(member, myRowViewFrom, myRowViewDest,
+                                 m_targetValue, m_newValue);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a "source" and "destination" rank-2 views such that in the source,
+     for each row, a random subset of elements is filled with a target value
+     that we want to replace_copy with a new value into the destination view.
+     The operation is done via a team parfor with one row per team.
+   */
+
+  const auto targetVal = static_cast<ValueType>(531);
+  const auto newVal    = static_cast<ValueType>(123);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // construct in memory space associated with default exespace
+  auto sourceView =
+      create_view<ValueType>(LayoutTag{}, numTeams, numCols, "sourceView");
+
+  // sourceView might not deep copyable (e.g. strided layout) so to fill it
+  // we make a new view that is for sure deep copyable, modify it on the host
+  // deep copy to device and then launch copy kernel to sourceView
+  auto sourceView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(sourceView);
+  auto sourceView_dc_h = create_mirror_view(Kokkos::HostSpace(), sourceView_dc);
+
+  // for each row, randomly select columns, fill with targetVal
+  const std::size_t maxColInd = numCols > 0 ? numCols - 1 : 0;
+  UnifDist<int> colCountProducer(maxColInd, 3123377);
+  UnifDist<int> colIndicesProducer(maxColInd, 455225);
+  for (std::size_t i = 0; i < sourceView_dc_h.extent(0); ++i) {
+    const std::size_t currCount = colCountProducer();
+    for (std::size_t j = 0; j < currCount; ++j) {
+      const auto colInd          = colIndicesProducer();
+      sourceView_dc_h(i, colInd) = targetVal;
+    }
+  }
+
+  // copy to sourceView_dc and then to sourceView
+  Kokkos::deep_copy(sourceView_dc, sourceView_dc_h);
+  // use CTAD
+  CopyFunctorRank2 F1(sourceView_dc, sourceView);
+  Kokkos::parallel_for("copy", sourceView.extent(0) * sourceView.extent(1), F1);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view where we to store the replace_copy
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // replace_copy returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   targetVal, newVal, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+  for (std::size_t i = 0; i < sourceView_dc_h.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(sourceView_dc_h, i, Kokkos::ALL());
+    auto rowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto it      = std::replace_copy(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                                KE::begin(rowDest), targetVal, newVal);
+    const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(destView);
+  expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_replace_copy_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReplaceCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceCopyIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceCopyIf.cpp
new file mode 100644
index 0000000000..d0217aed7a
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceCopyIf.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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReplaceCopyIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class ValueType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  ValueType m_threshold;
+  ValueType m_newValue;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               ValueType threshold, ValueType newVal, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_threshold(threshold),
+        m_newValue(newVal),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    GreaterThanValueFunctor predicate(m_threshold);
+
+    if (m_apiPick == 0) {
+      auto it = KE::replace_copy_if(
+          member, KE::begin(myRowViewFrom), KE::end(myRowViewFrom),
+          KE::begin(myRowViewDest), predicate, m_newValue);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::replace_copy_if(member, myRowViewFrom, myRowViewDest,
+                                    predicate, m_newValue);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level replace_copy_if where the values strictly
+     greater than a threshold are replaced/copied into a new view
+     with a new value, while those <= threshold are copied but unchanged
+   */
+
+  const auto threshold = static_cast<ValueType>(151);
+  const auto newVal    = static_cast<ValueType>(1);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{5, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // replace_copy_if returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   threshold, newVal, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto rowFrom =
+        Kokkos::subview(cloneOfSourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto it      = std::replace_copy_if(KE::cbegin(rowFrom), KE::cend(rowFrom),
+                                   KE::begin(rowDest), predicate, newVal);
+    const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(destView);
+  expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_replace_copy_if_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReplaceCopyIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceIf.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceIf.cpp
new file mode 100644
index 0000000000..d79b53d355
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReplaceIf.cpp
@@ -0,0 +1,138 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReplaceIf {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct GreaterThanValueFunctor {
+  ValueType m_val;
+
+  KOKKOS_INLINE_FUNCTION
+  GreaterThanValueFunctor(ValueType val) : m_val(val) {}
+
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType val) const { return (val > m_val); }
+};
+
+template <class ViewType, class ValueType>
+struct TestFunctorA {
+  ViewType m_view;
+  ValueType m_threshold;
+  ValueType m_newVal;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, ValueType threshold, ValueType newVal,
+               int apiPick)
+      : m_view(view),
+        m_threshold(threshold),
+        m_newVal(newVal),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+
+    GreaterThanValueFunctor predicate(m_threshold);
+    if (m_apiPick == 0) {
+      KE::replace_if(member, KE::begin(myRowView), KE::end(myRowView),
+                     predicate, m_newVal);
+    } else if (m_apiPick == 1) {
+      KE::replace_if(member, myRowView, predicate, m_newVal);
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level replace_if where the values strictly greater
+     than a threshold are replaced with a new value.
+   */
+  const auto threshold = static_cast<ValueType>(151);
+  const auto newVal    = static_cast<ValueType>(1);
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{5, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, threshold, newVal, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel
+  // -----------------------------------------------
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDataView("stdDataView",
+                                                           numTeams, numCols);
+  // ensure that we use the same data to run the std algo on
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataView.extent(1); ++j) {
+      stdDataView(i, j) = cloneOfDataViewBeforeOp_h(i, j);
+    }
+  }
+  GreaterThanValueFunctor<ValueType> predicate(threshold);
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto thisRow = Kokkos::subview(stdDataView, i, Kokkos::ALL());
+    std::replace_if(KE::begin(thisRow), KE::end(thisRow), predicate, newVal);
+  }
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(stdDataView, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_replace_if_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReplaceIf
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReverse.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReverse.cpp
new file mode 100644
index 0000000000..46d27aa16b
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReverse.cpp
@@ -0,0 +1,105 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReverse {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType>
+struct TestFunctorA {
+  ViewType m_view;
+  int m_api_pick;
+
+  TestFunctorA(const ViewType view, int apiPick)
+      : m_view(view), m_api_pick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+
+    if (m_api_pick == 0) {
+      KE::reverse(member, KE::begin(myRowView), KE::end(myRowView));
+    } else if (m_api_pick == 1) {
+      KE::reverse(member, myRowView);
+    }
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     create a rank-2 view, randomly fill, and do a team-level
+     KE::reverse for each row where each team is
+     responsible for a single row
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  for (std::size_t i = 0; i < dataViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataViewAfterOp_h.extent(1); ++j) {
+      EXPECT_TRUE(dataViewAfterOp_h(i, j) ==
+                  cloneOfDataViewBeforeOp_h(i, numCols - j - 1));
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_reverse_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReverse
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamReverseCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamReverseCopy.cpp
new file mode 100644
index 0000000000..a06ae839e1
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamReverseCopy.cpp
@@ -0,0 +1,153 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamReverseCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::reverse_copy(member, KE::begin(myRowViewFrom),
+                           KE::end(myRowViewFrom), KE::begin(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::reverse_copy(member, myRowViewFrom, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill a source view and reverse_copy into a destination view.
+     The operation is done via a team parfor with one row per team.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // to verify that things are correct each team stores the distance
+  // of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < destViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < destViewAfterOp_h.extent(1); ++j) {
+      EXPECT_TRUE(destViewAfterOp_h(i, j) ==
+                  cloneOfSourceViewBeforeOp_h(i, numCols - j - 1));
+    }
+    // each team should return an iterator past the last column
+    EXPECT_TRUE(distancesView_h(i) == numCols);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_reverse_copy_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamReverseCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamRotate.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamRotate.cpp
new file mode 100644
index 0000000000..3188e02910
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamRotate.cpp
@@ -0,0 +1,173 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamRotate {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_pivotShift;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t pivotShift, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_pivotShift(pivotShift),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto pivot = KE::begin(myRowView) + m_pivotShift;
+      auto it =
+          KE::rotate(member, KE::begin(myRowView), pivot, KE::end(myRowView));
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::rotate(member, myRowView, m_pivotShift);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t pivotShift,
+            int apiId) {
+  /* description:
+     randomly fill a rank-2 view and for a given pivot,
+     do a team-level KE::rotate
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, pivotShift,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+    auto pivot = KE::begin(myRow) + pivotShift;
+
+    auto it = std::rotate(KE::begin(myRow), pivot, KE::end(myRow));
+    const std::size_t stdDistance = KE::distance(KE::begin(myRow), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int b, std::size_t seedIn) : m_dist(0, b) { m_gen.seed(seedIn); }
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1153}) {
+      // given numTeams, numCols, randomly pick a few pivots to test
+      constexpr int numPivotsToTest = 5;
+      UnifDist<int> pivotsProducer(numCols, 3123377);
+      for (int k = 0; k < numPivotsToTest; ++k) {
+        const auto pivotIndex = pivotsProducer();
+        // test all apis
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, pivotIndex, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_rotate_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+}
+
+}  // namespace TeamRotate
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamRotateCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamRotateCopy.cpp
new file mode 100644
index 0000000000..e865b998f6
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamRotateCopy.cpp
@@ -0,0 +1,188 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamRotateCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_pivotShift;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t pivotShift, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_pivotShift(pivotShift),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto pivot = KE::cbegin(myRowViewFrom) + m_pivotShift;
+      auto it =
+          KE::rotate_copy(member, KE::cbegin(myRowViewFrom), pivot,
+                          KE::cend(myRowViewFrom), KE::begin(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it =
+          KE::rotate_copy(member, myRowViewFrom, m_pivotShift, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t pivotShift,
+            int apiId) {
+  /* description:
+     randomly fill a rank-2 view and for a given pivot,
+     do a team-level KE::rotateCopy
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   pivotShift, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < cloneOfSourceViewBeforeOp_h.extent(0); ++i) {
+    auto myRowFrom =
+        Kokkos::subview(cloneOfSourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto myRowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+
+    auto pivot = KE::cbegin(myRowFrom) + pivotShift;
+    auto it    = std::rotate_copy(KE::cbegin(myRowFrom), pivot,
+                               KE::cend(myRowFrom), KE::begin(myRowDest));
+    const std::size_t stdDistance = KE::distance(KE::begin(myRowDest), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto destViewAfterOp_h = create_host_space_copy(destView);
+  expect_equal_host_views(stdDestView, destViewAfterOp_h);
+}
+
+template <class ValueType>
+struct UnifDist;
+
+template <>
+struct UnifDist<int> {
+  using dist_type = std::uniform_int_distribution<int>;
+  std::mt19937 m_gen;
+  dist_type m_dist;
+
+  UnifDist(int b, std::size_t seedIn) : m_dist(0, b) { m_gen.seed(seedIn); }
+  int operator()() { return m_dist(m_gen); }
+};
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1153}) {
+      // given numTeams, numCols, randomly pick a few pivots to test
+      constexpr int numPivotsToTest = 5;
+      UnifDist<int> pivotsProducer(numCols, 3123377);
+      for (int k = 0; k < numPivotsToTest; ++k) {
+        const auto pivotIndex = pivotsProducer();
+        // test all apis
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, pivotIndex, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_rotate_copy_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+}
+
+}  // namespace TeamRotateCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamSearch.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamSearch.cpp
new file mode 100644
index 0000000000..039db4095d
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamSearch.cpp
@@ -0,0 +1,279 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamSearch {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct EqualFunctor {
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class SearchedSequencesViewType,
+          class DistancesViewType, class IntraTeamSentinelView,
+          class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  SearchedSequencesViewType m_searchedSequencesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  BinaryPredType m_binaryPred;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView,
+               const SearchedSequencesViewType searchedSequencesView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               BinaryPredType binaryPred, int apiPick)
+      : m_dataView(dataView),
+        m_searchedSequencesView(searchedSequencesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_binaryPred(binaryPred),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    auto myRowSearchedSeqView =
+        Kokkos::subview(m_searchedSequencesView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        const auto it = KE::search(
+            member, KE::cbegin(myRowViewFrom), KE::cend(myRowViewFrom),
+            KE::cbegin(myRowSearchedSeqView), KE::cend(myRowSearchedSeqView));
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        const auto it = KE::search(member, myRowViewFrom, myRowSearchedSeqView);
+        resultDist    = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 2: {
+        const auto it = KE::search(
+            member, KE::cbegin(myRowViewFrom), KE::cend(myRowViewFrom),
+            KE::cbegin(myRowSearchedSeqView), KE::cend(myRowSearchedSeqView),
+            m_binaryPred);
+        resultDist = KE::distance(KE::cbegin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 3: {
+        const auto it = KE::search(member, myRowViewFrom, myRowSearchedSeqView,
+                                   m_binaryPred);
+        resultDist    = KE::distance(KE::begin(myRowViewFrom), it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool sequencesExist, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level search
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // create a view that stores a sequence to found in dataView. If
+  // sequencesExist == true it is filled base on dataView content, to allow
+  // search to actually find anything. If sequencesExist == false it is filled
+  // with random values greater than upperBound
+  const std::size_t halfCols = (numCols > 1) ? ((numCols + 1) / 2) : (1);
+  const std::size_t seqSize  = (numCols > 1) ? (std::log2(numCols)) : (1);
+
+  Kokkos::View<ValueType**> searchedSequencesView("searchedSequencesView",
+                                                  numTeams, seqSize);
+  auto searchedSequencesView_h = create_host_space_copy(searchedSequencesView);
+
+  if (sequencesExist) {
+    const std::size_t dataBegin = halfCols - seqSize;
+    for (std::size_t i = 0; i < searchedSequencesView_h.extent(0); ++i) {
+      for (std::size_t js = 0, jd = dataBegin; js < seqSize; ++js, ++jd) {
+        searchedSequencesView_h(i, js) = dataViewBeforeOp_h(i, jd);
+      }
+    }
+  } else {
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(lowerBound * upperBound);
+    Kokkos::fill_random(searchedSequencesView_h, pool, upperBound,
+                        upperBound * 2);
+  }
+
+  Kokkos::deep_copy(searchedSequencesView, searchedSequencesView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // search returns an iterator so to verify that it is correct each team stores
+  // the distance of the returned iterator from the beginning of the interval
+  // that team operates on and then we check that these distances match the std
+  // result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  EqualFunctor<ValueType> binaryPred;
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, searchedSequencesView, distancesView,
+                   intraTeamSentinelView, binaryPred, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowSearchedSeq =
+        Kokkos::subview(searchedSequencesView_h, i, Kokkos::ALL());
+
+    const auto rowFromBegin     = KE::cbegin(rowFrom);
+    const auto rowFromEnd       = KE::cend(rowFrom);
+    const auto rowSearchedBegin = KE::cbegin(rowSearchedSeq);
+    const auto rowSearchedEnd   = KE::cend(rowSearchedSeq);
+
+    const std::size_t beginEndDistance = KE::distance(rowFromBegin, rowFromEnd);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const auto it = std::search(rowFromBegin, rowFromEnd, rowSearchedBegin,
+                                    rowSearchedEnd);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        if (sequencesExist) {
+          EXPECT_LT(distancesView_h(i), beginEndDistance);
+        } else {
+          ASSERT_EQ(distancesView_h(i), beginEndDistance);
+        }
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const auto it = std::search(rowFromBegin, rowFromEnd, rowSearchedBegin,
+                                    rowSearchedEnd, binaryPred);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        if (sequencesExist) {
+          EXPECT_LT(distancesView_h(i), beginEndDistance);
+        } else {
+          ASSERT_EQ(distancesView_h(i), beginEndDistance);
+        }
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool sequencesExist) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType>(sequencesExist, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_search_team_test, sequences_exist) {
+  constexpr bool sequencesExist = true;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+TEST(std_algorithms_search_team_test, sequences_do_not_exist) {
+  constexpr bool sequencesExist = false;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+}  // namespace TeamSearch
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamSearchN.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamSearchN.cpp
new file mode 100644
index 0000000000..25cd1471e0
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamSearchN.cpp
@@ -0,0 +1,295 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamSearchN {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct EqualFunctor {
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs == rhs;
+  }
+};
+
+template <class DataViewType, class SearchedValuesViewType,
+          class DistancesViewType, class IntraTeamSentinelView,
+          class BinaryPredType>
+struct TestFunctorA {
+  DataViewType m_dataView;
+  std::size_t m_seqSize;
+  SearchedValuesViewType m_searchedValuesView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  BinaryPredType m_binaryPred;
+  int m_apiPick;
+
+  TestFunctorA(const DataViewType dataView, std::size_t seqSize,
+               const SearchedValuesViewType searchedValuesView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               BinaryPredType binaryPred, int apiPick)
+      : m_dataView(dataView),
+        m_seqSize(seqSize),
+        m_searchedValuesView(searchedValuesView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_binaryPred(binaryPred),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom = Kokkos::subview(m_dataView, myRowIndex, Kokkos::ALL());
+    auto rowFromBegin  = KE::begin(myRowViewFrom);
+    auto rowFromEnd    = KE::end(myRowViewFrom);
+    const auto searchedValue = m_searchedValuesView(myRowIndex);
+    ptrdiff_t resultDist     = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        const auto it = KE::search_n(member, rowFromBegin, rowFromEnd,
+                                     m_seqSize, searchedValue);
+        resultDist    = KE::distance(rowFromBegin, it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 1: {
+        const auto it =
+            KE::search_n(member, myRowViewFrom, m_seqSize, searchedValue);
+        resultDist = KE::distance(rowFromBegin, it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 2: {
+        const auto it = KE::search_n(member, rowFromBegin, rowFromEnd,
+                                     m_seqSize, searchedValue, m_binaryPred);
+        resultDist    = KE::distance(rowFromBegin, it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+
+      case 3: {
+        const auto it = KE::search_n(member, myRowViewFrom, m_seqSize,
+                                     searchedValue, m_binaryPred);
+        resultDist    = KE::distance(rowFromBegin, it);
+        Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+          m_distancesView(myRowIndex) = resultDist;
+        });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(const bool sequencesExist, std::size_t numTeams,
+            std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level search_n
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [dataView, dataViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "dataView");
+
+  // If sequencesExist == true we need to inject some sequence of count test
+  // value into dataView. If sequencesExist == false we set searchedVal to a
+  // value that is not present in dataView
+
+  const std::size_t halfCols = (numCols > 1) ? ((numCols + 1) / 2) : (1);
+  const std::size_t seqSize  = (numCols > 1) ? (std::log2(numCols)) : (1);
+
+  Kokkos::View<ValueType*> searchedValuesView("searchedValuesView", numTeams);
+  auto searchedValuesView_h = create_host_space_copy(searchedValuesView);
+
+  // dataView might not deep copyable (e.g. strided layout) so to prepare it
+  // correclty, we make a new view that is for sure deep copyable, modify it
+  // on the host, deep copy to device and then launch a kernel to copy to
+  // dataView
+  auto dataView_dc =
+      create_deep_copyable_compatible_view_with_same_extent(dataView);
+  auto dataView_dc_h = create_mirror_view(Kokkos::HostSpace(), dataView_dc);
+
+  if (sequencesExist) {
+    const std::size_t dataBegin = halfCols - seqSize;
+    for (std::size_t i = 0; i < searchedValuesView.extent(0); ++i) {
+      const ValueType searchedVal = dataView_dc_h(i, dataBegin);
+      searchedValuesView_h(i)     = searchedVal;
+
+      for (std::size_t j = dataBegin + 1; j < seqSize; ++j) {
+        dataView_dc_h(i, j) = searchedVal;
+      }
+    }
+
+    // copy to dataView_dc and then to dataView
+    Kokkos::deep_copy(dataView_dc, dataView_dc_h);
+
+    CopyFunctorRank2 cpFun(dataView_dc, dataView);
+    Kokkos::parallel_for("copy", dataView.extent(0) * dataView.extent(1),
+                         cpFun);
+  } else {
+    using rand_pool =
+        Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+    rand_pool pool(lowerBound * upperBound);
+    Kokkos::fill_random(searchedValuesView_h, pool, upperBound, upperBound * 2);
+  }
+
+  Kokkos::deep_copy(searchedValuesView, searchedValuesView_h);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // search_n returns an iterator so to verify that it is correct each team
+  // stores the distance of the returned iterator from the beginning of the
+  // interval that team operates on and then we check that these distances match
+  // the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  EqualFunctor<ValueType> binaryPred;
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, seqSize, searchedValuesView, distancesView,
+                   intraTeamSentinelView, binaryPred, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView.extent(0); ++i) {
+    auto rowFrom = Kokkos::subview(dataView_dc_h, i, Kokkos::ALL());
+
+    const auto rowFromBegin = KE::cbegin(rowFrom);
+    const auto rowFromEnd   = KE::cend(rowFrom);
+
+    const ValueType searchedVal = searchedValuesView_h(i);
+
+    const std::size_t beginEndDist = KE::distance(rowFromBegin, rowFromEnd);
+
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const auto it =
+            std::search_n(rowFromBegin, rowFromEnd, seqSize, searchedVal);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        if (sequencesExist) {
+          EXPECT_LT(distancesView_h(i), beginEndDist);
+        } else {
+          ASSERT_EQ(distancesView_h(i), beginEndDist);
+        }
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+        ASSERT_TRUE(intraTeamSentinelView_h(i));
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const auto it = std::search_n(rowFromBegin, rowFromEnd, seqSize,
+                                      searchedVal, binaryPred);
+        const std::size_t stdDistance = KE::distance(rowFromBegin, it);
+
+        if (sequencesExist) {
+          EXPECT_LT(distancesView_h(i), beginEndDist);
+        } else {
+          ASSERT_EQ(distancesView_h(i), beginEndDist);
+        }
+
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+        ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+        break;
+      }
+    }
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios(const bool sequencesExist) {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(sequencesExist, numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_search_n_team_test, sequences_of_equal_elements_exist) {
+  constexpr bool sequencesExist = true;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+TEST(std_algorithms_search_n_team_test,
+     sequences_of_equal_elements_probably_does_not_exist) {
+  constexpr bool sequencesExist = false;
+
+  run_all_scenarios<DynamicTag, double>(sequencesExist);
+  run_all_scenarios<StridedTwoRowsTag, int>(sequencesExist);
+  run_all_scenarios<StridedThreeRowsTag, unsigned>(sequencesExist);
+}
+
+}  // namespace TeamSearchN
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamShiftLeft.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamShiftLeft.cpp
new file mode 100644
index 0000000000..60edb377d0
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamShiftLeft.cpp
@@ -0,0 +1,189 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamShiftLeft {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_shift;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t shift, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_shift(shift),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it = KE::shift_left(member, KE::begin(myRowView), KE::end(myRowView),
+                               m_shift);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::shift_left(member, myRowView, m_shift);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+// shift_left is only supported starting from C++20,
+// so put here a working version of the std algo copied from
+// https://github.com/llvm/llvm-project/blob/main/libcxx/include/__algorithm/shift_left.h
+template <class ForwardIterator>
+ForwardIterator my_std_shift_left(
+    ForwardIterator first, ForwardIterator last,
+    typename std::iterator_traits<ForwardIterator>::difference_type n) {
+  if (n == 0) {
+    return last;
+  }
+
+  ForwardIterator m = first;
+  for (; n > 0; --n) {
+    if (m == last) {
+      return first;
+    }
+    ++m;
+  }
+  return std::move(m, last, first);
+}
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t shift,
+            int apiId) {
+  /* description:
+     randomly fill a rank-2 view and do a team-level KE::shift_left
+     using shift as the shift count.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, shift,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+    auto it    = my_std_shift_left(KE::begin(myRow), KE::end(myRow), shift);
+    const std::size_t stdDistance = KE::distance(KE::begin(myRow), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  // prepare a map where, for a given set of num cols
+  // we provide a list of shifts to use for testing
+  // key = num of columns
+  // value = list of shifts
+  // Note that the cornerCase number is here since the shiftLeft algo
+  // should work even when the shift given is way larger than the range.
+  constexpr std::size_t cornerCase                        = 110111;
+  const std::map<int, std::vector<std::size_t>> scenarios = {
+      {0, {0, cornerCase}},
+      {2, {0, 1, 2, cornerCase}},
+      {6, {0, 1, 2, 5, cornerCase}},
+      {13, {0, 1, 2, 8, 11, cornerCase}},
+      {56, {0, 1, 2, 8, 11, 33, 56, cornerCase}},
+      {123, {0, 1, 11, 33, 56, 89, 112, cornerCase}},
+      {3145, {0, 1, 11, 33, 56, 89, 112, 5677, cornerCase}}};
+
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& scenario : scenarios) {
+      const std::size_t numCols = scenario.first;
+      for (int copyCount : scenario.second) {
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, copyCount, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_shift_left_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamShiftLeft
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamShiftRight.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamShiftRight.cpp
new file mode 100644
index 0000000000..00a80c5ef0
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamShiftRight.cpp
@@ -0,0 +1,187 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamShiftRight {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  std::size_t m_shift;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               std::size_t shift, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_shift(shift),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::shift_right(member, KE::begin(myRowView),
+                                KE::end(myRowView), m_shift);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::shift_right(member, myRowView, m_shift);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+// shift_right is only supported starting from C++20,
+// so put here a working version of the std algo copied from
+// https://github.com/llvm/llvm-project/blob/main/libcxx/include/__algorithm/shift_right.h
+template <class ForwardIterator>
+ForwardIterator my_std_shift_right(
+    ForwardIterator first, ForwardIterator last,
+    typename std::iterator_traits<ForwardIterator>::difference_type n) {
+  if (n == 0) {
+    return first;
+  }
+
+  decltype(n) d = last - first;
+  if (n >= d) {
+    return last;
+  }
+  ForwardIterator m = first + (d - n);
+  return std::move_backward(first, m, last);
+}
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, std::size_t shift,
+            int apiId) {
+  /* description:
+     randomly fill a rank-2 view and do a team-level KE::shift_right
+     using shift as the shift count.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, shift,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+    auto it    = my_std_shift_right(KE::begin(myRow), KE::end(myRow), shift);
+    const std::size_t stdDistance = KE::distance(KE::begin(myRow), it);
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class Tag, class ValueType>
+void run_all_scenarios() {
+  // prepare a map where, for a given set of num cols
+  // we provide a list of shifts to use for testing
+  // key = num of columns
+  // value = list of shifts
+  // Note that the cornerCase number is here since the shift_right algo
+  // should work even when the shift given is way larger than the range.
+  constexpr std::size_t cornerCase                        = 110111;
+  const std::map<int, std::vector<std::size_t>> scenarios = {
+      {0, {0, cornerCase}},
+      {2, {0, 1, 2, cornerCase}},
+      {6, {0, 1, 2, 5, cornerCase}},
+      {13, {0, 1, 2, 8, 11, cornerCase}},
+      {56, {0, 1, 2, 8, 11, 33, 56, cornerCase}},
+      {123, {0, 1, 11, 33, 56, 89, 112, cornerCase}},
+      {3145, {0, 1, 11, 33, 56, 89, 112, 5677, cornerCase}}};
+
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& scenario : scenarios) {
+      const std::size_t numCols = scenario.first;
+      for (int copyCount : scenario.second) {
+        for (int apiId : {0, 1}) {
+          test_A<Tag, ValueType>(numTeams, numCols, copyCount, apiId);
+        }
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_shift_right_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamShiftRight
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamSwapRanges.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamSwapRanges.cpp
new file mode 100644
index 0000000000..5fc9612caa
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamSwapRanges.cpp
@@ -0,0 +1,151 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamSwapRanges {
+
+namespace KE = Kokkos::Experimental;
+
+template <class View1Type, class View2Type, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  View1Type m_view1;
+  View2Type m_view2;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const View1Type view1, const View2Type view2,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view1(view1),
+        m_view2(view2),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView1       = Kokkos::subview(m_view1, myRowIndex, Kokkos::ALL());
+    auto myRowView2       = Kokkos::subview(m_view2, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::swap_ranges(member, KE::begin(myRowView1),
+                                KE::end(myRowView1), KE::begin(myRowView2));
+      resultDist = KE::distance(KE::begin(myRowView2), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::swap_ranges(member, myRowView1, myRowView2);
+      resultDist = KE::distance(KE::begin(myRowView2), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     randomly fill two views and do team level swap_ranges
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  auto [dataView1, cloneOfDataView1BeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{11, 523}, "dataView1");
+
+  auto [dataView2, cloneOfDataView2BeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{530, 1523}, "dataView2");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView1, dataView2, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto dataView1AfterOp_h      = create_host_space_copy(dataView1);
+  auto dataView2AfterOp_h      = create_host_space_copy(dataView2);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < dataView1AfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < dataView1AfterOp_h.extent(1); ++j) {
+      ASSERT_EQ(cloneOfDataView1BeforeOp_h(i, j), dataView2AfterOp_h(i, j));
+      ASSERT_EQ(cloneOfDataView2BeforeOp_h(i, j), dataView1AfterOp_h(i, j));
+    }
+    // each team should return an iterator past the last column
+    EXPECT_TRUE(distancesView_h(i) == numCols);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_swap_ranges_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamSwapRanges
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamTransformBinaryOp.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformBinaryOp.cpp
new file mode 100644
index 0000000000..b3557d8afb
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformBinaryOp.cpp
@@ -0,0 +1,185 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamTransformBinaryOp {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct AddValuesBinaryOp {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& a, const ValueType& b) const {
+    return a + b;
+  }
+};
+
+template <class SourceView1Type, class SourceView2Type, class DestViewType,
+          class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceView1Type m_sourceView1;
+  SourceView2Type m_sourceView2;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceView1Type sourceView1,
+               const SourceView2Type sourceView2, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView1(sourceView1),
+        m_sourceView2(sourceView2),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView1From =
+        Kokkos::subview(m_sourceView1, myRowIndex, Kokkos::ALL());
+    auto myRowView2From =
+        Kokkos::subview(m_sourceView2, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    using value_type = typename SourceView1Type::value_type;
+    if (m_apiPick == 0) {
+      auto it = KE::transform(
+          member, KE::cbegin(myRowView1From), KE::cend(myRowView1From),
+          KE::cbegin(myRowView2From), KE::begin(myRowViewDest),
+          AddValuesBinaryOp<value_type>());
+
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it = KE::transform(member, myRowView1From, myRowView2From,
+                              myRowViewDest, AddValuesBinaryOp<value_type>());
+
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team level transform with each team handling a row of
+     two rank-2 source views and applying a binary op that
+     add each pair of element from those two views
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView1, cloneOfSourceView1BeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{0, 523}, "sourceView1",
+          317539 /*random seed*/);
+  auto [sourceView2, cloneOfSourceView2BeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{0, 523}, "sourceView2",
+          957313 /*random seed*/);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  // make a host copy of the dest view that we can check below
+  // to be all zeros
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView1, sourceView2, destView, distancesView,
+                   intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < destViewAfterOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < destViewAfterOp_h.extent(1); ++j) {
+      // elements in dest view should be the sum of source elements
+      ASSERT_DOUBLE_EQ(destViewAfterOp_h(i, j),
+                       cloneOfSourceView1BeforeOp_h(i, j) +
+                           cloneOfSourceView2BeforeOp_h(i, j));
+    }
+
+    // each team should return an iterator whose distance from the
+    // beginning of the row equals the num of columns since
+    // each team transforms all elements in each row
+    EXPECT_TRUE(distancesView_h(i) == numCols);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_transform_team_test, test_binary_op) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamTransformBinaryOp
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamTransformExclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformExclusiveScan.cpp
new file mode 100644
index 0000000000..1c43854381
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformExclusiveScan.cpp
@@ -0,0 +1,245 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+
+namespace Test {
+namespace stdalgos {
+namespace TeamTransformExclusiveScan {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class ValueType>
+struct MultipliesByTwoFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& value) const { return value * 2; }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class InitValuesViewType,
+          class BinaryOpType, class UnaryOpType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  InitValuesViewType m_initValuesView;
+  BinaryOpType m_binaryOp;
+  UnaryOpType m_unaryOp;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               const InitValuesViewType initValuesView, BinaryOpType binaryOp,
+               UnaryOpType unaryOp, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_initValuesView(initValuesView),
+        m_binaryOp(binaryOp),
+        m_unaryOp(unaryOp),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto rowViewSrc    = Kokkos::subview(m_sourceView, rowIndex, Kokkos::ALL());
+    auto rowViewDest   = Kokkos::subview(m_destView, rowIndex, Kokkos::ALL());
+    const auto initVal = m_initValuesView(rowIndex);
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it = KE::transform_exclusive_scan(
+            member, KE::cbegin(rowViewSrc), KE::cend(rowViewSrc),
+            KE::begin(rowViewDest), initVal, m_binaryOp, m_unaryOp);
+        resultDist = KE::distance(KE::begin(rowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 1: {
+        auto it = KE::transform_exclusive_scan(member, rowViewSrc, rowViewDest,
+                                               initVal, m_binaryOp, m_unaryOp);
+        resultDist = KE::distance(KE::begin(rowViewDest), it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+struct InPlace {};
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level transform_exclusive_scan
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [sourceView, sourceViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // tranform_exclusive_scan returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the beginning
+  // of the interval that team operates on and then we check that these
+  // distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  PlusFunctor<ValueType> binaryOp;
+  MultipliesByTwoFunctor<ValueType> unaryOp;
+
+  // Create view of reduce init values to be used by test cases
+  Kokkos::View<ValueType*, Kokkos::DefaultHostExecutionSpace> initValuesView_h(
+      "initValuesView_h", numTeams);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(initValuesView_h, pool, lowerBound, upperBound);
+
+  auto initValuesView =
+      Kokkos::create_mirror_view_and_copy(space_t(), initValuesView_h);
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    TestFunctorA fnc(sourceView, sourceView, distancesView,
+                     intraTeamSentinelView, initValuesView, binaryOp, unaryOp,
+                     apiId);
+    Kokkos::parallel_for(policy, fnc);
+  } else {
+    TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                     initValuesView, binaryOp, unaryOp, apiId);
+    Kokkos::parallel_for(policy, fnc);
+  }
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto rowFrom   = Kokkos::subview(sourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto rowDest   = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto initValue = initValuesView_h(i);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+// libstdc++ as provided by GCC 8 does not have transform_exclusive_scan and
+// for GCC 9.1, 9.2 fails to compile for missing overload not accepting policy
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+#define transform_exclusive_scan testing_transform_exclusive_scan
+#else
+#define transform_exclusive_scan std::transform_exclusive_scan
+#endif
+
+    switch (apiId) {
+      case 0:
+      case 1: {
+        auto it = transform_exclusive_scan(
+            KE::cbegin(rowFrom), KE::cend(rowFrom), KE::begin(rowDest),
+            initValue, binaryOp, unaryOp);
+        const std::size_t stdDistance = KE::distance(KE::begin(rowDest), it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+        break;
+      }
+    }
+
+#undef transform_exclusive_scan
+  }
+
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    auto dataViewAfterOp_h = create_host_space_copy(sourceView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  } else {
+    auto dataViewAfterOp_h = create_host_space_copy(destView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  }
+}
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType, InPlaceOrVoid>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_transform_exclusive_scan_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+
+  run_all_scenarios<DynamicTag, double, InPlace>();
+  run_all_scenarios<StridedTwoRowsTag, int, InPlace>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned, InPlace>();
+}
+
+}  // namespace TeamTransformExclusiveScan
+}  // namespace stdalgos
+}  // namespace Test
+
+#endif
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamTransformInclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformInclusiveScan.cpp
new file mode 100644
index 0000000000..0b0d798fd8
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformInclusiveScan.cpp
@@ -0,0 +1,281 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+
+namespace Test {
+namespace stdalgos {
+namespace TeamTransformInclusiveScan {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class ValueType>
+struct MultipliesByTwoFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& value) const { return value * 2; }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView, class InitValuesViewType,
+          class BinaryOpType, class UnaryOpType>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  InitValuesViewType m_initValuesView;
+  BinaryOpType m_binaryOp;
+  UnaryOpType m_unaryOp;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               const InitValuesViewType initValuesView, BinaryOpType binaryOp,
+               UnaryOpType unaryOp, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_initValuesView(initValuesView),
+        m_binaryOp(binaryOp),
+        m_unaryOp(unaryOp),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto rowIndex = member.league_rank();
+
+    auto srcRow      = Kokkos::subview(m_sourceView, rowIndex, Kokkos::ALL());
+    const auto first = KE::cbegin(srcRow);
+    const auto last  = KE::cend(srcRow);
+    auto destRow     = Kokkos::subview(m_destView, rowIndex, Kokkos::ALL());
+    auto firstDest   = KE::begin(destRow);
+
+    const auto initVal   = m_initValuesView(rowIndex);
+    ptrdiff_t resultDist = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        auto it = KE::transform_inclusive_scan(member, first, last, firstDest,
+                                               m_binaryOp, m_unaryOp);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 1: {
+        auto it    = KE::transform_inclusive_scan(member, srcRow, destRow,
+                                               m_binaryOp, m_unaryOp);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 2: {
+        auto it = KE::transform_inclusive_scan(member, first, last, firstDest,
+                                               m_binaryOp, m_unaryOp, initVal);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+
+      case 3: {
+        auto it    = KE::transform_inclusive_scan(member, srcRow, destRow,
+                                               m_binaryOp, m_unaryOp, initVal);
+        resultDist = KE::distance(firstDest, it);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this] { m_distancesView(rowIndex) = resultDist; });
+
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+struct InPlace {};
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level transform_inclusive_scan
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [sourceView, sourceViewBeforeOp_h] = create_random_view_and_host_clone(
+      LayoutTag{}, numTeams, numCols, bounds, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // tranform_inclusive_scan returns an iterator so to verify that it is correct
+  // each team stores the distance of the returned iterator from the beginning
+  // of the interval that team operates on and then we check that these
+  // distances match the std result
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  PlusFunctor<ValueType> binaryOp;
+  MultipliesByTwoFunctor<ValueType> unaryOp;
+
+  // Create view of reduce init values to be used by test cases
+  Kokkos::View<ValueType*, Kokkos::DefaultHostExecutionSpace> initValuesView_h(
+      "initValuesView_h", numTeams);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(initValuesView_h, pool, lowerBound, upperBound);
+
+  auto initValuesView =
+      Kokkos::create_mirror_view_and_copy(space_t(), initValuesView_h);
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    TestFunctorA fnc(sourceView, sourceView, distancesView,
+                     intraTeamSentinelView, initValuesView, binaryOp, unaryOp,
+                     apiId);
+    Kokkos::parallel_for(policy, fnc);
+  } else {
+    TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                     initValuesView, binaryOp, unaryOp, apiId);
+    Kokkos::parallel_for(policy, fnc);
+  }
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < sourceView.extent(0); ++i) {
+    auto srcRow    = Kokkos::subview(sourceViewBeforeOp_h, i, Kokkos::ALL());
+    auto first     = KE::cbegin(srcRow);
+    auto last      = KE::cend(srcRow);
+    auto destRow   = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+    auto firstDest = KE::begin(destRow);
+    auto initValue = initValuesView_h(i);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+// libstdc++ as provided by GCC 8 does not have transform_inclusive_scan and
+// for GCC 9.1, 9.2 fails to compile for missing overload not accepting policy
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+#define transform_inclusive_scan testing_transform_inclusive_scan
+#else
+#define transform_inclusive_scan std::transform_inclusive_scan
+#endif
+
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const auto it =
+            transform_inclusive_scan(first, last, firstDest, binaryOp, unaryOp);
+        const std::size_t stdDistance = KE::distance(firstDest, it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const auto it = transform_inclusive_scan(first, last, firstDest,
+                                                 binaryOp, unaryOp, initValue);
+        const std::size_t stdDistance = KE::distance(firstDest, it);
+        ASSERT_EQ(stdDistance, distancesView_h(i));
+
+        break;
+      }
+    }
+  }
+#undef transform_inclusive_scan
+
+  if constexpr (std::is_same_v<InPlaceOrVoid, InPlace>) {
+    auto dataViewAfterOp_h = create_host_space_copy(sourceView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  } else {
+    auto dataViewAfterOp_h = create_host_space_copy(destView);
+    expect_equal_host_views(stdDestView, dataViewAfterOp_h);
+  }
+}
+
+template <class LayoutTag, class ValueType, class InPlaceOrVoid = void>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3}) {
+        test_A<LayoutTag, ValueType, InPlaceOrVoid>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_transform_inclusive_scan_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+
+  run_all_scenarios<DynamicTag, double, InPlace>();
+  run_all_scenarios<StridedTwoRowsTag, int, InPlace>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned, InPlace>();
+}
+
+}  // namespace TeamTransformInclusiveScan
+}  // namespace stdalgos
+}  // namespace Test
+
+#endif
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamTransformReduce.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformReduce.cpp
new file mode 100644
index 0000000000..17ded226aa
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformReduce.cpp
@@ -0,0 +1,323 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
+
+namespace Test {
+namespace stdalgos {
+namespace TeamTransformReduce {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs + rhs;
+  }
+};
+
+template <class ValueType>
+struct MultipliesFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& lhs, const ValueType& rhs) const {
+    return lhs * rhs;
+  }
+};
+
+template <class ValueType>
+struct PlusOneFunctor {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& val) const { return val + 1; };
+};
+
+template <class FirstDataViewType, class SecondDataViewType,
+          class InitValuesViewType, class ResultsViewType,
+          class IntraTeamSentinelView, class BinaryJoinerType,
+          class BinaryTransformType, class UnaryTransformType>
+struct TestFunctorA {
+  FirstDataViewType m_firstDataView;
+  SecondDataViewType m_secondDataView;
+  InitValuesViewType m_initValuesView;
+  ResultsViewType m_resultsView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  BinaryJoinerType m_binaryJoiner;
+  BinaryTransformType m_binaryTransform;
+  UnaryTransformType m_unaryTransform;
+  int m_apiPick;
+
+  TestFunctorA(const FirstDataViewType firstDataView,
+               const SecondDataViewType secondDataview,
+               const InitValuesViewType initValuesView,
+               const ResultsViewType resultsView,
+               const IntraTeamSentinelView intraTeamSentinelView,
+               BinaryJoinerType binaryJoiner,
+               BinaryTransformType binaryTransform,
+               UnaryTransformType unaryTransform, int apiPick)
+      : m_firstDataView(firstDataView),
+        m_secondDataView(secondDataview),
+        m_initValuesView(initValuesView),
+        m_resultsView(resultsView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_binaryJoiner(binaryJoiner),
+        m_binaryTransform(binaryTransform),
+        m_unaryTransform(unaryTransform),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const int rowIndex = member.league_rank();
+
+    auto firstDataRow =
+        Kokkos::subview(m_firstDataView, rowIndex, Kokkos::ALL());
+    auto firstDataRowBegin = KE::cbegin(firstDataRow);
+    auto firstDataRowEnd   = KE::cend(firstDataRow);
+
+    auto secondDataRow =
+        Kokkos::subview(m_secondDataView, rowIndex, Kokkos::ALL());
+    auto secondDataRowBegin = KE::cbegin(secondDataRow);
+
+    const auto initVal = m_initValuesView(rowIndex);
+    typename InitValuesViewType::non_const_value_type result = 0;
+
+    switch (m_apiPick) {
+      case 0: {
+        result =
+            KE::transform_reduce(member, firstDataRowBegin, firstDataRowEnd,
+                                 secondDataRowBegin, initVal);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 1: {
+        result =
+            KE::transform_reduce(member, firstDataRow, secondDataRow, initVal);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 2: {
+        result = KE::transform_reduce(
+            member, firstDataRowBegin, firstDataRowEnd, secondDataRowBegin,
+            initVal, m_binaryJoiner, m_binaryTransform);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 3: {
+        result =
+            KE::transform_reduce(member, firstDataRow, secondDataRow, initVal,
+                                 m_binaryJoiner, m_binaryTransform);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 4: {
+        result =
+            KE::transform_reduce(member, firstDataRowBegin, firstDataRowEnd,
+                                 initVal, m_binaryJoiner, m_unaryTransform);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+
+      case 5: {
+        result = KE::transform_reduce(member, firstDataRow, initVal,
+                                      m_binaryJoiner, m_unaryTransform);
+        Kokkos::single(Kokkos::PerTeam(member),
+                       [=, *this]() { m_resultsView(rowIndex) = result; });
+        break;
+      }
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, result, m_resultsView(rowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(rowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     use a rank-2 view randomly filled with values,
+     and run a team-level transform_reduce
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range.
+  constexpr ValueType lowerBound = 5;
+  constexpr ValueType upperBound = 523;
+  const auto bounds              = make_bounds(lowerBound, upperBound);
+
+  auto [firstDataView, firstDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(LayoutTag{}, numTeams, numCols, bounds,
+                                        "firstDataView");
+  auto [secondDataView, secondDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(LayoutTag{}, numTeams, numCols, bounds,
+                                        "secondDataView");
+
+  // Create view of init values to be used by test cases
+  Kokkos::View<ValueType*, Kokkos::DefaultHostExecutionSpace> initValuesView_h(
+      "initValuesView_h", numTeams);
+  using rand_pool =
+      Kokkos::Random_XorShift64_Pool<Kokkos::DefaultHostExecutionSpace>;
+  rand_pool pool(lowerBound * upperBound);
+  Kokkos::fill_random(initValuesView_h, pool, lowerBound, upperBound);
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // to verify that things work, each team stores the result of its
+  // transform_reduce call, and then we check that these match what we expect
+  Kokkos::View<ValueType*> resultsView("resultsView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  PlusFunctor<ValueType> binaryJoiner;
+  MultipliesFunctor<ValueType> binaryTransform;
+  PlusOneFunctor<ValueType> unaryTransform;
+
+  // use CTAD for functor
+  auto initValuesView =
+      Kokkos::create_mirror_view_and_copy(space_t(), initValuesView_h);
+  TestFunctorA fnc(firstDataView, secondDataView, initValuesView, resultsView,
+                   intraTeamSentinelView, binaryJoiner, binaryTransform,
+                   unaryTransform, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run cpp-std kernel and check
+  // -----------------------------------------------
+
+  auto resultsView_h           = create_host_space_copy(resultsView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < firstDataView.extent(0); ++i) {
+    auto firstDataRow =
+        Kokkos::subview(firstDataViewBeforeOp_h, i, Kokkos::ALL());
+
+    const auto firstDataRowBegin = KE::cbegin(firstDataRow);
+    const auto firstDataRowEnd   = KE::cend(firstDataRow);
+
+    auto secondDataRow =
+        Kokkos::subview(secondDataViewBeforeOp_h, i, Kokkos::ALL());
+
+    const auto secondDataRowBegin = KE::cbegin(secondDataRow);
+
+    const auto initVal = initValuesView_h(i);
+
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+// libstdc++ as provided by GCC 8 does not have reduce, transform_reduce,
+// exclusive_scan, inclusive_scan, transform_exclusive_scan,
+// transform_inclusive_scan and for GCC 9.1, 9.2 fails to compile them for
+// missing overload not accepting policy
+#if defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE <= 9)
+#define transform_reduce testing_transform_reduce
+#else
+#define transform_reduce std::transform_reduce
+#endif
+
+    switch (apiId) {
+      case 0:
+      case 1: {
+        const auto result = transform_reduce(firstDataRowBegin, firstDataRowEnd,
+                                             secondDataRowBegin, initVal);
+
+        if constexpr (std::is_floating_point_v<ValueType>) {
+          EXPECT_FLOAT_EQ(result, resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        const ValueType result = transform_reduce(
+            firstDataRowBegin, firstDataRowEnd, secondDataRowBegin, initVal,
+            binaryJoiner, binaryTransform);
+
+        if constexpr (std::is_floating_point_v<ValueType>) {
+          EXPECT_FLOAT_EQ(result, resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+
+      case 4:
+      case 5: {
+        const ValueType result =
+            transform_reduce(firstDataRowBegin, firstDataRowEnd, initVal,
+                             binaryJoiner, unaryTransform);
+
+        if constexpr (std::is_floating_point_v<ValueType>) {
+          EXPECT_FLOAT_EQ(result, resultsView_h(i));
+        } else {
+          ASSERT_EQ(result, resultsView_h(i));
+        }
+
+        break;
+      }
+    }
+
+#undef transform_reduce
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 8153}) {
+      for (int apiId : {0, 1, 2, 3, 4, 5}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_transform_reduce_team_test, test) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamTransformReduce
+}  // namespace stdalgos
+}  // namespace Test
+
+#endif
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamTransformUnaryOp.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformUnaryOp.cpp
new file mode 100644
index 0000000000..0fbb040020
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamTransformUnaryOp.cpp
@@ -0,0 +1,176 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamTransformUnaryOp {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct PlusTwoUnaryOp {
+  KOKKOS_INLINE_FUNCTION
+  ValueType operator()(const ValueType& val) const {
+    return val + static_cast<ValueType>(2);
+  }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    using value_type = typename SourceViewType::value_type;
+    if (m_apiPick == 0) {
+      auto it = KE::transform(member, KE::cbegin(myRowViewFrom),
+                              KE::cend(myRowViewFrom), KE::begin(myRowViewDest),
+                              PlusTwoUnaryOp<value_type>());
+
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it = KE::transform(member, myRowViewFrom, myRowViewDest,
+                              PlusTwoUnaryOp<value_type>());
+
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team level transform with each team handling a row of
+     a rank-2 source view and applying a unary op that
+     increments each element by two
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from an arbitrary range
+  auto [sourceView, cloneOfSourceViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{0, 523}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+  // make a host copy of the dest view that we can check below
+  // to be all zeros since this should remain unchanged
+  auto destViewBeforeOp_h = create_host_space_copy(destView);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto sourceViewAfterOp_h     = create_host_space_copy(sourceView);
+  auto destViewAfterOp_h       = create_host_space_copy(destView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  for (std::size_t i = 0; i < destViewBeforeOp_h.extent(0); ++i) {
+    for (std::size_t j = 0; j < destViewBeforeOp_h.extent(1); ++j) {
+      // source view should not change
+      ASSERT_EQ(sourceViewAfterOp_h(i, j), cloneOfSourceViewBeforeOp_h(i, j));
+
+      // elements in dest view should be the source elements plus two
+      ASSERT_EQ(destViewAfterOp_h(i, j), cloneOfSourceViewBeforeOp_h(i, j) + 2);
+      ASSERT_EQ(destViewBeforeOp_h(i, j), ValueType(0));
+    }
+
+    // each team should return an iterator whose distance from the
+    // beginning of the row equals the num of columns since
+    // each team transforms all elements in each row
+    EXPECT_TRUE(distancesView_h(i) == numCols);
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_transform_team_test, test_unary_op) {
+  run_all_scenarios<DynamicTag, double>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, unsigned>();
+}
+
+}  // namespace TeamTransformUnaryOp
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamUnique.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamUnique.cpp
new file mode 100644
index 0000000000..c46146e0a8
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamUnique.cpp
@@ -0,0 +1,171 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+#include <algorithm>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamUniqueDefaultPredicate {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ViewType, class DistancesViewType, class IntraTeamSentinelView>
+struct TestFunctorA {
+  ViewType m_view;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const ViewType view, const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_view(view),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowView        = Kokkos::subview(m_view, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist  = 0;
+
+    if (m_apiPick == 0) {
+      auto it    = KE::unique(member, KE::begin(myRowView), KE::end(myRowView));
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::unique(member, myRowView);
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 2) {
+      using value_type = typename ViewType::value_type;
+      auto it    = KE::unique(member, KE::begin(myRowView), KE::end(myRowView),
+                           CustomEqualityComparator<value_type>{});
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 3) {
+      using value_type = typename ViewType::value_type;
+      auto it =
+          KE::unique(member, myRowView, CustomEqualityComparator<value_type>{});
+      resultDist = KE::distance(KE::begin(myRowView), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team-level KE::unique on a rank-2 view where
+     data is filled randomly such that we have several subsets
+     of consecutive equal elements. Use one team per row.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from a range that is tight enough that there is a high likelihood
+  // of having several consecutive subsets of equal elements
+  auto [dataView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{121, 153}, "dataView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(dataView, distancesView, intraTeamSentinelView, apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  // here I can use cloneOfDataViewBeforeOp_h to run std algo on
+  // since that contains a valid copy of the data
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    auto myRow = Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+
+    std::size_t stdDistance = 0;
+    if (apiId <= 1) {
+      auto it     = std::unique(KE::begin(myRow), KE::end(myRow));
+      stdDistance = KE::distance(KE::begin(myRow), it);
+    } else {
+      auto it     = std::unique(KE::begin(myRow), KE::end(myRow),
+                            CustomEqualityComparator<value_type>{});
+      stdDistance = KE::distance(KE::begin(myRow), it);
+    }
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+  }
+
+  auto dataViewAfterOp_h = create_host_space_copy(dataView);
+  expect_equal_host_views(cloneOfDataViewBeforeOp_h, dataViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_unique_team_test, test_default_predicate) {
+  run_all_scenarios<DynamicTag, int>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+}
+
+}  // namespace TeamUniqueDefaultPredicate
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTeamUniqueCopy.cpp b/algorithms/unit_tests/TestStdAlgorithmsTeamUniqueCopy.cpp
new file mode 100644
index 0000000000..0d3289e196
--- /dev/null
+++ b/algorithms/unit_tests/TestStdAlgorithmsTeamUniqueCopy.cpp
@@ -0,0 +1,200 @@
+//@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 <TestStdAlgorithmsCommon.hpp>
+
+namespace Test {
+namespace stdalgos {
+namespace TeamUniqueCopy {
+
+namespace KE = Kokkos::Experimental;
+
+template <class ValueType>
+struct CustomPredicate {
+  KOKKOS_INLINE_FUNCTION
+  bool operator()(ValueType a, ValueType b) const { return a == b; }
+};
+
+template <class SourceViewType, class DestViewType, class DistancesViewType,
+          class IntraTeamSentinelView>
+struct TestFunctorA {
+  SourceViewType m_sourceView;
+  DestViewType m_destView;
+  DistancesViewType m_distancesView;
+  IntraTeamSentinelView m_intraTeamSentinelView;
+  int m_apiPick;
+
+  TestFunctorA(const SourceViewType sourceView, const DestViewType destView,
+               const DistancesViewType distancesView,
+               const IntraTeamSentinelView intraTeamSentinelView, int apiPick)
+      : m_sourceView(sourceView),
+        m_destView(destView),
+        m_distancesView(distancesView),
+        m_intraTeamSentinelView(intraTeamSentinelView),
+        m_apiPick(apiPick) {}
+
+  template <class MemberType>
+  KOKKOS_INLINE_FUNCTION void operator()(const MemberType& member) const {
+    const auto myRowIndex = member.league_rank();
+    auto myRowViewFrom =
+        Kokkos::subview(m_sourceView, myRowIndex, Kokkos::ALL());
+    auto myRowViewDest = Kokkos::subview(m_destView, myRowIndex, Kokkos::ALL());
+    ptrdiff_t resultDist = 0;
+
+    if (m_apiPick == 0) {
+      auto it =
+          KE::unique_copy(member, KE::begin(myRowViewFrom),
+                          KE::end(myRowViewFrom), KE::begin(myRowViewDest));
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 1) {
+      auto it    = KE::unique_copy(member, myRowViewFrom, myRowViewDest);
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 2) {
+      using comparator_t =
+          CustomEqualityComparator<typename SourceViewType::value_type>;
+      auto it    = KE::unique_copy(member, KE::begin(myRowViewFrom),
+                                KE::end(myRowViewFrom),
+                                KE::begin(myRowViewDest), comparator_t());
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    } else if (m_apiPick == 3) {
+      using comparator_t =
+          CustomEqualityComparator<typename SourceViewType::value_type>;
+      auto it =
+          KE::unique_copy(member, myRowViewFrom, myRowViewDest, comparator_t());
+      resultDist = KE::distance(KE::begin(myRowViewDest), it);
+      Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+        m_distancesView(myRowIndex) = resultDist;
+      });
+    }
+
+    // store result of checking if all members have their local
+    // values matching the one stored in m_distancesView
+    member.team_barrier();
+    const bool intraTeamCheck = team_members_have_matching_result(
+        member, resultDist, m_distancesView(myRowIndex));
+    Kokkos::single(Kokkos::PerTeam(member), [=, *this]() {
+      m_intraTeamSentinelView(myRowIndex) = intraTeamCheck;
+    });
+  }
+};
+
+template <class LayoutTag, class ValueType>
+void test_A(std::size_t numTeams, std::size_t numCols, int apiId) {
+  /* description:
+     team-level KE::unique_copy on a rank-2 view where
+     data is filled randomly such that we have several subsets
+     of consecutive equal elements. Use one team per row.
+   */
+
+  // -----------------------------------------------
+  // prepare data
+  // -----------------------------------------------
+  // create a view in the memory space associated with default exespace
+  // with as many rows as the number of teams and fill it with random
+  // values from a range that is tight enough that there is a high likelihood
+  // of having several consecutive subsets of equal elements
+  auto [sourceView, cloneOfDataViewBeforeOp_h] =
+      create_random_view_and_host_clone(
+          LayoutTag{}, numTeams, numCols,
+          Kokkos::pair<ValueType, ValueType>{121, 153}, "sourceView");
+
+  // -----------------------------------------------
+  // launch kokkos kernel
+  // -----------------------------------------------
+  using space_t = Kokkos::DefaultExecutionSpace;
+  Kokkos::TeamPolicy<space_t> policy(numTeams, Kokkos::AUTO());
+
+  // create the destination view
+  Kokkos::View<ValueType**> destView("destView", numTeams, numCols);
+
+  // each team stores the distance of the returned iterator from the
+  // beginning of the interval that team operates on and then we check
+  // that these distances match the expectation
+  Kokkos::View<std::size_t*> distancesView("distancesView", numTeams);
+  // sentinel to check if all members of the team compute the same result
+  Kokkos::View<bool*> intraTeamSentinelView("intraTeamSameResult", numTeams);
+
+  // use CTAD for functor
+  TestFunctorA fnc(sourceView, destView, distancesView, intraTeamSentinelView,
+                   apiId);
+  Kokkos::parallel_for(policy, fnc);
+
+  // -----------------------------------------------
+  // run std algo and check
+  // -----------------------------------------------
+  auto distancesView_h         = create_host_space_copy(distancesView);
+  auto intraTeamSentinelView_h = create_host_space_copy(intraTeamSentinelView);
+  Kokkos::View<ValueType**, Kokkos::HostSpace> stdDestView("stdDestView",
+                                                           numTeams, numCols);
+
+  for (std::size_t i = 0; i < cloneOfDataViewBeforeOp_h.extent(0); ++i) {
+    ASSERT_TRUE(intraTeamSentinelView_h(i));
+
+    auto myRowFrom =
+        Kokkos::subview(cloneOfDataViewBeforeOp_h, i, Kokkos::ALL());
+    auto myRowDest = Kokkos::subview(stdDestView, i, Kokkos::ALL());
+
+    std::size_t stdDistance = 0;
+    if (apiId <= 1) {
+      auto it     = std::unique_copy(KE::cbegin(myRowFrom), KE::cend(myRowFrom),
+                                 KE::begin(myRowDest));
+      stdDistance = KE::distance(KE::begin(myRowDest), it);
+    } else {
+      auto it     = std::unique_copy(KE::cbegin(myRowFrom), KE::cend(myRowFrom),
+                                 KE::begin(myRowDest),
+                                 CustomEqualityComparator<value_type>{});
+      stdDistance = KE::distance(KE::begin(myRowDest), it);
+    }
+    ASSERT_EQ(stdDistance, distancesView_h(i));
+  }
+
+  auto destViewAfterOp_h = create_host_space_copy(destView);
+  expect_equal_host_views(stdDestView, destViewAfterOp_h);
+}
+
+template <class LayoutTag, class ValueType>
+void run_all_scenarios() {
+  for (int numTeams : teamSizesToTest) {
+    for (const auto& numCols : {0, 1, 2, 13, 101, 1444, 11113}) {
+      for (int apiId : {0, 1}) {
+        test_A<LayoutTag, ValueType>(numTeams, numCols, apiId);
+      }
+    }
+  }
+}
+
+TEST(std_algorithms_unique_copy_team_test, test) {
+  // FIXME_OPENMPTARGET
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  GTEST_SKIP() << "the test is known to fail with OpenMPTarget on Intel GPUs";
+#endif
+  run_all_scenarios<DynamicTag, int>();
+  run_all_scenarios<StridedTwoRowsTag, int>();
+  run_all_scenarios<StridedThreeRowsTag, int>();
+}
+
+}  // namespace TeamUniqueCopy
+}  // namespace stdalgos
+}  // namespace Test
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp
index 75525b3b0f..fa2804256a 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsTransformExclusiveScan.cpp
@@ -16,6 +16,7 @@
 
 #include <TestStdAlgorithmsCommon.hpp>
 #include <utility>
+#include <iomanip>
 
 namespace Test {
 namespace stdalgos {
@@ -160,24 +161,15 @@ void verify_data(ViewType1 data_view,  // contains data
       create_mirror_view_and_copy(Kokkos::HostSpace(), test_view_dc);
   if (test_view_h.extent(0) > 0) {
     for (std::size_t i = 0; i < test_view_h.extent(0); ++i) {
-      // std::cout << i << " " << std::setprecision(15) << data_view_h(i) << " "
-      //           << 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) {
         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) {
-          std::cout << i << " " << std::setprecision(15) << data_view_h(i)
-                    << " " << gold_h(i) << " " << test_view_h(i) << " "
-                    << std::abs(gold_h(i) - test_view_h(i)) << std::endl;
-        }
-        EXPECT_LT(error, 1e-10);
+        ASSERT_LT(error, 1e-10) << i << " " << std::setprecision(15) << error
+                                << static_cast<double>(test_view_h(i)) << " "
+                                << static_cast<double>(gold_h(i));
       }
     }
-    // std::cout << " last el: " << test_view_h(test_view_h.extent(0)-1) <<
-    // std::endl;
   }
 }
 
@@ -205,17 +197,13 @@ void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
                          BinaryOp bop, UnaryOp uop) {
   const auto name            = std::get<0>(scenario_info);
   const std::size_t view_ext = std::get<1>(scenario_info);
-  // std::cout << "transform_exclusive_scan custom op: " << name << ", "
-  //           << view_tag_to_string(Tag{}) << ", "
-  //           << value_type_to_string(ValueType()) << ", "
-  //           << "init = " << init_value << std::endl;
-
-  auto view_dest =
-      create_view<ValueType>(Tag{}, view_ext, "transform_exclusive_scan");
-  auto view_from =
-      create_view<ValueType>(Tag{}, view_ext, "transform_exclusive_scan");
+
+  auto view_from = create_view<ValueType>(Tag{}, view_ext,
+                                          "transform_exclusive_scan_view_from");
   fill_view(view_from, name);
 
+  auto view_dest = create_view<ValueType>(Tag{}, view_ext,
+                                          "transform_exclusive_scan_view_dest");
   {
     fill_zero(view_dest);
     auto r = KE::transform_exclusive_scan(
@@ -253,6 +241,65 @@ void run_single_scenario(const InfoType& scenario_info, ValueType init_value,
   Kokkos::fence();
 }
 
+template <class Tag, class ValueType, class InfoType, class BinaryOp,
+          class UnaryOp>
+void run_single_scenario_inplace(const InfoType& scenario_info,
+                                 ValueType init_value, BinaryOp bop,
+                                 UnaryOp uop) {
+  const auto name            = std::get<0>(scenario_info);
+  const std::size_t view_ext = std::get<1>(scenario_info);
+
+  // since here we call the in-place operation, we need to use two views:
+  // view1: filled according to what the scenario asks for and is not modified
+  // view2: filled according to what the scenario asks for and used for the
+  // in-place op Therefore, after the op is done, view2 should contain the
+  // result of doing exclusive scan NOTE: view2 is filled below every time
+  // because the algorithm acts in place
+
+  auto view1 =
+      create_view<ValueType>(Tag{}, view_ext, "transform_exclusive_scan_view1");
+  fill_view(view1, name);
+
+  auto view2 =
+      create_view<ValueType>(Tag{}, view_ext, "transform_exclusive_scan_view2");
+
+  {
+    fill_view(view2, name);
+    auto r = KE::transform_exclusive_scan(exespace(), KE::cbegin(view2),
+                                          KE::cend(view2), KE::begin(view2),
+                                          init_value, bop, uop);
+    ASSERT_EQ(r, KE::end(view2));
+    verify_data(view1, view2, init_value, bop, uop);
+  }
+
+  {
+    fill_view(view2, name);
+    auto r = KE::transform_exclusive_scan(
+        "label", exespace(), KE::cbegin(view2), KE::cend(view2),
+        KE::begin(view2), init_value, bop, uop);
+    ASSERT_EQ(r, KE::end(view2));
+    verify_data(view1, view2, init_value, bop, uop);
+  }
+
+  {
+    fill_view(view2, name);
+    auto r = KE::transform_exclusive_scan(exespace(), view2, view2, init_value,
+                                          bop, uop);
+    ASSERT_EQ(r, KE::end(view2));
+    verify_data(view1, view2, init_value, bop, uop);
+  }
+
+  {
+    fill_view(view2, name);
+    auto r = KE::transform_exclusive_scan("label", exespace(), view2, view2,
+                                          init_value, bop, uop);
+    ASSERT_EQ(r, KE::end(view2));
+    verify_data(view1, view2, init_value, bop, uop);
+  }
+
+  Kokkos::fence();
+}
+
 template <class Tag, class ValueType>
 void run_all_scenarios() {
   const std::map<std::string, std::size_t> scenarios = {
@@ -267,6 +314,11 @@ void run_all_scenarios() {
     run_single_scenario<Tag, ValueType>(it, ValueType{1}, bop_t(), uop_t());
     run_single_scenario<Tag, ValueType>(it, ValueType{-2}, bop_t(), uop_t());
     run_single_scenario<Tag, ValueType>(it, ValueType{3}, bop_t(), uop_t());
+
+    run_single_scenario_inplace<Tag, ValueType>(it, ValueType{0}, bop_t(),
+                                                uop_t());
+    run_single_scenario_inplace<Tag, ValueType>(it, ValueType{-2}, bop_t(),
+                                                uop_t());
   }
 }
 
@@ -295,7 +347,7 @@ TEST(std_algorithms_numeric_ops_test, transform_exclusive_scan_functor) {
       Kokkos::Experimental::Impl::StdNumericScanIdentityReferenceUnaryFunctor<
           int>;
   using functor_type =
-      Kokkos::Experimental::Impl::TransformExclusiveScanFunctor<
+      Kokkos::Experimental::Impl::TransformExclusiveScanFunctorWithValueWrapper<
           exespace, int, int, view_type, view_type, MultiplyFunctor<int>,
           unary_op_type>;
   functor_type functor(dummy, dummy_view, dummy_view, {}, {});
diff --git a/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp b/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp
index 5d122ac5e8..fb81ae91b0 100644
--- a/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp
+++ b/algorithms/unit_tests/TestStdAlgorithmsTransformInclusiveScan.cpp
@@ -16,6 +16,7 @@
 
 #include <TestStdAlgorithmsCommon.hpp>
 #include <utility>
+#include <iomanip>
 
 namespace Test {
 namespace stdalgos {
@@ -172,24 +173,15 @@ void verify_data(ViewType1 data_view,  // contains data
       create_mirror_view_and_copy(Kokkos::HostSpace(), test_view_dc);
   if (test_view_h.extent(0) > 0) {
     for (std::size_t i = 0; i < test_view_h.extent(0); ++i) {
-      // std::cout << i << " " << std::setprecision(15) << data_view_h(i) << " "
-      //           << 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) {
         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) {
-          std::cout << i << " " << std::setprecision(15) << data_view_h(i)
-                    << " " << gold_h(i) << " " << test_view_h(i) << " "
-                    << std::abs(gold_h(i) - test_view_h(i)) << std::endl;
-        }
-        EXPECT_LT(error, 1e-10);
+        ASSERT_LT(error, 1e-10) << i << " " << std::setprecision(15) << error
+                                << static_cast<double>(test_view_h(i)) << " "
+                                << static_cast<double>(gold_h(i));
       }
     }
-    // std::cout << " last el: " << test_view_h(test_view_h.extent(0)-1) <<
-    // std::endl;
   }
 }
 
@@ -210,30 +202,11 @@ struct SumBinaryFunctor {
 std::string value_type_to_string(int) { return "int"; }
 std::string value_type_to_string(double) { return "double"; }
 
-template <class Tag, class BopT, class UopT>
-void print_scenario_details(const std::string& name, BopT bop, UopT uop) {
-  (void)bop;
-  (void)uop;
-  std::cout << "transform_inclusive_scan: " << name << ", "
-            << view_tag_to_string(Tag{}) << std::endl;
-}
-
-template <class Tag, class BopT, class UopT, class ValueType>
-void print_scenario_details(const std::string& name, BopT bop, UopT uop,
-                            ValueType init_value) {
-  (void)bop;
-  (void)uop;
-  std::cout << "transform_inclusive_scan: " << name << ", "
-            << view_tag_to_string(Tag{}) << ", "
-            << "init = " << init_value << std::endl;
-}
-
 template <class Tag, class ValueType, class InfoType, class... Args>
 void run_single_scenario(const InfoType& scenario_info,
                          Args... args /* by value on purpose*/) {
   const auto name            = std::get<0>(scenario_info);
   const std::size_t view_ext = std::get<1>(scenario_info);
-  // print_scenario_details<Tag>(name, args...);
 
   auto view_dest =
       create_view<ValueType>(Tag{}, view_ext, "transform_inclusive_scan");
@@ -278,6 +251,63 @@ void run_single_scenario(const InfoType& scenario_info,
   Kokkos::fence();
 }
 
+template <class Tag, class ValueType, class InfoType, class... Args>
+void run_single_scenario_inplace(const InfoType& scenario_info,
+                                 Args... args /* by value on purpose*/) {
+  const auto name            = std::get<0>(scenario_info);
+  const std::size_t view_ext = std::get<1>(scenario_info);
+
+  // since here we call the in-place operation, we need to use two views:
+  // view1: filled according to scenario and is not modified
+  // view2: filled according scenario and used for the in-place op
+  // Therefore, after the op is done, view_2 should contain the
+  // result of doing exclusive scan.
+  // NOTE: view2 must be filled before every call to the algorithm
+  // because the algorithm acts in place
+
+  auto view_1 = create_view<ValueType>(Tag{}, view_ext,
+                                       "transform_inclusive_scan_view_1");
+  fill_view(view_1, name);
+
+  auto view_2 = create_view<ValueType>(Tag{}, view_ext,
+                                       "transform_inclusive_scan_view_2");
+
+  {
+    fill_view(view_2, name);
+    auto r = KE::transform_inclusive_scan(exespace(), KE::cbegin(view_2),
+                                          KE::cend(view_2), KE::begin(view_2),
+                                          args...);
+    ASSERT_EQ(r, KE::end(view_2));
+    verify_data(view_1, view_2, args...);
+  }
+
+  {
+    fill_view(view_2, name);
+    auto r = KE::transform_inclusive_scan("label", exespace(),
+                                          KE::cbegin(view_2), KE::cend(view_2),
+                                          KE::begin(view_2), args...);
+    ASSERT_EQ(r, KE::end(view_2));
+    verify_data(view_1, view_2, args...);
+  }
+
+  {
+    fill_view(view_2, name);
+    auto r = KE::transform_inclusive_scan(exespace(), view_2, view_2, args...);
+    ASSERT_EQ(r, KE::end(view_2));
+    verify_data(view_1, view_2, args...);
+  }
+
+  {
+    fill_view(view_2, name);
+    auto r = KE::transform_inclusive_scan("label", exespace(), view_2, view_2,
+                                          args...);
+    ASSERT_EQ(r, KE::end(view_2));
+    verify_data(view_1, view_2, args...);
+  }
+
+  Kokkos::fence();
+}
+
 template <class Tag, class ValueType>
 void run_all_scenarios() {
   const std::map<std::string, std::size_t> scenarios = {
@@ -294,15 +324,23 @@ void run_all_scenarios() {
     run_single_scenario<Tag, ValueType>(it, bop_t(), uop_t(), ValueType{2});
     run_single_scenario<Tag, ValueType>(it, bop_t(), uop_t(), ValueType{-1});
     run_single_scenario<Tag, ValueType>(it, bop_t(), uop_t(), ValueType{-2});
+
+    run_single_scenario_inplace<Tag, ValueType>(it, bop_t(), uop_t());
+    run_single_scenario_inplace<Tag, ValueType>(it, bop_t(), uop_t(),
+                                                ValueType{0});
+    run_single_scenario_inplace<Tag, ValueType>(it, bop_t(), uop_t(),
+                                                ValueType{2});
+    run_single_scenario_inplace<Tag, ValueType>(it, bop_t(), uop_t(),
+                                                ValueType{-2});
   }
 }
 
 #if !defined KOKKOS_ENABLE_OPENMPTARGET
 TEST(std_algorithms_numeric_ops_test, transform_inclusive_scan) {
   run_all_scenarios<DynamicTag, double>();
-  // run_all_scenarios<StridedThreeTag, double>();
-  // run_all_scenarios<DynamicTag, int>();
-  // run_all_scenarios<StridedThreeTag, int>();
+  run_all_scenarios<StridedThreeTag, double>();
+  run_all_scenarios<DynamicTag, int>();
+  run_all_scenarios<StridedThreeTag, int>();
 }
 #endif
 
@@ -355,18 +393,20 @@ TEST(std_algorithms_numeric_ops_test, transform_inclusive_scan_functor) {
   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>;
+    using functor_type =
+        KE::Impl::ExeSpaceTransformInclusiveScanNoInitValueFunctor<
+            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>;
+    using functor_type =
+        KE::Impl::ExeSpaceTransformInclusiveScanWithInitValueFunctor<
+            exespace, int, int, view_type, view_type, MultiplyFunctor<int>,
+            unary_op_type>;
     functor_type functor(dummy_view, dummy_view, {}, {}, dummy);
 
     test_lambda(functor);
diff --git a/algorithms/unit_tests/TestStdReducers.cpp b/algorithms/unit_tests/TestStdReducers.cpp
index 3847e1e6a3..c05006a161 100644
--- a/algorithms/unit_tests/TestStdReducers.cpp
+++ b/algorithms/unit_tests/TestStdReducers.cpp
@@ -83,9 +83,6 @@ auto run_min_or_max_test(ViewType view, StdReducersTestEnumOrder enValue) {
   static_assert(std::is_same<ExeSpace, Kokkos::HostSpace>::value,
                 "test is only enabled for HostSpace");
 
-  std::cout << "checking reduction with order: " << order_to_string(enValue)
-            << "\n";
-
   using view_value_type = typename ViewType::value_type;
   using reducer_type    = std::conditional_t<
       (flag == 0), Kokkos::MaxFirstLoc<view_value_type, IndexType, ExeSpace>,
@@ -132,18 +129,24 @@ TEST(std_algorithms_reducers, max_first_loc) {
 
   const auto pair1 = run_min_or_max_test<0, hostspace, index_type>(
       view_h, StdReducersTestEnumOrder::LeftToRight);
-  ASSERT_EQ(pair1.first, gold_value);
-  ASSERT_EQ(pair1.second, gold_location);
+  ASSERT_EQ(pair1.first, gold_value)
+      << order_to_string(StdReducersTestEnumOrder::LeftToRight);
+  ASSERT_EQ(pair1.second, gold_location)
+      << order_to_string(StdReducersTestEnumOrder::LeftToRight);
 
   const auto pair2 = run_min_or_max_test<0, hostspace, index_type>(
       view_h, StdReducersTestEnumOrder::RightToLeft);
-  ASSERT_EQ(pair2.first, gold_value);
-  ASSERT_EQ(pair2.second, gold_location);
+  ASSERT_EQ(pair2.first, gold_value)
+      << order_to_string(StdReducersTestEnumOrder::RightToLeft);
+  ASSERT_EQ(pair2.second, gold_location)
+      << order_to_string(StdReducersTestEnumOrder::RightToLeft);
 
   const auto pair3 = run_min_or_max_test<0, hostspace, index_type>(
       view_h, StdReducersTestEnumOrder::Random);
-  ASSERT_EQ(pair3.first, gold_value);
-  ASSERT_EQ(pair3.second, gold_location);
+  ASSERT_EQ(pair3.first, gold_value)
+      << order_to_string(StdReducersTestEnumOrder::Random);
+  ASSERT_EQ(pair3.second, gold_location)
+      << order_to_string(StdReducersTestEnumOrder::Random);
 }
 
 TEST(std_algorithms_reducers, min_first_loc) {
@@ -191,9 +194,6 @@ void run_min_max_test(ViewType view, StdReducersTestEnumOrder enValue,
   static_assert(std::is_same<ExeSpace, Kokkos::HostSpace>::value,
                 "test is only enabled for HostSpace");
 
-  std::cout << "checking reduction with order: " << order_to_string(enValue)
-            << "\n";
-
   using view_value_type = typename ViewType::value_type;
   using reducer_type =
       Kokkos::MinMaxFirstLastLoc<view_value_type, IndexType, ExeSpace>;
@@ -212,10 +212,10 @@ void run_min_max_test(ViewType view, StdReducersTestEnumOrder enValue,
                  reduction_value_type{view(index), view(index), index, index});
   }
 
-  ASSERT_EQ(red_result.min_val, gold_values.first);
-  ASSERT_EQ(red_result.max_val, gold_values.second);
-  ASSERT_EQ(red_result.min_loc, gold_locs.first);
-  ASSERT_EQ(red_result.max_loc, gold_locs.second);
+  ASSERT_EQ(red_result.min_val, gold_values.first) << order_to_string(enValue);
+  ASSERT_EQ(red_result.max_val, gold_values.second) << order_to_string(enValue);
+  ASSERT_EQ(red_result.min_loc, gold_locs.first) << order_to_string(enValue);
+  ASSERT_EQ(red_result.max_loc, gold_locs.second) << order_to_string(enValue);
 }
 
 TEST(std_algorithms_reducers, min_max_first_last_loc) {
diff --git a/appveyor.yml b/appveyor.yml
index ceb33bf441..d0a5645ef7 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -5,6 +5,6 @@ build_script:
 - cmd: >-
     mkdir build &&
     cd build &&
-    cmake c:\projects\source -DKokkos_ENABLE_TESTS=ON -DKokkos_ENABLE_BENCHMARKS=ON -DCMAKE_CXX_FLAGS="/W0 /EHsc" -DKokkos_ENABLE_DEPRECATED_CODE_4=ON -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF &&
+    cmake c:\projects\source -DKokkos_ENABLE_IMPL_MDSPAN=OFF -DKokkos_ENABLE_TESTS=ON -DCMAKE_CXX_FLAGS="/W0 /EHsc" -DKokkos_ENABLE_DEPRECATED_CODE_4=ON -DKokkos_ENABLE_DEPRECATION_WARNINGS=OFF &&
     cmake --build . --target install &&
     ctest -C Debug --output-on-failure
diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
new file mode 100644
index 0000000000..529ef393d9
--- /dev/null
+++ b/benchmarks/CMakeLists.txt
@@ -0,0 +1,12 @@
+#FIXME_OPENMPTARGET - compiling in debug mode causes ICE.
+KOKKOS_ADD_BENCHMARK_DIRECTORIES(atomic)
+KOKKOS_ADD_BENCHMARK_DIRECTORIES(gather)
+KOKKOS_ADD_BENCHMARK_DIRECTORIES(gups)
+KOKKOS_ADD_BENCHMARK_DIRECTORIES(launch_latency)
+KOKKOS_ADD_BENCHMARK_DIRECTORIES(stream)
+KOKKOS_ADD_BENCHMARK_DIRECTORIES(view_copy_constructor)
+#FIXME_OPENMPTARGET - These two benchmarks cause ICE. Commenting them for now but a deeper analysis on the cause and a possible fix will follow.
+IF(NOT Kokkos_ENABLE_OPENMPTARGET)
+    KOKKOS_ADD_BENCHMARK_DIRECTORIES(policy_performance)
+    KOKKOS_ADD_BENCHMARK_DIRECTORIES(bytes_and_flops)
+ENDIF()
diff --git a/benchmarks/atomic/CMakeLists.txt b/benchmarks/atomic/CMakeLists.txt
new file mode 100644
index 0000000000..85f7412f49
--- /dev/null
+++ b/benchmarks/atomic/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  atomic
+  SOURCES main.cpp
+)
diff --git a/benchmarks/bytes_and_flops/CMakeLists.txt b/benchmarks/bytes_and_flops/CMakeLists.txt
new file mode 100644
index 0000000000..0ce44a6f1a
--- /dev/null
+++ b/benchmarks/bytes_and_flops/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  bytes_and_flops
+  SOURCES bench_double.cpp bench_float.cpp bench_int32_t.cpp bench_int64_t.cpp main.cpp
+)
diff --git a/benchmarks/bytes_and_flops/bench.hpp b/benchmarks/bytes_and_flops/bench.hpp
index 2589fd7309..88830af624 100644
--- a/benchmarks/bytes_and_flops/bench.hpp
+++ b/benchmarks/bytes_and_flops/bench.hpp
@@ -37,22 +37,22 @@ struct RunStride {
 };
 
 #define STRIDE 1
-#include <bench_stride.hpp>
+#include "bench_stride.hpp"
 #undef STRIDE
 #define STRIDE 2
-#include <bench_stride.hpp>
+#include "bench_stride.hpp"
 #undef STRIDE
 #define STRIDE 4
-#include <bench_stride.hpp>
+#include "bench_stride.hpp"
 #undef STRIDE
 #define STRIDE 8
-#include <bench_stride.hpp>
+#include "bench_stride.hpp"
 #undef STRIDE
 #define STRIDE 16
-#include <bench_stride.hpp>
+#include "bench_stride.hpp"
 #undef STRIDE
 #define STRIDE 32
-#include <bench_stride.hpp>
+#include "bench_stride.hpp"
 #undef STRIDE
 
 template <class Scalar>
diff --git a/benchmarks/bytes_and_flops/bench_double.cpp b/benchmarks/bytes_and_flops/bench_double.cpp
index f955c99666..2fda1ae3d4 100644
--- a/benchmarks/bytes_and_flops/bench_double.cpp
+++ b/benchmarks/bytes_and_flops/bench_double.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <bench.hpp>
+#include "bench.hpp"
 
 template void run_stride_unroll<double>(int N, int K, int R, int D, int U,
                                         int F, int T, int S, int B, int I);
diff --git a/benchmarks/bytes_and_flops/bench_float.cpp b/benchmarks/bytes_and_flops/bench_float.cpp
index 137ff67d40..3210116a9e 100644
--- a/benchmarks/bytes_and_flops/bench_float.cpp
+++ b/benchmarks/bytes_and_flops/bench_float.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <bench.hpp>
+#include "bench.hpp"
 
 template void run_stride_unroll<float>(int N, int K, int R, int D, int U, int F,
                                        int T, int S, int B, int I);
diff --git a/benchmarks/bytes_and_flops/bench_int32_t.cpp b/benchmarks/bytes_and_flops/bench_int32_t.cpp
index 29ccec0141..24a5dcd389 100644
--- a/benchmarks/bytes_and_flops/bench_int32_t.cpp
+++ b/benchmarks/bytes_and_flops/bench_int32_t.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <bench.hpp>
+#include "bench.hpp"
 
 template void run_stride_unroll<int32_t>(int N, int K, int R, int D, int U,
                                          int F, int T, int S, int B, int I);
diff --git a/benchmarks/bytes_and_flops/bench_int64_t.cpp b/benchmarks/bytes_and_flops/bench_int64_t.cpp
index c153d5eff3..0634700c31 100644
--- a/benchmarks/bytes_and_flops/bench_int64_t.cpp
+++ b/benchmarks/bytes_and_flops/bench_int64_t.cpp
@@ -14,7 +14,7 @@
 //
 //@HEADER
 
-#include <bench.hpp>
+#include "bench.hpp"
 
 template void run_stride_unroll<int64_t>(int N, int K, int R, int D, int U,
                                          int F, int T, int S, int B, int I);
diff --git a/benchmarks/bytes_and_flops/bench_stride.hpp b/benchmarks/bytes_and_flops/bench_stride.hpp
index b63d486fc9..80f017fbe8 100644
--- a/benchmarks/bytes_and_flops/bench_stride.hpp
+++ b/benchmarks/bytes_and_flops/bench_stride.hpp
@@ -15,28 +15,28 @@
 //@HEADER
 
 #define UNROLL 1
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 2
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 3
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 4
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 5
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 6
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 7
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 #define UNROLL 8
-#include <bench_unroll_stride.hpp>
+#include "bench_unroll_stride.hpp"
 #undef UNROLL
 
 template <class Scalar>
diff --git a/benchmarks/bytes_and_flops/bench_unroll_stride.hpp b/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
index 0f7a298c1b..78cfd48eff 100644
--- a/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
+++ b/benchmarks/bytes_and_flops/bench_unroll_stride.hpp
@@ -26,7 +26,7 @@ struct Run<Scalar, UNROLL, STRIDE> {
     Kokkos::deep_copy(C, Scalar(3.5));
 
     Kokkos::Timer timer;
-    for (int i = 0; i < I; ++i) {
+    for (int iter = 0; iter < I; ++iter) {
       Kokkos::parallel_for(
           "BenchmarkKernel",
           Kokkos::TeamPolicy<>(N, T).set_scratch_size(0, Kokkos::PerTeam(S)),
diff --git a/benchmarks/bytes_and_flops/main.cpp b/benchmarks/bytes_and_flops/main.cpp
index 20077757d1..fdfcc4ea64 100644
--- a/benchmarks/bytes_and_flops/main.cpp
+++ b/benchmarks/bytes_and_flops/main.cpp
@@ -16,7 +16,7 @@
 
 #include <Kokkos_Core.hpp>
 #include <Kokkos_Timer.hpp>
-#include <bench.hpp>
+#include "bench.hpp"
 #include <cstdlib>
 
 extern template void run_stride_unroll<float>(int, int, int, int, int, int, int,
@@ -86,7 +86,7 @@ int main(int argc, char* argv[]) {
     printf("D must be one of 1,2,4,8,16,32\n");
     return 0;
   }
-  if ((P < 1) && (P > 2)) {
+  if ((P < 1) || (P > 4)) {
     printf("P must be one of 1,2,3,4\n");
     return 0;
   }
diff --git a/benchmarks/gather/CMakeLists.txt b/benchmarks/gather/CMakeLists.txt
new file mode 100644
index 0000000000..24c7062772
--- /dev/null
+++ b/benchmarks/gather/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  gather
+  SOURCES main.cpp
+)
diff --git a/benchmarks/gather/gather.hpp b/benchmarks/gather/gather.hpp
index d83461702c..90b1101c1d 100644
--- a/benchmarks/gather/gather.hpp
+++ b/benchmarks/gather/gather.hpp
@@ -20,28 +20,28 @@ struct RunGather {
 };
 
 #define UNROLL 1
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 2
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 3
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 4
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 5
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 6
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 7
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 #define UNROLL 8
-#include <gather_unroll.hpp>
+#include "gather_unroll.hpp"
 #undef UNROLL
 
 template <class Scalar>
diff --git a/benchmarks/gather/gather_unroll.hpp b/benchmarks/gather/gather_unroll.hpp
index 5ee5742a3f..1aa73091bc 100644
--- a/benchmarks/gather/gather_unroll.hpp
+++ b/benchmarks/gather/gather_unroll.hpp
@@ -138,7 +138,7 @@ struct RunGather<Scalar, UNROLL> {
     printf(
         "SNKDRUF: %i %i %i %i %i %i %i Time: %lfs Bandwidth: %lfGiB/s GFlop/s: "
         "%lf GGather/s: %lf\n",
-        sizeof(Scalar) / 4, N, K, D, R, UNROLL, F, seconds,
+        static_cast<int>(sizeof(Scalar) / 4), N, K, D, R, UNROLL, F, seconds,
         1.0 * bytes / seconds / 1024 / 1024 / 1024, 1.e-9 * flops / seconds,
         1.e-9 * gather_ops / seconds);
   }
diff --git a/benchmarks/gather/main.cpp b/benchmarks/gather/main.cpp
index 7f4fc9ede6..07fca9fdc6 100644
--- a/benchmarks/gather/main.cpp
+++ b/benchmarks/gather/main.cpp
@@ -16,7 +16,7 @@
 
 #include <Kokkos_Core.hpp>
 #include <Kokkos_Timer.hpp>
-#include <gather.hpp>
+#include "gather.hpp"
 #include <cstdlib>
 
 int main(int argc, char* argv[]) {
diff --git a/benchmarks/gups/CMakeLists.txt b/benchmarks/gups/CMakeLists.txt
new file mode 100644
index 0000000000..8de5b73cc6
--- /dev/null
+++ b/benchmarks/gups/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  gups
+  SOURCES gups.cpp
+)
diff --git a/benchmarks/gups/gups-kokkos.cpp b/benchmarks/gups/gups-kokkos.cpp
deleted file mode 100644
index 97c339d09d..0000000000
--- a/benchmarks/gups/gups-kokkos.cpp
+++ /dev/null
@@ -1,175 +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>
-#include <cstdlib>
-#include <cmath>
-
-#include <sys/time.h>
-
-#define HLINE "-------------------------------------------------------------\n"
-
-#if defined(KOKKOS_ENABLE_CUDA)
-using GUPSHostArray   = Kokkos::View<int64_t*, Kokkos::CudaSpace>::HostMirror;
-using GUPSDeviceArray = Kokkos::View<int64_t*, Kokkos::CudaSpace>;
-#else
-using GUPSHostArray   = Kokkos::View<int64_t*, Kokkos::HostSpace>::HostMirror;
-using GUPSDeviceArray = Kokkos::View<int64_t*, Kokkos::HostSpace>;
-#endif
-
-using GUPSIndex = int;
-
-double now() {
-  struct timeval now;
-  gettimeofday(&now, nullptr);
-
-  return (double)now.tv_sec + ((double)now.tv_usec * 1.0e-6);
-}
-
-void randomize_indices(GUPSHostArray& indices, GUPSDeviceArray& dev_indices,
-                       const int64_t dataCount) {
-  for (GUPSIndex i = 0; i < indices.extent(0); ++i) {
-    indices[i] = lrand48() % dataCount;
-  }
-
-  Kokkos::deep_copy(dev_indices, indices);
-}
-
-void run_gups(GUPSDeviceArray& indices, GUPSDeviceArray& data,
-              const int64_t datum, const bool performAtomics) {
-  if (performAtomics) {
-    Kokkos::parallel_for(
-        "bench-gups-atomic", indices.extent(0),
-        KOKKOS_LAMBDA(const GUPSIndex i) {
-          Kokkos::atomic_fetch_xor(&data[indices[i]], datum);
-        });
-  } else {
-    Kokkos::parallel_for(
-        "bench-gups-non-atomic", indices.extent(0),
-        KOKKOS_LAMBDA(const GUPSIndex i) { data[indices[i]] ^= datum; });
-  }
-
-  Kokkos::fence();
-}
-
-int run_benchmark(const GUPSIndex indicesCount, const GUPSIndex dataCount,
-                  const int repeats, const bool useAtomics) {
-  printf("Reports fastest timing per kernel\n");
-  printf("Creating Views...\n");
-
-  printf("Memory Sizes:\n");
-  printf("- Elements:      %15" PRIu64 " (%12.4f MB)\n",
-         static_cast<uint64_t>(dataCount),
-         1.0e-6 * ((double)dataCount * (double)sizeof(int64_t)));
-  printf("- Indices:       %15" PRIu64 " (%12.4f MB)\n",
-         static_cast<uint64_t>(indicesCount),
-         1.0e-6 * ((double)indicesCount * (double)sizeof(int64_t)));
-  printf(" - Atomics:      %15s\n", (useAtomics ? "Yes" : "No"));
-  printf("Benchmark kernels will be performed for %d iterations.\n", repeats);
-
-  printf(HLINE);
-
-  GUPSDeviceArray dev_indices("indices", indicesCount);
-  GUPSDeviceArray dev_data("data", dataCount);
-  int64_t datum = -1;
-
-  GUPSHostArray indices = Kokkos::create_mirror_view(dev_indices);
-  GUPSHostArray data    = Kokkos::create_mirror_view(dev_data);
-
-  double gupsTime = 0.0;
-
-  printf("Initializing Views...\n");
-
-#if defined(KOKKOS_HAVE_OPENMP)
-  Kokkos::parallel_for(
-      "init-data", Kokkos::RangePolicy<Kokkos::OpenMP>(0, dataCount),
-#else
-  Kokkos::parallel_for(
-      "init-data", Kokkos::RangePolicy<Kokkos::Serial>(0, dataCount),
-#endif
-      KOKKOS_LAMBDA(const int i) { data[i] = 10101010101; });
-
-#if defined(KOKKOS_HAVE_OPENMP)
-  Kokkos::parallel_for(
-      "init-indices", Kokkos::RangePolicy<Kokkos::OpenMP>(0, indicesCount),
-#else
-  Kokkos::parallel_for(
-      "init-indices", Kokkos::RangePolicy<Kokkos::Serial>(0, indicesCount),
-#endif
-      KOKKOS_LAMBDA(const int i) { indices[i] = 0; });
-
-  Kokkos::deep_copy(dev_data, data);
-  Kokkos::deep_copy(dev_indices, indices);
-  double start;
-
-  printf("Starting benchmarking...\n");
-
-  for (GUPSIndex k = 0; k < repeats; ++k) {
-    randomize_indices(indices, dev_indices, data.extent(0));
-
-    start = now();
-    run_gups(dev_indices, dev_data, datum, useAtomics);
-    gupsTime += now() - start;
-  }
-
-  Kokkos::deep_copy(indices, dev_indices);
-  Kokkos::deep_copy(data, dev_data);
-
-  printf(HLINE);
-  printf(
-      "GUP/s Random:      %18.6f\n",
-      (1.0e-9 * ((double)repeats) * (double)dev_indices.extent(0)) / gupsTime);
-  printf(HLINE);
-
-  return 0;
-}
-
-int main(int argc, char* argv[]) {
-  printf(HLINE);
-  printf("Kokkos GUPS Benchmark\n");
-  printf(HLINE);
-
-  srand48(1010101);
-
-  Kokkos::initialize(argc, argv);
-
-  int64_t indices = 8192;
-  int64_t data    = 33554432;
-  int64_t repeats = 10;
-  bool useAtomics = false;
-
-  for (int i = 1; i < argc; ++i) {
-    if (strcmp(argv[i], "--indices") == 0) {
-      indices = std::atoll(argv[i + 1]);
-      ++i;
-    } else if (strcmp(argv[i], "--data") == 0) {
-      data = std::atoll(argv[i + 1]);
-      ++i;
-    } else if (strcmp(argv[i], "--repeats") == 0) {
-      repeats = std::atoll(argv[i + 1]);
-      ++i;
-    } else if (strcmp(argv[i], "--atomics") == 0) {
-      useAtomics = true;
-    }
-  }
-
-  const int rc = run_benchmark(indices, data, repeats, useAtomics);
-
-  Kokkos::finalize();
-
-  return rc;
-}
diff --git a/benchmarks/gups/gups.cpp b/benchmarks/gups/gups.cpp
new file mode 100644
index 0000000000..369052321d
--- /dev/null
+++ b/benchmarks/gups/gups.cpp
@@ -0,0 +1,195 @@
+//@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
+
+/*! \brief file gups.cpp
+
+    An implementation of something like HPCC RandomAccess.
+*/
+
+#include "Kokkos_Core.hpp"
+#include <cstdio>
+#include <cstdlib>
+#include <cmath>
+#include <chrono>
+#include <numeric>
+#include <algorithm>
+#include <random>
+
+#define HLINE "-------------------------------------------------------------\n"
+
+using Index = int;
+using Datum = int64_t;
+
+using IndexView = Kokkos::View<Index*>;
+using DataView  = Kokkos::View<Datum*>;
+
+using Clock    = std::chrono::steady_clock;
+using Duration = std::chrono::duration<double>;
+
+using RandomDevice = std::random_device;
+using RNG          = std::mt19937;
+
+IndexView randomized_indices(const Index indicesCount, const Index dataCount,
+                             RNG& rng) {
+  // generate random indices 0..dataCount
+  std::uniform_int_distribution<Index> uid(0, dataCount);
+  std::vector<Index> indices(indicesCount);
+  std::generate(indices.begin(), indices.end(), [&]() { return uid(rng); });
+
+  // Copy to the default space and return
+  Kokkos::View<Index*, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>
+      unmanaged_indices(indices.data(), indices.size());
+  IndexView dev_indices("dev_indices", indicesCount);
+  Kokkos::deep_copy(dev_indices, unmanaged_indices);
+  return dev_indices;
+}
+
+IndexView permuted_indices(const Index indicesCount, const Index dataCount,
+                           RNG& rng) {
+  // create a permutation array of offsets into the data
+  std::vector<Index> perm(dataCount);
+  std::iota(perm.begin(), perm.end(), 0);
+  std::shuffle(perm.begin(), perm.end(), rng);
+
+  // indices is repeated copies of the permutation array
+  // (or the first entries of the permutation array if there
+  // are fewer indices than data elements)
+  IndexView dev_indices("dev_indices", indicesCount);
+  auto indices = Kokkos::create_mirror_view(dev_indices);
+  for (Index i = 0; i < Index(indices.extent(0)); ++i) {
+    indices(i) = perm[i % perm.size()];
+  }
+
+  // Copy to the default space and return
+
+  Kokkos::deep_copy(dev_indices, indices);
+  return dev_indices;
+}
+
+void run_gups(IndexView& indices, DataView& data, const Datum datum,
+              const bool performAtomics) {
+  if (performAtomics) {
+    Kokkos::parallel_for(
+        "bench-gups-atomic", indices.extent(0), KOKKOS_LAMBDA(const Index i) {
+          Kokkos::atomic_fetch_xor(&data[indices[i]], datum);
+        });
+  } else {
+    Kokkos::parallel_for(
+        "bench-gups-non-atomic", indices.extent(0),
+        KOKKOS_LAMBDA(const Index i) { data[indices[i]] ^= datum; });
+  }
+
+  Kokkos::fence();
+}
+
+enum class AccessPattern { random, permutation };
+
+int run_benchmark(const Index indicesCount, const Index dataCount,
+                  const int repeats, const bool useAtomics,
+                  const AccessPattern pattern) {
+  constexpr auto arbitrary_seed = 20230913;
+  RNG rng(arbitrary_seed);
+
+  printf("Reports fastest timing per kernel\n");
+  printf("Creating Views...\n");
+
+  printf("Memory Sizes:\n");
+  printf("- Elements:      %15" PRIu64 " (%12.4f MB)\n",
+         static_cast<uint64_t>(dataCount),
+         1.0e-6 * ((double)dataCount * (double)sizeof(Datum)));
+  printf("- Indices:       %15" PRIu64 " (%12.4f MB)\n",
+         static_cast<uint64_t>(indicesCount),
+         1.0e-6 * ((double)indicesCount * (double)sizeof(Index)));
+  printf(" - Atomics:      %15s\n", (useAtomics ? "Yes" : "No"));
+  printf("Benchmark kernels will be performed for %d iterations.\n", repeats);
+
+  printf(HLINE);
+
+  printf("Initializing Data...\n");
+  DataView data("data", dataCount);
+  Kokkos::parallel_for(
+      "init-data",
+      Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>(0, dataCount),
+      KOKKOS_LAMBDA(const int i) { data[i] = 10101010101; });
+
+  printf("Starting benchmarking...\n");
+  double gupsTime       = 0.0;
+  constexpr Datum datum = -1;
+  for (Index k = 0; k < repeats; ++k) {
+    IndexView indices;
+    switch (pattern) {
+      case AccessPattern::random: {
+        indices = randomized_indices(indicesCount, dataCount, rng);
+        break;
+      }
+      case AccessPattern::permutation: {
+        indices = permuted_indices(indicesCount, dataCount, rng);
+        break;
+      }
+      default: {
+        throw std::runtime_error("unexpected mode");
+      }
+    }
+
+    auto start = Clock::now();
+    run_gups(indices, data, datum, useAtomics);
+    gupsTime += Duration(Clock::now() - start).count();
+  }
+
+  printf(HLINE);
+  printf("GUP/s Random:      %18.6f\n",
+         (1.0e-9 * ((double)repeats) * (double)indicesCount) / gupsTime);
+  printf(HLINE);
+
+  return 0;
+}
+
+int main(int argc, char* argv[]) {
+  printf(HLINE);
+  printf("Kokkos GUPS Benchmark\n");
+  printf(HLINE);
+
+  Kokkos::initialize(argc, argv);
+
+  int64_t indices       = 8192;
+  int64_t data          = 33554432;
+  int64_t repeats       = 10;
+  bool useAtomics       = false;
+  AccessPattern pattern = AccessPattern::random;
+
+  for (int i = 1; i < argc; ++i) {
+    if (strcmp(argv[i], "--indices") == 0) {
+      indices = std::atoll(argv[i + 1]);
+      ++i;
+    } else if (strcmp(argv[i], "--data") == 0) {
+      data = std::atoll(argv[i + 1]);
+      ++i;
+    } else if (strcmp(argv[i], "--repeats") == 0) {
+      repeats = std::atoll(argv[i + 1]);
+      ++i;
+    } else if (strcmp(argv[i], "--atomics") == 0) {
+      useAtomics = true;
+    } else if (strcmp(argv[i], "--pattern-permutation") == 0) {
+      pattern = AccessPattern::permutation;
+    }
+  }
+
+  const int rc = run_benchmark(indices, data, repeats, useAtomics, pattern);
+
+  Kokkos::finalize();
+
+  return rc;
+}
diff --git a/benchmarks/launch_latency/CMakeLists.txt b/benchmarks/launch_latency/CMakeLists.txt
new file mode 100644
index 0000000000..bb14da749d
--- /dev/null
+++ b/benchmarks/launch_latency/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  launch_latency
+  SOURCES launch_latency.cpp
+)
diff --git a/benchmarks/launch_latency/launch_latency.cpp b/benchmarks/launch_latency/launch_latency.cpp
new file mode 100644
index 0000000000..73b176ab8d
--- /dev/null
+++ b/benchmarks/launch_latency/launch_latency.cpp
@@ -0,0 +1,283 @@
+//@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
+
+/*! \file launch_latency.cpp
+
+    Tests of parallel_for and parallel_reduce latency for different
+   circumstances.
+
+    Three launch kinds are tested: parallel_for, parallel_reduce into scalar,
+   and parallel_reduce into view
+
+   N controls how large the parallel loops is
+   V controls how large the functor is
+   M controls across how many launches the latency is averaged
+   K controls how larege the nested loop is (no larger than V)
+
+    For each launch kind,
+    1. Avg functor dispatch latency: (time to do M launches) / M
+    2. Avg functor completion throughput: (M launches + sync) / M
+    3. Avg functor completion latency: (M (launch + sync)) / M
+*/
+
+#include <Kokkos_Core.hpp>
+
+template <int V>
+struct TestFunctor {
+  double values[V];
+  Kokkos::View<double*> a;
+  int K;
+  TestFunctor(Kokkos::View<double*> a_, int K_) : a(a_), K(K_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i) const {
+    for (int j = 0; j < K; j++) a(i) += 1.0 * i * values[j];
+  }
+};
+
+template <int V>
+struct TestRFunctor {
+  double values[V];
+  Kokkos::View<double*> a;
+  int K;
+  TestRFunctor(Kokkos::View<double*> a_, int K_) : a(a_), K(K_) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const int i, double& lsum) const {
+    for (int j = 0; j < K; j++) a(i) += 1.0 * i * values[j];
+    lsum += a(i);
+  }
+};
+
+struct Opts {
+  bool par_for         = true;
+  bool par_reduce      = true;
+  bool par_reduce_view = true;
+};
+
+template <int V>
+void run(int N, int M, int K, const Opts& opts) {
+  std::string l_no_fence, l_fence, l_red_no_fence, l_red_fence,
+      l_red_view_no_fence, l_red_view_fence;
+  {
+    std::ostringstream ostream;
+    ostream << "RunNoFence_" << N << "_" << K << std::endl;
+    l_no_fence = ostream.str();
+  }
+  {
+    std::ostringstream ostream;
+    ostream << "RunFence_" << N << "_" << K << std::endl;
+    l_fence = ostream.str();
+  }
+  {
+    std::ostringstream ostream;
+    ostream << "RunReduceNoFence_" << N << "_" << K << std::endl;
+    l_red_no_fence = ostream.str();
+  }
+  {
+    std::ostringstream ostream;
+    ostream << "RunReduceFence_" << N << "_" << K << std::endl;
+    l_red_fence = ostream.str();
+  }
+  {
+    std::ostringstream ostream;
+    ostream << "RunReduceViewNoFence_" << N << "_" << K << std::endl;
+    l_red_view_no_fence = ostream.str();
+  }
+  {
+    std::ostringstream ostream;
+    ostream << "RunReduceViewFence_" << N << "_" << K << std::endl;
+    l_red_view_fence = ostream.str();
+  }
+
+  double result;
+  Kokkos::View<double*> a("A", N);
+  Kokkos::View<double> v_result("result");
+  TestFunctor<V> f(a, K);
+  TestRFunctor<V> rf(a, K);
+  Kokkos::Timer timer;
+
+  // initialize to an obviously wrong value
+  double time_no_fence        = -1;  // launch loop
+  double time_no_fence_fenced = -1;  // launch loop then fence
+  double time_fence           = -1;  // launch&fence loop
+
+  double time_red_no_fence        = -1;
+  double time_red_no_fence_fenced = -1;
+  double time_red_fence           = -1;
+
+  double time_red_view_no_fence        = -1;
+  double time_red_view_no_fence_fenced = -1;
+  double time_red_view_fence           = -1;
+
+  if (opts.par_for) {
+    // warmup
+    for (int i = 0; i < 4; ++i) {
+      Kokkos::parallel_for(l_no_fence, N, f);
+    }
+    Kokkos::fence();
+
+    timer.reset();
+    for (int i = 0; i < M; i++) {
+      Kokkos::parallel_for(l_no_fence, N, f);
+    }
+    time_no_fence = timer.seconds();
+    Kokkos::fence();
+    time_no_fence_fenced = timer.seconds();
+
+    timer.reset();
+    for (int i = 0; i < M; i++) {
+      Kokkos::parallel_for(l_fence, N, f);
+      Kokkos::fence();
+    }
+    time_fence = timer.seconds();
+  }
+
+  if (opts.par_reduce) {
+    // warmup
+    for (int i = 0; i < 4; ++i) {
+      Kokkos::parallel_reduce(l_red_no_fence, N, rf, result);
+    }
+    Kokkos::fence();
+
+    timer.reset();
+    for (int i = 0; i < M; i++) {
+      Kokkos::parallel_reduce(l_red_no_fence, N, rf, result);
+    }
+    time_red_no_fence = timer.seconds();
+    Kokkos::fence();
+    time_red_no_fence_fenced = timer.seconds();
+
+    timer.reset();
+    for (int i = 0; i < M; i++) {
+      Kokkos::parallel_reduce(l_red_fence, N, rf, result);
+      Kokkos::fence();
+    }
+    time_red_fence = timer.seconds();
+    Kokkos::fence();
+  }
+
+  if (opts.par_reduce_view) {
+    // warmup
+    for (int i = 0; i < 4; ++i) {
+      Kokkos::parallel_reduce(l_red_view_no_fence, N, rf, v_result);
+    }
+    Kokkos::fence();
+
+    timer.reset();
+    for (int i = 0; i < M; i++) {
+      Kokkos::parallel_reduce(l_red_view_no_fence, N, rf, v_result);
+    }
+    time_red_view_no_fence = timer.seconds();
+    Kokkos::fence();
+    time_red_view_no_fence_fenced = timer.seconds();
+
+    timer.reset();
+    for (int i = 0; i < M; i++) {
+      Kokkos::parallel_reduce(l_red_view_fence, N, rf, v_result);
+      Kokkos::fence();
+    }
+    time_red_view_fence = timer.seconds();
+    Kokkos::fence();
+    timer.reset();
+  }
+
+  const double x = 1.e6 / M;
+  printf("%i %i %i %i", N, V, K, M);
+  if (opts.par_for) {
+    printf(" parallel_for: %lf %lf ( %lf )", x * time_no_fence, x * time_fence,
+           x * time_no_fence_fenced);
+  }
+  if (opts.par_reduce) {
+    printf(" parallel_reduce: %lf %lf ( %lf )", x * time_red_no_fence,
+           x * time_red_fence, x * time_red_no_fence_fenced);
+  }
+  if (opts.par_reduce_view) {
+    printf(" parallel_reduce(view): %lf %lf ( %lf )",
+           x * time_red_view_no_fence, x * time_red_view_fence,
+           x * time_red_view_no_fence_fenced);
+  }
+  printf("\n");
+}
+int main(int argc, char* argv[]) {
+  Kokkos::initialize(argc, argv);
+  {
+    int N = 10000;
+    int M = 20;
+    int K = 1;
+
+    Opts opts;
+
+    printf("==========================\n");
+    printf("Kokkos Launch Latency Test\n");
+    printf("==========================\n");
+    printf("\n");
+    printf("Usage: %s ARGUMENTS [OPTIONS...]\n\n", argv[0]);
+    printf("Arguments: N M K\n");
+    printf("  N: loop length\n");
+    printf("  M: how many kernels to dispatch\n");
+    printf(
+        "  K: nested loop length (capped by size of functor member array\n\n");
+    printf("Options:\n");
+    printf("  --no-parallel-for:         skip parallel_for benchmark\n");
+    printf("  --no-parallel-reduce:      skip parallel_reduce benchmark\n");
+    printf(
+        "  --no-parallel-reduce-view: skip parallel_reduce into view "
+        "benchmark\n");
+    printf("\n\n");
+    printf("  Output V is the size of the functor member array\n");
+    printf("\n\n");
+
+    for (int i = 1; i < argc; ++i) {
+      const std::string_view arg(argv[i]);
+
+      // anything that doesn't start with --
+      if (arg.size() < 2 ||
+          (arg.size() >= 2 && arg[0] != '-' && arg[1] != '-')) {
+        if (i == 1)
+          N = atoi(arg.data());
+        else if (i == 2)
+          M = atoi(arg.data());
+        else if (i == 3)
+          K = atoi(arg.data());
+        else {
+          throw std::runtime_error("unexpected argument!");
+        }
+      } else if (arg == "--no-parallel-for") {
+        opts.par_for = false;
+      } else if (arg == "--no-parallel-reduce") {
+        opts.par_reduce = false;
+      } else if (arg == "--no-parallel-reduce-view") {
+        opts.par_reduce_view = false;
+      } else {
+        std::stringstream ss;
+        ss << "unexpected argument \"" << arg << "\" at position " << i;
+        throw std::runtime_error(ss.str());
+      }
+    }
+
+    printf("N V K M time_no_fence time_fence (time_no_fence_fenced)\n");
+
+    /* A backend may have different launch strategies for functors of different
+     * sizes: test a variety of functor sizes.*/
+    run<1>(N, M, K <= 1 ? K : 1, opts);
+    run<16>(N, M, K <= 16 ? K : 16, opts);
+    run<200>(N, M, K <= 200 ? K : 200, opts);
+    run<3000>(N, M, K <= 3000 ? K : 3000, opts);
+    run<30000>(N, M, K <= 30000 ? K : 30000, opts);
+  }
+  Kokkos::finalize();
+}
diff --git a/benchmarks/policy_performance/CMakeLists.txt b/benchmarks/policy_performance/CMakeLists.txt
new file mode 100644
index 0000000000..929b9c9702
--- /dev/null
+++ b/benchmarks/policy_performance/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  policy_performance
+  SOURCES main.cpp
+)
diff --git a/benchmarks/policy_performance/main.cpp b/benchmarks/policy_performance/main.cpp
index 28cfde552a..0983a3d535 100644
--- a/benchmarks/policy_performance/main.cpp
+++ b/benchmarks/policy_performance/main.cpp
@@ -106,8 +106,9 @@ int main(int argc, char* argv[]) {
 
   Kokkos::parallel_reduce(
       "parallel_reduce warmup", Kokkos::TeamPolicy<>(10, 1),
-      KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type team,
-                    double& lval) { lval += 1; },
+      KOKKOS_LAMBDA(const Kokkos::TeamPolicy<>::member_type&, double& lval) {
+        lval += 1;
+      },
       result);
 
   using view_type_1d = Kokkos::View<double*, Kokkos::LayoutRight>;
diff --git a/benchmarks/policy_performance/policy_perf_test.hpp b/benchmarks/policy_performance/policy_perf_test.hpp
index cc2cc40257..0e23d221f6 100644
--- a/benchmarks/policy_performance/policy_perf_test.hpp
+++ b/benchmarks/policy_performance/policy_perf_test.hpp
@@ -21,13 +21,13 @@ struct ParallelScanFunctor {
   using value_type = double;
   ViewType v;
 
-  ParallelScanFunctor(const ViewType& v_) : v(v_) {}
+  explicit ParallelScanFunctor(const ViewType& v_) : v(v_) {}
 
   KOKKOS_INLINE_FUNCTION
-  void operator()(const int idx, value_type& val, const bool& final) const {
+  void operator()(const int idx, value_type& val, const bool& is_final) const {
     // inclusive scan
     val += v(idx);
-    if (final) {
+    if (is_final) {
       v(idx) = val;
     }
   }
@@ -109,7 +109,7 @@ void test_policy(int team_range, int thread_range, int vector_range,
                       vector_result = 0.0;
                       Kokkos::parallel_reduce(
                           Kokkos::ThreadVectorRange(team, vector_range),
-                          [&](const int vi, double& vval) { vval += 1; },
+                          [&](const int, double& vval) { vval += 1; },
                           vector_result);
                     }
                     v2(idx, t) = vector_result;
@@ -128,7 +128,7 @@ void test_policy(int team_range, int thread_range, int vector_range,
               team_result = 0.0;
               Kokkos::parallel_reduce(
                   Kokkos::TeamThreadRange(team, thread_range),
-                  [&](const int t, double& lval) { lval += 1; }, team_result);
+                  [&](const int, double& lval) { lval += 1; }, team_result);
             }
             v1(idx) = team_result;
             // prevent compiler optimizing loop away
@@ -170,13 +170,13 @@ void test_policy(int team_range, int thread_range, int vector_range,
             for (int tr = 0; tr < thread_repeat; ++tr) {
               Kokkos::parallel_reduce(
                   Kokkos::TeamThreadRange(team, thread_range),
-                  [&](const int t, double& lval) {
+                  [&](const int, double& lval) {
                     double vector_result = 0.0;
                     for (int vr = 0; vr < inner_repeat; ++vr) {
                       vector_result = 0.0;
                       Kokkos::parallel_reduce(
                           Kokkos::ThreadVectorRange(team, vector_range),
-                          [&](const int vi, double& vval) { vval += 1; },
+                          [&](const int, double& vval) { vval += 1; },
                           vector_result);
                       lval += vector_result;
                     }
diff --git a/benchmarks/stream/CMakeLists.txt b/benchmarks/stream/CMakeLists.txt
new file mode 100644
index 0000000000..0dded6e3a5
--- /dev/null
+++ b/benchmarks/stream/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  stream
+  SOURCES stream-kokkos.cpp
+)
diff --git a/benchmarks/view_copy_constructor/CMakeLists.txt b/benchmarks/view_copy_constructor/CMakeLists.txt
new file mode 100644
index 0000000000..50a331b2b3
--- /dev/null
+++ b/benchmarks/view_copy_constructor/CMakeLists.txt
@@ -0,0 +1,4 @@
+KOKKOS_ADD_EXECUTABLE(
+  view_copy_constructor
+  SOURCES view_copy_constructor.cpp
+)
diff --git a/benchmarks/gups/Makefile b/benchmarks/view_copy_constructor/Makefile
similarity index 73%
rename from benchmarks/gups/Makefile
rename to benchmarks/view_copy_constructor/Makefile
index 2a90621d8c..70c6d517e0 100644
--- a/benchmarks/gups/Makefile
+++ b/benchmarks/view_copy_constructor/Makefile
@@ -1,6 +1,5 @@
-KOKKOS_DEVICES=Cuda
-KOKKOS_CUDA_OPTIONS=enable_lambda
-KOKKOS_ARCH = "SNB,Volta70"
+KOKKOS_DEVICES=Serial
+KOKKOS_ARCH = ""
 
 
 MAKEFILE_PATH := $(subst Makefile,,$(abspath $(lastword $(MAKEFILE_LIST))))
@@ -17,20 +16,16 @@ vpath %.cpp $(sort $(dir $(SRC)))
 default: build
 	echo "Start Build"
 
-ifneq (,$(findstring Cuda,$(KOKKOS_DEVICES)))
-CXX = ${KOKKOS_PATH}/bin/nvcc_wrapper
-EXE = gups.cuda
-else
-CXX = g++
-EXE = gups.exe
-endif
+CXX = clang++
+EXE = view_copy_constructor.exe
 
-CXXFLAGS ?= -O3 -g
+CXXFLAGS ?= -Ofast
 override CXXFLAGS += -I$(MAKEFILE_PATH)
 
 DEPFLAGS = -M
 LINK = ${CXX}
-LINKFLAGS =
+LINKFLAGS = -Ofast
+KOKKOS_CXX_STANDARD=c++20
 
 OBJ = $(notdir $(SRC:.cpp=.o))
 LIB =
@@ -43,7 +38,7 @@ $(EXE): $(OBJ) $(KOKKOS_LINK_DEPENDS)
 	$(LINK) $(KOKKOS_LDFLAGS) $(LINKFLAGS) $(EXTRA_PATH) $(OBJ) $(KOKKOS_LIBS) $(LIB) -o $(EXE)
 
 clean: kokkos-clean
-	rm -f *.o gups.cuda gups.exe
+	rm -f *.o view_copy_constructor.cuda view_copy_constructor.exe
 
 # Compilation rules
 
diff --git a/benchmarks/view_copy_constructor/view_copy_constructor.cpp b/benchmarks/view_copy_constructor/view_copy_constructor.cpp
new file mode 100644
index 0000000000..63c49f09c0
--- /dev/null
+++ b/benchmarks/view_copy_constructor/view_copy_constructor.cpp
@@ -0,0 +1,310 @@
+//@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
+
+// The function "test_view_collection" exposes the copy constructor
+// and destructor overheads in Kokkos View objects
+// Please see the lines marked by "NOTE".
+
+#include <limits>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <sys/time.h>
+#include <Kokkos_Core.hpp>
+#include <iostream>
+
+// NVIEWS is the number of Kokkos View objects in our ViewCollection object
+// We have chosen a large value of 40 to make it easier to see performance
+// differences when using the likelihood attribute
+#define NVIEWS 40
+
+class ViewCollection {
+ public:
+  Kokkos::View<double*> v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
+      v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40;
+  double m_expected_sum;
+  double m_side_effect;
+  int m_N;
+
+  ViewCollection(int N)
+      : v1("v1", N),
+        v2("v2", N),
+        v3("v3", N),
+        v4("v4", N),
+        v5("v5", N),
+        v6("v6", N),
+        v7("v7", N),
+        v8("v8", N),
+        v9("v9", N),
+        v10("v10", N),
+        v11("v11", N),
+        v12("v12", N),
+        v13("v13", N),
+        v14("v14", N),
+        v15("v15", N),
+        v16("v16", N),
+        v17("v17", N),
+        v18("v18", N),
+        v19("v19", N),
+        v20("v20", N),
+        v21("v21", N),
+        v22("v22", N),
+        v23("v23", N),
+        v24("v24", N),
+        v25("v25", N),
+        v26("v26", N),
+        v27("v27", N),
+        v28("v28", N),
+        v29("v29", N),
+        v30("v30", N),
+        v31("v31", N),
+        v32("v32", N),
+        v33("v33", N),
+        v34("v34", N),
+        v35("v35", N),
+        v36("v36", N),
+        v37("v37", N),
+        v38("v38", N),
+        v39("v39", N),
+        v40("v40", N),
+        m_expected_sum(N * NVIEWS),
+        m_side_effect(0.0),
+        m_N(N) {
+    for (int i = 0; i < N; ++i) {
+      v1(i)  = 1;
+      v2(i)  = 1;
+      v3(i)  = 1;
+      v4(i)  = 1;
+      v5(i)  = 1;
+      v6(i)  = 1;
+      v7(i)  = 1;
+      v8(i)  = 1;
+      v9(i)  = 1;
+      v10(i) = 1;
+      v11(i) = 1;
+      v12(i) = 1;
+      v13(i) = 1;
+      v14(i) = 1;
+      v15(i) = 1;
+      v16(i) = 1;
+      v17(i) = 1;
+      v18(i) = 1;
+      v19(i) = 1;
+      v20(i) = 1;
+      v21(i) = 1;
+      v22(i) = 1;
+      v23(i) = 1;
+      v24(i) = 1;
+      v25(i) = 1;
+      v26(i) = 1;
+      v27(i) = 1;
+      v28(i) = 1;
+      v29(i) = 1;
+      v30(i) = 1;
+      v31(i) = 1;
+      v32(i) = 1;
+      v33(i) = 1;
+      v34(i) = 1;
+      v35(i) = 1;
+      v36(i) = 1;
+      v37(i) = 1;
+      v38(i) = 1;
+      v39(i) = 1;
+      v40(i) = 1;
+    }
+  }
+
+// The ADD_COPY_CONSTRUCTOR macro is helpful to compare time in the copy
+// constructor between compilers. We have found that the GNU compiler
+// is sometimes able to inline the default copy constructor.
+#ifdef ADD_COPY_CONSTRUCTOR
+  __attribute__((noinline)) ViewCollection(const ViewCollection& other)
+      : v1(other.v1),
+        v2(other.v2),
+        v3(other.v3),
+        v4(other.v4),
+        v5(other.v5),
+        v6(other.v6),
+        v7(other.v7),
+        v8(other.v8),
+        v9(other.v9),
+        v10(other.v10),
+        v11(other.v11),
+        v12(other.v12),
+        v13(other.v13),
+        v14(other.v14),
+        v15(other.v15),
+        v16(other.v16),
+        v17(other.v17),
+        v18(other.v18),
+        v19(other.v19),
+        v20(other.v20),
+        v21(other.v21),
+        v22(other.v22),
+        v23(other.v23),
+        v24(other.v24),
+        v25(other.v25),
+        v26(other.v26),
+        v27(other.v27),
+        v28(other.v28),
+        v29(other.v29),
+        v30(other.v30),
+        v31(other.v31),
+        v32(other.v32),
+        v33(other.v33),
+        v34(other.v34),
+        v35(other.v35),
+        v36(other.v36),
+        v37(other.v37),
+        v38(other.v38),
+        v39(other.v39),
+        v40(other.v40),
+        m_expected_sum(other.m_expected_sum),
+        m_side_effect(other.m_side_effect),
+        m_N(other.m_N) {}
+#endif
+
+  KOKKOS_INLINE_FUNCTION
+  double sum_views(int ii, bool execute_kernel) {
+    double result = 0.0;
+    if (execute_kernel) {
+      // This code is only executed when using the command line option -k
+      // The computation references all Kokkos views. This may help our
+      // effort to stop compilers from optimizing away the Kokkos views
+      for (int i = 0; i < m_N; ++i) {
+        result += v1(i) + v2(i) + v3(i) + v4(i) + v5(i) + v6(i) + v7(i) +
+                  v8(i) + v9(i) + v10(i) + v11(i) + v12(i) + v13(i) + v14(i) +
+                  v15(i) + v16(i) + v17(i) + v18(i) + v19(i) + v20(i) + v21(i) +
+                  v22(i) + v23(i) + v24(i) + v25(i) + v26(i) + v27(i) + v28(i) +
+                  v29(i) + v30(i) + v31(i) + v32(i) + v33(i) + v34(i) + v35(i) +
+                  v36(i) + v37(i) + v38(i) + v39(i) + v40(i);
+      }
+    } else {
+      result = m_expected_sum;
+    }
+    // This statement introduces a side effect that may help our effort to
+    // stop compilers from optimizing away the temporary ViewCollection object
+    m_side_effect = result * (ii + 1);
+    return result;
+  }
+};
+
+void test_view_collection_kk(int N, int num_iter, bool execute_kernel) {
+  ViewCollection view_collection(N);
+
+  Kokkos::Timer view_collection_timer;
+  double max_value = 0.0;
+  // Max Reduction boilerplate code taken from slide 53 of
+  // kokkos-tutorials/LectureSeries/KokkosTutorial_02_ViewsAndSpaces.pdf
+  Kokkos::parallel_reduce(
+      "collection-reduction", num_iter,
+      KOKKOS_LAMBDA(int i, double& valueToUpdate) {
+        // NOTE: The following lines expose the Kokkos View overheads
+        ViewCollection tmp_view_collection = view_collection;
+        double my_value = tmp_view_collection.sum_views(i, execute_kernel);
+        if (my_value > valueToUpdate) valueToUpdate = my_value;
+      },
+      Kokkos::Max<double>(max_value));
+  double view_collection_time = view_collection_timer.seconds();
+
+  bool success = std::fabs(max_value - N * NVIEWS) < 1.E-6;
+  std::cout << "View Time = " << view_collection_time << " seconds"
+            << std::endl;
+  if (success) {
+    std::cout << "Kokkos run:" << std::endl;
+    std::cout << "SUCCESS" << std::endl;
+  } else {
+    std::cout << "FAILURE" << std::endl;
+  }
+}
+
+void test_view_collection_serial(int N, int num_iter, bool execute_kernel) {
+  ViewCollection view_collection(N);
+
+  Kokkos::Timer view_collection_timer;
+  double max_value = 0.0;
+  // Max Reduction boilerplate code taken from slide 53 of
+  // kokkos-tutorials/LectureSeries/KokkosTutorial_02_ViewsAndSpaces.pdf
+  for (int i = 0; i < num_iter; ++i) {
+    // NOTE: The following lines expose the Kokkos View overheads
+    ViewCollection tmp_view_collection = view_collection;
+    double my_value = tmp_view_collection.sum_views(i, execute_kernel);
+    if (my_value > max_value) max_value = my_value;
+  }
+  double view_collection_time = view_collection_timer.seconds();
+
+  bool success = std::fabs(max_value - N * NVIEWS) < 1.E-6;
+  std::cout << "View Time 2 = " << view_collection_time << " seconds"
+            << std::endl;
+  if (success) {
+    std::cout << "Serial run:" << std::endl;
+    std::cout << "SUCCESS" << std::endl;
+  } else {
+    std::cout << "FAILURE" << std::endl;
+  }
+}
+
+int main(int argc, char* argv[]) {
+  // The benchmark is only testing reference counting for views on host.
+#if defined(KOKKOS_ENABLE_OPENMP) || defined(KOKKOS_ENABLE_SERIAL) || \
+    defined(KOKKOS_ENABLE_THREADS) || defined(KOKKOS_ENABLE_HPX)
+  int N               = 1;
+  int num_iter        = 1 << 27;
+  bool execute_kernel = false;
+
+  for (int i = 0; i < argc; i++) {
+    if ((strcmp(argv[i], "-N") == 0)) {
+      N = atoi(argv[++i]);
+      if (N < 1) {
+        std::cout << "Array extent must be >= 1" << std::endl;
+        exit(1);
+      }
+    } else if (strcmp(argv[i], "-i") == 0) {
+      num_iter = atoi(argv[++i]);
+      if (num_iter < 1) {
+        std::cout << "Number of iterations must be >= 1" << std::endl;
+        exit(1);
+      }
+    } else if (strcmp(argv[i], "-k") == 0) {
+      execute_kernel = true;
+    } else if ((strcmp(argv[i], "-h") == 0)) {
+      printf("  Options:\n");
+      printf("  -N <int>: Array extent\n");
+      printf("  -i <int>: Number of iterations\n");
+      printf("  -k:       Execute the summation kernel\n");
+      printf("  -h:       Print this message\n\n");
+      exit(1);
+    }
+  }
+
+  std::cout << "Array extent = " << N << std::endl;
+  std::cout << "Iterations = " << num_iter << std::endl;
+  std::cout << "Execute summation kernel = " << std::boolalpha << execute_kernel
+            << std::noboolalpha << std::endl;
+
+  // Test inside a Kokkos kernel.
+  Kokkos::initialize(argc, argv);
+  { test_view_collection_kk(N, num_iter, execute_kernel); }
+
+  // Test outside Kokkos kernel.
+  test_view_collection_serial(N, num_iter, execute_kernel);
+
+  Kokkos::finalize();
+#endif
+
+  return 0;
+}
diff --git a/bin/kokkos_launch_compiler b/bin/kokkos_launch_compiler
index 37c17956a1..d1f8896f91 100755
--- a/bin/kokkos_launch_compiler
+++ b/bin/kokkos_launch_compiler
@@ -1,4 +1,4 @@
-#!/bin/bash -e
+#!/usr/bin/env bash
 #
 #   This script allows CMAKE_CXX_COMPILER to be a standard
 #   C++ compiler and Kokkos sets RULE_LAUNCH_COMPILE and
@@ -13,6 +13,8 @@
 #   $1 are 'ar', 'cmake', etc. during the linking phase
 #
 
+set -e
+
 # emit a message about the underlying command executed
 : ${DEBUG:=0}
 : ${KOKKOS_DEBUG_LAUNCH_COMPILER:=${DEBUG}}
diff --git a/bin/nvcc_wrapper b/bin/nvcc_wrapper
index 1397148141..d58645f98a 100755
--- a/bin/nvcc_wrapper
+++ b/bin/nvcc_wrapper
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 #
 # This shell script (nvcc_wrapper) wraps both the host compiler and
 # NVCC, if you are building legacy C or C++ code with CUDA enabled.
@@ -229,11 +229,11 @@ do
     fi
     ;;
   #Handle known nvcc args
-  --dryrun|--verbose|--keep|--source-in-ptx|-src-in-ptx|--keep-dir*|-G|-lineinfo|-extended-lambda|-expt-extended-lambda|-expt-relaxed-constexpr|--resource-usage|--fmad=*|--use_fast_math|--Wext-lambda-captures-this|-Wext-lambda-captures-this)
+  --dryrun|-dryrun|--verbose|--keep|-keep|--source-in-ptx|-src-in-ptx|--keep-dir*|-keep-dir*|-G|-lineinfo|--generate-line-info|-extended-lambda|-expt-extended-lambda|-expt-relaxed-constexpr|--resource-usage|-res-usage|--fmad=*|-fmad=*|--use_fast_math|-use_fast_math|--Wext-lambda-captures-this|-Wext-lambda-captures-this)
     cuda_args="$cuda_args $1"
     ;;
   #Handle more known nvcc args
-  --extended-lambda|--expt-extended-lambda|--expt-relaxed-constexpr|--Wno-deprecated-gpu-targets|-Wno-deprecated-gpu-targets|-allow-unsupported-compiler|--allow-unsupported-compiler)
+  --extended-lambda|--expt-extended-lambda|--expt-relaxed-constexpr|--Wno-deprecated-gpu-targets|-Wno-deprecated-gpu-targets|-allow-unsupported-compiler|--allow-unsupported-compiler|--disable-warnings)
     cuda_args="$cuda_args $1"
     ;;
   #Handle known nvcc args that have an argument
diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake
index 611c089b2e..fb1e73b579 100644
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -1,6 +1,5 @@
 TRIBITS_PACKAGE_DEFINE_DEPENDENCIES(
   LIB_OPTIONAL_TPLS Pthread CUDA HWLOC DLlib
-  TEST_OPTIONAL_TPLS CUSPARSE
   )
 
 TRIBITS_TPL_TENTATIVELY_ENABLE(DLlib)
diff --git a/cmake/KokkosConfig.cmake.in b/cmake/KokkosConfig.cmake.in
index e26c75b312..1b6d1b66ff 100644
--- a/cmake/KokkosConfig.cmake.in
+++ b/cmake/KokkosConfig.cmake.in
@@ -39,10 +39,12 @@ IF("launch_compiler" IN_LIST Kokkos_FIND_COMPONENTS)
         GLOBAL
         CHECK_CUDA_COMPILES)
 
-ELSEIF(@Kokkos_ENABLE_CUDA@ AND NOT "separable_compilation" IN_LIST Kokkos_FIND_COMPONENTS)
+ELSEIF(@Kokkos_ENABLE_CUDA@
+    AND NOT @KOKKOS_COMPILE_LANGUAGE@ STREQUAL CUDA
+    AND NOT "separable_compilation" IN_LIST Kokkos_FIND_COMPONENTS)
     #
-    # if CUDA was enabled, separable compilation was not specified, and current compiler
-    # cannot compile CUDA, then set the RULE_LAUNCH_COMPILE and RULE_LAUNCH_LINK globally and
+    # if CUDA was enabled, the compilation language was not set to CUDA, and separable compilation was not
+    # specified, then set the RULE_LAUNCH_COMPILE and RULE_LAUNCH_LINK globally and
     # kokkos_launch_compiler will re-direct to the compiler used to compile CUDA code during installation.
     # kokkos_launch_compiler will re-direct if ${CMAKE_CXX_COMPILER} and -DKOKKOS_DEPENDENCE is present,
     # otherwise, the original command will be executed
diff --git a/cmake/KokkosConfigCommon.cmake.in b/cmake/KokkosConfigCommon.cmake.in
index 446d12fa5f..d3ac39ffa3 100644
--- a/cmake/KokkosConfigCommon.cmake.in
+++ b/cmake/KokkosConfigCommon.cmake.in
@@ -4,6 +4,7 @@ SET(Kokkos_TPLS @KOKKOS_ENABLED_TPLS@)
 SET(Kokkos_ARCH @KOKKOS_ENABLED_ARCH_LIST@)
 SET(Kokkos_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
 SET(Kokkos_CXX_COMPILER_ID "@KOKKOS_CXX_COMPILER_ID@")
+SET(Kokkos_CXX_COMPILER_VERSION "@KOKKOS_CXX_COMPILER_VERSION@")
 SET(Kokkos_CXX_STANDARD @KOKKOS_CXX_STANDARD@)
 
 # Required to be a TriBITS-compliant external package
@@ -224,8 +225,13 @@ FUNCTION(kokkos_compilation)
     # if built w/o CUDA support, we want to basically make this a no-op
     SET(_Kokkos_ENABLE_CUDA @Kokkos_ENABLE_CUDA@)
 
+
+    IF(CMAKE_VERSION VERSION_GREATER_EQUAL 3.17)
+      SET(MAYBE_CURRENT_INSTALLATION_ROOT "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../../..")
+    ENDIF()
+
     # search relative first and then absolute
-    SET(_HINTS "${CMAKE_CURRENT_LIST_DIR}/../.." "@CMAKE_INSTALL_PREFIX@")
+    SET(_HINTS "${MAYBE_CURRENT_INSTALLATION_ROOT}" "@CMAKE_INSTALL_PREFIX@")
 
     # find kokkos_launch_compiler
     FIND_PROGRAM(Kokkos_COMPILE_LAUNCHER
diff --git a/cmake/KokkosCore_config.h.in b/cmake/KokkosCore_config.h.in
index 58fc8375bf..7997aa3707 100644
--- a/cmake/KokkosCore_config.h.in
+++ b/cmake/KokkosCore_config.h.in
@@ -23,8 +23,6 @@
 #cmakedefine KOKKOS_ENABLE_CUDA
 #cmakedefine KOKKOS_ENABLE_HIP
 #cmakedefine KOKKOS_ENABLE_HPX
-#cmakedefine KOKKOS_ENABLE_MEMKIND
-#cmakedefine KOKKOS_ENABLE_LIBRT
 #cmakedefine KOKKOS_ENABLE_SYCL
 #cmakedefine KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED
 
@@ -32,6 +30,7 @@
 #cmakedefine KOKKOS_ENABLE_CXX17
 #cmakedefine KOKKOS_ENABLE_CXX20
 #cmakedefine KOKKOS_ENABLE_CXX23
+#cmakedefine KOKKOS_ENABLE_CXX26
 
 #cmakedefine KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE
 #cmakedefine KOKKOS_ENABLE_CUDA_UVM
@@ -40,12 +39,12 @@
 #cmakedefine KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC
 #cmakedefine KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
 #cmakedefine KOKKOS_ENABLE_HIP_MULTIPLE_KERNEL_INSTANTIATIONS
+#cmakedefine KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY
 #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_TUNING
-#cmakedefine KOKKOS_ENABLE_DEPRECATED_CODE_3
 #cmakedefine KOKKOS_ENABLE_DEPRECATED_CODE_4
 #cmakedefine KOKKOS_ENABLE_DEPRECATION_WARNINGS
 #cmakedefine KOKKOS_ENABLE_LARGE_MEM_TESTS
@@ -53,31 +52,33 @@
 #cmakedefine KOKKOS_OPT_RANGE_AGGRESSIVE_VECTORIZATION  // deprecated
 #cmakedefine KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION
 #cmakedefine KOKKOS_ENABLE_IMPL_MDSPAN
+#cmakedefine KOKKOS_ENABLE_IMPL_REF_COUNT_BRANCH_UNLIKELY
+#cmakedefine KOKKOS_ENABLE_IMPL_VIEW_OF_VIEWS_DESTRUCTOR_PRECONDITION_VIOLATION_WORKAROUND
+#cmakedefine KOKKOS_ENABLE_ATOMICS_BYPASS
 
 /* TPL Settings */
 #cmakedefine KOKKOS_ENABLE_HWLOC
-#cmakedefine KOKKOS_USE_LIBRT
-#cmakedefine KOKKOS_ENABLE_HBWSPACE
 #cmakedefine KOKKOS_ENABLE_LIBDL
 #cmakedefine KOKKOS_ENABLE_LIBQUADMATH
-#cmakedefine KOKKOS_IMPL_CUDA_CLANG_WORKAROUND
 #cmakedefine KOKKOS_ENABLE_ONEDPL
+#cmakedefine KOKKOS_ENABLE_ROCTHRUST
 
-#cmakedefine KOKKOS_ARCH_SSE42
 #cmakedefine KOKKOS_ARCH_ARMV80
 #cmakedefine KOKKOS_ARCH_ARMV8_THUNDERX
 #cmakedefine KOKKOS_ARCH_ARMV81
 #cmakedefine KOKKOS_ARCH_ARMV8_THUNDERX2
+#cmakedefine KOKKOS_ARCH_ARMV9_GRACE
 #cmakedefine KOKKOS_ARCH_A64FX
-#cmakedefine KOKKOS_ARCH_AMD_AVX2
 #cmakedefine KOKKOS_ARCH_AVX
 #cmakedefine KOKKOS_ARCH_AVX2
 #cmakedefine KOKKOS_ARCH_AVX512XEON
+#cmakedefine KOKKOS_ARCH_ARM_NEON
 #cmakedefine KOKKOS_ARCH_KNC
 #cmakedefine KOKKOS_ARCH_AVX512MIC
 #cmakedefine KOKKOS_ARCH_POWER7
 #cmakedefine KOKKOS_ARCH_POWER8
 #cmakedefine KOKKOS_ARCH_POWER9
+#cmakedefine KOKKOS_ARCH_RISCV_SG2042
 #cmakedefine KOKKOS_ARCH_INTEL_GEN
 #cmakedefine KOKKOS_ARCH_INTEL_DG1
 #cmakedefine KOKKOS_ARCH_INTEL_GEN9
@@ -111,12 +112,20 @@
 #cmakedefine KOKKOS_ARCH_AMD_ZEN
 #cmakedefine KOKKOS_ARCH_AMD_ZEN2
 #cmakedefine KOKKOS_ARCH_AMD_ZEN3
-#cmakedefine KOKKOS_ARCH_VEGA
-#cmakedefine KOKKOS_ARCH_VEGA906
-#cmakedefine KOKKOS_ARCH_VEGA908
-#cmakedefine KOKKOS_ARCH_VEGA90A
-#cmakedefine KOKKOS_ARCH_NAVI
-#cmakedefine KOKKOS_ARCH_NAVI1030
-#cmakedefine KOKKOS_ARCH_NAVI1100
+#cmakedefine KOKKOS_ARCH_AMD_GFX906
+#cmakedefine KOKKOS_ARCH_AMD_GFX908
+#cmakedefine KOKKOS_ARCH_AMD_GFX90A
+#cmakedefine KOKKOS_ARCH_AMD_GFX940
+#cmakedefine KOKKOS_ARCH_AMD_GFX942
+#cmakedefine KOKKOS_ARCH_AMD_GFX1030
+#cmakedefine KOKKOS_ARCH_AMD_GFX1100
+#cmakedefine KOKKOS_ARCH_AMD_GPU
+#cmakedefine KOKKOS_ARCH_VEGA // deprecated
+#cmakedefine KOKKOS_ARCH_VEGA906 // deprecated
+#cmakedefine KOKKOS_ARCH_VEGA908 // deprecated
+#cmakedefine KOKKOS_ARCH_VEGA90A // deprecated
+#cmakedefine KOKKOS_ARCH_NAVI // deprecated
+#cmakedefine KOKKOS_ARCH_NAVI1030 // deprecated
+#cmakedefine KOKKOS_ARCH_NAVI1100 // deprecated
 
 #cmakedefine KOKKOS_IMPL_32BIT
diff --git a/cmake/Modules/FindTPLCUDA.cmake b/cmake/Modules/FindTPLCUDA.cmake
index 792c92c07e..445f4e93a5 100644
--- a/cmake/Modules/FindTPLCUDA.cmake
+++ b/cmake/Modules/FindTPLCUDA.cmake
@@ -7,36 +7,38 @@ IF (NOT CUDAToolkit_ROOT)
   ENDIF()
 ENDIF()
 
+IF(KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC AND CMAKE_VERSION VERSION_LESS "3.20.1")
+  MESSAGE(FATAL_ERROR "Using NVHPC as host compiler requires at least CMake 3.20.1")
+ENDIF()
+
 IF(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17.0")
-  find_package(CUDAToolkit)
+  find_package(CUDAToolkit REQUIRED)
+  KOKKOS_CREATE_IMPORTED_TPL(CUDA INTERFACE
+    LINK_LIBRARIES CUDA::cuda_driver CUDA::cudart
+  )
+  KOKKOS_EXPORT_CMAKE_TPL(CUDAToolkit REQUIRED)
 ELSE()
   include(${CMAKE_CURRENT_LIST_DIR}/CudaToolkit.cmake)
-ENDIF()
-
 
-IF (TARGET CUDA::cudart)
-  SET(FOUND_CUDART TRUE)
-  KOKKOS_EXPORT_IMPORTED_TPL(CUDA::cudart)
-ELSE()
-  SET(FOUND_CUDART FALSE)
-ENDIF()
+  IF (TARGET CUDA::cudart)
+    SET(FOUND_CUDART TRUE)
+    KOKKOS_EXPORT_IMPORTED_TPL(CUDA::cudart)
+  ELSE()
+    SET(FOUND_CUDART FALSE)
+  ENDIF()
 
-IF (TARGET CUDA::cuda_driver)
-  SET(FOUND_CUDA_DRIVER TRUE)
-  KOKKOS_EXPORT_IMPORTED_TPL(CUDA::cuda_driver)
-ELSE()
-  SET(FOUND_CUDA_DRIVER FALSE)
-ENDIF()
+  IF (TARGET CUDA::cuda_driver)
+    SET(FOUND_CUDA_DRIVER TRUE)
+    KOKKOS_EXPORT_IMPORTED_TPL(CUDA::cuda_driver)
+  ELSE()
+    SET(FOUND_CUDA_DRIVER FALSE)
+  ENDIF()
 
-include(FindPackageHandleStandardArgs)
-IF(KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
-  SET(KOKKOS_CUDA_ERROR "Using NVHPC as host compiler requires at least CMake 3.20.1")
-ELSE()
-  SET(KOKKOS_CUDA_ERROR DEFAULT_MSG)
-ENDIF()
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(TPLCUDA ${KOKKOS_CUDA_ERROR} FOUND_CUDART FOUND_CUDA_DRIVER)
-IF (FOUND_CUDA_DRIVER AND FOUND_CUDART)
-  KOKKOS_CREATE_IMPORTED_TPL(CUDA INTERFACE
-    LINK_LIBRARIES CUDA::cuda_driver CUDA::cudart
-  )
+  include(FindPackageHandleStandardArgs)
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(TPLCUDA ${DEFAULT_MSG} FOUND_CUDART FOUND_CUDA_DRIVER)
+  IF (FOUND_CUDA_DRIVER AND FOUND_CUDART)
+    KOKKOS_CREATE_IMPORTED_TPL(CUDA INTERFACE
+      LINK_LIBRARIES CUDA::cuda_driver CUDA::cudart
+    )
+  ENDIF()
 ENDIF()
diff --git a/cmake/Modules/FindTPLLIBRT.cmake b/cmake/Modules/FindTPLLIBRT.cmake
deleted file mode 100644
index e75da56b5b..0000000000
--- a/cmake/Modules/FindTPLLIBRT.cmake
+++ /dev/null
@@ -1 +0,0 @@
-KOKKOS_FIND_IMPORTED(LIBRT HEADER time.h   LIBRARY rt)
diff --git a/cmake/Modules/FindTPLMEMKIND.cmake b/cmake/Modules/FindTPLMEMKIND.cmake
deleted file mode 100644
index 20aaff2295..0000000000
--- a/cmake/Modules/FindTPLMEMKIND.cmake
+++ /dev/null
@@ -1 +0,0 @@
-KOKKOS_FIND_IMPORTED(MEMKIND HEADER memkind.h LIBRARY memkind)
diff --git a/cmake/Modules/FindTPLONEDPL.cmake b/cmake/Modules/FindTPLONEDPL.cmake
index 01791cff44..603510c315 100644
--- a/cmake/Modules/FindTPLONEDPL.cmake
+++ b/cmake/Modules/FindTPLONEDPL.cmake
@@ -43,4 +43,7 @@ ELSE()
       COMPILE_DEFINITIONS PSTL_USE_PARALLEL_POLICIES=0 _GLIBCXX_USE_TBB_PAR_BACKEND=0
     )
   ENDIF()
+
+  # Export oneDPL as a Kokkos dependency
+  KOKKOS_EXPORT_CMAKE_TPL(oneDPL)
 ENDIF()
diff --git a/cmake/Modules/FindTPLROCM.cmake b/cmake/Modules/FindTPLROCM.cmake
index aacdfcaf19..f796737f5b 100644
--- a/cmake/Modules/FindTPLROCM.cmake
+++ b/cmake/Modules/FindTPLROCM.cmake
@@ -3,15 +3,27 @@ include(FindPackageHandleStandardArgs)
 FIND_LIBRARY(AMD_HIP_LIBRARY amdhip64 PATHS ENV ROCM_PATH PATH_SUFFIXES lib)
 FIND_LIBRARY(HSA_RUNTIME_LIBRARY hsa-runtime64 PATHS ENV ROCM_PATH PATH_SUFFIXES lib)
 
+# FIXME_HIP Starting with ROCm 5.5 it is not necessary to link againt clang_rt.
+# We keep the code as is for now because it is hard to find the version of ROCM
+# found.
 # clang_rt.builtins is necessary to use half precision. The following code to
 # find clang_rt.buitins is based on
-# https://github.com/ROCm-Developer-Tools/HIP/blob/develop/hip-lang-config.cmake.in#L99-L111
-file(GLOB_RECURSE CLANG_RT_DIR "$ENV{ROCM_PATH}/llvm/lib/clang/*/lib/*/*clang_rt.builtins*")
-FIND_LIBRARY(CLANG_RT_LIBRARY
-  NAMES
-  clang_rt.builtins
-  clang_rt.builtins-x86_64
-  PATHS "${CLANG_RT_DIR}/..")
+# https://github.com/ROCm-Developer-Tools/hipamd/blob/d1e0ee98a0f3d79f7bf43295f82d0053a69ec742/hip-config.cmake.in#L241
+# NOTE: Per the above, we still search for the clang-rt library,
+# but use the user's specified compiler to find the library to avoid use of
+# environment variables / relative paths.
+execute_process(
+  COMMAND ${CMAKE_CXX_COMPILER} -print-libgcc-file-name --rtlib=compiler-rt
+  OUTPUT_VARIABLE CLANG_RT_LIBRARY
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  RESULT_VARIABLE CLANG_RT_CHECK)
+
+if( NOT "${CLANG_RT_CHECK}" STREQUAL "0" )
+  # if the above failed, we delete CLANG_RT_LIBRARY to make the args check
+  # below fail
+  unset(CLANG_RT_LIBRARY)
+endif()
+
 
 find_package_handle_standard_args(TPLROCM DEFAULT_MSG AMD_HIP_LIBRARY HSA_RUNTIME_LIBRARY CLANG_RT_LIBRARY)
 
diff --git a/cmake/Modules/FindTPLROCTHRUST.cmake b/cmake/Modules/FindTPLROCTHRUST.cmake
new file mode 100644
index 0000000000..dae7dc3c95
--- /dev/null
+++ b/cmake/Modules/FindTPLROCTHRUST.cmake
@@ -0,0 +1,15 @@
+# ROCm 5.6 and earlier set AMDGPU_TARGETS and GPU_TARGETS to all the supported
+# architectures. Therefore, we end up compiling Kokkos for all the supported
+# architecture. Starting with ROCm 5.7 AMDGPU_TARGETS and GPU_TARGETS are empty.
+# It is the user's job to set the variables. Since we are injecting the
+# architecture flag ourselves, we can let the variables empty. To replicate the
+# behavior of ROCm 5.7 and later for earlier version of ROCm we set
+# AMDGPU_TARGETS and GPU_TARGETS to empty and set the values in the cache. If
+# the values are not cached, FIND_PACKAGE(rocthrust) will overwrite them.
+SET(AMDGPU_TARGETS "" CACHE STRING "AMD GPU targets to compile for")
+SET(GPU_TARGETS "" CACHE STRING "GPU targets to compile for")
+FIND_PACKAGE(rocthrust REQUIRED)
+KOKKOS_CREATE_IMPORTED_TPL(ROCTHRUST INTERFACE LINK_LIBRARIES roc::rocthrust)
+
+# Export ROCTHRUST as a Kokkos dependency
+KOKKOS_EXPORT_CMAKE_TPL(rocthrust)
diff --git a/cmake/deps/CUDA.cmake b/cmake/deps/CUDA.cmake
index 68bf5b3d57..5b6afd6151 100644
--- a/cmake/deps/CUDA.cmake
+++ b/cmake/deps/CUDA.cmake
@@ -35,7 +35,6 @@ IF(NOT _CUDA_FAILURE)
   GLOBAL_SET(TPL_CUDA_LIBRARY_DIRS)
   GLOBAL_SET(TPL_CUDA_INCLUDE_DIRS ${CUDA_TOOLKIT_INCLUDE})
   GLOBAL_SET(TPL_CUDA_LIBRARIES ${CUDA_CUDART_LIBRARY} ${CUDA_cublas_LIBRARY} ${CUDA_cufft_LIBRARY})
-  KOKKOS_CREATE_IMPORTED_TPL_LIBRARY(CUSPARSE)
 ELSE()
   SET(TPL_ENABLE_CUDA OFF)
 ENDIF()
diff --git a/cmake/deps/CUSPARSE.cmake b/cmake/deps/CUSPARSE.cmake
deleted file mode 100644
index b016971ab9..0000000000
--- a/cmake/deps/CUSPARSE.cmake
+++ /dev/null
@@ -1,26 +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.
-#
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-# ************************************************************************
-# @HEADER
-
-#include(${TRIBITS_DEPS_DIR}/CUDA.cmake)
-
-#IF (TPL_ENABLE_CUDA)
-#  GLOBAL_SET(TPL_CUSPARSE_LIBRARY_DIRS)
-#  GLOBAL_SET(TPL_CUSPARSE_INCLUDE_DIRS ${TPL_CUDA_INCLUDE_DIRS})
-#  GLOBAL_SET(TPL_CUSPARSE_LIBRARIES    ${CUDA_cusparse_LIBRARY})
-#  KOKKOS_CREATE_IMPORTED_TPL_LIBRARY(CUSPARSE)
-#ENDIF()
-
diff --git a/cmake/fake_tribits.cmake b/cmake/fake_tribits.cmake
index eedae14d45..a18d2ac518 100644
--- a/cmake/fake_tribits.cmake
+++ b/cmake/fake_tribits.cmake
@@ -118,14 +118,6 @@ FUNCTION(KOKKOS_ADD_TEST)
   ENDIF()
 ENDFUNCTION()
 
-FUNCTION(KOKKOS_ADD_ADVANCED_TEST)
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_ADD_ADVANCED_TEST(${ARGN})
-  else()
-    # TODO Write this
-  endif()
-ENDFUNCTION()
-
 MACRO(KOKKOS_CREATE_IMPORTED_TPL_LIBRARY TPL_NAME)
   ADD_INTERFACE_LIBRARY(TPL_LIB_${TPL_NAME})
   TARGET_LINK_LIBRARIES(TPL_LIB_${TPL_NAME} LINK_PUBLIC ${TPL_${TPL_NAME}_LIBRARIES})
@@ -170,15 +162,6 @@ else()
 endif()
 ENDMACRO()
 
-
-MACRO(KOKKOS_EXCLUDE_AUTOTOOLS_FILES)
-  if (KOKKOS_HAS_TRILINOS)
-    TRIBITS_EXCLUDE_AUTOTOOLS_FILES()
-  else()
-    #do nothing
-  endif()
-ENDMACRO()
-
 FUNCTION(KOKKOS_LIB_TYPE LIB RET)
 GET_TARGET_PROPERTY(PROP ${LIB} TYPE)
 IF (${PROP} STREQUAL "INTERFACE_LIBRARY")
diff --git a/cmake/kokkos_arch.cmake b/cmake/kokkos_arch.cmake
index d64726307b..a581d9f945 100644
--- a/cmake/kokkos_arch.cmake
+++ b/cmake/kokkos_arch.cmake
@@ -28,6 +28,7 @@ KOKKOS_CHECK_DEPRECATED_OPTIONS(
 #-------------------------------------------------------------------------------
 SET(KOKKOS_ARCH_LIST)
 
+include(CheckCXXCompilerFlag)
 
 KOKKOS_DEPRECATED_LIST(ARCH ARCH)
 
@@ -49,7 +50,7 @@ DECLARE_AND_CHECK_HOST_ARCH(ARMV81            "ARMv8.1 Compatible CPU")
 DECLARE_AND_CHECK_HOST_ARCH(ARMV8_THUNDERX    "ARMv8 Cavium ThunderX CPU")
 DECLARE_AND_CHECK_HOST_ARCH(ARMV8_THUNDERX2   "ARMv8 Cavium ThunderX2 CPU")
 DECLARE_AND_CHECK_HOST_ARCH(A64FX             "ARMv8.2 with SVE Support")
-DECLARE_AND_CHECK_HOST_ARCH(WSM               "Intel Westmere CPU")
+DECLARE_AND_CHECK_HOST_ARCH(ARMV9_GRACE       "ARMv9 NVIDIA Grace CPU")
 DECLARE_AND_CHECK_HOST_ARCH(SNB               "Intel Sandy/Ivy Bridge CPUs")
 DECLARE_AND_CHECK_HOST_ARCH(HSW               "Intel Haswell CPUs")
 DECLARE_AND_CHECK_HOST_ARCH(BDW               "Intel Broadwell Xeon E-class CPUs")
@@ -60,13 +61,12 @@ DECLARE_AND_CHECK_HOST_ARCH(SKX               "Intel Skylake Xeon Server CPUs (A
 DECLARE_AND_CHECK_HOST_ARCH(KNC               "Intel Knights Corner Xeon Phi")
 DECLARE_AND_CHECK_HOST_ARCH(KNL               "Intel Knights Landing Xeon Phi")
 DECLARE_AND_CHECK_HOST_ARCH(SPR               "Intel Sapphire Rapids Xeon Server CPUs (AVX512)")
-DECLARE_AND_CHECK_HOST_ARCH(BGQ               "IBM Blue Gene Q")
-DECLARE_AND_CHECK_HOST_ARCH(POWER7            "IBM POWER7 CPUs")
 DECLARE_AND_CHECK_HOST_ARCH(POWER8            "IBM POWER8 CPUs")
 DECLARE_AND_CHECK_HOST_ARCH(POWER9            "IBM POWER9 CPUs")
 DECLARE_AND_CHECK_HOST_ARCH(ZEN               "AMD Zen architecture")
 DECLARE_AND_CHECK_HOST_ARCH(ZEN2              "AMD Zen2 architecture")
 DECLARE_AND_CHECK_HOST_ARCH(ZEN3              "AMD Zen3 architecture")
+DECLARE_AND_CHECK_HOST_ARCH(RISCV_SG2042      "SG2042 (RISC-V) CPUs")
 
 IF(Kokkos_ENABLE_CUDA OR Kokkos_ENABLE_OPENMPTARGET OR Kokkos_ENABLE_OPENACC OR Kokkos_ENABLE_SYCL)
   SET(KOKKOS_SHOW_CUDA_ARCHS ON)
@@ -89,14 +89,23 @@ KOKKOS_ARCH_OPTION(AMPERE86        GPU  "NVIDIA Ampere generation CC 8.6"  "KOKK
 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)
+IF(Kokkos_ENABLE_HIP OR Kokkos_ENABLE_OPENMPTARGET OR Kokkos_ENABLE_OPENACC OR Kokkos_ENABLE_SYCL)
   SET(KOKKOS_SHOW_HIP_ARCHS ON)
 ENDIF()
 
 # AMD archs ordered in decreasing priority of autodetection
-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)
+LIST(APPEND SUPPORTED_AMD_GPUS       MI300 MI300)
+LIST(APPEND SUPPORTED_AMD_ARCHS      AMD_GFX942 AMD_GFX940)
+LIST(APPEND CORRESPONDING_AMD_FLAGS  gfx942 gfx940)
+LIST(APPEND SUPPORTED_AMD_GPUS       MI200    MI200       MI100    MI100)
+LIST(APPEND SUPPORTED_AMD_ARCHS      VEGA90A  AMD_GFX90A  VEGA908  AMD_GFX908)
+LIST(APPEND CORRESPONDING_AMD_FLAGS  gfx90a   gfx90a      gfx908   gfx908)
+LIST(APPEND SUPPORTED_AMD_GPUS       MI50/60  MI50/60)
+LIST(APPEND SUPPORTED_AMD_ARCHS      VEGA906  AMD_GFX906)
+LIST(APPEND CORRESPONDING_AMD_FLAGS  gfx906   gfx906)
+LIST(APPEND SUPPORTED_AMD_GPUS       RX7900XTX  RX7900XTX    V620/W6800  V620/W6800)
+LIST(APPEND SUPPORTED_AMD_ARCHS      NAVI1100   AMD_GFX1100  NAVI1030    AMD_GFX1030)
+LIST(APPEND CORRESPONDING_AMD_FLAGS  gfx1100    gfx1100      gfx1030     gfx1030)
 
 #FIXME CAN BE REPLACED WITH LIST_ZIP IN CMAKE 3.17
 FOREACH(ARCH IN LISTS SUPPORTED_AMD_ARCHS)
@@ -182,15 +191,6 @@ IF (KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
   ELSEIF(CUDAToolkit_BIN_DIR)
     GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS --cuda-path=${CUDAToolkit_BIN_DIR}/..)
   ENDIF()
-  IF (KOKKOS_ENABLE_CUDA)
-     SET(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND ON CACHE BOOL "enable CUDA Clang workarounds" FORCE)
-  ENDIF()
-ELSEIF (KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
-  SET(CUDA_ARCH_FLAG "-gpu")
-  GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS -cuda)
-  IF (KOKKOS_ENABLE_CUDA) # FIXME ideally unreachable when CUDA not enabled
-    GLOBAL_APPEND(KOKKOS_LINK_OPTIONS -cuda)
-  ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
   SET(CUDA_ARCH_FLAG "-arch")
 ENDIF()
@@ -205,11 +205,19 @@ ENDIF()
 
 
 #------------------------------- KOKKOS_HIP_OPTIONS ---------------------------
+KOKKOS_OPTION(IMPL_AMDGPU_FLAGS "" STRING "Set compiler flags for AMD GPUs")
+KOKKOS_OPTION(IMPL_AMDGPU_LINK "" STRING "Set linker flags for AMD GPUs")
+MARK_AS_ADVANCED(Kokkos_IMPL_AMDGPU_FLAGS)
+MARK_AS_ADVANCED(Kokkos_IMPL_AMDGPU_LINK)
+
 #clear anything that might be in the cache
 GLOBAL_SET(KOKKOS_AMDGPU_OPTIONS)
 IF(KOKKOS_ENABLE_HIP)
   SET(AMDGPU_ARCH_FLAG "--offload-arch")
   IF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL HIPCC)
+    IF (NOT CMAKE_CXX_STANDARD)
+      MESSAGE(FATAL_ERROR "Kokkos requires CMAKE_CXX_STANDARD to set to 17 or higher")
+    ENDIF()
     GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS -xhip)
     IF(DEFINED ENV{ROCM_PATH})
       GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS --rocm-path=$ENV{ROCM_PATH})
@@ -237,6 +245,7 @@ IF(KOKKOS_ARCH_NATIVE)
 ENDIF()
 
 IF (KOKKOS_ARCH_ARMV80)
+  SET(KOKKOS_ARCH_ARM_NEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     Cray    NO-VALUE-SPECIFIED
@@ -247,6 +256,7 @@ IF (KOKKOS_ARCH_ARMV80)
 ENDIF()
 
 IF (KOKKOS_ARCH_ARMV81)
+  SET(KOKKOS_ARCH_ARM_NEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     Cray    NO-VALUE-SPECIFIED
@@ -257,6 +267,7 @@ IF (KOKKOS_ARCH_ARMV81)
 ENDIF()
 
 IF (KOKKOS_ARCH_ARMV8_THUNDERX)
+  SET(KOKKOS_ARCH_ARM_NEON ON)
   SET(KOKKOS_ARCH_ARMV80 ON) #Not a cache variable
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
@@ -268,6 +279,7 @@ IF (KOKKOS_ARCH_ARMV8_THUNDERX)
 ENDIF()
 
 IF (KOKKOS_ARCH_ARMV8_THUNDERX2)
+  SET(KOKKOS_ARCH_ARM_NEON ON)
   SET(KOKKOS_ARCH_ARMV81 ON) #Not a cache variable
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
@@ -279,6 +291,7 @@ IF (KOKKOS_ARCH_ARMV8_THUNDERX2)
 ENDIF()
 
 IF (KOKKOS_ARCH_A64FX)
+  SET(KOKKOS_ARCH_ARM_NEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     Clang   -march=armv8.2-a+sve -msve-vector-bits=512
@@ -289,6 +302,20 @@ IF (KOKKOS_ARCH_A64FX)
   )
 ENDIF()
 
+IF (KOKKOS_ARCH_ARMV9_GRACE)
+  SET(KOKKOS_ARCH_ARM_NEON ON)
+  check_cxx_compiler_flag("-mcpu=neoverse-n2" COMPILER_SUPPORTS_NEOVERSE_N2)
+  check_cxx_compiler_flag("-msve-vector-bits=128" COMPILER_SUPPORTS_SVE_VECTOR_BITS)
+  IF (COMPILER_SUPPORTS_NEOVERSE_N2 AND COMPILER_SUPPORTS_SVE_VECTOR_BITS)
+    COMPILER_SPECIFIC_FLAGS(
+      COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
+      DEFAULT -mcpu=neoverse-n2 -msve-vector-bits=128
+    )
+  ELSE()
+    MESSAGE(WARNING "Compiler does not support ARMv9 Grace architecture")
+  ENDIF()
+ENDIF()
+
 IF (KOKKOS_ARCH_ZEN)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
@@ -298,7 +325,7 @@ IF (KOKKOS_ARCH_ZEN)
     DEFAULT -march=znver1 -mtune=znver1
   )
   SET(KOKKOS_ARCH_AMD_ZEN  ON)
-  SET(KOKKOS_ARCH_AMD_AVX2 ON)
+  SET(KOKKOS_ARCH_AVX2 ON)
 ENDIF()
 
 IF (KOKKOS_ARCH_ZEN2)
@@ -310,7 +337,7 @@ IF (KOKKOS_ARCH_ZEN2)
     DEFAULT -march=znver2 -mtune=znver2
   )
   SET(KOKKOS_ARCH_AMD_ZEN2 ON)
-  SET(KOKKOS_ARCH_AMD_AVX2 ON)
+  SET(KOKKOS_ARCH_AVX2 ON)
 ENDIF()
 
 IF (KOKKOS_ARCH_ZEN3)
@@ -322,19 +349,7 @@ IF (KOKKOS_ARCH_ZEN3)
     DEFAULT -march=znver3 -mtune=znver3
   )
   SET(KOKKOS_ARCH_AMD_ZEN3 ON)
-  SET(KOKKOS_ARCH_AMD_AVX2 ON)
-ENDIF()
-
-IF (KOKKOS_ARCH_WSM)
-  COMPILER_SPECIFIC_FLAGS(
-    COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
-    Cray    NO-VALUE-SPECIFIED
-    Intel   -xSSE4.2
-    MSVC    NO-VALUE-SPECIFIED
-    NVHPC   -tp=px
-    DEFAULT -msse4.2
-  )
-  SET(KOKKOS_ARCH_SSE42 ON)
+  SET(KOKKOS_ARCH_AVX2 ON)
 ENDIF()
 
 IF (KOKKOS_ARCH_SNB OR KOKKOS_ARCH_AMDAVX)
@@ -361,6 +376,23 @@ IF (KOKKOS_ARCH_HSW)
   )
 ENDIF()
 
+IF (KOKKOS_ARCH_RISCV_SG2042)
+  IF(NOT
+  (KOKKOS_CXX_COMPILER_ID STREQUAL GNU
+    AND KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12)
+  OR
+  (KOKKOS_CXX_COMPILER_ID STREQUAL Clang
+    AND KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+  )
+  MESSAGE(SEND_ERROR "Only gcc >= 12 and clang >= 14 support RISC-V.")
+  ENDIF()
+  COMPILER_SPECIFIC_FLAGS(
+    COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
+        DEFAULT -march=rv64imafdcv
+      )
+ENDIF()
+
+
 IF (KOKKOS_ARCH_BDW)
   SET(KOKKOS_ARCH_AVX2 ON)
   COMPILER_SPECIFIC_FLAGS(
@@ -406,10 +438,7 @@ IF (KOKKOS_ARCH_SKL)
 ENDIF()
 
 IF (KOKKOS_ARCH_SKX)
-  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
-  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
-    SET(KOKKOS_ARCH_AVX512XEON ON)
-  ENDIF()
+  SET(KOKKOS_ARCH_AVX512XEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     Cray    NO-VALUE-SPECIFIED
@@ -421,10 +450,7 @@ IF (KOKKOS_ARCH_SKX)
 ENDIF()
 
 IF (KOKKOS_ARCH_ICL)
-  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
-  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
-    SET(KOKKOS_ARCH_AVX512XEON ON)
-  ENDIF()
+  SET(KOKKOS_ARCH_AVX512XEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     MSVC    /arch:AVX512
@@ -433,10 +459,7 @@ IF (KOKKOS_ARCH_ICL)
 ENDIF()
 
 IF (KOKKOS_ARCH_ICX)
-  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
-  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
-    SET(KOKKOS_ARCH_AVX512XEON ON)
-  ENDIF()
+  SET(KOKKOS_ARCH_AVX512XEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     MSVC    /arch:AVX512
@@ -445,10 +468,7 @@ IF (KOKKOS_ARCH_ICX)
 ENDIF()
 
 IF (KOKKOS_ARCH_SPR)
-  # FIXME_NVHPC nvc++ doesn't seem to support AVX512.
-  IF (NOT KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
-    SET(KOKKOS_ARCH_AVX512XEON ON)
-  ENDIF()
+  SET(KOKKOS_ARCH_AVX512XEON ON)
   COMPILER_SPECIFIC_FLAGS(
     COMPILER_ID KOKKOS_CXX_HOST_COMPILER_ID
     MSVC    /arch:AVX512
@@ -483,17 +503,64 @@ IF (KOKKOS_ARCH_POWER9)
   )
 ENDIF()
 
+# If Kokkos_ARCH_NATIVE is enabled, we are trying to autodetect
+# the SIMD capabilities based on compiler macros.
+IF (KOKKOS_ARCH_NATIVE)
+  # Make sure to rerun the checks if compile options have changed
+  IF(NOT "${KOKKOS_COMPILE_OPTIONS}" STREQUAL "${KOKKOS_COMPILE_OPTIONS_SAVED}")
+    SET(KOKKOS_COMPILE_OPTIONS_SAVED "${KOKKOS_COMPILE_OPTIONS}" CACHE INTERNAL "")
+
+    SET(CMAKE_REQUIRED_QUIET ON)
+    SET(CMAKE_REQUIRED_FLAGS "${KOKKOS_COMPILE_OPTIONS}")
+    INCLUDE(CheckCXXSymbolExists)
+
+    UNSET(KOKKOS_COMPILER_HAS_AVX512 CACHE)
+    CHECK_CXX_SYMBOL_EXISTS(__AVX512F__ "" KOKKOS_COMPILER_HAS_AVX512)
+    UNSET(KOKKOS_COMPILER_HAS_AVX2 CACHE)
+    CHECK_CXX_SYMBOL_EXISTS(__AVX2__ "" KOKKOS_COMPILER_HAS_AVX2)
+    UNSET(KOKKOS_COMPILER_HAS_ARM_NEON CACHE)
+    CHECK_CXX_SYMBOL_EXISTS(__ARM_NEON "" KOKKOS_COMPILER_HAS_ARM_NEON)
+    UNSET(KOKKOS_COMPILER_HAS_AVX CACHE)
+    CHECK_CXX_SYMBOL_EXISTS(__AVX__ "" KOKKOS_COMPILER_HAS_AVX)
+    SET(CMAKE_REQUIRED_FLAGS "${KOKKOS_COMPILE_OPTIONS}")
+
+    UNSET(CMAKE_REQUIRED_QUIET)
+    UNSET(CMAKE_REQUIRED_FLAGS)
+  ENDIF()
+
+  # Only define one of these macros for now
+  # to be uniform with what we are doing for other architectures.
+  IF(KOKKOS_COMPILER_HAS_AVX512)
+    MESSAGE(STATUS "SIMD: AVX512 detected")
+    SET(KOKKOS_ARCH_AVX512XEON ON)
+  ELSEIF(KOKKOS_COMPILER_HAS_AVX2)
+    MESSAGE(STATUS "SIMD: AVX2 detected")
+    SET(KOKKOS_ARCH_AVX2 ON)
+  ELSEIF(KOKKOS_COMPILER_HAS_ARM_NEON)
+    MESSAGE(STATUS "SIMD: ARM_NEON detected")
+    SET(KOKKOS_ARCH_ARM_NEON ON)
+  ELSEIF(KOKKOS_COMPILER_HAS_AVX)
+    MESSAGE(STATUS "SIMD: AVX detected")
+    SET(KOKKOS_ARCH_AVX ON)
+  ENDIF()
+ENDIF()
+
+# FIXME_NVHPC nvc++ doesn't seem to support AVX512.
+IF (KOKKOS_CXX_HOST_COMPILER_ID STREQUAL NVHPC)
+  SET(KOKKOS_ARCH_AVX512XEON OFF)
+ENDIF()
+
+# FIXME_NVCC nvcc doesn't seem to support Arm Neon.
+IF(KOKKOS_ARCH_ARM_NEON AND KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+  UNSET(KOKKOS_ARCH_ARM_NEON)
+ENDIF()
+
 IF (NOT KOKKOS_COMPILE_LANGUAGE STREQUAL CUDA)
   IF (KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
       COMPILER_SPECIFIC_FLAGS(
         Clang  -fcuda-rdc
         NVIDIA --relocatable-device-code=true
-        NVHPC -gpu=rdc
       )
-  ELSEIF(KOKKOS_ENABLE_CUDA)
-    COMPILER_SPECIFIC_FLAGS(
-      NVHPC -gpu=nordc
-    )
   ENDIF()
 ENDIF()
 
@@ -519,6 +586,11 @@ IF (KOKKOS_ENABLE_HIP)
     COMPILER_SPECIFIC_FLAGS(
       DEFAULT -fgpu-rdc
     )
+    IF (NOT KOKKOS_CXX_COMPILER_ID STREQUAL HIPCC AND NOT KOKKOS_IMPL_AMDGPU_FLAGS)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        DEFAULT --hip-link
+      )
+    ENDIF()
   ELSE()
     COMPILER_SPECIFIC_FLAGS(
       DEFAULT -fno-gpu-rdc
@@ -536,32 +608,44 @@ 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)
+# FIXME_SYCL If SYCL_EXT_ONEAPI_DEVICE_GLOBAL is defined, we can use device
+#   global variables with shared libraries using the "non-separable compilation"
+#   implementation. Otherwise, the feature is not supported when building shared
+#   libraries. Thus, we don't even check for support if shared libraries are
+#   requested and SYCL_EXT_ONEAPI_DEVICE_GLOBAL is not defined.
+IF(KOKKOS_ENABLE_SYCL)
   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
-    )
+  INCLUDE(CheckCXXSymbolExists)
+  CHECK_CXX_SYMBOL_EXISTS(SYCL_EXT_ONEAPI_DEVICE_GLOBAL "sycl/sycl.hpp" KOKKOS_IMPL_HAVE_SYCL_EXT_ONEAPI_DEVICE_GLOBAL)
+  IF (KOKKOS_IMPL_HAVE_SYCL_EXT_ONEAPI_DEVICE_GLOBAL)
+    SET(KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED ON)
+    # Use the non-separable compilation implementation to support shared libraries as well.
+    COMPILER_SPECIFIC_FLAGS(DEFAULT -DDESUL_SYCL_DEVICE_GLOBAL_SUPPORTED)
+  ELSEIF(NOT BUILD_SHARED_LIBS)
+    INCLUDE(CheckCXXSourceCompiles)
+    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)
+      # Only the separable compilation implementation is supported.
+      COMPILER_SPECIFIC_FLAGS(
+        DEFAULT -fsycl-device-code-split=off -DDESUL_SYCL_DEVICE_GLOBAL_SUPPORTED
+      )
+    ENDIF()
   ENDIF()
 ENDIF()
 
@@ -573,7 +657,7 @@ FUNCTION(CHECK_CUDA_ARCH ARCH FLAG)
     ENDIF()
     SET(CUDA_ARCH_ALREADY_SPECIFIED ${ARCH} PARENT_SCOPE)
     IF (NOT KOKKOS_ENABLE_CUDA AND NOT KOKKOS_ENABLE_OPENMPTARGET AND NOT KOKKOS_ENABLE_SYCL AND NOT KOKKOS_ENABLE_OPENACC)
-      MESSAGE(WARNING "Given CUDA arch ${ARCH}, but Kokkos_ENABLE_CUDA, Kokkos_ENABLE_OPENACC, and Kokkos_ENABLE_OPENMPTARGET are OFF. Option will be ignored.")
+      MESSAGE(WARNING "Given CUDA arch ${ARCH}, but Kokkos_ENABLE_CUDA, Kokkos_ENABLE_SYCL, Kokkos_ENABLE_OPENACC, and Kokkos_ENABLE_OPENMPTARGET are OFF. Option will be ignored.")
       UNSET(KOKKOS_ARCH_${ARCH} PARENT_SCOPE)
     ELSE()
       IF(KOKKOS_ENABLE_CUDA)
@@ -585,15 +669,9 @@ FUNCTION(CHECK_CUDA_ARCH ARCH FLAG)
       IF(KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
         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})
-          GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "${CUDA_ARCH_FLAG}=${NVHPC_CUDA_ARCH}")
-          GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${CUDA_ARCH_FLAG}=${NVHPC_CUDA_ARCH}")
-        ELSE()
-          GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "${CUDA_ARCH_FLAG}=${FLAG}")
-          IF(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE OR KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
-            GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${CUDA_ARCH_FLAG}=${FLAG}")
-          ENDIF()
+        GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS "${CUDA_ARCH_FLAG}=${FLAG}")
+        IF(KOKKOS_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE OR KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+          GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${CUDA_ARCH_FLAG}=${FLAG}")
         ENDIF()
       ENDIF()
     ENDIF()
@@ -631,18 +709,20 @@ FUNCTION(CHECK_AMDGPU_ARCH ARCH FLAG)
       MESSAGE(FATAL_ERROR "Multiple GPU architectures given! Already have ${AMDGPU_ARCH_ALREADY_SPECIFIED}, but trying to add ${ARCH}. If you are re-running CMake, try clearing the cache and running again.")
     ENDIF()
     SET(AMDGPU_ARCH_ALREADY_SPECIFIED ${ARCH} PARENT_SCOPE)
-    IF (NOT KOKKOS_ENABLE_HIP AND NOT KOKKOS_ENABLE_OPENMPTARGET)
-      MESSAGE(WARNING "Given AMD GPU architecture ${ARCH}, but Kokkos_ENABLE_HIP and Kokkos_ENABLE_OPENMPTARGET are OFF. Option will be ignored.")
+    IF (NOT KOKKOS_ENABLE_HIP AND NOT KOKKOS_ENABLE_OPENMPTARGET AND NOT KOKKOS_ENABLE_OPENACC AND NOT KOKKOS_ENABLE_SYCL)
+      MESSAGE(WARNING "Given AMD GPU architecture ${ARCH}, but Kokkos_ENABLE_HIP, Kokkos_ENABLE_SYCL, Kokkos_ENABLE_OPENACC, 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)
-        GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${AMDGPU_ARCH_FLAG}=${FLAG}")
-      ENDIF()
+        IF(KOKKOS_ENABLE_HIP)
+          SET(KOKKOS_HIP_ARCHITECTURES ${FLAG} PARENT_SCOPE)
+        ENDIF()
+        IF(NOT KOKKOS_IMPL_AMDGPU_FLAGS)
+          SET(KOKKOS_AMDGPU_ARCH_FLAG ${FLAG} PARENT_SCOPE)
+          GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS "${AMDGPU_ARCH_FLAG}=${FLAG}")
+        ENDIF()
+        IF(KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE)
+          GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${AMDGPU_ARCH_FLAG}=${FLAG}")
+        ENDIF()
     ENDIF()
   ENDIF()
 ENDFUNCTION()
@@ -655,6 +735,15 @@ FOREACH(ARCH IN LISTS SUPPORTED_AMD_ARCHS)
   CHECK_AMDGPU_ARCH(${ARCH} ${FLAG})
 ENDFOREACH()
 
+IF(KOKKOS_IMPL_AMDGPU_FLAGS)
+  IF (NOT AMDGPU_ARCH_ALREADY_SPECIFIED)
+    MESSAGE(FATAL_ERROR "When IMPL_AMDGPU_FLAGS is set the architecture autodectection is disabled. "
+      "Please explicitly set the GPU architecture.")
+  ENDIF()
+  GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS "${KOKKOS_IMPL_AMDGPU_FLAGS}")
+  GLOBAL_APPEND(KOKKOS_LINK_OPTIONS "${KOKKOS_IMPL_AMDGPU_LINK}")
+ENDIF()
+
 MACRO(SET_AND_CHECK_AMD_ARCH ARCH FLAG)
   KOKKOS_SET_OPTION(ARCH_${ARCH} ON)
   CHECK_AMDGPU_ARCH(${ARCH} ${FLAG})
@@ -715,38 +804,51 @@ IF (KOKKOS_ENABLE_OPENMPTARGET)
     COMPILER_SPECIFIC_FLAGS(
       IntelLLVM -fopenmp-targets=spir64 -D__STRICT_ANSI__
     )
-  ELSEIF(KOKKOS_ARCH_INTEL_GEN9)
-    COMPILER_SPECIFIC_FLAGS(
-      IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device gen9" -D__STRICT_ANSI__
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_GEN11)
-    COMPILER_SPECIFIC_FLAGS(
-      IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device gen11" -D__STRICT_ANSI__
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_GEN12LP)
-    COMPILER_SPECIFIC_FLAGS(
-      IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device gen12lp" -D__STRICT_ANSI__
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_DG1)
-    COMPILER_SPECIFIC_FLAGS(
-      IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device dg1" -D__STRICT_ANSI__
-    )
-  ELSEIF(KOKKOS_ARCH_INTEL_XEHP)
-    COMPILER_SPECIFIC_FLAGS(
-      IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device 12.50.4" -D__STRICT_ANSI__
+  ELSE()
+    COMPILER_SPECIFIC_OPTIONS(
+      IntelLLVM -fopenmp-targets=spir64_gen -D__STRICT_ANSI__
     )
-  ELSEIF(KOKKOS_ARCH_INTEL_PVC)
-    COMPILER_SPECIFIC_FLAGS(
-      IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device 12.60.7" -D__STRICT_ANSI__
+    IF(KOKKOS_ARCH_INTEL_GEN9)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device gen9"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_GEN11)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device gen11"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_GEN12LP)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device gen12lp"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_DG1)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device dg1"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_XEHP)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device 12.50.4"
+      )
+    ELSEIF(KOKKOS_ARCH_INTEL_PVC)
+      COMPILER_SPECIFIC_LINK_OPTIONS(
+        IntelLLVM -fopenmp-targets=spir64_gen -Xopenmp-target-backend "-device 12.60.7"
     )
+    ENDIF()
   ENDIF()
 ENDIF()
 
 IF (KOKKOS_ENABLE_OPENACC)
   IF(KOKKOS_CUDA_ARCH_FLAG)
+    SET(CLANG_CUDA_ARCH ${KOKKOS_CUDA_ARCH_FLAG})
     STRING(REPLACE "sm_" "cc" NVHPC_CUDA_ARCH ${KOKKOS_CUDA_ARCH_FLAG})
     COMPILER_SPECIFIC_FLAGS(
       NVHPC -acc -gpu=${NVHPC_CUDA_ARCH}
+      Clang -Xopenmp-target=nvptx64-nvidia-cuda -march=${CLANG_CUDA_ARCH}
+            -fopenmp-targets=nvptx64-nvidia-cuda
+    )
+  ELSEIF(KOKKOS_AMDGPU_ARCH_FLAG)
+    COMPILER_SPECIFIC_FLAGS(
+      Clang -Xopenmp-target=amdgcn-amd-amdhsa -march=${KOKKOS_AMDGPU_ARCH_FLAG}
+            -fopenmp-targets=amdgcn-amd-amdhsa
     )
   ELSE()
     COMPILER_SPECIFIC_FLAGS(
@@ -764,6 +866,14 @@ IF (KOKKOS_ENABLE_SYCL)
     ELSE()
       MESSAGE(SEND_ERROR "Setting a CUDA architecture for SYCL is only allowed with Kokkos_ENABLE_UNSUPPORTED_ARCHS=ON!")
     ENDIF()
+  ELSEIF(AMDGPU_ARCH_ALREADY_SPECIFIED)
+    IF(KOKKOS_ENABLE_UNSUPPORTED_ARCHS)
+      COMPILER_SPECIFIC_FLAGS(
+        DEFAULT -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=${KOKKOS_AMDGPU_ARCH_FLAG}
+      )
+    ELSE()
+      MESSAGE(SEND_ERROR "Setting a AMDGPU architecture for SYCL is only allowed with Kokkos_ENABLE_UNSUPPORTED_ARCHS=ON!")
+    ENDIF()
   ELSEIF(KOKKOS_ARCH_INTEL_GEN)
     COMPILER_SPECIFIC_FLAGS(
       DEFAULT -fsycl-targets=spir64
@@ -894,7 +1004,7 @@ IF (KOKKOS_ARCH_HOPPER90)
 ENDIF()
 
 #HIP detection of gpu arch
-IF(KOKKOS_ENABLE_HIP AND NOT AMDGPU_ARCH_ALREADY_SPECIFIED)
+IF(KOKKOS_ENABLE_HIP AND NOT AMDGPU_ARCH_ALREADY_SPECIFIED AND NOT KOKKOS_IMPL_AMDGPU_FLAGS)
   FIND_PROGRAM(ROCM_ENUMERATOR rocm_agent_enumerator)
   IF(NOT ROCM_ENUMERATOR)
     MESSAGE(FATAL_ERROR "Autodetection of AMD GPU architecture not possible as "
@@ -929,9 +1039,45 @@ IF(KOKKOS_ENABLE_HIP AND NOT AMDGPU_ARCH_ALREADY_SPECIFIED)
   ENDIF()
 ENDIF()
 
+FOREACH(ARCH IN LISTS SUPPORTED_AMD_ARCHS)
+  IF (KOKKOS_ARCH_${ARCH})
+    STRING(REGEX MATCH "90A" IS_90A ${ARCH})
+    IF(IS_90A)
+      SET(KOKKOS_ARCH_AMD_GFX90A ON)
+      SET(KOKKOS_ARCH_VEGA90A ON)
+      BREAK()
+    ENDIF()
+    STRING(REGEX MATCH "908" IS_908 ${ARCH})
+    IF(IS_908)
+      SET(KOKKOS_ARCH_AMD_GFX908 ON)
+      SET(KOKKOS_ARCH_VEGA908 ON)
+      BREAK()
+    ENDIF()
+    STRING(REGEX MATCH "906" IS_906 ${ARCH})
+    IF(IS_906)
+      SET(KOKKOS_ARCH_AMD_GFX906 ON)
+      SET(KOKKOS_ARCH_VEGA906 ON)
+      BREAK()
+    ENDIF()
+    STRING(REGEX MATCH "1100" IS_1100 ${ARCH})
+    IF(IS_1100)
+      SET(KOKKOS_ARCH_AMD_GFX1100 ON)
+      SET(KOKKOS_ARCH_NAVI1100 ON)
+      BREAK()
+    ENDIF()
+    STRING(REGEX MATCH "1030" IS_1030 ${ARCH})
+    IF(IS_1030)
+      SET(KOKKOS_ARCH_AMD_GFX1030 ON)
+      SET(KOKKOS_ARCH_NAVI1030 ON)
+      BREAK()
+    ENDIF()
+  ENDIF()
+ENDFOREACH()
+
 #Regardless of version, make sure we define the general architecture name
 FOREACH(ARCH IN LISTS SUPPORTED_AMD_ARCHS)
   IF (KOKKOS_ARCH_${ARCH})
+    SET(KOKKOS_ARCH_AMD_GPU ON)
     STRING(REGEX MATCH "(VEGA)" IS_VEGA ${ARCH})
     IF(IS_VEGA)
       SET(KOKKOS_ARCH_VEGA ON)
@@ -1026,3 +1172,14 @@ MESSAGE(STATUS "Architectures:")
 FOREACH(Arch ${KOKKOS_ENABLED_ARCH_LIST})
   MESSAGE(STATUS " ${Arch}")
 ENDFOREACH()
+
+
+IF(KOKKOS_ENABLE_ATOMICS_BYPASS)
+  IF(NOT _HOST_PARALLEL STREQUAL "NoTypeDefined" OR NOT _DEVICE_PARALLEL STREQUAL "NoTypeDefined")
+    MESSAGE(FATAL_ERROR "Not allowed to disable atomics (via -DKokkos_ENABLE_AROMICS_BYPASS=ON) if neither a host parallel nor a device backend is enabled!")
+  ENDIF()
+  IF(NOT KOKKOS_ENABLE_SERIAL)
+    MESSAGE(FATAL_ERROR "Implementation bug")  # safeguard
+  ENDIF()
+  MESSAGE(STATUS "Atomics: **DISABLED**")
+ENDIF()
diff --git a/cmake/kokkos_compiler_id.cmake b/cmake/kokkos_compiler_id.cmake
index fc4c06ce2b..e8bfadb64e 100644
--- a/cmake/kokkos_compiler_id.cmake
+++ b/cmake/kokkos_compiler_id.cmake
@@ -42,10 +42,9 @@ IF(Kokkos_ENABLE_CUDA)
     # If launcher was found and nvcc_wrapper was not specified as
     # compiler and `CMAKE_CXX_COMPILIER_LAUNCHER` is not set, set to use launcher.
     # Will ensure CMAKE_CXX_COMPILER is replaced by nvcc_wrapper
-    IF(Kokkos_COMPILE_LAUNCHER AND NOT INTERNAL_HAVE_COMPILER_NVCC AND NOT KOKKOS_CXX_COMPILER_ID STREQUAL Clang AND NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
+    IF(Kokkos_COMPILE_LAUNCHER AND NOT INTERNAL_HAVE_COMPILER_NVCC AND NOT KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
       IF(CMAKE_CXX_COMPILER_LAUNCHER)
-       MESSAGE(FATAL_ERROR "Cannot use CMAKE_CXX_COMPILER_LAUNCHER if the CMAKE_CXX_COMPILER is not able to compile CUDA code, i.e. nvcc_wrapper or
-clang++!")
+        MESSAGE(FATAL_ERROR "Cannot use CMAKE_CXX_COMPILER_LAUNCHER if the CMAKE_CXX_COMPILER is not able to compile CUDA code, i.e. nvcc_wrapper or clang++!")
       ENDIF()
       # the first argument to launcher is always the C++ compiler defined by cmake
       # if the second argument matches the C++ compiler, it forwards the rest of the
@@ -146,55 +145,85 @@ IF(KOKKOS_CXX_COMPILER_ID STREQUAL Fujitsu)
 ENDIF()
 
 # Enforce the minimum compilers supported by Kokkos.
-SET(KOKKOS_MESSAGE_TEXT "Compiler not supported by Kokkos.  Required compiler versions:")
-SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang(CPU)         8.0.0 or higher")
-SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang(CUDA)       10.0.0 or higher")
-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) 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")
-SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    MSVC               19.29 or higher")
-SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    XL/XLClang           not supported")
+IF(NOT CMAKE_CXX_STANDARD)
+  SET(CMAKE_CXX_STANDARD 17)
+ENDIF()
+IF(CMAKE_CXX_STANDARD EQUAL 17)
+  SET(KOKKOS_CLANG_CPU_MINIMUM             8.0.0)
+  SET(KOKKOS_CLANG_CUDA_MINIMUM           10.0.0)
+  SET(KOKKOS_CLANG_OPENMPTARGET_MINIMUM   15.0.0)
+  SET(KOKKOS_GCC_MINIMUM                   8.2.0)
+  SET(KOKKOS_INTEL_MINIMUM                19.0.5)
+  SET(KOKKOS_INTEL_LLVM_CPU_MINIMUM     2021.1.1)
+  SET(KOKKOS_INTEL_LLVM_SYCL_MINIMUM    2023.0.0)
+  SET(KOKKOS_NVCC_MINIMUM                 11.0.0)
+  SET(KOKKOS_HIPCC_MINIMUM                 5.2.0)
+  SET(KOKKOS_NVHPC_MINIMUM                  22.3)
+  SET(KOKKOS_MSVC_MINIMUM                  19.29)
+ELSE()
+  SET(KOKKOS_CLANG_CPU_MINIMUM            14.0.0)
+  SET(KOKKOS_CLANG_CUDA_MINIMUM           14.0.0)
+  SET(KOKKOS_CLANG_OPENMPTARGET_MINIMUM   15.0.0)
+  SET(KOKKOS_GCC_MINIMUM                  10.1.0)
+  SET(KOKKOS_INTEL_MINIMUM                "not supported")
+  SET(KOKKOS_INTEL_LLVM_CPU_MINIMUM     2022.0.0)
+  SET(KOKKOS_INTEL_LLVM_SYCL_MINIMUM    2023.0.0)
+  SET(KOKKOS_NVCC_MINIMUM                 12.0.0)
+  SET(KOKKOS_HIPCC_MINIMUM                 5.2.0)
+  SET(KOKKOS_NVHPC_MINIMUM                22.3)
+  SET(KOKKOS_MSVC_MINIMUM                 19.30)
+ENDIF()
+
+SET(KOKKOS_MESSAGE_TEXT "Compiler not supported by Kokkos for C++${CMAKE_CXX_STANDARD}. Required minimum compiler versions:")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang(CPU)          ${KOKKOS_CLANG_CPU_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang(CUDA)         ${KOKKOS_CLANG_CUDA_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Clang(OpenMPTarget) ${KOKKOS_CLANG_OPENMPTARGET_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    GCC                 ${KOKKOS_GCC_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    Intel               ${KOKKOS_INTEL_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    IntelLLVM(CPU)      ${KOKKOS_INTEL_LLVM_CPU_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    IntelLLVM(SYCL)     ${KOKKOS_INTEL_LLVM_SYCL_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    NVCC                ${KOKKOS_NVCC_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    HIPCC               ${KOKKOS_HIPCC_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    NVHPC/PGI           ${KOKKOS_NVHPC_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    MSVC                ${KOKKOS_MSVC_MINIMUM}")
+SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\n    XL/XLClang          not supported")
 SET(KOKKOS_MESSAGE_TEXT "${KOKKOS_MESSAGE_TEXT}\nCompiler: ${KOKKOS_CXX_COMPILER_ID} ${KOKKOS_CXX_COMPILER_VERSION}\n")
 
 IF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang AND NOT Kokkos_ENABLE_CUDA)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 8.0.0)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_CLANG_CPU_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang AND Kokkos_ENABLE_CUDA)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 10.0.0)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_CLANG_CUDA_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL GNU)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 8.2.0)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_GCC_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL Intel)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 19.0.5)
+  IF((NOT CMAKE_CXX_STANDARD EQUAL 17) OR (KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_INTEL_MINIMUM}))
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL IntelLLVM AND NOT Kokkos_ENABLE_SYCL)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 2021.1.1)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_INTEL_LLVM_CPU_MINIMUM})
     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 2023.0.0)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_INTEL_LLVM_SYCL_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 11.0.0)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_NVCC_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
   SET(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Kokkos turns off CXX extensions" FORCE)
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL HIPCC)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 5.2.0)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_HIPCC_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL PGI OR KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 22.3)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_NVHPC_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
   # Treat PGI internally as NVHPC to simplify handling both compilers.
@@ -202,11 +231,15 @@ ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL PGI OR KOKKOS_CXX_COMPILER_ID STREQUAL NV
   # backward-compatible to pgc++.
   SET(KOKKOS_CXX_COMPILER_ID NVHPC CACHE STRING INTERNAL FORCE)
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL "MSVC")
-  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 19.29)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS ${KOKKOS_MSVC_MINIMUM})
     MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
   ENDIF()
 ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL XL OR KOKKOS_CXX_COMPILER_ID STREQUAL XLClang)
   MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang AND Kokkos_ENABLE_OPENMPTARGET)
+  IF(KOKKOS_CXX_COMPILER_VERSION VERSION_LESS KOKKOS_CLANG_OPENMPTARGET_MINIMUM)
+    MESSAGE(FATAL_ERROR "${KOKKOS_MESSAGE_TEXT}")
+  ENDIF()
 ENDIF()
 
 IF(NOT DEFINED KOKKOS_CXX_HOST_COMPILER_ID)
diff --git a/cmake/kokkos_enable_devices.cmake b/cmake/kokkos_enable_devices.cmake
index d4a7744eb5..c7d189285c 100644
--- a/cmake/kokkos_enable_devices.cmake
+++ b/cmake/kokkos_enable_devices.cmake
@@ -40,7 +40,37 @@ ELSE()
 ENDIF()
 KOKKOS_DEVICE_OPTION(OPENMP ${OMP_DEFAULT} HOST "Whether to build OpenMP backend")
 
+
+# We want this to default to OFF for cache reasons, but if no
+# host space is given, then activate serial
+IF (KOKKOS_HAS_TRILINOS)
+  #However, Trilinos always wants Serial ON
+  SET(SERIAL_DEFAULT ON)
+ELSEIF (KOKKOS_HAS_HOST)
+  SET(SERIAL_DEFAULT OFF)
+ELSE()
+  SET(SERIAL_DEFAULT ON)
+  IF (NOT DEFINED Kokkos_ENABLE_SERIAL)
+    MESSAGE(STATUS "SERIAL backend is being turned on to ensure there is at least one Host space. To change this, you must enable another host execution space and configure with -DKokkos_ENABLE_SERIAL=OFF or change CMakeCache.txt")
+  ENDIF()
+ENDIF()
+KOKKOS_DEVICE_OPTION(SERIAL ${SERIAL_DEFAULT} HOST "Whether to build serial backend")
+
+KOKKOS_DEVICE_OPTION(HPX OFF HOST "Whether to build HPX backend (experimental)")
+
+# Device backends have to come after host backends for header include order reasons
+# Without this we can't make e.g. CudaSpace accessible by HostSpace
 KOKKOS_DEVICE_OPTION(OPENACC OFF DEVICE "Whether to build the OpenACC backend")
+IF (KOKKOS_ENABLE_OPENACC)
+  COMPILER_SPECIFIC_FLAGS(
+    Clang -fopenacc -fopenacc-fake-async-wait
+          -Wno-openacc-and-cxx -Wno-openmp-mapping -Wno-unknown-cuda-version
+          -Wno-pass-failed
+  )
+  COMPILER_SPECIFIC_DEFS(
+    Clang KOKKOS_WORKAROUND_OPENMPTARGET_CLANG
+  )
+ENDIF()
 
 KOKKOS_DEVICE_OPTION(OPENMPTARGET OFF DEVICE "Whether to build the OpenMP target backend")
 IF (KOKKOS_ENABLE_OPENMPTARGET)
@@ -80,23 +110,6 @@ IF (KOKKOS_ENABLE_CUDA)
   LIST(APPEND DEVICE_SETUP_LIST Cuda)
 ENDIF()
 
-# We want this to default to OFF for cache reasons, but if no
-# host space is given, then activate serial
-IF (KOKKOS_HAS_TRILINOS)
-  #However, Trilinos always wants Serial ON
-  SET(SERIAL_DEFAULT ON)
-ELSEIF (KOKKOS_HAS_HOST)
-  SET(SERIAL_DEFAULT OFF)
-ELSE()
-  SET(SERIAL_DEFAULT ON)
-  IF (NOT DEFINED Kokkos_ENABLE_SERIAL)
-    MESSAGE(STATUS "SERIAL backend is being turned on to ensure there is at least one Host space. To change this, you must enable another host execution space and configure with -DKokkos_ENABLE_SERIAL=OFF or change CMakeCache.txt")
-  ENDIF()
-ENDIF()
-KOKKOS_DEVICE_OPTION(SERIAL ${SERIAL_DEFAULT} HOST "Whether to build serial backend")
-
-KOKKOS_DEVICE_OPTION(HPX OFF HOST "Whether to build HPX backend (experimental)")
-
 KOKKOS_DEVICE_OPTION(HIP OFF DEVICE "Whether to build HIP backend")
 
 ## HIP has extra setup requirements, turn on Kokkos_Setup_HIP.hpp in macros
diff --git a/cmake/kokkos_enable_options.cmake b/cmake/kokkos_enable_options.cmake
index 435fe47ab1..b900c4a232 100644
--- a/cmake/kokkos_enable_options.cmake
+++ b/cmake/kokkos_enable_options.cmake
@@ -43,9 +43,11 @@ ELSE()
 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" )
+# May be used to disable our use of CudaMallocAsync.  It had caused issues in
+# the past when UCX was used as MPI communication layer.  We expect it is
+# resolved but we keep the option around a bit longer to be safe.
+KOKKOS_ENABLE_OPTION(IMPL_CUDA_MALLOC_ASYNC ON  "Whether to enable CudaMallocAsync (requires CUDA Toolkit 11.2)")
+KOKKOS_ENABLE_OPTION(IMPL_NVHPC_AS_DEVICE_COMPILER OFF "Whether to allow nvc++ as Cuda device compiler")
 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")
@@ -68,13 +70,19 @@ KOKKOS_ENABLE_OPTION(TUNING               OFF "Whether to create bindings for tu
 KOKKOS_ENABLE_OPTION(AGGRESSIVE_VECTORIZATION OFF "Whether to aggressively vectorize loops")
 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")
+KOKKOS_ENABLE_OPTION(IMPL_HIP_UNIFIED_MEMORY OFF "Whether to leverage unified memory architectures for HIP")
 
 # This option will go away eventually, but allows fallback to old implementation when needed.
 KOKKOS_ENABLE_OPTION(DESUL_ATOMICS_EXTERNAL OFF "Whether to use an external desul installation")
+KOKKOS_ENABLE_OPTION(ATOMICS_BYPASS OFF "**NOT RECOMMENDED** Whether to make atomics non-atomic for non-threaded MPI-only use cases")
+KOKKOS_ENABLE_OPTION(IMPL_REF_COUNT_BRANCH_UNLIKELY ON "Whether to use the C++20 `[[unlikely]]` attribute in the view reference counting")
+mark_as_advanced(Kokkos_ENABLE_IMPL_REF_COUNT_BRANCH_UNLIKELY)
+KOKKOS_ENABLE_OPTION(IMPL_VIEW_OF_VIEWS_DESTRUCTOR_PRECONDITION_VIOLATION_WORKAROUND OFF "Whether to enable a workaround for invalid use of View of Views that causes program hang on destruction.")
+mark_as_advanced(Kokkos_ENABLE_IMPL_VIEW_OF_VIEWS_DESTRUCTOR_PRECONDITION_VIOLATION_WORKAROUND)
 
-KOKKOS_ENABLE_OPTION(IMPL_MDSPAN OFF "Whether to enable experimental mdspan support")
+KOKKOS_ENABLE_OPTION(IMPL_MDSPAN ON "Whether to enable experimental mdspan support")
 KOKKOS_ENABLE_OPTION(MDSPAN_EXTERNAL OFF BOOL "Whether to use an external version of mdspan")
-KOKKOS_ENABLE_OPTION(IMPL_SKIP_COMPILER_MDSPAN OFF BOOL "Whether to use an internal version of mdspan even if the compiler supports mdspan")
+KOKKOS_ENABLE_OPTION(IMPL_SKIP_COMPILER_MDSPAN ON BOOL "Whether to use an internal version of mdspan even if the compiler supports mdspan")
 mark_as_advanced(Kokkos_ENABLE_IMPL_MDSPAN)
 mark_as_advanced(Kokkos_ENABLE_MDSPAN_EXTERNAL)
 mark_as_advanced(Kokkos_ENABLE_IMPL_SKIP_COMPILER_MDSPAN)
diff --git a/cmake/kokkos_functions.cmake b/cmake/kokkos_functions.cmake
index 9dab1ca00e..d1f1e0d7a7 100644
--- a/cmake/kokkos_functions.cmake
+++ b/cmake/kokkos_functions.cmake
@@ -709,7 +709,12 @@ MACRO(kokkos_find_imported NAME)
   ENDIF()
 
   IF (NOT TPL_LIBRARY_SUFFIXES)
-    SET(TPL_LIBRARY_SUFFIXES lib lib64)
+    SET(TPL_LIBRARY_SUFFIXES lib)
+    IF(KOKKOS_IMPL_32BIT)
+      LIST(APPEND TPL_LIBRARY_SUFFIXES lib32)
+    ELSE()
+      LIST(APPEND TPL_LIBRARY_SUFFIXES lib64)
+    ENDIF()
   ENDIF()
 
   SET(${NAME}_INCLUDE_DIRS)
diff --git a/cmake/kokkos_pick_cxx_std.cmake b/cmake/kokkos_pick_cxx_std.cmake
index d4eca651d4..ae14a10d53 100644
--- a/cmake/kokkos_pick_cxx_std.cmake
+++ b/cmake/kokkos_pick_cxx_std.cmake
@@ -7,6 +7,7 @@ KOKKOS_OPTION(CXX_STANDARD "" STRING "[[DEPRECATED - USE CMAKE_CXX_STANDARD INST
 SET(KOKKOS_ENABLE_CXX17 OFF)
 SET(KOKKOS_ENABLE_CXX20 OFF)
 SET(KOKKOS_ENABLE_CXX23 OFF)
+SET(KOKKOS_ENABLE_CXX26 OFF)
 IF (KOKKOS_CXX_STANDARD)
   MESSAGE(FATAL_ERROR "Setting the variable Kokkos_CXX_STANDARD in configuration is deprecated - set CMAKE_CXX_STANDARD directly instead")
 ENDIF()
diff --git a/cmake/kokkos_test_cxx_std.cmake b/cmake/kokkos_test_cxx_std.cmake
index 5f8e15cd67..5b45674e05 100644
--- a/cmake/kokkos_test_cxx_std.cmake
+++ b/cmake/kokkos_test_cxx_std.cmake
@@ -74,6 +74,10 @@ ELSEIF(KOKKOS_CXX_STANDARD STREQUAL "23")
   kokkos_set_cxx_standard_feature(23)
   SET(KOKKOS_CXX_INTERMEDIATE_STANDARD "2B")
   SET(KOKKOS_ENABLE_CXX23 ON)
+ELSEIF(KOKKOS_CXX_STANDARD STREQUAL "26")
+  kokkos_set_cxx_standard_feature(26)
+  SET(KOKKOS_CXX_INTERMEDIATE_STANDARD "2C")
+  SET(KOKKOS_ENABLE_CXX26 ON)
 ELSE()
   MESSAGE(FATAL_ERROR "Kokkos requires C++17 or newer but requested ${KOKKOS_CXX_STANDARD}!")
 ENDIF()
@@ -120,8 +124,8 @@ IF(KOKKOS_ENABLE_CUDA)
     ELSEIF(CMAKE_CXX_EXTENSIONS)
       MESSAGE(FATAL_ERROR "Compiling CUDA code with clang doesn't support C++ extensions.  Set -DCMAKE_CXX_EXTENSIONS=OFF")
     ENDIF()
-  ELSEIF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA AND NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
-    MESSAGE(FATAL_ERROR "Invalid compiler for CUDA.  The compiler must be nvcc_wrapper or Clang or NVC++ or use kokkos_launch_compiler, but compiler ID was ${KOKKOS_CXX_COMPILER_ID}")
+  ELSEIF(NOT KOKKOS_CXX_COMPILER_ID STREQUAL NVIDIA)
+    MESSAGE(FATAL_ERROR "Invalid compiler for CUDA. The compiler must be nvcc_wrapper or Clang or use kokkos_launch_compiler, but compiler ID was ${KOKKOS_CXX_COMPILER_ID}")
   ENDIF()
 ENDIF()
 
diff --git a/cmake/kokkos_tpls.cmake b/cmake/kokkos_tpls.cmake
index c902e9f0e5..cda9e0d600 100644
--- a/cmake/kokkos_tpls.cmake
+++ b/cmake/kokkos_tpls.cmake
@@ -32,20 +32,27 @@ FUNCTION(KOKKOS_TPL_OPTION PKG DEFAULT)
 ENDFUNCTION()
 
 KOKKOS_TPL_OPTION(HWLOC   Off TRIBITS HWLOC)
-KOKKOS_TPL_OPTION(MEMKIND Off)
-IF(KOKKOS_ENABLE_MEMKIND)
-  SET(KOKKOS_ENABLE_HBWSPACE ON)
-ENDIF()
 KOKKOS_TPL_OPTION(CUDA    ${Kokkos_ENABLE_CUDA} TRIBITS CUDA)
-KOKKOS_TPL_OPTION(LIBRT   Off)
 IF(KOKKOS_ENABLE_HIP AND NOT KOKKOS_CXX_COMPILER_ID STREQUAL HIPCC AND NOT
     KOKKOS_HAS_TRILINOS)
   SET(ROCM_DEFAULT ON)
 ELSE()
   SET(ROCM_DEFAULT OFF)
 ENDIF()
+IF(KOKKOS_ENABLE_HIP AND NOT KOKKOS_HAS_TRILINOS)
+  SET(ROCTHRUST_DEFAULT ON)
+ELSE()
+  SET(ROCTHRUST_DEFAULT OFF)
+ENDIF()
 KOKKOS_TPL_OPTION(ROCM    ${ROCM_DEFAULT})
-KOKKOS_TPL_OPTION(ONEDPL  ${Kokkos_ENABLE_SYCL})
+KOKKOS_TPL_OPTION(ROCTHRUST ${ROCTHRUST_DEFAULT})
+
+IF(KOKKOS_ENABLE_SYCL AND NOT KOKKOS_HAS_TRILINOS)
+  SET(ONEDPL_DEFAULT ON)
+ELSE()
+  SET(ONEDPL_DEFAULT OFF)
+ENDIF()
+KOKKOS_TPL_OPTION(ONEDPL  ${ONEDPL_DEFAULT})
 
 IF (WIN32)
   SET(LIBDL_DEFAULT Off)
@@ -72,21 +79,18 @@ KOKKOS_TPL_OPTION(LIBQUADMATH ${LIBQUADMATH_DEFAULT} TRIBITS quadmath)
 
 #Make sure we use our local FindKokkosCuda.cmake
 KOKKOS_IMPORT_TPL(HPX INTERFACE)
-IF (NOT KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
-  KOKKOS_IMPORT_TPL(CUDA INTERFACE)
-ENDIF()
+KOKKOS_IMPORT_TPL(CUDA INTERFACE)
 KOKKOS_IMPORT_TPL(HWLOC)
-KOKKOS_IMPORT_TPL(LIBRT)
 KOKKOS_IMPORT_TPL(LIBDL)
-KOKKOS_IMPORT_TPL(MEMKIND)
 IF (NOT WIN32)
   KOKKOS_IMPORT_TPL(THREADS INTERFACE)
 ENDIF()
 IF (NOT KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
   KOKKOS_IMPORT_TPL(ROCM INTERFACE)
-  KOKKOS_IMPORT_TPL(ONEDPL INTERFACE)
 ENDIF()
+KOKKOS_IMPORT_TPL(ONEDPL INTERFACE)
 KOKKOS_IMPORT_TPL(LIBQUADMATH)
+KOKKOS_IMPORT_TPL(ROCTHRUST)
 
 IF (Kokkos_ENABLE_DESUL_ATOMICS_EXTERNAL)
   find_package(desul REQUIRED COMPONENTS atomics)
@@ -99,13 +103,19 @@ if (Kokkos_ENABLE_IMPL_MDSPAN AND Kokkos_ENABLE_MDSPAN_EXTERNAL)
 endif()
 
 IF (Kokkos_ENABLE_OPENMP)
-  find_package(OpenMP REQUIRED)
+  find_package(OpenMP REQUIRED COMPONENTS CXX)
   # FIXME_TRILINOS Trilinos doesn't allow for Kokkos to use find_dependency
   # so we just append the flags here instead of linking with the OpenMP target.
   IF(KOKKOS_HAS_TRILINOS)
     COMPILER_SPECIFIC_FLAGS(DEFAULT ${OpenMP_CXX_FLAGS})
   ELSE()
-    KOKKOS_EXPORT_CMAKE_TPL(OpenMP REQUIRED)
+    KOKKOS_EXPORT_CMAKE_TPL(OpenMP REQUIRED COMPONENTS CXX)
+  ENDIF()
+  IF(Kokkos_ENABLE_HIP AND KOKKOS_COMPILE_LANGUAGE STREQUAL HIP)
+    GLOBAL_APPEND(KOKKOS_AMDGPU_OPTIONS ${OpenMP_CXX_FLAGS})
+  ENDIF()
+  IF(Kokkos_ENABLE_CUDA AND KOKKOS_COMPILE_LANGUAGE STREQUAL CUDA)
+    GLOBAL_APPEND(KOKKOS_CUDA_OPTIONS -Xcompiler ${OpenMP_CXX_FLAGS})
   ENDIF()
 ENDIF()
 
@@ -114,7 +124,3 @@ STRING(REPLACE ";" "\n" KOKKOS_TPL_EXPORT_TEMP "${KOKKOS_TPL_EXPORTS}")
 #Convert to a regular variable
 UNSET(KOKKOS_TPL_EXPORTS CACHE)
 SET(KOKKOS_TPL_EXPORTS ${KOKKOS_TPL_EXPORT_TEMP})
-IF (KOKKOS_ENABLE_MEMKIND)
-   SET(KOKKOS_ENABLE_HBWSPACE)
-   LIST(APPEND KOKKOS_MEMSPACE_LIST HBWSpace)
-ENDIF()
diff --git a/cmake/kokkos_tribits.cmake b/cmake/kokkos_tribits.cmake
index 01ea7efd8a..6da543a2c8 100644
--- a/cmake/kokkos_tribits.cmake
+++ b/cmake/kokkos_tribits.cmake
@@ -51,6 +51,7 @@ MACRO(KOKKOS_PROCESS_SUBPACKAGES)
   ADD_SUBDIRECTORY(simd)
   if (NOT KOKKOS_HAS_TRILINOS)
     ADD_SUBDIRECTORY(example)
+    ADD_SUBDIRECTORY(benchmarks)
   endif()
 ENDMACRO()
 
@@ -159,6 +160,12 @@ FUNCTION(KOKKOS_ADD_EXECUTABLE_AND_TEST ROOT_NAME)
             )
         ENDIF()
     ENDIF()
+    # We noticed problems with -fvisibility=hidden for inline static variables
+    # if Kokkos was built as shared library.
+    IF(BUILD_SHARED_LIBS)
+      SET_PROPERTY(TARGET ${PACKAGE_NAME}_${ROOT_NAME} PROPERTY VISIBILITY_INLINES_HIDDEN ON)
+      SET_PROPERTY(TARGET ${PACKAGE_NAME}_${ROOT_NAME} PROPERTY CXX_VISIBILITY_PRESET hidden)
+    ENDIF()
 ENDFUNCTION()
 
 FUNCTION(KOKKOS_SET_EXE_PROPERTY ROOT_NAME)
@@ -236,46 +243,10 @@ ENDMACRO()
 ##                        KOKKOS_DECLARE is the declaration set
 ##                        KOKKOS_POST_INCLUDE is included at the end of Kokkos_Core.hpp
 MACRO(KOKKOS_CONFIGURE_CORE)
-   SET(FWD_BACKEND_LIST)
-   FOREACH(MEMSPACE ${KOKKOS_MEMSPACE_LIST})
-      LIST(APPEND FWD_BACKEND_LIST ${MEMSPACE})
-   ENDFOREACH()
-   FOREACH(BACKEND_ ${KOKKOS_ENABLED_DEVICES})
-      LIST(APPEND FWD_BACKEND_LIST ${BACKEND_})
-   ENDFOREACH()
-   MESSAGE(STATUS "Kokkos Devices: ${KOKKOS_ENABLED_DEVICES}, Kokkos Backends: ${FWD_BACKEND_LIST}")
-   KOKKOS_CONFIG_HEADER( KokkosCore_Config_HeaderSet.in KokkosCore_Config_FwdBackend.hpp "KOKKOS_FWD" "fwd/Kokkos_Fwd" "${FWD_BACKEND_LIST}")
+   MESSAGE(STATUS "Kokkos Backends: ${KOKKOS_ENABLED_DEVICES}")
+   KOKKOS_CONFIG_HEADER( KokkosCore_Config_HeaderSet.in KokkosCore_Config_FwdBackend.hpp "KOKKOS_FWD" "fwd/Kokkos_Fwd" "${KOKKOS_ENABLED_DEVICES}")
    KOKKOS_CONFIG_HEADER( KokkosCore_Config_HeaderSet.in KokkosCore_Config_SetupBackend.hpp "KOKKOS_SETUP" "setup/Kokkos_Setup" "${DEVICE_SETUP_LIST}")
-   KOKKOS_CONFIG_HEADER( KokkosCore_Config_HeaderSet.in KokkosCore_Config_DeclareBackend.hpp "KOKKOS_DECLARE" "decl/Kokkos_Declare" "${FWD_BACKEND_LIST}")
-   KOKKOS_CONFIG_HEADER( KokkosCore_Config_HeaderSet.in KokkosCore_Config_PostInclude.hpp "KOKKOS_POST_INCLUDE" "Kokkos_Post_Include" "${KOKKOS_BACKEND_POST_INCLUDE_LIST}")
-   SET(_DEFAULT_HOST_MEMSPACE "::Kokkos::HostSpace")
-   KOKKOS_OPTION(DEFAULT_DEVICE_MEMORY_SPACE "" STRING "Override default device memory space")
-   KOKKOS_OPTION(DEFAULT_HOST_MEMORY_SPACE "" STRING "Override default host memory space")
-   KOKKOS_OPTION(DEFAULT_DEVICE_EXECUTION_SPACE "" STRING "Override default device execution space")
-   KOKKOS_OPTION(DEFAULT_HOST_PARALLEL_EXECUTION_SPACE "" STRING "Override default host parallel execution space")
-   IF (NOT Kokkos_DEFAULT_DEVICE_EXECUTION_SPACE STREQUAL "")
-      SET(_DEVICE_PARALLEL ${Kokkos_DEFAULT_DEVICE_EXECUTION_SPACE})
-      MESSAGE(STATUS "Override default device execution space: ${_DEVICE_PARALLEL}")
-      SET(KOKKOS_DEVICE_SPACE_ACTIVE ON)
-   ELSE()
-      IF (_DEVICE_PARALLEL STREQUAL "NoTypeDefined")
-         SET(KOKKOS_DEVICE_SPACE_ACTIVE OFF)
-      ELSE()
-         SET(KOKKOS_DEVICE_SPACE_ACTIVE ON)
-      ENDIF()
-   ENDIF()
-   IF (NOT Kokkos_DEFAULT_HOST_PARALLEL_EXECUTION_SPACE STREQUAL "")
-      SET(_HOST_PARALLEL ${Kokkos_DEFAULT_HOST_PARALLEL_EXECUTION_SPACE})
-      MESSAGE(STATUS "Override default host parallel execution space: ${_HOST_PARALLEL}")
-      SET(KOKKOS_HOSTPARALLEL_SPACE_ACTIVE ON)
-   ELSE()
-      IF (_HOST_PARALLEL STREQUAL "NoTypeDefined")
-         SET(KOKKOS_HOSTPARALLEL_SPACE_ACTIVE OFF)
-      ELSE()
-         SET(KOKKOS_HOSTPARALLEL_SPACE_ACTIVE ON)
-      ENDIF()
-   ENDIF()
-   #We are ready to configure the header
+   KOKKOS_CONFIG_HEADER( KokkosCore_Config_HeaderSet.in KokkosCore_Config_DeclareBackend.hpp "KOKKOS_DECLARE" "decl/Kokkos_Declare" "${KOKKOS_ENABLED_DEVICES}")
    CONFIGURE_FILE(cmake/KokkosCore_config.h.in KokkosCore_config.h @ONLY)
 ENDMACRO()
 
@@ -308,7 +279,6 @@ MACRO(KOKKOS_INSTALL_ADDITIONAL_FILES)
           "${CMAKE_CURRENT_BINARY_DIR}/KokkosCore_Config_FwdBackend.hpp"
           "${CMAKE_CURRENT_BINARY_DIR}/KokkosCore_Config_SetupBackend.hpp"
           "${CMAKE_CURRENT_BINARY_DIR}/KokkosCore_Config_DeclareBackend.hpp"
-          "${CMAKE_CURRENT_BINARY_DIR}/KokkosCore_Config_PostInclude.hpp"
           DESTINATION ${KOKKOS_HEADER_DIR})
 ENDMACRO()
 
@@ -492,15 +462,10 @@ ENDFUNCTION()
 
 
 FUNCTION(KOKKOS_LIB_INCLUDE_DIRECTORIES TARGET)
-  IF(KOKKOS_HAS_TRILINOS)
-    #ignore the target, tribits doesn't do anything directly with targets
-    TRIBITS_INCLUDE_DIRECTORIES(${ARGN})
-  ELSE() #append to a list for later
-    KOKKOS_LIB_TYPE(${TARGET} INCTYPE)
-    FOREACH(DIR ${ARGN})
-      TARGET_INCLUDE_DIRECTORIES(${TARGET} ${INCTYPE} $<BUILD_INTERFACE:${DIR}>)
-    ENDFOREACH()
-  ENDIF()
+  KOKKOS_LIB_TYPE(${TARGET} INCTYPE)
+  FOREACH(DIR ${ARGN})
+    TARGET_INCLUDE_DIRECTORIES(${TARGET} ${INCTYPE} $<BUILD_INTERFACE:${DIR}>)
+  ENDFOREACH()
 ENDFUNCTION()
 
 FUNCTION(KOKKOS_LIB_COMPILE_OPTIONS TARGET)
@@ -531,3 +496,11 @@ MACRO(KOKKOS_ADD_EXAMPLE_DIRECTORIES)
     ENDIF()
   endif()
 ENDMACRO()
+
+MACRO(KOKKOS_ADD_BENCHMARK_DIRECTORIES)
+  IF(KOKKOS_ENABLE_BENCHMARKS)
+    FOREACH(BENCHMARK_DIR ${ARGN})
+      ADD_SUBDIRECTORY(${BENCHMARK_DIR})
+    ENDFOREACH()
+  ENDIF()
+ENDMACRO()
diff --git a/cmake/tpls/FindTPLCUSPARSE.cmake b/cmake/tpls/FindTPLCUSPARSE.cmake
deleted file mode 100644
index 4709f8002b..0000000000
--- a/cmake/tpls/FindTPLCUSPARSE.cmake
+++ /dev/null
@@ -1,26 +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.
-#
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#@HEADER
-
-# Check for CUDA support
-
-IF (NOT TPL_ENABLE_CUDA)
-  MESSAGE(FATAL_ERROR "\nCUSPARSE requires CUDA")
-ELSE()
-  GLOBAL_SET(TPL_CUSPARSE_LIBRARY_DIRS)
-  GLOBAL_SET(TPL_CUSPARSE_INCLUDE_DIRS ${TPL_CUDA_INCLUDE_DIRS})
-  GLOBAL_SET(TPL_CUSPARSE_LIBRARIES    ${CUDA_cusparse_LIBRARY})
-ENDIF()
-
diff --git a/config/test_all_sandia b/config/test_all_sandia
deleted file mode 100755
index 193a162a4e..0000000000
--- a/config/test_all_sandia
+++ /dev/null
@@ -1,773 +0,0 @@
-#!/bin/bash -e
-
-#
-# Global config
-#
-
-set -o pipefail
-
-# Determine current machine.
-
-MACHINE=""
-HOSTNAME=$(hostname)
-PROCESSOR=`uname -p`
-
-if [[ "$HOSTNAME" =~ (white|ride).* ]]; then
-  MACHINE=white
-  module load git
-fi
-
-if [[ "$HOSTNAME" =~ .*bowman.* ]]; then
-  MACHINE=bowman
-  module load git
-fi
-
-if [[ "$HOSTNAME" == n* ]]; then # Warning: very generic name
-  if [[ "$PROCESSOR" = "aarch64" ]]; then
-    MACHINE=sullivan
-    module load git
-  fi
-fi
-
-if [[ "$HOSTNAME" == node* ]]; then # Warning: very generic name
-  if [[ "$MACHINE" = "" ]]; then
-    MACHINE=shepard
-    module load git
-  fi
-fi
-
-if [[ "$HOSTNAME" == apollo\.* ]]; then
-  MACHINE=apollo
-  module load git
-fi
-
-if [[ "$HOSTNAME" == sullivan ]]; then
-  MACHINE=sullivan
-  module load git
-fi
-
-if [[ "$HOSTNAME" == mayer\.* ]]; then
-  MACHINE=mayer
-#  module load git
-fi
-if [[ "$HOSTNAME" == cn* ]]; then # Warning: very generic name
-  MACHINE=mayer
-fi
-
-if [ ! -z "$SEMS_MODULEFILES_ROOT" ]; then
-  if [[ "$MACHINE" = "" ]]; then
-    MACHINE=sems
-    module load sems-git
-  fi  
-fi
-
-if [[ "$MACHINE" = "" ]]; then
-  echo "Unrecognized machine" >&2
-  exit 1
-fi
-
-echo "Running on machine: $MACHINE"
-
-GCC_BUILD_LIST="OpenMP,Pthread,Serial,OpenMP_Serial,Pthread_Serial"
-IBM_BUILD_LIST="OpenMP,Serial,OpenMP_Serial"
-ARM_GCC_BUILD_LIST="OpenMP,Serial,OpenMP_Serial"
-INTEL_BUILD_LIST="OpenMP,Pthread,Serial,OpenMP_Serial,Pthread_Serial"
-CLANG_BUILD_LIST="Pthread,Serial,Pthread_Serial"
-CUDA_BUILD_LIST="Cuda_OpenMP,Cuda_Pthread,Cuda_Serial"
-CUDA_IBM_BUILD_LIST="Cuda_OpenMP,Cuda_Serial"
-
-GCC_WARNING_FLAGS="-Wall,-Wunused-parameter,-Wshadow,-pedantic,-Werror,-Wsign-compare,-Wtype-limits,-Wignored-qualifiers,-Wempty-body,-Wclobbered,-Wuninitialized"
-IBM_WARNING_FLAGS="-Wall,-Wunused-parameter,-Wshadow,-pedantic,-Werror,-Wsign-compare,-Wtype-limits,-Wuninitialized"
-CLANG_WARNING_FLAGS="-Wall,-Wunused-parameter,-Wshadow,-pedantic,-Werror,-Wsign-compare,-Wtype-limits,-Wuninitialized"
-INTEL_WARNING_FLAGS="-Wall,-Wunused-parameter,-Wshadow,-pedantic,-Werror,-Wsign-compare,-Wtype-limits,-Wuninitialized"
-#CUDA_WARNING_FLAGS="-Wall,-Wunused-parameter,-Wshadow,-pedantic,-Werror,-Wsign-compare,-Wtype-limits,-Wuninitialized"
-CUDA_WARNING_FLAGS="-Wall,-Wunused-parameter,-Wshadow,-pedantic,-Wsign-compare,-Wtype-limits,-Wuninitialized"
-PGI_WARNING_FLAGS=""
-
-# Default. Machine specific can override.
-DEBUG=False
-ARGS=""
-CUSTOM_BUILD_LIST=""
-DRYRUN=False
-BUILD_ONLY=False
-declare -i NUM_JOBS_TO_RUN_IN_PARALLEL=1
-TEST_SCRIPT=False
-SKIP_HWLOC=False
-SPOT_CHECK=False
-
-PRINT_HELP=False
-OPT_FLAG=""
-CXX_FLAGS_EXTRA=""
-LD_FLAGS_EXTRA=""
-KOKKOS_OPTIONS=""
-
-#
-# Handle arguments.
-#
-
-while [[ $# > 0 ]]
-do
-  key="$1"
-
-  case $key in
-    --kokkos-path*)
-      KOKKOS_PATH="${key#*=}"
-      ;;
-    --build-list*)
-      CUSTOM_BUILD_LIST="${key#*=}"
-      ;;
-    --debug*)
-      DEBUG=True
-      ;;
-    --build-only*)
-      BUILD_ONLY=True
-      ;;
-    --test-script*)
-      TEST_SCRIPT=True
-      ;;
-    --skip-hwloc*)
-      SKIP_HWLOC=True
-      ;;
-    --num*)
-      NUM_JOBS_TO_RUN_IN_PARALLEL="${key#*=}"
-      ;;
-    --dry-run*)
-      DRYRUN=True
-      ;;
-    --spot-check*)
-      SPOT_CHECK=True
-      ;;
-    --arch*)
-      ARCH_FLAG="--arch=${key#*=}"
-      ;;
-    --opt-flag*)
-      OPT_FLAG="${key#*=}"
-      ;;
-    --with-cuda-options*)
-      KOKKOS_CUDA_OPTIONS="--with-cuda-options=${key#*=}"
-      ;;
-    --with-options*)
-      KOKKOS_OPTIONS="--with-options=enable_large_mem_tests,${key#*=}"
-      ;;
-    --cxxflags-extra*)
-      CXX_FLAGS_EXTRA="${key#*=}"
-      ;;
-    --ldflags-extra*)
-      LD_FLAGS_EXTRA="${key#*=}"
-      ;;
-    --help*)
-      PRINT_HELP=True
-      ;;
-    *)
-      # args, just append
-      ARGS="$ARGS $1"
-      ;;
-  esac
-
-  shift
-done
-
-SCRIPT_KOKKOS_ROOT=$( cd "$( dirname "$0" )" && cd .. && pwd )
-
-# Set kokkos path.
-if [ -z "$KOKKOS_PATH" ]; then
-  KOKKOS_PATH=$SCRIPT_KOKKOS_ROOT
-else
-  # Ensure KOKKOS_PATH is abs path.
-  KOKKOS_PATH=$( cd $KOKKOS_PATH && pwd )
-fi
-
-UNCOMMITTED=`cd ${KOKKOS_PATH}; git status --porcelain 2>/dev/null`
-if ! [ -z "$UNCOMMITTED" ]; then
-  echo "WARNING!! THE FOLLOWING CHANGES ARE UNCOMMITTED!! :"
-  echo "$UNCOMMITTED"
-  echo ""
-fi
-
-GITSTATUS=`cd ${KOKKOS_PATH}; git log -n 1 --format=oneline`
-echo "Repository Status: " ${GITSTATUS}
-echo ""
-echo ""
-
-#
-# Machine specific config.
-#
-
-if [ "$MACHINE" = "sems" ]; then
-  source /projects/sems/modulefiles/utils/sems-modules-init.sh
-
-  BASE_MODULE_LIST="sems-env,kokkos-env,kokkos-hwloc/1.10.1/base,sems-<COMPILER_NAME>/<COMPILER_VERSION>"
-  CUDA_MODULE_LIST="sems-env,kokkos-env,kokkos-<COMPILER_NAME>/<COMPILER_VERSION>,sems-gcc/4.8.4,kokkos-hwloc/1.10.1/base"
-  CUDA8_MODULE_LIST="sems-env,kokkos-env,kokkos-<COMPILER_NAME>/<COMPILER_VERSION>,sems-gcc/5.3.0,kokkos-hwloc/1.10.1/base"
-
-  if [ -z "$ARCH_FLAG" ]; 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/6.1.0 $BASE_MODULE_LIST "Serial" g++ $GCC_WARNING_FLAGS"
-               "intel/17.0.1 $BASE_MODULE_LIST "OpenMP" icpc $INTEL_WARNING_FLAGS"
-               "clang/3.9.0 $BASE_MODULE_LIST "Pthread_Serial" clang++ $CLANG_WARNING_FLAGS"
-               "cuda/8.0.44 $CUDA8_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/4.8.4 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/4.9.3 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_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"
-               "intel/15.0.2 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/16.0.1 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/16.0.3 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "clang/3.6.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/3.7.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/3.8.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/3.9.0 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "cuda/7.0.28 $CUDA_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/7.5.18 $CUDA_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "cuda/8.0.44 $CUDA8_MODULE_LIST $CUDA_BUILD_LIST $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-    )
-  fi
-elif [ "$MACHINE" = "white" ]; then
-  source /etc/profile.d/modules.sh
-  SKIP_HWLOC=True
-  export SLURM_TASKS_PER_NODE=32
-
-  BASE_MODULE_LIST="<COMPILER_NAME>/<COMPILER_VERSION>"
-  IBM_MODULE_LIST="<COMPILER_NAME>/xl/<COMPILER_VERSION>"
-  CUDA_MODULE_LIST="<COMPILER_NAME>/<COMPILER_VERSION>,gcc/6.4.0,ibm/xl/16.1.0"
-
-  # Don't do pthread on white.
-  GCC_BUILD_LIST="OpenMP,Serial,OpenMP_Serial"
-
-  # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("gcc/5.4.0 $BASE_MODULE_LIST $IBM_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-             "gcc/6.4.0 $BASE_MODULE_LIST $IBM_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-             "ibm/16.1.0 $IBM_MODULE_LIST $IBM_BUILD_LIST xlC $IBM_WARNING_FLAGS"
-             "cuda/9.0.103 $CUDA_MODULE_LIST $CUDA_IBM_BUILD_LIST ${KOKKOS_PATH}/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-  )
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=Power8,Kepler37"
-  fi
-
-  NUM_JOBS_TO_RUN_IN_PARALLEL=1
-
-elif [ "$MACHINE" = "bowman" ]; then
-  source /etc/profile.d/modules.sh
-  SKIP_HWLOC=True
-  export SLURM_TASKS_PER_NODE=32
-
-  BASE_MODULE_LIST="<COMPILER_NAME>/compilers/<COMPILER_VERSION>"
-
-  OLD_INTEL_BUILD_LIST="Pthread,Serial,Pthread_Serial"
-
-  # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("intel/16.4.258 $BASE_MODULE_LIST $OLD_INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "intel/17.2.174 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "intel/18.0.128 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-  )
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=KNL"
-  fi
-
-  NUM_JOBS_TO_RUN_IN_PARALLEL=1
-
-elif [ "$MACHINE" = "sullivan" ]; then
-  source /etc/profile.d/modules.sh
-  SKIP_HWLOC=True
-  export SLURM_TASKS_PER_NODE=96
-
-  BASE_MODULE_LIST="<COMPILER_NAME>/<COMPILER_VERSION>"
-
-  # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("gcc/6.1.0 $BASE_MODULE_LIST $ARM_GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS")
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=ARMv8-ThunderX"
-  fi
-
-  NUM_JOBS_TO_RUN_IN_PARALLEL=1
-
-elif [ "$MACHINE" = "mayer" ]; then
-  SKIP_HWLOC=True
-  export SLURM_TASKS_PER_NODE=96
-
-  BASE_MODULE_LIST="<COMPILER_NAME>/<COMPILER_VERSION>"
-  ARM_MODULE_LIST="<COMPILER_NAME>/<COMPILER_VERSION>"
-
-  # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("gcc/7.2.0 $BASE_MODULE_LIST $ARM_GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-             "arm/1.4.0 $ARM_MODULE_LIST $ARM_GCC_BUILD_LIST armclang++ $CLANG_WARNING_FLAGS")
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=ARMv8-TX2"
-  fi
-
-  NUM_JOBS_TO_RUN_IN_PARALLEL=1
-
-elif [ "$MACHINE" = "shepard" ]; then
-  source /etc/profile.d/modules.sh
-  SKIP_HWLOC=True
-  export SLURM_TASKS_PER_NODE=32
-
-  BASE_MODULE_LIST="<COMPILER_NAME>/<COMPILER_VERSION>"
-  BASE_MODULE_LIST_INTEL="<COMPILER_NAME>/compilers/<COMPILER_VERSION>"
-
-  # Format: (compiler module-list build-list exe-name warning-flag)
-  COMPILERS=("intel/17.4.196 $BASE_MODULE_LIST_INTEL $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "intel/18.0.128 $BASE_MODULE_LIST_INTEL $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-             "pgi/17.10.0 $BASE_MODULE_LIST $GCC_BUILD_LIST pgc++ $PGI_WARNING_FLAGS"
-  )
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=HSW"
-  fi
-  NUM_JOBS_TO_RUN_IN_PARALLEL=1
-
-elif [ "$MACHINE" = "apollo" ]; then
-  source /projects/sems/modulefiles/utils/sems-modules-init.sh
-  module use /home/projects/modulefiles/local/x86-64
-  module load kokkos-env
-
-  module load sems-git
-  module load sems-tex
-  module load sems-cmake/3.5.2
-  module load sems-gdb
-
-  SKIP_HWLOC=True
-
-  BASE_MODULE_LIST="sems-env,kokkos-env,sems-<COMPILER_NAME>/<COMPILER_VERSION>,kokkos-hwloc/1.10.1/base"
-  CUDA_MODULE_LIST="sems-env,kokkos-env,kokkos-<COMPILER_NAME>/<COMPILER_VERSION>,sems-gcc/4.8.4,kokkos-hwloc/1.10.1/base"
-  CUDA8_MODULE_LIST="sems-env,kokkos-env,kokkos-<COMPILER_NAME>/<COMPILER_VERSION>,sems-gcc/5.3.0,kokkos-hwloc/1.10.1/base"
-
-  CLANG_MODULE_LIST="sems-env,kokkos-env,sems-git,sems-cmake/3.5.2,<COMPILER_NAME>/<COMPILER_VERSION>,cuda/9.0.69"
-  NVCC_MODULE_LIST="sems-env,kokkos-env,sems-git,sems-cmake/3.5.2,<COMPILER_NAME>/<COMPILER_VERSION>,sems-gcc/5.3.0"
-
-  BUILD_LIST_CUDA_NVCC="Cuda_Serial,Cuda_OpenMP"
-  BUILD_LIST_CUDA_CLANG="Cuda_Serial,Cuda_Pthread"
-  BUILD_LIST_CLANG="Serial,Pthread,OpenMP"
-
-  if [ "$SPOT_CHECK" = "True" ]; then
-    # Format: (compiler module-list build-list exe-name warning-flag)
-    COMPILERS=("gcc/4.8.4 $BASE_MODULE_LIST "OpenMP,Pthread" g++ $GCC_WARNING_FLAGS"
-               "gcc/5.3.0 $BASE_MODULE_LIST "Serial" g++ $GCC_WARNING_FLAGS"
-               "intel/16.0.1 $BASE_MODULE_LIST "OpenMP" icpc $INTEL_WARNING_FLAGS"
-               "clang/3.9.0 $BASE_MODULE_LIST "Pthread_Serial" clang++ $CLANG_WARNING_FLAGS"
-               "clang/6.0 $CLANG_MODULE_LIST "Cuda_Pthread,OpenMP" clang++ $CUDA_WARNING_FLAGS"
-               "cuda/9.1 $CUDA_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/9.1 $CUDA8_MODULE_LIST $BUILD_LIST_CUDA_NVCC $KOKKOS_PATH/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-               "clang/6.0 $CLANG_MODULE_LIST $BUILD_LIST_CUDA_CLANG clang++ $CUDA_WARNING_FLAGS"
-               "clang/3.9.0 $CLANG_MODULE_LIST $BUILD_LIST_CLANG clang++ $CLANG_WARNING_FLAGS"
-               "gcc/4.8.4 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-               "gcc/4.9.3 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_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"
-               "intel/15.0.2 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/16.0.1 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "intel/17.0.1 $BASE_MODULE_LIST $INTEL_BUILD_LIST icpc $INTEL_WARNING_FLAGS"
-               "clang/3.5.2 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-               "clang/3.6.1 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
-    )
-  fi
-
-  if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=SNB,Volta70"
-  fi
-
-  NUM_JOBS_TO_RUN_IN_PARALLEL=1
-
-else
-  echo "Unhandled machine $MACHINE" >&2
-  exit 1
-fi
-
-export OMP_NUM_THREADS=4
-
-declare -i NUM_RESULTS_TO_KEEP=7
-
-RESULT_ROOT_PREFIX=TestAll
-
-if [ "$PRINT_HELP" = "True" ]; then
-  echo "test_all_sandia <ARGS> <OPTIONS>:"
-  echo "--kokkos-path=/Path/To/Kokkos: Path to the Kokkos root directory"
-  echo "    Defaults to root repo containing this script"
-  echo "--debug: Run tests in debug. Defaults to False"
-  echo "--test-script: Test this script, not Kokkos"
-  echo "--skip-hwloc: Do not do hwloc tests"
-  echo "--num=N: Number of jobs to run in parallel"
-  echo "--spot-check: Minimal test set to issue pull request"
-  echo "--dry-run: Just print what would be executed"
-  echo "--build-only: Just do builds, don't run anything"
-  echo "--opt-flag=FLAG: Optimization flag (default: -O3)"
-  echo "--cxxflags-extra=FLAGS: Extra flags to be added to CXX_FLAGS"
-  echo "--ldflags-extra=FLAGS: Extra flags to be added to LD_FLAGS"
-  echo "--arch=ARCHITECTURE: overwrite architecture flags"
-  echo "--with-cuda-options=OPT: set KOKKOS_CUDA_OPTIONS"
-  echo "--build-list=BUILD,BUILD,BUILD..."
-  echo "    Provide a comma-separated list of builds instead of running all builds"
-  echo "    Valid items:"
-  echo "      OpenMP, Pthread, Serial, OpenMP_Serial, Pthread_Serial"
-  echo "      Cuda_OpenMP, Cuda_Pthread, Cuda_Serial"
-  echo ""
-
-  echo "ARGS: list of expressions matching compilers to test"
-  echo "  supported compilers sems"
-  for COMPILER_DATA in "${COMPILERS[@]}"; do
-    ARR=($COMPILER_DATA)
-    COMPILER=${ARR[0]}
-    echo "    $COMPILER"
-  done
-  echo ""
-
-  echo "Examples:"
-  echo "  Run all tests"
-  echo "  % test_all_sandia"
-  echo ""
-  echo "  Run all gcc tests"
-  echo "  % test_all_sandia gcc"
-  echo ""
-  echo "  Run all gcc/4.8.4 and all intel tests"
-  echo "  % test_all_sandia gcc/4.8.4 intel"
-  echo ""
-  echo "  Run all tests in debug"
-  echo "  % test_all_sandia --debug"
-  echo ""
-  echo "  Run gcc/4.8.4 and only do OpenMP and OpenMP_Serial builds"
-  echo "  % test_all_sandia gcc/4.8.4 --build-list=OpenMP,OpenMP_Serial"
-  echo ""
-  echo "If you want to kill the tests, do:"
-  echo "  hit ctrl-z"
-  echo "  % kill -9 %1"
-  echo
-  exit 0
-fi
-
-# Set build type.
-if [ "$DEBUG" = "True" ]; then
-  BUILD_TYPE=debug
-else
-  BUILD_TYPE=release
-fi
-
-# If no args provided, do all compilers.
-if [ -z "$ARGS" ]; then
-  ARGS='?'
-fi
-
-# Process args to figure out which compilers to test.
-COMPILERS_TO_TEST=""
-
-for ARG in $ARGS; do
-  for COMPILER_DATA in "${COMPILERS[@]}"; do
-    ARR=($COMPILER_DATA)
-    COMPILER=${ARR[0]}
-
-    if [[ "$COMPILER" = $ARG* ]]; then
-      if [[ "$COMPILERS_TO_TEST" != *${COMPILER}* ]]; then
-        COMPILERS_TO_TEST="$COMPILERS_TO_TEST $COMPILER"
-      else
-        echo "Tried to add $COMPILER twice"
-      fi
-    fi
-  done
-done
-
-#
-# Functions.
-#
-
-# get_compiler_name <COMPILER>
-get_compiler_name() {
-  echo $1 | cut -d/ -f1
-}
-
-# get_compiler_version <COMPILER>
-get_compiler_version() {
-  echo $1 | cut -d/ -f2
-}
-
-# Do not call directly.
-get_compiler_data() {
-  local compiler=$1
-  local item=$2
-  local compiler_name=$(get_compiler_name $compiler)
-  local compiler_vers=$(get_compiler_version $compiler)
-
-  local compiler_data
-  for compiler_data in "${COMPILERS[@]}" ; do
-    local arr=($compiler_data)
-
-    if [ "$compiler" = "${arr[0]}" ]; then
-      echo "${arr[$item]}" | tr , ' ' | sed -e "s/<COMPILER_NAME>/$compiler_name/g" -e "s/<COMPILER_VERSION>/$compiler_vers/g"
-      return 0
-    fi
-  done
-
-  # Not found.
-  echo "Unreconized compiler $compiler" >&2
-  exit 1
-}
-
-#
-# For all getters, usage: <GETTER> <COMPILER>
-#
-
-get_compiler_modules() {
-  get_compiler_data $1 1
-}
-
-get_compiler_build_list() {
-  get_compiler_data $1 2
-}
-
-get_compiler_exe_name() {
-  get_compiler_data $1 3
-}
-
-get_compiler_warning_flags() {
-  get_compiler_data $1 4
-}
-
-run_cmd() {
-  echo "RUNNING: $*"
-  if [ "$DRYRUN" != "True" ]; then
-    eval "$* 2>&1"
-  fi
-}
-
-# report_and_log_test_results <SUCCESS> <DESC> <COMMENT>
-report_and_log_test_result() {
-  # Use sane var names.
-  local success=$1; local desc=$2; local comment=$3;
-
-  if [ "$success" = "0" ]; then
-    echo "  PASSED $desc"
-    echo $comment > $PASSED_DIR/$desc
-  else
-    # For failures, comment should be the name of the phase that failed.
-    echo "  FAILED $desc" >&2
-    echo $comment > $FAILED_DIR/$desc
-    cat ${desc}.${comment}.log
-  fi
-}
-
-setup_env() {
-  local compiler=$1
-  local compiler_modules=$(get_compiler_modules $compiler)
-
-  module purge
-
-  local mod
-  for mod in $compiler_modules; do
-    echo "Loading module $mod"
-    module load $mod 2>&1
-    # It is ridiculously hard to check for the success of a loaded
-    # module. Module does not return error codes and piping to grep
-    # causes module to run in a subshell.
-    module list 2>&1 | grep "$mod" >& /dev/null || return 1
-  done
-
-  return 0
-}
-
-# single_build_and_test <COMPILER> <BUILD> <BUILD_TYPE>
-single_build_and_test() {
-  # Use sane var names.
-  local compiler=$1; local build=$2; local build_type=$3;
-
-  # Set up env.
-  mkdir -p $ROOT_DIR/$compiler/"${build}-$build_type"
-  cd $ROOT_DIR/$compiler/"${build}-$build_type"
-  local desc=$(echo "${compiler}-${build}-${build_type}" | sed 's:/:-:g')
-  setup_env $compiler >& ${desc}.configure.log || { report_and_log_test_result 1 ${desc} configure && return 0; }
-
-  # Set up flags.
-  local compiler_warning_flags=$(get_compiler_warning_flags $compiler)
-  local compiler_exe=$(get_compiler_exe_name $compiler)
-
-  if [[ "$build_type" = hwloc* ]]; then
-    local extra_args=--with-hwloc=$(dirname $(dirname $(which hwloc-info)))
-  fi
-
-  if [[ "$OPT_FLAG" = "" ]]; then
-    OPT_FLAG="-O3"
-  fi
-
-  if [[ "$build_type" = *debug* ]]; then
-    local extra_args="$extra_args --debug"
-    local cxxflags="-g $compiler_warning_flags"
-    local ldflags="-g"
-  else
-    local cxxflags="$OPT_FLAG $compiler_warning_flags"
-    local ldflags="${OPT_FLAG}"
-  fi
-
-  local cxxflags="${cxxflags} ${CXX_FLAGS_EXTRA}"
-  local ldflags="${ldflags} ${LD_FLAGS_EXTRA}"
-
-  if [[ "$KOKKOS_CUDA_OPTIONS" != "" ]]; then
-    local extra_args="$extra_args $KOKKOS_CUDA_OPTIONS"
-  fi
-  if [[ "$KOKKOS_OPTIONS" != "" ]]; then
-    local extra_args="$extra_args $KOKKOS_OPTIONS"
-  else
-    local extra_args="$extra_args --with-options=enable_large_mem_tests"
-  fi    
-
-  echo "  Starting job $desc"
-
-  local comment="no_comment"
-
-  if [ "$TEST_SCRIPT" = "True" ]; then
-    local rand=$[ 1 + $[ RANDOM % 10 ]]
-    sleep $rand
-
-    if [ $rand -gt 5 ]; then
-      run_cmd ls fake_problem >& ${desc}.configure.log || { report_and_log_test_result 1 $desc configure && return 0; }
-    fi
-  else
-    run_cmd ${KOKKOS_PATH}/generate_makefile.bash --with-devices=$build $ARCH_FLAG --compiler=$(which $compiler_exe) --cxxflags=\"$cxxflags\" --ldflags=\"$ldflags\" $extra_args &>> ${desc}.configure.log || { report_and_log_test_result 1 ${desc} configure && return 0; }
-    local -i build_start_time=$(date +%s)
-    run_cmd make -j 48 build-test >& ${desc}.build.log || { report_and_log_test_result 1 ${desc} build && return 0; }
-    local -i build_end_time=$(date +%s)
-    comment="build_time=$(($build_end_time-$build_start_time))"
-
-    if [[ "$BUILD_ONLY" == False ]]; then
-      run_cmd make test >& ${desc}.test.log || { report_and_log_test_result 1 ${desc} test && return 0; }
-      local -i run_end_time=$(date +%s)
-      comment="$comment run_time=$(($run_end_time-$build_end_time))"
-    fi
-  fi
-
-  report_and_log_test_result 0 $desc "$comment"
-
-  return 0
-}
-
-# wait_for_jobs <NUM-JOBS>
-wait_for_jobs() {
-  local -i max_jobs=$1
-  local -i num_active_jobs=$(jobs | wc -l)
-  while [ $num_active_jobs -ge $max_jobs ]
-  do
-    sleep 1
-    num_active_jobs=$(jobs | wc -l)
-    jobs >& /dev/null
-  done
-}
-
-# run_in_background <COMPILER> <BUILD> <BUILD_TYPE>
-run_in_background() {
-  local compiler=$1
-
-  local -i num_jobs=$NUM_JOBS_TO_RUN_IN_PARALLEL
-  # Don't override command line input.
-  # if [[ "$BUILD_ONLY" == True ]]; then
-  #   num_jobs=8
-  # else
-    if [[ "$compiler" == cuda* ]]; then
-      num_jobs=1
-    fi
-    if [[ "$compiler" == clang ]]; then 
-      num_jobs=1
-    fi
-  # fi
-  wait_for_jobs $num_jobs
-
-  single_build_and_test $* &
-}
-
-# build_and_test_all <COMPILER>
-build_and_test_all() {
-  # Get compiler data.
-  local compiler=$1
-  if [ -z "$CUSTOM_BUILD_LIST" ]; then
-    local compiler_build_list=$(get_compiler_build_list $compiler)
-  else
-    local compiler_build_list=$(echo "$CUSTOM_BUILD_LIST" | tr , ' ')
-  fi
-
-  # Do builds.
-  local build
-  for build in $compiler_build_list
-  do
-    run_in_background $compiler $build $BUILD_TYPE
-
-    # If not cuda, do a hwloc test too.
-    if [[ "$compiler" != cuda* && "$SKIP_HWLOC" == False ]]; then
-      run_in_background $compiler $build "hwloc-$BUILD_TYPE"
-    fi
-  done
-
-  return 0
-}
-
-get_test_root_dir() {
-  local existing_results=$(find . -maxdepth 1 -name "$RESULT_ROOT_PREFIX*" | sort)
-  local -i num_existing_results=$(echo $existing_results | tr ' ' '\n' | wc -l)
-  local -i num_to_delete=${num_existing_results}-${NUM_RESULTS_TO_KEEP}
-
-  if [ $num_to_delete -gt 0 ]; then
-    /bin/rm -rf $(echo $existing_results | tr ' ' '\n' | head -n $num_to_delete)
-  fi
-
-  echo $(pwd)/${RESULT_ROOT_PREFIX}_$(date +"%Y-%m-%d_%H.%M.%S")
-}
-
-wait_summarize_and_exit() {
-  wait_for_jobs 1
-
-  echo "#######################################################"
-  echo "PASSED TESTS"
-  echo "#######################################################"
-
-  local passed_test
-  for passed_test in $(\ls -1 $PASSED_DIR | sort)
-  do
-    echo $passed_test $(cat $PASSED_DIR/$passed_test)
-  done
-
-  local -i rv=0
-  if [ "$(ls -A $FAILED_DIR)" ]; then
-    echo "#######################################################"
-    echo "FAILED TESTS"
-    echo "#######################################################"
-
-    local failed_test
-    for failed_test in $(\ls -1 $FAILED_DIR | sort)
-    do
-      echo $failed_test "("$(cat $FAILED_DIR/$failed_test)" failed)"
-      rv=$rv+1
-    done
-  fi
-
-  exit $rv
-}
-
-#
-# Main.
-#
-
-ROOT_DIR=$(get_test_root_dir)
-mkdir -p $ROOT_DIR
-cd $ROOT_DIR
-
-PASSED_DIR=$ROOT_DIR/results/passed
-FAILED_DIR=$ROOT_DIR/results/failed
-mkdir -p $PASSED_DIR
-mkdir -p $FAILED_DIR
-
-echo "Going to test compilers: " $COMPILERS_TO_TEST
-for COMPILER in $COMPILERS_TO_TEST; do
-  echo "Testing compiler $COMPILER"
-  build_and_test_all $COMPILER
-done
-
-wait_summarize_and_exit
diff --git a/config/yaml/volta.yaml b/config/yaml/volta.yaml
deleted file mode 100644
index f67af9c2a4..0000000000
--- a/config/yaml/volta.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-packages:
- kokkos:
-  variants: +cuda +openmp +volta70 +cuda_lambda +wrapper ^cuda@10.1
-  compiler: [gcc@7.2.0]
diff --git a/containers/performance_tests/TestCuda.cpp b/containers/performance_tests/TestCuda.cpp
index e98595a41e..71b1c1d4ee 100644
--- a/containers/performance_tests/TestCuda.cpp
+++ b/containers/performance_tests/TestCuda.cpp
@@ -44,10 +44,6 @@ TEST(TEST_CATEGORY, dynrankview_perf) {
 }
 
 TEST(TEST_CATEGORY, global_2_local) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  GTEST_SKIP() << "errors reported for all sizes";
-#endif
   std::cout << "Cuda" << std::endl;
   std::cout << "size, create, generate, fill, find" << std::endl;
   for (unsigned i = Performance::begin_id_size; i <= Performance::end_id_size;
diff --git a/containers/src/Kokkos_Bitset.hpp b/containers/src/Kokkos_Bitset.hpp
index 35f691ecf4..f50ab0a0f7 100644
--- a/containers/src/Kokkos_Bitset.hpp
+++ b/containers/src/Kokkos_Bitset.hpp
@@ -70,13 +70,32 @@ class Bitset {
     block_shift = Kokkos::Impl::integral_power_of_two(block_size)
   };
 
+  //! Type of @ref m_blocks.
+  using block_view_type = View<unsigned*, Device, MemoryTraits<RandomAccess>>;
+
  public:
-  /// constructor
+  Bitset() = default;
+
   /// arg_size := number of bit in set
-  Bitset(unsigned arg_size = 0u)
-      : m_size(arg_size),
-        m_last_block_mask(0u),
-        m_blocks("Bitset", ((m_size + block_mask) >> block_shift)) {
+  Bitset(unsigned arg_size) : Bitset(Kokkos::view_alloc(), arg_size) {}
+
+  template <class... P>
+  Bitset(const Impl::ViewCtorProp<P...>& arg_prop, unsigned arg_size)
+      : m_size(arg_size), m_last_block_mask(0u) {
+    //! Ensure that allocation properties are consistent.
+    using alloc_prop_t = std::decay_t<decltype(arg_prop)>;
+    static_assert(alloc_prop_t::initialize,
+                  "Allocation property 'initialize' should be true.");
+    static_assert(
+        !alloc_prop_t::has_pointer,
+        "Allocation properties should not contain the 'pointer' property.");
+
+    //! Update 'label' property and allocate.
+    const auto prop_copy =
+        Impl::with_properties_if_unset(arg_prop, std::string("Bitset"));
+    m_blocks =
+        block_view_type(prop_copy, ((m_size + block_mask) >> block_shift));
+
     for (int i = 0, end = static_cast<int>(m_size & block_mask); i < end; ++i) {
       m_last_block_mask |= 1u << i;
     }
@@ -105,7 +124,7 @@ class Bitset {
   /// number of bits which are set to 1
   /// can only be called from the host
   unsigned count() const {
-    Impl::BitsetCount<Bitset<Device> > f(*this);
+    Impl::BitsetCount<Bitset<Device>> f(*this);
     return f.apply();
   }
 
@@ -273,9 +292,9 @@ class Bitset {
   }
 
  private:
-  unsigned m_size;
-  unsigned m_last_block_mask;
-  View<unsigned*, Device, MemoryTraits<RandomAccess> > m_blocks;
+  unsigned m_size            = 0;
+  unsigned m_last_block_mask = 0;
+  block_view_type m_blocks;
 
  private:
   template <typename DDevice>
@@ -302,6 +321,7 @@ class ConstBitset {
  public:
   using execution_space = typename Device::execution_space;
   using size_type       = unsigned int;
+  using block_view_type = typename Bitset<Device>::block_view_type::const_type;
 
  private:
   enum { block_size = static_cast<unsigned>(sizeof(unsigned) * CHAR_BIT) };
@@ -340,7 +360,7 @@ class ConstBitset {
   unsigned size() const { return m_size; }
 
   unsigned count() const {
-    Impl::BitsetCount<ConstBitset<Device> > f(*this);
+    Impl::BitsetCount<ConstBitset<Device>> f(*this);
     return f.apply();
   }
 
@@ -356,7 +376,7 @@ class ConstBitset {
 
  private:
   unsigned m_size;
-  View<const unsigned*, Device, MemoryTraits<RandomAccess> > m_blocks;
+  block_view_type m_blocks;
 
  private:
   template <typename DDevice>
diff --git a/containers/src/Kokkos_DualView.hpp b/containers/src/Kokkos_DualView.hpp
index e821570a8d..a37a2bdceb 100644
--- a/containers/src/Kokkos_DualView.hpp
+++ b/containers/src/Kokkos_DualView.hpp
@@ -944,13 +944,13 @@ class DualView : public ViewTraits<DataType, Properties...> {
 
     if (sizeMismatch) {
       ::Kokkos::realloc(arg_prop, d_view, n0, n1, n2, n3, n4, n5, n6, n7);
-      if (alloc_prop_input::initialize) {
+      if constexpr (alloc_prop_input::initialize) {
         h_view = create_mirror_view(typename t_host::memory_space(), d_view);
       } else {
         h_view = create_mirror_view(Kokkos::WithoutInitializing,
                                     typename t_host::memory_space(), d_view);
       }
-    } else if (alloc_prop_input::initialize) {
+    } else if constexpr (alloc_prop_input::initialize) {
       if constexpr (alloc_prop_input::has_execution_space) {
         const auto& exec_space =
             Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop);
@@ -1038,12 +1038,10 @@ class DualView : public ViewTraits<DataType, Properties...> {
       /* Resize on Device */
       if (sizeMismatch) {
         ::Kokkos::resize(properties, d_view, n0, n1, n2, n3, n4, n5, n6, n7);
-        if (alloc_prop_input::initialize) {
-          h_view = create_mirror_view(typename t_host::memory_space(), d_view);
-        } else {
-          h_view = create_mirror_view(Kokkos::WithoutInitializing,
-                                      typename t_host::memory_space(), d_view);
-        }
+        // this part of the lambda was relocated in a method as it contains a
+        // `if constexpr`. In some cases, both branches were evaluated
+        // leading to a compile error
+        resync_host(properties);
 
         /* Mark Device copy as modified */
         ++modified_flags(1);
@@ -1054,13 +1052,10 @@ class DualView : public ViewTraits<DataType, Properties...> {
       /* Resize on Host */
       if (sizeMismatch) {
         ::Kokkos::resize(properties, h_view, n0, n1, n2, n3, n4, n5, n6, n7);
-        if (alloc_prop_input::initialize) {
-          d_view = create_mirror_view(typename t_dev::memory_space(), h_view);
-
-        } else {
-          d_view = create_mirror_view(Kokkos::WithoutInitializing,
-                                      typename t_dev::memory_space(), h_view);
-        }
+        // this part of the lambda was relocated in a method as it contains a
+        // `if constexpr`. In some cases, both branches were evaluated
+        // leading to a compile error
+        resync_device(properties);
 
         /* Mark Host copy as modified */
         ++modified_flags(0);
@@ -1099,6 +1094,39 @@ class DualView : public ViewTraits<DataType, Properties...> {
     }
   }
 
+ private:
+  // resync host mirror from device
+  // this code was relocated from a lambda as it contains a `if constexpr`.
+  // In some cases, both branches were evaluated, leading to a compile error
+  template <class... ViewCtorArgs>
+  inline void resync_host(Impl::ViewCtorProp<ViewCtorArgs...> const&) {
+    using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
+
+    if constexpr (alloc_prop_input::initialize) {
+      h_view = create_mirror_view(typename t_host::memory_space(), d_view);
+    } else {
+      h_view = create_mirror_view(Kokkos::WithoutInitializing,
+                                  typename t_host::memory_space(), d_view);
+    }
+  }
+
+  // resync device mirror from host
+  // this code was relocated from a lambda as it contains a `if constexpr`
+  // In some cases, both branches were evaluated leading to a compile error
+  template <class... ViewCtorArgs>
+  inline void resync_device(Impl::ViewCtorProp<ViewCtorArgs...> const&) {
+    using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
+
+    if constexpr (alloc_prop_input::initialize) {
+      d_view = create_mirror_view(typename t_dev::memory_space(), h_view);
+
+    } else {
+      d_view = create_mirror_view(Kokkos::WithoutInitializing,
+                                  typename t_dev::memory_space(), h_view);
+    }
+  }
+
+ public:
   void resize(const size_t n0 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
               const size_t n1 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
               const size_t n2 = KOKKOS_IMPL_CTOR_DEFAULT_ARG,
diff --git a/containers/src/Kokkos_DynRankView.hpp b/containers/src/Kokkos_DynRankView.hpp
index 39d72fb37d..5f7fcaf69e 100644
--- a/containers/src/Kokkos_DynRankView.hpp
+++ b/containers/src/Kokkos_DynRankView.hpp
@@ -221,7 +221,7 @@ KOKKOS_INLINE_FUNCTION bool dyn_rank_view_verify_operator_bounds(
     return (size_t(i) < map.extent(R)) &&
            dyn_rank_view_verify_operator_bounds<R + 1>(rank, map, args...);
   } else if (i != 0) {
-    KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+    Kokkos::printf(
         "DynRankView Debug Bounds Checking Error: at rank %u\n  Extra "
         "arguments beyond the rank must be zero \n",
         R);
@@ -1340,7 +1340,7 @@ class ViewMapping<
 
   template <class MemoryTraits>
   struct apply {
-    static_assert(Kokkos::is_memory_traits<MemoryTraits>::value, "");
+    static_assert(Kokkos::is_memory_traits<MemoryTraits>::value);
 
     using traits_type =
         Kokkos::ViewTraits<data_type, array_layout,
@@ -1653,8 +1653,16 @@ KOKKOS_FUNCTION auto as_view_of_rank_n(
         Kokkos::abort("Converting DynRankView to a View of mis-matched rank!");)
   }
 
-  return View<typename RankDataType<T, N>::type, Args...>(
-      v.data(), v.impl_map().layout());
+  auto layout = v.impl_map().layout();
+
+  if constexpr (std::is_same_v<decltype(layout), Kokkos::LayoutLeft> ||
+                std::is_same_v<decltype(layout), Kokkos::LayoutRight> ||
+                std::is_same_v<decltype(layout), Kokkos::LayoutStride>) {
+    for (int i = N; i < 7; ++i)
+      layout.dimension[i] = KOKKOS_IMPL_CTOR_DEFAULT_ARG;
+  }
+
+  return View<typename RankDataType<T, N>::type, Args...>(v.data(), layout);
 }
 
 template <typename Function, typename... Args>
@@ -1924,254 +1932,155 @@ struct MirrorDRVType {
 }  // namespace Impl
 
 namespace Impl {
-template <class T, class... P, class... ViewCtorArgs>
-inline typename DynRankView<T, P...>::HostMirror create_mirror(
-    const DynRankView<T, P...>& src,
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    std::enable_if_t<!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
-        nullptr) {
-  using src_type = DynRankView<T, P...>;
-  using dst_type = typename src_type::HostMirror;
 
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-
-  static_assert(
-      !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
-      "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
+// create a mirror
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs>
+inline auto create_mirror(const DynRankView<T, P...>& src,
+                          const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
+  check_view_ctor_args_create_mirror<ViewCtorArgs...>();
 
   auto prop_copy = Impl::with_properties_if_unset(
       arg_prop, std::string(src.label()).append("_mirror"));
 
-  return dst_type(prop_copy, Impl::reconstructLayout(src.layout(), src.rank()));
-}
-
-template <class T, class... P, class... ViewCtorArgs>
-inline auto create_mirror(
-    const DynRankView<T, P...>& src,
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    std::enable_if_t<Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
-        nullptr) {
-  using dst_type = typename Impl::MirrorDRVType<
-      typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-      P...>::view_type;
-
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-
-  static_assert(
-      !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
-      "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
+  if constexpr (Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    using dst_type = typename Impl::MirrorDRVType<
+        typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
+        P...>::view_type;
 
-  auto prop_copy = Impl::with_properties_if_unset(
-      arg_prop, std::string(src.label()).append("_mirror"));
+    return dst_type(prop_copy,
+                    Impl::reconstructLayout(src.layout(), src.rank()));
+  } else {
+    using src_type = DynRankView<T, P...>;
+    using dst_type = typename src_type::HostMirror;
 
-  return dst_type(prop_copy, Impl::reconstructLayout(src.layout(), src.rank()));
+    return dst_type(prop_copy,
+                    Impl::reconstructLayout(src.layout(), src.rank()));
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 
 }  // namespace Impl
 
-// Create a mirror in host space
-template <class T, class... P>
-inline typename DynRankView<T, P...>::HostMirror create_mirror(
-    const DynRankView<T, P...>& src,
-    std::enable_if_t<std::is_same<typename ViewTraits<T, P...>::specialize,
-                                  void>::value>* = nullptr) {
-  return Impl::create_mirror(src, Kokkos::Impl::ViewCtorProp<>{});
+// public interface
+template <class T, class... P,
+          class Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+inline auto create_mirror(const DynRankView<T, P...>& src) {
+  return Impl::create_mirror(src, Kokkos::view_alloc());
 }
 
-template <class T, class... P>
-inline typename DynRankView<T, P...>::HostMirror create_mirror(
-    Kokkos::Impl::WithoutInitializing_t wi, const DynRankView<T, P...>& src,
-    std::enable_if_t<std::is_same<typename ViewTraits<T, P...>::specialize,
-                                  void>::value>* = nullptr) {
+// public interface that accepts a without initializing flag
+template <class T, class... P,
+          class Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+inline auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi,
+                          const DynRankView<T, P...>& src) {
   return Impl::create_mirror(src, Kokkos::view_alloc(wi));
 }
 
-template <class T, class... P, class... ViewCtorArgs>
-inline typename DynRankView<T, P...>::HostMirror create_mirror(
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    const DynRankView<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* = nullptr) {
-  return Impl::create_mirror(src, arg_prop);
-}
-
-// Create a mirror in a new space
+// public interface that accepts a space
 template <class Space, class T, class... P,
-          typename Enable = std::enable_if_t<
+          class Enable = std::enable_if_t<
               Kokkos::is_space<Space>::value &&
-              std::is_void<typename ViewTraits<T, P...>::specialize>::value>>
-typename Impl::MirrorDRVType<Space, T, P...>::view_type create_mirror(
-    const Space&, const Kokkos::DynRankView<T, P...>& src) {
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+auto create_mirror(const Space&, const Kokkos::DynRankView<T, P...>& src) {
   return Impl::create_mirror(
       src, Kokkos::view_alloc(typename Space::memory_space{}));
 }
 
-template <class Space, class T, class... P>
-typename Impl::MirrorDRVType<Space, T, P...>::view_type create_mirror(
-    Kokkos::Impl::WithoutInitializing_t wi, const Space&,
-    const Kokkos::DynRankView<T, P...>& src,
-    std::enable_if_t<std::is_same<typename ViewTraits<T, P...>::specialize,
-                                  void>::value>* = nullptr) {
+// public interface that accepts a space and a without initializing flag
+template <class Space, class T, class... P,
+          class Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
+                   const Kokkos::DynRankView<T, P...>& src) {
   return Impl::create_mirror(
       src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
 }
 
-template <class T, class... P, class... ViewCtorArgs>
-inline auto create_mirror(
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    const DynRankView<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* = nullptr) {
-  using ReturnType = typename Impl::MirrorDRVType<
-      typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-      P...>::view_type;
-  return ReturnType{Impl::create_mirror(src, arg_prop)};
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs,
+          typename Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+inline auto create_mirror(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
+                          const DynRankView<T, P...>& src) {
+  return Impl::create_mirror(src, arg_prop);
 }
 
 namespace Impl {
-template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        std::is_same<
-            typename DynRankView<T, P...>::memory_space,
-            typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
-        std::is_same<
-            typename DynRankView<T, P...>::data_type,
-            typename DynRankView<T, P...>::HostMirror::data_type>::value,
-    typename DynRankView<T, P...>::HostMirror>
-create_mirror_view(const DynRankView<T, P...>& src,
-                   const typename Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
-}
 
+// create a mirror view
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        !(std::is_same<
-              typename DynRankView<T, P...>::memory_space,
-              typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
-          std::is_same<
-              typename DynRankView<T, P...>::data_type,
-              typename DynRankView<T, P...>::HostMirror::data_type>::value),
-    typename DynRankView<T, P...>::HostMirror>
-create_mirror_view(
+inline auto create_mirror_view(
     const DynRankView<T, P...>& src,
-    const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::Impl::create_mirror(src, arg_prop);
-}
-
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-inline std::enable_if_t<
-    Kokkos::is_space<
-        typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space>::value &&
-        Impl::MirrorDRViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace,
-    typename Impl::MirrorDRViewType<
-        typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-        P...>::view_type>
-create_mirror_view(const Kokkos::DynRankView<T, P...>& src,
-                   const typename Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
+    [[maybe_unused]] const typename Impl::ViewCtorProp<ViewCtorArgs...>&
+        arg_prop) {
+  if constexpr (!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    if constexpr (std::is_same<typename DynRankView<T, P...>::memory_space,
+                               typename DynRankView<
+                                   T, P...>::HostMirror::memory_space>::value &&
+                  std::is_same<typename DynRankView<T, P...>::data_type,
+                               typename DynRankView<
+                                   T, P...>::HostMirror::data_type>::value) {
+      return typename DynRankView<T, P...>::HostMirror(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  } else {
+    if constexpr (Impl::MirrorDRViewType<typename Impl::ViewCtorProp<
+                                             ViewCtorArgs...>::memory_space,
+                                         T, P...>::is_same_memspace) {
+      return typename Impl::MirrorDRViewType<
+          typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
+          P...>::view_type(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-inline std::enable_if_t<
-    Kokkos::is_space<
-        typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space>::value &&
-        !Impl::MirrorDRViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace,
-    typename Impl::MirrorDRViewType<
-        typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-        P...>::view_type>
-create_mirror_view(
-    const Kokkos::DynRankView<T, P...>& src,
-    const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::Impl::create_mirror(src, arg_prop);
-}
 }  // namespace Impl
 
-// Create a mirror view in host space
-template <class T, class... P>
-inline std::enable_if_t<
-    (std::is_same<
-         typename DynRankView<T, P...>::memory_space,
-         typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
-     std::is_same<typename DynRankView<T, P...>::data_type,
-                  typename DynRankView<T, P...>::HostMirror::data_type>::value),
-    typename DynRankView<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::DynRankView<T, P...>& src) {
-  return src;
-}
-
+// public interface
 template <class T, class... P>
-inline std::enable_if_t<
-    !(std::is_same<
-          typename DynRankView<T, P...>::memory_space,
-          typename DynRankView<T, P...>::HostMirror::memory_space>::value &&
-      std::is_same<
-          typename DynRankView<T, P...>::data_type,
-          typename DynRankView<T, P...>::HostMirror::data_type>::value),
-    typename DynRankView<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::DynRankView<T, P...>& src) {
-  return Kokkos::create_mirror(src);
+inline auto create_mirror_view(const Kokkos::DynRankView<T, P...>& src) {
+  return Impl::create_mirror_view(src, Kokkos::view_alloc());
 }
 
+// public interface that accepts a without initializing flag
 template <class T, class... P>
 inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
                                const DynRankView<T, P...>& src) {
   return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
 }
 
-// Create a mirror view in a new space
-// FIXME_C++17 Improve SFINAE here.
+// public interface that accepts a space
 template <class Space, class T, class... P,
           class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-inline typename Impl::MirrorDRViewType<Space, T, P...>::view_type
-create_mirror_view(
-    const Space&, const Kokkos::DynRankView<T, P...>& src,
-    std::enable_if_t<
-        Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>* = nullptr) {
-  return src;
+inline auto create_mirror_view(const Space&,
+                               const Kokkos::DynRankView<T, P...>& src) {
+  return Impl::create_mirror_view(
+      src, Kokkos::view_alloc(typename Space::memory_space()));
 }
 
-// FIXME_C++17 Improve SFINAE here.
+// public interface that accepts a space and a without initializing flag
 template <class Space, class T, class... P,
-          class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-inline typename Impl::MirrorDRViewType<Space, T, P...>::view_type
-create_mirror_view(
-    const Space& space, const Kokkos::DynRankView<T, P...>& src,
-    std::enable_if_t<
-        !Impl::MirrorDRViewType<Space, T, P...>::is_same_memspace>* = nullptr) {
-  return Kokkos::create_mirror(space, src);
-}
-
-template <class Space, class T, class... P>
+          typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
 inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
                                const Space&,
                                const Kokkos::DynRankView<T, P...>& src) {
@@ -2179,6 +2088,8 @@ inline auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
       src, Kokkos::view_alloc(typename Space::memory_space{}, wi));
 }
 
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
 inline auto create_mirror_view(
     const typename Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
@@ -2186,75 +2097,51 @@ inline auto create_mirror_view(
   return Impl::create_mirror_view(src, arg_prop);
 }
 
-template <class... ViewCtorArgs, class T, class... P>
+// create a mirror view and deep copy it
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class... ViewCtorArgs, class T, class... P,
+          class Enable = std::enable_if_t<
+              std::is_void<typename ViewTraits<T, P...>::specialize>::value>>
 auto create_mirror_view_and_copy(
-    const Impl::ViewCtorProp<ViewCtorArgs...>&,
-    const Kokkos::DynRankView<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        Impl::MirrorDRViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace>* = nullptr) {
+    [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
+    const Kokkos::DynRankView<T, P...>& src) {
   using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-  static_assert(
-      alloc_prop_input::has_memory_space,
-      "The view constructor arguments passed to "
-      "Kokkos::create_mirror_view_and_copy must include a memory space!");
-  static_assert(!alloc_prop_input::has_pointer,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not include a pointer!");
-  static_assert(!alloc_prop_input::allow_padding,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not explicitly allow padding!");
-
-  // same behavior as deep_copy(src, src)
-  if (!alloc_prop_input::has_execution_space)
-    fence(
-        "Kokkos::create_mirror_view_and_copy: fence before returning src view");
-  return src;
-}
 
-template <class... ViewCtorArgs, class T, class... P>
-auto create_mirror_view_and_copy(
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    const Kokkos::DynRankView<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        !Impl::MirrorDRViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace>* = nullptr) {
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-  static_assert(
-      alloc_prop_input::has_memory_space,
-      "The view constructor arguments passed to "
-      "Kokkos::create_mirror_view_and_copy must include a memory space!");
-  static_assert(!alloc_prop_input::has_pointer,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not include a pointer!");
-  static_assert(!alloc_prop_input::allow_padding,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not explicitly allow padding!");
-  using Space  = typename alloc_prop_input::memory_space;
-  using Mirror = typename Impl::MirrorDRViewType<Space, T, P...>::view_type;
-
-  auto arg_prop_copy = Impl::with_properties_if_unset(
-      arg_prop, std::string{}, WithoutInitializing,
-      typename Space::execution_space{});
-
-  std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
-  if (label.empty()) label = src.label();
-  auto mirror = typename Mirror::non_const_type{
-      arg_prop_copy, Impl::reconstructLayout(src.layout(), src.rank())};
-  if constexpr (alloc_prop_input::has_execution_space) {
-    deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
-              mirror, src);
-  } else
-    deep_copy(mirror, src);
-  return mirror;
+  Impl::check_view_ctor_args_create_mirror_view_and_copy<ViewCtorArgs...>();
+
+  if constexpr (Impl::MirrorDRViewType<
+                    typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
+                    T, P...>::is_same_memspace) {
+    // same behavior as deep_copy(src, src)
+    if constexpr (!alloc_prop_input::has_execution_space)
+      fence(
+          "Kokkos::create_mirror_view_and_copy: fence before returning src "
+          "view");
+    return src;
+  } else {
+    using Space  = typename alloc_prop_input::memory_space;
+    using Mirror = typename Impl::MirrorDRViewType<Space, T, P...>::view_type;
+
+    auto arg_prop_copy = Impl::with_properties_if_unset(
+        arg_prop, std::string{}, WithoutInitializing,
+        typename Space::execution_space{});
+
+    std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
+    if (label.empty()) label = src.label();
+    auto mirror = typename Mirror::non_const_type{
+        arg_prop_copy, Impl::reconstructLayout(src.layout(), src.rank())};
+    if constexpr (alloc_prop_input::has_execution_space) {
+      deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
+                mirror, src);
+    } else
+      deep_copy(mirror, src);
+    return mirror;
+  }
+#if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+    !defined(KOKKOS_COMPILER_MSVC)
+  __builtin_unreachable();
+#endif
 }
 
 template <class Space, class T, class... P>
diff --git a/containers/src/Kokkos_DynamicView.hpp b/containers/src/Kokkos_DynamicView.hpp
index 12885edbae..a4b74e246e 100644
--- a/containers/src/Kokkos_DynamicView.hpp
+++ b/containers/src/Kokkos_DynamicView.hpp
@@ -590,96 +590,81 @@ struct MirrorDynamicViewType {
 }  // namespace Impl
 
 namespace Impl {
+
+// create a mirror
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
-inline auto create_mirror(
-    const Kokkos::Experimental::DynamicView<T, P...>& src,
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    std::enable_if_t<!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
-        nullptr) {
+inline auto create_mirror(const Kokkos::Experimental::DynamicView<T, P...>& src,
+                          const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
   using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-
-  static_assert(
-      !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
-      "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
+  check_view_ctor_args_create_mirror<ViewCtorArgs...>();
 
   auto prop_copy = Impl::with_properties_if_unset(
       arg_prop, std::string(src.label()).append("_mirror"));
 
-  auto ret = typename Kokkos::Experimental::DynamicView<T, P...>::HostMirror(
-      prop_copy, src.chunk_size(), src.chunk_max() * src.chunk_size());
-
-  ret.resize_serial(src.extent(0));
-
-  return ret;
-}
+  if constexpr (Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    using MemorySpace = typename alloc_prop_input::memory_space;
 
-template <class T, class... P, class... ViewCtorArgs>
-inline auto create_mirror(
-    const Kokkos::Experimental::DynamicView<T, P...>& src,
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    std::enable_if_t<Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>* =
-        nullptr) {
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
+    auto ret = typename Kokkos::Impl::MirrorDynamicViewType<
+        MemorySpace, T, P...>::view_type(prop_copy, src.chunk_size(),
+                                         src.chunk_max() * src.chunk_size());
 
-  static_assert(
-      !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
-      "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
-
-  using MemorySpace = typename alloc_prop_input::memory_space;
-  auto prop_copy    = Impl::with_properties_if_unset(
-      arg_prop, std::string(src.label()).append("_mirror"));
+    ret.resize_serial(src.extent(0));
 
-  auto ret = typename Kokkos::Impl::MirrorDynamicViewType<
-      MemorySpace, T, P...>::view_type(prop_copy, src.chunk_size(),
-                                       src.chunk_max() * src.chunk_size());
+    return ret;
+  } else {
+    auto ret = typename Kokkos::Experimental::DynamicView<T, P...>::HostMirror(
+        prop_copy, src.chunk_size(), src.chunk_max() * src.chunk_size());
 
-  ret.resize_serial(src.extent(0));
+    ret.resize_serial(src.extent(0));
 
-  return ret;
+    return ret;
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
+
 }  // namespace Impl
 
-// Create a mirror in host space
-template <class T, class... P>
+// public interface
+template <class T, class... P,
+          typename Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     const Kokkos::Experimental::DynamicView<T, P...>& src) {
   return Impl::create_mirror(src, Impl::ViewCtorProp<>{});
 }
 
-template <class T, class... P>
+// public interface that accepts a without initializing flag
+template <class T, class... P,
+          typename Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     Kokkos::Impl::WithoutInitializing_t wi,
     const Kokkos::Experimental::DynamicView<T, P...>& src) {
   return Impl::create_mirror(src, Kokkos::view_alloc(wi));
 }
 
-// Create a mirror in a new space
-template <class Space, class T, class... P>
+// public interface that accepts a space
+template <class Space, class T, class... P,
+          typename Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     const Space&, const Kokkos::Experimental::DynamicView<T, P...>& src) {
   return Impl::create_mirror(
       src, Kokkos::view_alloc(typename Space::memory_space{}));
 }
 
-template <class Space, class T, class... P>
+// public interface that accepts a space and a without initializing flag
+template <class Space, class T, class... P,
+          typename Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 typename Kokkos::Impl::MirrorDynamicViewType<Space, T, P...>::view_type
 create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
               const Kokkos::Experimental::DynamicView<T, P...>& src) {
@@ -687,7 +672,11 @@ create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
       src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
 }
 
-template <class T, class... P, class... ViewCtorArgs>
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs,
+          typename Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
     const Kokkos::Experimental::DynamicView<T, P...>& src) {
@@ -696,76 +685,56 @@ inline auto create_mirror(
 
 namespace Impl {
 
+// create a mirror view
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        (std::is_same<
-             typename Kokkos::Experimental::DynamicView<T, P...>::memory_space,
-             typename Kokkos::Experimental::DynamicView<
-                 T, P...>::HostMirror::memory_space>::value &&
-         std::is_same<
-             typename Kokkos::Experimental::DynamicView<T, P...>::data_type,
-             typename Kokkos::Experimental::DynamicView<
-                 T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::Experimental::DynamicView<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
-}
-
-template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        !(std::is_same<
-              typename Kokkos::Experimental::DynamicView<T, P...>::memory_space,
-              typename Kokkos::Experimental::DynamicView<
-                  T, P...>::HostMirror::memory_space>::value &&
-          std::is_same<
-              typename Kokkos::Experimental::DynamicView<T, P...>::data_type,
-              typename Kokkos::Experimental::DynamicView<
-                  T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::Experimental::DynamicView<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::create_mirror(arg_prop, src);
-}
-
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-std::enable_if_t<Impl::MirrorDynamicViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::is_same_memspace,
-                 typename Impl::MirrorDynamicViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::view_type>
-create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
+inline auto create_mirror_view(
+    const Kokkos::Experimental::DynamicView<T, P...>& src,
+    [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
+  if constexpr (!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    if constexpr (std::is_same<typename Kokkos::Experimental::DynamicView<
+                                   T, P...>::memory_space,
+                               typename Kokkos::Experimental::DynamicView<
+                                   T, P...>::HostMirror::memory_space>::value &&
+                  std::is_same<typename Kokkos::Experimental::DynamicView<
+                                   T, P...>::data_type,
+                               typename Kokkos::Experimental::DynamicView<
+                                   T, P...>::HostMirror::data_type>::value) {
+      return
+          typename Kokkos::Experimental::DynamicView<T, P...>::HostMirror(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  } else {
+    if constexpr (Impl::MirrorDynamicViewType<
+                      typename Impl::ViewCtorProp<
+                          ViewCtorArgs...>::memory_space,
+                      T, P...>::is_same_memspace) {
+      return typename Impl::MirrorDynamicViewType<
+          typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
+          P...>::view_type(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-std::enable_if_t<!Impl::MirrorDynamicViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::is_same_memspace,
-                 typename Impl::MirrorDynamicViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::view_type>
-create_mirror_view(const Kokkos::Experimental::DynamicView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::Impl::create_mirror(src, arg_prop);
-}
 }  // namespace Impl
 
-// Create a mirror view in host space
+// public interface
 template <class T, class... P>
 inline auto create_mirror_view(
     const typename Kokkos::Experimental::DynamicView<T, P...>& src) {
   return Impl::create_mirror_view(src, Impl::ViewCtorProp<>{});
 }
 
+// public interface that accepts a without initializing flag
 template <class T, class... P>
 inline auto create_mirror_view(
     Kokkos::Impl::WithoutInitializing_t wi,
@@ -773,15 +742,18 @@ inline auto create_mirror_view(
   return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
 }
 
-// Create a mirror in a new space
-template <class Space, class T, class... P>
+// public interface that accepts a space
+template <class Space, class T, class... P,
+          class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
 inline auto create_mirror_view(
     const Space&, const Kokkos::Experimental::DynamicView<T, P...>& src) {
   return Impl::create_mirror_view(src,
                                   view_alloc(typename Space::memory_space{}));
 }
 
-template <class Space, class T, class... P>
+// public interface that accepts a space and a without initializing flag
+template <class Space, class T, class... P,
+          class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
 inline auto create_mirror_view(
     Kokkos::Impl::WithoutInitializing_t wi, const Space&,
     const Kokkos::Experimental::DynamicView<T, P...>& src) {
@@ -789,6 +761,8 @@ inline auto create_mirror_view(
       src, Kokkos::view_alloc(wi, typename Space::memory_space{}));
 }
 
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
 inline auto create_mirror_view(
     const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
@@ -985,80 +959,57 @@ struct ViewCopy<Kokkos::Experimental::DynamicView<DP...>,
 
 }  // namespace Impl
 
-template <class... ViewCtorArgs, class T, class... P>
+// create a mirror view and deep copy it
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class... ViewCtorArgs, class T, class... P,
+          class Enable = std::enable_if_t<
+              std::is_void<typename ViewTraits<T, P...>::specialize>::value>>
 auto create_mirror_view_and_copy(
-    const Impl::ViewCtorProp<ViewCtorArgs...>&,
-    const Kokkos::Experimental::DynamicView<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        Impl::MirrorDynamicViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace>* = nullptr) {
+    [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
+    const Kokkos::Experimental::DynamicView<T, P...>& src) {
   using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-  static_assert(
-      alloc_prop_input::has_memory_space,
-      "The view constructor arguments passed to "
-      "Kokkos::create_mirror_view_and_copy must include a memory space!");
-  static_assert(!alloc_prop_input::has_pointer,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not include a pointer!");
-  static_assert(!alloc_prop_input::allow_padding,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not explicitly allow padding!");
-
-  // same behavior as deep_copy(src, src)
-  if (!alloc_prop_input::has_execution_space)
-    fence(
-        "Kokkos::create_mirror_view_and_copy: fence before returning src view");
-  return src;
-}
 
-template <class... ViewCtorArgs, class T, class... P>
-auto create_mirror_view_and_copy(
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    const Kokkos::Experimental::DynamicView<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        !Impl::MirrorDynamicViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace>* = nullptr) {
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-  static_assert(
-      alloc_prop_input::has_memory_space,
-      "The view constructor arguments passed to "
-      "Kokkos::create_mirror_view_and_copy must include a memory space!");
-  static_assert(!alloc_prop_input::has_pointer,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not include a pointer!");
-  static_assert(!alloc_prop_input::allow_padding,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not explicitly allow padding!");
-  using Space = typename alloc_prop_input::memory_space;
-  using Mirror =
-      typename Impl::MirrorDynamicViewType<Space, T, P...>::view_type;
-
-  auto arg_prop_copy = Impl::with_properties_if_unset(
-      arg_prop, std::string{}, WithoutInitializing,
-      typename Space::execution_space{});
-
-  std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
-  if (label.empty()) label = src.label();
-  auto mirror = typename Mirror::non_const_type(
-      arg_prop_copy, src.chunk_size(), src.chunk_max() * src.chunk_size());
-  mirror.resize_serial(src.extent(0));
-  if constexpr (alloc_prop_input::has_execution_space) {
-    deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
-              mirror, src);
-  } else
-    deep_copy(mirror, src);
-  return mirror;
+  Impl::check_view_ctor_args_create_mirror_view_and_copy<ViewCtorArgs...>();
+
+  if constexpr (Impl::MirrorDynamicViewType<
+                    typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
+                    T, P...>::is_same_memspace) {
+    // same behavior as deep_copy(src, src)
+    if constexpr (!alloc_prop_input::has_execution_space)
+      fence(
+          "Kokkos::create_mirror_view_and_copy: fence before returning src "
+          "view");
+    return src;
+  } else {
+    using Space = typename alloc_prop_input::memory_space;
+    using Mirror =
+        typename Impl::MirrorDynamicViewType<Space, T, P...>::view_type;
+
+    auto arg_prop_copy = Impl::with_properties_if_unset(
+        arg_prop, std::string{}, WithoutInitializing,
+        typename Space::execution_space{});
+
+    std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
+    if (label.empty()) label = src.label();
+    auto mirror = typename Mirror::non_const_type(
+        arg_prop_copy, src.chunk_size(), src.chunk_max() * src.chunk_size());
+    mirror.resize_serial(src.extent(0));
+    if constexpr (alloc_prop_input::has_execution_space) {
+      deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
+                mirror, src);
+    } else
+      deep_copy(mirror, src);
+    return mirror;
+  }
+#if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+    !defined(KOKKOS_COMPILER_MSVC)
+  __builtin_unreachable();
+#endif
 }
 
-template <class Space, class T, class... P>
+template <class Space, class T, class... P,
+          typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
 auto create_mirror_view_and_copy(
     const Space&, const Kokkos::Experimental::DynamicView<T, P...>& src,
     std::string const& name = "") {
diff --git a/containers/src/Kokkos_OffsetView.hpp b/containers/src/Kokkos_OffsetView.hpp
index 92aead2878..3adc70b190 100644
--- a/containers/src/Kokkos_OffsetView.hpp
+++ b/containers/src/Kokkos_OffsetView.hpp
@@ -124,15 +124,8 @@ KOKKOS_INLINE_FUNCTION void offsetview_verify_operator_bounds(
                                              args...);
          Kokkos::Impl::throw_runtime_exception(std::string(buffer));))
 
-    KOKKOS_IF_ON_DEVICE((
-        /* Check #1: is there a SharedAllocationRecord?
-          (we won't use it, but if it is not there then there isn't
-           a corresponding SharedAllocationHeader containing a label).
-          This check should cover the case of Views that don't
-          have the Unmanaged trait but were initialized by pointer. */
-        if (tracker.has_record()) {
-          Kokkos::Impl::operator_bounds_error_on_device(map);
-        } else { Kokkos::abort("OffsetView bounds error"); }))
+    KOKKOS_IF_ON_DEVICE(
+        (Kokkos::abort("OffsetView bounds error"); (void)tracker;))
   }
 }
 
@@ -478,62 +471,31 @@ class OffsetView : public ViewTraits<DataType, Properties...> {
   template <typename I0, typename I1>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
       (Kokkos::Impl::are_integral<I0, I1>::value && (2 == Rank) &&
-       is_default_map && is_layout_left && (traits::rank_dynamic == 0)),
-      reference_type>
-  operator()(const I0& i0, const I1& i1) const {
-    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
-    const size_t j0 = i0 - m_begins[0];
-    const size_t j1 = i1 - m_begins[1];
-    return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_dim.N0 * j1];
-  }
-
-  template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::are_integral<I0, I1>::value && (2 == Rank) &&
-       is_default_map && is_layout_left && (traits::rank_dynamic != 0)),
-      reference_type>
-  operator()(const I0& i0, const I1& i1) const {
-    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
-    const size_t j0 = i0 - m_begins[0];
-    const size_t j1 = i1 - m_begins[1];
-    return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_stride * j1];
-  }
-
-  template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::are_integral<I0, I1>::value && (2 == Rank) &&
-       is_default_map && is_layout_right && (traits::rank_dynamic == 0)),
+       is_default_map &&
+       (is_layout_left || is_layout_right || is_layout_stride)),
       reference_type>
   operator()(const I0& i0, const I1& i1) const {
     KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
     const size_t j0 = i0 - m_begins[0];
     const size_t j1 = i1 - m_begins[1];
-    return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_dim.N1 * j0];
-  }
-
-  template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<
-      (Kokkos::Impl::are_integral<I0, I1>::value && (2 == Rank) &&
-       is_default_map && is_layout_right && (traits::rank_dynamic != 0)),
-      reference_type>
-  operator()(const I0& i0, const I1& i1) const {
-    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
-    const size_t j0 = i0 - m_begins[0];
-    const size_t j1 = i1 - m_begins[1];
-    return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_stride * j0];
-  }
-
-  template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION
-      std::enable_if_t<(Kokkos::Impl::are_integral<I0, I1>::value &&
-                        (2 == Rank) && is_default_map && is_layout_stride),
-                       reference_type>
-      operator()(const I0& i0, const I1& i1) const {
-    KOKKOS_IMPL_OFFSETVIEW_OPERATOR_VERIFY((m_track, m_map, m_begins, i0, i1))
-    const size_t j0 = i0 - m_begins[0];
-    const size_t j1 = i1 - m_begins[1];
-    return m_map.m_impl_handle[j0 * m_map.m_impl_offset.m_stride.S0 +
-                               j1 * m_map.m_impl_offset.m_stride.S1];
+    if constexpr (is_layout_left) {
+      if constexpr (traits::rank_dynamic == 0)
+        return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_dim.N0 * j1];
+      else
+        return m_map.m_impl_handle[j0 + m_map.m_impl_offset.m_stride * j1];
+    } else if constexpr (is_layout_right) {
+      if constexpr (traits::rank_dynamic == 0)
+        return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_dim.N1 * j0];
+      else
+        return m_map.m_impl_handle[j1 + m_map.m_impl_offset.m_stride * j0];
+    } else {
+      static_assert(is_layout_stride);
+      return m_map.m_impl_handle[j0 * m_map.m_impl_offset.m_stride.S0 +
+                                 j1 * m_map.m_impl_offset.m_stride.S1];
+    }
+#if defined(KOKKOS_COMPILER_INTEL)
+    __builtin_unreachable();
+#endif
   }
 
   //------------------------------
@@ -1848,71 +1810,73 @@ struct MirrorOffsetType {
 }  // namespace Impl
 
 namespace Impl {
-template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space,
-    typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror>
-create_mirror(const Kokkos::Experimental::OffsetView<T, P...>& src,
-              const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror(
-      Kokkos::create_mirror(arg_prop, src.view()), src.begins());
-}
 
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
+// create a mirror
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs>
 inline auto create_mirror(const Kokkos::Experimental::OffsetView<T, P...>& src,
                           const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-  using Space = typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space;
+  check_view_ctor_args_create_mirror<ViewCtorArgs...>();
 
-  static_assert(
-      !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
-      "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
+  if constexpr (Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    using Space = typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space;
 
-  auto prop_copy = Impl::with_properties_if_unset(
-      arg_prop, std::string(src.label()).append("_mirror"));
+    auto prop_copy = Impl::with_properties_if_unset(
+        arg_prop, std::string(src.label()).append("_mirror"));
 
-  return typename Kokkos::Impl::MirrorOffsetType<Space, T, P...>::view_type(
-      prop_copy, src.layout(),
-      {src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
-       src.begin(5), src.begin(6), src.begin(7)});
+    return typename Kokkos::Impl::MirrorOffsetType<Space, T, P...>::view_type(
+        prop_copy, src.layout(),
+        {src.begin(0), src.begin(1), src.begin(2), src.begin(3), src.begin(4),
+         src.begin(5), src.begin(6), src.begin(7)});
+  } else {
+    return typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror(
+        Kokkos::create_mirror(arg_prop, src.view()), src.begins());
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
+
 }  // namespace Impl
 
-// Create a mirror in host space
-template <class T, class... P>
+// public interface
+template <class T, class... P,
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     const Kokkos::Experimental::OffsetView<T, P...>& src) {
   return Impl::create_mirror(src, Impl::ViewCtorProp<>{});
 }
 
-template <class T, class... P>
+// public interface that accepts a without initializing flag
+template <class T, class... P,
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     Kokkos::Impl::WithoutInitializing_t wi,
     const Kokkos::Experimental::OffsetView<T, P...>& src) {
   return Impl::create_mirror(src, Kokkos::view_alloc(wi));
 }
 
-// Create a mirror in a new space
+// public interface that accepts a space
 template <class Space, class T, class... P,
-          typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
+          typename Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     const Space&, const Kokkos::Experimental::OffsetView<T, P...>& src) {
   return Impl::create_mirror(
       src, Kokkos::view_alloc(typename Space::memory_space{}));
 }
 
-template <class Space, class T, class... P>
+// public interface that accepts a space and a without initializing flag
+template <class Space, class T, class... P,
+          typename Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 typename Kokkos::Impl::MirrorOffsetType<Space, T, P...>::view_type
 create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
               const Kokkos::Experimental::OffsetView<T, P...>& src) {
@@ -1920,7 +1884,11 @@ create_mirror(Kokkos::Impl::WithoutInitializing_t wi, const Space&,
       src, Kokkos::view_alloc(typename Space::memory_space{}, wi));
 }
 
-template <class T, class... P, class... ViewCtorArgs>
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs,
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 inline auto create_mirror(
     const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
     const Kokkos::Experimental::OffsetView<T, P...>& src) {
@@ -1928,76 +1896,56 @@ inline auto create_mirror(
 }
 
 namespace Impl {
-template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        (std::is_same<
-             typename Kokkos::Experimental::OffsetView<T, P...>::memory_space,
-             typename Kokkos::Experimental::OffsetView<
-                 T, P...>::HostMirror::memory_space>::value &&
-         std::is_same<
-             typename Kokkos::Experimental::OffsetView<T, P...>::data_type,
-             typename Kokkos::Experimental::OffsetView<
-                 T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::Experimental::OffsetView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
-}
 
+// create a mirror view
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        !(std::is_same<
-              typename Kokkos::Experimental::OffsetView<T, P...>::memory_space,
-              typename Kokkos::Experimental::OffsetView<
-                  T, P...>::HostMirror::memory_space>::value &&
-          std::is_same<
-              typename Kokkos::Experimental::OffsetView<T, P...>::data_type,
-              typename Kokkos::Experimental::OffsetView<
-                  T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::Experimental::OffsetView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::create_mirror(arg_prop, src);
-}
-
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-std::enable_if_t<Impl::MirrorOffsetViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::is_same_memspace,
-                 typename Impl::MirrorOffsetViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::view_type>
-create_mirror_view(const Kokkos::Experimental::OffsetView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
+inline auto create_mirror_view(
+    const Kokkos::Experimental::OffsetView<T, P...>& src,
+    [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
+  if constexpr (!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    if constexpr (std::is_same<typename Kokkos::Experimental::OffsetView<
+                                   T, P...>::memory_space,
+                               typename Kokkos::Experimental::OffsetView<
+                                   T, P...>::HostMirror::memory_space>::value &&
+                  std::is_same<typename Kokkos::Experimental::OffsetView<
+                                   T, P...>::data_type,
+                               typename Kokkos::Experimental::OffsetView<
+                                   T, P...>::HostMirror::data_type>::value) {
+      return
+          typename Kokkos::Experimental::OffsetView<T, P...>::HostMirror(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  } else {
+    if constexpr (Impl::MirrorOffsetViewType<typename Impl::ViewCtorProp<
+                                                 ViewCtorArgs...>::memory_space,
+                                             T, P...>::is_same_memspace) {
+      return typename Impl::MirrorOffsetViewType<
+          typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
+          P...>::view_type(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-std::enable_if_t<!Impl::MirrorOffsetViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::is_same_memspace,
-                 typename Impl::MirrorOffsetViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::view_type>
-create_mirror_view(const Kokkos::Experimental::OffsetView<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::Impl::create_mirror(src, arg_prop);
-}
 }  // namespace Impl
 
-// Create a mirror view in host space
+// public interface
 template <class T, class... P>
 inline auto create_mirror_view(
     const typename Kokkos::Experimental::OffsetView<T, P...>& src) {
   return Impl::create_mirror_view(src, Impl::ViewCtorProp<>{});
 }
 
+// public interface that accepts a without initializing flag
 template <class T, class... P>
 inline auto create_mirror_view(
     Kokkos::Impl::WithoutInitializing_t wi,
@@ -2005,7 +1953,7 @@ inline auto create_mirror_view(
   return Impl::create_mirror_view(src, Kokkos::view_alloc(wi));
 }
 
-// Create a mirror view in a new space
+// public interface that accepts a space
 template <class Space, class T, class... P,
           typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
 inline auto create_mirror_view(
@@ -2014,7 +1962,9 @@ inline auto create_mirror_view(
       src, Kokkos::view_alloc(typename Space::memory_space{}));
 }
 
-template <class Space, class T, class... P>
+// public interface that accepts a space and a without initializing flag
+template <class Space, class T, class... P,
+          typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
 inline auto create_mirror_view(
     Kokkos::Impl::WithoutInitializing_t wi, const Space&,
     const Kokkos::Experimental::OffsetView<T, P...>& src) {
@@ -2022,6 +1972,8 @@ inline auto create_mirror_view(
       src, Kokkos::view_alloc(typename Space::memory_space{}, wi));
 }
 
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
 inline auto create_mirror_view(
     const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
@@ -2029,7 +1981,9 @@ inline auto create_mirror_view(
   return Impl::create_mirror_view(src, arg_prop);
 }
 
-// Create a mirror view and deep_copy in a new space
+// create a mirror view and deep copy it
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class... ViewCtorArgs, class T, class... P>
 typename Kokkos::Impl::MirrorOffsetViewType<
     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
diff --git a/containers/src/Kokkos_UnorderedMap.hpp b/containers/src/Kokkos_UnorderedMap.hpp
index aa62d32557..c3a8b67df8 100644
--- a/containers/src/Kokkos_UnorderedMap.hpp
+++ b/containers/src/Kokkos_UnorderedMap.hpp
@@ -34,8 +34,7 @@
 
 #include <impl/Kokkos_Traits.hpp>
 #include <impl/Kokkos_UnorderedMap_impl.hpp>
-
-#include <iostream>
+#include <impl/Kokkos_ViewCtor.hpp>
 
 #include <cstdint>
 
@@ -244,16 +243,16 @@ class UnorderedMap {
   using const_map_type = UnorderedMap<const_key_type, const_value_type,
                                       device_type, hasher_type, equal_to_type>;
 
-  static const bool is_set = std::is_void<value_type>::value;
-  static const bool has_const_key =
-      std::is_same<const_key_type, declared_key_type>::value;
-  static const bool has_const_value =
-      is_set || std::is_same<const_value_type, declared_value_type>::value;
+  static constexpr bool is_set = std::is_void_v<value_type>;
+  static constexpr bool has_const_key =
+      std::is_same_v<const_key_type, declared_key_type>;
+  static constexpr bool has_const_value =
+      is_set || std::is_same_v<const_value_type, declared_value_type>;
 
-  static const bool is_insertable_map =
+  static constexpr bool is_insertable_map =
       !has_const_key && (is_set || !has_const_value);
-  static const bool is_modifiable_map = has_const_key && !has_const_value;
-  static const bool is_const_map      = has_const_key && has_const_value;
+  static constexpr bool is_modifiable_map = has_const_key && !has_const_value;
+  static constexpr bool is_const_map      = has_const_key && has_const_value;
 
   using insert_result = UnorderedMapInsertResult;
 
@@ -304,28 +303,76 @@ class UnorderedMap {
   ///                           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("UnorderedMap size"),
-        m_available_indexes(calculate_capacity(capacity_hint)),
-        m_hash_lists(view_alloc(WithoutInitializing, "UnorderedMap hash list"),
-                     Impl::find_hash_size(capacity())),
-        m_next_index(view_alloc(WithoutInitializing, "UnorderedMap next index"),
-                     capacity() + 1)  // +1 so that the *_at functions can
-                                      // always return a valid reference
-        ,
-        m_keys("UnorderedMap keys", capacity()),
-        m_values("UnorderedMap values", (is_set ? 0 : capacity())),
-        m_scalars("UnorderedMap scalars") {
+      : UnorderedMap(Kokkos::view_alloc(), capacity_hint, hasher, equal_to) {}
+
+  template <class... P>
+  UnorderedMap(const Impl::ViewCtorProp<P...> &arg_prop,
+               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) {
     if (!is_insertable_map) {
       Kokkos::Impl::throw_runtime_exception(
           "Cannot construct a non-insertable (i.e. const key_type) "
           "unordered_map");
     }
 
-    Kokkos::deep_copy(m_hash_lists, invalid_index);
-    Kokkos::deep_copy(m_next_index, invalid_index);
+    //! Ensure that allocation properties are consistent.
+    using alloc_prop_t = std::decay_t<decltype(arg_prop)>;
+    static_assert(alloc_prop_t::initialize,
+                  "Allocation property 'initialize' should be true.");
+    static_assert(
+        !alloc_prop_t::has_pointer,
+        "Allocation properties should not contain the 'pointer' property.");
+
+    /// Update allocation properties with 'label' and 'without initializing'
+    /// properties.
+    const auto prop_copy =
+        Impl::with_properties_if_unset(arg_prop, std::string("UnorderedMap"));
+    const auto prop_copy_noinit =
+        Impl::with_properties_if_unset(prop_copy, Kokkos::WithoutInitializing);
+
+    //! Initialize member views.
+    m_size = shared_size_t(Kokkos::view_alloc(
+        Kokkos::DefaultHostExecutionSpace{},
+        Impl::get_property<Impl::LabelTag>(prop_copy) + " - size"));
+
+    m_available_indexes =
+        bitset_type(Kokkos::Impl::append_to_label(prop_copy, " - bitset"),
+                    calculate_capacity(capacity_hint));
+
+    m_hash_lists = size_type_view(
+        Kokkos::Impl::append_to_label(prop_copy_noinit, " - hash list"),
+        Impl::find_hash_size(capacity()));
+
+    m_next_index = size_type_view(
+        Kokkos::Impl::append_to_label(prop_copy_noinit, " - next index"),
+        capacity() + 1);  // +1 so that the *_at functions can always return a
+                          // valid reference
+
+    m_keys = key_type_view(Kokkos::Impl::append_to_label(prop_copy, " - keys"),
+                           capacity());
+
+    m_values =
+        value_type_view(Kokkos::Impl::append_to_label(prop_copy, " - values"),
+                        is_set ? 0 : capacity());
+
+    m_scalars =
+        scalars_view(Kokkos::Impl::append_to_label(prop_copy, " - scalars"));
+
+    /**
+     * Deep copies should also be done using the space instance if given.
+     * Instead of the if/else we could use the
+     * @c get_property_or_default, but giving even the default execution space
+     * instance will change the behavior of @c deep_copy.
+     */
+    if constexpr (alloc_prop_t::has_execution_space) {
+      const auto &space = Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop);
+      Kokkos::deep_copy(space, m_hash_lists, invalid_index);
+      Kokkos::deep_copy(space, m_next_index, invalid_index);
+    } else {
+      Kokkos::deep_copy(m_hash_lists, invalid_index);
+      Kokkos::deep_copy(m_next_index, invalid_index);
+    }
   }
 
   void reset_failed_insert_flag() { reset_flag(failed_insert_idx); }
@@ -568,7 +615,7 @@ class UnorderedMap {
           // Previously claimed an unused entry that was not inserted.
           // Release this unused entry immediately.
           if (!m_available_indexes.reset(new_index)) {
-            KOKKOS_IMPL_DO_NOT_USE_PRINTF("Unable to free existing\n");
+            Kokkos::printf("Unable to free existing\n");
           }
         }
 
@@ -758,56 +805,94 @@ class UnorderedMap {
     return *this;
   }
 
+  // Re-allocate the views of the calling UnorderedMap according to src
+  // capacity, and deep copy the src data.
   template <typename SKey, typename SValue, typename SDevice>
   std::enable_if_t<std::is_same<std::remove_const_t<SKey>, key_type>::value &&
                    std::is_same<std::remove_const_t<SValue>, value_type>::value>
   create_copy_view(
       UnorderedMap<SKey, SValue, SDevice, Hasher, EqualTo> const &src) {
     if (m_hash_lists.data() != src.m_hash_lists.data()) {
-      insertable_map_type tmp;
-
-      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.m_size();
-      tmp.m_available_indexes = bitset_type(src.capacity());
-      tmp.m_hash_lists        = size_type_view(
-          view_alloc(WithoutInitializing, "UnorderedMap hash list"),
-          src.m_hash_lists.extent(0));
-      tmp.m_next_index = size_type_view(
-          view_alloc(WithoutInitializing, "UnorderedMap next index"),
-          src.m_next_index.extent(0));
-      tmp.m_keys =
-          key_type_view(view_alloc(WithoutInitializing, "UnorderedMap keys"),
-                        src.m_keys.extent(0));
-      tmp.m_values = value_type_view(
-          view_alloc(WithoutInitializing, "UnorderedMap values"),
-          src.m_values.extent(0));
-      tmp.m_scalars = scalars_view("UnorderedMap scalars");
-
-      Kokkos::deep_copy(tmp.m_available_indexes, src.m_available_indexes);
+      allocate_view(src);
+      deep_copy_view(src);
+    }
+  }
+
+  // Allocate views of the calling UnorderedMap with the same capacity as the
+  // src.
+  template <typename SKey, typename SValue, typename SDevice>
+  std::enable_if_t<std::is_same<std::remove_const_t<SKey>, key_type>::value &&
+                   std::is_same<std::remove_const_t<SValue>, value_type>::value>
+  allocate_view(
+      UnorderedMap<SKey, SValue, SDevice, Hasher, EqualTo> const &src) {
+    insertable_map_type tmp;
+
+    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.m_size();
+    tmp.m_available_indexes = bitset_type(src.capacity());
+    tmp.m_hash_lists        = size_type_view(
+        view_alloc(WithoutInitializing, "UnorderedMap hash list"),
+        src.m_hash_lists.extent(0));
+    tmp.m_next_index = size_type_view(
+        view_alloc(WithoutInitializing, "UnorderedMap next index"),
+        src.m_next_index.extent(0));
+    tmp.m_keys =
+        key_type_view(view_alloc(WithoutInitializing, "UnorderedMap keys"),
+                      src.m_keys.extent(0));
+    tmp.m_values =
+        value_type_view(view_alloc(WithoutInitializing, "UnorderedMap values"),
+                        src.m_values.extent(0));
+    tmp.m_scalars = scalars_view("UnorderedMap scalars");
+
+    *this = tmp;
+  }
+
+  // Deep copy view data from src. This requires that the src capacity is
+  // identical to the capacity of the calling UnorderedMap.
+  template <typename SKey, typename SValue, typename SDevice>
+  std::enable_if_t<std::is_same<std::remove_const_t<SKey>, key_type>::value &&
+                   std::is_same<std::remove_const_t<SValue>, value_type>::value>
+  deep_copy_view(
+      UnorderedMap<SKey, SValue, SDevice, Hasher, EqualTo> const &src) {
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_4
+    // To deep copy UnorderedMap, capacity must be identical
+    KOKKOS_EXPECTS(capacity() == src.capacity());
+#else
+    if (capacity() != src.capacity()) {
+      allocate_view(src);
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+      Kokkos::Impl::log_warning(
+          "Warning: deep_copy_view() allocating views is deprecated. Must call "
+          "with UnorderedMaps of identical capacity, or use "
+          "create_copy_view().\n");
+#endif
+    }
+#endif
+
+    if (m_hash_lists.data() != src.m_hash_lists.data()) {
+      Kokkos::deep_copy(m_available_indexes, src.m_available_indexes);
 
       using raw_deep_copy =
           Kokkos::Impl::DeepCopy<typename device_type::memory_space,
                                  typename SDevice::memory_space>;
 
-      raw_deep_copy(tmp.m_hash_lists.data(), src.m_hash_lists.data(),
+      raw_deep_copy(m_hash_lists.data(), src.m_hash_lists.data(),
                     sizeof(size_type) * src.m_hash_lists.extent(0));
-      raw_deep_copy(tmp.m_next_index.data(), src.m_next_index.data(),
+      raw_deep_copy(m_next_index.data(), src.m_next_index.data(),
                     sizeof(size_type) * src.m_next_index.extent(0));
-      raw_deep_copy(tmp.m_keys.data(), src.m_keys.data(),
+      raw_deep_copy(m_keys.data(), src.m_keys.data(),
                     sizeof(key_type) * src.m_keys.extent(0));
       if (!is_set) {
-        raw_deep_copy(tmp.m_values.data(), src.m_values.data(),
+        raw_deep_copy(m_values.data(), src.m_values.data(),
                       sizeof(impl_value_type) * src.m_values.extent(0));
       }
-      raw_deep_copy(tmp.m_scalars.data(), src.m_scalars.data(),
+      raw_deep_copy(m_scalars.data(), src.m_scalars.data(),
                     sizeof(int) * num_scalars);
 
       Kokkos::fence(
-          "Kokkos::UnorderedMap::create_copy_view: fence after copy to tmp");
-
-      *this = tmp;
+          "Kokkos::UnorderedMap::deep_copy_view: fence after copy to dst.");
     }
   }
 
@@ -862,7 +947,8 @@ class UnorderedMap {
   bool m_bounded_insert;
   hasher_type m_hasher;
   equal_to_type m_equal_to;
-  View<size_type, HostSpace> m_size;
+  using shared_size_t = View<size_type, Kokkos::DefaultHostExecutionSpace>;
+  shared_size_t m_size;
   bitset_type m_available_indexes;
   size_type_view m_hash_lists;
   size_type_view m_next_index;
@@ -884,13 +970,25 @@ class UnorderedMap {
   friend struct Impl::UnorderedMapPrint;
 };
 
-// Specialization of deep_copy for two UnorderedMap objects.
+// Specialization of deep_copy() for two UnorderedMap objects.
 template <typename DKey, typename DT, typename DDevice, typename SKey,
           typename ST, typename SDevice, typename Hasher, typename EqualTo>
 inline void deep_copy(
     UnorderedMap<DKey, DT, DDevice, Hasher, EqualTo> &dst,
     const UnorderedMap<SKey, ST, SDevice, Hasher, EqualTo> &src) {
-  dst.create_copy_view(src);
+  dst.deep_copy_view(src);
+}
+
+// Specialization of create_mirror() for an UnorderedMap object.
+template <typename Key, typename ValueType, typename Device, typename Hasher,
+          typename EqualTo>
+typename UnorderedMap<Key, ValueType, Device, Hasher, EqualTo>::HostMirror
+create_mirror(
+    const UnorderedMap<Key, ValueType, Device, Hasher, EqualTo> &src) {
+  typename UnorderedMap<Key, ValueType, Device, Hasher, EqualTo>::HostMirror
+      dst;
+  dst.allocate_view(src);
+  return dst;
 }
 
 }  // namespace Kokkos
diff --git a/containers/src/Kokkos_Vector.hpp b/containers/src/Kokkos_Vector.hpp
index 9c9cde3a55..88109fb0ba 100644
--- a/containers/src/Kokkos_Vector.hpp
+++ b/containers/src/Kokkos_Vector.hpp
@@ -21,6 +21,22 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_VECTOR
 #endif
 
+#include <Kokkos_Macros.hpp>
+
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+#if defined(KOKKOS_ENABLE_DEPRECATION_WARNINGS)
+namespace {
+[[deprecated("Deprecated <Kokkos_Vector.hpp> header is included")]] int
+emit_warning_kokkos_vector_deprecated() {
+  return 0;
+}
+static auto do_not_include = emit_warning_kokkos_vector_deprecated();
+}  // namespace
+#endif
+#else
+#error "Deprecated <Kokkos_Vector.hpp> header is included"
+#endif
+
 #include <Kokkos_Core_fwd.hpp>
 #include <Kokkos_DualView.hpp>
 
@@ -31,8 +47,10 @@
  */
 namespace Kokkos {
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 template <class Scalar, class Arg1Type = void>
-class vector : public DualView<Scalar*, LayoutLeft, Arg1Type> {
+class KOKKOS_DEPRECATED vector
+    : public DualView<Scalar*, LayoutLeft, Arg1Type> {
  public:
   using value_type      = Scalar;
   using pointer         = Scalar*;
@@ -312,6 +330,7 @@ class vector : public DualView<Scalar*, LayoutLeft, Arg1Type> {
     void operator()(const int& i) const { _data(i) = _val; }
   };
 };
+#endif
 
 }  // namespace Kokkos
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_VECTOR
diff --git a/containers/src/impl/Kokkos_Bitset_impl.hpp b/containers/src/impl/Kokkos_Bitset_impl.hpp
index c598e4b67b..b71037afea 100644
--- a/containers/src/impl/Kokkos_Bitset_impl.hpp
+++ b/containers/src/impl/Kokkos_Bitset_impl.hpp
@@ -23,7 +23,6 @@
 
 #include <cstdio>
 #include <climits>
-#include <iostream>
 #include <iomanip>
 
 namespace Kokkos {
diff --git a/containers/src/impl/Kokkos_UnorderedMap_impl.hpp b/containers/src/impl/Kokkos_UnorderedMap_impl.hpp
index 2c431d1579..a979ee40d8 100644
--- a/containers/src/impl/Kokkos_UnorderedMap_impl.hpp
+++ b/containers/src/impl/Kokkos_UnorderedMap_impl.hpp
@@ -22,12 +22,23 @@
 
 #include <cstdio>
 #include <climits>
-#include <iostream>
 #include <iomanip>
 
 namespace Kokkos {
 namespace Impl {
 
+//! Append to the label contained in view_ctor_prop.
+template <typename... P>
+auto append_to_label(const ViewCtorProp<P...>& view_ctor_prop,
+                     const std::string& label) {
+  using vcp_t = ViewCtorProp<P...>;
+  static_assert(vcp_t::has_label);
+  vcp_t new_ctor_props(view_ctor_prop);
+  static_cast<ViewCtorProp<void, std::string>&>(new_ctor_props)
+      .value.append(label);
+  return new_ctor_props;
+}
+
 uint32_t find_hash_size(uint32_t size);
 
 template <typename Map>
@@ -226,8 +237,8 @@ struct UnorderedMapPrint {
     uint32_t list = m_map.m_hash_lists(i);
     for (size_type curr = list, ii = 0; curr != invalid_index;
          curr = m_map.m_next_index[curr], ++ii) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("%d[%d]: %d->%d\n", list, ii,
-                                    m_map.key_at(curr), m_map.value_at(curr));
+      Kokkos::printf("%d[%d]: %d->%d\n", list, ii, m_map.key_at(curr),
+                     m_map.value_at(curr));
     }
   }
 };
diff --git a/containers/unit_tests/CMakeLists.txt b/containers/unit_tests/CMakeLists.txt
index 161f7be93e..e69e46bb6a 100644
--- a/containers/unit_tests/CMakeLists.txt
+++ b/containers/unit_tests/CMakeLists.txt
@@ -28,6 +28,9 @@ foreach(Tag Threads;Serial;OpenMP;HPX;Cuda;HIP;SYCL)
         Vector
         ViewCtorPropEmbeddedDim
         )
+      if(NOT Kokkos_ENABLE_DEPRECATED_CODE_4 AND Name STREQUAL "Vector")
+        continue() # skip Kokkos::vector test if deprecated code 4 is not enabled
+      endif()
       # Write to a temporary intermediate file and call configure_file to avoid
       # updating timestamps triggering unnecessary rebuilds on subsequent cmake runs.
       set(file ${dir}/Test${Tag}_${Name}.cpp)
@@ -43,6 +46,11 @@ foreach(Tag Threads;Serial;OpenMP;HPX;Cuda;HIP;SYCL)
      LIST(REMOVE_ITEM UnitTestSources ${dir}/TestCuda_DynViewAPI_generic.cpp)
     endif()
 
+    # FIXME_NVHPC: NVC++-S-0000-Internal compiler error. extractor: bad opc       0
+    if(KOKKOS_ENABLE_CUDA AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
+     LIST(REMOVE_ITEM UnitTestSources ${dir}/TestCuda_WithoutInitializing.cpp)
+    endif()
+
     KOKKOS_ADD_EXECUTABLE_AND_TEST(ContainersUnitTest_${Tag} SOURCES ${UnitTestSources})
   endif()
 endforeach()
diff --git a/containers/unit_tests/Makefile b/containers/unit_tests/Makefile
index a6235983d5..18410882bc 100644
--- a/containers/unit_tests/Makefile
+++ b/containers/unit_tests/Makefile
@@ -31,12 +31,12 @@ KOKKOS_CXXFLAGS += -I$(GTEST_PATH) -I${KOKKOS_PATH}/containers/unit_tests -I${KO
 TEST_TARGETS =
 TARGETS =
 
-TESTS = Bitset DualView DynamicView DynViewAPI_generic DynViewAPI_rank12345 DynViewAPI_rank67 ErrorReporter OffsetView ScatterView StaticCrsGraph UnorderedMap Vector ViewCtorPropEmbeddedDim
+TESTS = Bitset DualView DynamicView DynViewAPI_generic DynViewAPI_rank12345 DynViewAPI_rank67 ErrorReporter OffsetView ScatterView StaticCrsGraph UnorderedMap ViewCtorPropEmbeddedDim
 tmp := $(foreach device, $(KOKKOS_DEVICELIST), \
   tmp2 := $(foreach test, $(TESTS), \
     $(if $(filter Test$(device)_$(test).cpp, $(shell ls Test$(device)_$(test).cpp 2>/dev/null)),,\
-      $(shell echo "\#include<Test"$(device)"_Category.hpp>" > Test$(device)_$(test).cpp); \
-      $(shell echo "\#include<Test"$(test)".hpp>" >> Test$(device)_$(test).cpp); \
+      $(shell echo "$(H)include<Test"$(device)"_Category.hpp>" > Test$(device)_$(test).cpp); \
+      $(shell echo "$(H)include<Test"$(test)".hpp>" >> Test$(device)_$(test).cpp); \
      )\
   ) \
 )
@@ -54,7 +54,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
 	OBJ_CUDA += TestCuda_ScatterView.o
 	OBJ_CUDA += TestCuda_StaticCrsGraph.o
 	OBJ_CUDA += TestCuda_UnorderedMap.o
-	OBJ_CUDA += TestCuda_Vector.o
 	OBJ_CUDA += TestCuda_ViewCtorPropEmbeddedDim.o
 	TARGETS += KokkosContainers_UnitTest_Cuda
 	TEST_TARGETS += test-cuda
@@ -73,7 +72,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
 	OBJ_THREADS += TestThreads_ScatterView.o
 	OBJ_THREADS += TestThreads_StaticCrsGraph.o
 	OBJ_THREADS += TestThreads_UnorderedMap.o
-	OBJ_THREADS += TestThreads_Vector.o
 	OBJ_THREADS += TestThreads_ViewCtorPropEmbeddedDim.o
 	TARGETS += KokkosContainers_UnitTest_Threads
 	TEST_TARGETS += test-threads
@@ -92,7 +90,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
 	OBJ_OPENMP += TestOpenMP_ScatterView.o
 	OBJ_OPENMP += TestOpenMP_StaticCrsGraph.o
 	OBJ_OPENMP += TestOpenMP_UnorderedMap.o
-	OBJ_OPENMP += TestOpenMP_Vector.o
 	OBJ_OPENMP += TestOpenMP_ViewCtorPropEmbeddedDim.o
 	TARGETS += KokkosContainers_UnitTest_OpenMP
 	TEST_TARGETS += test-openmp
@@ -111,7 +108,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
 	OBJ_HPX += TestHPX_ScatterView.o
 	OBJ_HPX += TestHPX_StaticCrsGraph.o
 	OBJ_HPX += TestHPX_UnorderedMap.o
-	OBJ_HPX += TestHPX_Vector.o
 	OBJ_HPX += TestHPX_ViewCtorPropEmbeddedDim.o
 	TARGETS += KokkosContainers_UnitTest_HPX
 	TEST_TARGETS += test-hpx
@@ -130,7 +126,6 @@ ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
 	OBJ_SERIAL += TestSerial_ScatterView.o
 	OBJ_SERIAL += TestSerial_StaticCrsGraph.o
 	OBJ_SERIAL += TestSerial_UnorderedMap.o
-	OBJ_SERIAL += TestSerial_Vector.o
 	OBJ_SERIAL += TestSerial_ViewCtorPropEmbeddedDim.o
 	TARGETS += KokkosContainers_UnitTest_Serial
 	TEST_TARGETS += test-serial
diff --git a/containers/unit_tests/TestBitset.hpp b/containers/unit_tests/TestBitset.hpp
index d97bdf9679..9923453f72 100644
--- a/containers/unit_tests/TestBitset.hpp
+++ b/containers/unit_tests/TestBitset.hpp
@@ -23,6 +23,8 @@
 #include <Kokkos_Bitset.hpp>
 #include <array>
 
+#include <../../core/unit_test/tools/include/ToolTestingUtilities.hpp>
+
 namespace Test {
 
 namespace Impl {
@@ -155,7 +157,7 @@ void test_bitset() {
 
   {
     unsigned ts = 100u;
-    bitset_type b1;
+    bitset_type b1(Kokkos::view_alloc("MyBitset"), 0);
     ASSERT_TRUE(b1.is_allocated());
 
     b1 = bitset_type(ts);
@@ -165,6 +167,9 @@ void test_bitset() {
     ASSERT_TRUE(b1.is_allocated());
     ASSERT_TRUE(b2.is_allocated());
     ASSERT_TRUE(b3.is_allocated());
+
+    bitset_type b4;
+    ASSERT_FALSE(b4.is_allocated());
   }
 
   std::array<unsigned, 7> test_sizes = {
@@ -190,19 +195,8 @@ void test_bitset() {
     {
       Impl::TestBitsetTest<const_bitset_type> f(bitset);
       uint32_t count = f.testit();
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-      if constexpr (!std::is_same_v<typename Device::execution_space,
-                                    Kokkos::Cuda>) {
-        EXPECT_EQ(bitset.size(), count);
-        EXPECT_EQ(count, bitset.count());
-      } else {
-        (void)count;
-      }
-#else
       EXPECT_EQ(bitset.size(), count);
       EXPECT_EQ(count, bitset.count());
-#endif
     }
 
     // std::cout << "  Check reset() " << std::endl;
@@ -248,6 +242,24 @@ void test_bitset() {
 }
 
 TEST(TEST_CATEGORY, bitset) { test_bitset<TEST_EXECSPACE>(); }
+
+TEST(TEST_CATEGORY, bitset_default_constructor_no_alloc) {
+  using namespace Kokkos::Test::Tools;
+  listen_tool_events(Config::DisableAll(), Config::EnableAllocs());
+
+  auto success = validate_absence(
+      [&]() {
+        Kokkos::Bitset bs;
+        EXPECT_FALSE(bs.is_allocated());
+      },
+      [&](AllocateDataEvent) {
+        return MatchDiagnostic{true, {"Found alloc event"}};
+      });
+  ASSERT_TRUE(success);
+
+  listen_tool_events(Config::DisableAll());
+}
+
 }  // namespace Test
 
 #endif  // KOKKOS_TEST_BITSET_HPP
diff --git a/containers/unit_tests/TestDualView.hpp b/containers/unit_tests/TestDualView.hpp
index 6e2e56c5cf..2512cb5c49 100644
--- a/containers/unit_tests/TestDualView.hpp
+++ b/containers/unit_tests/TestDualView.hpp
@@ -55,8 +55,49 @@ struct test_dualview_alloc {
   bool result = false;
 
   test_dualview_alloc(unsigned int size) {
-    result = run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(
-        size, 3);
+    result =
+        run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(size, 3);
+  }
+};
+
+template <typename Scalar, class Device>
+struct test_dualview_copy_construction_and_assignment {
+  using scalar_type     = Scalar;
+  using execution_space = Device;
+
+  void operator()() {
+    constexpr unsigned int n = 10;
+    constexpr unsigned int m = 5;
+
+    using SrcViewType = Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>;
+    using DstViewType =
+        Kokkos::DualView<const Scalar * [m], Kokkos::LayoutLeft, Device>;
+
+    SrcViewType a("A", n, m);
+
+    // Copy construction
+    DstViewType b(a);
+
+    // Copy assignment
+    DstViewType c = a;
+
+    // Check equality (shallow) of the host and device views
+    ASSERT_EQ(a.view_host(), b.view_host());
+    ASSERT_EQ(a.view_device(), b.view_device());
+
+    ASSERT_EQ(a.view_host(), c.view_host());
+    ASSERT_EQ(a.view_device(), c.view_device());
+
+    // We can't test shallow equality of modified_flags because it's protected.
+    // So we test it indirectly through sync state behavior.
+    if (!std::decay_t<SrcViewType>::impl_dualview_is_single_device::value) {
+      a.clear_sync_state();
+      a.modify_host();
+      ASSERT_TRUE(a.need_sync_device());
+      ASSERT_TRUE(b.need_sync_device());
+      ASSERT_TRUE(c.need_sync_device());
+      a.clear_sync_state();
+    }
   }
 };
 
@@ -113,7 +154,7 @@ struct test_dualview_combinations {
   }
 
   test_dualview_combinations(unsigned int size, bool with_init) {
-    result = run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(
+    result = run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(
         size, 3, with_init);
   }
 };
@@ -212,21 +253,18 @@ struct test_dual_view_deep_copy {
   }  // end run_me
 
   test_dual_view_deep_copy() {
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(10, 5,
-                                                                    true);
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(10, 5,
-                                                                    false);
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(10, 5, true);
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(10, 5,
+                                                                   false);
     // Test zero length but allocated (a.d_view.data!=nullptr but
     // a.d_view.span()==0)
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(0, 5, true);
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(0, 5,
-                                                                    false);
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(0, 5, true);
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(0, 5, false);
 
     // Test default constructed view
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(-1, 5,
-                                                                    true);
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >(-1, 5,
-                                                                    false);
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(-1, 5, true);
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>(-1, 5,
+                                                                   false);
   }
 };
 
@@ -241,15 +279,20 @@ struct test_dualview_resize {
     const unsigned int m      = 5;
     const unsigned int factor = 2;
 
-    ViewType a("A", n, m);
+    ViewType a;
+    if constexpr (Initialize)
+      a = ViewType("A", n, m);
+    else
+      a = ViewType(Kokkos::view_alloc(Kokkos::WithoutInitializing, "A"), n, m);
+
     Kokkos::deep_copy(a.d_view, 1);
 
     /* Covers case "Resize on Device" */
     a.modify_device();
-    if (Initialize)
-      Kokkos::resize(Kokkos::WithoutInitializing, a, factor * n, factor * m);
-    else
+    if constexpr (Initialize)
       Kokkos::resize(a, factor * n, factor * m);
+    else
+      Kokkos::resize(Kokkos::WithoutInitializing, a, factor * n, factor * m);
     ASSERT_EQ(a.extent(0), n * factor);
     ASSERT_EQ(a.extent(1), m * factor);
 
@@ -257,33 +300,38 @@ struct test_dualview_resize {
     a.sync_host();
 
     // Check device view is initialized as expected
-    scalar_type a_d_sum = 0;
     // Execute on the execution_space associated with t_dev's memory space
     using t_dev_exec_space =
         typename ViewType::t_dev::memory_space::execution_space;
-    Kokkos::parallel_reduce(
-        Kokkos::RangePolicy<t_dev_exec_space>(0, a.d_view.extent(0)),
-        SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(a.d_view),
-        a_d_sum);
+    Kokkos::View<int, typename ViewType::t_dev::memory_space> errors_d(
+        "errors");
+    Kokkos::parallel_for(
+        Kokkos::MDRangePolicy<t_dev_exec_space, Kokkos::Rank<2>>(
+            {0, 0}, {a.d_view.extent(0), a.d_view.extent(1)}),
+        KOKKOS_LAMBDA(int i, int j) {
+          if (a.d_view(i, j) != 1) Kokkos::atomic_inc(errors_d.data());
+        });
+    int errors_d_scalar;
+    Kokkos::deep_copy(errors_d_scalar, errors_d);
 
     // Check host view is synced as expected
-    scalar_type a_h_sum = 0;
+    int errors_h_scalar = 0;
     for (size_t i = 0; i < a.h_view.extent(0); ++i)
       for (size_t j = 0; j < a.h_view.extent(1); ++j) {
-        a_h_sum += a.h_view(i, j);
+        if (a.h_view(i, j) != 1) ++errors_h_scalar;
       }
 
     // Check
-    ASSERT_EQ(a_h_sum, a_d_sum);
-    ASSERT_EQ(a_h_sum, scalar_type(a.extent(0) * a.extent(1)));
+    ASSERT_EQ(errors_d_scalar, 0);
+    ASSERT_EQ(errors_h_scalar, 0);
 
     /* Covers case "Resize on Host" */
     a.modify_host();
 
-    if (Initialize)
-      Kokkos::resize(Kokkos::WithoutInitializing, a, n / factor, m / factor);
-    else
+    if constexpr (Initialize)
       Kokkos::resize(a, n / factor, m / factor);
+    else
+      Kokkos::resize(Kokkos::WithoutInitializing, a, n / factor, m / factor);
     ASSERT_EQ(a.extent(0), n / factor);
     ASSERT_EQ(a.extent(1), m / factor);
 
@@ -291,30 +339,33 @@ struct test_dualview_resize {
     a.sync_device(Kokkos::DefaultExecutionSpace{});
 
     // Check device view is initialized as expected
-    a_d_sum = 0;
+    Kokkos::deep_copy(errors_d, 0);
     // Execute on the execution_space associated with t_dev's memory space
     using t_dev_exec_space =
         typename ViewType::t_dev::memory_space::execution_space;
-    Kokkos::parallel_reduce(
-        Kokkos::RangePolicy<t_dev_exec_space>(0, a.d_view.extent(0)),
-        SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(a.d_view),
-        a_d_sum);
+    Kokkos::parallel_for(
+        Kokkos::MDRangePolicy<t_dev_exec_space, Kokkos::Rank<2>>(
+            {0, 0}, {a.d_view.extent(0), a.d_view.extent(1)}),
+        KOKKOS_LAMBDA(int i, int j) {
+          if (a.d_view(i, j) != 1) Kokkos::atomic_inc(errors_d.data());
+        });
+    Kokkos::deep_copy(errors_d_scalar, errors_d);
 
     // Check host view is synced as expected
-    a_h_sum = 0;
+    errors_h_scalar = 0;
     for (size_t i = 0; i < a.h_view.extent(0); ++i)
       for (size_t j = 0; j < a.h_view.extent(1); ++j) {
-        a_h_sum += a.h_view(i, j);
+        if (a.h_view(i, j) != 1) ++errors_h_scalar;
       }
 
     // Check
-    ASSERT_EQ(a_h_sum, scalar_type(a.extent(0) * a.extent(1)));
-    ASSERT_EQ(a_h_sum, a_d_sum);
+    ASSERT_EQ(errors_d_scalar, 0);
+    ASSERT_EQ(errors_h_scalar, 0);
 
   }  // end run_me
 
   test_dualview_resize() {
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >();
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>();
   }
 };
 
@@ -328,40 +379,51 @@ struct test_dualview_realloc {
     const unsigned int n = 10;
     const unsigned int m = 5;
 
-    ViewType a("A", n, m);
-    if (Initialize)
-      Kokkos::realloc(Kokkos::WithoutInitializing, a, n, m);
-    else
+    ViewType a;
+    if constexpr (Initialize) {
+      a = ViewType("A", n, m);
       Kokkos::realloc(a, n, m);
+    } else {
+      a = ViewType(Kokkos::view_alloc(Kokkos::WithoutInitializing, "A"), n, m);
+      Kokkos::realloc(Kokkos::WithoutInitializing, a, n, m);
+    }
+    ASSERT_EQ(a.extent(0), n);
+    ASSERT_EQ(a.extent(1), m);
 
     Kokkos::deep_copy(a.d_view, 1);
+
     a.modify_device();
     a.sync_host();
 
     // Check device view is initialized as expected
-    scalar_type a_d_sum = 0;
     // Execute on the execution_space associated with t_dev's memory space
     using t_dev_exec_space =
         typename ViewType::t_dev::memory_space::execution_space;
-    Kokkos::parallel_reduce(
-        Kokkos::RangePolicy<t_dev_exec_space>(0, a.d_view.extent(0)),
-        SumViewEntriesFunctor<scalar_type, typename ViewType::t_dev>(a.d_view),
-        a_d_sum);
+    Kokkos::View<int, typename ViewType::t_dev::memory_space> errors_d(
+        "errors");
+    Kokkos::parallel_for(
+        Kokkos::MDRangePolicy<t_dev_exec_space, Kokkos::Rank<2>>(
+            {0, 0}, {a.d_view.extent(0), a.d_view.extent(1)}),
+        KOKKOS_LAMBDA(int i, int j) {
+          if (a.d_view(i, j) != 1) Kokkos::atomic_inc(errors_d.data());
+        });
+    int errors_d_scalar;
+    Kokkos::deep_copy(errors_d_scalar, errors_d);
 
     // Check host view is synced as expected
-    scalar_type a_h_sum = 0;
+    int errors_h_scalar = 0;
     for (size_t i = 0; i < a.h_view.extent(0); ++i)
       for (size_t j = 0; j < a.h_view.extent(1); ++j) {
-        a_h_sum += a.h_view(i, j);
+        if (a.h_view(i, j) != 1) ++errors_h_scalar;
       }
 
     // Check
-    ASSERT_EQ(a_h_sum, scalar_type(a.extent(0) * a.extent(1)));
-    ASSERT_EQ(a_h_sum, a_d_sum);
+    ASSERT_EQ(errors_d_scalar, 0);
+    ASSERT_EQ(errors_h_scalar, 0);
   }  // end run_me
 
   test_dualview_realloc() {
-    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device> >();
+    run_me<Kokkos::DualView<Scalar**, Kokkos::LayoutLeft, Device>>();
   }
 };
 
@@ -379,6 +441,11 @@ void test_dualview_alloc(unsigned int size) {
   ASSERT_TRUE(test.result);
 }
 
+template <typename Scalar, typename Device>
+void test_dualview_copy_construction_and_assignment() {
+  Impl::test_dualview_copy_construction_and_assignment<Scalar, Device>()();
+}
+
 template <typename Scalar, typename Device>
 void test_dualview_deep_copy() {
   Impl::test_dual_view_deep_copy<Scalar, Device>();
@@ -404,6 +471,10 @@ TEST(TEST_CATEGORY, dualview_alloc) {
   test_dualview_alloc<int, TEST_EXECSPACE>(10);
 }
 
+TEST(TEST_CATEGORY, test_dualview_copy_construction_and_assignment) {
+  test_dualview_copy_construction_and_assignment<int, TEST_EXECSPACE>();
+}
+
 TEST(TEST_CATEGORY, dualview_combinations_without_init) {
   test_dualview_combinations<int, TEST_EXECSPACE>(10, false);
 }
@@ -413,12 +484,23 @@ TEST(TEST_CATEGORY, dualview_deep_copy) {
   test_dualview_deep_copy<double, TEST_EXECSPACE>();
 }
 
+struct NoDefaultConstructor {
+  NoDefaultConstructor(int i_) : i(i_) {}
+  KOKKOS_FUNCTION operator int() const { return i; }
+
+  int i;
+};
+
 TEST(TEST_CATEGORY, dualview_realloc) {
   test_dualview_realloc<int, TEST_EXECSPACE>();
+  Impl::test_dualview_realloc<NoDefaultConstructor, TEST_EXECSPACE,
+                              /* Initialize */ false>();
 }
 
 TEST(TEST_CATEGORY, dualview_resize) {
   test_dualview_resize<int, TEST_EXECSPACE>();
+  Impl::test_dualview_resize<NoDefaultConstructor, TEST_EXECSPACE,
+                             /* Initialize */ false>();
 }
 
 namespace {
diff --git a/containers/unit_tests/TestUnorderedMap.hpp b/containers/unit_tests/TestUnorderedMap.hpp
index 296c9f42ac..4a7e826ecb 100644
--- a/containers/unit_tests/TestUnorderedMap.hpp
+++ b/containers/unit_tests/TestUnorderedMap.hpp
@@ -68,7 +68,7 @@ struct TestInsert {
     } while (rehash_on_fail && failed_count > 0u);
 
     // Trigger the m_size mutable bug.
-    typename map_type::HostMirror map_h;
+    auto map_h = create_mirror(map);
     execution_space().fence();
     Kokkos::deep_copy(map_h, map);
     execution_space().fence();
@@ -367,7 +367,7 @@ void test_deep_copy(uint32_t num_nodes) {
     }
   }
 
-  host_map_type hmap;
+  auto hmap = create_mirror(map);
   Kokkos::deep_copy(hmap, map);
 
   ASSERT_EQ(map.size(), hmap.size());
@@ -380,6 +380,7 @@ void test_deep_copy(uint32_t num_nodes) {
   }
 
   map_type mmap;
+  mmap.allocate_view(hmap);
   Kokkos::deep_copy(mmap, hmap);
 
   const_map_type cmap = mmap;
@@ -396,12 +397,6 @@ void test_deep_copy(uint32_t num_nodes) {
 
 #if !defined(_WIN32)
 TEST(TEST_CATEGORY, UnorderedMap_insert) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Cuda>) {
-    GTEST_SKIP() << "unit test is hanging from index 0";
-  }
-#endif
   for (int i = 0; i < 500; ++i) {
     test_inserts<TEST_EXECSPACE>(100000, 90000, 100, true);
     test_inserts<TEST_EXECSPACE>(100000, 90000, 100, false);
@@ -418,12 +413,6 @@ TEST(TEST_CATEGORY, UnorderedMap_failed_insert) {
 }
 
 TEST(TEST_CATEGORY, UnorderedMap_deep_copy) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Cuda>) {
-    GTEST_SKIP() << "unit test is hanging from index 0";
-  }
-#endif
   for (int i = 0; i < 2; ++i) test_deep_copy<TEST_EXECSPACE>(10000);
 }
 
@@ -436,22 +425,62 @@ TEST(TEST_CATEGORY, UnorderedMap_valid_empty) {
   Map n{};
   n = Map{m.capacity()};
   n.rehash(m.capacity());
-  Kokkos::deep_copy(n, m);
+  n.create_copy_view(m);
   ASSERT_TRUE(m.is_allocated());
   ASSERT_TRUE(n.is_allocated());
 }
 
+/**
+ * This helper is needed because NVCC does not like extended lambdas
+ * in private member functions.
+ * Google Test bodies are private member functions. So it is incompatible.
+ * See also https://github.com/google/googletest/issues/4104.
+ */
+template <typename map_type>
+struct UnorderedMapInsert {
+  //! Type of range-for policy and its index type.
+  using range_policy_t =
+      Kokkos::RangePolicy<typename map_type::execution_space,
+                          Kokkos::IndexType<unsigned short int>>;
+  using index_t = typename range_policy_t::index_type;
+
+  const map_type m_map;
+
+  //! Ensure shared ownership of @ref m_map.
+  UnorderedMapInsert(map_type map) : m_map(std::move(map)) {}
+
+  //! Insert a single value.
+  template <typename T>
+  void insert_single(const T &arg) const {
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename map_type::execution_space>(0, 1),
+        // NOLINTNEXTLINE(kokkos-implicit-this-capture)
+        KOKKOS_CLASS_LAMBDA(const index_t) { m_map.insert(arg); });
+  }
+
+  //! Insert multiple values.
+  template <typename... Args>
+  void insert(Args &&... args) const {
+    static_assert(sizeof...(Args) > 1, "Prefer the single value version");
+    constexpr size_t size = sizeof...(Args);
+    Kokkos::Array<typename map_type::key_type, size> values{
+        std::forward<Args>(args)...};
+    Kokkos::parallel_for(
+        Kokkos::RangePolicy<typename map_type::execution_space>(0, size),
+        // NOLINTNEXTLINE(kokkos-implicit-this-capture)
+        KOKKOS_CLASS_LAMBDA(const index_t i) { m_map.insert(values[i]); });
+  }
+};
+
 TEST(TEST_CATEGORY, UnorderedMap_clear_zero_size) {
-  using Map =
-      Kokkos::UnorderedMap<int, void, Kokkos::DefaultHostExecutionSpace>;
+  using map_type = Kokkos::UnorderedMap<int, void, TEST_EXECSPACE>;
+
+  map_type m(11);
 
-  Map m(11);
   ASSERT_EQ(0u, m.size());
 
-  m.insert(2);
-  m.insert(3);
-  m.insert(5);
-  m.insert(7);
+  UnorderedMapInsert<map_type>(m).insert(2, 3, 5, 7);
+
   ASSERT_EQ(4u, m.size());
   m.rehash(0);
   ASSERT_EQ(128u, m.capacity());
@@ -462,19 +491,22 @@ TEST(TEST_CATEGORY, UnorderedMap_clear_zero_size) {
 }
 
 TEST(TEST_CATEGORY, UnorderedMap_consistent_size) {
-  using Map =
-      Kokkos::UnorderedMap<int, void, Kokkos::DefaultHostExecutionSpace>;
+  using map_type = Kokkos::UnorderedMap<int, void, TEST_EXECSPACE>;
+
+  map_type m(11);
+  UnorderedMapInsert<map_type> inserter(m);
+
+  inserter.insert_single(7);
 
-  Map m(11);
-  m.insert(7);
-  ;
   ASSERT_EQ(1u, m.size());
 
   {
-    auto m2 = m;
-    m2.insert(2);
+    auto m_copy = m;
+    UnorderedMapInsert<decltype(m_copy)> inserter_copy(m_copy);
+    inserter_copy.insert_single(2);
     // This line triggers modified flags to be cleared in both m and m2
-    [[maybe_unused]] auto sz = m2.size();
+    const auto sz = m_copy.size();
+    ASSERT_EQ(2u, sz);
   }
 
   ASSERT_EQ(2u, m.size());
@@ -519,6 +551,18 @@ TEST(TEST_CATEGORY, UnorderedMap_lambda_capturable) {
 }
 #endif
 
+/**
+ * @test This test ensures that an @ref UnorderedMap can be built
+ *       with an execution space instance (using @ref view_alloc).
+ */
+TEST(TEST_CATEGORY, UnorderedMap_constructor_view_alloc) {
+  using map_type = Kokkos::UnorderedMap<size_t, void, TEST_EXECSPACE>;
+  map_type map(Kokkos::view_alloc(TEST_EXECSPACE{}, "test umap"), 150);
+  ASSERT_EQ(map.size(), 0u);
+  ASSERT_GE(map.capacity(), 150u);
+  ASSERT_TRUE(map.is_allocated());
+}
+
 }  // namespace Test
 
 #endif  // KOKKOS_TEST_UNORDERED_MAP_HPP
diff --git a/containers/unit_tests/TestVector.hpp b/containers/unit_tests/TestVector.hpp
index a7d341b789..abed2676d7 100644
--- a/containers/unit_tests/TestVector.hpp
+++ b/containers/unit_tests/TestVector.hpp
@@ -21,6 +21,8 @@
 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
+#include <Kokkos_Macros.hpp>
+KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
 #include <Kokkos_Vector.hpp>
 
 namespace Test {
@@ -231,7 +233,7 @@ void test_vector_allocate(unsigned int size) {
 TEST(TEST_CATEGORY, vector_combination) {
   test_vector_allocate<int, TEST_EXECSPACE>(10);
   test_vector_combinations<int, TEST_EXECSPACE>(10);
-  test_vector_combinations<int, TEST_EXECSPACE>(3057);
+  test_vector_combinations<long long int, TEST_EXECSPACE>(3057);
 }
 
 TEST(TEST_CATEGORY, vector_insert) {
diff --git a/core/perf_test/CMakeLists.txt b/core/perf_test/CMakeLists.txt
index 66319f43f5..e0dba03e1e 100644
--- a/core/perf_test/CMakeLists.txt
+++ b/core/perf_test/CMakeLists.txt
@@ -3,6 +3,9 @@
 IF ((KOKKOS_ENABLE_OPENMPTARGET OR KOKKOS_ENABLE_OPENACC) AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
   RETURN()
 ENDIF()
+IF (KOKKOS_ENABLE_OPENACC AND KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+  RETURN()
+ENDIF()
 
 # all PerformanceTest_* executables are part of regular tests
 # TODO: finish converting these into benchmarks (in progress)
@@ -35,7 +38,7 @@ IF (KOKKOS_HAS_TRILINOS)
 ENDIF()
 
 # Find or download google/benchmark library
-find_package(benchmark QUIET)
+find_package(benchmark QUIET 1.5.6)
 IF(benchmark_FOUND)
   MESSAGE(STATUS "Using google benchmark found in ${benchmark_DIR}")
 ELSE()
@@ -46,8 +49,9 @@ ELSE()
   list(APPEND CMAKE_MESSAGE_INDENT "[benchmark] ")
   FetchContent_Declare(
     googlebenchmark
-    URL https://github.com/google/benchmark/archive/refs/tags/v1.6.2.tar.gz
-    URL_HASH MD5=14d14849e075af116143a161bc3b927b
+    DOWNLOAD_EXTRACT_TIMESTAMP FALSE
+    URL https://github.com/google/benchmark/archive/refs/tags/v1.7.1.tar.gz
+    URL_HASH MD5=0459a6c530df9851bee6504c3e37c2e7
   )
   FetchContent_MakeAvailable(googlebenchmark)
   list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -123,6 +127,7 @@ SET(
   PerfTest_CustomReduction.cpp
   PerfTest_ExecSpacePartitioning.cpp
   PerfTestHexGrad.cpp
+  PerfTest_MallocFree.cpp
   PerfTest_ViewAllocate.cpp
   PerfTest_ViewCopy_a123.cpp
   PerfTest_ViewCopy_b123.cpp
diff --git a/core/perf_test/PerfTest_MallocFree.cpp b/core/perf_test/PerfTest_MallocFree.cpp
new file mode 100644
index 0000000000..80736d9915
--- /dev/null
+++ b/core/perf_test/PerfTest_MallocFree.cpp
@@ -0,0 +1,100 @@
+//@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 <benchmark/benchmark.h>
+#include "Benchmark_Context.hpp"
+
+namespace Benchmark {
+
+// when the time will be recorded
+enum class When { after_malloc, after_touch, after_free };
+
+static void Impl(benchmark::State& state, const bool touch, const When when) {
+  const size_t N = state.range(0);
+  for (auto _ : state) {
+    Kokkos::Timer timer;
+    char* a_ptr = static_cast<char*>(Kokkos::kokkos_malloc("A", N));
+    if (When::after_malloc == when) {
+      state.SetIterationTime(timer.seconds());
+    }
+    if (touch) {
+      constexpr size_t STRIDE = 1024;  // stride for touching the allocation.
+      // this is intended to be a safe value that would touch every "page", but
+      // not saturate the memory bandwidth
+      Kokkos::parallel_for(
+          N / STRIDE,
+          KOKKOS_LAMBDA(const size_t& i) { a_ptr[i * STRIDE] = i * STRIDE; });
+      Kokkos::fence();
+    }
+    if (When::after_touch == when) {
+      state.SetIterationTime(timer.seconds());
+    }
+    Kokkos::kokkos_free(a_ptr);
+    if (When::after_free == when) {
+      state.SetIterationTime(timer.seconds());
+    }
+  }
+
+  state.counters[KokkosBenchmark::benchmark_fom("rate")] =
+      benchmark::Counter(state.iterations(), benchmark::Counter::kIsRate);
+}
+
+static void Malloc(benchmark::State& state) {
+  Impl(state, false, When::after_malloc);
+}
+
+static void MallocFree(benchmark::State& state) {
+  Impl(state, false, When::after_free);
+}
+
+static void MallocTouch(benchmark::State& state) {
+  Impl(state, true, When::after_touch);
+}
+
+static void MallocTouchFree(benchmark::State& state) {
+  Impl(state, true, When::after_free);
+}
+
+BENCHMARK(Malloc)
+    ->ArgName("N")
+    ->RangeMultiplier(16)
+    ->Range(1, int64_t(1) << 32)
+    ->UseManualTime()
+    ->Unit(benchmark::kMicrosecond);
+
+BENCHMARK(MallocFree)
+    ->ArgName("N")
+    ->RangeMultiplier(16)
+    ->Range(1, int64_t(1) << 32)
+    ->UseManualTime()
+    ->Unit(benchmark::kMicrosecond);
+
+BENCHMARK(MallocTouch)
+    ->ArgName("N")
+    ->RangeMultiplier(16)
+    ->Range(1, int64_t(1) << 32)
+    ->UseManualTime()
+    ->Unit(benchmark::kMicrosecond);
+
+BENCHMARK(MallocTouchFree)
+    ->ArgName("N")
+    ->RangeMultiplier(16)
+    ->Range(1, int64_t(1) << 32)
+    ->UseManualTime()
+    ->Unit(benchmark::kMicrosecond);
+
+}  // namespace Benchmark
diff --git a/core/perf_test/PerfTest_ViewAllocate.cpp b/core/perf_test/PerfTest_ViewAllocate.cpp
index 63f1d6b2c7..163e1d7d04 100644
--- a/core/perf_test/PerfTest_ViewAllocate.cpp
+++ b/core/perf_test/PerfTest_ViewAllocate.cpp
@@ -115,28 +115,6 @@ static void ViewAllocate_Rank8(benchmark::State& state) {
   }
 }
 
-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;
-    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);
-  }
-}
-
 BENCHMARK(ViewAllocate_Rank1<Kokkos::LayoutLeft>)
     ->ArgName("N")
     ->Arg(N)
@@ -217,16 +195,4 @@ BENCHMARK(ViewAllocate_Rank8<Kokkos::LayoutRight>)
     ->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/test_atomic.cpp b/core/perf_test/test_atomic.cpp
index ce3059f47d..af74723e7e 100644
--- a/core/perf_test/test_atomic.cpp
+++ b/core/perf_test/test_atomic.cpp
@@ -390,7 +390,7 @@ static void Test_Atomic(benchmark::State& state) {
 
 static constexpr int LOOP = 100'000;
 
-BENCHMARK(Test_Atomic<int>)->Arg(LOOP)->Iterations(10);
+BENCHMARK(Test_Atomic<int>)->Arg(30'000)->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);
@@ -398,4 +398,3 @@ 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 b838c8eccf..bc35d1c776 100644
--- a/core/perf_test/test_atomic_minmax_simple.cpp
+++ b/core/perf_test/test_atomic_minmax_simple.cpp
@@ -183,7 +183,8 @@ double atomic_contentious_max_replacement(benchmark::State& state,
   Kokkos::parallel_reduce(
       con_length,
       KOKKOS_LAMBDA(const int i, T& inner) {
-        inner = Kokkos::atomic_max_fetch(&(input(0)), inner + 1);
+        inner = Kokkos::atomic_max_fetch(&(input(0)),
+                                         Kokkos::min(inner, max - 1) + 1);
         if (i == con_length - 1) {
           Kokkos::atomic_max_fetch(&(input(0)), max);
           inner = max;
@@ -223,7 +224,8 @@ double atomic_contentious_min_replacement(benchmark::State& state,
   Kokkos::parallel_reduce(
       con_length,
       KOKKOS_LAMBDA(const int i, T& inner) {
-        inner = Kokkos::atomic_min_fetch(&(input(0)), inner - 1);
+        inner = Kokkos::atomic_min_fetch(&(input(0)),
+                                         Kokkos::max(inner, min + 1) - 1);
         if (i == con_length - 1) {
           Kokkos::atomic_min_fetch(&(input(0)), min);
           inner = min;
@@ -246,7 +248,7 @@ static void Atomic_ContentiousMinReplacements(benchmark::State& state) {
   auto inp          = prepare_input(1, std::numeric_limits<T>::max());
 
   for (auto _ : state) {
-    const auto time = atomic_contentious_max_replacement(state, inp, length);
+    const auto time = atomic_contentious_min_replacement(state, inp, length);
 
     state.SetIterationTime(time);
   }
diff --git a/core/perf_test/test_mempool.cpp b/core/perf_test/test_mempool.cpp
index abb6180346..9905740afb 100644
--- a/core/perf_test/test_mempool.cpp
+++ b/core/perf_test/test_mempool.cpp
@@ -17,6 +17,7 @@
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
+#include <iostream>
 #include <limits>
 
 #include <benchmark/benchmark.h>
diff --git a/core/perf_test/test_taskdag.cpp b/core/perf_test/test_taskdag.cpp
index bbb48af6c4..fccaab64dd 100644
--- a/core/perf_test/test_taskdag.cpp
+++ b/core/perf_test/test_taskdag.cpp
@@ -14,6 +14,8 @@
 //
 //@HEADER
 
+#include <iostream>
+
 #include <Kokkos_Core.hpp>
 
 #if !defined(KOKKOS_ENABLE_TASKDAG) || \
diff --git a/core/src/CMakeLists.txt b/core/src/CMakeLists.txt
index 012af0a7d0..b84677e61b 100644
--- a/core/src/CMakeLists.txt
+++ b/core/src/CMakeLists.txt
@@ -18,10 +18,16 @@ IF (NOT desul_FOUND)
   ENDIF()
   IF(KOKKOS_ENABLE_SYCL)
     SET(DESUL_ATOMICS_ENABLE_SYCL ON)
+    IF(KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED AND NOT KOKKOS_IMPL_HAVE_SYCL_EXT_ONEAPI_DEVICE_GLOBAL)
+      SET(DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION ON)
+    ENDIF()
   ENDIF()
   IF(KOKKOS_ENABLE_OPENMPTARGET)
     SET(DESUL_ATOMICS_ENABLE_OPENMP ON) # not a typo Kokkos OpenMPTarget -> Desul OpenMP
   ENDIF()
+  IF(KOKKOS_ENABLE_OPENACC)
+    SET(DESUL_ATOMICS_ENABLE_OPENACC ON)
+  ENDIF()
   CONFIGURE_FILE(
     ${CMAKE_CURRENT_SOURCE_DIR}/../../tpls/desul/Config.hpp.cmake.in
     ${CMAKE_CURRENT_BINARY_DIR}/desul/atomics/Config.hpp
@@ -80,10 +86,6 @@ IF (KOKKOS_ENABLE_HPX)
   APPEND_GLOB(KOKKOS_CORE_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/HPX/*.hpp)
 ENDIF()
 
-IF (NOT KOKKOS_ENABLE_MEMKIND)
-  LIST(REMOVE_ITEM KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/impl/Kokkos_HBWSpace.cpp)
-ENDIF()
-
 IF (KOKKOS_ENABLE_SERIAL)
   APPEND_GLOB(KOKKOS_CORE_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/Serial/*.cpp)
   APPEND_GLOB(KOKKOS_CORE_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Serial/*.hpp)
@@ -180,20 +182,15 @@ IF (Kokkos_ENABLE_IMPL_MDSPAN)
 ENDIF()
 
 KOKKOS_LINK_TPL(kokkoscore PUBLIC HWLOC)
-KOKKOS_LINK_TPL(kokkoscore PUBLIC MEMKIND)
-IF (NOT KOKKOS_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
-  KOKKOS_LINK_TPL(kokkoscore PUBLIC CUDA)
-ENDIF()
+KOKKOS_LINK_TPL(kokkoscore PUBLIC CUDA)
 KOKKOS_LINK_TPL(kokkoscore PUBLIC HPX)
 KOKKOS_LINK_TPL(kokkoscore PUBLIC LIBDL)
-KOKKOS_LINK_TPL(kokkoscore PUBLIC LIBRT)
 # On *nix-like systems (Linux, macOS) we need pthread for C++ std::thread
 IF (NOT WIN32)
   KOKKOS_LINK_TPL(kokkoscore PUBLIC THREADS)
 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
diff --git a/core/src/Cuda/Kokkos_Cuda.hpp b/core/src/Cuda/Kokkos_Cuda.hpp
index 6c78a7984d..fd86976d3b 100644
--- a/core/src/Cuda/Kokkos_Cuda.hpp
+++ b/core/src/Cuda/Kokkos_Cuda.hpp
@@ -46,7 +46,6 @@ static_assert(false,
 
 namespace Kokkos {
 namespace Impl {
-class CudaExec;
 class CudaInternal;
 }  // namespace Impl
 }  // namespace Kokkos
@@ -80,6 +79,9 @@ struct CudaDispatchProperties {
   CudaLaunchMechanism launch_mechanism = l;
 };
 }  // namespace Experimental
+
+enum class ManageStream : bool { no, yes };
+
 }  // namespace Impl
 /// \class Cuda
 /// \brief Kokkos Execution Space that uses CUDA to run on GPUs.
@@ -126,33 +128,16 @@ class Cuda {
 
   /// \brief True if and only if this method is being called in a
   ///   thread-parallel function.
-  KOKKOS_INLINE_FUNCTION static int in_parallel() {
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED KOKKOS_INLINE_FUNCTION static int in_parallel() {
 #if defined(__CUDA_ARCH__)
     return true;
 #else
     return false;
 #endif
   }
-
-  /** \brief  Set the device in a "sleep" state.
-   *
-   * This function sets the device in a "sleep" state in which it is
-   * not ready for work.  This may consume less resources than if the
-   * device were in an "awake" state, but it may also take time to
-   * bring the device from a sleep state to be ready for work.
-   *
-   * \return True if the device is in the "sleep" state, else false if
-   *   the device is actively working and could not enter the "sleep"
-   *   state.
-   */
-  static bool sleep();
-
-  /// \brief Wake the device from the 'sleep' state so it is ready for work.
-  ///
-  /// \return True if the device is in the "ready" state, else "false"
-  ///  if the device is actively working (which also means that it's
-  ///  awake).
-  static bool wake();
+#endif
 
   /// \brief Wait until all dispatched functors complete.
   ///
@@ -181,7 +166,19 @@ class Cuda {
 
   Cuda();
 
-  Cuda(cudaStream_t stream, bool manage_stream = false);
+  explicit Cuda(cudaStream_t stream) : Cuda(stream, Impl::ManageStream::no) {}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT(
+      "Cuda execution space should be constructed explicitly.")
+  Cuda(cudaStream_t stream)
+      : Cuda(stream) {}
+#endif
+
+  Cuda(cudaStream_t stream, Impl::ManageStream manage_stream);
+
+  KOKKOS_DEPRECATED Cuda(cudaStream_t stream, bool manage_stream);
 
   //--------------------------------------------------------------------------
   //! Free any resources being consumed by the device.
@@ -193,18 +190,37 @@ class Cuda {
   //! Initialize, telling the CUDA run-time library which device to use.
   static void impl_initialize(InitializationSettings const&);
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   /// \brief Cuda device architecture of the selected device.
   ///
   /// This matches the __CUDA_ARCH__ specification.
-  static size_type device_arch();
+  KOKKOS_DEPRECATED static size_type device_arch() {
+    const cudaDeviceProp cudaProp = Cuda().cuda_device_prop();
+    return cudaProp.major * 100 + cudaProp.minor;
+  }
 
   //! Query device count.
-  static size_type detect_device_count();
+  KOKKOS_DEPRECATED static size_type detect_device_count() {
+    int count;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&count));
+    return count;
+  }
 
   /** \brief  Detect the available devices and their architecture
    *          as defined by the __CUDA_ARCH__ specification.
    */
-  static std::vector<unsigned> detect_device_arch();
+  KOKKOS_DEPRECATED static std::vector<unsigned> detect_device_arch() {
+    int count;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&count));
+    std::vector<unsigned> out;
+    for (int i = 0; i < count; ++i) {
+      cudaDeviceProp prop;
+      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceProperties(&prop, i));
+      out.push_back(prop.major * 100 + prop.minor);
+    }
+    return out;
+  }
+#endif
 
   cudaStream_t cuda_stream() const;
   int cuda_device() const;
diff --git a/core/src/Cuda/Kokkos_CudaSpace.cpp b/core/src/Cuda/Kokkos_CudaSpace.cpp
index 334c93d17e..75318aff77 100644
--- a/core/src/Cuda/Kokkos_CudaSpace.cpp
+++ b/core/src/Cuda/Kokkos_CudaSpace.cpp
@@ -33,7 +33,6 @@
 
 //#include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
 #include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
 
 #include <impl/Kokkos_Tools.hpp>
 
@@ -43,7 +42,8 @@
 cudaStream_t Kokkos::Impl::cuda_get_deep_copy_stream() {
   static cudaStream_t s = nullptr;
   if (s == nullptr) {
-    cudaStreamCreate(&s);
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        (CudaInternal::singleton().cuda_stream_create_wrapper(&s)));
   }
   return s;
 }
@@ -59,31 +59,28 @@ const std::unique_ptr<Kokkos::Cuda> &Kokkos::Impl::cuda_get_deep_copy_space(
 namespace Kokkos {
 namespace Impl {
 
-namespace {
-
-static std::atomic<int> num_uvm_allocations(0);
-
-}  // namespace
-
 void DeepCopyCuda(void *dst, const void *src, size_t n) {
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaMemcpy(dst, src, n, cudaMemcpyDefault));
+  KOKKOS_IMPL_CUDA_SAFE_CALL((CudaInternal::singleton().cuda_memcpy_wrapper(
+      dst, src, n, cudaMemcpyDefault)));
 }
 
 void DeepCopyAsyncCuda(const Cuda &instance, void *dst, const void *src,
                        size_t n) {
   KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMemcpyAsync(dst, src, n, cudaMemcpyDefault, instance.cuda_stream()));
+      (instance.impl_internal_space_instance()->cuda_memcpy_async_wrapper(
+          dst, src, n, cudaMemcpyDefault)));
 }
 
 void DeepCopyAsyncCuda(void *dst, const void *src, size_t n) {
   cudaStream_t s = cuda_get_deep_copy_stream();
   KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMemcpyAsync(dst, src, n, cudaMemcpyDefault, s));
-  Impl::cuda_stream_synchronize(
-      s,
+      (CudaInternal::singleton().cuda_memcpy_async_wrapper(
+          dst, src, n, cudaMemcpyDefault, s)));
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Cuda>(
+      "Kokkos::Impl::DeepCopyAsyncCuda: Deep Copy Stream Sync",
       Kokkos::Tools::Experimental::SpecialSynchronizationCases::
           DeepCopyResourceSynchronization,
-      "Kokkos::Impl::DeepCopyAsyncCuda: Deep Copy Stream Sync");
+      [&]() { KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamSynchronize(s)); });
 }
 
 }  // namespace Impl
@@ -131,13 +128,25 @@ void kokkos_impl_cuda_set_pin_uvm_to_host(bool val) {
 
 namespace Kokkos {
 
-CudaSpace::CudaSpace() : m_device(Kokkos::Cuda().cuda_device()) {}
+CudaSpace::CudaSpace()
+    : m_device(Kokkos::Cuda().cuda_device()),
+      m_stream(Kokkos::Cuda().cuda_stream()) {}
+CudaSpace::CudaSpace(int device_id, cudaStream_t stream)
+    : m_device(device_id), m_stream(stream) {}
 
-CudaUVMSpace::CudaUVMSpace() : m_device(Kokkos::Cuda().cuda_device()) {}
+CudaUVMSpace::CudaUVMSpace()
+    : m_device(Kokkos::Cuda().cuda_device()),
+      m_stream(Kokkos::Cuda().cuda_stream()) {}
+CudaUVMSpace::CudaUVMSpace(int device_id, cudaStream_t stream)
+    : m_device(device_id), m_stream(stream) {}
 
-CudaHostPinnedSpace::CudaHostPinnedSpace() {}
+CudaHostPinnedSpace::CudaHostPinnedSpace()
+    : m_device(Kokkos::Cuda().cuda_device()),
+      m_stream(Kokkos::Cuda().cuda_stream()) {}
+CudaHostPinnedSpace::CudaHostPinnedSpace(int device_id, cudaStream_t stream)
+    : m_device(device_id), m_stream(stream) {}
 
-int memory_threshold_g = 40000;  // 40 kB
+size_t memory_threshold_g = 40000;  // 40 kB
 
 //==============================================================================
 // <editor-fold desc="allocate()"> {{{1
@@ -157,43 +166,39 @@ void *CudaSpace::allocate(const char *arg_label, const size_t arg_alloc_size,
 }
 
 namespace {
-void *impl_allocate_common(const Cuda &exec_space, const char *arg_label,
-                           const size_t arg_alloc_size,
+void *impl_allocate_common(const int device_id,
+                           [[maybe_unused]] const cudaStream_t stream,
+                           const char *arg_label, const size_t arg_alloc_size,
                            const size_t arg_logical_size,
                            const Kokkos::Tools::SpaceHandle arg_handle,
-                           bool exec_space_provided) {
+                           [[maybe_unused]] bool stream_sync_only) {
   void *ptr = nullptr;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(device_id));
 
+  cudaError_t error_code = cudaSuccess;
 #ifndef CUDART_VERSION
 #error CUDART_VERSION undefined!
 #elif (defined(KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC) && CUDART_VERSION >= 11020)
-  cudaError_t error_code;
   if (arg_alloc_size >= memory_threshold_g) {
-    if (exec_space_provided) {
-      cudaStream_t stream = exec_space.cuda_stream();
-      error_code          = cudaMallocAsync(&ptr, arg_alloc_size, stream);
-      exec_space.fence("Kokkos::Cuda: backend fence after async malloc");
-    } else {
-      error_code = cudaMallocAsync(&ptr, arg_alloc_size, 0);
-      Impl::cuda_device_synchronize(
-          "Kokkos::Cuda: backend fence after async malloc");
+    error_code = cudaMallocAsync(&ptr, arg_alloc_size, stream);
+
+    if (error_code == cudaSuccess) {
+      if (stream_sync_only) {
+        KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamSynchronize(stream));
+      } else {
+        Impl::cuda_device_synchronize(
+            "Kokkos::Cuda: backend fence after async malloc");
+      }
     }
-  } else {
-    error_code = cudaMalloc(&ptr, arg_alloc_size);
-  }
-#else
-  (void)exec_space;
-  (void)exec_space_provided;
-  auto error_code = cudaMalloc(&ptr, arg_alloc_size);
+  } else
 #endif
+  { error_code = cudaMalloc(&ptr, arg_alloc_size); }
   if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
-    cudaGetLastError();  // This is the only way to clear the last error, which
-                         // we should do here since we're turning it into an
-                         // exception here
-    throw Experimental::CudaRawMemoryAllocationFailure(
-        arg_alloc_size, error_code,
-        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-            CudaMalloc);
+    // This is the only way to clear the last error, which
+    // we should do here since we're turning it into an
+    // exception here
+    cudaGetLastError();
+    Kokkos::Impl::throw_bad_alloc(arg_handle.name, arg_alloc_size, arg_label);
   }
 
   if (Kokkos::Profiling::profileLibraryLoaded()) {
@@ -209,7 +214,7 @@ void *CudaSpace::impl_allocate(
     const char *arg_label, const size_t arg_alloc_size,
     const size_t arg_logical_size,
     const Kokkos::Tools::SpaceHandle arg_handle) const {
-  return impl_allocate_common(Kokkos::Cuda{}, arg_label, arg_alloc_size,
+  return impl_allocate_common(m_device, m_stream, arg_label, arg_alloc_size,
                               arg_logical_size, arg_handle, false);
 }
 
@@ -217,8 +222,9 @@ void *CudaSpace::impl_allocate(
     const Cuda &exec_space, const char *arg_label, const size_t arg_alloc_size,
     const size_t arg_logical_size,
     const Kokkos::Tools::SpaceHandle arg_handle) const {
-  return impl_allocate_common(exec_space, arg_label, arg_alloc_size,
-                              arg_logical_size, arg_handle, true);
+  return impl_allocate_common(
+      exec_space.cuda_device(), exec_space.cuda_stream(), arg_label,
+      arg_alloc_size, arg_logical_size, arg_handle, true);
 }
 
 void *CudaUVMSpace::allocate(const size_t arg_alloc_size) const {
@@ -237,26 +243,24 @@ void *CudaUVMSpace::impl_allocate(
   Cuda::impl_static_fence(
       "Kokkos::CudaUVMSpace::impl_allocate: Pre UVM Allocation");
   if (arg_alloc_size > 0) {
-    Kokkos::Impl::num_uvm_allocations++;
-
-    auto error_code =
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
+    cudaError_t error_code =
         cudaMallocManaged(&ptr, arg_alloc_size, cudaMemAttachGlobal);
 
+    if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
+      // This is the only way to clear the last error, which
+      // we should do here since we're turning it into an
+      // exception here
+      cudaGetLastError();
+      Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
+    }
+
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
     if (Kokkos::CudaUVMSpace::cuda_pin_uvm_to_host())
-      cudaMemAdvise(ptr, arg_alloc_size, cudaMemAdviseSetPreferredLocation,
-                    cudaCpuDeviceId);
+      KOKKOS_IMPL_CUDA_SAFE_CALL(
+          cudaMemAdvise(ptr, arg_alloc_size, cudaMemAdviseSetPreferredLocation,
+                        cudaCpuDeviceId));
 #endif
-
-    if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
-      cudaGetLastError();  // This is the only way to clear the last error,
-                           // which we should do here since we're turning it
-                           // into an exception here
-      throw Experimental::CudaRawMemoryAllocationFailure(
-          arg_alloc_size, error_code,
-          Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-              CudaMallocManaged);
-    }
   }
   Cuda::impl_static_fence(
       "Kokkos::CudaUVMSpace::impl_allocate: Post UVM Allocation");
@@ -281,15 +285,15 @@ void *CudaHostPinnedSpace::impl_allocate(
     const Kokkos::Tools::SpaceHandle arg_handle) const {
   void *ptr = nullptr;
 
-  auto error_code = cudaHostAlloc(&ptr, arg_alloc_size, cudaHostAllocDefault);
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
+  cudaError_t error_code =
+      cudaHostAlloc(&ptr, arg_alloc_size, cudaHostAllocDefault);
   if (error_code != cudaSuccess) {  // TODO tag as unlikely branch
-    cudaGetLastError();  // This is the only way to clear the last error, which
-                         // we should do here since we're turning it into an
-                         // exception here
-    throw Experimental::CudaRawMemoryAllocationFailure(
-        arg_alloc_size, error_code,
-        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-            CudaHostAlloc);
+    // This is the only way to clear the last error, which
+    // we should do here since we're turning it into an
+    // exception here
+    cudaGetLastError();
+    Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
   }
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     const size_t reported_size =
@@ -320,24 +324,24 @@ void CudaSpace::impl_deallocate(
     Kokkos::Profiling::deallocateData(arg_handle, arg_label, arg_alloc_ptr,
                                       reported_size);
   }
-  try {
 #ifndef CUDART_VERSION
 #error CUDART_VERSION undefined!
 #elif (defined(KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC) && CUDART_VERSION >= 11020)
-    if (arg_alloc_size >= memory_threshold_g) {
-      Impl::cuda_device_synchronize(
-          "Kokkos::Cuda: backend fence before async free");
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeAsync(arg_alloc_ptr, 0));
-      Impl::cuda_device_synchronize(
-          "Kokkos::Cuda: backend fence after async free");
-    } else {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
-    }
-#else
+  if (arg_alloc_size >= memory_threshold_g) {
+    Impl::cuda_device_synchronize(
+        "Kokkos::Cuda: backend fence before async free");
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeAsync(arg_alloc_ptr, m_stream));
+    Impl::cuda_device_synchronize(
+        "Kokkos::Cuda: backend fence after async free");
+  } else {
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
     KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
-#endif
-  } catch (...) {
   }
+#else
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
+#endif
 }
 void CudaUVMSpace::deallocate(void *const arg_alloc_ptr,
                               const size_t arg_alloc_size) const {
@@ -353,10 +357,7 @@ void CudaUVMSpace::deallocate(const char *arg_label, void *const arg_alloc_ptr,
 }
 void CudaUVMSpace::impl_deallocate(
     const char *arg_label, void *const arg_alloc_ptr,
-    const size_t arg_alloc_size
-
-    ,
-    const size_t arg_logical_size,
+    const size_t arg_alloc_size, const size_t arg_logical_size,
     const Kokkos::Tools::SpaceHandle arg_handle) const {
   Cuda::impl_static_fence(
       "Kokkos::CudaUVMSpace::impl_deallocate: Pre UVM Deallocation");
@@ -366,12 +367,9 @@ void CudaUVMSpace::impl_deallocate(
     Kokkos::Profiling::deallocateData(arg_handle, arg_label, arg_alloc_ptr,
                                       reported_size);
   }
-  try {
-    if (arg_alloc_ptr != nullptr) {
-      Kokkos::Impl::num_uvm_allocations--;
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
-    }
-  } catch (...) {
+  if (arg_alloc_ptr != nullptr) {
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(arg_alloc_ptr));
   }
   Cuda::impl_static_fence(
       "Kokkos::CudaUVMSpace::impl_deallocate: Post UVM Deallocation");
@@ -398,10 +396,8 @@ void CudaHostPinnedSpace::impl_deallocate(
     Kokkos::Profiling::deallocateData(arg_handle, arg_label, arg_alloc_ptr,
                                       reported_size);
   }
-  try {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeHost(arg_alloc_ptr));
-  } catch (...) {
-  }
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_device));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeHost(arg_alloc_ptr));
 }
 
 }  // namespace Kokkos
@@ -412,165 +408,13 @@ void CudaHostPinnedSpace::impl_deallocate(
 namespace Kokkos {
 namespace Impl {
 
-#ifdef KOKKOS_ENABLE_DEBUG
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<Kokkos::CudaSpace, void>::s_root_record;
-
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::s_root_record;
-
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::s_root_record;
-#endif
-
-//==============================================================================
-// <editor-fold desc="SharedAllocationRecord destructors"> {{{1
-
-SharedAllocationRecord<Kokkos::CudaSpace, void>::~SharedAllocationRecord() {
-  auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     alloc_size, (alloc_size - sizeof(SharedAllocationHeader)));
-}
-
-void SharedAllocationRecord<Kokkos::CudaSpace, void>::deep_copy_header_no_exec(
-    void *ptr, const void *header) {
-  Kokkos::Cuda exec;
-  Kokkos::Impl::DeepCopy<CudaSpace, HostSpace>(exec, ptr, header,
-                                               sizeof(SharedAllocationHeader));
-  exec.fence(
-      "SharedAllocationRecord<Kokkos::CudaSpace, "
-      "void>::SharedAllocationRecord(): fence after copying header from "
-      "HostSpace");
-}
-
-SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     SharedAllocationRecord<void, void>::m_alloc_size,
-                     (SharedAllocationRecord<void, void>::m_alloc_size -
-                      sizeof(SharedAllocationHeader)));
-}
-
-SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
-                       void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     SharedAllocationRecord<void, void>::m_alloc_size,
-                     (SharedAllocationRecord<void, void>::m_alloc_size -
-                      sizeof(SharedAllocationHeader)));
-}
-
-// </editor-fold> end SharedAllocationRecord destructors }}}1
-//==============================================================================
-
-//==============================================================================
-// <editor-fold desc="SharedAllocationRecord constructors"> {{{1
-
-SharedAllocationRecord<Kokkos::CudaSpace, void>::SharedAllocationRecord(
-    const Kokkos::CudaSpace &arg_space, const std::string &arg_label,
-    const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::CudaSpace, void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  // Copy to device memory
-  Kokkos::Cuda exec;
-  Kokkos::Impl::DeepCopy<CudaSpace, HostSpace>(
-      exec, RecordBase::m_alloc_ptr, &header, sizeof(SharedAllocationHeader));
-  exec.fence(
-      "SharedAllocationRecord<Kokkos::CudaSpace, "
-      "void>::SharedAllocationRecord(): fence after copying header from "
-      "HostSpace");
-}
-
-SharedAllocationRecord<Kokkos::CudaSpace, void>::SharedAllocationRecord(
-    const Kokkos::Cuda &arg_exec_space, const Kokkos::CudaSpace &arg_space,
-    const std::string &arg_label, const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::CudaSpace, void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_exec_space, arg_space,
-                                               arg_label, arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  // Copy to device memory
-  Kokkos::Impl::DeepCopy<CudaSpace, HostSpace>(arg_exec_space,
-                                               RecordBase::m_alloc_ptr, &header,
-                                               sizeof(SharedAllocationHeader));
-}
-
-SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::SharedAllocationRecord(
-    const Kokkos::CudaUVMSpace &arg_space, const std::string &arg_label,
-    const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                  arg_label);
-}
-
-SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::CudaHostPinnedSpace &arg_space,
-        const std::string &arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                  arg_label);
-}
-
-// </editor-fold> end SharedAllocationRecord constructors }}}1
-//==============================================================================
-
 void cuda_prefetch_pointer(const Cuda &space, const void *ptr, size_t bytes,
                            bool to_device) {
   if ((ptr == nullptr) || (bytes == 0)) return;
   cudaPointerAttributes attr;
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaPointerGetAttributes(&attr, ptr));
+  KOKKOS_IMPL_CUDA_SAFE_CALL((
+      space.impl_internal_space_instance()->cuda_pointer_get_attributes_wrapper(
+          &attr, ptr)));
   // I measured this and it turns out prefetching towards the host slows
   // DualView syncs down. Probably because the latency is not too bad in the
   // first place for the pull down. If we want to change that provde
@@ -578,8 +422,9 @@ void cuda_prefetch_pointer(const Cuda &space, const void *ptr, size_t bytes,
   bool is_managed = attr.type == cudaMemoryTypeManaged;
   if (to_device && is_managed &&
       space.cuda_device_prop().concurrentManagedAccess) {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaMemPrefetchAsync(
-        ptr, bytes, space.cuda_device(), space.cuda_stream()));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        (space.impl_internal_space_instance()->cuda_mem_prefetch_async_wrapper(
+            ptr, bytes, space.cuda_device())));
   }
 }
 
@@ -591,19 +436,12 @@ void cuda_prefetch_pointer(const Cuda &space, const void *ptr, size_t bytes,
 
 #include <impl/Kokkos_SharedAlloc_timpl.hpp>
 
-namespace Kokkos {
-namespace Impl {
-
-// To avoid additional compilation cost for something that's (mostly?) not
-// performance sensitive, we explicity instantiate these CRTP base classes here,
-// where we have access to the associated *_timpl.hpp header files.
-template class SharedAllocationRecordCommon<Kokkos::CudaSpace>;
-template class HostInaccessibleSharedAllocationRecordCommon<Kokkos::CudaSpace>;
-template class SharedAllocationRecordCommon<Kokkos::CudaUVMSpace>;
-template class SharedAllocationRecordCommon<Kokkos::CudaHostPinnedSpace>;
-
-}  // end namespace Impl
-}  // end namespace Kokkos
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::CudaSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::CudaUVMSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::CudaHostPinnedSpace);
 
 // </editor-fold> end Explicit instantiations of CRTP Base classes }}}1
 //==============================================================================
diff --git a/core/src/Cuda/Kokkos_CudaSpace.hpp b/core/src/Cuda/Kokkos_CudaSpace.hpp
index b8fa335cd3..0e20193e8b 100644
--- a/core/src/Cuda/Kokkos_CudaSpace.hpp
+++ b/core/src/Cuda/Kokkos_CudaSpace.hpp
@@ -68,6 +68,11 @@ class CudaSpace {
   /*--------------------------------*/
 
   CudaSpace();
+
+ private:
+  CudaSpace(int device_id, cudaStream_t stream);
+
+ public:
   CudaSpace(CudaSpace&& rhs)      = default;
   CudaSpace(const CudaSpace& rhs) = default;
   CudaSpace& operator=(CudaSpace&& rhs) = default;
@@ -89,9 +94,11 @@ class CudaSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
+  static CudaSpace impl_create(int device_id, cudaStream_t stream) {
+    return CudaSpace(device_id, stream);
+  }
+
  private:
-  template <class, class, class, class>
-  friend class Kokkos::Experimental::LogicalMemorySpace;
   void* impl_allocate(const Cuda& exec_space, const char* arg_label,
                       const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
@@ -112,10 +119,10 @@ class CudaSpace {
   static constexpr const char* name() { return m_name; }
 
  private:
-  int m_device;  ///< Which Cuda device
+  int m_device;
+  cudaStream_t m_stream;
 
   static constexpr const char* m_name = "Cuda";
-  friend class Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>;
 };
 
 template <>
@@ -149,6 +156,11 @@ class CudaUVMSpace {
   /*--------------------------------*/
 
   CudaUVMSpace();
+
+ private:
+  CudaUVMSpace(int device_id, cudaStream_t stream);
+
+ public:
   CudaUVMSpace(CudaUVMSpace&& rhs)      = default;
   CudaUVMSpace(const CudaUVMSpace& rhs) = default;
   CudaUVMSpace& operator=(CudaUVMSpace&& rhs) = default;
@@ -156,6 +168,16 @@ class CudaUVMSpace {
   ~CudaUVMSpace()                                  = default;
 
   /**\brief  Allocate untracked memory in the cuda space */
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -167,8 +189,6 @@ class CudaUVMSpace {
                   const size_t arg_logical_size = 0) const;
 
  private:
-  template <class, class, class, class>
-  friend class Kokkos::Experimental::LogicalMemorySpace;
   void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
                       const Kokkos::Tools::SpaceHandle =
@@ -189,8 +209,13 @@ class CudaUVMSpace {
 #endif
   /*--------------------------------*/
 
+  static CudaUVMSpace impl_create(int device_id, cudaStream_t stream) {
+    return CudaUVMSpace(device_id, stream);
+  }
+
  private:
-  int m_device;  ///< Which Cuda device
+  int m_device;
+  cudaStream_t m_stream;
 
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_PIN_UVM_TO_HOST
   static bool kokkos_impl_cuda_pin_uvm_to_host_v;
@@ -223,6 +248,11 @@ class CudaHostPinnedSpace {
   /*--------------------------------*/
 
   CudaHostPinnedSpace();
+
+ private:
+  CudaHostPinnedSpace(int device_id, cudaStream_t stream);
+
+ public:
   CudaHostPinnedSpace(CudaHostPinnedSpace&& rhs)      = default;
   CudaHostPinnedSpace(const CudaHostPinnedSpace& rhs) = default;
   CudaHostPinnedSpace& operator=(CudaHostPinnedSpace&& rhs) = default;
@@ -230,6 +260,16 @@ class CudaHostPinnedSpace {
   ~CudaHostPinnedSpace()                                         = default;
 
   /**\brief  Allocate untracked memory in the space */
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -240,9 +280,11 @@ class CudaHostPinnedSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
+  static CudaHostPinnedSpace impl_create(int device_id, cudaStream_t stream) {
+    return CudaHostPinnedSpace(device_id, stream);
+  }
+
  private:
-  template <class, class, class, class>
-  friend class Kokkos::Experimental::LogicalMemorySpace;
   void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
                       const Kokkos::Tools::SpaceHandle =
@@ -258,6 +300,9 @@ class CudaHostPinnedSpace {
   static constexpr const char* name() { return m_name; }
 
  private:
+  int m_device;
+  cudaStream_t m_stream;
+
   static constexpr const char* m_name = "CudaHostPinned";
 
   /*--------------------------------*/
@@ -280,15 +325,12 @@ const std::unique_ptr<Kokkos::Cuda>& cuda_get_deep_copy_space(
     bool initialize = true);
 
 static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                              Kokkos::CudaSpace>::assignable,
-              "");
-static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                              Kokkos::CudaUVMSpace>::assignable,
-              "");
+                                              Kokkos::CudaSpace>::assignable);
+static_assert(Kokkos::Impl::MemorySpaceAccess<
+              Kokkos::CudaUVMSpace, Kokkos::CudaUVMSpace>::assignable);
 static_assert(
     Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                    Kokkos::CudaHostPinnedSpace>::assignable,
-    "");
+                                    Kokkos::CudaHostPinnedSpace>::assignable);
 
 //----------------------------------------
 
@@ -516,179 +558,10 @@ struct DeepCopy<HostSpace, MemSpace, ExecutionSpace,
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos {
-namespace Impl {
-
-template <>
-class SharedAllocationRecord<Kokkos::CudaSpace, void>
-    : public HostInaccessibleSharedAllocationRecordCommon<Kokkos::CudaSpace> {
- private:
-  friend class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>;
-  friend class SharedAllocationRecordCommon<Kokkos::CudaSpace>;
-  friend class HostInaccessibleSharedAllocationRecordCommon<Kokkos::CudaSpace>;
-
-  using RecordBase = SharedAllocationRecord<void, void>;
-  using base_t =
-      HostInaccessibleSharedAllocationRecordCommon<Kokkos::CudaSpace>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  static RecordBase s_root_record;
-#endif
-
-  const Kokkos::CudaSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  // This constructor does not forward to the one without exec_space arg
-  // in order to work around https://github.com/kokkos/kokkos/issues/5258
-  // This constructor is templated so I can't just put it into the cpp file
-  // like the other constructor.
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/, const Kokkos::CudaSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-            &SharedAllocationRecord<Kokkos::CudaSpace, void>::s_root_record,
-#endif
-            Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                 arg_alloc_size),
-            sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-            arg_label),
-        m_space(arg_space) {
-
-    SharedAllocationHeader header;
-
-    this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-    // Copy to device memory
-    // workaround for issue with NVCC and MSVC
-    // https://github.com/kokkos/kokkos/issues/5258
-    deep_copy_header_no_exec(RecordBase::m_alloc_ptr, &header);
-  }
-
-  SharedAllocationRecord(
-      const Kokkos::Cuda& exec_space, const Kokkos::CudaSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
-  SharedAllocationRecord(
-      const Kokkos::CudaSpace& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
-  // 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*);
-};
-
-template <>
-class SharedAllocationRecord<Kokkos::CudaUVMSpace, void>
-    : public SharedAllocationRecordCommon<Kokkos::CudaUVMSpace> {
- private:
-  friend class SharedAllocationRecordCommon<Kokkos::CudaUVMSpace>;
-
-  using base_t     = SharedAllocationRecordCommon<Kokkos::CudaUVMSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-  static RecordBase s_root_record;
-
-  const Kokkos::CudaUVMSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  // This constructor does not forward to the one without exec_space arg
-  // in order to work around https://github.com/kokkos/kokkos/issues/5258
-  // This constructor is templated so I can't just put it into the cpp file
-  // like the other constructor.
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      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)
-      : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-            &SharedAllocationRecord<Kokkos::CudaUVMSpace, void>::s_root_record,
-#endif
-            Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                 arg_alloc_size),
-            sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-            arg_label),
-        m_space(arg_space) {
-    this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                    arg_label);
-  }
-
-  SharedAllocationRecord(
-      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);
-};
-
-template <>
-class SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>
-    : public SharedAllocationRecordCommon<Kokkos::CudaHostPinnedSpace> {
- private:
-  friend class SharedAllocationRecordCommon<Kokkos::CudaHostPinnedSpace>;
-
-  using RecordBase = SharedAllocationRecord<void, void>;
-  using base_t     = SharedAllocationRecordCommon<Kokkos::CudaHostPinnedSpace>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-  static RecordBase s_root_record;
-
-  const Kokkos::CudaHostPinnedSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  // This constructor does not forward to the one without exec_space arg
-  // in order to work around https://github.com/kokkos/kokkos/issues/5258
-  // This constructor is templated so I can't just put it into the cpp file
-  // like the other constructor.
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      const Kokkos::CudaHostPinnedSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-            &SharedAllocationRecord<Kokkos::CudaHostPinnedSpace,
-                                    void>::s_root_record,
-#endif
-            Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                 arg_alloc_size),
-            sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-            arg_label),
-        m_space(arg_space) {
-    this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                    arg_label);
-  }
-
-  SharedAllocationRecord(
-      const Kokkos::CudaHostPinnedSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::CudaSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(Kokkos::CudaUVMSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(Kokkos::CudaHostPinnedSpace);
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp b/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp
index 75c1686dc2..3de8b2820e 100644
--- a/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp
@@ -183,9 +183,7 @@ int cuda_get_max_block_size(const CudaInternal* cuda_instance,
                             const FunctorType& f, const size_t vector_length,
                             const size_t shmem_block,
                             const size_t shmem_thread) {
-  (void)cuda_instance;
-
-  auto const& prop = Kokkos::Cuda().cuda_device_prop();
+  auto const& prop = cuda_instance->m_deviceProp;
 
   auto const block_size_to_dynamic_shmem = [&f, vector_length, shmem_block,
                                             shmem_thread](int block_size) {
@@ -209,9 +207,7 @@ int cuda_get_opt_block_size(const CudaInternal* cuda_instance,
                             const FunctorType& f, const size_t vector_length,
                             const size_t shmem_block,
                             const size_t shmem_thread) {
-  (void)cuda_instance;
-
-  auto const& prop = Kokkos::Cuda().cuda_device_prop();
+  auto const& prop = cuda_instance->m_deviceProp;
 
   auto const block_size_to_dynamic_shmem = [&f, vector_length, shmem_block,
                                             shmem_thread](int block_size) {
diff --git a/core/src/Cuda/Kokkos_Cuda_Error.hpp b/core/src/Cuda/Kokkos_Cuda_Error.hpp
index f68e05f780..66656fefda 100644
--- a/core/src/Cuda/Kokkos_Cuda_Error.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Error.hpp
@@ -22,15 +22,10 @@
 
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_Profiling.hpp>
-#include <iosfwd>
 
 namespace Kokkos {
 namespace Impl {
 
-void cuda_stream_synchronize(
-    const cudaStream_t stream,
-    Kokkos::Tools::Experimental::SpecialSynchronizationCases reason,
-    const std::string& name);
 void cuda_device_synchronize(const std::string& name);
 void cuda_stream_synchronize(const cudaStream_t stream,
                              const std::string& name);
@@ -73,52 +68,6 @@ inline void cuda_internal_safe_call(cudaError e, const char* name,
   Kokkos::Impl::cuda_internal_safe_call(call, #call, __FILE__, __LINE__)
 
 }  // namespace Impl
-
-namespace Experimental {
-
-class CudaRawMemoryAllocationFailure : public RawMemoryAllocationFailure {
- private:
-  using base_t = RawMemoryAllocationFailure;
-
-  cudaError_t m_error_code = cudaSuccess;
-
-  static FailureMode get_failure_mode(cudaError_t error_code) {
-    switch (error_code) {
-      case cudaErrorMemoryAllocation: return FailureMode::OutOfMemoryError;
-      case cudaErrorInvalidValue: return FailureMode::InvalidAllocationSize;
-      // TODO handle cudaErrorNotSupported for cudaMallocManaged
-      default: return FailureMode::Unknown;
-    }
-  }
-
- public:
-  // using base_t::base_t;
-  // would trigger
-  //
-  // error: cannot determine the exception specification of the default
-  // constructor due to a circular dependency
-  //
-  // using NVCC 9.1 and gcc 7.4
-  CudaRawMemoryAllocationFailure(
-      size_t arg_attempted_size, size_t arg_attempted_alignment,
-      FailureMode arg_failure_mode = FailureMode::OutOfMemoryError,
-      AllocationMechanism arg_mechanism =
-          AllocationMechanism::StdMalloc) noexcept
-      : base_t(arg_attempted_size, arg_attempted_alignment, arg_failure_mode,
-               arg_mechanism) {}
-
-  CudaRawMemoryAllocationFailure(size_t arg_attempted_size,
-                                 cudaError_t arg_error_code,
-                                 AllocationMechanism arg_mechanism) noexcept
-      : base_t(arg_attempted_size, /* CudaSpace doesn't handle alignment? */ 1,
-               get_failure_mode(arg_error_code), arg_mechanism),
-        m_error_code(arg_error_code) {}
-
-  void append_additional_error_information(std::ostream& o) const override;
-};
-
-}  // end namespace Experimental
-
 }  // namespace Kokkos
 
 #endif  // KOKKOS_ENABLE_CUDA
diff --git a/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp b/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp
index 86649fa015..5a821ab64a 100644
--- a/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_GraphNodeKernel.hpp
@@ -23,26 +23,17 @@
 
 #include <Kokkos_Graph_fwd.hpp>
 
-#include <impl/Kokkos_GraphImpl.hpp>    // GraphAccess needs to be complete
-#include <impl/Kokkos_SharedAlloc.hpp>  // SharedAllocationRecord
+#include <impl/Kokkos_GraphImpl.hpp>  // GraphAccess needs to be complete
 
 #include <Kokkos_Parallel.hpp>
 #include <Kokkos_Parallel_Reduce.hpp>
 #include <Kokkos_PointerOwnership.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...>
@@ -58,10 +49,6 @@ class GraphNodeKernelImpl<Kokkos::Cuda, PolicyType, Functor, PatternTag,
   // covers and we're not modifying it
   Kokkos::ObservingRawPtr<const cudaGraph_t> m_graph_ptr    = nullptr;
   Kokkos::ObservingRawPtr<cudaGraphNode_t> m_graph_node_ptr = nullptr;
-  // Note: owned pointer to CudaSpace memory (used for global memory launches),
-  // which we're responsible for deallocating, but not responsible for calling
-  // its destructor.
-  using Record = Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>;
   // Basically, we have to make this mutable for the same reasons that the
   // global kernel buffers in the Cuda instance are mutable...
   mutable Kokkos::OwningRawPtr<base_t> m_driver_storage = nullptr;
@@ -90,9 +77,7 @@ class GraphNodeKernelImpl<Kokkos::Cuda, PolicyType, Functor, PatternTag,
 
   ~GraphNodeKernelImpl() {
     if (m_driver_storage) {
-      // We should be the only owner, but this is still the easiest way to
-      // allocate and deallocate aligned memory for these sorts of things
-      Record::decrement(Record::get_record(m_driver_storage));
+      Kokkos::CudaSpace().deallocate(m_driver_storage, sizeof(base_t));
     }
   }
 
@@ -107,13 +92,8 @@ class GraphNodeKernelImpl<Kokkos::Cuda, PolicyType, Functor, PatternTag,
 
   Kokkos::ObservingRawPtr<base_t> allocate_driver_memory_buffer() const {
     KOKKOS_EXPECTS(m_driver_storage == nullptr)
-
-    auto* record = Record::allocate(
-        Kokkos::CudaSpace{}, "GraphNodeKernel global memory functor storage",
-        sizeof(base_t));
-
-    Record::increment(record);
-    m_driver_storage = reinterpret_cast<base_t*>(record->data());
+    m_driver_storage = static_cast<base_t*>(Kokkos::CudaSpace().allocate(
+        "GraphNodeKernel global memory functor storage", sizeof(base_t)));
     KOKKOS_ENSURES(m_driver_storage != nullptr)
     return m_driver_storage;
   }
diff --git a/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp b/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp
index 17de1be7a6..ff0aa0da0d 100644
--- a/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_GraphNode_Impl.hpp
@@ -26,7 +26,6 @@
 #include <impl/Kokkos_GraphImpl.hpp>  // GraphAccess needs to be complete
 
 #include <Cuda/Kokkos_Cuda.hpp>
-#include <cuda_runtime_api.h>
 
 namespace Kokkos {
 namespace Impl {
diff --git a/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp b/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp
index 0609d0ffa6..625d8c317a 100644
--- a/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Graph_Impl.hpp
@@ -31,8 +31,8 @@
 #include <Cuda/Kokkos_Cuda_GraphNode_Impl.hpp>
 
 #include <Cuda/Kokkos_Cuda.hpp>
-#include <cuda_runtime_api.h>
 #include <Cuda/Kokkos_Cuda_Error.hpp>
+#include <Cuda/Kokkos_Cuda_Instance.hpp>
 
 namespace Kokkos {
 namespace Impl {
@@ -55,8 +55,11 @@ struct GraphImpl<Kokkos::Cuda> {
     constexpr size_t error_log_size = 256;
     cudaGraphNode_t error_node      = nullptr;
     char error_log[error_log_size];
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGraphInstantiate(
-        &m_graph_exec, m_graph, &error_node, error_log, error_log_size));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_instantiate_wrapper(&m_graph_exec, m_graph,
+                                              &error_node, error_log,
+                                              error_log_size)));
     // TODO @graphs print out errors
   }
 
@@ -69,7 +72,7 @@ struct GraphImpl<Kokkos::Cuda> {
       GraphNodeImpl<Kokkos::Cuda, aggregate_kernel_impl_t,
                     Kokkos::Experimental::TypeErasedTag>;
 
-  // Not moveable or copyable; it spends its whole life as a shared_ptr in the
+  // Not movable or copyable; it spends its whole life as a shared_ptr in the
   // Graph object
   GraphImpl()                 = delete;
   GraphImpl(GraphImpl const&) = delete;
@@ -83,34 +86,38 @@ struct GraphImpl<Kokkos::Cuda> {
     m_execution_space.fence("Kokkos::GraphImpl::~GraphImpl: Graph Destruction");
     KOKKOS_EXPECTS(bool(m_graph))
     if (bool(m_graph_exec)) {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGraphExecDestroy(m_graph_exec));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(
+          (m_execution_space.impl_internal_space_instance()
+               ->cuda_graph_exec_destroy_wrapper(m_graph_exec)));
     }
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGraphDestroy(m_graph));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_destroy_wrapper(m_graph)));
   };
 
   explicit GraphImpl(Kokkos::Cuda arg_instance)
       : m_execution_space(std::move(arg_instance)) {
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaGraphCreate(&m_graph, cuda_graph_flags_t{0}));
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_create_wrapper(&m_graph, cuda_graph_flags_t{0})));
   }
 
   void add_node(std::shared_ptr<aggregate_node_impl_t> const& arg_node_ptr) {
     // All of the predecessors are just added as normal, so all we need to
     // do here is add an empty node
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaGraphAddEmptyNode(&(arg_node_ptr->node_details_t::node), m_graph,
-                              /* dependencies = */ nullptr,
-                              /* numDependencies = */ 0));
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_add_empty_node_wrapper(
+                 &(arg_node_ptr->node_details_t::node), m_graph,
+                 /* dependencies = */ nullptr,
+                 /* numDependencies = */ 0)));
   }
 
   template <class NodeImpl>
   //  requires NodeImplPtr is a shared_ptr to specialization of GraphNodeImpl
-  //  Also requires that the kernel has the graph node tag in it's policy
+  //  Also requires that the kernel has the graph node tag in its policy
   void add_node(std::shared_ptr<NodeImpl> const& arg_node_ptr) {
-    static_assert(
-        NodeImpl::kernel_type::Policy::is_graph_kernel::value,
-        "Something has gone horribly wrong, but it's too complicated to "
-        "explain here.  Buy Daisy a coffee and she'll explain it to you.");
+    static_assert(NodeImpl::kernel_type::Policy::is_graph_kernel::value);
     KOKKOS_EXPECTS(bool(arg_node_ptr));
     // The Kernel launch from the execute() method has been shimmed to insert
     // the node into the graph
@@ -146,7 +153,9 @@ struct GraphImpl<Kokkos::Cuda> {
     KOKKOS_EXPECTS(bool(cuda_node))
 
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaGraphAddDependencies(m_graph, &pred_cuda_node, &cuda_node, 1));
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_add_dependencies_wrapper(m_graph, &pred_cuda_node,
+                                                   &cuda_node, 1)));
   }
 
   void submit() {
@@ -154,7 +163,8 @@ struct GraphImpl<Kokkos::Cuda> {
       _instantiate_graph();
     }
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaGraphLaunch(m_graph_exec, m_execution_space.cuda_stream()));
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_launch_wrapper(m_graph_exec)));
   }
 
   execution_space const& get_execution_space() const noexcept {
@@ -167,9 +177,11 @@ struct GraphImpl<Kokkos::Cuda> {
     auto rv = std::make_shared<root_node_impl_t>(
         get_execution_space(), _graph_node_is_root_ctor_tag{});
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaGraphAddEmptyNode(&(rv->node_details_t::node), m_graph,
-                              /* dependencies = */ nullptr,
-                              /* numDependencies = */ 0));
+        (m_execution_space.impl_internal_space_instance()
+             ->cuda_graph_add_empty_node_wrapper(&(rv->node_details_t::node),
+                                                 m_graph,
+                                                 /* dependencies = */ nullptr,
+                                                 /* numDependencies = */ 0)));
     KOKKOS_ENSURES(bool(rv->node_details_t::node))
     return rv;
   }
diff --git a/core/src/Cuda/Kokkos_Cuda_Instance.cpp b/core/src/Cuda/Kokkos_Cuda_Instance.cpp
index cb88c5adf1..89a0002896 100644
--- a/core/src/Cuda/Kokkos_Cuda_Instance.cpp
+++ b/core/src/Cuda/Kokkos_Cuda_Instance.cpp
@@ -26,12 +26,13 @@
 
 #include <Kokkos_Core.hpp>
 
-#include <Cuda/Kokkos_Cuda_Error.hpp>
-#include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
-#include <Cuda/Kokkos_Cuda_Instance.hpp>
-#include <Cuda/Kokkos_Cuda_UniqueToken.hpp>
+//#include <Cuda/Kokkos_Cuda_Error.hpp>
+//#include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
+//#include <Cuda/Kokkos_Cuda_Instance.hpp>
+//#include <Cuda/Kokkos_Cuda_UniqueToken.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_Tools.hpp>
+#include <impl/Kokkos_CheckedIntegerOps.hpp>
 #include <impl/Kokkos_DeviceManagement.hpp>
 #include <impl/Kokkos_ExecSpaceManager.hpp>
 
@@ -96,20 +97,31 @@ __global__ void query_cuda_kernel_arch(int *d_arch) {
 }
 
 /** Query what compute capability is actually launched to the device: */
-int cuda_kernel_arch() {
+int cuda_kernel_arch(int device_id) {
   int arch    = 0;
   int *d_arch = nullptr;
 
-  cudaMalloc(reinterpret_cast<void **>(&d_arch), sizeof(int));
-  cudaMemcpy(d_arch, &arch, sizeof(int), cudaMemcpyDefault);
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(device_id));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(
+      cudaMalloc(reinterpret_cast<void **>(&d_arch), sizeof(int)));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(
+      cudaMemcpy(d_arch, &arch, sizeof(int), cudaMemcpyDefault));
 
   query_cuda_kernel_arch<<<1, 1>>>(d_arch);
 
-  cudaMemcpy(&arch, d_arch, sizeof(int), cudaMemcpyDefault);
-  cudaFree(d_arch);
+  KOKKOS_IMPL_CUDA_SAFE_CALL(
+      cudaMemcpy(&arch, d_arch, sizeof(int), cudaMemcpyDefault));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(d_arch));
   return arch;
 }
 
+constexpr auto sizeScratchGrain =
+    sizeof(Cuda::size_type[Impl::CudaTraits::WarpSize]);
+
+std::size_t scratch_count(const std::size_t size) {
+  return (size + sizeScratchGrain - 1) / sizeScratchGrain;
+}
+
 }  // namespace
 
 Kokkos::View<uint32_t *, Kokkos::CudaSpace> cuda_global_unique_token_locks(
@@ -131,14 +143,16 @@ void cuda_device_synchronize(const std::string &name) {
 #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());
-      });
+      [] __host__()
 #else
-      []() {  // TODO: correct device ID
-        KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
-      });
+      []()
 #endif
+      {
+        for (int cuda_device : Kokkos::Impl::CudaInternal::cuda_devices) {
+          KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(cuda_device));
+          KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
+        }
+      });
 }
 
 void cuda_stream_synchronize(const cudaStream_t stream, const CudaInternal *ptr,
@@ -147,18 +161,9 @@ void cuda_stream_synchronize(const cudaStream_t stream, const CudaInternal *ptr,
       name,
       Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{
           ptr->impl_get_instance_id()},
-      [&]() {  // TODO: correct device ID
-        KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamSynchronize(stream));
-      });
-}
-
-void cuda_stream_synchronize(
-    const cudaStream_t stream,
-    Kokkos::Tools::Experimental::SpecialSynchronizationCases reason,
-    const std::string &name) {
-  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Cuda>(
-      name, reason, [&]() {  // TODO: correct device ID
-        KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamSynchronize(stream));
+      [&]() {
+        KOKKOS_IMPL_CUDA_SAFE_CALL(
+            (ptr->cuda_stream_synchronize_wrapper(stream)));
       });
 }
 
@@ -186,92 +191,6 @@ void cuda_internal_error_abort(cudaError e, const char *name, const char *file,
   host_abort(out.str().c_str());
 }
 
-//----------------------------------------------------------------------------
-// Some significant cuda device properties:
-//
-// cudaDeviceProp::name                : Text label for device
-// cudaDeviceProp::major               : Device major number
-// cudaDeviceProp::minor               : Device minor number
-// cudaDeviceProp::warpSize            : number of threads per warp
-// cudaDeviceProp::multiProcessorCount : number of multiprocessors
-// cudaDeviceProp::sharedMemPerBlock   : capacity of shared memory per block
-// cudaDeviceProp::totalConstMem       : capacity of constant memory
-// cudaDeviceProp::totalGlobalMem      : capacity of global memory
-// cudaDeviceProp::maxGridSize[3]      : maximum grid size
-
-//
-//  Section 4.4.2.4 of the CUDA Toolkit Reference Manual
-//
-// struct cudaDeviceProp {
-//   char name[256];
-//   size_t totalGlobalMem;
-//   size_t sharedMemPerBlock;
-//   int regsPerBlock;
-//   int warpSize;
-//   size_t memPitch;
-//   int maxThreadsPerBlock;
-//   int maxThreadsDim[3];
-//   int maxGridSize[3];
-//   size_t totalConstMem;
-//   int major;
-//   int minor;
-//   int clockRate;
-//   size_t textureAlignment;
-//   int deviceOverlap;
-//   int multiProcessorCount;
-//   int kernelExecTimeoutEnabled;
-//   int integrated;
-//   int canMapHostMemory;
-//   int computeMode;
-//   int concurrentKernels;
-//   int ECCEnabled;
-//   int pciBusID;
-//   int pciDeviceID;
-//   int tccDriver;
-//   int asyncEngineCount;
-//   int unifiedAddressing;
-//   int memoryClockRate;
-//   int memoryBusWidth;
-//   int l2CacheSize;
-//   int maxThreadsPerMultiProcessor;
-// };
-
-namespace {
-
-class CudaInternalDevices {
- public:
-  enum { MAXIMUM_DEVICE_COUNT = 64 };
-  struct cudaDeviceProp m_cudaProp[MAXIMUM_DEVICE_COUNT];
-  int m_cudaDevCount;
-
-  CudaInternalDevices();
-
-  static const CudaInternalDevices &singleton();
-};
-
-CudaInternalDevices::CudaInternalDevices() {
-  // See 'cudaSetDeviceFlags' for host-device thread interaction
-  // Section 4.4.2.6 of the CUDA Toolkit Reference Manual
-
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&m_cudaDevCount));
-
-  if (m_cudaDevCount > MAXIMUM_DEVICE_COUNT) {
-    Kokkos::abort(
-        "Sorry, you have more GPUs per node than we thought anybody would ever "
-        "have. Please report this to github.com/kokkos/kokkos.");
-  }
-  for (int i = 0; i < m_cudaDevCount; ++i) {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceProperties(m_cudaProp + i, i));
-  }
-}
-
-const CudaInternalDevices &CudaInternalDevices::singleton() {
-  static CudaInternalDevices self;
-  return self;
-}
-
-}  // namespace
-
 //----------------------------------------------------------------------------
 
 int Impl::CudaInternal::concurrency() {
@@ -281,8 +200,6 @@ int Impl::CudaInternal::concurrency() {
 }
 
 void CudaInternal::print_configuration(std::ostream &s) const {
-  const CudaInternalDevices &dev_info = CudaInternalDevices::singleton();
-
 #if defined(KOKKOS_ENABLE_CUDA)
   s << "macro  KOKKOS_ENABLE_CUDA      : defined\n";
 #endif
@@ -291,22 +208,23 @@ void CudaInternal::print_configuration(std::ostream &s) const {
     << CUDA_VERSION / 1000 << "." << (CUDA_VERSION % 1000) / 10 << '\n';
 #endif
 
-  for (int i = 0; i < dev_info.m_cudaDevCount; ++i) {
-    s << "Kokkos::Cuda[ " << i << " ] " << dev_info.m_cudaProp[i].name
-      << " capability " << dev_info.m_cudaProp[i].major << "."
-      << dev_info.m_cudaProp[i].minor << ", Total Global Memory: "
-      << human_memory_size(dev_info.m_cudaProp[i].totalGlobalMem)
+  for (int i : get_visible_devices()) {
+    cudaDeviceProp prop;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceProperties(&prop, i));
+    s << "Kokkos::Cuda[ " << i << " ] " << prop.name << " capability "
+      << prop.major << "." << prop.minor
+      << ", Total Global Memory: " << human_memory_size(prop.totalGlobalMem)
       << ", Shared Memory per Block: "
-      << human_memory_size(dev_info.m_cudaProp[i].sharedMemPerBlock);
+      << human_memory_size(prop.sharedMemPerBlock);
     if (m_cudaDev == i) s << " : Selected";
-    s << std::endl;
+    s << '\n';
   }
 }
 
 //----------------------------------------------------------------------------
 
 CudaInternal::~CudaInternal() {
-  if (m_stream || m_scratchSpace || m_scratchFlags || m_scratchUnified) {
+  if (m_scratchSpace || m_scratchFlags || m_scratchUnified) {
     std::cerr << "Kokkos::Cuda ERROR: Failed to call Kokkos::Cuda::finalize()"
               << std::endl;
   }
@@ -338,92 +256,59 @@ CudaInternal &CudaInternal::singleton() {
   return self;
 }
 void CudaInternal::fence(const std::string &name) const {
-  Impl::cuda_stream_synchronize(m_stream, this, name);
+  Impl::cuda_stream_synchronize(get_stream(), this, name);
 }
 void CudaInternal::fence() const {
   fence("Kokkos::CudaInternal::fence(): Unnamed Instance Fence");
 }
 
-void CudaInternal::initialize(cudaStream_t stream, bool manage_stream) {
+void CudaInternal::initialize(cudaStream_t stream) {
+  KOKKOS_EXPECTS(!is_initialized());
+
   if (was_finalized)
     Kokkos::abort("Calling Cuda::initialize after Cuda::finalize is illegal\n");
   was_initialized = true;
-  if (is_initialized()) return;
-
-#ifndef KOKKOS_IMPL_TURN_OFF_CUDA_HOST_INIT_CHECK
-  if (!HostSpace::execution_space::impl_is_initialized()) {
-    const std::string msg(
-        "Cuda::initialize ERROR : HostSpace::execution_space is not "
-        "initialized");
-    throw_runtime_exception(msg);
-  }
-#endif
-
-  const bool ok_init = nullptr == m_scratchSpace || nullptr == m_scratchFlags;
-
-  if (ok_init) {
-    //----------------------------------
-    // Multiblock reduction uses scratch flags for counters
-    // and scratch space for partial reduction values.
-    // Allocate some initial space.  This will grow as needed.
-
-    {
-      const unsigned reduce_block_count =
-          m_maxWarpCount * Impl::CudaTraits::WarpSize;
 
-      (void)scratch_unified(16 * sizeof(size_type));
-      (void)scratch_flags(reduce_block_count * 2 * sizeof(size_type));
-      (void)scratch_space(reduce_block_count * 16 * sizeof(size_type));
-    }
-  } else {
-    std::ostringstream msg;
-    msg << "Kokkos::Cuda::initialize(" << m_cudaDev
-        << ") FAILED : Already initialized";
-    Kokkos::Impl::throw_runtime_exception(msg.str());
-  }
-
-#ifdef KOKKOS_ENABLE_CUDA_UVM
-  const char *env_force_device_alloc =
-      getenv("CUDA_MANAGED_FORCE_DEVICE_ALLOC");
-  bool force_device_alloc;
-  if (env_force_device_alloc == nullptr)
-    force_device_alloc = false;
-  else
-    force_device_alloc = std::stoi(env_force_device_alloc) != 0;
+  // Check that the device associated with the stream matches cuda_device
+  CUcontext context;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaError_t(cuStreamGetCtx(stream, &context)));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaError_t(cuCtxPushCurrent(context)));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaError_t(cuCtxGetDevice(&m_cudaDev)));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_cudaDev));
 
-  const char *env_visible_devices = getenv("CUDA_VISIBLE_DEVICES");
-  bool visible_devices_one        = true;
-  if (env_visible_devices == nullptr) visible_devices_one = false;
-
-  if (Kokkos::show_warnings() &&
-      (!visible_devices_one && !force_device_alloc)) {
-    std::cerr << R"warning(
-Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default
-                                  without setting CUDA_MANAGED_FORCE_DEVICE_ALLOC=1 or
-                                  setting CUDA_VISIBLE_DEVICES.
-                                  This could on multi GPU systems lead to severe performance"
-                                  penalties.)warning"
-              << std::endl;
-  }
-#endif
-
-  // Init the array for used for arbitrarily sized atomics
-  if (this == &singleton()) {
-    desul::Impl::init_lock_arrays();  // FIXME
-  }
+  m_stream = stream;
+  CudaInternal::cuda_devices.insert(m_cudaDev);
 
   // Allocate a staging buffer for constant mem in pinned host memory
   // and an event to avoid overwriting driver for previous kernel launches
-  if (this == &singleton()) {
+  if (!constantMemHostStagingPerDevice[m_cudaDev])
+    KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_malloc_host_wrapper(
+        reinterpret_cast<void **>(&constantMemHostStagingPerDevice[m_cudaDev]),
+        CudaTraits::ConstantMemoryUsage)));
+
+  if (!constantMemReusablePerDevice[m_cudaDev])
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaMallocHost(reinterpret_cast<void **>(&constantMemHostStaging),
-                       CudaTraits::ConstantMemoryUsage));
+        (cuda_event_create_wrapper(&constantMemReusablePerDevice[m_cudaDev])));
+
+  //----------------------------------
+  // Multiblock reduction uses scratch flags for counters
+  // and scratch space for partial reduction values.
+  // Allocate some initial space.  This will grow as needed.
 
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaEventCreate(&constantMemReusable));
+  {
+    // Maximum number of warps,
+    // at most one warp per thread in a warp for reduction.
+    auto const maxWarpCount = std::min<unsigned>(
+        m_deviceProp.maxThreadsPerBlock / CudaTraits::WarpSize,
+        CudaTraits::WarpSize);
+    unsigned const reduce_block_count =
+        maxWarpCount * Impl::CudaTraits::WarpSize;
+
+    (void)scratch_unified(16 * sizeof(size_type));
+    (void)scratch_flags(reduce_block_count * 2 * sizeof(size_type));
+    (void)scratch_space(reduce_block_count * 16 * sizeof(size_type));
   }
 
-  m_stream        = stream;
-  m_manage_stream = manage_stream;
   for (int i = 0; i < m_n_team_scratch; ++i) {
     m_team_scratch_current_size[i] = 0;
     m_team_scratch_ptr[i]          = nullptr;
@@ -431,36 +316,36 @@ Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default
 
   m_num_scratch_locks = concurrency();
   KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMalloc(&m_scratch_locks, sizeof(int32_t) * m_num_scratch_locks));
-  KOKKOS_IMPL_CUDA_SAFE_CALL(
-      cudaMemset(m_scratch_locks, 0, sizeof(int32_t) * m_num_scratch_locks));
+      (cuda_malloc_wrapper(reinterpret_cast<void **>(&m_scratch_locks),
+                           sizeof(int32_t) * m_num_scratch_locks)));
+  KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_memset_wrapper(
+      m_scratch_locks, 0, sizeof(int32_t) * m_num_scratch_locks)));
 }
 
 //----------------------------------------------------------------------------
 
-using ScratchGrain = Cuda::size_type[Impl::CudaTraits::WarpSize];
-enum { sizeScratchGrain = sizeof(ScratchGrain) };
-
 Cuda::size_type *CudaInternal::scratch_flags(const std::size_t size) const {
   if (verify_is_initialized("scratch_flags") &&
-      m_scratchFlagsCount * sizeScratchGrain < size) {
-    m_scratchFlagsCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
-
-    using Record =
-        Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>;
+      m_scratchFlagsCount < scratch_count(size)) {
+    auto mem_space = Kokkos::CudaSpace::impl_create(m_cudaDev, m_stream);
 
-    if (m_scratchFlags) Record::decrement(Record::get_record(m_scratchFlags));
-
-    Record *const r =
-        Record::allocate(Kokkos::CudaSpace(), "Kokkos::InternalScratchFlags",
-                         (sizeof(ScratchGrain) * m_scratchFlagsCount));
+    if (m_scratchFlags) {
+      mem_space.deallocate(m_scratchFlags,
+                           m_scratchFlagsCount * sizeScratchGrain);
+    }
 
-    Record::increment(r);
+    m_scratchFlagsCount = scratch_count(size);
 
-    m_scratchFlags = reinterpret_cast<size_type *>(r->data());
+    std::size_t alloc_size =
+        multiply_overflow_abort(m_scratchFlagsCount, sizeScratchGrain);
+    m_scratchFlags = static_cast<size_type *>(
+        mem_space.allocate("Kokkos::InternalScratchFlags", alloc_size));
 
+    // We only zero-initialize the allocation when we actually allocate.
+    // It's the responsibility of the features using scratch_flags,
+    // namely parallel_reduce and parallel_scan, to reset the used values to 0.
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaMemset(m_scratchFlags, 0, m_scratchFlagsCount * sizeScratchGrain));
+        (cuda_memset_wrapper(m_scratchFlags, 0, alloc_size)));
   }
 
   return m_scratchFlags;
@@ -468,44 +353,42 @@ Cuda::size_type *CudaInternal::scratch_flags(const std::size_t size) const {
 
 Cuda::size_type *CudaInternal::scratch_space(const std::size_t size) const {
   if (verify_is_initialized("scratch_space") &&
-      m_scratchSpaceCount * sizeScratchGrain < size) {
-    m_scratchSpaceCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
+      m_scratchSpaceCount < scratch_count(size)) {
+    auto mem_space = Kokkos::CudaSpace::impl_create(m_cudaDev, m_stream);
 
-    using Record =
-        Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>;
-
-    if (m_scratchSpace) Record::decrement(Record::get_record(m_scratchSpace));
-
-    Record *const r =
-        Record::allocate(Kokkos::CudaSpace(), "Kokkos::InternalScratchSpace",
-                         (sizeof(ScratchGrain) * m_scratchSpaceCount));
+    if (m_scratchSpace) {
+      mem_space.deallocate(m_scratchSpace,
+                           m_scratchSpaceCount * sizeScratchGrain);
+    }
 
-    Record::increment(r);
+    m_scratchSpaceCount = scratch_count(size);
 
-    m_scratchSpace = reinterpret_cast<size_type *>(r->data());
+    std::size_t alloc_size =
+        multiply_overflow_abort(m_scratchSpaceCount, sizeScratchGrain);
+    m_scratchSpace = static_cast<size_type *>(
+        mem_space.allocate("Kokkos::InternalScratchSpace", alloc_size));
   }
 
   return m_scratchSpace;
 }
 
 Cuda::size_type *CudaInternal::scratch_unified(const std::size_t size) const {
-  if (verify_is_initialized("scratch_unified") && m_scratchUnifiedSupported &&
-      m_scratchUnifiedCount * sizeScratchGrain < size) {
-    m_scratchUnifiedCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
-
-    using Record =
-        Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaHostPinnedSpace, void>;
-
-    if (m_scratchUnified)
-      Record::decrement(Record::get_record(m_scratchUnified));
-
-    Record *const r = Record::allocate(
-        Kokkos::CudaHostPinnedSpace(), "Kokkos::InternalScratchUnified",
-        (sizeof(ScratchGrain) * m_scratchUnifiedCount));
+  if (verify_is_initialized("scratch_unified") &&
+      m_scratchUnifiedCount < scratch_count(size)) {
+    auto mem_space =
+        Kokkos::CudaHostPinnedSpace::impl_create(m_cudaDev, m_stream);
+
+    if (m_scratchUnified) {
+      mem_space.deallocate(m_scratchUnified,
+                           m_scratchUnifiedCount * sizeScratchGrain);
+    }
 
-    Record::increment(r);
+    m_scratchUnifiedCount = scratch_count(size);
 
-    m_scratchUnified = reinterpret_cast<size_type *>(r->data());
+    std::size_t alloc_size =
+        multiply_overflow_abort(m_scratchUnifiedCount, sizeScratchGrain);
+    m_scratchUnified = static_cast<size_type *>(
+        mem_space.allocate("Kokkos::InternalScratchUnified", alloc_size));
   }
 
   return m_scratchUnified;
@@ -513,21 +396,16 @@ Cuda::size_type *CudaInternal::scratch_unified(const std::size_t size) const {
 
 Cuda::size_type *CudaInternal::scratch_functor(const std::size_t size) const {
   if (verify_is_initialized("scratch_functor") && m_scratchFunctorSize < size) {
-    m_scratchFunctorSize = size;
+    auto mem_space = Kokkos::CudaSpace::impl_create(m_cudaDev, m_stream);
 
-    using Record =
-        Kokkos::Impl::SharedAllocationRecord<Kokkos::CudaSpace, void>;
-
-    if (m_scratchFunctor)
-      Record::decrement(Record::get_record(m_scratchFunctor));
-
-    Record *const r =
-        Record::allocate(Kokkos::CudaSpace(), "Kokkos::InternalScratchFunctor",
-                         m_scratchFunctorSize);
+    if (m_scratchFunctor) {
+      mem_space.deallocate(m_scratchFunctor, m_scratchFunctorSize);
+    }
 
-    Record::increment(r);
+    m_scratchFunctorSize = size;
 
-    m_scratchFunctor = reinterpret_cast<size_type *>(r->data());
+    m_scratchFunctor = static_cast<size_type *>(mem_space.allocate(
+        "Kokkos::InternalScratchFunctor", m_scratchFunctorSize));
   }
 
   return m_scratchFunctor;
@@ -550,21 +428,21 @@ void *CudaInternal::resize_team_scratch_space(int scratch_pool_id,
   // 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.
+  auto mem_space = Kokkos::CudaSpace::impl_create(m_cudaDev, m_stream);
   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<Kokkos::CudaSpace>(
-            "Kokkos::CudaSpace::TeamScratchMemory",
-            m_team_scratch_current_size[scratch_pool_id]);
+        mem_space.allocate("Kokkos::CudaSpace::TeamScratchMemory",
+                           m_team_scratch_current_size[scratch_pool_id]);
   }
   if ((bytes > m_team_scratch_current_size[scratch_pool_id]) ||
       ((bytes < m_team_scratch_current_size[scratch_pool_id]) &&
        (force_shrink))) {
+    mem_space.deallocate(m_team_scratch_ptr[scratch_pool_id],
+                         m_team_scratch_current_size[scratch_pool_id]);
     m_team_scratch_current_size[scratch_pool_id] = bytes;
     m_team_scratch_ptr[scratch_pool_id] =
-        Kokkos::kokkos_realloc<Kokkos::CudaSpace>(
-            m_team_scratch_ptr[scratch_pool_id],
-            m_team_scratch_current_size[scratch_pool_id]);
+        mem_space.allocate("Kokkos::CudaSpace::TeamScratchMemory", bytes);
   }
   return m_team_scratch_ptr[scratch_pool_id];
 }
@@ -581,87 +459,45 @@ void CudaInternal::finalize() {
 
   was_finalized = true;
 
-  // Only finalize this if we're the singleton
-  if (this == &singleton()) {
-    (void)Impl::cuda_global_unique_token_locks(true);
-    desul::Impl::finalize_lock_arrays();  // FIXME
-
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFreeHost(constantMemHostStaging));
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaEventDestroy(constantMemReusable));
-    auto &deep_copy_space =
-        Kokkos::Impl::cuda_get_deep_copy_space(/*initialize*/ false);
-    if (deep_copy_space)
-      deep_copy_space->impl_internal_space_instance()->finalize();
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamDestroy(cuda_get_deep_copy_stream()));
-  }
-
+  auto cuda_mem_space = Kokkos::CudaSpace::impl_create(m_cudaDev, m_stream);
   if (nullptr != m_scratchSpace || nullptr != m_scratchFlags) {
-    using RecordCuda = Kokkos::Impl::SharedAllocationRecord<CudaSpace>;
-    using RecordHost =
-        Kokkos::Impl::SharedAllocationRecord<CudaHostPinnedSpace>;
-
-    RecordCuda::decrement(RecordCuda::get_record(m_scratchFlags));
-    RecordCuda::decrement(RecordCuda::get_record(m_scratchSpace));
-    RecordHost::decrement(RecordHost::get_record(m_scratchUnified));
-    if (m_scratchFunctorSize > 0)
-      RecordCuda::decrement(RecordCuda::get_record(m_scratchFunctor));
+    auto host_mem_space =
+        Kokkos::CudaHostPinnedSpace::impl_create(m_cudaDev, m_stream);
+    cuda_mem_space.deallocate(m_scratchFlags,
+                              m_scratchFlagsCount * sizeScratchGrain);
+    cuda_mem_space.deallocate(m_scratchSpace,
+                              m_scratchSpaceCount * sizeScratchGrain);
+    host_mem_space.deallocate(m_scratchUnified,
+                              m_scratchUnifiedCount * sizeScratchGrain);
+    if (m_scratchFunctorSize > 0) {
+      cuda_mem_space.deallocate(m_scratchFunctor, m_scratchFunctorSize);
+    }
   }
 
   for (int i = 0; i < m_n_team_scratch; ++i) {
     if (m_team_scratch_current_size[i] > 0)
-      Kokkos::kokkos_free<Kokkos::CudaSpace>(m_team_scratch_ptr[i]);
+      cuda_mem_space.deallocate(m_team_scratch_ptr[i],
+                                m_team_scratch_current_size[i]);
   }
 
-  if (m_manage_stream && m_stream != nullptr)
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamDestroy(m_stream));
-
   m_scratchSpaceCount   = 0;
   m_scratchFlagsCount   = 0;
   m_scratchUnifiedCount = 0;
   m_scratchSpace        = nullptr;
   m_scratchFlags        = nullptr;
   m_scratchUnified      = nullptr;
-  m_stream              = nullptr;
   for (int i = 0; i < m_n_team_scratch; ++i) {
     m_team_scratch_current_size[i] = 0;
     m_team_scratch_ptr[i]          = nullptr;
   }
 
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(m_scratch_locks));
+  KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_free_wrapper(m_scratch_locks)));
   m_scratch_locks     = nullptr;
   m_num_scratch_locks = 0;
 }
 
 //----------------------------------------------------------------------------
 
-Cuda::size_type cuda_internal_multiprocessor_count() {
-  return CudaInternal::singleton().m_multiProcCount;
-}
-
-CudaSpace::size_type cuda_internal_maximum_concurrent_block_count() {
-#if defined(KOKKOS_ARCH_KEPLER)
-  // Compute capability 3.0 through 3.7
-  enum : int { max_resident_blocks_per_multiprocessor = 16 };
-#else
-  // Compute capability 5.0 through 6.2
-  enum : int { max_resident_blocks_per_multiprocessor = 32 };
-#endif
-  return CudaInternal::singleton().m_multiProcCount *
-         max_resident_blocks_per_multiprocessor;
-};
-
-Cuda::size_type cuda_internal_maximum_warp_count() {
-  return CudaInternal::singleton().m_maxWarpCount;
-}
-
-std::array<Cuda::size_type, 3> cuda_internal_maximum_grid_count() {
-  return CudaInternal::singleton().m_maxBlock;
-}
-
-Cuda::size_type cuda_internal_maximum_shared_words() {
-  return CudaInternal::singleton().m_maxSharedWords;
-}
-
 Cuda::size_type *cuda_internal_scratch_space(const Cuda &instance,
                                              const std::size_t size) {
   return instance.impl_internal_space_instance()->scratch_space(size);
@@ -684,10 +520,6 @@ Cuda::size_type *cuda_internal_scratch_unified(const Cuda &instance,
 
 namespace Kokkos {
 
-Cuda::size_type Cuda::detect_device_count() {
-  return Impl::CudaInternalDevices::singleton().m_cudaDevCount;
-}
-
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 int Cuda::concurrency() {
 #else
@@ -701,150 +533,113 @@ int Cuda::impl_is_initialized() {
 }
 
 void Cuda::impl_initialize(InitializationSettings const &settings) {
-  const int cuda_device_id = Impl::get_gpu(settings);
-  const auto &dev_info     = Impl::CudaInternalDevices::singleton();
-
-  // Need device capability 3.0 or better
-  const bool ok_dev = 3 <= dev_info.m_cudaProp[cuda_device_id].major &&
-                      0 <= dev_info.m_cudaProp[cuda_device_id].minor;
-  if (ok_dev) {
-    const struct cudaDeviceProp &cudaProp = dev_info.m_cudaProp[cuda_device_id];
-
-    Impl::CudaInternal::m_cudaDev    = cuda_device_id;
-    Impl::CudaInternal::m_deviceProp = cudaProp;
-
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(cuda_device_id));
-    Kokkos::Impl::cuda_device_synchronize(
-        "Kokkos::CudaInternal::initialize: Fence on space initialization");
-
-    // Query what compute capability architecture a kernel executes:
-    Impl::CudaInternal::m_cudaArch = Impl::cuda_kernel_arch();
-
-    if (Impl::CudaInternal::m_cudaArch == 0) {
-      std::stringstream ss;
-      ss << "Kokkos::Cuda::initialize ERROR: likely mismatch of architecture\n";
-      std::string msg = ss.str();
-      Kokkos::abort(msg.c_str());
-    }
+  const std::vector<int> &visible_devices = Impl::get_visible_devices();
+  const int cuda_device_id =
+      Impl::get_gpu(settings).value_or(visible_devices[0]);
 
-    int compiled_major = Impl::CudaInternal::m_cudaArch / 100;
-    int compiled_minor = (Impl::CudaInternal::m_cudaArch % 100) / 10;
-
-    if ((compiled_major > cudaProp.major) ||
-        ((compiled_major == cudaProp.major) &&
-         (compiled_minor > cudaProp.minor))) {
-      std::stringstream ss;
-      ss << "Kokkos::Cuda::initialize ERROR: running kernels compiled for "
-            "compute capability "
-         << compiled_major << "." << compiled_minor
-         << " on device with compute capability " << cudaProp.major << "."
-         << cudaProp.minor << " is not supported by CUDA!\n";
-      std::string msg = ss.str();
-      Kokkos::abort(msg.c_str());
-    }
-    if (Kokkos::show_warnings() && (compiled_major != cudaProp.major ||
-                                    compiled_minor != cudaProp.minor)) {
-      std::cerr << "Kokkos::Cuda::initialize WARNING: running kernels compiled "
-                   "for compute capability "
-                << compiled_major << "." << compiled_minor
-                << " on device with compute capability " << cudaProp.major
-                << "." << cudaProp.minor
-                << " , this will likely reduce potential performance."
-                << std::endl;
-    }
+  cudaDeviceProp cudaProp;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(
+      cudaGetDeviceProperties(&cudaProp, cuda_device_id));
+  Impl::CudaInternal::m_deviceProp = cudaProp;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(cuda_device_id));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaDeviceSynchronize());
 
-    // number of multiprocessors
-    Impl::CudaInternal::m_multiProcCount = cudaProp.multiProcessorCount;
+  // Query what compute capability architecture a kernel executes:
+  Impl::CudaInternal::m_cudaArch = Impl::cuda_kernel_arch(cuda_device_id);
 
-    //----------------------------------
-    // Maximum number of warps,
-    // at most one warp per thread in a warp for reduction.
-    Impl::CudaInternal::m_maxWarpCount =
-        cudaProp.maxThreadsPerBlock / Impl::CudaTraits::WarpSize;
-
-    if (Impl::CudaTraits::WarpSize < Impl::CudaInternal::m_maxWarpCount) {
-      Impl::CudaInternal::m_maxWarpCount = Impl::CudaTraits::WarpSize;
-    }
-
-    constexpr auto WordSize = sizeof(size_type);
-    Impl::CudaInternal::m_maxSharedWords =
-        cudaProp.sharedMemPerBlock / WordSize;
-
-    //----------------------------------
-    // Maximum number of blocks:
-
-    Impl::CudaInternal::m_maxBlock[0] = cudaProp.maxGridSize[0];
-    Impl::CudaInternal::m_maxBlock[1] = cudaProp.maxGridSize[1];
-    Impl::CudaInternal::m_maxBlock[2] = cudaProp.maxGridSize[2];
-
-    Impl::CudaInternal::m_shmemPerSM = cudaProp.sharedMemPerMultiprocessor;
-    Impl::CudaInternal::m_maxShmemPerBlock = cudaProp.sharedMemPerBlock;
-    Impl::CudaInternal::m_maxBlocksPerSM =
-        Impl::CudaInternal::m_cudaArch < 500
-            ? 16
-            : (Impl::CudaInternal::m_cudaArch < 750
-                   ? 32
-                   : (Impl::CudaInternal::m_cudaArch == 750 ? 16 : 32));
-    Impl::CudaInternal::m_maxThreadsPerSM =
-        cudaProp.maxThreadsPerMultiProcessor;
-    Impl::CudaInternal::m_maxThreadsPerBlock = cudaProp.maxThreadsPerBlock;
-
-    //----------------------------------
-
-    Impl::CudaInternal::m_scratchUnifiedSupported = cudaProp.unifiedAddressing;
-
-    if (Kokkos::show_warnings() &&
-        !Impl::CudaInternal::m_scratchUnifiedSupported) {
-      std::cerr << "Kokkos::Cuda device " << cudaProp.name << " capability "
-                << cudaProp.major << "." << cudaProp.minor
-                << " does not support unified virtual address space"
-                << std::endl;
-    }
-  } else {
-    std::ostringstream msg;
-    msg << "Kokkos::Cuda::initialize(" << cuda_device_id << ") FAILED: Device ";
-    msg << dev_info.m_cudaProp[cuda_device_id].major;
-    msg << ".";
-    msg << dev_info.m_cudaProp[cuda_device_id].minor;
-    msg << " has insufficient capability, required 3.0 or better";
-    Kokkos::Impl::throw_runtime_exception(msg.str());
+  if (Impl::CudaInternal::m_cudaArch == 0) {
+    Kokkos::abort(
+        "Kokkos::Cuda::initialize ERROR: likely mismatch of architecture\n");
   }
 
-  cudaStream_t singleton_stream;
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamCreate(&singleton_stream));
+  int compiled_major = Impl::CudaInternal::m_cudaArch / 100;
+  int compiled_minor = (Impl::CudaInternal::m_cudaArch % 100) / 10;
+
+  if ((compiled_major > cudaProp.major) ||
+      ((compiled_major == cudaProp.major) &&
+       (compiled_minor > cudaProp.minor))) {
+    std::stringstream ss;
+    ss << "Kokkos::Cuda::initialize ERROR: running kernels compiled for "
+          "compute capability "
+       << compiled_major << "." << compiled_minor
+       << " on device with compute capability " << cudaProp.major << "."
+       << cudaProp.minor << " is not supported by CUDA!\n";
+    std::string msg = ss.str();
+    Kokkos::abort(msg.c_str());
+  }
+  if (Kokkos::show_warnings() &&
+      (compiled_major != cudaProp.major || compiled_minor != cudaProp.minor)) {
+    std::cerr << "Kokkos::Cuda::initialize WARNING: running kernels compiled "
+                 "for compute capability "
+              << compiled_major << "." << compiled_minor
+              << " on device with compute capability " << cudaProp.major << "."
+              << cudaProp.minor
+              << " , this will likely reduce potential performance."
+              << std::endl;
+  }
 
-  auto &cuda_singleton = Impl::CudaInternal::singleton();
-  cuda_singleton.initialize(singleton_stream, /*manage*/ true);
-}
+  //----------------------------------
 
-std::vector<unsigned> Cuda::detect_device_arch() {
-  const Impl::CudaInternalDevices &s = Impl::CudaInternalDevices::singleton();
+#ifdef KOKKOS_ENABLE_CUDA_UVM
+  const char *env_force_device_alloc =
+      getenv("CUDA_MANAGED_FORCE_DEVICE_ALLOC");
+  bool force_device_alloc;
+  if (env_force_device_alloc == nullptr)
+    force_device_alloc = false;
+  else
+    force_device_alloc = std::stoi(env_force_device_alloc) != 0;
 
-  std::vector<unsigned> output(s.m_cudaDevCount);
+  const char *env_visible_devices = getenv("CUDA_VISIBLE_DEVICES");
+  bool visible_devices_one        = true;
+  if (env_visible_devices == nullptr) visible_devices_one = false;
 
-  for (int i = 0; i < s.m_cudaDevCount; ++i) {
-    output[i] = s.m_cudaProp[i].major * 100 + s.m_cudaProp[i].minor;
+  if (Kokkos::show_warnings() &&
+      (!visible_devices_one && !force_device_alloc)) {
+    std::cerr << R"warning(
+Kokkos::Cuda::initialize WARNING: Cuda is allocating into UVMSpace by default
+                                  without setting CUDA_MANAGED_FORCE_DEVICE_ALLOC=1 or
+                                  setting CUDA_VISIBLE_DEVICES.
+                                  This could on multi GPU systems lead to severe performance"
+                                  penalties.)warning"
+              << std::endl;
   }
+#endif
 
-  return output;
-}
+  //----------------------------------
+
+  cudaStream_t singleton_stream;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(cuda_device_id));
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamCreate(&singleton_stream));
 
-Cuda::size_type Cuda::device_arch() {
-  const int dev_id = Impl::CudaInternal::singleton().m_cudaDev;
+  // Init the array for used for arbitrarily sized atomics
+  desul::Impl::init_lock_arrays();  // FIXME
 
-  int dev_arch = 0;
+  Impl::CudaInternal::singleton().initialize(singleton_stream);
+}
 
-  if (0 <= dev_id) {
-    const struct cudaDeviceProp &cudaProp =
-        Impl::CudaInternalDevices::singleton().m_cudaProp[dev_id];
+void Cuda::impl_finalize() {
+  (void)Impl::cuda_global_unique_token_locks(true);
+  desul::Impl::finalize_lock_arrays();  // FIXME
 
-    dev_arch = cudaProp.major * 100 + cudaProp.minor;
+  for (const auto cuda_device : Kokkos::Impl::CudaInternal::cuda_devices) {
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(cuda_device));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        cudaFreeHost(Kokkos::Impl::CudaInternal::constantMemHostStagingPerDevice
+                         [cuda_device]));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaEventDestroy(
+        Kokkos::Impl::CudaInternal::constantMemReusablePerDevice[cuda_device]));
   }
 
-  return dev_arch;
-}
+  auto &deep_copy_space = Impl::cuda_get_deep_copy_space(/*initialize*/ false);
+  if (deep_copy_space)
+    deep_copy_space->impl_internal_space_instance()->finalize();
+  KOKKOS_IMPL_CUDA_SAFE_CALL(
+      cudaStreamDestroy(Impl::cuda_get_deep_copy_stream()));
 
-void Cuda::impl_finalize() { Impl::CudaInternal::singleton().finalize(); }
+  Impl::CudaInternal::singleton().finalize();
+  KOKKOS_IMPL_CUDA_SAFE_CALL(
+      cudaStreamDestroy(Impl::CudaInternal::singleton().m_stream));
+}
 
 Cuda::Cuda()
     : m_space_instance(&Impl::CudaInternal::singleton(),
@@ -853,14 +648,22 @@ Cuda::Cuda()
       "Cuda instance constructor");
 }
 
-Cuda::Cuda(cudaStream_t stream, bool manage_stream)
-    : m_space_instance(new Impl::CudaInternal, [](Impl::CudaInternal *ptr) {
-        ptr->finalize();
-        delete ptr;
-      }) {
+KOKKOS_DEPRECATED Cuda::Cuda(cudaStream_t stream, bool manage_stream)
+    : Cuda(stream,
+           manage_stream ? Impl::ManageStream::yes : Impl::ManageStream::no) {}
+
+Cuda::Cuda(cudaStream_t stream, Impl::ManageStream manage_stream)
+    : m_space_instance(
+          new Impl::CudaInternal, [manage_stream](Impl::CudaInternal *ptr) {
+            ptr->finalize();
+            if (static_cast<bool>(manage_stream)) {
+              KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamDestroy(ptr->m_stream));
+            }
+            delete ptr;
+          }) {
   Impl::CudaInternal::singleton().verify_is_initialized(
       "Cuda instance constructor");
-  m_space_instance->initialize(stream, manage_stream);
+  m_space_instance->initialize(stream);
 }
 
 void Cuda::print_configuration(std::ostream &os, bool /*verbose*/) const {
@@ -896,6 +699,12 @@ void Cuda::print_configuration(std::ostream &os, bool /*verbose*/) const {
 #else
   os << "no\n";
 #endif
+  os << "  KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC: ";
+#ifdef KOKKOS_ENABLE_IMPL_CUDA_MALLOC_ASYNC
+  os << "yes\n";
+#else
+  os << "no\n";
+#endif
 
   os << "\nCuda Runtime Configuration:\n";
 
@@ -915,7 +724,9 @@ uint32_t Cuda::impl_instance_id() const noexcept {
   return m_space_instance->impl_get_instance_id();
 }
 
-cudaStream_t Cuda::cuda_stream() const { return m_space_instance->m_stream; }
+cudaStream_t Cuda::cuda_stream() const {
+  return m_space_instance->get_stream();
+}
 int Cuda::cuda_device() const { return m_space_instance->m_cudaDev; }
 const cudaDeviceProp &Cuda::cuda_device_prop() const {
   return m_space_instance->m_deviceProp;
@@ -926,10 +737,28 @@ namespace Impl {
 int g_cuda_space_factory_initialized =
     initialize_space_factory<Cuda>("150_Cuda");
 
+int CudaInternal::m_cudaArch = -1;
+cudaDeviceProp CudaInternal::m_deviceProp;
+std::set<int> CudaInternal::cuda_devices = {};
+std::map<int, unsigned long *> CudaInternal::constantMemHostStagingPerDevice =
+    {};
+std::map<int, cudaEvent_t> CudaInternal::constantMemReusablePerDevice = {};
+std::map<int, std::mutex> CudaInternal::constantMemMutexPerDevice     = {};
+
 }  // namespace Impl
 
 }  // namespace Kokkos
 
+void Kokkos::Impl::create_Cuda_instances(std::vector<Cuda> &instances) {
+  for (int s = 0; s < int(instances.size()); s++) {
+    cudaStream_t stream;
+    KOKKOS_IMPL_CUDA_SAFE_CALL((
+        instances[s].impl_internal_space_instance()->cuda_stream_create_wrapper(
+            &stream)));
+    instances[s] = Cuda(stream, ManageStream::yes);
+  }
+}
+
 #else
 
 void KOKKOS_CORE_SRC_CUDA_IMPL_PREVENT_LINK_ERROR() {}
diff --git a/core/src/Cuda/Kokkos_Cuda_Instance.hpp b/core/src/Cuda/Kokkos_Cuda_Instance.hpp
index ddbddfd674..ffaa0f5474 100644
--- a/core/src/Cuda/Kokkos_Cuda_Instance.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Instance.hpp
@@ -21,6 +21,11 @@
 #include <impl/Kokkos_Tools.hpp>
 #include <atomic>
 #include <Cuda/Kokkos_Cuda_Error.hpp>
+#include <cuda_runtime_api.h>
+#include "Kokkos_CudaSpace.hpp"
+
+#include <set>
+#include <map>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -54,28 +59,10 @@ struct CudaTraits {
       unsigned long[ConstantMemoryUsage / sizeof(unsigned long)];
 
   static constexpr int ConstantMemoryUseThreshold = 0x000200 /* 512 bytes */;
-
-  KOKKOS_INLINE_FUNCTION static CudaSpace::size_type warp_count(
-      CudaSpace::size_type i) {
-    return (i + WarpIndexMask) >> WarpIndexShift;
-  }
-
-  KOKKOS_INLINE_FUNCTION static CudaSpace::size_type warp_align(
-      CudaSpace::size_type i) {
-    constexpr CudaSpace::size_type Mask = ~WarpIndexMask;
-    return (i + WarpIndexMask) & Mask;
-  }
 };
 
 //----------------------------------------------------------------------------
 
-CudaSpace::size_type cuda_internal_multiprocessor_count();
-CudaSpace::size_type cuda_internal_maximum_warp_count();
-std::array<CudaSpace::size_type, 3> cuda_internal_maximum_grid_count();
-CudaSpace::size_type cuda_internal_maximum_shared_words();
-
-CudaSpace::size_type cuda_internal_maximum_concurrent_block_count();
-
 CudaSpace::size_type* cuda_internal_scratch_flags(const Cuda&,
                                                   const std::size_t size);
 CudaSpace::size_type* cuda_internal_scratch_space(const Cuda&,
@@ -101,22 +88,13 @@ class CudaInternal {
  public:
   using size_type = Cuda::size_type;
 
-  inline static int m_cudaDev = -1;
+  int m_cudaDev = -1;
 
   // Device Properties
-  inline static int m_cudaArch                      = -1;
-  inline static unsigned m_multiProcCount           = 0;
-  inline static unsigned m_maxWarpCount             = 0;
-  inline static std::array<size_type, 3> m_maxBlock = {0, 0, 0};
-  inline static unsigned m_maxSharedWords           = 0;
-  inline static int m_shmemPerSM                    = 0;
-  inline static int m_maxShmemPerBlock              = 0;
-  inline static int m_maxBlocksPerSM                = 0;
-  inline static int m_maxThreadsPerSM               = 0;
-  inline static int m_maxThreadsPerBlock            = 0;
+  static int m_cudaArch;
   static int concurrency();
 
-  inline static cudaDeviceProp m_deviceProp;
+  static cudaDeviceProp m_deviceProp;
 
   // Scratch Spaces for Reductions
   mutable std::size_t m_scratchSpaceCount;
@@ -124,14 +102,12 @@ class CudaInternal {
   mutable std::size_t m_scratchUnifiedCount;
   mutable std::size_t m_scratchFunctorSize;
 
-  inline static size_type m_scratchUnifiedSupported = 0;
   mutable size_type* m_scratchSpace;
   mutable size_type* m_scratchFlags;
   mutable size_type* m_scratchUnified;
   mutable size_type* m_scratchFunctor;
   cudaStream_t m_stream;
   uint32_t m_instance_id;
-  bool m_manage_stream;
 
   // Team Scratch Level 1 Space
   int m_n_team_scratch = 10;
@@ -144,11 +120,10 @@ class CudaInternal {
   bool was_initialized = false;
   bool was_finalized   = false;
 
-  // FIXME_CUDA: these want to be per-device, not per-stream...  use of 'static'
-  //  here will break once there are multiple devices though
-  inline static unsigned long* constantMemHostStaging = nullptr;
-  inline static cudaEvent_t constantMemReusable       = nullptr;
-  inline static std::mutex constantMemMutex;
+  static std::set<int> cuda_devices;
+  static std::map<int, unsigned long*> constantMemHostStagingPerDevice;
+  static std::map<int, cudaEvent_t> constantMemReusablePerDevice;
+  static std::map<int, std::mutex> constantMemMutexPerDevice;
 
   static CudaInternal& singleton();
 
@@ -158,7 +133,7 @@ class CudaInternal {
     return nullptr != m_scratchSpace && nullptr != m_scratchFlags;
   }
 
-  void initialize(cudaStream_t stream, bool manage_stream);
+  void initialize(cudaStream_t stream);
   void finalize();
 
   void print_configuration(std::ostream&) const;
@@ -193,6 +168,284 @@ class CudaInternal {
     }
   }
 
+  // Using cudaAPI function/objects will be w.r.t. device 0 unless
+  // cudaSetDevice(device_id) is called with the correct device_id.
+  // The correct device_id is stored in the variable
+  // CudaInternal::m_cudaDev set in Cuda::impl_initialize(). It is not
+  // sufficient to call cudaSetDevice(m_cudaDev) during cuda initialization
+  // only, however, since if a user creates a new thread, that thread will be
+  // given the default cuda env with device_id=0, causing errors when
+  // device_id!=0 is requested by the user. To ensure against this, almost all
+  // cudaAPI calls, as well as using cudaStream_t variables, must be proceeded
+  // by cudaSetDevice(device_id).
+
+  // This function sets device in cudaAPI to device requested at runtime (set in
+  // m_cudaDev).
+  void set_cuda_device() const {
+    verify_is_initialized("set_cuda_device");
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_cudaDev));
+  }
+
+  // Return the class stream, optionally setting the device id.
+  template <bool setCudaDevice = true>
+  cudaStream_t get_stream() const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return m_stream;
+  }
+
+  // The following are wrappers for cudaAPI functions (C and C++ routines) which
+  // set the correct device id directly before the cudaAPI call (unless
+  // explicitly disabled by providing setCudaDevice=false template).
+  // setCudaDevice=true should be used for all API calls which take a stream
+  // unless it is guarenteed to be from a cuda instance with the correct device
+  // set already (e.g., back-to-back cudaAPI calls in a single function). For
+  // cudaAPI functions that take a stream, an optional input stream is
+  // available. If no stream is given, the stream for the CudaInternal instance
+  // is used. All cudaAPI calls should be wrapped in these interface functions
+  // to ensure safety when using threads.
+
+  // Helper function for selecting the correct input stream
+  cudaStream_t get_input_stream(cudaStream_t s) const {
+    return s == nullptr ? get_stream<false>() : s;
+  }
+
+  // C API routines
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_device_get_limit_wrapper(size_t* pValue,
+                                            cudaLimit limit) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaDeviceGetLimit(pValue, limit);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_device_set_limit_wrapper(cudaLimit limit,
+                                            size_t value) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaDeviceSetLimit(limit, value);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_event_create_wrapper(cudaEvent_t* event) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaEventCreate(event);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_event_destroy_wrapper(cudaEvent_t event) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaEventDestroy(event);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_event_record_wrapper(cudaEvent_t event,
+                                        cudaStream_t stream = nullptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaEventRecord(event, get_input_stream(stream));
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_event_synchronize_wrapper(cudaEvent_t event) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaEventSynchronize(event);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_free_wrapper(void* devPtr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaFree(devPtr);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_free_host_wrapper(void* ptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaFreeHost(ptr);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_add_dependencies_wrapper(
+      cudaGraph_t graph, const cudaGraphNode_t* from, const cudaGraphNode_t* to,
+      size_t numDependencies) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphAddDependencies(graph, from, to, numDependencies);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_add_empty_node_wrapper(
+      cudaGraphNode_t* pGraphNode, cudaGraph_t graph,
+      const cudaGraphNode_t* pDependencies, size_t numDependencies) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies,
+                                 numDependencies);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_add_kernel_node_wrapper(
+      cudaGraphNode_t* pGraphNode, cudaGraph_t graph,
+      const cudaGraphNode_t* pDependencies, size_t numDependencies,
+      const cudaKernelNodeParams* pNodeParams) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphAddKernelNode(pGraphNode, graph, pDependencies,
+                                  numDependencies, pNodeParams);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_create_wrapper(cudaGraph_t* pGraph,
+                                        unsigned int flags) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphCreate(pGraph, flags);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_destroy_wrapper(cudaGraph_t graph) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphDestroy(graph);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_exec_destroy_wrapper(cudaGraphExec_t graphExec) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphExecDestroy(graphExec);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_launch_wrapper(cudaGraphExec_t graphExec,
+                                        cudaStream_t stream = nullptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphLaunch(graphExec, get_input_stream(stream));
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_host_alloc_wrapper(void** pHost, size_t size,
+                                      unsigned int flags) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaHostAlloc(pHost, size, flags);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_malloc_wrapper(void** devPtr, size_t size) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMalloc(devPtr, size);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_malloc_host_wrapper(void** ptr, size_t size) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMallocHost(ptr, size);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_malloc_managed_wrapper(
+      void** devPtr, size_t size,
+      unsigned int flags = cudaMemAttachGlobal) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMallocManaged(devPtr, size, flags);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_mem_advise_wrapper(const void* devPtr, size_t count,
+                                      cudaMemoryAdvise advice,
+                                      int device) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemAdvise(devPtr, count, advice, device);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_mem_prefetch_async_wrapper(
+      const void* devPtr, size_t count, int dstDevice,
+      cudaStream_t stream = nullptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemPrefetchAsync(devPtr, count, dstDevice,
+                                get_input_stream(stream));
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_memcpy_wrapper(void* dst, const void* src, size_t count,
+                                  cudaMemcpyKind kind) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemcpy(dst, src, count, kind);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_memcpy_async_wrapper(void* dst, const void* src,
+                                        size_t count, cudaMemcpyKind kind,
+                                        cudaStream_t stream = nullptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemcpyAsync(dst, src, count, kind, get_input_stream(stream));
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_memcpy_to_symbol_async_wrapper(
+      const void* symbol, const void* src, size_t count, size_t offset,
+      cudaMemcpyKind kind, cudaStream_t stream = nullptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemcpyToSymbolAsync(symbol, src, count, offset, kind,
+                                   get_input_stream(stream));
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_memset_wrapper(void* devPtr, int value, size_t count) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemset(devPtr, value, count);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_memset_async_wrapper(void* devPtr, int value, size_t count,
+                                        cudaStream_t stream = nullptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaMemsetAsync(devPtr, value, count, get_input_stream(stream));
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_pointer_get_attributes_wrapper(
+      cudaPointerAttributes* attributes, const void* ptr) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaPointerGetAttributes(attributes, ptr);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_stream_create_wrapper(cudaStream_t* pStream) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaStreamCreate(pStream);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_stream_destroy_wrapper(cudaStream_t stream) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaStreamDestroy(stream);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_stream_synchronize_wrapper(cudaStream_t stream) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaStreamSynchronize(stream);
+  }
+
+  // C++ API routines
+  template <typename T, bool setCudaDevice = true>
+  cudaError_t cuda_func_get_attributes_wrapper(cudaFuncAttributes* attr,
+                                               T* entry) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaFuncGetAttributes(attr, entry);
+  }
+
+  template <typename T, bool setCudaDevice = true>
+  cudaError_t cuda_func_set_attribute_wrapper(T* entry, cudaFuncAttribute attr,
+                                              int value) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaFuncSetAttribute(entry, attr, value);
+  }
+
+  template <bool setCudaDevice = true>
+  cudaError_t cuda_graph_instantiate_wrapper(cudaGraphExec_t* pGraphExec,
+                                             cudaGraph_t graph,
+                                             cudaGraphNode_t* pErrorNode,
+                                             char* pLogBuffer,
+                                             size_t bufferSize) const {
+    if constexpr (setCudaDevice) set_cuda_device();
+    return cudaGraphInstantiate(pGraphExec, graph, pErrorNode, pLogBuffer,
+                                bufferSize);
+  }
+
   // Resizing of reduction related scratch spaces
   size_type* scratch_space(const std::size_t size) const;
   size_type* scratch_flags(const std::size_t size) const;
@@ -206,6 +459,7 @@ class CudaInternal {
   void release_team_scratch_space(int scratch_pool_id);
 };
 
+void create_Cuda_instances(std::vector<Cuda>& instances);
 }  // Namespace Impl
 
 namespace Experimental {
@@ -214,23 +468,13 @@ namespace Experimental {
 //   Customization point for backends
 //   Default behavior is to return the passed in instance
 
-namespace Impl {
-inline void create_Cuda_instances(std::vector<Cuda>& instances) {
-  for (int s = 0; s < int(instances.size()); s++) {
-    cudaStream_t stream;
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamCreate(&stream));
-    instances[s] = Cuda(stream, true);
-  }
-}
-}  // namespace Impl
-
 template <class... Args>
 std::vector<Cuda> partition_space(const Cuda&, Args...) {
   static_assert(
       (... && std::is_arithmetic_v<Args>),
       "Kokkos Error: partitioning arguments must be integers or floats");
   std::vector<Cuda> instances(sizeof...(Args));
-  Impl::create_Cuda_instances(instances);
+  Kokkos::Impl::create_Cuda_instances(instances);
   return instances;
 }
 
@@ -243,7 +487,7 @@ std::vector<Cuda> partition_space(const Cuda&, std::vector<T> const& weights) {
   // 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);
+  Kokkos::Impl::create_Cuda_instances(instances);
   return instances;
 }
 }  // namespace Experimental
diff --git a/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp b/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
index 3a96f850a9..b0dadb45f7 100644
--- a/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_KernelLaunch.hpp
@@ -21,7 +21,6 @@
 #ifdef KOKKOS_ENABLE_CUDA
 
 #include <mutex>
-#include <string>
 #include <cstdint>
 #include <cmath>
 #include <Kokkos_Parallel.hpp>
@@ -118,40 +117,43 @@ inline bool is_empty_launch(dim3 const& grid, dim3 const& block) {
 }
 
 inline void check_shmem_request(CudaInternal const* cuda_instance, int shmem) {
-  if (cuda_instance->m_maxShmemPerBlock < shmem) {
+  int const maxShmemPerBlock = cuda_instance->m_deviceProp.sharedMemPerBlock;
+  if (maxShmemPerBlock < shmem) {
     Kokkos::Impl::throw_runtime_exception(
-        std::string("CudaParallelLaunch (or graph node creation) FAILED: shared"
-                    " memory request is too large"));
+        "CudaParallelLaunch (or graph node creation) FAILED: shared memory "
+        "request is too large");
   }
 }
 
 // These functions need to be templated on DriverType and LaunchBounds
 // so that the static bool is unique for each type combo
 // KernelFuncPtr does not necessarily contain that type information.
-
 template <class DriverType, class LaunchBounds, class KernelFuncPtr>
 const cudaFuncAttributes& get_cuda_kernel_func_attributes(
-    const KernelFuncPtr& func) {
+    int cuda_device, const KernelFuncPtr& func) {
   // Only call cudaFuncGetAttributes once for each unique kernel
   // by leveraging static variable initialization rules
-  auto wrap_get_attributes = [&]() -> cudaFuncAttributes {
+  static std::map<int, cudaFuncAttributes> func_attr;
+  if (func_attr.find(cuda_device) == func_attr.end()) {
     cudaFuncAttributes attr;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(cuda_device));
     KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFuncGetAttributes(&attr, func));
-    return attr;
-  };
-  static cudaFuncAttributes func_attr = wrap_get_attributes();
-  return func_attr;
+    func_attr.emplace(cuda_device, attr);
+  }
+  return func_attr[cuda_device];
 }
 
 template <class DriverType, class LaunchBounds, class KernelFuncPtr>
-inline void configure_shmem_preference(const KernelFuncPtr& func,
+inline void configure_shmem_preference(const int cuda_device,
+                                       const KernelFuncPtr& func,
                                        const cudaDeviceProp& device_props,
                                        const size_t block_size, int& shmem,
                                        const size_t occupancy) {
 #ifndef KOKKOS_ARCH_KEPLER
 
   const auto& func_attr =
-      get_cuda_kernel_func_attributes<DriverType, LaunchBounds>(func);
+      get_cuda_kernel_func_attributes<DriverType, LaunchBounds>(cuda_device,
+                                                                func);
 
   // Compute limits for number of blocks due to registers/SM
   const size_t regs_per_sm     = device_props.regsPerMultiprocessor;
@@ -217,9 +219,11 @@ inline void configure_shmem_preference(const KernelFuncPtr& func,
   if (carveout > 100) carveout = 100;
 
   // Set the carveout, but only call it once per kernel or when it changes
+  // FIXME_CUDA_MULTIPLE_DEVICES
   auto set_cache_config = [&] {
-    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFuncSetAttribute(
-        func, cudaFuncAttributePreferredSharedMemoryCarveout, carveout));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        (CudaInternal::singleton().cuda_func_set_attribute_wrapper(
+            func, cudaFuncAttributePreferredSharedMemoryCarveout, carveout)));
     return carveout;
   };
   // Store the value in a static variable so we only reset if needed
@@ -361,9 +365,8 @@ struct CudaParallelLaunchKernelInvoker<
   static void invoke_kernel(DriverType const& driver, dim3 const& grid,
                             dim3 const& block, int shmem,
                             CudaInternal const* cuda_instance) {
-    (base_t::
-         get_kernel_func())<<<grid, block, shmem, cuda_instance->m_stream>>>(
-        driver);
+    (base_t::get_kernel_func())<<<grid, block, shmem,
+                                  cuda_instance->get_stream()>>>(driver);
   }
 
   inline static void create_parallel_launch_graph_node(
@@ -384,8 +387,8 @@ struct CudaParallelLaunchKernelInvoker<
             driver.get_policy().impl_get_desired_occupancy().value();
         size_t block_size = block.x * block.y * block.z;
         Impl::configure_shmem_preference<DriverType, LaunchBounds>(
-            base_t::get_kernel_func(), cuda_instance->m_deviceProp, block_size,
-            shmem, desired_occupancy);
+            cuda_instance->m_cudaDev, base_t::get_kernel_func(),
+            cuda_instance->m_deviceProp, block_size, shmem, desired_occupancy);
       }
 
       void const* args[] = {&driver};
@@ -399,15 +402,17 @@ struct CudaParallelLaunchKernelInvoker<
       params.kernelParams   = (void**)args;
       params.extra          = nullptr;
 
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGraphAddKernelNode(
-          &graph_node, graph, /* dependencies = */ nullptr,
-          /* numDependencies = */ 0, &params));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(
+          (cuda_instance->cuda_graph_add_kernel_node_wrapper(
+              &graph_node, graph, /* dependencies = */ nullptr,
+              /* numDependencies = */ 0, &params)));
     } else {
       // We still need an empty node for the dependency structure
       KOKKOS_IMPL_CUDA_SAFE_CALL(
-          cudaGraphAddEmptyNode(&graph_node, graph,
-                                /* dependencies = */ nullptr,
-                                /* numDependencies = */ 0));
+          (cuda_instance->cuda_graph_add_empty_node_wrapper(
+              &graph_node, graph,
+              /* dependencies = */ nullptr,
+              /* numDependencies = */ 0)));
     }
     KOKKOS_ENSURES(bool(graph_node))
   }
@@ -458,11 +463,10 @@ struct CudaParallelLaunchKernelInvoker<
     DriverType* driver_ptr = reinterpret_cast<DriverType*>(
         cuda_instance->scratch_functor(sizeof(DriverType)));
 
-    cudaMemcpyAsync(driver_ptr, &driver, sizeof(DriverType), cudaMemcpyDefault,
-                    cuda_instance->m_stream);
-    (base_t::
-         get_kernel_func())<<<grid, block, shmem, cuda_instance->m_stream>>>(
-        driver_ptr);
+    KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_instance->cuda_memcpy_async_wrapper(
+        driver_ptr, &driver, sizeof(DriverType), cudaMemcpyDefault)));
+    (base_t::get_kernel_func())<<<grid, block, shmem,
+                                  cuda_instance->get_stream()>>>(driver_ptr);
   }
 
   inline static void create_parallel_launch_graph_node(
@@ -483,8 +487,8 @@ struct CudaParallelLaunchKernelInvoker<
             driver.get_policy().impl_get_desired_occupancy().value();
         size_t block_size = block.x * block.y * block.z;
         Impl::configure_shmem_preference<DriverType, LaunchBounds>(
-            base_t::get_kernel_func(), cuda_instance->m_deviceProp, block_size,
-            shmem, desired_occupancy);
+            cuda_instance->m_cudaDev, base_t::get_kernel_func(),
+            cuda_instance->m_deviceProp, block_size, shmem, desired_occupancy);
       }
 
       auto* driver_ptr = Impl::allocate_driver_storage_for_kernel(driver);
@@ -494,8 +498,8 @@ struct CudaParallelLaunchKernelInvoker<
       // which is guaranteed to be alive until the graph instance itself is
       // destroyed, where there should be a fence ensuring that the allocation
       // associated with this kernel on the device side isn't deleted.
-      cudaMemcpyAsync(driver_ptr, &driver, sizeof(DriverType),
-                      cudaMemcpyDefault, cuda_instance->m_stream);
+      KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_instance->cuda_memcpy_async_wrapper(
+          driver_ptr, &driver, sizeof(DriverType), cudaMemcpyDefault)));
 
       void const* args[] = {&driver_ptr};
 
@@ -508,15 +512,17 @@ struct CudaParallelLaunchKernelInvoker<
       params.kernelParams   = (void**)args;
       params.extra          = nullptr;
 
-      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGraphAddKernelNode(
-          &graph_node, graph, /* dependencies = */ nullptr,
-          /* numDependencies = */ 0, &params));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(
+          (cuda_instance->cuda_graph_add_kernel_node_wrapper(
+              &graph_node, graph, /* dependencies = */ nullptr,
+              /* numDependencies = */ 0, &params)));
     } else {
       // We still need an empty node for the dependency structure
       KOKKOS_IMPL_CUDA_SAFE_CALL(
-          cudaGraphAddEmptyNode(&graph_node, graph,
-                                /* dependencies = */ nullptr,
-                                /* numDependencies = */ 0));
+          (cuda_instance->cuda_graph_add_empty_node_wrapper(
+              &graph_node, graph,
+              /* dependencies = */ nullptr,
+              /* numDependencies = */ 0)));
     }
     KOKKOS_ENSURES(bool(graph_node))
   }
@@ -570,28 +576,31 @@ struct CudaParallelLaunchKernelInvoker<
   static void invoke_kernel(DriverType const& driver, dim3 const& grid,
                             dim3 const& block, int shmem,
                             CudaInternal const* cuda_instance) {
+    int cuda_device = cuda_instance->m_cudaDev;
     // Wait until the previous kernel that uses the constant buffer is done
-    std::lock_guard<std::mutex> lock(CudaInternal::constantMemMutex);
-    KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaEventSynchronize(CudaInternal::constantMemReusable));
+    std::lock_guard<std::mutex> lock(
+        CudaInternal::constantMemMutexPerDevice[cuda_device]);
+    KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_instance->cuda_event_synchronize_wrapper(
+        CudaInternal::constantMemReusablePerDevice[cuda_device])));
 
     // Copy functor (synchronously) to staging buffer in pinned host memory
-    unsigned long* staging = cuda_instance->constantMemHostStaging;
+    unsigned long* staging =
+        cuda_instance->constantMemHostStagingPerDevice[cuda_device];
     memcpy(staging, &driver, sizeof(DriverType));
 
     // Copy functor asynchronously from there to constant memory on the device
-    cudaMemcpyToSymbolAsync(kokkos_impl_cuda_constant_memory_buffer, staging,
-                            sizeof(DriverType), 0, cudaMemcpyHostToDevice,
-                            cudaStream_t(cuda_instance->m_stream));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        (cuda_instance->cuda_memcpy_to_symbol_async_wrapper(
+            kokkos_impl_cuda_constant_memory_buffer, staging,
+            sizeof(DriverType), 0, cudaMemcpyHostToDevice)));
 
     // Invoke the driver function on the device
-    (base_t::
-         get_kernel_func())<<<grid, block, shmem, cuda_instance->m_stream>>>();
+    (base_t::get_kernel_func())<<<grid, block, shmem,
+                                  cuda_instance->get_stream()>>>();
 
     // Record an event that says when the constant buffer can be reused
-    KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaEventRecord(CudaInternal::constantMemReusable,
-                        cudaStream_t(cuda_instance->m_stream)));
+    KOKKOS_IMPL_CUDA_SAFE_CALL((cuda_instance->cuda_event_record_wrapper(
+        CudaInternal::constantMemReusablePerDevice[cuda_device])));
   }
 
   inline static void create_parallel_launch_graph_node(
@@ -659,8 +668,8 @@ struct CudaParallelLaunchImpl<
         Impl::configure_shmem_preference<
             DriverType,
             Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>>(
-            base_t::get_kernel_func(), cuda_instance->m_deviceProp, block_size,
-            shmem, desired_occupancy);
+            cuda_instance->m_cudaDev, base_t::get_kernel_func(),
+            cuda_instance->m_deviceProp, block_size, shmem, desired_occupancy);
       }
 
       desul::ensure_cuda_lock_arrays_on_device();
@@ -676,10 +685,10 @@ struct CudaParallelLaunchImpl<
     }
   }
 
-  static cudaFuncAttributes get_cuda_func_attributes() {
+  static cudaFuncAttributes get_cuda_func_attributes(int cuda_device) {
     return get_cuda_kernel_func_attributes<
         DriverType, Kokkos::LaunchBounds<MaxThreadsPerBlock, MinBlocksPerSM>>(
-        base_t::get_kernel_func());
+        cuda_device, base_t::get_kernel_func());
   }
 };
 
diff --git a/core/src/Cuda/Kokkos_Cuda_MDRangePolicy.hpp b/core/src/Cuda/Kokkos_Cuda_MDRangePolicy.hpp
index 7492ab49e5..2c7eba7a18 100644
--- a/core/src/Cuda/Kokkos_Cuda_MDRangePolicy.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_MDRangePolicy.hpp
@@ -40,8 +40,8 @@ template <>
 inline TileSizeProperties get_tile_size_properties<Kokkos::Cuda>(
     const Kokkos::Cuda& space) {
   TileSizeProperties properties;
-  properties.max_threads =
-      space.impl_internal_space_instance()->m_maxThreadsPerSM;
+  properties.max_threads = space.impl_internal_space_instance()
+                               ->m_deviceProp.maxThreadsPerMultiProcessor;
   properties.default_largest_tile_size = 16;
   properties.default_tile_size         = 2;
   properties.max_total_tile_size       = 512;
diff --git a/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp b/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp
index 8aae27d091..6303898400 100644
--- a/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Parallel_MDRange.hpp
@@ -28,7 +28,6 @@
 #include <Cuda/Kokkos_Cuda_KernelLaunch.hpp>
 #include <Cuda/Kokkos_Cuda_ReduceScan.hpp>
 #include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
-#include <Kokkos_MinMaxClamp.hpp>
 
 #include <impl/Kokkos_Tools.hpp>
 #include <typeinfo>
@@ -42,8 +41,8 @@ namespace Impl {
 template <typename ParallelType, typename Policy, typename LaunchBounds>
 int max_tile_size_product_helper(const Policy& pol, const LaunchBounds&) {
   cudaFuncAttributes attr =
-      CudaParallelLaunch<ParallelType,
-                         LaunchBounds>::get_cuda_func_attributes();
+      CudaParallelLaunch<ParallelType, LaunchBounds>::get_cuda_func_attributes(
+          pol.space().cuda_device());
   auto const& prop = pol.space().cuda_device_prop();
 
   // Limits due to registers/SM, MDRange doesn't have
@@ -96,7 +95,7 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, Kokkos::Cuda> {
 
   inline void execute() const {
     if (m_rp.m_num_tiles == 0) return;
-    const auto maxblocks = cuda_internal_maximum_grid_count();
+    const auto maxblocks = m_rp.space().cuda_device_prop().maxGridSize;
     if (RP::rank == 2) {
       const dim3 block(m_rp.m_tile[0], m_rp.m_tile[1], 1);
       KOKKOS_ASSERT(block.x > 0);
@@ -309,6 +308,11 @@ class ParallelReduce<CombinedFunctorReducerType,
 
       if (CudaTraits::WarpSize < word_count.value) {
         __syncthreads();
+      } else {
+        // In the above call to final(), shared might have been updated by a
+        // single thread within a warp without synchronization. Synchronize
+        // threads within warp to avoid potential race condition.
+        __syncwarp(0xffffffff);
       }
 
       for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
@@ -320,19 +324,18 @@ class ParallelReduce<CombinedFunctorReducerType,
   // Determine block size constrained by shared memory:
   inline unsigned local_block_size(const FunctorType& f) {
     unsigned n = CudaTraits::WarpSize * 8;
+    int const maxShmemPerBlock =
+        m_policy.space().cuda_device_prop().sharedMemPerBlock;
     int shmem_size =
         cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, value_type>(
             f, n);
     using closure_type =
         Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
                              Policy, Kokkos::Cuda>;
-    cudaFuncAttributes attr =
-        CudaParallelLaunch<closure_type,
-                           LaunchBounds>::get_cuda_func_attributes();
+    cudaFuncAttributes attr = CudaParallelLaunch<closure_type, LaunchBounds>::
+        get_cuda_func_attributes(m_policy.space().cuda_device());
     while (
-        (n &&
-         (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
-          shmem_size)) ||
+        (n && (maxShmemPerBlock < shmem_size)) ||
         (n >
          static_cast<unsigned>(
              Kokkos::Impl::cuda_get_max_block_size<FunctorType, LaunchBounds>(
diff --git a/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp b/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp
index 5226c48bd9..334834938a 100644
--- a/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Parallel_Range.hpp
@@ -28,7 +28,6 @@
 #include <Cuda/Kokkos_Cuda_KernelLaunch.hpp>
 #include <Cuda/Kokkos_Cuda_ReduceScan.hpp>
 #include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
-#include <Kokkos_MinMaxClamp.hpp>
 
 #include <impl/Kokkos_Tools.hpp>
 #include <typeinfo>
@@ -86,18 +85,18 @@ class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
     const typename Policy::index_type nwork = m_policy.end() - m_policy.begin();
 
     cudaFuncAttributes attr =
-        CudaParallelLaunch<ParallelFor,
-                           LaunchBounds>::get_cuda_func_attributes();
+        CudaParallelLaunch<ParallelFor, LaunchBounds>::get_cuda_func_attributes(
+            m_policy.space().cuda_device());
     const int block_size =
         Kokkos::Impl::cuda_get_opt_block_size<FunctorType, LaunchBounds>(
             m_policy.space().impl_internal_space_instance(), attr, m_functor, 1,
             0, 0);
     KOKKOS_ASSERT(block_size > 0);
     dim3 block(1, block_size, 1);
+    const int maxGridSizeX = m_policy.space().cuda_device_prop().maxGridSize[0];
     dim3 grid(
-        std::min(
-            typename Policy::index_type((nwork + block.y - 1) / block.y),
-            typename Policy::index_type(cuda_internal_maximum_grid_count()[0])),
+        std::min(typename Policy::index_type((nwork + block.y - 1) / block.y),
+                 typename Policy::index_type(maxGridSizeX)),
         1, 1);
 #ifdef KOKKOS_IMPL_DEBUG_CUDA_SERIAL_EXECUTION
     if (Kokkos::Impl::CudaInternal::cuda_use_serial_execution()) {
@@ -243,6 +242,12 @@ class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
 
       if (CudaTraits::WarpSize < word_count.value) {
         __syncthreads();
+      } else if (word_count.value > 1) {
+        // Inside cuda_single_inter_block_reduce_scan() and final() above,
+        // shared[i] below might have been updated by a single thread within a
+        // warp without synchronization afterwards. Synchronize threads within
+        // warp to avoid potential race condition.
+        __syncwarp(0xffffffff);
       }
 
       for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
@@ -254,19 +259,18 @@ class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
   // Determine block size constrained by shared memory:
   inline unsigned local_block_size(const FunctorType& f) {
     unsigned n = CudaTraits::WarpSize * 8;
+    const int maxShmemPerBlock =
+        m_policy.space().cuda_device_prop().sharedMemPerBlock;
     int shmem_size =
         cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, value_type>(
             f, n);
     using closure_type =
         Impl::ParallelReduce<CombinedFunctorReducer<FunctorType, ReducerType>,
                              Policy, Kokkos::Cuda>;
-    cudaFuncAttributes attr =
-        CudaParallelLaunch<closure_type,
-                           LaunchBounds>::get_cuda_func_attributes();
+    cudaFuncAttributes attr = CudaParallelLaunch<closure_type, LaunchBounds>::
+        get_cuda_func_attributes(m_policy.space().cuda_device());
     while (
-        (n &&
-         (m_policy.space().impl_internal_space_instance()->m_maxShmemPerBlock <
-          shmem_size)) ||
+        (n && (maxShmemPerBlock < shmem_size)) ||
         (n >
          static_cast<unsigned>(
              Kokkos::Impl::cuda_get_max_block_size<FunctorType, LaunchBounds>(
@@ -308,8 +312,9 @@ class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
       // REQUIRED ( 1 , N , 1 )
       dim3 block(1, block_size, 1);
       // Required grid.x <= block.y
-      dim3 grid(std::min(int(block.y), int((nwork + block.y - 1) / block.y)), 1,
-                1);
+      dim3 grid(std::min(index_type(block.y),
+                         index_type((nwork + block.y - 1) / block.y)),
+                1, 1);
 
       // TODO @graph We need to effectively insert this in to the graph
       const int shmem =
@@ -609,11 +614,11 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Cuda> {
     // 4 warps was 10% faster than 8 warps and 20% faster than 16 warps in unit
     // testing
 
+    const int maxShmemPerBlock =
+        m_policy.space().cuda_device_prop().sharedMemPerBlock;
     unsigned n = CudaTraits::WarpSize * 4;
     while (n &&
-           unsigned(m_policy.space()
-                        .impl_internal_space_instance()
-                        ->m_maxShmemPerBlock) <
+           unsigned(maxShmemPerBlock) <
                cuda_single_inter_block_reduce_scan_shmem<true, WorkTag,
                                                          value_type>(f, n)) {
       n >>= 1;
@@ -933,11 +938,11 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     // 4 warps was 10% faster than 8 warps and 20% faster than 16 warps in unit
     // testing
 
+    const int maxShmemPerBlock =
+        m_policy.space().cuda_device_prop().sharedMemPerBlock;
     unsigned n = CudaTraits::WarpSize * 4;
     while (n &&
-           unsigned(m_policy.space()
-                        .impl_internal_space_instance()
-                        ->m_maxShmemPerBlock) <
+           unsigned(maxShmemPerBlock) <
                cuda_single_inter_block_reduce_scan_shmem<true, WorkTag,
                                                          value_type>(f, n)) {
       n >>= 1;
diff --git a/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp b/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp
index c5a211a807..71e7751821 100644
--- a/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Parallel_Team.hpp
@@ -32,7 +32,7 @@
 #include <Cuda/Kokkos_Cuda_ReduceScan.hpp>
 #include <Cuda/Kokkos_Cuda_BlockSize_Deduction.hpp>
 #include <Cuda/Kokkos_Cuda_Team.hpp>
-#include <Kokkos_MinMaxClamp.hpp>
+#include <Kokkos_MinMax.hpp>
 #include <Kokkos_Vectorization.hpp>
 
 #include <impl/Kokkos_Tools.hpp>
@@ -98,7 +98,7 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
         Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
     cudaFuncAttributes attr =
         CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
-            get_cuda_func_attributes();
+            get_cuda_func_attributes(space().cuda_device());
     int block_size =
         Kokkos::Impl::cuda_get_max_block_size<FunctorType,
                                               typename traits::launch_bounds>(
@@ -137,7 +137,7 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
         Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
     cudaFuncAttributes attr =
         CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
-            get_cuda_func_attributes();
+            get_cuda_func_attributes(space().cuda_device());
     const int block_size =
         Kokkos::Impl::cuda_get_opt_block_size<FunctorType,
                                               typename traits::launch_bounds>(
@@ -262,7 +262,8 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
         m_tune_team(bool(team_size_request <= 0)),
         m_tune_vector(bool(vector_length_request <= 0)) {
     // Make sure league size is permissible
-    if (league_size_ >= int(Impl::cuda_internal_maximum_grid_count()[0]))
+    const int maxGridSizeX = m_space.cuda_device_prop().maxGridSize[0];
+    if (league_size_ >= maxGridSizeX)
       Impl::throw_runtime_exception(
           "Requested too large league_size for TeamPolicy on Cuda execution "
           "space.");
@@ -369,7 +370,7 @@ class TeamPolicyInternal<Kokkos::Cuda, Properties...>
 
     cudaFuncAttributes attr =
         CudaParallelLaunch<closure_type, typename traits::launch_bounds>::
-            get_cuda_func_attributes();
+            get_cuda_func_attributes(space().cuda_device());
     const int block_size = std::forward<BlockSizeCallable>(block_size_callable)(
         space().impl_internal_space_instance(), attr, f,
         (size_t)impl_vector_length(),
@@ -538,25 +539,18 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
         m_vector_size(arg_policy.impl_vector_length()) {
     auto internal_space_instance =
         m_policy.space().impl_internal_space_instance();
-    cudaFuncAttributes attr =
-        CudaParallelLaunch<ParallelFor,
-                           LaunchBounds>::get_cuda_func_attributes();
-    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_size = m_team_size >= 0 ? m_team_size
+                                   : arg_policy.team_size_recommended(
+                                         arg_functor, ParallelForTag());
 
     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_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.
@@ -574,21 +568,16 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
                   static_cast<std::int64_t>(m_league_size))));
     }
 
+    const int maxShmemPerBlock =
+        m_policy.space().cuda_device_prop().sharedMemPerBlock;
     const int shmem_size_total = m_shmem_begin + m_shmem_size;
-    if (internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
-      printf("%i %i\n", internal_space_instance->m_maxShmemPerBlock,
-             shmem_size_total);
+    if (maxShmemPerBlock < shmem_size_total) {
+      printf("%i %i\n", maxShmemPerBlock, shmem_size_total);
       Kokkos::Impl::throw_runtime_exception(std::string(
           "Kokkos::Impl::ParallelFor< Cuda > insufficient shared memory"));
     }
 
-    if (int(m_team_size) >
-        int(Kokkos::Impl::cuda_get_max_block_size<FunctorType, LaunchBounds>(
-                internal_space_instance, attr, arg_functor,
-                arg_policy.impl_vector_length(),
-                arg_policy.team_scratch_size(0),
-                arg_policy.thread_scratch_size(0)) /
-            arg_policy.impl_vector_length())) {
+    if (m_team_size > arg_policy.team_size_max(arg_functor, ParallelForTag())) {
       Kokkos::Impl::throw_runtime_exception(std::string(
           "Kokkos::Impl::ParallelFor< Cuda > requested too large team size."));
     }
@@ -622,6 +611,22 @@ class ParallelReduce<CombinedFunctorReducerType,
 
  public:
   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)
+  // 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.
+  using word_size_type = std::conditional_t<
+      sizeof(value_type) < sizeof(Kokkos::Cuda::size_type),
+      std::conditional_t<sizeof(value_type) == 2, int16_t, int8_t>,
+      Kokkos::Cuda::size_type>;
   using size_type    = Cuda::size_type;
   using reducer_type = ReducerType;
 
@@ -645,9 +650,11 @@ class ParallelReduce<CombinedFunctorReducerType,
   const pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
   const bool m_result_ptr_host_accessible;
-  size_type* m_scratch_space;
-  size_type* m_scratch_flags;
-  size_type* m_unified_space;
+  word_size_type* m_scratch_space;
+  // m_scratch_flags must be of type Cuda::size_type due to use of atomics
+  // for tracking metadata in Kokkos_Cuda_ReduceScan.hpp
+  Cuda::size_type* m_scratch_flags;
+  word_size_type* m_unified_space;
   size_type m_team_begin;
   size_type m_shmem_begin;
   size_type m_shmem_size;
@@ -691,13 +698,14 @@ class ParallelReduce<CombinedFunctorReducerType,
   }
 
   __device__ inline void run(SHMEMReductionTag&, const int& threadid) const {
-    const integral_nonzero_constant<
-        size_type, ReducerType::static_value_size() / 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(size_type));
+                   sizeof(word_size_type));
 
     reference_type value = m_functor_reducer.get_reducer().init(
-        kokkos_impl_cuda_shared_memory<size_type>() +
+        kokkos_impl_cuda_shared_memory<word_size_type>() +
         threadIdx.y * word_count.value);
 
     // Iterate this block through the league
@@ -720,18 +728,19 @@ class ParallelReduce<CombinedFunctorReducerType,
     if (!zero_length)
       do_final_reduction = cuda_single_inter_block_reduce_scan<false>(
           m_functor_reducer.get_reducer(), blockIdx.x, gridDim.x,
-          kokkos_impl_cuda_shared_memory<size_type>(), m_scratch_space,
+          kokkos_impl_cuda_shared_memory<word_size_type>(), m_scratch_space,
           m_scratch_flags);
 
     if (do_final_reduction) {
       // 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;
+      word_size_type* const shared =
+          kokkos_impl_cuda_shared_memory<word_size_type>() +
+          (blockDim.y - 1) * word_count.value;
       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) {
@@ -741,6 +750,11 @@ class ParallelReduce<CombinedFunctorReducerType,
 
       if (CudaTraits::WarpSize < word_count.value) {
         __syncthreads();
+      } else {
+        // In the above call to final(), shared might have been updated by a
+        // single thread within a warp without synchronization. Synchronize
+        // threads within warp to avoid potential race condition.
+        __syncwarp(0xffffffff);
       }
 
       for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
@@ -781,7 +795,8 @@ class ParallelReduce<CombinedFunctorReducerType,
       *result = value;
     } else if (Impl::cuda_inter_block_reduction(
                    value, init, m_functor_reducer.get_reducer(),
-                   m_scratch_space, result, m_scratch_flags, blockDim.y)) {
+                   reinterpret_cast<pointer_type>(m_scratch_space), result,
+                   m_scratch_flags, blockDim.y)) {
       const unsigned id = threadIdx.y * blockDim.x + threadIdx.x;
       if (id == 0) {
         m_functor_reducer.get_reducer().final(&value);
@@ -802,13 +817,15 @@ class ParallelReduce<CombinedFunctorReducerType,
           1u, UseShflReduction ? std::min(m_league_size, size_type(1024 * 32))
                                : std::min(int(m_league_size), m_team_size));
 
-      m_scratch_space = cuda_internal_scratch_space(
-          m_policy.space(),
-          m_functor_reducer.get_reducer().value_size() * 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_count));
       m_scratch_flags =
           cuda_internal_scratch_flags(m_policy.space(), sizeof(size_type));
-      m_unified_space = cuda_internal_scratch_unified(
-          m_policy.space(), m_functor_reducer.get_reducer().value_size());
+      m_unified_space =
+          reinterpret_cast<word_size_type*>(cuda_internal_scratch_unified(
+              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);
@@ -841,7 +858,8 @@ class ParallelReduce<CombinedFunctorReducerType,
             }
           } else {
             const int size = m_functor_reducer.get_reducer().value_size();
-            DeepCopy<HostSpace, CudaSpace>(m_result_ptr, m_scratch_space, size);
+            DeepCopy<HostSpace, CudaSpace, Cuda>(m_policy.space(), m_result_ptr,
+                                                 m_scratch_space, size);
           }
         }
       }
@@ -877,18 +895,11 @@ class ParallelReduce<CombinedFunctorReducerType,
         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();
-    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_reducer.get_functor(), m_vector_size,
-                  m_policy.team_scratch_size(0),
-                  m_policy.thread_scratch_size(0)) /
-                  m_vector_size;
+    m_team_size = m_team_size >= 0 ? m_team_size
+                                   : arg_policy.team_size_recommended(
+                                         arg_functor_reducer.get_functor(),
+                                         arg_functor_reducer.get_reducer(),
+                                         ParallelReduceTag());
 
     m_team_begin =
         UseShflReduction
@@ -934,6 +945,8 @@ class ParallelReduce<CombinedFunctorReducerType,
     // Functor's reduce memory, team scan memory, and team shared memory depend
     // upon team size.
 
+    const int maxShmemPerBlock =
+        m_policy.space().cuda_device_prop().sharedMemPerBlock;
     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) &&
@@ -942,7 +955,7 @@ class ParallelReduce<CombinedFunctorReducerType,
           std::string("Kokkos::Impl::ParallelReduce< Cuda > bad team size"));
     }
 
-    if (internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
+    if (maxShmemPerBlock < shmem_size_total) {
       Kokkos::Impl::throw_runtime_exception(
           std::string("Kokkos::Impl::ParallelReduce< Cuda > requested too much "
                       "L0 scratch memory"));
diff --git a/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp b/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
index 2cdc291358..3037c4ab54 100644
--- a/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_ReduceScan.hpp
@@ -103,7 +103,7 @@ template <class FunctorType>
 __device__ bool cuda_inter_block_reduction(
     typename FunctorType::reference_type value,
     typename FunctorType::reference_type neutral, const FunctorType& reducer,
-    Cuda::size_type* const m_scratch_space,
+    typename FunctorType::pointer_type const m_scratch_space,
     typename FunctorType::pointer_type const /*result*/,
     Cuda::size_type* const m_scratch_flags,
     const int max_active_thread = blockDim.y) {
@@ -117,7 +117,7 @@ __device__ bool cuda_inter_block_reduction(
 
   // One thread in the block writes block result to global scratch_memory
   if (id == 0) {
-    pointer_type global = ((pointer_type)m_scratch_space) + blockIdx.x;
+    pointer_type global = m_scratch_space + blockIdx.x;
     *global             = value;
   }
 
@@ -140,7 +140,7 @@ __device__ bool cuda_inter_block_reduction(
       last_block = true;
       value      = neutral;
 
-      pointer_type const volatile global = (pointer_type)m_scratch_space;
+      pointer_type const volatile global = m_scratch_space;
 
       // Reduce all global values with splitting work over threads in one warp
       const int step_size =
@@ -315,7 +315,7 @@ struct CudaReductionsFunctor<FunctorType, false, false> {
     __syncwarp(mask);
 
     for (int delta = skip_vector ? blockDim.x : 1; delta < width; delta *= 2) {
-      if (lane_id + delta < 32) {
+      if ((lane_id + delta < 32) && (lane_id % (delta * 2) == 0)) {
         functor.join(value, value + delta);
       }
       __syncwarp(mask);
@@ -702,8 +702,7 @@ inline void check_reduced_view_shmem_size(const Policy& policy,
   unsigned reqShmemSize =
       cuda_single_inter_block_reduce_scan_shmem<false, WorkTag, ValueType>(
           functor, minBlockSize);
-  size_t maxShmemPerBlock =
-      policy.space().impl_internal_space_instance()->m_maxShmemPerBlock;
+  size_t maxShmemPerBlock = policy.space().cuda_device_prop().sharedMemPerBlock;
 
   if (reqShmemSize > maxShmemPerBlock) {
     Kokkos::Impl::throw_runtime_exception(
diff --git a/core/src/Cuda/Kokkos_Cuda_Task.hpp b/core/src/Cuda/Kokkos_Cuda_Task.hpp
index d579214cd4..86d6d91bbe 100644
--- a/core/src/Cuda/Kokkos_Cuda_Task.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Task.hpp
@@ -84,8 +84,8 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Cuda, QueueType>> {
   KOKKOS_INLINE_FUNCTION
   static void iff_single_thread_recursive_execute(scheduler_type const&) {}
 
-  static int get_max_team_count(execution_space const&) {
-    return Kokkos::Impl::cuda_internal_multiprocessor_count() * warps_per_block;
+  static int get_max_team_count(execution_space const& space) {
+    return space.cuda_device_prop().multiProcessorCount * warps_per_block;
   }
 
   __device__ static void driver(scheduler_type scheduler,
@@ -222,9 +222,14 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Cuda, QueueType>> {
     }
   }
 
+  // FIXME_CUDA_MULTIPLE_DEVICES
   static void execute(scheduler_type const& scheduler) {
     const int shared_per_warp = 2048;
-    const dim3 grid(Kokkos::Impl::cuda_internal_multiprocessor_count(), 1, 1);
+    const Kokkos::Cuda& exec  = scheduler.get_execution_space();
+    const auto& impl_instance = exec.impl_internal_space_instance();
+    const int multi_processor_count =
+        exec.cuda_device_prop().multiProcessorCount;
+    const dim3 grid(multi_processor_count, 1, 1);
     const dim3 block(1, Kokkos::Impl::CudaTraits::WarpSize, warps_per_block);
     const int shared_total    = shared_per_warp * warps_per_block;
     const cudaStream_t stream = nullptr;
@@ -244,16 +249,16 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Cuda, QueueType>> {
     // Query the stack size, in bytes:
 
     size_t previous_stack_size = 0;
-    KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaDeviceGetLimit(&previous_stack_size, cudaLimitStackSize));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(impl_instance->cuda_device_get_limit_wrapper(
+        &previous_stack_size, cudaLimitStackSize));
 
     // If not large enough then set the stack size, in bytes:
 
     const size_t larger_stack_size = 1 << 11;
 
     if (previous_stack_size < larger_stack_size) {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(
-          cudaDeviceSetLimit(cudaLimitStackSize, larger_stack_size));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(impl_instance->cuda_device_set_limit_wrapper(
+          cudaLimitStackSize, larger_stack_size));
     }
 
     cuda_task_queue_execute<<<grid, block, shared_total, stream>>>(
@@ -266,8 +271,8 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Cuda, QueueType>> {
         "Cuda>::execute: Post Task Execution");
 
     if (previous_stack_size < larger_stack_size) {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(
-          cudaDeviceSetLimit(cudaLimitStackSize, previous_stack_size));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(impl_instance->cuda_device_set_limit_wrapper(
+          cudaLimitStackSize, previous_stack_size));
     }
   }
 
@@ -296,6 +301,7 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::Cuda, QueueType>> {
         <<<1, 1>>>(ptr_ptr, dtor_ptr);
 
     KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetLastError());
+
     Impl::cuda_device_synchronize(
         "Kokkos::Impl::TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::"
         "Cuda>::execute: Post Get Function Pointer for Tasks");
@@ -456,10 +462,17 @@ class TaskQueueSpecializationConstrained<
     } while (1);
   }
 
+  // FIXME_CUDA_MULTIPLE_DEVICES
   static void execute(scheduler_type const& scheduler) {
     const int shared_per_warp = 2048;
     const int warps_per_block = 4;
-    const dim3 grid(Kokkos::Impl::cuda_internal_multiprocessor_count(), 1, 1);
+    const Kokkos::Cuda exec   = Cuda();  // FIXME_CUDA_MULTIPLE_DEVICES
+    const auto& impl_instance = exec.impl_internal_space_instance();
+    const int multi_processor_count =
+        // FIXME not sure why this didn't work
+        // exec.cuda_device_prop().multiProcessorCount;
+        impl_instance->m_deviceProp.multiProcessorCount;
+    const dim3 grid(multi_processor_count, 1, 1);
     // const dim3 grid( 1 , 1 , 1 );
     const dim3 block(1, Kokkos::Impl::CudaTraits::WarpSize, warps_per_block);
     const int shared_total    = shared_per_warp * warps_per_block;
@@ -475,16 +488,16 @@ class TaskQueueSpecializationConstrained<
     // Query the stack size, in bytes:
 
     size_t previous_stack_size = 0;
-    KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaDeviceGetLimit(&previous_stack_size, cudaLimitStackSize));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(impl_instance->cuda_device_get_limit_wrapper(
+        &previous_stack_size, cudaLimitStackSize));
 
     // If not large enough then set the stack size, in bytes:
 
     const size_t larger_stack_size = 2048;
 
     if (previous_stack_size < larger_stack_size) {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(
-          cudaDeviceSetLimit(cudaLimitStackSize, larger_stack_size));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(impl_instance->cuda_device_set_limit_wrapper(
+          cudaLimitStackSize, larger_stack_size));
     }
 
     cuda_task_queue_execute<<<grid, block, shared_total, stream>>>(
@@ -497,8 +510,8 @@ class TaskQueueSpecializationConstrained<
         "Kokkos::Cuda>::execute: Post Execute Task");
 
     if (previous_stack_size < larger_stack_size) {
-      KOKKOS_IMPL_CUDA_SAFE_CALL(
-          cudaDeviceSetLimit(cudaLimitStackSize, previous_stack_size));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(impl_instance->cuda_device_set_limit_wrapper(
+          cudaLimitStackSize, previous_stack_size));
     }
   }
 
diff --git a/core/src/Cuda/Kokkos_Cuda_Team.hpp b/core/src/Cuda/Kokkos_Cuda_Team.hpp
index b4315a72e9..c2b5f1fa78 100644
--- a/core/src/Cuda/Kokkos_Cuda_Team.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_Team.hpp
@@ -689,15 +689,17 @@ parallel_reduce(Impl::ThreadVectorRangeBoundariesStruct<
  *  final == true.
  */
 // This is the same code as in HIP and largely the same as in OpenMPTarget
-template <typename iType, typename FunctorType>
+template <typename iType, typename FunctorType, typename ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
         loop_bounds,
-    const FunctorType& lambda) {
-  // Extract value_type from lambda
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+    const FunctorType& lambda, ValueType& return_val) {
+  // Extract ValueType from the Functor
+  using functor_value_type = typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
       void>::value_type;
+  static_assert(std::is_same<functor_value_type, ValueType>::value,
+                "Non-matching value types of functor and return type");
 
   const auto start     = loop_bounds.start;
   const auto end       = loop_bounds.end;
@@ -705,12 +707,12 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   const auto team_size = member.team_size();
   const auto team_rank = member.team_rank();
   const auto nchunk    = (end - start + team_size - 1) / team_size;
-  value_type accum     = 0;
+  ValueType 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;
+    ValueType local_accum = 0;
     // user updates value with prefix value
     if (ii < loop_bounds.end) lambda(ii, local_accum, false);
     // perform team scan
@@ -724,6 +726,29 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     // broadcast last value to rest of the team
     member.team_broadcast(accum, team_size - 1);
   }
+  return_val = accum;
+}
+
+/** \brief  Inter-thread parallel exclusive prefix sum.
+ *
+ *  Executes closure(iType i, ValueType & val, bool final) for each i=[0..N)
+ *
+ *  The range [0..N) is mapped to each rank in the team (whose global rank is
+ *  less than N) and a scan operation is performed. The last call to closure has
+ *  final == true.
+ */
+template <typename iType, typename FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
+        loop_bounds,
+    const FunctorType& lambda) {
+  // Extract value_type from functor
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+
+  value_type dummy;
+  parallel_scan(loop_bounds, lambda, dummy);
 }
 
 //----------------------------------------------------------------------------
@@ -782,7 +807,7 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
         // exclusive scan -- the final accumulation
         // of i's val will be included in the second
         // closure call later.
-        if (i < loop_boundaries.end && threadIdx.x > 0) {
+        if (i - 1 < loop_boundaries.end && threadIdx.x > 0) {
           closure(i - 1, val, false);
         }
 
@@ -814,6 +839,8 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
         Impl::in_place_shfl(accum, val, mask, blockDim.x, active_mask);
       }
 
+      reducer.reference() = accum;
+
       ))
 }
 
@@ -839,6 +866,32 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   parallel_scan(loop_boundaries, closure, Kokkos::Sum<value_type>(dummy));
 }
 
+/** \brief  Intra-thread vector parallel exclusive prefix sum.
+ *
+ *  Executes closure(iType i, ValueType & val, bool final) for each i=[0..N)
+ *
+ *  The range [0..N) is mapped to all vector lanes in the
+ *  thread and a scan operation is performed.
+ *  The last call to closure has final == true.
+ */
+template <typename iType, class Closure, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::CudaTeamMember>&
+        loop_boundaries,
+    const Closure& closure, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using closure_value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      ValueType>::value_type;
+  static_assert(std::is_same<closure_value_type, ValueType>::value,
+                "Non-matching value types of closure and return type");
+
+  ValueType accum;
+  parallel_scan(loop_boundaries, closure, Kokkos::Sum<ValueType>(accum));
+
+  return_val = accum;
+}
+
 }  // namespace Kokkos
 
 namespace Kokkos {
diff --git a/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp b/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
index abb747e39a..94a428493f 100644
--- a/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_UniqueToken.hpp
@@ -22,7 +22,6 @@
 
 #include <Cuda/Kokkos_CudaSpace.hpp>
 #include <Kokkos_UniqueToken.hpp>
-#include <impl/Kokkos_SharedAlloc.hpp>
 
 namespace Kokkos {
 
diff --git a/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp b/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
index a945a716bc..c7ea6988a5 100644
--- a/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_WorkGraphPolicy.hpp
@@ -77,7 +77,9 @@ class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
 
   inline void execute() {
     const int warps_per_block = 4;
-    const dim3 grid(Kokkos::Impl::cuda_internal_multiprocessor_count(), 1, 1);
+    const int multi_processor_count =
+        m_policy.space().cuda_device_prop().multiProcessorCount;
+    const dim3 grid(multi_processor_count, 1, 1);
     const dim3 block(1, Kokkos::Impl::CudaTraits::WarpSize, warps_per_block);
     const int shared = 0;
 
diff --git a/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp b/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp
index 001cf0cce0..517c592af7 100644
--- a/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_ZeroMemset.hpp
@@ -25,18 +25,13 @@ 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&) {
+  ZeroMemset(const Kokkos::Cuda& exec_space_instance,
+             const View<T, P...>& dst) {
     KOKKOS_IMPL_CUDA_SAFE_CALL(
-        cudaMemset(dst.data(), 0,
-                   dst.size() * sizeof(typename View<T, P...>::value_type)));
+        (exec_space_instance.impl_internal_space_instance()
+             ->cuda_memset_async_wrapper(
+                 dst.data(), 0,
+                 dst.size() * sizeof(typename View<T, P...>::value_type))));
   }
 };
 
diff --git a/core/src/Cuda/Kokkos_Cuda_abort.hpp b/core/src/Cuda/Kokkos_Cuda_abort.hpp
index c8d6641d1e..18aca15065 100644
--- a/core/src/Cuda/Kokkos_Cuda_abort.hpp
+++ b/core/src/Cuda/Kokkos_Cuda_abort.hpp
@@ -28,35 +28,20 @@ extern "C" {
 /*  Cuda runtime function, declared in <crt/device_runtime.h>
  *  Requires capability 2.x or better.
  */
-extern __device__ void __assertfail(const void *message, const void *file,
-                                    unsigned int line, const void *function,
-                                    size_t charsize);
+[[noreturn]] __device__ void __assertfail(const void *message, const void *file,
+                                          unsigned int line,
+                                          const void *function,
+                                          size_t charsize);
 }
 
 namespace Kokkos {
 namespace Impl {
 
-// required to workaround failures in random number generator unit tests with
-// pre-volta architectures
-#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
-__device__ inline void cuda_abort(const char *const message) {
-#else
-[[noreturn]] __device__ inline void cuda_abort(const char *const message) {
-#endif
+[[noreturn]] __device__ static void cuda_abort(const char *const message) {
   const char empty[] = "";
 
   __assertfail((const void *)message, (const void *)empty, (unsigned int)0,
                (const void *)empty, sizeof(char));
-
-  // This loop is never executed. It's intended to suppress warnings that the
-  // function returns, even though it does not. This is necessary because
-  // __assertfail is not marked as [[noreturn]], even though it does not return.
-  //  Disable with KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK to workaround failures
-  //  in random number generator unit tests with pre-volta architectures
-#if !defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
-  while (true)
-    ;
-#endif
 }
 
 }  // namespace Impl
diff --git a/core/src/HIP/Kokkos_HIP.cpp b/core/src/HIP/Kokkos_HIP.cpp
index 94cd97b2b9..aced2083ff 100644
--- a/core/src/HIP/Kokkos_HIP.cpp
+++ b/core/src/HIP/Kokkos_HIP.cpp
@@ -18,6 +18,7 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE
 #endif
 
+#include <Kokkos_Core.hpp>
 #include <HIP/Kokkos_HIP.hpp>
 #include <HIP/Kokkos_HIP_Instance.hpp>
 
@@ -41,7 +42,9 @@ int HIP::impl_is_initialized() {
 }
 
 void HIP::impl_initialize(InitializationSettings const& settings) {
-  const int hip_device_id = Impl::get_gpu(settings);
+  const std::vector<int>& visible_devices = Impl::get_visible_devices();
+  const int hip_device_id =
+      Impl::get_gpu(settings).value_or(visible_devices[0]);
 
   Impl::HIPInternal::m_hipDev = hip_device_id;
   KOKKOS_IMPL_HIP_SAFE_CALL(
@@ -60,8 +63,6 @@ void HIP::impl_initialize(InitializationSettings const& settings) {
   if (Impl::HIPTraits::WarpSize < Impl::HIPInternal::m_maxWarpCount) {
     Impl::HIPInternal::m_maxWarpCount = Impl::HIPTraits::WarpSize;
   }
-  int constexpr WordSize              = sizeof(size_type);
-  Impl::HIPInternal::m_maxSharedWords = hipProp.sharedMemPerBlock / WordSize;
 
   //----------------------------------
   // Maximum number of blocks
@@ -91,10 +92,23 @@ void HIP::impl_initialize(InitializationSettings const& settings) {
 
   hipStream_t singleton_stream;
   KOKKOS_IMPL_HIP_SAFE_CALL(hipStreamCreate(&singleton_stream));
-  Impl::HIPInternal::singleton().initialize(singleton_stream, /*manage*/ true);
+  Impl::HIPInternal::singleton().initialize(singleton_stream);
 }
 
-void HIP::impl_finalize() { Impl::HIPInternal::singleton().finalize(); }
+void HIP::impl_finalize() {
+  (void)Impl::hip_global_unique_token_locks(true);
+
+  desul::Impl::finalize_lock_arrays();  // FIXME
+
+  KOKKOS_IMPL_HIP_SAFE_CALL(
+      hipEventDestroy(Impl::HIPInternal::constantMemReusable));
+  KOKKOS_IMPL_HIP_SAFE_CALL(
+      hipHostFree(Impl::HIPInternal::constantMemHostStaging));
+
+  Impl::HIPInternal::singleton().finalize();
+  KOKKOS_IMPL_HIP_SAFE_CALL(
+      hipStreamDestroy(Impl::HIPInternal::singleton().m_stream));
+}
 
 HIP::HIP()
     : m_space_instance(&Impl::HIPInternal::singleton(),
@@ -103,16 +117,24 @@ HIP::HIP()
       "HIP instance constructor");
 }
 
-HIP::HIP(hipStream_t const stream, bool manage_stream)
-    : m_space_instance(new Impl::HIPInternal, [](Impl::HIPInternal* ptr) {
-        ptr->finalize();
-        delete ptr;
-      }) {
+HIP::HIP(hipStream_t const stream, Impl::ManageStream manage_stream)
+    : m_space_instance(
+          new Impl::HIPInternal, [manage_stream](Impl::HIPInternal* ptr) {
+            ptr->finalize();
+            if (static_cast<bool>(manage_stream)) {
+              KOKKOS_IMPL_HIP_SAFE_CALL(hipStreamDestroy(ptr->m_stream));
+            }
+            delete ptr;
+          }) {
   Impl::HIPInternal::singleton().verify_is_initialized(
       "HIP instance constructor");
-  m_space_instance->initialize(stream, manage_stream);
+  m_space_instance->initialize(stream);
 }
 
+KOKKOS_DEPRECATED HIP::HIP(hipStream_t const stream, bool manage_stream)
+    : HIP(stream,
+          manage_stream ? Impl::ManageStream::yes : Impl::ManageStream::no) {}
+
 void HIP::print_configuration(std::ostream& os, bool /*verbose*/) const {
   os << "Device Execution Space:\n";
   os << "  KOKKOS_ENABLE_HIP: yes\n";
@@ -124,6 +146,10 @@ void HIP::print_configuration(std::ostream& os, bool /*verbose*/) const {
 #else
   os << "no\n";
 #endif
+#ifdef KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY
+  os << "  KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY: ";
+  os << "yes\n";
+#endif
 
   os << "\nRuntime Configuration:\n";
 
diff --git a/core/src/HIP/Kokkos_HIP.hpp b/core/src/HIP/Kokkos_HIP.hpp
index d7cc25ffe1..439075fc6c 100644
--- a/core/src/HIP/Kokkos_HIP.hpp
+++ b/core/src/HIP/Kokkos_HIP.hpp
@@ -27,7 +27,8 @@
 namespace Kokkos {
 namespace Impl {
 class HIPInternal;
-}
+enum class ManageStream : bool { no, yes };
+}  // namespace Impl
 /// \class HIP
 /// \brief Kokkos device for multicore processors in the host memory space.
 class HIP {
@@ -47,20 +48,35 @@ class HIP {
   using scratch_memory_space = ScratchMemorySpace<HIP>;
 
   HIP();
-  HIP(hipStream_t stream, bool manage_stream = false);
+
+  explicit HIP(hipStream_t stream) : HIP(stream, Impl::ManageStream::no) {}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT(
+      "HIP execution space should be constructed explicitly.")
+  HIP(hipStream_t stream)
+      : HIP(stream) {}
+#endif
+
+  HIP(hipStream_t stream, Impl::ManageStream manage_stream);
+
+  KOKKOS_DEPRECATED HIP(hipStream_t stream, bool manage_stream);
 
   //@}
   //------------------------------------
   //! \name Functions that all Kokkos devices must implement.
   //@{
 
-  KOKKOS_INLINE_FUNCTION static int in_parallel() {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED KOKKOS_INLINE_FUNCTION static int in_parallel() {
 #if defined(__HIP_DEVICE_COMPILE__)
     return true;
 #else
     return false;
 #endif
   }
+#endif
 
   /** \brief Wait until all dispatched functors complete.
    *
@@ -91,9 +107,13 @@ class HIP {
 
   static int impl_is_initialized();
 
-  //  static size_type device_arch();
-
-  static size_type detect_device_count();
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED static size_type detect_device_count() {
+    int count;
+    KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDeviceCount(&count));
+    return count;
+  }
+#endif
 
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   static int concurrency();
diff --git a/core/src/HIP/Kokkos_HIP_Error.hpp b/core/src/HIP/Kokkos_HIP_Error.hpp
index 43d63c090b..fa45dcfec3 100644
--- a/core/src/HIP/Kokkos_HIP_Error.hpp
+++ b/core/src/HIP/Kokkos_HIP_Error.hpp
@@ -22,8 +22,6 @@
 
 #include <hip/hip_runtime.h>
 
-#include <ostream>
-
 namespace Kokkos {
 namespace Impl {
 
@@ -44,39 +42,4 @@ inline void hip_internal_safe_call(hipError_t e, const char* name,
 #define KOKKOS_IMPL_HIP_SAFE_CALL(call) \
   Kokkos::Impl::hip_internal_safe_call(call, #call, __FILE__, __LINE__)
 
-namespace Kokkos {
-namespace Experimental {
-
-class HIPRawMemoryAllocationFailure : public RawMemoryAllocationFailure {
- private:
-  hipError_t m_error_code = hipSuccess;
-
-  static FailureMode get_failure_mode(hipError_t error_code) {
-    switch (error_code) {
-      case hipErrorMemoryAllocation: return FailureMode::OutOfMemoryError;
-      case hipErrorInvalidValue: return FailureMode::InvalidAllocationSize;
-      default: return FailureMode::Unknown;
-    }
-  }
-
- public:
-  HIPRawMemoryAllocationFailure(size_t arg_attempted_size,
-                                hipError_t arg_error_code,
-                                AllocationMechanism arg_mechanism) noexcept
-      : RawMemoryAllocationFailure(
-            arg_attempted_size, /* HIPSpace doesn't handle alignment? */ 1,
-            get_failure_mode(arg_error_code), arg_mechanism),
-        m_error_code(arg_error_code) {}
-
-  void append_additional_error_information(std::ostream& o) const override {
-    if (m_error_code != hipSuccess) {
-      o << "  The HIP allocation returned the error code \""
-        << hipGetErrorName(m_error_code) << "\".";
-    }
-  }
-};
-
-}  // namespace Experimental
-}  // namespace Kokkos
-
 #endif
diff --git a/core/src/HIP/Kokkos_HIP_GraphNodeKernel.hpp b/core/src/HIP/Kokkos_HIP_GraphNodeKernel.hpp
new file mode 100644
index 0000000000..5f0df72df1
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_GraphNodeKernel.hpp
@@ -0,0 +1,152 @@
+//@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_GRAPHNODEKERNEL_HPP
+#define KOKKOS_HIP_GRAPHNODEKERNEL_HPP
+
+#include <Kokkos_Graph_fwd.hpp>
+
+#include <impl/Kokkos_GraphImpl.hpp>
+
+#include <Kokkos_Parallel.hpp>
+#include <Kokkos_Parallel_Reduce.hpp>
+#include <Kokkos_PointerOwnership.hpp>
+
+#include <HIP/Kokkos_HIP_GraphNode_Impl.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <typename PolicyType, typename Functor, typename PatternTag,
+          typename... Args>
+class GraphNodeKernelImpl<Kokkos::HIP, PolicyType, Functor, PatternTag, Args...>
+    : public PatternImplSpecializationFromTag<PatternTag, Functor, PolicyType,
+                                              Args..., Kokkos::HIP>::type {
+ public:
+  using Policy       = PolicyType;
+  using graph_kernel = GraphNodeKernelImpl;
+  using base_t =
+      typename PatternImplSpecializationFromTag<PatternTag, Functor, Policy,
+                                                Args..., Kokkos::HIP>::type;
+
+  // TODO use the name and executionspace
+  template <typename PolicyDeduced, typename... ArgsDeduced>
+  GraphNodeKernelImpl(std::string, Kokkos::HIP const&, Functor arg_functor,
+                      PolicyDeduced&& arg_policy, ArgsDeduced&&... args)
+      : base_t(std::move(arg_functor), (PolicyDeduced &&) arg_policy,
+               (ArgsDeduced &&) args...) {}
+
+  template <typename PolicyDeduced>
+  GraphNodeKernelImpl(Kokkos::HIP const& exec_space, Functor arg_functor,
+                      PolicyDeduced&& arg_policy)
+      : GraphNodeKernelImpl("", exec_space, std::move(arg_functor),
+                            (PolicyDeduced &&) arg_policy) {}
+
+  ~GraphNodeKernelImpl() {
+    if (m_driver_storage) {
+      Kokkos::HIPSpace().deallocate(m_driver_storage, sizeof(base_t));
+    }
+  }
+
+  void set_hip_graph_ptr(hipGraph_t* arg_graph_ptr) {
+    m_graph_ptr = arg_graph_ptr;
+  }
+
+  void set_hip_graph_node_ptr(hipGraphNode_t* arg_node_ptr) {
+    m_graph_node_ptr = arg_node_ptr;
+  }
+
+  hipGraphNode_t* get_hip_graph_node_ptr() const { return m_graph_node_ptr; }
+
+  hipGraph_t const* get_hip_graph_ptr() const { return m_graph_ptr; }
+
+  Kokkos::ObservingRawPtr<base_t> allocate_driver_memory_buffer() const {
+    KOKKOS_EXPECTS(m_driver_storage == nullptr);
+    m_driver_storage = static_cast<base_t*>(Kokkos::HIPSpace().allocate(
+        "GraphNodeKernel global memory functor storage", sizeof(base_t)));
+    KOKKOS_ENSURES(m_driver_storage != nullptr);
+    return m_driver_storage;
+  }
+
+ private:
+  Kokkos::ObservingRawPtr<const hipGraph_t> m_graph_ptr    = nullptr;
+  Kokkos::ObservingRawPtr<hipGraphNode_t> m_graph_node_ptr = nullptr;
+  Kokkos::OwningRawPtr<base_t> m_driver_storage            = nullptr;
+};
+
+struct HIPGraphNodeAggregateKernel {
+  using graph_kernel = HIPGraphNodeAggregateKernel;
+
+  // Aggregates don't need a policy, but for the purposes of checking the static
+  // assertions about graph kernels,
+  struct Policy {
+    using is_graph_kernel = std::true_type;
+  };
+};
+
+template <typename KernelType,
+          typename Tag =
+              typename PatternTagFromImplSpecialization<KernelType>::type>
+struct get_graph_node_kernel_type
+    : type_identity<
+          GraphNodeKernelImpl<Kokkos::HIP, typename KernelType::Policy,
+                              typename KernelType::functor_type, Tag>> {};
+
+template <typename KernelType>
+struct get_graph_node_kernel_type<KernelType, Kokkos::ParallelReduceTag>
+    : type_identity<GraphNodeKernelImpl<
+          Kokkos::HIP, typename KernelType::Policy,
+          CombinedFunctorReducer<typename KernelType::functor_type,
+                                 typename KernelType::reducer_type>,
+          Kokkos::ParallelReduceTag>> {};
+
+template <typename KernelType>
+auto* allocate_driver_storage_for_kernel(KernelType const& kernel) {
+  using graph_node_kernel_t =
+      typename get_graph_node_kernel_type<KernelType>::type;
+  auto const& kernel_as_graph_kernel =
+      static_cast<graph_node_kernel_t const&>(kernel);
+
+  return kernel_as_graph_kernel.allocate_driver_memory_buffer();
+}
+
+template <typename KernelType>
+auto const& get_hip_graph_from_kernel(KernelType const& kernel) {
+  using graph_node_kernel_t =
+      typename get_graph_node_kernel_type<KernelType>::type;
+  auto const& kernel_as_graph_kernel =
+      static_cast<graph_node_kernel_t const&>(kernel);
+  hipGraph_t const* graph_ptr = kernel_as_graph_kernel.get_hip_graph_ptr();
+  KOKKOS_EXPECTS(graph_ptr != nullptr);
+
+  return *graph_ptr;
+}
+
+template <typename KernelType>
+auto& get_hip_graph_node_from_kernel(KernelType const& kernel) {
+  using graph_node_kernel_t =
+      typename get_graph_node_kernel_type<KernelType>::type;
+  auto const& kernel_as_graph_kernel =
+      static_cast<graph_node_kernel_t const&>(kernel);
+  auto* graph_node_ptr = kernel_as_graph_kernel.get_hip_graph_node_ptr();
+  KOKKOS_EXPECTS(graph_node_ptr != nullptr);
+
+  return *graph_node_ptr;
+}
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_GraphNode_Impl.hpp b/core/src/HIP/Kokkos_HIP_GraphNode_Impl.hpp
new file mode 100644
index 0000000000..819ee12f39
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_GraphNode_Impl.hpp
@@ -0,0 +1,54 @@
+//@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_GRAPHNODE_IMPL_HPP
+#define KOKKOS_HIP_GRAPHNODE_IMPL_HPP
+
+#include <Kokkos_Graph_fwd.hpp>
+
+#include <impl/Kokkos_GraphImpl.hpp>
+
+#include <HIP/Kokkos_HIP.hpp>
+
+namespace Kokkos {
+namespace Impl {
+template <>
+struct GraphNodeBackendSpecificDetails<Kokkos::HIP> {
+  hipGraphNode_t node = nullptr;
+
+  explicit GraphNodeBackendSpecificDetails() = default;
+
+  explicit GraphNodeBackendSpecificDetails(
+      _graph_node_is_root_ctor_tag) noexcept {}
+};
+
+template <typename Kernel, typename PredecessorRef>
+struct GraphNodeBackendDetailsBeforeTypeErasure<Kokkos::HIP, Kernel,
+                                                PredecessorRef> {
+ protected:
+  GraphNodeBackendDetailsBeforeTypeErasure(
+      Kokkos::HIP const &, Kernel &, PredecessorRef const &,
+      GraphNodeBackendSpecificDetails<Kokkos::HIP> &) noexcept {}
+
+  GraphNodeBackendDetailsBeforeTypeErasure(
+      Kokkos::HIP const &, _graph_node_is_root_ctor_tag,
+      GraphNodeBackendSpecificDetails<Kokkos::HIP> &) noexcept {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_Graph_Impl.hpp b/core/src/HIP/Kokkos_HIP_Graph_Impl.hpp
new file mode 100644
index 0000000000..a0989fe671
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_Graph_Impl.hpp
@@ -0,0 +1,187 @@
+//@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_GRAPH_IMPL_HPP
+#define KOKKOS_HIP_GRAPH_IMPL_HPP
+
+#include <Kokkos_Macros.hpp>
+
+#include <Kokkos_Graph_fwd.hpp>
+
+#include <impl/Kokkos_GraphImpl.hpp>
+#include <impl/Kokkos_GraphNodeImpl.hpp>
+
+#include <HIP/Kokkos_HIP_GraphNodeKernel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+template <>
+class GraphImpl<Kokkos::HIP> {
+ public:
+  using node_details_t = GraphNodeBackendSpecificDetails<Kokkos::HIP>;
+  using root_node_impl_t =
+      GraphNodeImpl<Kokkos::HIP, Kokkos::Experimental::TypeErasedTag,
+                    Kokkos::Experimental::TypeErasedTag>;
+  using aggregate_kernel_impl_t = HIPGraphNodeAggregateKernel;
+  using aggregate_node_impl_t =
+      GraphNodeImpl<Kokkos::HIP, aggregate_kernel_impl_t,
+                    Kokkos::Experimental::TypeErasedTag>;
+
+  // Not movable or copyable; it spends its whole life as a shared_ptr in the
+  // Graph object.
+  GraphImpl()                 = delete;
+  GraphImpl(GraphImpl const&) = delete;
+  GraphImpl(GraphImpl&&)      = delete;
+  GraphImpl& operator=(GraphImpl const&) = delete;
+  GraphImpl& operator=(GraphImpl&&) = delete;
+
+  ~GraphImpl();
+
+  explicit GraphImpl(Kokkos::HIP instance);
+
+  void add_node(std::shared_ptr<aggregate_node_impl_t> const& arg_node_ptr);
+
+  template <class NodeImpl>
+  void add_node(std::shared_ptr<NodeImpl> const& arg_node_ptr);
+
+  template <class NodeImplPtr, class PredecessorRef>
+  void add_predecessor(NodeImplPtr arg_node_ptr, PredecessorRef arg_pred_ref);
+
+  void submit();
+
+  Kokkos::HIP const& get_execution_space() const noexcept;
+
+  auto create_root_node_ptr();
+
+  template <class... PredecessorRefs>
+  auto create_aggregate_ptr(PredecessorRefs&&...);
+
+ private:
+  void instantiate_graph() {
+    constexpr size_t error_log_size = 256;
+    hipGraphNode_t error_node       = nullptr;
+    char error_log[error_log_size];
+    KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphInstantiate(
+        &m_graph_exec, m_graph, &error_node, error_log, error_log_size));
+  }
+
+  Kokkos::HIP m_execution_space;
+  hipGraph_t m_graph          = nullptr;
+  hipGraphExec_t m_graph_exec = nullptr;
+};
+
+inline GraphImpl<Kokkos::HIP>::~GraphImpl() {
+  m_execution_space.fence("Kokkos::GraphImpl::~GraphImpl: Graph Destruction");
+  KOKKOS_EXPECTS(m_graph);
+  if (m_graph_exec) {
+    KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphExecDestroy(m_graph_exec));
+  }
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphDestroy(m_graph));
+}
+
+inline GraphImpl<Kokkos::HIP>::GraphImpl(Kokkos::HIP instance)
+    : m_execution_space(std::move(instance)) {
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphCreate(&m_graph, 0));
+}
+
+inline void GraphImpl<Kokkos::HIP>::add_node(
+    std::shared_ptr<aggregate_node_impl_t> const& arg_node_ptr) {
+  // All of the predecessors are just added as normal, so all we need to
+  // do here is add an empty node
+  KOKKOS_IMPL_HIP_SAFE_CALL(
+      hipGraphAddEmptyNode(&(arg_node_ptr->node_details_t::node), m_graph,
+                           /* dependencies = */ nullptr,
+                           /* numDependencies = */ 0));
+}
+
+// Requires NodeImplPtr is a shared_ptr to specialization of GraphNodeImpl
+// Also requires that the kernel has the graph node tag in its policy
+template <class NodeImpl>
+inline void GraphImpl<Kokkos::HIP>::add_node(
+    std::shared_ptr<NodeImpl> const& arg_node_ptr) {
+  static_assert(NodeImpl::kernel_type::Policy::is_graph_kernel::value);
+  KOKKOS_EXPECTS(arg_node_ptr);
+  // The Kernel launch from the execute() method has been shimmed to insert
+  // the node into the graph
+  auto& kernel = arg_node_ptr->get_kernel();
+  auto& node   = static_cast<node_details_t*>(arg_node_ptr.get())->node;
+  KOKKOS_EXPECTS(!node);
+  kernel.set_hip_graph_ptr(&m_graph);
+  kernel.set_hip_graph_node_ptr(&node);
+  kernel.execute();
+  KOKKOS_ENSURES(node);
+}
+
+// Requires PredecessorRef is a specialization of GraphNodeRef that has
+// already been added to this graph and NodeImpl is a specialization of
+// GraphNodeImpl that has already been added to this graph.
+template <class NodeImplPtr, class PredecessorRef>
+inline void GraphImpl<Kokkos::HIP>::add_predecessor(
+    NodeImplPtr arg_node_ptr, PredecessorRef arg_pred_ref) {
+  KOKKOS_EXPECTS(arg_node_ptr);
+  auto pred_ptr = GraphAccess::get_node_ptr(arg_pred_ref);
+  KOKKOS_EXPECTS(pred_ptr);
+
+  auto const& pred_node = pred_ptr->node_details_t::node;
+  KOKKOS_EXPECTS(pred_node);
+
+  auto const& node = arg_node_ptr->node_details_t::node;
+  KOKKOS_EXPECTS(node);
+
+  KOKKOS_IMPL_HIP_SAFE_CALL(
+      hipGraphAddDependencies(m_graph, &pred_node, &node, 1));
+}
+
+inline void GraphImpl<Kokkos::HIP>::submit() {
+  if (!m_graph_exec) {
+    instantiate_graph();
+  }
+  KOKKOS_IMPL_HIP_SAFE_CALL(
+      hipGraphLaunch(m_graph_exec, m_execution_space.hip_stream()));
+}
+
+inline Kokkos::HIP const& GraphImpl<Kokkos::HIP>::get_execution_space() const
+    noexcept {
+  return m_execution_space;
+}
+
+inline auto GraphImpl<Kokkos::HIP>::create_root_node_ptr() {
+  KOKKOS_EXPECTS(m_graph);
+  KOKKOS_EXPECTS(!m_graph_exec);
+  auto rv = std::make_shared<root_node_impl_t>(get_execution_space(),
+                                               _graph_node_is_root_ctor_tag{});
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphAddEmptyNode(&(rv->node_details_t::node),
+                                                 m_graph,
+                                                 /* dependencies = */ nullptr,
+                                                 /* numDependencies = */ 0));
+  KOKKOS_ENSURES(rv->node_details_t::node);
+  return rv;
+}
+
+template <class... PredecessorRefs>
+inline auto GraphImpl<Kokkos::HIP>::create_aggregate_ptr(PredecessorRefs&&...) {
+  // The attachment to predecessors, which is all we really need, happens
+  // in the generic layer, which calls through to add_predecessor for
+  // each predecessor ref, so all we need to do here is create the (trivial)
+  // aggregate node.
+  return std::make_shared<aggregate_node_impl_t>(m_execution_space,
+                                                 _graph_node_kernel_ctor_tag{},
+                                                 aggregate_kernel_impl_t{});
+}
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_Instance.cpp b/core/src/HIP/Kokkos_HIP_Instance.cpp
index 7840ad905b..e0b25c6939 100644
--- a/core/src/HIP/Kokkos_HIP_Instance.cpp
+++ b/core/src/HIP/Kokkos_HIP_Instance.cpp
@@ -26,6 +26,8 @@
 #include <HIP/Kokkos_HIP_Instance.hpp>
 #include <HIP/Kokkos_HIP.hpp>
 #include <HIP/Kokkos_HIP_Space.hpp>
+#include <impl/Kokkos_CheckedIntegerOps.hpp>
+#include <impl/Kokkos_DeviceManagement.hpp>
 #include <impl/Kokkos_Error.hpp>
 
 /*--------------------------------------------------------------------------*/
@@ -59,14 +61,24 @@ Kokkos::View<uint32_t *, HIPSpace> hip_global_unique_token_locks(
 }  // namespace Kokkos
 
 namespace Kokkos {
-
 namespace Impl {
 
+namespace {
+
+using ScratchGrain = Kokkos::HIP::size_type[Impl::HIPTraits::WarpSize];
+constexpr auto sizeScratchGrain = sizeof(ScratchGrain);
+
+std::size_t scratch_count(const std::size_t size) {
+  return (size + sizeScratchGrain - 1) / sizeScratchGrain;
+}
+
+}  // namespace
+
 //----------------------------------------------------------------------------
 
 int HIPInternal::concurrency() {
-  static int const concurrency = m_deviceProp.maxThreadsPerMultiProcessor *
-                                 m_deviceProp.multiProcessorCount;
+  static int const concurrency = m_maxThreadsPerSM * m_multiProcCount;
+
   return concurrency;
 }
 
@@ -78,18 +90,27 @@ void HIPInternal::print_configuration(std::ostream &s) const {
     << '\n';
 #endif
 
-  int hipDevCount;
-  KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDeviceCount(&hipDevCount));
+  s << "macro KOKKOS_ENABLE_ROCTHRUST : "
+#if defined(KOKKOS_ENABLE_ROCTHRUST)
+    << "defined\n";
+#else
+    << "undefined\n";
+#endif
 
-  for (int i = 0; i < hipDevCount; ++i) {
+  for (int i : get_visible_devices()) {
     hipDeviceProp_t hipProp;
     KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDeviceProperties(&hipProp, i));
+    std::string gpu_type = hipProp.integrated == 1 ? "APU" : "dGPU";
 
     s << "Kokkos::HIP[ " << i << " ] "
-      << "gcnArch " << hipProp.gcnArch << ", Total Global Memory: "
+      << "gcnArch " << hipProp.gcnArchName << ", Total Global Memory: "
       << ::Kokkos::Impl::human_memory_size(hipProp.totalGlobalMem)
       << ", Shared Memory per Block: "
-      << ::Kokkos::Impl::human_memory_size(hipProp.sharedMemPerBlock);
+      << ::Kokkos::Impl::human_memory_size(hipProp.sharedMemPerBlock)
+      << ", APU or dGPU: " << gpu_type
+      << ", Is Large Bar: " << hipProp.isLargeBar
+      << ", Supports Managed Memory: " << hipProp.managedMemory
+      << ", Wavefront Size: " << hipProp.warpSize;
     if (m_hipDev == i) s << " : Selected";
     s << '\n';
   }
@@ -143,41 +164,24 @@ void HIPInternal::fence(const std::string &name) const {
       [&]() { KOKKOS_IMPL_HIP_SAFE_CALL(hipStreamSynchronize(m_stream)); });
 }
 
-void HIPInternal::initialize(hipStream_t stream, bool manage_stream) {
+void HIPInternal::initialize(hipStream_t stream) {
+  KOKKOS_EXPECTS(!is_initialized());
+
   if (was_finalized)
     Kokkos::abort("Calling HIP::initialize after HIP::finalize is illegal\n");
 
-  if (is_initialized()) return;
+  m_stream = stream;
 
-  if (!HostSpace::execution_space::impl_is_initialized()) {
-    const std::string msg(
-        "HIP::initialize ERROR : HostSpace::execution_space "
-        "is not initialized");
-    Kokkos::Impl::throw_runtime_exception(msg);
-  }
-
-  const bool ok_init = nullptr == m_scratchSpace || nullptr == m_scratchFlags;
-
-  if (ok_init) {
-    m_stream        = stream;
-    m_manage_stream = manage_stream;
+  //----------------------------------
+  // Multiblock reduction uses scratch flags for counters
+  // and scratch space for partial reduction values.
+  // Allocate some initial space.  This will grow as needed.
+  {
+    const unsigned reduce_block_count =
+        m_maxWarpCount * Impl::HIPTraits::WarpSize;
 
-    //----------------------------------
-    // Multiblock reduction uses scratch flags for counters
-    // and scratch space for partial reduction values.
-    // Allocate some initial space.  This will grow as needed.
-    {
-      const unsigned reduce_block_count =
-          m_maxWarpCount * Impl::HIPTraits::WarpSize;
-
-      (void)scratch_flags(reduce_block_count * 2 * sizeof(size_type));
-      (void)scratch_space(reduce_block_count * 16 * sizeof(size_type));
-    }
-  } else {
-    std::ostringstream msg;
-    msg << "Kokkos::HIP::initialize(" << m_hipDev
-        << ") FAILED : Already initialized";
-    Kokkos::Impl::throw_runtime_exception(msg.str());
+    (void)scratch_flags(reduce_block_count * 2 * sizeof(size_type));
+    (void)scratch_space(reduce_block_count * 16 * sizeof(size_type));
   }
 
   m_num_scratch_locks = concurrency();
@@ -189,25 +193,22 @@ void HIPInternal::initialize(hipStream_t stream, bool manage_stream) {
 
 //----------------------------------------------------------------------------
 
-using ScratchGrain = Kokkos::HIP::size_type[Impl::HIPTraits::WarpSize];
-enum { sizeScratchGrain = sizeof(ScratchGrain) };
-
 Kokkos::HIP::size_type *HIPInternal::scratch_space(const std::size_t size) {
   if (verify_is_initialized("scratch_space") &&
-      m_scratchSpaceCount * sizeScratchGrain < size) {
-    m_scratchSpaceCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
-
-    using Record = Kokkos::Impl::SharedAllocationRecord<Kokkos::HIPSpace, void>;
-
-    if (m_scratchSpace) Record::decrement(Record::get_record(m_scratchSpace));
+      m_scratchSpaceCount < scratch_count(size)) {
+    Kokkos::HIPSpace mem_space;
 
-    Record *const r =
-        Record::allocate(Kokkos::HIPSpace(), "Kokkos::InternalScratchSpace",
-                         (sizeScratchGrain * m_scratchSpaceCount));
+    if (m_scratchSpace) {
+      mem_space.deallocate(m_scratchSpace,
+                           m_scratchSpaceCount * sizeScratchGrain);
+    }
 
-    Record::increment(r);
+    m_scratchSpaceCount = scratch_count(size);
 
-    m_scratchSpace = reinterpret_cast<size_type *>(r->data());
+    std::size_t alloc_size =
+        multiply_overflow_abort(m_scratchSpaceCount, sizeScratchGrain);
+    m_scratchSpace = static_cast<size_type *>(
+        mem_space.allocate("Kokkos::InternalScratchSpace", alloc_size));
   }
 
   return m_scratchSpace;
@@ -215,23 +216,25 @@ Kokkos::HIP::size_type *HIPInternal::scratch_space(const std::size_t size) {
 
 Kokkos::HIP::size_type *HIPInternal::scratch_flags(const std::size_t size) {
   if (verify_is_initialized("scratch_flags") &&
-      m_scratchFlagsCount * sizeScratchGrain < size) {
-    m_scratchFlagsCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
-
-    using Record = Kokkos::Impl::SharedAllocationRecord<Kokkos::HIPSpace, void>;
-
-    if (m_scratchFlags) Record::decrement(Record::get_record(m_scratchFlags));
+      m_scratchFlagsCount < scratch_count(size)) {
+    Kokkos::HIPSpace mem_space;
 
-    Record *const r =
-        Record::allocate(Kokkos::HIPSpace(), "Kokkos::InternalScratchFlags",
-                         (sizeScratchGrain * m_scratchFlagsCount));
+    if (m_scratchFlags) {
+      mem_space.deallocate(m_scratchFlags,
+                           m_scratchFlagsCount * sizeScratchGrain);
+    }
 
-    Record::increment(r);
+    m_scratchFlagsCount = scratch_count(size);
 
-    m_scratchFlags = reinterpret_cast<size_type *>(r->data());
+    std::size_t alloc_size =
+        multiply_overflow_abort(m_scratchFlagsCount, sizeScratchGrain);
+    m_scratchFlags = static_cast<size_type *>(
+        mem_space.allocate("Kokkos::InternalScratchFlags", alloc_size));
 
-    KOKKOS_IMPL_HIP_SAFE_CALL(
-        hipMemset(m_scratchFlags, 0, m_scratchFlagsCount * sizeScratchGrain));
+    // We only zero-initialize the allocation when we actually allocate.
+    // It's the responsibility of the features using scratch_flags,
+    // namely parallel_reduce and parallel_scan, to reset the used values to 0.
+    KOKKOS_IMPL_HIP_SAFE_CALL(hipMemset(m_scratchFlags, 0, alloc_size));
   }
 
   return m_scratchFlags;
@@ -240,29 +243,20 @@ Kokkos::HIP::size_type *HIPInternal::scratch_flags(const std::size_t size) {
 Kokkos::HIP::size_type *HIPInternal::stage_functor_for_execution(
     void const *driver, std::size_t const size) const {
   if (verify_is_initialized("scratch_functor") && m_scratchFunctorSize < size) {
-    m_scratchFunctorSize = size;
-
-    using Record = Kokkos::Impl::SharedAllocationRecord<Kokkos::HIPSpace, void>;
-    using RecordHost =
-        Kokkos::Impl::SharedAllocationRecord<Kokkos::HIPHostPinnedSpace, void>;
+    Kokkos::HIPSpace device_mem_space;
+    Kokkos::HIPHostPinnedSpace host_mem_space;
 
     if (m_scratchFunctor) {
-      Record::decrement(Record::get_record(m_scratchFunctor));
-      RecordHost::decrement(RecordHost::get_record(m_scratchFunctorHost));
+      device_mem_space.deallocate(m_scratchFunctor, m_scratchFunctorSize);
+      host_mem_space.deallocate(m_scratchFunctorHost, m_scratchFunctorSize);
     }
 
-    Record *const r =
-        Record::allocate(Kokkos::HIPSpace(), "Kokkos::InternalScratchFunctor",
-                         m_scratchFunctorSize);
-    RecordHost *const r_host = RecordHost::allocate(
-        Kokkos::HIPHostPinnedSpace(), "Kokkos::InternalScratchFunctorHost",
-        m_scratchFunctorSize);
-
-    Record::increment(r);
-    RecordHost::increment(r_host);
+    m_scratchFunctorSize = size;
 
-    m_scratchFunctor     = reinterpret_cast<size_type *>(r->data());
-    m_scratchFunctorHost = reinterpret_cast<size_type *>(r_host->data());
+    m_scratchFunctor     = static_cast<size_type *>(device_mem_space.allocate(
+        "Kokkos::InternalScratchFunctor", m_scratchFunctorSize));
+    m_scratchFunctorHost = static_cast<size_type *>(host_mem_space.allocate(
+        "Kokkos::InternalScratchFunctorHost", m_scratchFunctorSize));
   }
 
   // When using HSA_XNACK=1, it is necessary to copy the driver to the host to
@@ -325,23 +319,18 @@ void HIPInternal::finalize() {
   this->fence("Kokkos::HIPInternal::finalize: fence on finalization");
   was_finalized = true;
 
-  if (this == &singleton()) {
-    (void)Kokkos::Impl::hip_global_unique_token_locks(true);
-    desul::Impl::finalize_lock_arrays();  // FIXME
-
-    KOKKOS_IMPL_HIP_SAFE_CALL(hipHostFree(constantMemHostStaging));
-    KOKKOS_IMPL_HIP_SAFE_CALL(hipEventDestroy(constantMemReusable));
-  }
-
   if (nullptr != m_scratchSpace || nullptr != m_scratchFlags) {
-    using RecordHIP = Kokkos::Impl::SharedAllocationRecord<Kokkos::HIPSpace>;
+    Kokkos::HIPSpace device_mem_space;
 
-    RecordHIP::decrement(RecordHIP::get_record(m_scratchFlags));
-    RecordHIP::decrement(RecordHIP::get_record(m_scratchSpace));
+    device_mem_space.deallocate(m_scratchFlags,
+                                m_scratchSpaceCount * sizeScratchGrain);
+    device_mem_space.deallocate(m_scratchSpace,
+                                m_scratchFlagsCount * sizeScratchGrain);
 
     if (m_scratchFunctorSize > 0) {
-      RecordHIP::decrement(RecordHIP::get_record(m_scratchFunctor));
-      RecordHIP::decrement(RecordHIP::get_record(m_scratchFunctorHost));
+      device_mem_space.deallocate(m_scratchFunctor, m_scratchFunctorSize);
+      Kokkos::HIPHostPinnedSpace host_mem_space;
+      host_mem_space.deallocate(m_scratchFunctorHost, m_scratchFunctorSize);
     }
   }
 
@@ -350,14 +339,10 @@ void HIPInternal::finalize() {
       Kokkos::kokkos_free<Kokkos::HIPSpace>(m_team_scratch_ptr[i]);
   }
 
-  if (m_manage_stream && m_stream != nullptr)
-    KOKKOS_IMPL_HIP_SAFE_CALL(hipStreamDestroy(m_stream));
-
   m_scratchSpaceCount = 0;
   m_scratchFlagsCount = 0;
   m_scratchSpace      = nullptr;
   m_scratchFlags      = nullptr;
-  m_stream            = nullptr;
   for (int i = 0; i < m_n_team_scratch; ++i) {
     m_team_scratch_current_size[i] = 0;
     m_team_scratch_ptr[i]          = nullptr;
@@ -368,6 +353,22 @@ void HIPInternal::finalize() {
   m_num_scratch_locks = 0;
 }
 
+int HIPInternal::m_hipDev                                     = -1;
+unsigned HIPInternal::m_multiProcCount                        = 0;
+unsigned HIPInternal::m_maxWarpCount                          = 0;
+std::array<HIPInternal::size_type, 3> HIPInternal::m_maxBlock = {0, 0, 0};
+unsigned HIPInternal::m_maxWavesPerCU                         = 0;
+int HIPInternal::m_shmemPerSM                                 = 0;
+int HIPInternal::m_maxShmemPerBlock                           = 0;
+int HIPInternal::m_maxThreadsPerSM                            = 0;
+
+hipDeviceProp_t HIPInternal::m_deviceProp;
+
+std::mutex HIPInternal::scratchFunctorMutex;
+unsigned long *HIPInternal::constantMemHostStaging = nullptr;
+hipEvent_t HIPInternal::constantMemReusable        = nullptr;
+std::mutex HIPInternal::constantMemMutex;
+
 //----------------------------------------------------------------------------
 
 Kokkos::HIP::size_type hip_internal_multiprocessor_count() {
@@ -414,10 +415,10 @@ void hip_internal_error_throw(hipError_t e, const char *name, const char *file,
 
 //----------------------------------------------------------------------------
 
-namespace Kokkos {
-HIP::size_type HIP::detect_device_count() {
-  int hipDevCount;
-  KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDeviceCount(&hipDevCount));
-  return hipDevCount;
+void Kokkos::Impl::create_HIP_instances(std::vector<HIP> &instances) {
+  for (int s = 0; s < int(instances.size()); s++) {
+    hipStream_t stream;
+    KOKKOS_IMPL_HIP_SAFE_CALL(hipStreamCreate(&stream));
+    instances[s] = HIP(stream, ManageStream::yes);
+  }
 }
-}  // namespace Kokkos
diff --git a/core/src/HIP/Kokkos_HIP_Instance.hpp b/core/src/HIP/Kokkos_HIP_Instance.hpp
index 9595a3e0b0..19349e90bb 100644
--- a/core/src/HIP/Kokkos_HIP_Instance.hpp
+++ b/core/src/HIP/Kokkos_HIP_Instance.hpp
@@ -29,22 +29,24 @@ namespace Kokkos {
 namespace Impl {
 
 struct HIPTraits {
-#if defined(KOKKOS_ARCH_VEGA)
-  static int constexpr WarpSize       = 64;
-  static int constexpr WarpIndexMask  = 0x003f; /* hexadecimal for 63 */
-  static int constexpr WarpIndexShift = 6;      /* WarpSize == 1 << WarpShift*/
-#elif defined(KOKKOS_ARCH_NAVI)
-  static int constexpr WarpSize       = 32;
-  static int constexpr WarpIndexMask  = 0x001f; /* hexadecimal for 31 */
-  static int constexpr WarpIndexShift = 5;      /* WarpSize == 1 << WarpShift*/
+#if defined(KOKKOS_ARCH_AMD_GFX906) || defined(KOKKOS_ARCH_AMD_GFX908) || \
+    defined(KOKKOS_ARCH_AMD_GFX90A) || defined(KOKKOS_ARCH_AMD_GFX940) || \
+    defined(KOKKOS_ARCH_AMD_GFX942)
+  static constexpr int WarpSize       = 64;
+  static constexpr int WarpIndexMask  = 0x003f; /* hexadecimal for 63 */
+  static constexpr int WarpIndexShift = 6;      /* WarpSize == 1 << WarpShift*/
+#elif defined(KOKKOS_ARCH_AMD_GFX1030) || defined(KOKKOS_ARCH_AMD_GFX1100)
+  static constexpr int WarpSize       = 32;
+  static constexpr int WarpIndexMask  = 0x001f; /* hexadecimal for 31 */
+  static constexpr int WarpIndexShift = 5;      /* WarpSize == 1 << WarpShift*/
 #endif
-  static int constexpr ConservativeThreadsPerBlock =
+  static constexpr int ConservativeThreadsPerBlock =
       256;  // conservative fallback blocksize in case of spills
-  static int constexpr MaxThreadsPerBlock =
+  static constexpr int MaxThreadsPerBlock =
       1024;  // the maximum we can fit in a block
-  static int constexpr ConstantMemoryUsage        = 0x008000; /* 32k bytes */
-  static int constexpr KernelArgumentLimit        = 0x001000; /*  4k bytes */
-  static int constexpr ConstantMemoryUseThreshold = 0x000200; /* 512 bytes */
+  static constexpr int ConstantMemoryUsage        = 0x008000; /* 32k bytes */
+  static constexpr int KernelArgumentLimit        = 0x001000; /*  4k bytes */
+  static constexpr int ConstantMemoryUseThreshold = 0x000200; /* 512 bytes */
 };
 
 //----------------------------------------------------------------------------
@@ -68,18 +70,16 @@ class HIPInternal {
  public:
   using size_type = ::Kokkos::HIP::size_type;
 
-  inline static int m_hipDev                        = -1;
-  inline static int m_hipArch                       = -1;
-  inline static unsigned m_multiProcCount           = 0;
-  inline static unsigned m_maxWarpCount             = 0;
-  inline static std::array<size_type, 3> m_maxBlock = {0, 0, 0};
-  inline static unsigned m_maxWavesPerCU            = 0;
-  inline static unsigned m_maxSharedWords           = 0;
-  inline static int m_shmemPerSM                    = 0;
-  inline static int m_maxShmemPerBlock              = 0;
-  inline static int m_maxThreadsPerSM               = 0;
+  static int m_hipDev;
+  static unsigned m_multiProcCount;
+  static unsigned m_maxWarpCount;
+  static std::array<size_type, 3> m_maxBlock;
+  static unsigned m_maxWavesPerCU;
+  static int m_shmemPerSM;
+  static int m_maxShmemPerBlock;
+  static int m_maxThreadsPerSM;
 
-  inline static hipDeviceProp_t m_deviceProp;
+  static hipDeviceProp_t m_deviceProp;
 
   static int concurrency();
 
@@ -92,13 +92,12 @@ class HIPInternal {
   size_type *m_scratchFlags               = nullptr;
   mutable size_type *m_scratchFunctor     = nullptr;
   mutable size_type *m_scratchFunctorHost = nullptr;
-  inline static std::mutex scratchFunctorMutex;
+  static std::mutex scratchFunctorMutex;
 
   hipStream_t m_stream = nullptr;
   uint32_t m_instance_id =
       Kokkos::Tools::Experimental::Impl::idForInstance<HIP>(
           reinterpret_cast<uintptr_t>(this));
-  bool m_manage_stream = false;
 
   // Team Scratch Level 1 Space
   int m_n_team_scratch                            = 10;
@@ -112,9 +111,9 @@ class HIPInternal {
 
   // FIXME_HIP: these want to be per-device, not per-stream...  use of 'static'
   // here will break once there are multiple devices though
-  inline static unsigned long *constantMemHostStaging = nullptr;
-  inline static hipEvent_t constantMemReusable        = nullptr;
-  inline static std::mutex constantMemMutex;
+  static unsigned long *constantMemHostStaging;
+  static hipEvent_t constantMemReusable;
+  static std::mutex constantMemMutex;
 
   static HIPInternal &singleton();
 
@@ -124,7 +123,7 @@ class HIPInternal {
     return nullptr != m_scratchSpace && nullptr != m_scratchFlags;
   }
 
-  void initialize(hipStream_t stream, bool manage_stream);
+  void initialize(hipStream_t stream);
   void finalize();
 
   void print_configuration(std::ostream &) const;
@@ -149,6 +148,7 @@ class HIPInternal {
   void release_team_scratch_space(int scratch_pool_id);
 };
 
+void create_HIP_instances(std::vector<HIP> &instances);
 }  // namespace Impl
 
 namespace Experimental {
@@ -157,16 +157,6 @@ namespace Experimental {
 //   Customization point for backends
 //   Default behavior is to return the passed in instance
 
-namespace Impl {
-inline void create_HIP_instances(std::vector<HIP> &instances) {
-  for (int s = 0; s < int(instances.size()); s++) {
-    hipStream_t stream;
-    KOKKOS_IMPL_HIP_SAFE_CALL(hipStreamCreate(&stream));
-    instances[s] = HIP(stream, true);
-  }
-}
-}  // namespace Impl
-
 template <class... Args>
 std::vector<HIP> partition_space(const HIP &, Args...) {
   static_assert(
@@ -174,7 +164,7 @@ std::vector<HIP> partition_space(const HIP &, Args...) {
       "Kokkos Error: partitioning arguments must be integers or floats");
 
   std::vector<HIP> instances(sizeof...(Args));
-  Impl::create_HIP_instances(instances);
+  Kokkos::Impl::create_HIP_instances(instances);
   return instances;
 }
 
@@ -187,7 +177,7 @@ std::vector<HIP> partition_space(const HIP &, std::vector<T> const &weights) {
   // 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);
+  Kokkos::Impl::create_HIP_instances(instances);
   return instances;
 }
 }  // namespace Experimental
diff --git a/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp b/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp
index 0bc3529530..7cd0afcf47 100644
--- a/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp
+++ b/core/src/HIP/Kokkos_HIP_KernelLaunch.hpp
@@ -25,6 +25,15 @@
 #include <HIP/Kokkos_HIP_Instance.hpp>
 #include <HIP/Kokkos_HIP_Space.hpp>
 
+#if !((HIP_VERSION_MAJOR == 5) && (HIP_VERSION_MINOR == 2))
+#define KOKKOS_IMPL_HIP_GRAPH_ENABLED
+#endif
+
+#ifdef KOKKOS_IMPL_HIP_GRAPH_ENABLED
+#include <HIP/Kokkos_HIP_GraphNodeKernel.hpp>
+#include <impl/Kokkos_GraphImpl_fwd.hpp>
+#endif
+
 // Must use global variable on the device with HIP-Clang
 #ifdef __HIP__
 #ifdef KOKKOS_ENABLE_HIP_RELOCATABLE_DEVICE_CODE
@@ -193,6 +202,13 @@ struct HIPParallelLaunchKernelFuncData {
   }
 };
 
+//---------------------------------------------------------------//
+// Helper function                                               //
+//---------------------------------------------------------------//
+inline bool is_empty_launch(dim3 const &grid, dim3 const &block) {
+  return (grid.x == 0) || ((block.x * block.y * block.z) == 0);
+}
+
 //---------------------------------------------------------------//
 // HIPParallelLaunchKernelFunc structure and its specializations //
 //---------------------------------------------------------------//
@@ -367,6 +383,42 @@ struct HIPParallelLaunchKernelInvoker<DriverType, LaunchBounds,
     (base_t::get_kernel_func())<<<grid, block, shmem, hip_instance->m_stream>>>(
         driver);
   }
+
+#ifdef KOKKOS_IMPL_HIP_GRAPH_ENABLED
+  static void create_parallel_launch_graph_node(
+      DriverType const &driver, dim3 const &grid, dim3 const &block, int shmem,
+      HIPInternal const * /*hip_instance*/) {
+    auto const &graph = get_hip_graph_from_kernel(driver);
+    KOKKOS_EXPECTS(graph);
+    auto &graph_node = get_hip_graph_node_from_kernel(driver);
+    // Expect node not yet initialized
+    KOKKOS_EXPECTS(!graph_node);
+
+    if (!is_empty_launch(grid, block)) {
+      void const *args[] = {&driver};
+
+      hipKernelNodeParams params = {};
+
+      params.blockDim       = block;
+      params.gridDim        = grid;
+      params.sharedMemBytes = shmem;
+      params.func           = (void *)base_t::get_kernel_func();
+      params.kernelParams   = (void **)args;
+      params.extra          = nullptr;
+
+      KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphAddKernelNode(
+          &graph_node, graph, /* dependencies = */ nullptr,
+          /* numDependencies = */ 0, &params));
+    } else {
+      // We still need an empty node for the dependency structure
+      KOKKOS_IMPL_HIP_SAFE_CALL(
+          hipGraphAddEmptyNode(&graph_node, graph,
+                               /* dependencies = */ nullptr,
+                               /* numDependencies = */ 0));
+    }
+    KOKKOS_ENSURES(graph_node);
+  }
+#endif
 };
 
 // HIPLaunchMechanism::GlobalMemory specialization
@@ -389,6 +441,52 @@ struct HIPParallelLaunchKernelInvoker<DriverType, LaunchBounds,
     (base_t::get_kernel_func())<<<grid, block, shmem, hip_instance->m_stream>>>(
         driver_ptr);
   }
+
+#ifdef KOKKOS_IMPL_HIP_GRAPH_ENABLED
+  static void create_parallel_launch_graph_node(
+      DriverType const &driver, dim3 const &grid, dim3 const &block, int shmem,
+      HIPInternal const *hip_instance) {
+    auto const &graph = get_hip_graph_from_kernel(driver);
+    KOKKOS_EXPECTS(graph);
+    auto &graph_node = get_hip_graph_node_from_kernel(driver);
+    // Expect node not yet initialized
+    KOKKOS_EXPECTS(!graph_node);
+
+    if (!Impl::is_empty_launch(grid, block)) {
+      auto *driver_ptr = Impl::allocate_driver_storage_for_kernel(driver);
+
+      // Unlike in the non-graph case, we can get away with doing an async copy
+      // here because the `DriverType` instance is held in the GraphNodeImpl
+      // which is guaranteed to be alive until the graph instance itself is
+      // destroyed, where there should be a fence ensuring that the allocation
+      // associated with this kernel on the device side isn't deleted.
+      hipMemcpyAsync(driver_ptr, &driver, sizeof(DriverType), hipMemcpyDefault,
+                     hip_instance->m_stream);
+
+      void const *args[] = {&driver_ptr};
+
+      hipKernelNodeParams params = {};
+
+      params.blockDim       = block;
+      params.gridDim        = grid;
+      params.sharedMemBytes = shmem;
+      params.func           = (void *)base_t::get_kernel_func();
+      params.kernelParams   = (void **)args;
+      params.extra          = nullptr;
+
+      KOKKOS_IMPL_HIP_SAFE_CALL(hipGraphAddKernelNode(
+          &graph_node, graph, /* dependencies = */ nullptr,
+          /* numDependencies = */ 0, &params));
+    } else {
+      // We still need an empty node for the dependency structure
+      KOKKOS_IMPL_HIP_SAFE_CALL(
+          hipGraphAddEmptyNode(&graph_node, graph,
+                               /* dependencies = */ nullptr,
+                               /* numDependencies = */ 0));
+    }
+    KOKKOS_ENSURES(bool(graph_node))
+  }
+#endif
 };
 
 // HIPLaunchMechanism::ConstantMemory specializations
@@ -481,42 +579,57 @@ struct HIPParallelLaunch<
 // al.
 template <typename DriverType, typename LaunchBounds = Kokkos::LaunchBounds<>,
           HIPLaunchMechanism LaunchMechanism =
-              DeduceHIPLaunchMechanism<DriverType>::launch_mechanism>
+              DeduceHIPLaunchMechanism<DriverType>::launch_mechanism,
+          bool DoGraph = DriverType::Policy::is_graph_kernel::value>
 void hip_parallel_launch(const DriverType &driver, const dim3 &grid,
                          const dim3 &block, const int shmem,
                          const HIPInternal *hip_instance,
                          const bool prefer_shmem) {
+#ifdef KOKKOS_IMPL_HIP_GRAPH_ENABLED
+  if constexpr (DoGraph) {
+    // Graph launch
+    using base_t = HIPParallelLaunchKernelInvoker<DriverType, LaunchBounds,
+                                                  LaunchMechanism>;
+    base_t::create_parallel_launch_graph_node(driver, grid, block, shmem,
+                                              hip_instance);
+  } else
+#endif
+  {
+    // Regular kernel launch
 #ifndef KOKKOS_ENABLE_HIP_MULTIPLE_KERNEL_INSTANTIATIONS
-  HIPParallelLaunch<DriverType, LaunchBounds, LaunchMechanism>(
-      driver, grid, block, shmem, hip_instance, prefer_shmem);
-#else
-  if constexpr (!HIPParallelLaunch<DriverType, LaunchBounds,
-                                   LaunchMechanism>::default_launchbounds()) {
-    // for user defined, we *always* honor the request
     HIPParallelLaunch<DriverType, LaunchBounds, LaunchMechanism>(
         driver, grid, block, shmem, hip_instance, prefer_shmem);
-  } else {
-    // we can do what we like
-    const unsigned flat_block_size = block.x * block.y * block.z;
-    if (flat_block_size <= HIPTraits::ConservativeThreadsPerBlock) {
-      // we have to use the large blocksize
-      HIPParallelLaunch<
-          DriverType,
-          Kokkos::LaunchBounds<HIPTraits::ConservativeThreadsPerBlock, 1>,
-          LaunchMechanism>(driver, grid, block, shmem, hip_instance,
-                           prefer_shmem);
+#else
+    if constexpr (!HIPParallelLaunch<DriverType, LaunchBounds,
+                                     LaunchMechanism>::default_launchbounds()) {
+      // for user defined, we *always* honor the request
+      HIPParallelLaunch<DriverType, LaunchBounds, LaunchMechanism>(
+          driver, grid, block, shmem, hip_instance, prefer_shmem);
     } else {
-      HIPParallelLaunch<DriverType,
-                        Kokkos::LaunchBounds<HIPTraits::MaxThreadsPerBlock, 1>,
-                        LaunchMechanism>(driver, grid, block, shmem,
-                                         hip_instance, prefer_shmem);
+      // we can do what we like
+      const unsigned flat_block_size = block.x * block.y * block.z;
+      if (flat_block_size <= HIPTraits::ConservativeThreadsPerBlock) {
+        // we have to use the large blocksize
+        HIPParallelLaunch<
+            DriverType,
+            Kokkos::LaunchBounds<HIPTraits::ConservativeThreadsPerBlock, 1>,
+            LaunchMechanism>(driver, grid, block, shmem, hip_instance,
+                             prefer_shmem);
+      } else {
+        HIPParallelLaunch<
+            DriverType, Kokkos::LaunchBounds<HIPTraits::MaxThreadsPerBlock, 1>,
+            LaunchMechanism>(driver, grid, block, shmem, hip_instance,
+                             prefer_shmem);
+      }
     }
-  }
 #endif
+  }
 }
 }  // namespace Impl
 }  // namespace Kokkos
 
+#undef KOKKOS_IMPL_HIP_GRAPH_ENABLED
+
 #endif
 
 #endif
diff --git a/core/src/HIP/Kokkos_HIP_ParallelFor_MDRange.hpp b/core/src/HIP/Kokkos_HIP_ParallelFor_MDRange.hpp
new file mode 100644
index 0000000000..db07c360b5
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_ParallelFor_MDRange.hpp
@@ -0,0 +1,173 @@
+//@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_PARALLEL_FOR_MDRANGE_HPP
+#define KOKKOS_HIP_PARALLEL_FOR_MDRANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <HIP/Kokkos_HIP_BlockSize_Deduction.hpp>
+#include <HIP/Kokkos_HIP_KernelLaunch.hpp>
+#include <KokkosExp_MDRangePolicy.hpp>
+#include <impl/KokkosExp_IterateTileGPU.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+// ParallelFor
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, HIP> {
+ public:
+  using Policy       = Kokkos::MDRangePolicy<Traits...>;
+  using functor_type = FunctorType;
+
+ private:
+  using array_index_type = typename Policy::array_index_type;
+  using index_type       = typename Policy::index_type;
+  using LaunchBounds     = typename Policy::launch_bounds;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+ public:
+  ParallelFor()                   = delete;
+  ParallelFor(ParallelFor const&) = default;
+  ParallelFor& operator=(ParallelFor const&) = delete;
+
+  inline __device__ void operator()() const {
+    Kokkos::Impl::DeviceIterateTile<Policy::rank, Policy, FunctorType,
+                                    typename Policy::work_tag>(m_policy,
+                                                               m_functor)
+        .exec_range();
+  }
+
+  inline void execute() const {
+    using ClosureType = ParallelFor<FunctorType, Policy, HIP>;
+    if (m_policy.m_num_tiles == 0) return;
+    auto const maxblocks = hip_internal_maximum_grid_count();
+    if (Policy::rank == 2) {
+      dim3 const block(m_policy.m_tile[0], m_policy.m_tile[1], 1);
+      dim3 const grid(
+          std::min<array_index_type>(
+              (m_policy.m_upper[0] - m_policy.m_lower[0] + block.x - 1) /
+                  block.x,
+              maxblocks[0]),
+          std::min<array_index_type>(
+              (m_policy.m_upper[1] - m_policy.m_lower[1] + block.y - 1) /
+                  block.y,
+              maxblocks[1]),
+          1);
+      hip_parallel_launch<ClosureType, LaunchBounds>(
+          *this, grid, block, 0,
+          m_policy.space().impl_internal_space_instance(), false);
+    } else if (Policy::rank == 3) {
+      dim3 const block(m_policy.m_tile[0], m_policy.m_tile[1],
+                       m_policy.m_tile[2]);
+      dim3 const grid(
+          std::min<array_index_type>(
+              (m_policy.m_upper[0] - m_policy.m_lower[0] + block.x - 1) /
+                  block.x,
+              maxblocks[0]),
+          std::min<array_index_type>(
+              (m_policy.m_upper[1] - m_policy.m_lower[1] + block.y - 1) /
+                  block.y,
+              maxblocks[1]),
+          std::min<array_index_type>(
+              (m_policy.m_upper[2] - m_policy.m_lower[2] + block.z - 1) /
+                  block.z,
+              maxblocks[2]));
+      hip_parallel_launch<ClosureType, LaunchBounds>(
+          *this, grid, block, 0,
+          m_policy.space().impl_internal_space_instance(), false);
+    } else if (Policy::rank == 4) {
+      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to
+      // threadIdx.z
+      dim3 const block(m_policy.m_tile[0] * m_policy.m_tile[1],
+                       m_policy.m_tile[2], m_policy.m_tile[3]);
+      dim3 const grid(
+          std::min<array_index_type>(
+              m_policy.m_tile_end[0] * m_policy.m_tile_end[1], maxblocks[0]),
+          std::min<array_index_type>(
+              (m_policy.m_upper[2] - m_policy.m_lower[2] + block.y - 1) /
+                  block.y,
+              maxblocks[1]),
+          std::min<array_index_type>(
+              (m_policy.m_upper[3] - m_policy.m_lower[3] + block.z - 1) /
+                  block.z,
+              maxblocks[2]));
+      hip_parallel_launch<ClosureType, LaunchBounds>(
+          *this, grid, block, 0,
+          m_policy.space().impl_internal_space_instance(), false);
+    } else if (Policy::rank == 5) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4
+      // to threadIdx.z
+      dim3 const block(m_policy.m_tile[0] * m_policy.m_tile[1],
+                       m_policy.m_tile[2] * m_policy.m_tile[3],
+                       m_policy.m_tile[4]);
+      dim3 const grid(
+          std::min<array_index_type>(
+              m_policy.m_tile_end[0] * m_policy.m_tile_end[1], maxblocks[0]),
+          std::min<array_index_type>(
+              m_policy.m_tile_end[2] * m_policy.m_tile_end[3], maxblocks[1]),
+          std::min<array_index_type>(
+              (m_policy.m_upper[4] - m_policy.m_lower[4] + block.z - 1) /
+                  block.z,
+              maxblocks[2]));
+      hip_parallel_launch<ClosureType, LaunchBounds>(
+          *this, grid, block, 0,
+          m_policy.space().impl_internal_space_instance(), false);
+    } else if (Policy::rank == 6) {
+      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y;
+      // id4,id5 to threadIdx.z
+      dim3 const block(m_policy.m_tile[0] * m_policy.m_tile[1],
+                       m_policy.m_tile[2] * m_policy.m_tile[3],
+                       m_policy.m_tile[4] * m_policy.m_tile[5]);
+      dim3 const grid(
+          std::min<array_index_type>(
+              m_policy.m_tile_end[0] * m_policy.m_tile_end[1], maxblocks[0]),
+          std::min<array_index_type>(
+              m_policy.m_tile_end[2] * m_policy.m_tile_end[3], maxblocks[1]),
+          std::min<array_index_type>(
+              m_policy.m_tile_end[4] * m_policy.m_tile_end[5], maxblocks[2]));
+      hip_parallel_launch<ClosureType, LaunchBounds>(
+          *this, grid, block, 0,
+          m_policy.space().impl_internal_space_instance(), false);
+    } else {
+      Kokkos::abort("Kokkos::MDRange Error: Exceeded rank bounds with HIP\n");
+    }
+
+  }  // end execute
+
+  ParallelFor(FunctorType const& arg_functor, Policy const& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+
+  template <typename Policy, typename Functor>
+  static int max_tile_size_product(const Policy&, const Functor&) {
+    using closure_type =
+        ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, HIP>;
+    unsigned block_size = hip_get_max_blocksize<closure_type, LaunchBounds>();
+    if (block_size == 0)
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelFor< HIP > could not find a valid "
+                      "tile size."));
+    return block_size;
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_ParallelFor_Range.hpp b/core/src/HIP/Kokkos_HIP_ParallelFor_Range.hpp
new file mode 100644
index 0000000000..9355c1c75f
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_ParallelFor_Range.hpp
@@ -0,0 +1,100 @@
+//@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_PARALLEL_FOR_RANGE_HPP
+#define KOKKOS_HIP_PARALLEL_FOR_RANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <HIP/Kokkos_HIP_BlockSize_Deduction.hpp>
+#include <HIP/Kokkos_HIP_KernelLaunch.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::HIP> {
+ public:
+  using Policy = Kokkos::RangePolicy<Traits...>;
+
+ private:
+  using Member       = typename Policy::member_type;
+  using WorkTag      = typename Policy::work_tag;
+  using LaunchBounds = typename Policy::launch_bounds;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+  template <class TagType>
+  inline __device__ std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const Member i) const {
+    m_functor(i);
+  }
+
+  template <class TagType>
+  inline __device__ std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const Member i) const {
+    m_functor(TagType(), i);
+  }
+
+ public:
+  using functor_type = FunctorType;
+
+  ParallelFor()                   = delete;
+  ParallelFor(ParallelFor const&) = default;
+  ParallelFor& operator=(ParallelFor const&) = delete;
+
+  inline __device__ void operator()() const {
+    const Member work_stride = blockDim.y * gridDim.x;
+    const Member work_end    = m_policy.end();
+
+    for (Member iwork =
+             m_policy.begin() + threadIdx.y + blockDim.y * blockIdx.x;
+         iwork < work_end;
+         iwork = iwork < work_end - work_stride ? iwork + work_stride
+                                                : work_end) {
+      this->template exec_range<WorkTag>(iwork);
+    }
+  }
+
+  inline void execute() const {
+    const typename Policy::index_type nwork = m_policy.end() - m_policy.begin();
+
+    using DriverType = ParallelFor<FunctorType, Policy, Kokkos::HIP>;
+    const int block_size =
+        Kokkos::Impl::hip_get_preferred_blocksize<DriverType, LaunchBounds>();
+    const dim3 block(1, block_size, 1);
+    const dim3 grid(
+        typename Policy::index_type((nwork + block.y - 1) / block.y), 1, 1);
+
+    if (block_size == 0) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelFor< HIP > could not find a "
+                      "valid execution configuration."));
+    }
+    Kokkos::Impl::hip_parallel_launch<DriverType, LaunchBounds>(
+        *this, grid, block, 0, m_policy.space().impl_internal_space_instance(),
+        false);
+  }
+
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_ParallelFor_Team.hpp b/core/src/HIP/Kokkos_HIP_ParallelFor_Team.hpp
new file mode 100644
index 0000000000..bf0c219338
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_ParallelFor_Team.hpp
@@ -0,0 +1,177 @@
+//@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_PARALLEL_FOR_TEAM_HPP
+#define KOKKOS_HIP_PARALLEL_FOR_TEAM_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <HIP/Kokkos_HIP_KernelLaunch.hpp>
+#include <HIP/Kokkos_HIP_Team.hpp>
+#include <HIP/Kokkos_HIP_Instance.hpp>
+#include <HIP/Kokkos_HIP_TeamPolicyInternal.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <typename FunctorType, typename... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP> {
+ public:
+  using Policy       = TeamPolicy<Properties...>;
+  using functor_type = FunctorType;
+  using size_type    = HIP::size_type;
+
+ private:
+  using member_type   = typename Policy::member_type;
+  using work_tag      = typename Policy::work_tag;
+  using launch_bounds = typename Policy::launch_bounds;
+
+  // Algorithmic constraints: blockDim.y is a power of two AND
+  // blockDim.y  == blockDim.z == 1 shared memory utilization:
+  //
+  //  [ team   reduce space ]
+  //  [ team   shared space ]
+
+  FunctorType const m_functor;
+  Policy const m_policy;
+  size_type const m_league_size;
+  int m_team_size;
+  size_type const m_vector_size;
+  int m_shmem_begin;
+  int m_shmem_size;
+  void* m_scratch_ptr[2];
+  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(
+      const member_type& member) const {
+    m_functor(member);
+  }
+
+  template <typename TagType>
+  __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_team(
+      const member_type& member) const {
+    m_functor(TagType(), member);
+  }
+
+ public:
+  ParallelFor()                   = delete;
+  ParallelFor(ParallelFor const&) = default;
+  ParallelFor& operator=(ParallelFor const&) = delete;
+
+  __device__ inline void operator()() const {
+    // 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,
+                                       m_num_scratch_locks);
+    }
+
+    int const int_league_size = static_cast<int>(m_league_size);
+    for (int league_rank = blockIdx.x; league_rank < int_league_size;
+         league_rank += gridDim.x) {
+      this->template exec_team<work_tag>(typename Policy::member_type(
+          kokkos_impl_hip_shared_memory<void>(), m_shmem_begin, m_shmem_size,
+          static_cast<void*>(static_cast<char*>(m_scratch_ptr[1]) +
+                             ptrdiff_t(threadid / (blockDim.x * blockDim.y)) *
+                                 m_scratch_size[1]),
+          m_scratch_size[1], league_rank, m_league_size));
+    }
+    if (m_scratch_size[1] > 0) {
+      hip_release_scratch_index(m_scratch_locks, threadid);
+    }
+  }
+
+  inline void execute() const {
+    int64_t const shmem_size_total = m_shmem_begin + m_shmem_size;
+    dim3 const grid(static_cast<int>(m_league_size), 1, 1);
+    dim3 const block(static_cast<int>(m_vector_size),
+                     static_cast<int>(m_team_size), 1);
+
+    using closure_type =
+        ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP>;
+    Impl::hip_parallel_launch<closure_type, launch_bounds>(
+        *this, grid, block, shmem_size_total,
+        m_policy.space().impl_internal_space_instance(),
+        true);  // copy to device and execute
+  }
+
+  ParallelFor(FunctorType const& arg_functor, Policy const& arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        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, ParallelForTag());
+
+    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_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.
+    m_scratch_ptr[0] = nullptr;
+    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))));
+    }
+
+    int const shmem_size_total = m_shmem_begin + m_shmem_size;
+    if (internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
+      Kokkos::Impl::throw_runtime_exception(std::string(
+          "Kokkos::Impl::ParallelFor< HIP > insufficient shared memory"));
+    }
+
+    size_t max_size = arg_policy.team_size_max(arg_functor, ParallelForTag());
+    if (static_cast<int>(m_team_size) > static_cast<int>(max_size)) {
+      Kokkos::Impl::throw_runtime_exception(std::string(
+          "Kokkos::Impl::ParallelFor< HIP > requested too large team size."));
+    }
+  }
+
+  ~ParallelFor() {
+    if (m_scratch_pool_id >= 0) {
+      m_policy.space()
+          .impl_internal_space_instance()
+          ->release_team_scratch_space(m_scratch_pool_id);
+    }
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp b/core/src/HIP/Kokkos_HIP_ParallelReduce_MDRange.hpp
similarity index 61%
rename from core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp
rename to core/src/HIP/Kokkos_HIP_ParallelReduce_MDRange.hpp
index ec1e143849..1629511646 100644
--- a/core/src/HIP/Kokkos_HIP_Parallel_MDRange.hpp
+++ b/core/src/HIP/Kokkos_HIP_ParallelReduce_MDRange.hpp
@@ -14,155 +14,19 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_HIP_PARALLEL_MDRANGE_HPP
-#define KOKKOS_HIP_PARALLEL_MDRANGE_HPP
+#ifndef KOKKOS_HIP_PARALLEL_REDUCE_MDRANGE_HPP
+#define KOKKOS_HIP_PARALLEL_REDUCE_MDRANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
 
 #include <HIP/Kokkos_HIP_BlockSize_Deduction.hpp>
 #include <HIP/Kokkos_HIP_KernelLaunch.hpp>
 #include <HIP/Kokkos_HIP_ReduceScan.hpp>
 #include <KokkosExp_MDRangePolicy.hpp>
 #include <impl/KokkosExp_IterateTileGPU.hpp>
-#include <Kokkos_Parallel.hpp>
 
 namespace Kokkos {
 namespace Impl {
-// ParallelFor
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, HIP> {
- public:
-  using Policy = Kokkos::MDRangePolicy<Traits...>;
-
- private:
-  using array_index_type = typename Policy::array_index_type;
-  using index_type       = typename Policy::index_type;
-  using LaunchBounds     = typename Policy::launch_bounds;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  ParallelFor()        = delete;
-  ParallelFor& operator=(ParallelFor const&) = delete;
-
- public:
-  inline __device__ void operator()() const {
-    Kokkos::Impl::DeviceIterateTile<Policy::rank, Policy, FunctorType,
-                                    typename Policy::work_tag>(m_policy,
-                                                               m_functor)
-        .exec_range();
-  }
-
-  inline void execute() const {
-    using ClosureType = ParallelFor<FunctorType, Policy, HIP>;
-    if (m_policy.m_num_tiles == 0) return;
-    auto const maxblocks = hip_internal_maximum_grid_count();
-    if (Policy::rank == 2) {
-      dim3 const block(m_policy.m_tile[0], m_policy.m_tile[1], 1);
-      dim3 const grid(
-          std::min<array_index_type>(
-              (m_policy.m_upper[0] - m_policy.m_lower[0] + block.x - 1) /
-                  block.x,
-              maxblocks[0]),
-          std::min<array_index_type>(
-              (m_policy.m_upper[1] - m_policy.m_lower[1] + block.y - 1) /
-                  block.y,
-              maxblocks[1]),
-          1);
-      hip_parallel_launch<ClosureType, LaunchBounds>(
-          *this, grid, block, 0,
-          m_policy.space().impl_internal_space_instance(), false);
-    } else if (Policy::rank == 3) {
-      dim3 const block(m_policy.m_tile[0], m_policy.m_tile[1],
-                       m_policy.m_tile[2]);
-      dim3 const grid(
-          std::min<array_index_type>(
-              (m_policy.m_upper[0] - m_policy.m_lower[0] + block.x - 1) /
-                  block.x,
-              maxblocks[0]),
-          std::min<array_index_type>(
-              (m_policy.m_upper[1] - m_policy.m_lower[1] + block.y - 1) /
-                  block.y,
-              maxblocks[1]),
-          std::min<array_index_type>(
-              (m_policy.m_upper[2] - m_policy.m_lower[2] + block.z - 1) /
-                  block.z,
-              maxblocks[2]));
-      hip_parallel_launch<ClosureType, LaunchBounds>(
-          *this, grid, block, 0,
-          m_policy.space().impl_internal_space_instance(), false);
-    } else if (Policy::rank == 4) {
-      // id0,id1 encoded within threadIdx.x; id2 to threadIdx.y; id3 to
-      // threadIdx.z
-      dim3 const block(m_policy.m_tile[0] * m_policy.m_tile[1],
-                       m_policy.m_tile[2], m_policy.m_tile[3]);
-      dim3 const grid(
-          std::min<array_index_type>(
-              m_policy.m_tile_end[0] * m_policy.m_tile_end[1], maxblocks[0]),
-          std::min<array_index_type>(
-              (m_policy.m_upper[2] - m_policy.m_lower[2] + block.y - 1) /
-                  block.y,
-              maxblocks[1]),
-          std::min<array_index_type>(
-              (m_policy.m_upper[3] - m_policy.m_lower[3] + block.z - 1) /
-                  block.z,
-              maxblocks[2]));
-      hip_parallel_launch<ClosureType, LaunchBounds>(
-          *this, grid, block, 0,
-          m_policy.space().impl_internal_space_instance(), false);
-    } else if (Policy::rank == 5) {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y; id4
-      // to threadIdx.z
-      dim3 const block(m_policy.m_tile[0] * m_policy.m_tile[1],
-                       m_policy.m_tile[2] * m_policy.m_tile[3],
-                       m_policy.m_tile[4]);
-      dim3 const grid(
-          std::min<array_index_type>(
-              m_policy.m_tile_end[0] * m_policy.m_tile_end[1], maxblocks[0]),
-          std::min<array_index_type>(
-              m_policy.m_tile_end[2] * m_policy.m_tile_end[3], maxblocks[1]),
-          std::min<array_index_type>(
-              (m_policy.m_upper[4] - m_policy.m_lower[4] + block.z - 1) /
-                  block.z,
-              maxblocks[2]));
-      hip_parallel_launch<ClosureType, LaunchBounds>(
-          *this, grid, block, 0,
-          m_policy.space().impl_internal_space_instance(), false);
-    } else if (Policy::rank == 6) {
-      // id0,id1 encoded within threadIdx.x; id2,id3 to threadIdx.y;
-      // id4,id5 to threadIdx.z
-      dim3 const block(m_policy.m_tile[0] * m_policy.m_tile[1],
-                       m_policy.m_tile[2] * m_policy.m_tile[3],
-                       m_policy.m_tile[4] * m_policy.m_tile[5]);
-      dim3 const grid(
-          std::min<array_index_type>(
-              m_policy.m_tile_end[0] * m_policy.m_tile_end[1], maxblocks[0]),
-          std::min<array_index_type>(
-              m_policy.m_tile_end[2] * m_policy.m_tile_end[3], maxblocks[1]),
-          std::min<array_index_type>(
-              m_policy.m_tile_end[4] * m_policy.m_tile_end[5], maxblocks[2]));
-      hip_parallel_launch<ClosureType, LaunchBounds>(
-          *this, grid, block, 0,
-          m_policy.space().impl_internal_space_instance(), false);
-    } else {
-      Kokkos::abort("Kokkos::MDRange Error: Exceeded rank bounds with HIP\n");
-    }
-
-  }  // end execute
-
-  ParallelFor(FunctorType const& arg_functor, Policy const& arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-
-  template <typename Policy, typename Functor>
-  static int max_tile_size_product(const Policy&, const Functor&) {
-    using closure_type =
-        ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>, HIP>;
-    unsigned block_size = hip_get_max_blocksize<closure_type, LaunchBounds>();
-    if (block_size == 0)
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelFor< HIP > could not find a valid "
-                      "tile size."));
-    return block_size;
-  }
-};
 
 // ParallelReduce
 template <class CombinedFunctorReducerType, class... Traits>
@@ -186,6 +50,7 @@ class ParallelReduce<CombinedFunctorReducerType,
   using value_type     = typename ReducerType::value_type;
   using reference_type = typename ReducerType::reference_type;
   using functor_type   = FunctorType;
+  using reducer_type   = ReducerType;
   using size_type      = HIP::size_type;
 
   // Conditionally set word_size_type to int16_t or int8_t if value_type is
diff --git a/core/src/HIP/Kokkos_HIP_ParallelReduce_Range.hpp b/core/src/HIP/Kokkos_HIP_ParallelReduce_Range.hpp
new file mode 100644
index 0000000000..c8981866e8
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_ParallelReduce_Range.hpp
@@ -0,0 +1,329 @@
+//@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_PARALLEL_REDUCE_RANGE_HPP
+#define KOKKOS_HIP_PARALLEL_REDUCE_RANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <HIP/Kokkos_HIP_BlockSize_Deduction.hpp>
+#include <HIP/Kokkos_HIP_KernelLaunch.hpp>
+#include <HIP/Kokkos_HIP_ReduceScan.hpp>
+#include <HIP/Kokkos_HIP_Shuffle_Reduce.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
+                     Kokkos::HIP> {
+ public:
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+ private:
+  using WorkRange    = typename Policy::WorkRange;
+  using WorkTag      = typename Policy::work_tag;
+  using Member       = typename Policy::member_type;
+  using LaunchBounds = typename Policy::launch_bounds;
+
+ public:
+  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 reducer_type   = ReducerType;
+  using size_type      = Kokkos::HIP::size_type;
+  using index_type     = typename Policy::index_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 scan is performed.
+  // Within the scan, the word count is recomputed based on word_size_type
+  // and when calculating indexes into the shared/global memory buffers for
+  // performing the scan, 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.
+  using word_size_type = std::conditional_t<
+      sizeof(value_type) < sizeof(size_type),
+      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 CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+  const bool m_result_ptr_host_accessible;
+  word_size_type* m_scratch_space = nullptr;
+  size_type* m_scratch_flags      = nullptr;
+
+  static constexpr bool UseShflReduction = false;
+
+ private:
+  struct ShflReductionTag {};
+  struct SHMEMReductionTag {};
+
+  // Make the exec_range calls call to Reduce::DeviceIterateTile
+  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_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_reducer.get_functor()(TagType(), i, update);
+  }
+
+ public:
+  __device__ inline void operator()() const {
+    using ReductionTag = std::conditional_t<UseShflReduction, ShflReductionTag,
+                                            SHMEMReductionTag>;
+    run(ReductionTag{});
+  }
+
+  __device__ inline void run(SHMEMReductionTag) const {
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+    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 = reducer.init(reinterpret_cast<pointer_type>(
+          ::Kokkos::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 arithmetically
+      // equivalent.
+
+      const WorkRange range(m_policy, blockIdx.x, gridDim.x);
+
+      for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
+           iwork < iwork_end; iwork += blockDim.y) {
+        this->template exec_range<WorkTag>(iwork, value);
+      }
+    }
+
+    // Reduce with final value at blockDim.y - 1 location.
+    // Shortcut for length zero reduction
+    bool do_final_reduction = m_policy.begin() == m_policy.end();
+    if (!do_final_reduction)
+      do_final_reduction = hip_single_inter_block_reduce_scan<false>(
+          reducer, blockIdx.x, gridDim.x,
+          ::Kokkos::kokkos_impl_hip_shared_memory<word_size_type>(),
+          m_scratch_space, m_scratch_flags);
+    if (do_final_reduction) {
+      // This is the final block with the final result at the final threads'
+      // location
+
+      word_size_type* const shared =
+          ::Kokkos::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) {
+        reducer.final(reinterpret_cast<value_type*>(shared));
+      }
+
+      if (::Kokkos::Impl::HIPTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }
+
+      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
+        global[i] = shared[i];
+      }
+    }
+  }
+
+  __device__ inline void run(ShflReductionTag) const {
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+
+    value_type 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
+    // ordering does not match the final pass, but is arithmetically equivalent.
+
+    WorkRange const range(m_policy, blockIdx.x, gridDim.x);
+
+    for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
+         iwork < iwork_end; iwork += blockDim.y) {
+      this->template exec_range<WorkTag>(iwork, value);
+    }
+
+    pointer_type const result = reinterpret_cast<pointer_type>(m_scratch_space);
+
+    int max_active_thread = static_cast<int>(range.end() - range.begin()) <
+                                    static_cast<int>(blockDim.y)
+                                ? range.end() - range.begin()
+                                : blockDim.y;
+
+    max_active_thread =
+        (max_active_thread == 0) ? blockDim.y : max_active_thread;
+
+    value_type init;
+    reducer.init(&init);
+    if (m_policy.begin() == m_policy.end()) {
+      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, reducer, m_scratch_space, result,
+                   m_scratch_flags, max_active_thread)) {
+      unsigned int const id = threadIdx.y * blockDim.x + threadIdx.x;
+      if (id == 0) {
+        reducer.final(&value);
+        pointer_type const final_result =
+            m_result_ptr_device_accessible ? m_result_ptr : result;
+        *final_result = value;
+      }
+    }
+  }
+
+  // Determine block size constrained by shared memory:
+  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, WorkTag,
+                                                      value_type>(f, n);
+    };
+    return Kokkos::Impl::hip_get_preferred_blocksize<ParallelReduce,
+                                                     LaunchBounds>(
+        instance, shmem_functor);
+  }
+
+  inline void execute() {
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+
+    const index_type nwork     = m_policy.end() - m_policy.begin();
+    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_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 general idea here is we want to:
+      //    1. Not undersubscribe the device (i.e., we want at least
+      //    preferred_block_min blocks)
+      //    2. Have each thread reduce > 1 value to minimize overheads
+      //    3. Limit the total # of blocks, to avoid unbounded scratch space
+      constexpr int block_max           = 4096;
+      constexpr int preferred_block_min = 1024;
+
+      if (nblocks < preferred_block_min) {
+        // keep blocks as is, already have low parallelism
+      } else if (nblocks > block_max) {
+        // "large dispatch" -> already have lots of parallelism
+        nblocks = block_max;
+      } else {
+        // in the intermediate range, try to have each thread process multiple
+        // items to offset the cost of the reduction (with not enough
+        // parallelism to hide it)
+        int items_per_thread =
+            (nwork + nblocks * block_size - 1) / (nblocks * block_size);
+        if (items_per_thread < 4) {
+          int ratio = std::min(
+              (nblocks + preferred_block_min - 1) / preferred_block_min,
+              (4 + items_per_thread - 1) / items_per_thread);
+          nblocks /= ratio;
+        }
+      }
+
+      // TODO: down casting these uses more space than required?
+      m_scratch_space =
+          (word_size_type*)::Kokkos::Impl::hip_internal_scratch_space(
+              m_policy.space(), reducer.value_size() * nblocks);
+      // Intentionally do not downcast to word_size_type since we use HIP
+      // atomics in Kokkos_HIP_ReduceScan.hpp
+      m_scratch_flags = ::Kokkos::Impl::hip_internal_scratch_flags(
+          m_policy.space(), sizeof(size_type));
+      // Required grid.x <= block.y
+      dim3 grid(nblocks, 1, 1);
+
+      if (nwork == 0) {
+        block = dim3(1, 1, 1);
+        grid  = dim3(1, 1, 1);
+      }
+      const int shmem =
+          UseShflReduction
+              ? 0
+              : hip_single_inter_block_reduce_scan_shmem<false, WorkTag,
+                                                         value_type>(
+                    m_functor_reducer.get_functor(), block.y);
+
+      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 = reducer.value_size();
+        DeepCopy<HostSpace, HIPSpace, HIP>(m_policy.space(), m_result_ptr,
+                                           m_scratch_space, size);
+      }
+    } else {
+      if (m_result_ptr) {
+        reducer.init(m_result_ptr);
+      }
+    }
+  }
+
+  template <class ViewType>
+  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_result_ptr(arg_result.data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<HIPSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_result_ptr_host_accessible(
+            MemorySpaceAccess<Kokkos::HostSpace,
+                              typename ViewType::memory_space>::accessible) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_ParallelReduce_Team.hpp b/core/src/HIP/Kokkos_HIP_ParallelReduce_Team.hpp
new file mode 100644
index 0000000000..0c24e5cc62
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_ParallelReduce_Team.hpp
@@ -0,0 +1,395 @@
+//@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_PARALLEL_REDUCE_TEAM_HPP
+#define KOKKOS_HIP_PARALLEL_REDUCE_TEAM_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <HIP/Kokkos_HIP_KernelLaunch.hpp>
+#include <HIP/Kokkos_HIP_Team.hpp>
+#include <HIP/Kokkos_HIP_Instance.hpp>
+#include <HIP/Kokkos_HIP_TeamPolicyInternal.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class CombinedFunctorReducerType, class... Properties>
+class ParallelReduce<CombinedFunctorReducerType,
+                     Kokkos::TeamPolicy<Properties...>, HIP> {
+ public:
+  using Policy      = TeamPolicy<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 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 reducer_type = ReducerType;
+  using size_type    = HIP::size_type;
+
+  // static int constexpr UseShflReduction = false;
+  // FIXME_HIP This should be disabled unconditionally for best performance, but
+  // it currently causes tests to fail.
+  static constexpr int UseShflReduction =
+      (ReducerType::static_value_size() != 0);
+
+ private:
+  struct ShflReductionTag {};
+  struct SHMEMReductionTag {};
+
+  // Algorithmic constraints: blockDim.y is a power of two AND
+  // blockDim.y == blockDim.z == 1 shared memory utilization:
+  //
+  //  [ global reduce space ]
+  //  [ team   reduce space ]
+  //  [ team   shared space ]
+  //
+
+  const CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+  const bool m_result_ptr_host_accessible;
+  size_type* m_scratch_space;
+  size_type* m_scratch_flags;
+  size_type m_team_begin;
+  size_type m_shmem_begin;
+  size_type m_shmem_size;
+  void* m_scratch_ptr[2];
+  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;
+
+  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_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_reducer.get_functor()(TagType(), member, update);
+  }
+
+  __device__ inline void iterate_through_league(int const threadid,
+                                                reference_type value) const {
+    int const int_league_size = static_cast<int>(m_league_size);
+    for (int league_rank = blockIdx.x; league_rank < int_league_size;
+         league_rank += gridDim.x) {
+      this->template exec_team<work_tag>(
+          member_type(
+              kokkos_impl_hip_shared_memory<char>() + m_team_begin,
+              m_shmem_begin, m_shmem_size,
+              reinterpret_cast<void*>(
+                  reinterpret_cast<char*>(m_scratch_ptr[1]) +
+                  static_cast<ptrdiff_t>(threadid / (blockDim.x * blockDim.y)) *
+                      m_scratch_size[1]),
+              m_scratch_size[1], league_rank, m_league_size),
+          value);
+    }
+  }
+
+  int compute_block_count() const {
+    constexpr auto light_weight =
+        Kokkos::Experimental::WorkItemProperty::HintLightWeight;
+    constexpr typename Policy::work_item_property property;
+    // Numbers were tuned on MI210 using dot product and yAx benchmarks
+    constexpr int block_max =
+        (property & light_weight) == light_weight ? 2097152 : 65536;
+    constexpr int preferred_block_min = 1024;
+    int block_count                   = m_league_size;
+    if (block_count < preferred_block_min) {
+      // keep blocks as is, already low parallelism
+    } else if (block_count >= block_max) {
+      block_count = block_max;
+
+    } else {
+      int nwork = m_league_size * m_team_size;
+      int items_per_thread =
+          (nwork + block_count * m_team_size - 1) / (block_count * m_team_size);
+      if (items_per_thread < 4) {
+        int ratio = std::min(
+            (block_count + preferred_block_min - 1) / preferred_block_min,
+            (4 + items_per_thread - 1) / items_per_thread);
+        block_count /= ratio;
+      }
+    }
+
+    return block_count;
+  }
+
+ public:
+  __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,
+                                       m_num_scratch_locks);
+    }
+
+    using ReductionTag = std::conditional_t<UseShflReduction, ShflReductionTag,
+                                            SHMEMReductionTag>;
+    run(ReductionTag{}, threadid);
+
+    if (m_scratch_size[1] > 0) {
+      hip_release_scratch_index(m_scratch_locks, threadid);
+    }
+  }
+
+  __device__ inline void run(SHMEMReductionTag, int const threadid) const {
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+
+    integral_nonzero_constant<size_type, ReducerType::static_value_size() /
+                                             sizeof(size_type)> const
+        word_count(reducer.value_size() / sizeof(size_type));
+
+    reference_type 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);
+
+    // Reduce with final value at blockDim.y - 1 location.
+    bool do_final_reduce = (m_league_size == 0);
+    if (!do_final_reduce)
+      do_final_reduce =
+          hip_single_inter_block_reduce_scan<false, FunctorType, work_tag>(
+              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
+
+      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;
+
+      if (threadIdx.y == 0) {
+        reducer.final(reinterpret_cast<value_type*>(shared));
+      }
+
+      if (HIPTraits::WarpSize < word_count.value) {
+        __syncthreads();
+      }
+
+      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
+        global[i] = shared[i];
+      }
+    }
+  }
+
+  __device__ inline void run(ShflReductionTag, int const threadid) const {
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+
+    value_type value;
+    reducer.init(&value);
+
+    // Iterate this block through the league
+    iterate_through_league(threadid, value);
+
+    pointer_type const result =
+        m_result_ptr_device_accessible
+            ? m_result_ptr
+            : reinterpret_cast<pointer_type>(m_scratch_space);
+
+    value_type init;
+    reducer.init(&init);
+    if (m_league_size == 0) {
+      reducer.final(&value);
+      *result = value;
+    } else if (Impl::hip_inter_block_shuffle_reduction(
+                   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) {
+        reducer.final(&value);
+        *result = value;
+      }
+    }
+  }
+
+  inline void execute() {
+    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 = 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 (!is_empty_range || need_device_set) {
+      int const block_count = compute_block_count();
+
+      m_scratch_space = hip_internal_scratch_space(
+          m_policy.space(), reducer.value_size() * block_count);
+      m_scratch_flags =
+          hip_internal_scratch_flags(m_policy.space(), sizeof(size_type));
+
+      dim3 block(m_vector_size, m_team_size, 1);
+      dim3 grid(block_count, 1, 1);
+      if (is_empty_range) {
+        block = dim3(1, 1, 1);
+        grid  = dim3(1, 1, 1);
+      }
+      const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
+
+      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
+
+      if (!m_result_ptr_device_accessible) {
+        m_policy.space().impl_internal_space_instance()->fence();
+
+        if (m_result_ptr) {
+          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) {
+        reducer.init(m_result_ptr);
+      }
+    }
+  }
+
+  template <class ViewType>
+  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_result_ptr(arg_result.data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<HIPSpace,
+                              typename ViewType::memory_space>::accessible),
+        m_result_ptr_host_accessible(
+            MemorySpaceAccess<Kokkos::HostSpace,
+                              typename ViewType::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.get_functor(),
+                                         arg_functor_reducer.get_reducer(),
+                                         ParallelReduceTag());
+
+    m_team_begin =
+        UseShflReduction
+            ? 0
+            : 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_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 {
+      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) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< HIP > bad team size"));
+    }
+
+    if (internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
+      Kokkos::Impl::throw_runtime_exception(
+          std::string("Kokkos::Impl::ParallelReduce< HIP > requested too much "
+                      "L0 scratch memory"));
+    }
+
+    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 "
+                      "large team size."));
+    }
+  }
+
+  ~ParallelReduce() {
+    if (m_scratch_pool_id >= 0) {
+      m_policy.space()
+          .impl_internal_space_instance()
+          ->release_team_scratch_space(m_scratch_pool_id);
+    }
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_Parallel_Range.hpp b/core/src/HIP/Kokkos_HIP_ParallelScan_Range.hpp
similarity index 53%
rename from core/src/HIP/Kokkos_HIP_Parallel_Range.hpp
rename to core/src/HIP/Kokkos_HIP_ParallelScan_Range.hpp
index 7b08832d3b..41692a3291 100644
--- a/core/src/HIP/Kokkos_HIP_Parallel_Range.hpp
+++ b/core/src/HIP/Kokkos_HIP_ParallelScan_Range.hpp
@@ -14,356 +14,18 @@
 //
 //@HEADER
 
-#ifndef KOKKO_HIP_PARALLEL_RANGE_HPP
-#define KOKKO_HIP_PARALLEL_RANGE_HPP
+#ifndef KOKKOS_HIP_PARALLEL_SCAN_RANGE_HPP
+#define KOKKOS_HIP_PARALLEL_SCAN_RANGE_HPP
 
 #include <Kokkos_Parallel.hpp>
 
-#if defined(__HIPCC__)
-
 #include <HIP/Kokkos_HIP_BlockSize_Deduction.hpp>
 #include <HIP/Kokkos_HIP_KernelLaunch.hpp>
 #include <HIP/Kokkos_HIP_ReduceScan.hpp>
-#include <HIP/Kokkos_HIP_Shuffle_Reduce.hpp>
-#include <impl/Kokkos_Traits.hpp>
 
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::HIP> {
- public:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-
- private:
-  using Member       = typename Policy::member_type;
-  using WorkTag      = typename Policy::work_tag;
-  using LaunchBounds = typename Policy::launch_bounds;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  ParallelFor()        = delete;
-  ParallelFor& operator=(const ParallelFor&) = delete;
-
-  template <class TagType>
-  inline __device__ std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const Member i) const {
-    m_functor(i);
-  }
-
-  template <class TagType>
-  inline __device__ std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const Member i) const {
-    m_functor(TagType(), i);
-  }
-
- public:
-  using functor_type = FunctorType;
-
-  inline __device__ void operator()() const {
-    const Member work_stride = blockDim.y * gridDim.x;
-    const Member work_end    = m_policy.end();
-
-    for (Member iwork =
-             m_policy.begin() + threadIdx.y + blockDim.y * blockIdx.x;
-         iwork < work_end;
-         iwork = iwork < work_end - work_stride ? iwork + work_stride
-                                                : work_end) {
-      this->template exec_range<WorkTag>(iwork);
-    }
-  }
-
-  inline void execute() const {
-    const typename Policy::index_type nwork = m_policy.end() - m_policy.begin();
-
-    using DriverType = ParallelFor<FunctorType, Policy, Kokkos::HIP>;
-    const int block_size =
-        Kokkos::Impl::hip_get_preferred_blocksize<DriverType, LaunchBounds>();
-    const dim3 block(1, block_size, 1);
-    const dim3 grid(
-        typename Policy::index_type((nwork + block.y - 1) / block.y), 1, 1);
-
-    if (block_size == 0) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelFor< HIP > could not find a "
-                      "valid execution configuration."));
-    }
-    Kokkos::Impl::hip_parallel_launch<DriverType, LaunchBounds>(
-        *this, grid, block, 0, m_policy.space().impl_internal_space_instance(),
-        false);
-  }
-
-  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-template <class CombinedFunctorReducerType, class... Traits>
-class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
-                     Kokkos::HIP> {
- public:
-  using Policy      = Kokkos::RangePolicy<Traits...>;
-  using FunctorType = typename CombinedFunctorReducerType::functor_type;
-  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
-
- private:
-  using WorkRange    = typename Policy::WorkRange;
-  using WorkTag      = typename Policy::work_tag;
-  using Member       = typename Policy::member_type;
-  using LaunchBounds = typename Policy::launch_bounds;
-
- public:
-  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;
-
-  // Algorithmic constraints: blockSize is a power of two AND blockDim.y ==
-  // blockDim.z == 1
-
-  const CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-  const bool m_result_ptr_device_accessible;
-  const bool m_result_ptr_host_accessible;
-  size_type* m_scratch_space = nullptr;
-  size_type* m_scratch_flags = nullptr;
-
-  static bool constexpr UseShflReduction =
-      static_cast<bool>(ReducerType::static_value_size());
-
- private:
-  struct ShflReductionTag {};
-  struct SHMEMReductionTag {};
-
-  // Make the exec_range calls call to Reduce::DeviceIterateTile
-  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_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_reducer.get_functor()(TagType(), i, update);
-  }
-
- public:
-  __device__ inline void operator()() const {
-    using ReductionTag = std::conditional_t<UseShflReduction, ShflReductionTag,
-                                            SHMEMReductionTag>;
-    run(ReductionTag{});
-  }
-
-  __device__ inline void run(SHMEMReductionTag) const {
-    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 = reducer.init(reinterpret_cast<pointer_type>(
-          ::Kokkos::kokkos_impl_hip_shared_memory<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 arithmetically
-      // equivalent.
-
-      const WorkRange range(m_policy, blockIdx.x, gridDim.x);
-
-      for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
-           iwork < iwork_end; iwork += blockDim.y) {
-        this->template exec_range<WorkTag>(iwork, value);
-      }
-    }
-
-    // Reduce with final value at blockDim.y - 1 location.
-    // Shortcut for length zero reduction
-    bool do_final_reduction = m_policy.begin() == m_policy.end();
-    if (!do_final_reduction)
-      do_final_reduction = hip_single_inter_block_reduce_scan<false>(
-          reducer, blockIdx.x, gridDim.x,
-          ::Kokkos::kokkos_impl_hip_shared_memory<size_type>(), m_scratch_space,
-          m_scratch_flags);
-    if (do_final_reduction) {
-      // This is the final block with the final result at the final threads'
-      // location
-
-      size_type* const shared =
-          ::Kokkos::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;
-
-      if (threadIdx.y == 0) {
-        reducer.final(reinterpret_cast<value_type*>(shared));
-      }
-
-      if (::Kokkos::Impl::HIPTraits::WarpSize < word_count.value) {
-        __syncthreads();
-      }
-
-      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
-        global[i] = shared[i];
-      }
-    }
-  }
-
-  __device__ inline void run(ShflReductionTag) const {
-    const ReducerType& reducer = m_functor_reducer.get_reducer();
-
-    value_type 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
-    // ordering does not match the final pass, but is arithmetically equivalent.
-
-    WorkRange const range(m_policy, blockIdx.x, gridDim.x);
-
-    for (Member iwork = range.begin() + threadIdx.y, iwork_end = range.end();
-         iwork < iwork_end; iwork += blockDim.y) {
-      this->template exec_range<WorkTag>(iwork, value);
-    }
-
-    pointer_type const result = reinterpret_cast<pointer_type>(m_scratch_space);
-
-    int max_active_thread = static_cast<int>(range.end() - range.begin()) <
-                                    static_cast<int>(blockDim.y)
-                                ? range.end() - range.begin()
-                                : blockDim.y;
-
-    max_active_thread =
-        (max_active_thread == 0) ? blockDim.y : max_active_thread;
-
-    value_type init;
-    reducer.init(&init);
-    if (m_policy.begin() == m_policy.end()) {
-      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, reducer, m_scratch_space, result,
-                   m_scratch_flags, max_active_thread)) {
-      unsigned int const id = threadIdx.y * blockDim.x + threadIdx.x;
-      if (id == 0) {
-        reducer.final(&value);
-        pointer_type const final_result =
-            m_result_ptr_device_accessible ? m_result_ptr : result;
-        *final_result = value;
-      }
-    }
-  }
-
-  // Determine block size constrained by shared memory:
-  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, WorkTag,
-                                                      value_type>(f, n);
-    };
-    return Kokkos::Impl::hip_get_preferred_blocksize<ParallelReduce,
-                                                     LaunchBounds>(
-        instance, shmem_functor);
-  }
-
-  inline void execute() {
-    const ReducerType& reducer = m_functor_reducer.get_reducer();
-
-    const index_type nwork     = m_policy.end() - m_policy.begin();
-    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_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(), reducer.value_size() * nblocks);
-      m_scratch_flags = ::Kokkos::Impl::hip_internal_scratch_flags(
-          m_policy.space(), sizeof(size_type));
-      // Required grid.x <= block.y
-      dim3 grid(nblocks, 1, 1);
-
-      if (nwork == 0) {
-        block = dim3(1, 1, 1);
-        grid  = dim3(1, 1, 1);
-      }
-      const int shmem =
-          UseShflReduction
-              ? 0
-              : hip_single_inter_block_reduce_scan_shmem<false, WorkTag,
-                                                         value_type>(
-                    m_functor_reducer.get_functor(), block.y);
-
-      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 = reducer.value_size();
-        DeepCopy<HostSpace, HIPSpace, HIP>(m_policy.space(), m_result_ptr,
-                                           m_scratch_space, size);
-      }
-    } else {
-      if (m_result_ptr) {
-        reducer.init(m_result_ptr);
-      }
-    }
-  }
-
-  template <class ViewType>
-  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_result_ptr(arg_result.data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<HIPSpace,
-                              typename ViewType::memory_space>::accessible),
-        m_result_ptr_host_accessible(
-            MemorySpaceAccess<Kokkos::HostSpace,
-                              typename ViewType::memory_space>::accessible) {}
-};
-
 template <class FunctorType, class ValueType, class... Traits>
 class ParallelScanHIPBase {
  public:
@@ -729,5 +391,3 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
 }  // namespace Kokkos
 
 #endif
-
-#endif
diff --git a/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp b/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp
deleted file mode 100644
index 0d75c3ca86..0000000000
--- a/core/src/HIP/Kokkos_HIP_Parallel_Team.hpp
+++ /dev/null
@@ -1,902 +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 KOKKO_HIP_PARALLEL_TEAM_HPP
-#define KOKKO_HIP_PARALLEL_TEAM_HPP
-
-#include <Kokkos_Parallel.hpp>
-
-#if defined(__HIPCC__)
-
-#include <HIP/Kokkos_HIP_KernelLaunch.hpp>
-#include <HIP/Kokkos_HIP_Team.hpp>
-#include <HIP/Kokkos_HIP_Instance.hpp>
-#include <Kokkos_MinMaxClamp.hpp>
-
-namespace Kokkos {
-namespace Impl {
-
-template <typename... Properties>
-class TeamPolicyInternal<HIP, Properties...>
-    : public PolicyTraits<Properties...> {
- public:
-  using execution_policy = TeamPolicyInternal;
-
-  using traits = PolicyTraits<Properties...>;
-
-  template <typename ExecSpace, typename... OtherProperties>
-  friend class TeamPolicyInternal;
-
- private:
-  typename traits::execution_space m_space;
-  int m_league_size;
-  int m_team_size;
-  int m_vector_length;
-  size_t m_team_scratch_size[2];
-  size_t m_thread_scratch_size[2];
-  int m_chunk_size;
-  bool m_tune_team_size;
-  bool m_tune_vector_length;
-
- public:
-  using execution_space = HIP;
-
-  template <class... OtherProperties>
-  TeamPolicyInternal(TeamPolicyInternal<OtherProperties...> const& p) {
-    m_league_size            = p.m_league_size;
-    m_team_size              = p.m_team_size;
-    m_vector_length          = p.m_vector_length;
-    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
-    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
-    m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size             = p.m_chunk_size;
-    m_space                  = p.m_space;
-    m_tune_team_size         = p.m_tune_team_size;
-    m_tune_vector_length     = p.m_tune_vector_length;
-  }
-
-  template <typename FunctorType>
-  int team_size_max(FunctorType const& f, ParallelForTag const&) const {
-    using closure_type =
-        Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
-
-    return internal_team_size_common<BlockType::Max, closure_type, void>(f);
-  }
-
-  template <class FunctorType>
-  inline int team_size_max(const FunctorType& f,
-                           const ParallelReduceTag&) const {
-    using functor_analysis_type =
-        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                              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<CombinedFunctorReducer<FunctorType, ReducerType>,
-                             TeamPolicy<Properties...>, Kokkos::HIP>;
-    return internal_team_size_common<BlockType::Max, closure_type,
-                                     typename ReducerType::value_type>(f);
-  }
-
-  template <typename FunctorType>
-  int team_size_recommended(FunctorType const& f, ParallelForTag const&) const {
-    using closure_type =
-        Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
-
-    return internal_team_size_common<BlockType::Preferred, closure_type, void>(
-        f);
-  }
-
-  template <typename FunctorType>
-  inline int team_size_recommended(FunctorType const& f,
-                                   ParallelReduceTag const&) const {
-    using functor_analysis_type =
-        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
-                              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<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; }
-  inline bool impl_auto_team_size() const { return m_tune_team_size; }
-  static int vector_length_max() { return HIPTraits::WarpSize; }
-
-  static int verify_requested_vector_length(int requested_vector_length) {
-    int test_vector_length =
-        std::min(requested_vector_length, vector_length_max());
-
-    // Allow only power-of-two vector_length
-    if (!(is_integral_power_of_two(test_vector_length))) {
-      int test_pow2           = 1;
-      int constexpr warp_size = HIPTraits::WarpSize;
-      while (test_pow2 < warp_size) {
-        test_pow2 <<= 1;
-        if (test_pow2 > test_vector_length) {
-          break;
-        }
-      }
-      test_vector_length = test_pow2 >> 1;
-    }
-
-    return test_vector_length;
-  }
-
-  inline static int scratch_size_max(int level) {
-    // HIP Teams use (team_size + 2)*sizeof(double) shared memory for team
-    // reductions. They also use one int64_t in static shared memory for a
-    // shared ID. Furthermore, they use additional scratch memory in some
-    // reduction scenarios, which depend on the size of the value_type and is
-    // NOT captured here
-    constexpr size_t max_possible_team_size = 1024;
-    constexpr size_t max_reserved_shared_mem_per_team =
-        (max_possible_team_size + 2) * sizeof(double) + sizeof(int64_t);
-    // arbitrarily setting level 1 scratch limit to 20MB, for a
-    // MI250 that would give us about 4.4GB for 2 teams per CU
-    constexpr size_t max_l1_scratch_size = 20 * 1024 * 1024;
-
-    size_t max_shmem = HIP().hip_device_prop().sharedMemPerBlock;
-    return (level == 0 ? max_shmem - max_reserved_shared_mem_per_team
-                       : max_l1_scratch_size);
-  }
-
-  inline void impl_set_vector_length(size_t size) { m_vector_length = size; }
-  inline void impl_set_team_size(size_t size) { m_team_size = size; }
-  int impl_vector_length() const { return m_vector_length; }
-
-  int team_size() const { return m_team_size; }
-
-  int league_size() const { return m_league_size; }
-
-  size_t scratch_size(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];
-  }
-
-  size_t team_scratch_size(int level) const {
-    return m_team_scratch_size[level];
-  }
-
-  size_t thread_scratch_size(int level) const {
-    return m_thread_scratch_size[level];
-  }
-
-  typename traits::execution_space space() const { return m_space; }
-
-  TeamPolicyInternal()
-      : m_space(typename traits::execution_space()),
-        m_league_size(0),
-        m_team_size(-1),
-        m_vector_length(0),
-        m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(HIPTraits::WarpSize),
-        m_tune_team_size(false),
-        m_tune_vector_length(false) {}
-
-  /** \brief  Specify league size, request team size */
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     int team_size_request, int vector_length_request = 1)
-      : m_space(space_),
-        m_league_size(league_size_),
-        m_team_size(team_size_request),
-        m_vector_length(
-            (vector_length_request > 0)
-                ? verify_requested_vector_length(vector_length_request)
-                : (verify_requested_vector_length(1))),
-        m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(HIPTraits::WarpSize),
-        m_tune_team_size(bool(team_size_request <= 0)),
-        m_tune_vector_length(bool(vector_length_request <= 0)) {
-    // Make sure league size is permissible
-    if (league_size_ >= static_cast<int>(hip_internal_maximum_grid_count()[0]))
-      Impl::throw_runtime_exception(
-          "Requested too large league_size for TeamPolicy on HIP execution "
-          "space.");
-
-    // Make sure total block size is permissible
-    if (m_team_size * m_vector_length > HIPTraits::MaxThreadsPerBlock) {
-      Impl::throw_runtime_exception(
-          std::string("Kokkos::TeamPolicy< HIP > the team size is too large. "
-                      "Team size x vector length must be smaller than 1024."));
-    }
-  }
-
-  /** \brief  Specify league size, request team size */
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     int vector_length_request = 1)
-      : TeamPolicyInternal(space_, league_size_, -1, vector_length_request) {}
-  // FLAG
-  /** \brief  Specify league size and team size, request vector length*/
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     int team_size_request,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-                     )
-      : TeamPolicyInternal(space_, league_size_, team_size_request, -1)
-
-  {}
-
-  /** \brief  Specify league size, request team size and vector length*/
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-
-                     )
-      : TeamPolicyInternal(space_, league_size_, -1, -1)
-
-  {}
-
-  TeamPolicyInternal(int league_size_, int team_size_request,
-                     int vector_length_request = 1)
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
-                           team_size_request, vector_length_request) {}
-
-  TeamPolicyInternal(int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     int vector_length_request = 1)
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
-                           vector_length_request) {}
-
-  /** \brief  Specify league size and team size, request vector length*/
-  TeamPolicyInternal(int league_size_, int team_size_request,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-
-                     )
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
-                           team_size_request, -1)
-
-  {}
-
-  /** \brief  Specify league size, request team size and vector length*/
-  TeamPolicyInternal(int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-
-                     )
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
-                           -1) {}
-
-  int chunk_size() const { return m_chunk_size; }
-
-  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 */
-  TeamPolicyInternal& set_scratch_size(int level,
-                                       PerTeamValue const& 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 */
-  TeamPolicyInternal& set_scratch_size(int level,
-                                       PerThreadValue const& 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 */
-  TeamPolicyInternal& set_scratch_size(int level, PerTeamValue const& per_team,
-                                       PerThreadValue const& per_thread) {
-    m_team_scratch_size[level]   = per_team.value;
-    m_thread_scratch_size[level] = per_thread.value;
-    return *this;
-  }
-
-  using member_type = Kokkos::Impl::HIPTeamMember;
-
- protected:
-  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);
-    using Tag = typename PatternTagFromImplSpecialization<ClosureType>::type;
-    if constexpr (std::is_same_v<Tag, ParallelReduceTag>) {
-      using Interface =
-          typename Impl::DeduceFunctorPatternInterface<ClosureType>::type;
-      using Analysis =
-          Impl::FunctorAnalysis<Interface, typename ClosureType::Policy,
-                                FunctorType, ValueType>;
-      shmem_thread +=
-          ((Analysis::StaticValueSize != 0) ? 0 : Analysis::value_size(f));
-    }
-    const int vector_length = impl_vector_length();
-
-    const auto functor = [&f, shmem_block, shmem_thread, vector_length](
-                             const hipFuncAttributes& attr, int block_size) {
-      int functor_shmem =
-          ::Kokkos::Impl::FunctorTeamShmemSize<FunctorType>::value(
-              f, block_size / vector_length);
-      return shmem_block + shmem_thread * (block_size / vector_length) +
-             functor_shmem + attr.sharedSizeBytes;
-    };
-    int block_size;
-    if constexpr (BlockSize == BlockType::Max) {
-      block_size = hip_get_max_team_blocksize<ClosureType,
-                                              typename traits::launch_bounds>(
-          space().impl_internal_space_instance(), functor);
-    } else {
-      block_size =
-          hip_get_preferred_team_blocksize<ClosureType,
-                                           typename traits::launch_bounds>(
-              space().impl_internal_space_instance(), functor);
-    }
-
-    if (block_size == 0) {
-      Kokkos::Impl::throw_runtime_exception(std::string(
-          "Kokkos::Impl::ParallelFor/Reduce< HIP > could not find a valid "
-          "team size."));
-    }
-    if constexpr (std::is_same_v<Tag, ParallelForTag>) {
-      return block_size / impl_vector_length();
-    } else {
-      // Currently we require Power-of-2 team size for reductions.
-      int p2 = 1;
-      while (p2 <= block_size) p2 *= 2;
-      p2 /= 2;
-      return p2 / impl_vector_length();
-    }
-  }
-};
-
-__device__ inline int64_t hip_get_scratch_index(HIP::size_type league_size,
-                                                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(num_scratch_locks) / (blockDim.x * blockDim.y));
-    threadid = (blockIdx.x * blockDim.z + threadIdx.z) % wraparound_len;
-    threadid *= blockDim.x * blockDim.y;
-    int done = 0;
-    while (!done) {
-      done = (0 == atomicCAS(&scratch_locks[threadid], 0, 1));
-      if (!done) {
-        threadid += blockDim.x * blockDim.y;
-        if (int64_t(threadid + blockDim.x * blockDim.y) >=
-            wraparound_len * blockDim.x * blockDim.y)
-          threadid = 0;
-      }
-    }
-    base_thread_id = threadid;
-  }
-  __syncthreads();
-  threadid = base_thread_id;
-  return threadid;
-}
-
-__device__ inline void hip_release_scratch_index(int32_t* scratch_locks,
-                                                 int64_t threadid) {
-  __syncthreads();
-  if (threadIdx.x == 0 && threadIdx.y == 0) {
-    scratch_locks[threadid] = 0;
-  }
-}
-
-template <typename FunctorType, typename... Properties>
-class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP> {
- public:
-  using Policy       = TeamPolicyInternal<HIP, Properties...>;
-  using functor_type = FunctorType;
-  using size_type    = HIP::size_type;
-
- private:
-  using member_type   = typename Policy::member_type;
-  using work_tag      = typename Policy::work_tag;
-  using launch_bounds = typename Policy::launch_bounds;
-
-  // Algorithmic constraints: blockDim.y is a power of two AND
-  // blockDim.y  == blockDim.z == 1 shared memory utilization:
-  //
-  //  [ team   reduce space ]
-  //  [ team   shared space ]
-
-  FunctorType const m_functor;
-  Policy const m_policy;
-  size_type const m_league_size;
-  int m_team_size;
-  size_type const m_vector_size;
-  int m_shmem_begin;
-  int m_shmem_size;
-  void* m_scratch_ptr[2];
-  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(
-      const member_type& member) const {
-    m_functor(member);
-  }
-
-  template <typename TagType>
-  __device__ inline std::enable_if_t<!std::is_void<TagType>::value> exec_team(
-      const member_type& member) const {
-    m_functor(TagType(), member);
-  }
-
- public:
-  __device__ inline void operator()() const {
-    // 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,
-                                       m_num_scratch_locks);
-    }
-
-    int const int_league_size = static_cast<int>(m_league_size);
-    for (int league_rank = blockIdx.x; league_rank < int_league_size;
-         league_rank += gridDim.x) {
-      this->template exec_team<work_tag>(typename Policy::member_type(
-          kokkos_impl_hip_shared_memory<void>(), m_shmem_begin, m_shmem_size,
-          static_cast<void*>(static_cast<char*>(m_scratch_ptr[1]) +
-                             ptrdiff_t(threadid / (blockDim.x * blockDim.y)) *
-                                 m_scratch_size[1]),
-          m_scratch_size[1], league_rank, m_league_size));
-    }
-    if (m_scratch_size[1] > 0) {
-      hip_release_scratch_index(m_scratch_locks, threadid);
-    }
-  }
-
-  inline void execute() const {
-    int64_t const shmem_size_total = m_shmem_begin + m_shmem_size;
-    dim3 const grid(static_cast<int>(m_league_size), 1, 1);
-    dim3 const block(static_cast<int>(m_vector_size),
-                     static_cast<int>(m_team_size), 1);
-
-    using closure_type =
-        ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>, HIP>;
-    Impl::hip_parallel_launch<closure_type, launch_bounds>(
-        *this, grid, block, shmem_size_total,
-        m_policy.space().impl_internal_space_instance(),
-        true);  // copy to device and execute
-  }
-
-  ParallelFor(FunctorType const& arg_functor, Policy const& arg_policy)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        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, ParallelForTag());
-
-    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_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.
-    m_scratch_ptr[0] = nullptr;
-    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))));
-    }
-
-    int const shmem_size_total = m_shmem_begin + m_shmem_size;
-    if (internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
-      Kokkos::Impl::throw_runtime_exception(std::string(
-          "Kokkos::Impl::ParallelFor< HIP > insufficient shared memory"));
-    }
-
-    size_t max_size = arg_policy.team_size_max(arg_functor, ParallelForTag());
-    if (static_cast<int>(m_team_size) > static_cast<int>(max_size)) {
-      Kokkos::Impl::throw_runtime_exception(std::string(
-          "Kokkos::Impl::ParallelFor< HIP > requested too large team size."));
-    }
-  }
-
-  ~ParallelFor() {
-    if (m_scratch_pool_id >= 0) {
-      m_policy.space()
-          .impl_internal_space_instance()
-          ->release_team_scratch_space(m_scratch_pool_id);
-    }
-  }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-template <class CombinedFunctorReducerType, class... Properties>
-class ParallelReduce<CombinedFunctorReducerType,
-                     Kokkos::TeamPolicy<Properties...>, HIP> {
- public:
-  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 pointer_type   = typename ReducerType::pointer_type;
-  using reference_type = typename ReducerType::reference_type;
-  using value_type     = typename ReducerType::value_type;
-
- public:
-  using size_type = HIP::size_type;
-
-  static int constexpr UseShflReduction =
-      (ReducerType::static_value_size() != 0);
-
- private:
-  struct ShflReductionTag {};
-  struct SHMEMReductionTag {};
-
-  // Algorithmic constraints: blockDim.y is a power of two AND
-  // blockDim.y == blockDim.z == 1 shared memory utilization:
-  //
-  //  [ global reduce space ]
-  //  [ team   reduce space ]
-  //  [ team   shared space ]
-  //
-
-  const CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-  const bool m_result_ptr_device_accessible;
-  const bool m_result_ptr_host_accessible;
-  size_type* m_scratch_space;
-  size_type* m_scratch_flags;
-  size_type m_team_begin;
-  size_type m_shmem_begin;
-  size_type m_shmem_size;
-  void* m_scratch_ptr[2];
-  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;
-
-  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_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_reducer.get_functor()(TagType(), member, update);
-  }
-
-  __device__ inline void iterate_through_league(int const threadid,
-                                                reference_type value) const {
-    int const int_league_size = static_cast<int>(m_league_size);
-    for (int league_rank = blockIdx.x; league_rank < int_league_size;
-         league_rank += gridDim.x) {
-      this->template exec_team<work_tag>(
-          member_type(
-              kokkos_impl_hip_shared_memory<char>() + m_team_begin,
-              m_shmem_begin, m_shmem_size,
-              reinterpret_cast<void*>(
-                  reinterpret_cast<char*>(m_scratch_ptr[1]) +
-                  static_cast<ptrdiff_t>(threadid / (blockDim.x * blockDim.y)) *
-                      m_scratch_size[1]),
-              m_scratch_size[1], league_rank, m_league_size),
-          value);
-    }
-  }
-
- public:
-  __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,
-                                       m_num_scratch_locks);
-    }
-
-    using ReductionTag = std::conditional_t<UseShflReduction, ShflReductionTag,
-                                            SHMEMReductionTag>;
-    run(ReductionTag{}, threadid);
-
-    if (m_scratch_size[1] > 0) {
-      hip_release_scratch_index(m_scratch_locks, threadid);
-    }
-  }
-
-  __device__ inline void run(SHMEMReductionTag, int const threadid) const {
-    const ReducerType& reducer = m_functor_reducer.get_reducer();
-
-    integral_nonzero_constant<size_type, ReducerType::static_value_size() /
-                                             sizeof(size_type)> const
-        word_count(reducer.value_size() / sizeof(size_type));
-
-    reference_type 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);
-
-    // Reduce with final value at blockDim.y - 1 location.
-    bool do_final_reduce = (m_league_size == 0);
-    if (!do_final_reduce)
-      do_final_reduce =
-          hip_single_inter_block_reduce_scan<false, FunctorType, work_tag>(
-              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
-
-      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;
-
-      if (threadIdx.y == 0) {
-        reducer.final(reinterpret_cast<value_type*>(shared));
-      }
-
-      if (HIPTraits::WarpSize < word_count.value) {
-        __syncthreads();
-      }
-
-      for (unsigned i = threadIdx.y; i < word_count.value; i += blockDim.y) {
-        global[i] = shared[i];
-      }
-    }
-  }
-
-  __device__ inline void run(ShflReductionTag, int const threadid) const {
-    const ReducerType& reducer = m_functor_reducer.get_reducer();
-
-    value_type value;
-    reducer.init(&value);
-
-    // Iterate this block through the league
-    iterate_through_league(threadid, value);
-
-    pointer_type const result =
-        m_result_ptr_device_accessible
-            ? m_result_ptr
-            : reinterpret_cast<pointer_type>(m_scratch_space);
-
-    value_type init;
-    reducer.init(&init);
-    if (m_league_size == 0) {
-      reducer.final(&value);
-      *result = value;
-    } else if (Impl::hip_inter_block_shuffle_reduction(
-                   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) {
-        reducer.final(&value);
-        *result = value;
-      }
-    }
-  }
-
-  inline void execute() {
-    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 = 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) {
-      const int block_count =
-          UseShflReduction
-              ? std::min(m_league_size, size_type(1024 * HIPTraits::WarpSize))
-              : std::min(static_cast<int>(m_league_size), m_team_size);
-
-      m_scratch_space = hip_internal_scratch_space(
-          m_policy.space(), reducer.value_size() * block_count);
-      m_scratch_flags =
-          hip_internal_scratch_flags(m_policy.space(), sizeof(size_type));
-
-      dim3 block(m_vector_size, m_team_size, 1);
-      dim3 grid(block_count, 1, 1);
-      if (is_empty_range) {
-        block = dim3(1, 1, 1);
-        grid  = dim3(1, 1, 1);
-      }
-      const int shmem_size_total = m_team_begin + m_shmem_begin + m_shmem_size;
-
-      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
-
-      if (!m_result_ptr_device_accessible) {
-        m_policy.space().impl_internal_space_instance()->fence();
-
-        if (m_result_ptr) {
-          const int size = reducer.value_size();
-          DeepCopy<HostSpace, HIPSpace>(m_result_ptr, m_scratch_space, size);
-        }
-      }
-    } else {
-      if (m_result_ptr) {
-        reducer.init(m_result_ptr);
-      }
-    }
-  }
-
-  template <class ViewType>
-  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_result_ptr(arg_result.data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<HIPSpace,
-                              typename ViewType::memory_space>::accessible),
-        m_result_ptr_host_accessible(
-            MemorySpaceAccess<Kokkos::HostSpace,
-                              typename ViewType::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.get_functor(),
-                                         arg_functor_reducer.get_reducer(),
-                                         ParallelReduceTag());
-
-    m_team_begin =
-        UseShflReduction
-            ? 0
-            : 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_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 {
-      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) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelReduce< HIP > bad team size"));
-    }
-
-    if (internal_space_instance->m_maxShmemPerBlock < shmem_size_total) {
-      Kokkos::Impl::throw_runtime_exception(
-          std::string("Kokkos::Impl::ParallelReduce< HIP > requested too much "
-                      "L0 scratch memory"));
-    }
-
-    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 "
-                      "large team size."));
-    }
-  }
-
-  ~ParallelReduce() {
-    if (m_scratch_pool_id >= 0) {
-      m_policy.space()
-          .impl_internal_space_instance()
-          ->release_team_scratch_space(m_scratch_pool_id);
-    }
-  }
-};
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif
-
-#endif
diff --git a/core/src/HIP/Kokkos_HIP_ReduceScan.hpp b/core/src/HIP/Kokkos_HIP_ReduceScan.hpp
index a533d41537..b9226fc264 100644
--- a/core/src/HIP/Kokkos_HIP_ReduceScan.hpp
+++ b/core/src/HIP/Kokkos_HIP_ReduceScan.hpp
@@ -58,7 +58,7 @@ struct HIPReductionsFunctor<FunctorType, true> {
       FunctorType const& functor, Scalar value, bool const skip,
       Scalar* my_global_team_buffer_element, int const shared_elements,
       Scalar* shared_team_buffer_element) {
-    unsigned int constexpr warp_size = HIPTraits::WarpSize;
+    constexpr unsigned int warp_size = HIPTraits::WarpSize;
     int const warp_id                = (threadIdx.y * blockDim.x) / warp_size;
     Scalar* const my_shared_team_buffer_element =
         shared_team_buffer_element + warp_id % shared_elements;
@@ -90,6 +90,7 @@ struct HIPReductionsFunctor<FunctorType, true> {
       }
       scalar_intra_warp_reduction(functor, value, false, warp_size,
                                   *my_global_team_buffer_element);
+      __threadfence();
     }
   }
 
@@ -104,7 +105,7 @@ struct HIPReductionsFunctor<FunctorType, true> {
     Scalar* shared_team_buffer_elements =
         reinterpret_cast<Scalar*>(shared_data);
     Scalar value                     = shared_team_buffer_elements[threadIdx.y];
-    unsigned int constexpr warp_size = Impl::HIPTraits::WarpSize;
+    constexpr unsigned int warp_size = Impl::HIPTraits::WarpSize;
     int shared_elements              = blockDim.x * blockDim.y / warp_size;
     int global_elements              = block_count;
     __syncthreads();
@@ -116,16 +117,12 @@ struct HIPReductionsFunctor<FunctorType, true> {
 
     // Use the last block that is done to do the do the reduction across the
     // block
-    __shared__ unsigned int num_teams_done;
+    unsigned int num_teams_done = 0;
     if (threadIdx.x + threadIdx.y == 0) {
       num_teams_done = Kokkos::atomic_fetch_add(global_flags, 1) + 1;
     }
     bool is_last_block = false;
-    // FIXME_HIP HIP does not support syncthreads_or. That's why we need to make
-    // num_teams_done __shared__
-    // if (__syncthreads_or(num_teams_done == gridDim.x)) {*/
-    __syncthreads();
-    if (num_teams_done == gridDim.x) {
+    if (__syncthreads_or(num_teams_done == gridDim.x)) {
       is_last_block = true;
       *global_flags = 0;
       functor.init(&value);
@@ -157,7 +154,8 @@ struct HIPReductionsFunctor<FunctorType, false> {
     int const lane_id =
         (threadIdx.y * blockDim.x + threadIdx.x) % HIPTraits::WarpSize;
     for (int delta = skip_vector ? blockDim.x : 1; delta < width; delta *= 2) {
-      if (lane_id + delta < HIPTraits::WarpSize) {
+      if (lane_id + delta < HIPTraits::WarpSize &&
+          (lane_id % (delta * 2) == 0)) {
         functor.join(value, value + delta);
       }
     }
@@ -186,7 +184,10 @@ struct HIPReductionsFunctor<FunctorType, false> {
       scalar_intra_warp_reduction(
           functor, my_shared_team_buffer_element, false,
           blockDim.x * blockDim.y / HIPTraits::WarpSize);
-      if (threadIdx.x + threadIdx.y == 0) *result = *shared_team_buffer_element;
+      if (threadIdx.x + threadIdx.y == 0) {
+        *result = *shared_team_buffer_element;
+        if (skip) __threadfence();
+      }
     }
   }
 
@@ -214,16 +215,12 @@ struct HIPReductionsFunctor<FunctorType, false> {
 
     // Use the last block that is done to do the do the reduction across the
     // block
-    __shared__ unsigned int num_teams_done;
+    unsigned int num_teams_done = 0;
     if (threadIdx.x + threadIdx.y == 0) {
       num_teams_done = Kokkos::atomic_fetch_add(global_flags, 1) + 1;
     }
     bool is_last_block = false;
-    // FIXME_HIP HIP does not support syncthreads_or. That's why we need to make
-    // num_teams_done __shared__
-    // if (__syncthreads_or(num_teams_done == gridDim.x)) {*/
-    __syncthreads();
-    if (num_teams_done == gridDim.x) {
+    if (__syncthreads_or(num_teams_done == gridDim.x)) {
       is_last_block = true;
       *global_flags = 0;
       functor.init(&value);
@@ -390,25 +387,16 @@ __device__ bool hip_single_inter_block_reduce_scan_impl(
     for (size_t i = threadIdx.y; i < word_count.value; i += blockDim.y) {
       global[i] = shared[i];
     }
+    __threadfence();
   }
 
   // Contributing blocks note that their contribution has been completed via an
   // atomic-increment flag If this block is not the last block to contribute to
   // this group then the block is done.
-  // FIXME_HIP __syncthreads_or is not supported by HIP yet.
-  // const bool is_last_block = !__syncthreads_or(
-  //    threadIdx.y
-  //        ? 0
-  //        : (1 + atomicInc(global_flags, block_count - 1) < block_count));
-  __shared__ int n_done;
-  n_done = 0;
-  __syncthreads();
-  if (threadIdx.y == 0) {
-    n_done = 1 + atomicInc(global_flags, block_count - 1);
-  }
-  __syncthreads();
-  bool const is_last_block = (n_done == static_cast<int>(block_count));
-
+  const bool is_last_block = !__syncthreads_or(
+      threadIdx.y
+          ? 0
+          : (1 + atomicInc(global_flags, block_count - 1) < block_count));
   if (is_last_block) {
     size_type const b = (static_cast<long long int>(block_count) *
                          static_cast<long long int>(threadIdx.y)) >>
diff --git a/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.cpp b/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.cpp
index ea599989e7..83f829fdda 100644
--- a/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.cpp
+++ b/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.cpp
@@ -18,138 +18,18 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE
 #endif
 
-#include <HIP/Kokkos_HIP_SharedAllocationRecord.hpp>
-#include <HIP/Kokkos_HIP_DeepCopy.hpp>
 #include <HIP/Kokkos_HIP.hpp>
+#include <HIP/Kokkos_HIP_DeepCopy.hpp>
+#include <HIP/Kokkos_HIP_SharedAllocationRecord.hpp>
+#include <impl/Kokkos_SharedAlloc_timpl.hpp>
 
-namespace Kokkos {
-namespace Impl {
-
-#ifdef KOKKOS_ENABLE_DEBUG
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<HIPSpace, void>::s_root_record;
-
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<HIPHostPinnedSpace, void>::s_root_record;
-
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<HIPManagedSpace, void>::s_root_record;
-#endif
-
-SharedAllocationRecord<HIPSpace, void>::~SharedAllocationRecord() {
-  auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     alloc_size, (alloc_size - sizeof(SharedAllocationHeader)));
-}
-
-SharedAllocationRecord<HIPHostPinnedSpace, void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     SharedAllocationRecord<void, void>::m_alloc_size);
-}
-
-SharedAllocationRecord<HIPManagedSpace, void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     SharedAllocationRecord<void, void>::m_alloc_size);
-}
-
-SharedAllocationRecord<HIPSpace, void>::SharedAllocationRecord(
-    const HIPSpace& arg_space, const std::string& arg_label,
-    const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<HIPSpace, void>::s_root_record,
-#endif
-          Kokkos::Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                       arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  // Copy to device memory
-  HIP exec;
-  Kokkos::Impl::DeepCopy<HIPSpace, HostSpace>(
-      exec, RecordBase::m_alloc_ptr, &header, sizeof(SharedAllocationHeader));
-  exec.fence(
-      "SharedAllocationRecord<Kokkos::HIPSpace, "
-      "void>::SharedAllocationRecord(): fence after copying header from "
-      "HostSpace");
-}
-
-SharedAllocationRecord<HIPSpace, void>::SharedAllocationRecord(
-    const HIP& arg_exec_space, const HIPSpace& arg_space,
-    const std::string& arg_label, const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<HIPSpace, void>::s_root_record,
-#endif
-          Kokkos::Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                       arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  // Copy to device memory
-  Kokkos::Impl::DeepCopy<HIPSpace, HostSpace>(arg_exec_space,
-                                              RecordBase::m_alloc_ptr, &header,
-                                              sizeof(SharedAllocationHeader));
-}
-
-SharedAllocationRecord<HIPHostPinnedSpace, void>::SharedAllocationRecord(
-    const HIPHostPinnedSpace& arg_space, const std::string& arg_label,
-    const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<HIPHostPinnedSpace, void>::s_root_record,
-#endif
-          Kokkos::Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                       arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  // Fill in the Header information, directly accessible via host pinned memory
-  this->base_t::_fill_host_accessible_header_info(*RecordBase::m_alloc_ptr,
-                                                  arg_label);
-}
-
-SharedAllocationRecord<HIPManagedSpace, void>::SharedAllocationRecord(
-    const HIPManagedSpace& arg_space, const std::string& arg_label,
-    const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<HIPManagedSpace, void>::s_root_record,
+#ifndef KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::HIPSpace);
+#else
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(Kokkos::HIPSpace);
 #endif
-          Kokkos::Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                       arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  // Fill in the Header information, directly accessible via managed memory
-  this->base_t::_fill_host_accessible_header_info(*RecordBase::m_alloc_ptr,
-                                                  arg_label);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::HIPHostPinnedSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::HIPManagedSpace);
diff --git a/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.hpp b/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.hpp
index e68bad9723..1ca7bd5cd0 100644
--- a/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.hpp
+++ b/core/src/HIP/Kokkos_HIP_SharedAllocationRecord.hpp
@@ -18,120 +18,15 @@
 #define KOKKOS_HIP_SHARED_ALLOCATION_RECORD_HPP
 
 #include <HIP/Kokkos_HIP_Space.hpp>
+#include <impl/Kokkos_SharedAlloc.hpp>
 
-namespace Kokkos {
-namespace Impl {
-
-template <>
-class SharedAllocationRecord<HIPSpace, void>
-    : public HostInaccessibleSharedAllocationRecordCommon<HIPSpace> {
- private:
-  friend class SharedAllocationRecordCommon<HIPSpace>;
-  friend class HostInaccessibleSharedAllocationRecordCommon<HIPSpace>;
-  using base_t     = HostInaccessibleSharedAllocationRecordCommon<HIPSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  static RecordBase s_root_record;
-#endif
-
-  const HIPSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec*/, const HIPSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const HIP& exec_space, const HIPSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
-  SharedAllocationRecord(
-      const HIPSpace& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-
-template <>
-class SharedAllocationRecord<HIPHostPinnedSpace, void>
-    : public SharedAllocationRecordCommon<HIPHostPinnedSpace> {
- private:
-  friend class SharedAllocationRecordCommon<HIPHostPinnedSpace>;
-  using base_t     = SharedAllocationRecordCommon<HIPHostPinnedSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  static RecordBase s_root_record;
+#if defined(KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY)
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(Kokkos::HIPSpace);
+#else
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::HIPSpace);
 #endif
-
-  const HIPHostPinnedSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/, const HIPHostPinnedSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const HIPHostPinnedSpace& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-
-template <>
-class SharedAllocationRecord<HIPManagedSpace, void>
-    : public SharedAllocationRecordCommon<HIPManagedSpace> {
- private:
-  friend class SharedAllocationRecordCommon<HIPManagedSpace>;
-  using base_t     = SharedAllocationRecordCommon<HIPManagedSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  static RecordBase s_root_record;
-#endif
-
-  const HIPManagedSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/, const HIPManagedSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const HIPManagedSpace& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-}  // namespace Impl
-}  // namespace Kokkos
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(Kokkos::HIPHostPinnedSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(Kokkos::HIPManagedSpace);
 
 #endif
diff --git a/core/src/HIP/Kokkos_HIP_Shuffle_Reduce.hpp b/core/src/HIP/Kokkos_HIP_Shuffle_Reduce.hpp
index cca5e9ff26..4035bb0121 100644
--- a/core/src/HIP/Kokkos_HIP_Shuffle_Reduce.hpp
+++ b/core/src/HIP/Kokkos_HIP_Shuffle_Reduce.hpp
@@ -40,7 +40,7 @@ __device__ inline void hip_intra_warp_shuffle_reduction(
   unsigned int shift = 1;
 
   // Reduce over values from threads with different threadIdx.y
-  unsigned int constexpr warp_size = HIPTraits::WarpSize;
+  constexpr unsigned int warp_size = HIPTraits::WarpSize;
   while (blockDim.x * shift < warp_size) {
     ValueType const tmp = shfl_down(result, blockDim.x * shift, warp_size);
     // Only join if upper thread is active (this allows non power of two for
@@ -59,8 +59,8 @@ template <typename ValueType, typename ReducerType>
 __device__ inline void hip_inter_warp_shuffle_reduction(
     ValueType& value, const ReducerType& reducer,
     const int max_active_thread = blockDim.y) {
-  unsigned int constexpr warp_size = HIPTraits::WarpSize;
-  int constexpr step_width         = 8;
+  constexpr unsigned int warp_size = HIPTraits::WarpSize;
+  constexpr int step_width         = 8;
   // Depending on the ValueType __shared__ memory must be aligned up to 8 byte
   // boundaries. The reason not to use ValueType directly is that for types with
   // constructors it could lead to race conditions.
@@ -118,13 +118,14 @@ __device__ inline bool hip_inter_block_shuffle_reduction(
     pointer_type global =
         reinterpret_cast<pointer_type>(m_scratch_space) + blockIdx.x;
     *global = value;
+    __threadfence();
   }
 
   // One warp of last block performs inter block reduction through loading the
   // block values from global scratch_memory
   bool last_block = false;
   __syncthreads();
-  int constexpr warp_size = HIPTraits::WarpSize;
+  constexpr int warp_size = HIPTraits::WarpSize;
   if (id < warp_size) {
     HIP::size_type count;
 
diff --git a/core/src/HIP/Kokkos_HIP_Space.cpp b/core/src/HIP/Kokkos_HIP_Space.cpp
index 07b9382ab7..67635fc1c4 100644
--- a/core/src/HIP/Kokkos_HIP_Space.cpp
+++ b/core/src/HIP/Kokkos_HIP_Space.cpp
@@ -24,10 +24,8 @@
 #include <HIP/Kokkos_HIP_Space.hpp>
 
 #include <HIP/Kokkos_HIP_DeepCopy.hpp>
-#include <HIP/Kokkos_HIP_SharedAllocationRecord.hpp>
 
 #include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
 #include <impl/Kokkos_DeviceManagement.hpp>
 #include <impl/Kokkos_ExecSpaceManager.hpp>
 
@@ -41,18 +39,11 @@
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
+
 namespace {
 
 static std::atomic<bool> is_first_hip_managed_allocation(true);
 
-bool hip_driver_check_page_migration(int deviceId) {
-  // check with driver if page migrating memory is available
-  // this driver query is copied from the hip documentation
-  int hasManagedMemory = 0;  // false by default
-  KOKKOS_IMPL_HIP_SAFE_CALL(hipDeviceGetAttribute(
-      &hasManagedMemory, hipDeviceAttributeManagedMemory, deviceId));
-  return static_cast<bool>(hasManagedMemory);
-}
 }  // namespace
 
 /*--------------------------------------------------------------------------*/
@@ -76,7 +67,6 @@ void* HIPSpace::allocate(
   return impl_allocate(arg_label, arg_alloc_size, arg_logical_size);
 }
 void* HIPSpace::impl_allocate(
-
     const char* arg_label, const size_t arg_alloc_size,
     const size_t arg_logical_size,
     const Kokkos::Tools::SpaceHandle arg_handle) const {
@@ -87,10 +77,7 @@ void* HIPSpace::impl_allocate(
     // This is the only way to clear the last error, which we should do here
     // since we're turning it into an exception here
     (void)hipGetLastError();
-    throw Experimental::HIPRawMemoryAllocationFailure(
-        arg_alloc_size, error_code,
-        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-            HIPMalloc);
+    Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
   }
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     const size_t reported_size =
@@ -121,10 +108,7 @@ void* HIPHostPinnedSpace::impl_allocate(
     // This is the only way to clear the last error, which we should do here
     // since we're turning it into an exception here
     (void)hipGetLastError();
-    throw Experimental::HIPRawMemoryAllocationFailure(
-        arg_alloc_size, error_code,
-        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-            HIPHostMalloc);
+    Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
   }
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     const size_t reported_size =
@@ -153,7 +137,7 @@ void* HIPManagedSpace::impl_allocate(
     if (is_first_hip_managed_allocation.exchange(false) &&
         Kokkos::show_warnings()) {
       do {  // hack to avoid spamming users with too many warnings
-        if (!hip_driver_check_page_migration(m_device)) {
+        if (!impl_hip_driver_check_page_migration()) {
           std::cerr << R"warning(
 Kokkos::HIP::allocation WARNING: The combination of device and system configuration
                                  does not support page migration between device and host.
@@ -188,10 +172,7 @@ Kokkos::HIP::runtime WARNING: Kokkos did not find an environment variable 'HSA_X
       // This is the only way to clear the last error, which we should do here
       // since we're turning it into an exception here
       (void)hipGetLastError();
-      throw Experimental::HIPRawMemoryAllocationFailure(
-          arg_alloc_size, error_code,
-          Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-              HIPMallocManaged);
+      Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
     }
     KOKKOS_IMPL_HIP_SAFE_CALL(hipMemAdvise(
         ptr, arg_alloc_size, hipMemAdviseSetCoarseGrain, m_device));
@@ -205,6 +186,19 @@ Kokkos::HIP::runtime WARNING: Kokkos did not find an environment variable 'HSA_X
 
   return ptr;
 }
+bool HIPManagedSpace::impl_hip_driver_check_page_migration() const {
+  // check with driver if page migrating memory is available
+  // this driver query is copied from the hip documentation
+  int hasManagedMemory = 0;  // false by default
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipDeviceGetAttribute(
+      &hasManagedMemory, hipDeviceAttributeManagedMemory, m_device));
+  if (!static_cast<bool>(hasManagedMemory)) return false;
+  // next, check pageableMemoryAccess
+  int hasPageableMemory = 0;  // false by default
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipDeviceGetAttribute(
+      &hasPageableMemory, hipDeviceAttributePageableMemoryAccess, m_device));
+  return static_cast<bool>(hasPageableMemory);
+}
 
 void HIPSpace::deallocate(void* const arg_alloc_ptr,
                           const size_t arg_alloc_size) const {
@@ -282,22 +276,3 @@ void HIPManagedSpace::impl_deallocate(
 }
 
 }  // namespace Kokkos
-
-/*--------------------------------------------------------------------------*/
-/*--------------------------------------------------------------------------*/
-
-#include <impl/Kokkos_SharedAlloc_timpl.hpp>
-
-namespace Kokkos {
-namespace Impl {
-
-// To avoid additional compilation cost for something that's (mostly?) not
-// performance sensitive, we explicity instantiate these CRTP base classes here,
-// where we have access to the associated *_timpl.hpp header files.
-template class HostInaccessibleSharedAllocationRecordCommon<HIPSpace>;
-template class SharedAllocationRecordCommon<HIPSpace>;
-template class SharedAllocationRecordCommon<HIPHostPinnedSpace>;
-template class SharedAllocationRecordCommon<HIPManagedSpace>;
-
-}  // end namespace Impl
-}  // end namespace Kokkos
diff --git a/core/src/HIP/Kokkos_HIP_Space.hpp b/core/src/HIP/Kokkos_HIP_Space.hpp
index 902b6f0552..e1b4768b87 100644
--- a/core/src/HIP/Kokkos_HIP_Space.hpp
+++ b/core/src/HIP/Kokkos_HIP_Space.hpp
@@ -65,6 +65,28 @@ class HIPSpace {
   ~HIPSpace()                              = default;
 
   /**\brief  Allocate untracked memory in the hip space */
+#ifdef KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
+#else
+  // FIXME_HIP Use execution space instance
+  void* allocate(const HIP&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  // FIXME_HIP Use execution space instance
+  void* allocate(const HIP&, const char* arg_label, const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
+#endif
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -76,8 +98,6 @@ class HIPSpace {
                   const size_t arg_logical_size = 0) const;
 
  private:
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
   void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
                       const Kokkos::Tools::SpaceHandle =
@@ -94,8 +114,6 @@ class HIPSpace {
 
  private:
   int m_device;  ///< Which HIP device
-
-  friend class Kokkos::Impl::SharedAllocationRecord<HIPSpace, void>;
 };
 
 template <>
@@ -129,6 +147,16 @@ class HIPHostPinnedSpace {
   ~HIPHostPinnedSpace()                                        = default;
 
   /**\brief  Allocate untracked memory in the space */
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -140,8 +168,6 @@ class HIPHostPinnedSpace {
                   const size_t arg_logical_size = 0) const;
 
  private:
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
   void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
                       const Kokkos::Tools::SpaceHandle =
@@ -194,6 +220,16 @@ class HIPManagedSpace {
   ~HIPManagedSpace()                                     = default;
 
   /**\brief  Allocate untracked memory in the space */
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -204,10 +240,11 @@ class HIPManagedSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
+  //  internal only method to determine whether page migration is supported
+  bool impl_hip_driver_check_page_migration() const;
+
  private:
   int m_device;  ///< Which HIP device
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
   void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
                       const Kokkos::Tools::SpaceHandle =
@@ -236,15 +273,18 @@ struct Impl::is_hip_type_space<HIPManagedSpace> : public std::true_type {};
 namespace Kokkos {
 namespace Impl {
 
-static_assert(Kokkos::Impl::MemorySpaceAccess<HIPSpace, HIPSpace>::assignable,
-              "");
+static_assert(Kokkos::Impl::MemorySpaceAccess<HIPSpace, HIPSpace>::assignable);
 
 //----------------------------------------
 
 template <>
 struct MemorySpaceAccess<HostSpace, HIPSpace> {
   enum : bool { assignable = false };
-  enum : bool { accessible = false };
+#if !defined(KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY)
+  enum : bool{accessible = false};
+#else
+  enum : bool { accessible = true };
+#endif
   enum : bool { deepcopy = true };
 };
 
diff --git a/core/src/HIP/Kokkos_HIP_Team.hpp b/core/src/HIP/Kokkos_HIP_Team.hpp
index 2fed2b7719..fb466d8a72 100644
--- a/core/src/HIP/Kokkos_HIP_Team.hpp
+++ b/core/src/HIP/Kokkos_HIP_Team.hpp
@@ -537,15 +537,17 @@ parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
  *  final == true.
  */
 // This is the same code as in CUDA and largely the same as in OpenMPTarget
-template <typename iType, typename FunctorType>
+template <typename iType, typename FunctorType, typename ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HIPTeamMember>&
         loop_bounds,
-    const FunctorType& lambda) {
-  // Extract value_type from lambda
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+    const FunctorType& lambda, ValueType& return_val) {
+  // Extract ValueType from the Functor
+  using functor_value_type = typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
-      void>::value_type;
+      ValueType>::value_type;
+  static_assert(std::is_same_v<functor_value_type, ValueType>,
+                "Non-matching value types of functor and return type");
 
   const auto start     = loop_bounds.start;
   const auto end       = loop_bounds.end;
@@ -553,12 +555,12 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   const auto team_size = member.team_size();
   const auto team_rank = member.team_rank();
   const auto nchunk    = (end - start + team_size - 1) / team_size;
-  value_type accum     = 0;
+  ValueType accum      = {};
   // 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;
+    ValueType local_accum = 0;
     // user updates value with prefix value
     if (ii < loop_bounds.end) lambda(ii, local_accum, false);
     // perform team scan
@@ -572,6 +574,29 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     // broadcast last value to rest of the team
     member.team_broadcast(accum, team_size - 1);
   }
+  return_val = accum;
+}
+
+/** \brief  Inter-thread parallel exclusive prefix sum.
+ *
+ *  Executes closure(iType i, ValueType & val, bool final) for each i=[0..N)
+ *
+ *  The range [0..N) is mapped to each rank in the team (whose global rank is
+ *  less than N) and a scan operation is performed. The last call to closure has
+ *  final == true.
+ */
+template <typename iType, typename FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HIPTeamMember>&
+        loop_bounds,
+    const FunctorType& lambda) {
+  // Extract value_type from lambda
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+
+  value_type scan_val;
+  parallel_scan(loop_bounds, lambda, scan_val);
 }
 
 template <typename iType, class Closure>
@@ -772,7 +797,8 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
     // exclusive scan -- the final accumulation
     // of i's val will be included in the second
     // closure call later.
-    if (i < loop_boundaries.end && threadIdx.x > 0) closure(i - 1, val, false);
+    if (i - 1 < loop_boundaries.end && threadIdx.x > 0)
+      closure(i - 1, val, false);
 
     // Bottom up exclusive scan in triangular pattern
     // where each HIP thread is the root of a reduction tree
@@ -801,6 +827,7 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
     if (i < loop_boundaries.end) closure(i, val, true);
     Impl::in_place_shfl(accum, val, blockDim.x - 1, blockDim.x);
   }
+  reducer.reference() = accum;
 #else
   (void)loop_boundaries;
   (void)closure;
@@ -830,6 +857,32 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   parallel_scan(loop_boundaries, closure, Kokkos::Sum<value_type>(dummy));
 }
 
+/** \brief  Intra-thread vector parallel exclusive prefix sum.
+ *
+ *  Executes closure(iType i, ValueType & val, bool final) for each i=[0..N)
+ *
+ *  The range [0..N) is mapped to all vector lanes in the
+ *  thread and a scan operation is performed.
+ *  The last call to closure has final == true.
+ */
+template <typename iType, class Closure, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HIPTeamMember>&
+        loop_boundaries,
+    const Closure& closure, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using closure_value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      ValueType>::value_type;
+  static_assert(std::is_same_v<closure_value_type, ValueType>,
+                "Non-matching value types of closure and return type");
+
+  ValueType accum;
+  parallel_scan(loop_boundaries, closure, Kokkos::Sum<ValueType>(accum));
+
+  return_val = accum;
+}
+
 }  // namespace Kokkos
 
 namespace Kokkos {
diff --git a/core/src/HIP/Kokkos_HIP_TeamPolicyInternal.hpp b/core/src/HIP/Kokkos_HIP_TeamPolicyInternal.hpp
new file mode 100644
index 0000000000..67e1181125
--- /dev/null
+++ b/core/src/HIP/Kokkos_HIP_TeamPolicyInternal.hpp
@@ -0,0 +1,421 @@
+//@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_TEAM_POLICY_INTERNAL_HPP
+#define KOKKOS_HIP_TEAM_POLICY_INTERNAL_HPP
+
+#include <Kokkos_MinMax.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <typename... Properties>
+class TeamPolicyInternal<HIP, Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
+  using execution_policy = TeamPolicyInternal;
+
+  using traits = PolicyTraits<Properties...>;
+
+  template <typename ExecSpace, typename... OtherProperties>
+  friend class TeamPolicyInternal;
+
+ private:
+  typename traits::execution_space m_space;
+  int m_league_size;
+  int m_team_size;
+  int m_vector_length;
+  size_t m_team_scratch_size[2];
+  size_t m_thread_scratch_size[2];
+  int m_chunk_size;
+  bool m_tune_team_size;
+  bool m_tune_vector_length;
+
+ public:
+  using execution_space = HIP;
+
+  template <class... OtherProperties>
+  TeamPolicyInternal(TeamPolicyInternal<OtherProperties...> const& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
+    m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
+    m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
+    m_chunk_size             = p.m_chunk_size;
+    m_space                  = p.m_space;
+    m_tune_team_size         = p.m_tune_team_size;
+    m_tune_vector_length     = p.m_tune_vector_length;
+  }
+
+  template <typename FunctorType>
+  int team_size_max(FunctorType const& f, ParallelForTag const&) const {
+    using closure_type =
+        Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
+
+    return internal_team_size_common<BlockType::Max, closure_type, void>(f);
+  }
+
+  template <class FunctorType>
+  inline int team_size_max(const FunctorType& f,
+                           const ParallelReduceTag&) const {
+    using functor_analysis_type =
+        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                              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<CombinedFunctorReducer<FunctorType, ReducerType>,
+                             TeamPolicy<Properties...>, Kokkos::HIP>;
+    return internal_team_size_common<BlockType::Max, closure_type,
+                                     typename ReducerType::value_type>(f);
+  }
+
+  template <typename FunctorType>
+  int team_size_recommended(FunctorType const& f, ParallelForTag const&) const {
+    using closure_type =
+        Impl::ParallelFor<FunctorType, TeamPolicy<Properties...>>;
+
+    return internal_team_size_common<BlockType::Preferred, closure_type, void>(
+        f);
+  }
+
+  template <typename FunctorType>
+  inline int team_size_recommended(FunctorType const& f,
+                                   ParallelReduceTag const&) const {
+    using functor_analysis_type =
+        Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE,
+                              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<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; }
+  inline bool impl_auto_team_size() const { return m_tune_team_size; }
+  static int vector_length_max() { return HIPTraits::WarpSize; }
+
+  static int verify_requested_vector_length(int requested_vector_length) {
+    int test_vector_length =
+        std::min(requested_vector_length, vector_length_max());
+
+    // Allow only power-of-two vector_length
+    if (!(is_integral_power_of_two(test_vector_length))) {
+      int test_pow2           = 1;
+      constexpr int warp_size = HIPTraits::WarpSize;
+      while (test_pow2 < warp_size) {
+        test_pow2 <<= 1;
+        if (test_pow2 > test_vector_length) {
+          break;
+        }
+      }
+      test_vector_length = test_pow2 >> 1;
+    }
+
+    return test_vector_length;
+  }
+
+  inline static int scratch_size_max(int level) {
+    // HIP Teams use (team_size + 2)*sizeof(double) shared memory for team
+    // reductions. They also use one int64_t in static shared memory for a
+    // shared ID. Furthermore, they use additional scratch memory in some
+    // reduction scenarios, which depend on the size of the value_type and is
+    // NOT captured here
+    constexpr size_t max_possible_team_size = 1024;
+    constexpr size_t max_reserved_shared_mem_per_team =
+        (max_possible_team_size + 2) * sizeof(double) + sizeof(int64_t);
+    // arbitrarily setting level 1 scratch limit to 20MB, for a
+    // MI250 that would give us about 4.4GB for 2 teams per CU
+    constexpr size_t max_l1_scratch_size = 20 * 1024 * 1024;
+
+    size_t max_shmem = HIP().hip_device_prop().sharedMemPerBlock;
+    return (level == 0 ? max_shmem - max_reserved_shared_mem_per_team
+                       : max_l1_scratch_size);
+  }
+
+  inline void impl_set_vector_length(size_t size) { m_vector_length = size; }
+  inline void impl_set_team_size(size_t size) { m_team_size = size; }
+  int impl_vector_length() const { return m_vector_length; }
+
+  int team_size() const { return m_team_size; }
+
+  int league_size() const { return m_league_size; }
+
+  size_t scratch_size(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];
+  }
+
+  size_t team_scratch_size(int level) const {
+    return m_team_scratch_size[level];
+  }
+
+  size_t thread_scratch_size(int level) const {
+    return m_thread_scratch_size[level];
+  }
+
+  typename traits::execution_space space() const { return m_space; }
+
+  TeamPolicyInternal()
+      : m_space(typename traits::execution_space()),
+        m_league_size(0),
+        m_team_size(-1),
+        m_vector_length(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(HIPTraits::WarpSize),
+        m_tune_team_size(false),
+        m_tune_vector_length(false) {}
+
+  /** \brief  Specify league size, request team size */
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     int team_size_request, int vector_length_request = 1)
+      : m_space(space_),
+        m_league_size(league_size_),
+        m_team_size(team_size_request),
+        m_vector_length(
+            (vector_length_request > 0)
+                ? verify_requested_vector_length(vector_length_request)
+                : (verify_requested_vector_length(1))),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(HIPTraits::WarpSize),
+        m_tune_team_size(bool(team_size_request <= 0)),
+        m_tune_vector_length(bool(vector_length_request <= 0)) {
+    // Make sure league size is permissible
+    if (league_size_ >= static_cast<int>(hip_internal_maximum_grid_count()[0]))
+      Impl::throw_runtime_exception(
+          "Requested too large league_size for TeamPolicy on HIP execution "
+          "space.");
+
+    // Make sure total block size is permissible
+    if (m_team_size * m_vector_length > HIPTraits::MaxThreadsPerBlock) {
+      Impl::throw_runtime_exception(
+          std::string("Kokkos::TeamPolicy< HIP > the team size is too large. "
+                      "Team size x vector length must be smaller than 1024."));
+    }
+  }
+
+  /** \brief  Specify league size, request team size */
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     int vector_length_request = 1)
+      : TeamPolicyInternal(space_, league_size_, -1, vector_length_request) {}
+  // FLAG
+  /** \brief  Specify league size and team size, request vector length*/
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     int team_size_request,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+                     )
+      : TeamPolicyInternal(space_, league_size_, team_size_request, -1)
+
+  {}
+
+  /** \brief  Specify league size, request team size and vector length*/
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+
+                     )
+      : TeamPolicyInternal(space_, league_size_, -1, -1)
+
+  {}
+
+  TeamPolicyInternal(int league_size_, int team_size_request,
+                     int vector_length_request = 1)
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
+                           team_size_request, vector_length_request) {}
+
+  TeamPolicyInternal(int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     int vector_length_request = 1)
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
+                           vector_length_request) {}
+
+  /** \brief  Specify league size and team size, request vector length*/
+  TeamPolicyInternal(int league_size_, int team_size_request,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+
+                     )
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
+                           team_size_request, -1)
+
+  {}
+
+  /** \brief  Specify league size, request team size and vector length*/
+  TeamPolicyInternal(int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+
+                     )
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
+                           -1) {}
+
+  int chunk_size() const { return m_chunk_size; }
+
+  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 */
+  TeamPolicyInternal& set_scratch_size(int level,
+                                       PerTeamValue const& 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 */
+  TeamPolicyInternal& set_scratch_size(int level,
+                                       PerThreadValue const& 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 */
+  TeamPolicyInternal& set_scratch_size(int level, PerTeamValue const& per_team,
+                                       PerThreadValue const& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
+    m_thread_scratch_size[level] = per_thread.value;
+    return *this;
+  }
+
+  using member_type = Kokkos::Impl::HIPTeamMember;
+
+ protected:
+  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);
+    using Tag = typename PatternTagFromImplSpecialization<ClosureType>::type;
+    if constexpr (std::is_same_v<Tag, ParallelReduceTag>) {
+      using Interface =
+          typename Impl::DeduceFunctorPatternInterface<ClosureType>::type;
+      using Analysis =
+          Impl::FunctorAnalysis<Interface, typename ClosureType::Policy,
+                                FunctorType, ValueType>;
+      shmem_thread +=
+          ((Analysis::StaticValueSize != 0) ? 0 : Analysis::value_size(f));
+    }
+    const int vector_length = impl_vector_length();
+
+    const auto functor = [&f, shmem_block, shmem_thread, vector_length](
+                             const hipFuncAttributes& attr, int block_size) {
+      int functor_shmem =
+          ::Kokkos::Impl::FunctorTeamShmemSize<FunctorType>::value(
+              f, block_size / vector_length);
+      return shmem_block + shmem_thread * (block_size / vector_length) +
+             functor_shmem + attr.sharedSizeBytes;
+    };
+    int block_size;
+    if constexpr (BlockSize == BlockType::Max) {
+      block_size = hip_get_max_team_blocksize<ClosureType,
+                                              typename traits::launch_bounds>(
+          space().impl_internal_space_instance(), functor);
+    } else {
+      block_size =
+          hip_get_preferred_team_blocksize<ClosureType,
+                                           typename traits::launch_bounds>(
+              space().impl_internal_space_instance(), functor);
+    }
+
+    if (block_size == 0) {
+      Kokkos::Impl::throw_runtime_exception(std::string(
+          "Kokkos::Impl::ParallelFor/Reduce< HIP > could not find a valid "
+          "team size."));
+    }
+    if constexpr (std::is_same_v<Tag, ParallelForTag>) {
+      return block_size / impl_vector_length();
+    } else {
+      // Currently we require Power-of-2 team size for reductions.
+      int p2 = 1;
+      while (p2 <= block_size) p2 *= 2;
+      p2 /= 2;
+      return p2 / impl_vector_length();
+    }
+  }
+};
+
+__device__ inline int64_t hip_get_scratch_index(HIP::size_type league_size,
+                                                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(num_scratch_locks) / (blockDim.x * blockDim.y));
+    threadid = (blockIdx.x * blockDim.z + threadIdx.z) % wraparound_len;
+    threadid *= blockDim.x * blockDim.y;
+    int done = 0;
+    while (!done) {
+      done = (0 == atomicCAS(&scratch_locks[threadid], 0, 1));
+      if (!done) {
+        threadid += blockDim.x * blockDim.y;
+        if (int64_t(threadid + blockDim.x * blockDim.y) >=
+            wraparound_len * blockDim.x * blockDim.y)
+          threadid = 0;
+      }
+    }
+    base_thread_id = threadid;
+  }
+  __syncthreads();
+  threadid = base_thread_id;
+  return threadid;
+}
+
+__device__ inline void hip_release_scratch_index(int32_t* scratch_locks,
+                                                 int64_t threadid) {
+  __syncthreads();
+  if (threadIdx.x == 0 && threadIdx.y == 0) {
+    scratch_locks[threadid] = 0;
+  }
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/HIP/Kokkos_HIP_UniqueToken.hpp b/core/src/HIP/Kokkos_HIP_UniqueToken.hpp
index 313e5f5217..3d70b59646 100644
--- a/core/src/HIP/Kokkos_HIP_UniqueToken.hpp
+++ b/core/src/HIP/Kokkos_HIP_UniqueToken.hpp
@@ -19,7 +19,6 @@
 
 #include <HIP/Kokkos_HIP_Space.hpp>
 #include <Kokkos_UniqueToken.hpp>
-#include <impl/Kokkos_SharedAlloc.hpp>
 
 namespace Kokkos {
 
diff --git a/core/src/HIP/Kokkos_HIP_Vectorization.hpp b/core/src/HIP/Kokkos_HIP_Vectorization.hpp
index e14b722f37..30774c898b 100644
--- a/core/src/HIP/Kokkos_HIP_Vectorization.hpp
+++ b/core/src/HIP/Kokkos_HIP_Vectorization.hpp
@@ -85,7 +85,7 @@ struct in_place_shfl_op {
   operator()(Scalar& out, const Scalar& val, int lane_or_delta, int width) const
       noexcept {
     using shuffle_as_t = int;
-    int constexpr N    = sizeof(Scalar) / sizeof(shuffle_as_t);
+    constexpr int N    = sizeof(Scalar) / sizeof(shuffle_as_t);
 
     for (int i = 0; i < N; ++i) {
       reinterpret_cast<shuffle_as_t*>(&out)[i] = self().do_shfl_op(
diff --git a/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp b/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp
index 5c40d0fbc8..4bca29868f 100644
--- a/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp
+++ b/core/src/HIP/Kokkos_HIP_ZeroMemset.hpp
@@ -25,19 +25,11 @@ 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&) {
+  ZeroMemset(const HIP& exec_space, const View<T, P...>& dst) {
     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
diff --git a/core/src/HPX/Kokkos_HPX.cpp b/core/src/HPX/Kokkos_HPX.cpp
index f6792a98f6..1f3d078344 100644
--- a/core/src/HPX/Kokkos_HPX.cpp
+++ b/core/src/HPX/Kokkos_HPX.cpp
@@ -25,11 +25,11 @@
 
 #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/condition_variable.hpp>
+#include <hpx/init.hpp>
+#include <hpx/mutex.hpp>
+#include <hpx/runtime.hpp>
+#include <hpx/thread.hpp>
 #include <hpx/version.hpp>
 
 #include <atomic>
@@ -103,6 +103,7 @@ void HPX::print_configuration(std::ostream &os, const bool) const {
   os << hpx::configuration_string() << '\n';
 }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 bool &HPX::impl_get_in_parallel() noexcept {
   static thread_local bool in_parallel = false;
   return in_parallel;
@@ -127,6 +128,7 @@ HPX::impl_not_in_parallel_scope::~impl_not_in_parallel_scope() noexcept {
   KOKKOS_EXPECTS(!impl_get_in_parallel());
   impl_get_in_parallel() = true;
 }
+#endif
 
 void HPX::impl_decrement_active_parallel_region_count() {
   std::unique_lock<hpx::spinlock> l(m_active_parallel_region_count_mutex);
@@ -151,7 +153,7 @@ void HPX::impl_instance_fence_locked(const std::string &name) const {
         auto &s = impl_get_sender();
 
         hpx::this_thread::experimental::sync_wait(std::move(s));
-        s = hpx::execution::experimental::unique_any_sender(
+        s = hpx::execution::experimental::unique_any_sender<>(
             hpx::execution::experimental::just());
       });
 }
@@ -182,7 +184,7 @@ void HPX::impl_static_fence(const std::string &name) {
         }
 
         hpx::this_thread::experimental::sync_wait(std::move(s));
-        s = hpx::execution::experimental::unique_any_sender(
+        s = hpx::execution::experimental::unique_any_sender<>(
             hpx::execution::experimental::just());
       });
 }
@@ -207,12 +209,7 @@ int HPX::concurrency() const {
 void HPX::impl_initialize(InitializationSettings const &settings) {
   hpx::runtime *rt = hpx::get_runtime_ptr();
   if (rt == nullptr) {
-    hpx::local::init_params i;
-    i.cfg = {
-#ifdef KOKKOS_ENABLE_DEBUG
-        "--hpx:attach-debugger=exception",
-#endif
-    };
+    hpx::init_params i;
     if (settings.has_num_threads()) {
       i.cfg.emplace_back("hpx.os_threads=" +
                          std::to_string(settings.get_num_threads()));
@@ -220,7 +217,7 @@ void HPX::impl_initialize(InitializationSettings const &settings) {
     int argc_hpx     = 1;
     char name[]      = "kokkos_hpx";
     char *argv_hpx[] = {name, nullptr};
-    hpx::local::start(nullptr, argc_hpx, argv_hpx, i);
+    hpx::start(nullptr, argc_hpx, argv_hpx, i);
 
     m_hpx_initialized = true;
   }
@@ -236,11 +233,11 @@ void HPX::impl_finalize() {
     hpx::runtime *rt = hpx::get_runtime_ptr();
     if (rt != nullptr) {
 #if HPX_VERSION_FULL >= 0x010900
-      hpx::post([]() { hpx::local::finalize(); });
+      hpx::post([]() { hpx::finalize(); });
 #else
-      hpx::apply([]() { hpx::local::finalize(); });
+      hpx::apply([]() { hpx::finalize(); });
 #endif
-      hpx::local::stop();
+      hpx::stop();
     } else {
       Kokkos::abort(
           "Kokkos::Experimental::HPX::impl_finalize: Kokkos started "
@@ -330,4 +327,4 @@ int g_hpx_space_factory_initialized =
 
 #else
 void KOKKOS_CORE_SRC_IMPL_HPX_PREVENT_LINK_ERROR() {}
-#endif  //#ifdef KOKKOS_ENABLE_HPX
+#endif  // #ifdef KOKKOS_ENABLE_HPX
diff --git a/core/src/HPX/Kokkos_HPX.hpp b/core/src/HPX/Kokkos_HPX.hpp
index 89117a42bd..245dc128ca 100644
--- a/core/src/HPX/Kokkos_HPX.hpp
+++ b/core/src/HPX/Kokkos_HPX.hpp
@@ -27,14 +27,6 @@ static_assert(false,
 
 #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>
@@ -50,15 +42,16 @@ static_assert(false,
 
 #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 <hpx/barrier.hpp>
+#include <hpx/condition_variable.hpp>
+#include <hpx/execution.hpp>
+#include <hpx/future.hpp>
+#include <hpx/mutex.hpp>
+#include <hpx/thread.hpp>
 
 #include <Kokkos_UniqueToken.hpp>
 
+#include <cstddef>
 #include <iosfwd>
 #include <functional>
 #include <memory>
@@ -175,17 +168,31 @@ class HPX {
       : m_instance_data(Kokkos::Impl::HostSharedPtr<instance_data>(
             &m_default_instance_data, &default_instance_deleter)) {}
   ~HPX() = default;
-  HPX(instance_mode mode)
+  explicit 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)
+  explicit 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)))) {}
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT(
+      "HPX execution space should be constructed explicitly.")
+  HPX(instance_mode mode)
+      : HPX(mode) {}
+
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT(
+      "HPX execution space should be constructed explicitly.")
+  HPX(hpx::execution::experimental::unique_any_sender<> &&sender)
+      : HPX(std::move(sender)) {}
+#endif
+
   HPX(HPX &&other)      = default;
   HPX(const HPX &other) = default;
 
@@ -201,6 +208,7 @@ class HPX {
     return impl_get_instance_data().m_instance_id;
   }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   static bool &impl_get_in_parallel() noexcept;
 
   struct impl_in_parallel_scope {
@@ -223,9 +231,10 @@ class HPX {
         delete;
   };
 
-  static bool in_parallel(HPX const & = HPX()) noexcept {
+  KOKKOS_DEPRECATED static bool in_parallel(HPX const & = HPX()) noexcept {
     return impl_get_in_parallel();
   }
+#endif
 
   static void impl_decrement_active_parallel_region_count();
   static void impl_increment_active_parallel_region_count();
@@ -248,18 +257,6 @@ class HPX {
 #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
@@ -355,7 +352,9 @@ class HPX {
                            hpx::threads::thread_stacksize::default_) const {
     impl_bulk_plain_erased(force_synchronous, is_light_weight_policy,
                            {[functor](Index i) {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
                              impl_in_parallel_scope p;
+#endif
                              functor.execute_range(i);
                            }},
                            n, stacksize);
@@ -417,15 +416,21 @@ class HPX {
           hpx::threads::thread_stacksize::default_) const {
     impl_bulk_setup_finalize_erased(force_synchronous, is_light_weight_policy,
                                     {[functor](Index i) {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
                                       impl_in_parallel_scope p;
+#endif
                                       functor.execute_range(i);
                                     }},
                                     {[functor]() {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
                                       impl_in_parallel_scope p;
+#endif
                                       functor.setup();
                                     }},
                                     {[functor]() {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
                                       impl_in_parallel_scope p;
+#endif
                                       functor.finalize();
                                     }},
                                     n, stacksize);
@@ -1292,6 +1297,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
     const WorkRange range(m_policy, t, num_worker_threads);
     execute_chunk(range.begin(), range.end(), update_sum, false);
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
     {
       // 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
@@ -1299,6 +1305,9 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
       Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
       barrier.arrive_and_wait();
     }
+#else
+    barrier.arrive_and_wait();
+#endif
 
     if (t == 0) {
       final_reducer.init(reinterpret_cast<pointer_type>(
@@ -1320,6 +1329,7 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
       }
     }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
     {
       // 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
@@ -1327,6 +1337,9 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
       Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
       barrier.arrive_and_wait();
     }
+#else
+    barrier.arrive_and_wait();
+#endif
 
     reference_type update_base =
         Analysis::Reducer::reference(reinterpret_cast<pointer_type>(
@@ -1407,6 +1420,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     const WorkRange range(m_policy, t, num_worker_threads);
     execute_chunk(range.begin(), range.end(), update_sum, false);
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
     {
       // 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
@@ -1414,6 +1428,9 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
       Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
       barrier.arrive_and_wait();
     }
+#else
+    barrier.arrive_and_wait();
+#endif
 
     if (t == 0) {
       final_reducer.init(reinterpret_cast<pointer_type>(
@@ -1435,6 +1452,7 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
       }
     }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
     {
       // 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
@@ -1442,6 +1460,9 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
       Kokkos::Experimental::HPX::impl_not_in_parallel_scope p;
       barrier.arrive_and_wait();
     }
+#else
+    barrier.arrive_and_wait();
+#endif
 
     reference_type update_base =
         Analysis::Reducer::reference(reinterpret_cast<pointer_type>(
@@ -1828,16 +1849,18 @@ KOKKOS_INLINE_FUNCTION void parallel_reduce(
   }
 }
 
-template <typename iType, class FunctorType>
+template <typename iType, class FunctorType, typename ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember> const
         &loop_boundaries,
-    const FunctorType &lambda) {
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+    const FunctorType &lambda, ValueType &return_val) {
+  using functor_value_type = typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
       void>::value_type;
+  static_assert(std::is_same_v<functor_value_type, ValueType>,
+                "Non-matching value types of functor and return type");
 
-  value_type scan_val = value_type();
+  ValueType scan_val{};
 
   // Intra-member scan
   for (iType i = loop_boundaries.start; i < loop_boundaries.end;
@@ -1852,6 +1875,22 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
        i += loop_boundaries.increment) {
     lambda(i, scan_val, true);
   }
+
+  return_val = scan_val;
+}
+
+template <typename iType, typename FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_bounds,
+    const FunctorType &lambda) {
+  // Extract value_type from lambda
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+
+  value_type scan_val;
+  parallel_scan(loop_bounds, lambda, scan_val);
 }
 
 /** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
@@ -1905,6 +1944,25 @@ parallel_scan(
        i += loop_boundaries.increment) {
     lambda(i, scan_val, true);
   }
+  reducer.reference() = scan_val;
+}
+
+template <typename iType, class FunctorType, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::HPXTeamMember>
+        &loop_boundaries,
+    const FunctorType &lambda, ValueType &return_val) {
+  // Extract ValueType from FunctorType
+  using closure_value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+  static_assert(std::is_same<closure_value_type, ValueType>::value,
+                "Non-matching value types of closure and return type");
+
+  ValueType accum;
+  parallel_scan(loop_boundaries, lambda, Kokkos::Sum<ValueType>(accum));
+
+  return_val = accum;
 }
 
 template <class FunctorType>
diff --git a/core/src/HPX/Kokkos_HPX_Task.hpp b/core/src/HPX/Kokkos_HPX_Task.hpp
index 191e4cf9b3..28c75b2515 100644
--- a/core/src/HPX/Kokkos_HPX_Task.hpp
+++ b/core/src/HPX/Kokkos_HPX_Task.hpp
@@ -20,12 +20,13 @@
 #include <Kokkos_Macros.hpp>
 #if defined(KOKKOS_ENABLE_HPX) && defined(KOKKOS_ENABLE_TASKDAG)
 
+#include <Kokkos_Atomic.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
 #include <HPX/Kokkos_HPX.hpp>
 
-#include <hpx/local/execution.hpp>
-#include <hpx/local/future.hpp>
+#include <hpx/execution.hpp>
+#include <hpx/future.hpp>
 
 #include <type_traits>
 
@@ -164,7 +165,9 @@ class TaskQueueSpecializationConstrained<
         team_queue.complete(task);
       }
 
-      if (*((volatile int *)&team_queue.m_ready_count) > 0) {
+      if (desul::atomic_load(&team_queue.m_ready_count,
+                             desul::MemoryOrderAcquire(),
+                             desul::MemoryScopeDevice()) > 0) {
         task = end;
         for (int i = 0; i < queue_type::NumQueue && end == task; ++i) {
           for (int j = 0; j < 2 && end == task; ++j) {
diff --git a/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp b/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
index f3fabcfee3..92eafa4250 100644
--- a/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
+++ b/core/src/HPX/Kokkos_HPX_WorkGraphPolicy.hpp
@@ -19,8 +19,7 @@
 
 #include <HPX/Kokkos_HPX.hpp>
 
-#include <hpx/local/algorithm.hpp>
-#include <hpx/local/execution.hpp>
+#include <hpx/execution.hpp>
 
 namespace Kokkos {
 namespace Impl {
diff --git a/core/src/KokkosExp_MDRangePolicy.hpp b/core/src/KokkosExp_MDRangePolicy.hpp
index c9080db01c..297b1fadee 100644
--- a/core/src/KokkosExp_MDRangePolicy.hpp
+++ b/core/src/KokkosExp_MDRangePolicy.hpp
@@ -73,7 +73,7 @@ is_less_than_value_initialized_variable(T arg) {
 
 // Checked narrowing conversion that calls abort if the cast changes the value
 template <class To, class From>
-constexpr To checked_narrow_cast(From arg) {
+constexpr To checked_narrow_cast(From arg, std::size_t idx) {
   constexpr const bool is_different_signedness =
       (std::is_signed<To>::value != std::is_signed<From>::value);
   auto const ret = static_cast<To>(arg);
@@ -81,7 +81,12 @@ constexpr To checked_narrow_cast(From arg) {
       (is_different_signedness &&
        is_less_than_value_initialized_variable(arg) !=
            is_less_than_value_initialized_variable(ret))) {
-    Kokkos::abort("unsafe narrowing conversion");
+    auto msg =
+        "Kokkos::MDRangePolicy bound type error: an unsafe implicit conversion "
+        "is performed on a bound (" +
+        std::to_string(arg) + ") in dimension (" + std::to_string(idx) +
+        "), which may not preserve its original value.\n";
+    Kokkos::abort(msg.c_str());
   }
   return ret;
 }
@@ -96,15 +101,15 @@ constexpr Array to_array_potentially_narrowing(const U (&init)[M]) {
   using T = typename Array::value_type;
   Array a{};
   constexpr std::size_t N = a.size();
-  static_assert(M <= N, "");
+  static_assert(M <= N);
   auto* ptr = a.data();
   // NOTE equivalent to
   // std::transform(std::begin(init), std::end(init), a.data(),
   //                [](U x) { return static_cast<T>(x); });
   // except that std::transform is not constexpr.
-  for (auto x : init) {
-    *ptr++ = checked_narrow_cast<T>(x);
-    (void)checked_narrow_cast<IndexType>(x);  // see note above
+  for (std::size_t i = 0; i < M; ++i) {
+    *ptr++ = checked_narrow_cast<T>(init[i], i);
+    (void)checked_narrow_cast<IndexType>(init[i], i);  // see note above
   }
   return a;
 }
@@ -120,10 +125,10 @@ constexpr NVCC_WONT_LET_ME_CALL_YOU_Array to_array_potentially_narrowing(
   using T = typename NVCC_WONT_LET_ME_CALL_YOU_Array::value_type;
   NVCC_WONT_LET_ME_CALL_YOU_Array a{};
   constexpr std::size_t N = a.size();
-  static_assert(M <= N, "");
+  static_assert(M <= N);
   for (std::size_t i = 0; i < M; ++i) {
-    a[i] = checked_narrow_cast<T>(other[i]);
-    (void)checked_narrow_cast<IndexType>(other[i]);  // see note above
+    a[i] = checked_narrow_cast<T>(other[i], i);
+    (void)checked_narrow_cast<IndexType>(other[i], i);  // see note above
   }
   return a;
 }
@@ -150,9 +155,20 @@ TileSizeProperties get_tile_size_properties(const ExecutionSpace&) {
 
 // multi-dimensional iteration pattern
 template <typename... Properties>
-struct MDRangePolicy : public Kokkos::Impl::PolicyTraits<Properties...> {
-  using traits       = Kokkos::Impl::PolicyTraits<Properties...>;
-  using range_policy = RangePolicy<Properties...>;
+struct MDRangePolicy;
+
+// Note: If MDRangePolicy has a primary template, implicit CTAD (deduction
+// guides) are generated -> MDRangePolicy<> by some compilers, which is
+// incorrect.  By making it a template specialization instead, no implicit CTAD
+// is generated.  This works because there has to be at least one property
+// specified (which is Rank<...>); otherwise, we'd get the static_assert
+// "Kokkos::Error: MD iteration pattern not defined".  This template
+// specialization uses <P, Properties...> in all places for correctness.
+template <typename P, typename... Properties>
+struct MDRangePolicy<P, Properties...>
+    : public Kokkos::Impl::PolicyTraits<P, Properties...> {
+  using traits       = Kokkos::Impl::PolicyTraits<P, Properties...>;
+  using range_policy = RangePolicy<P, Properties...>;
 
   typename traits::execution_space m_space;
 
@@ -161,8 +177,8 @@ struct MDRangePolicy : public Kokkos::Impl::PolicyTraits<Properties...> {
                   typename traits::schedule_type, typename traits::index_type>;
 
   using execution_policy =
-      MDRangePolicy<Properties...>;  // needed for is_execution_space
-                                     // interrogation
+      MDRangePolicy<P, Properties...>;  // needed for is_execution_policy
+                                        // interrogation
 
   template <class... OtherProperties>
   friend struct MDRangePolicy;
@@ -327,6 +343,20 @@ struct MDRangePolicy : public Kokkos::Impl::PolicyTraits<Properties...> {
     }
     for (int i = rank_start; i != rank_end; i += increment) {
       const index_type length = m_upper[i] - m_lower[i];
+
+      if (m_upper[i] < m_lower[i]) {
+        std::string msg =
+            "Kokkos::MDRangePolicy bounds error: The lower bound (" +
+            std::to_string(m_lower[i]) + ") is greater than its upper bound (" +
+            std::to_string(m_upper[i]) + ") in dimension " + std::to_string(i) +
+            ".\n";
+#if !defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+        Kokkos::abort(msg.c_str());
+#elif defined(KOKKOS_ENABLE_DEPRECATION_WARNINGS)
+        Kokkos::Impl::log_warning(msg);
+#endif
+      }
+
       if (m_tile[i] <= 0) {
         m_tune_tile_size = true;
         if ((inner_direction == Iterate::Right && (i < rank - 1)) ||
@@ -358,6 +388,60 @@ struct MDRangePolicy : public Kokkos::Impl::PolicyTraits<Properties...> {
   }
 };
 
+template <typename LT, size_t N, typename UT>
+MDRangePolicy(const LT (&)[N], const UT (&)[N])->MDRangePolicy<Rank<N>>;
+
+template <typename LT, size_t N, typename UT, typename TT, size_t TN>
+MDRangePolicy(const LT (&)[N], const UT (&)[N], const TT (&)[TN])
+    ->MDRangePolicy<Rank<N>>;
+
+template <typename LT, size_t N, typename UT>
+MDRangePolicy(DefaultExecutionSpace const&, const LT (&)[N], const UT (&)[N])
+    ->MDRangePolicy<Rank<N>>;
+
+template <typename LT, size_t N, typename UT, typename TT, size_t TN>
+MDRangePolicy(DefaultExecutionSpace const&, const LT (&)[N], const UT (&)[N],
+              const TT (&)[TN])
+    ->MDRangePolicy<Rank<N>>;
+
+template <typename ES, typename LT, size_t N, typename UT,
+          typename = std::enable_if_t<is_execution_space_v<ES>>>
+MDRangePolicy(ES const&, const LT (&)[N], const UT (&)[N])
+    ->MDRangePolicy<ES, Rank<N>>;
+
+template <typename ES, typename LT, size_t N, typename UT, typename TT,
+          size_t TN, typename = std::enable_if_t<is_execution_space_v<ES>>>
+MDRangePolicy(ES const&, const LT (&)[N], const UT (&)[N], const TT (&)[TN])
+    ->MDRangePolicy<ES, Rank<N>>;
+
+template <typename T, size_t N>
+MDRangePolicy(Array<T, N> const&, Array<T, N> const&)->MDRangePolicy<Rank<N>>;
+
+template <typename T, size_t N, size_t NT>
+MDRangePolicy(Array<T, N> const&, Array<T, N> const&, Array<T, NT> const&)
+    ->MDRangePolicy<Rank<N>>;
+
+template <typename T, size_t N>
+MDRangePolicy(DefaultExecutionSpace const&, Array<T, N> const&,
+              Array<T, N> const&)
+    ->MDRangePolicy<Rank<N>>;
+
+template <typename T, size_t N, size_t NT>
+MDRangePolicy(DefaultExecutionSpace const&, Array<T, N> const&,
+              Array<T, N> const&, Array<T, NT> const&)
+    ->MDRangePolicy<Rank<N>>;
+
+template <typename ES, typename T, size_t N,
+          typename = std::enable_if_t<is_execution_space_v<ES>>>
+MDRangePolicy(ES const&, Array<T, N> const&, Array<T, N> const&)
+    ->MDRangePolicy<ES, Rank<N>>;
+
+template <typename ES, typename T, size_t N, size_t NT,
+          typename = std::enable_if_t<is_execution_space_v<ES>>>
+MDRangePolicy(ES const&, Array<T, N> const&, Array<T, N> const&,
+              Array<T, NT> const&)
+    ->MDRangePolicy<ES, Rank<N>>;
+
 }  // namespace Kokkos
 
 #endif  // KOKKOS_CORE_EXP_MD_RANGE_POLICY_HPP
diff --git a/core/src/Kokkos_Abort.hpp b/core/src/Kokkos_Abort.hpp
new file mode 100644
index 0000000000..a8f38837ea
--- /dev/null
+++ b/core/src/Kokkos_Abort.hpp
@@ -0,0 +1,105 @@
+//@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_ABORT_HPP
+#define KOKKOS_ABORT_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <Kokkos_Printf.hpp>
+#ifdef KOKKOS_ENABLE_CUDA
+#include <Cuda/Kokkos_Cuda_abort.hpp>
+#endif
+#ifdef KOKKOS_ENABLE_HIP
+#include <HIP/Kokkos_HIP_Abort.hpp>
+#endif
+#ifdef KOKKOS_ENABLE_SYCL
+#include <SYCL/Kokkos_SYCL_Abort.hpp>
+#endif
+
+namespace Kokkos {
+namespace Impl {
+
+[[noreturn]] void host_abort(const char *const);
+
+#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__)
+
+#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
+// required to workaround failures in random number generator unit tests with
+// pre-volta architectures
+#define KOKKOS_IMPL_ABORT_NORETURN
+#else
+// cuda_abort aborts when building for other platforms than macOS
+#define KOKKOS_IMPL_ABORT_NORETURN [[noreturn]]
+#endif
+
+#elif defined(KOKKOS_COMPILER_NVHPC)
+
+#define KOKKOS_IMPL_ABORT_NORETURN
+
+#elif defined(KOKKOS_ENABLE_HIP) && defined(__HIP_DEVICE_COMPILE__)
+// HIP aborts
+#define KOKKOS_IMPL_ABORT_NORETURN [[noreturn]]
+#elif defined(KOKKOS_ENABLE_SYCL) && defined(__SYCL_DEVICE_ONLY__)
+// FIXME_SYCL SYCL doesn't abort
+#define KOKKOS_IMPL_ABORT_NORETURN
+#elif !defined(KOKKOS_ENABLE_OPENMPTARGET) && !defined(KOKKOS_ENABLE_OPENACC)
+// Host aborts
+#define KOKKOS_IMPL_ABORT_NORETURN [[noreturn]]
+#else
+// Everything else does not abort
+#define KOKKOS_IMPL_ABORT_NORETURN
+#endif
+
+// FIXME_SYCL
+// Accomodate host pass for device functions that are not [[noreturn]]
+#if defined(KOKKOS_ENABLE_SYCL) || \
+    (defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK))
+#define KOKKOS_IMPL_ABORT_NORETURN_DEVICE
+#else
+#define KOKKOS_IMPL_ABORT_NORETURN_DEVICE KOKKOS_IMPL_ABORT_NORETURN
+#endif
+
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) ||          \
+    defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENMPTARGET) || \
+    defined(KOKKOS_ENABLE_OPENACC)
+KOKKOS_IMPL_ABORT_NORETURN_DEVICE inline KOKKOS_IMPL_DEVICE_FUNCTION void
+device_abort(const char *const msg) {
+#if defined(KOKKOS_ENABLE_CUDA)
+  ::Kokkos::Impl::cuda_abort(msg);
+#elif defined(KOKKOS_ENABLE_HIP)
+  ::Kokkos::Impl::hip_abort(msg);
+#elif defined(KOKKOS_ENABLE_SYCL)
+  ::Kokkos::Impl::sycl_abort(msg);
+#elif defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_OPENACC)
+  printf("%s", msg);  // FIXME_OPENMPTARGET FIXME_OPENACC
+#else
+#error faulty logic
+#endif
+}
+#endif
+}  // namespace Impl
+
+KOKKOS_IMPL_ABORT_NORETURN KOKKOS_INLINE_FUNCTION void abort(
+    const char *const message) {
+  KOKKOS_IF_ON_HOST(::Kokkos::Impl::host_abort(message);)
+  KOKKOS_IF_ON_DEVICE(::Kokkos::Impl::device_abort(message);)
+}
+
+#undef KOKKOS_IMPL_ABORT_NORETURN
+
+}  // namespace Kokkos
+
+#endif /* #ifndef KOKKOS_ABORT_HPP */
diff --git a/core/src/Kokkos_Array.hpp b/core/src/Kokkos_Array.hpp
index 1e3ab4741c..4d905fbc55 100644
--- a/core/src/Kokkos_Array.hpp
+++ b/core/src/Kokkos_Array.hpp
@@ -22,13 +22,13 @@
 #endif
 
 #include <Kokkos_Macros.hpp>
+#include <Kokkos_Swap.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_StringManipulation.hpp>
 
 #include <type_traits>
 #include <algorithm>
 #include <utility>
-#include <limits>
 #include <cstddef>
 
 namespace Kokkos {
@@ -79,7 +79,11 @@ struct ArrayBoundsCheck<Integral, false> {
 /**\brief  Derived from the C++17 'std::array'.
  *         Dropping the iterator interface.
  */
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 template <class T = void, size_t N = KOKKOS_INVALID_INDEX, class Proxy = void>
+#else
+template <class T, size_t N>
+#endif
 struct Array {
  public:
   /**
@@ -128,10 +132,38 @@ struct Array {
   KOKKOS_INLINE_FUNCTION constexpr const_pointer data() const {
     return &m_internal_implementation_private_member_data[0];
   }
+
+  friend KOKKOS_FUNCTION constexpr bool operator==(Array const& lhs,
+                                                   Array const& rhs) noexcept {
+    for (size_t i = 0; i != N; ++i)
+      if (lhs[i] != rhs[i]) return false;
+    return true;
+  }
+
+  friend KOKKOS_FUNCTION constexpr bool operator!=(Array const& lhs,
+                                                   Array const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+
+ private:
+  template <class U = T>
+  friend KOKKOS_INLINE_FUNCTION constexpr std::enable_if_t<
+      Impl::is_swappable<U>::value>
+  kokkos_swap(Array<T, N>& a,
+              Array<T, N>& b) noexcept(Impl::is_nothrow_swappable_v<U>) {
+    for (std::size_t i = 0; i < N; ++i) {
+      kokkos_swap(a[i], b[i]);
+    }
+  }
 };
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 template <class T, class Proxy>
 struct Array<T, 0, Proxy> {
+#else
+template <class T>
+struct Array<T, 0> {
+#endif
  public:
   using reference       = T&;
   using const_reference = std::add_const_t<T>&;
@@ -163,28 +195,38 @@ struct Array<T, 0, Proxy> {
     return *reinterpret_cast<const_pointer>(-1);
   }
 
-  KOKKOS_INLINE_FUNCTION pointer data() { return pointer(0); }
-  KOKKOS_INLINE_FUNCTION const_pointer data() const { return const_pointer(0); }
+  KOKKOS_INLINE_FUNCTION pointer data() { return nullptr; }
+  KOKKOS_INLINE_FUNCTION const_pointer data() const { return nullptr; }
 
-  KOKKOS_DEFAULTED_FUNCTION ~Array()            = default;
-  KOKKOS_DEFAULTED_FUNCTION Array()             = default;
-  KOKKOS_DEFAULTED_FUNCTION Array(const Array&) = default;
-  KOKKOS_DEFAULTED_FUNCTION Array& operator=(const Array&) = default;
+  friend KOKKOS_FUNCTION constexpr bool operator==(Array const&,
+                                                   Array const&) noexcept {
+    return true;
+  }
+  friend KOKKOS_FUNCTION constexpr bool operator!=(Array const&,
+                                                   Array const&) noexcept {
+    return false;
+  }
 
-  // Some supported compilers are not sufficiently C++11 compliant
-  // for default move constructor and move assignment operator.
-  // Array( Array && ) = default ;
-  // Array & operator = ( Array && ) = default ;
+ private:
+  friend KOKKOS_INLINE_FUNCTION constexpr void kokkos_swap(
+      Array<T, 0>&, Array<T, 0>&) noexcept {}
 };
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+namespace Impl {
+struct KokkosArrayContiguous {};
+struct KokkosArrayStrided {};
+}  // namespace Impl
+
 template <>
-struct Array<void, KOKKOS_INVALID_INDEX, void> {
-  struct contiguous {};
-  struct strided {};
+struct KOKKOS_DEPRECATED Array<void, KOKKOS_INVALID_INDEX, void> {
+  using contiguous = Impl::KokkosArrayContiguous;
+  using strided    = Impl::KokkosArrayStrided;
 };
 
 template <class T>
-struct Array<T, KOKKOS_INVALID_INDEX, Array<>::contiguous> {
+struct KOKKOS_DEPRECATED
+    Array<T, KOKKOS_INVALID_INDEX, Impl::KokkosArrayContiguous> {
  private:
   T* m_elem;
   size_t m_size;
@@ -199,7 +241,7 @@ struct Array<T, KOKKOS_INVALID_INDEX, Array<>::contiguous> {
   using const_pointer   = std::add_const_t<T>*;
 
   KOKKOS_INLINE_FUNCTION constexpr size_type size() const { return m_size; }
-  KOKKOS_INLINE_FUNCTION constexpr bool empty() const { return 0 != m_size; }
+  KOKKOS_INLINE_FUNCTION constexpr bool empty() const { return 0 == m_size; }
   KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return m_size; }
 
   template <typename iType>
@@ -234,14 +276,14 @@ struct Array<T, KOKKOS_INVALID_INDEX, Array<>::contiguous> {
 
   KOKKOS_INLINE_FUNCTION
   Array& operator=(const Array& rhs) {
-    const size_t n = std::min(m_size, rhs.size());
+    const size_t n = size() < rhs.size() ? size() : rhs.size();
     for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
     return *this;
   }
 
   template <size_t N, class P>
   KOKKOS_INLINE_FUNCTION Array& operator=(const Array<T, N, P>& rhs) {
-    const size_t n = std::min(m_size, rhs.size());
+    const size_t n = size() < rhs.size() ? size() : rhs.size();
     for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
     return *this;
   }
@@ -252,7 +294,8 @@ struct Array<T, KOKKOS_INVALID_INDEX, Array<>::contiguous> {
 };
 
 template <class T>
-struct Array<T, KOKKOS_INVALID_INDEX, Array<>::strided> {
+struct KOKKOS_DEPRECATED
+    Array<T, KOKKOS_INVALID_INDEX, Impl::KokkosArrayStrided> {
  private:
   T* m_elem;
   size_t m_size;
@@ -268,7 +311,7 @@ struct Array<T, KOKKOS_INVALID_INDEX, Array<>::strided> {
   using const_pointer   = std::add_const_t<T>*;
 
   KOKKOS_INLINE_FUNCTION constexpr size_type size() const { return m_size; }
-  KOKKOS_INLINE_FUNCTION constexpr bool empty() const { return 0 != m_size; }
+  KOKKOS_INLINE_FUNCTION constexpr bool empty() const { return 0 == m_size; }
   KOKKOS_INLINE_FUNCTION constexpr size_type max_size() const { return m_size; }
 
   template <typename iType>
@@ -303,15 +346,15 @@ struct Array<T, KOKKOS_INVALID_INDEX, Array<>::strided> {
 
   KOKKOS_INLINE_FUNCTION
   Array& operator=(const Array& rhs) {
-    const size_t n = std::min(m_size, rhs.size());
-    for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
+    const size_t n = size() < rhs.size() ? size() : rhs.size();
+    for (size_t i = 0; i < n; ++i) m_elem[i * m_stride] = rhs[i];
     return *this;
   }
 
   template <size_t N, class P>
   KOKKOS_INLINE_FUNCTION Array& operator=(const Array<T, N, P>& rhs) {
-    const size_t n = std::min(m_size, rhs.size());
-    for (size_t i = 0; i < n; ++i) m_elem[i] = rhs[i];
+    const size_t n = size() < rhs.size() ? size() : rhs.size();
+    for (size_t i = 0; i < n; ++i) m_elem[i * m_stride] = rhs[i];
     return *this;
   }
 
@@ -319,6 +362,36 @@ struct Array<T, KOKKOS_INVALID_INDEX, Array<>::strided> {
                                          size_type arg_stride)
       : m_elem(arg_ptr), m_size(arg_size), m_stride(arg_stride) {}
 };
+#endif
+
+template <typename T, typename... Us>
+Array(T, Us...)->Array<T, 1 + sizeof...(Us)>;
+
+namespace Impl {
+
+template <typename T, size_t N, size_t... I>
+KOKKOS_FUNCTION constexpr Array<std::remove_cv_t<T>, N> to_array_impl(
+    T (&a)[N], std::index_sequence<I...>) {
+  return {{a[I]...}};
+}
+
+template <typename T, size_t N, size_t... I>
+KOKKOS_FUNCTION constexpr Array<std::remove_cv_t<T>, N> to_array_impl(
+    T(&&a)[N], std::index_sequence<I...>) {
+  return {{std::move(a[I])...}};
+}
+
+}  // namespace Impl
+
+template <typename T, size_t N>
+KOKKOS_FUNCTION constexpr auto to_array(T (&a)[N]) {
+  return Impl::to_array_impl(a, std::make_index_sequence<N>{});
+}
+
+template <typename T, size_t N>
+KOKKOS_FUNCTION constexpr auto to_array(T(&&a)[N]) {
+  return Impl::to_array_impl(std::move(a), std::make_index_sequence<N>{});
+}
 
 }  // namespace Kokkos
 
@@ -329,6 +402,7 @@ struct std::tuple_size<Kokkos::Array<T, N>>
 
 template <std::size_t I, class T, std::size_t N>
 struct std::tuple_element<I, Kokkos::Array<T, N>> {
+  static_assert(I < N);
   using type = T;
 };
 
@@ -336,21 +410,25 @@ namespace Kokkos {
 
 template <std::size_t I, class T, std::size_t N>
 KOKKOS_FUNCTION constexpr T& get(Array<T, N>& a) noexcept {
+  static_assert(I < N);
   return a[I];
 }
 
 template <std::size_t I, class T, std::size_t N>
 KOKKOS_FUNCTION constexpr T const& get(Array<T, N> const& a) noexcept {
+  static_assert(I < N);
   return a[I];
 }
 
 template <std::size_t I, class T, std::size_t N>
 KOKKOS_FUNCTION constexpr T&& get(Array<T, N>&& a) noexcept {
+  static_assert(I < N);
   return std::move(a[I]);
 }
 
 template <std::size_t I, class T, std::size_t N>
 KOKKOS_FUNCTION constexpr T const&& get(Array<T, N> const&& a) noexcept {
+  static_assert(I < N);
   return std::move(a[I]);
 }
 
diff --git a/core/src/Kokkos_Assert.hpp b/core/src/Kokkos_Assert.hpp
new file mode 100644
index 0000000000..6fea286005
--- /dev/null
+++ b/core/src/Kokkos_Assert.hpp
@@ -0,0 +1,66 @@
+//@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_ASSERT_HPP
+#define KOKKOS_ASSERT_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <Kokkos_Abort.hpp>
+
+#if !defined(NDEBUG) || defined(KOKKOS_ENFORCE_CONTRACTS) || \
+    defined(KOKKOS_ENABLE_DEBUG)
+#define KOKKOS_EXPECTS(...)                                                    \
+  {                                                                            \
+    if (!bool(__VA_ARGS__)) {                                                  \
+      ::Kokkos::abort(                                                         \
+          "Kokkos contract violation:\n  "                                     \
+          "  Expected precondition `" #__VA_ARGS__                             \
+          "` evaluated false.\n"                                               \
+          "Error at " KOKKOS_IMPL_TOSTRING(__FILE__) ":" KOKKOS_IMPL_TOSTRING( \
+              __LINE__) " \n");                                                \
+    }                                                                          \
+  }
+#define KOKKOS_ENSURES(...)                                                    \
+  {                                                                            \
+    if (!bool(__VA_ARGS__)) {                                                  \
+      ::Kokkos::abort(                                                         \
+          "Kokkos contract violation:\n  "                                     \
+          "  Ensured postcondition `" #__VA_ARGS__                             \
+          "` evaluated false.\n"                                               \
+          "Error at " KOKKOS_IMPL_TOSTRING(__FILE__) ":" KOKKOS_IMPL_TOSTRING( \
+              __LINE__) " \n");                                                \
+    }                                                                          \
+  }
+#define KOKKOS_ASSERT(...)                                                     \
+  {                                                                            \
+    if (!bool(__VA_ARGS__)) {                                                  \
+      ::Kokkos::abort(                                                         \
+          "Kokkos contract violation:\n  "                                     \
+          "  Asserted condition `" #__VA_ARGS__                                \
+          "` evaluated false.\n"                                               \
+          "Error at " KOKKOS_IMPL_TOSTRING(__FILE__) ":" KOKKOS_IMPL_TOSTRING( \
+              __LINE__) " \n");                                                \
+    }                                                                          \
+  }
+#else  // not debug mode
+#define KOKKOS_EXPECTS(...)
+#define KOKKOS_ENSURES(...)
+#ifndef KOKKOS_ASSERT
+#define KOKKOS_ASSERT(...)
+#endif  // ifndef KOKKOS_ASSERT
+#endif  // end debug mode ifdefs
+
+#endif /* #ifndef KOKKOS_ASSERT_HPP */
diff --git a/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp b/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp
index 1c43474632..bf57dcae65 100644
--- a/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp
+++ b/core/src/Kokkos_Atomics_Desul_Volatile_Wrapper.hpp
@@ -22,10 +22,9 @@ static_assert(false,
 #ifndef KOKKOS_DESUL_ATOMICS_VOLATILE_WRAPPER_HPP_
 #define KOKKOS_DESUL_ATOMICS_VOLATILE_WRAPPER_HPP_
 #include <Kokkos_Macros.hpp>
-#include <Kokkos_Atomics_Desul_Config.hpp>
 #include <desul/atomics.hpp>
 
-#ifdef KOKKOS_INTERNAL_NOT_PARALLEL
+#ifdef KOKKOS_ENABLE_ATOMICS_BYPASS
 #define KOKKOS_DESUL_MEM_SCOPE desul::MemoryScopeCaller()
 #else
 #define KOKKOS_DESUL_MEM_SCOPE desul::MemoryScopeDevice()
diff --git a/core/src/Kokkos_Atomics_Desul_Wrapper.hpp b/core/src/Kokkos_Atomics_Desul_Wrapper.hpp
index bda3783980..26db69ac1f 100644
--- a/core/src/Kokkos_Atomics_Desul_Wrapper.hpp
+++ b/core/src/Kokkos_Atomics_Desul_Wrapper.hpp
@@ -22,8 +22,6 @@ static_assert(false,
 #ifndef KOKKOS_DESUL_ATOMICS_WRAPPER_HPP_
 #define KOKKOS_DESUL_ATOMICS_WRAPPER_HPP_
 #include <Kokkos_Macros.hpp>
-
-#include <Kokkos_Atomics_Desul_Config.hpp>
 #include <desul/atomics.hpp>
 
 #include <impl/Kokkos_Volatile_Load.hpp>
@@ -49,7 +47,7 @@ inline const char* atomic_query_version() { return "KOKKOS_DESUL_ATOMICS"; }
 #endif
 // ============================================================
 
-#ifdef KOKKOS_INTERNAL_NOT_PARALLEL
+#ifdef KOKKOS_ENABLE_ATOMICS_BYPASS
 #define KOKKOS_DESUL_MEM_SCOPE desul::MemoryScopeCaller()
 #else
 #define KOKKOS_DESUL_MEM_SCOPE desul::MemoryScopeDevice()
diff --git a/core/src/Kokkos_BitManipulation.hpp b/core/src/Kokkos_BitManipulation.hpp
index e541f179c8..f5653aaba3 100644
--- a/core/src/Kokkos_BitManipulation.hpp
+++ b/core/src/Kokkos_BitManipulation.hpp
@@ -100,9 +100,8 @@ inline constexpr bool is_standard_unsigned_integer_type_v =
 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
+#if defined(KOKKOS_ENABLE_SYCL) && defined(__INTEL_LLVM_COMPILER) && \
+    __INTEL_LLVM_COMPILER < 20240000
 using sycl::detail::bit_cast;
 #else
 template <class To, class From>
@@ -111,9 +110,14 @@ KOKKOS_FUNCTION std::enable_if_t<sizeof(To) == sizeof(From) &&
                                      std::is_trivially_copyable_v<From>,
                                  To>
 bit_cast(From const& from) noexcept {
+#if defined(KOKKOS_ENABLE_SYCL) && defined(__INTEL_LLVM_COMPILER) && \
+    __INTEL_LLVM_COMPILER >= 20240000
+  return sycl::bit_cast<To>(from);
+#else
   To to;
-  memcpy(&to, &from, sizeof(To));
+  memcpy(static_cast<void*>(&to), static_cast<const void*>(&from), sizeof(To));
   return to;
+#endif
 }
 #endif
 //</editor-fold>
@@ -283,15 +287,13 @@ 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)) {
+  if constexpr (sizeof(T) == sizeof(long long int))
     return __clzll(reinterpret_cast<long long int&>(x));
-  } else if constexpr (sizeof(T) == sizeof(int)) {
+  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;
-  }
+  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
@@ -328,11 +330,9 @@ KOKKOS_IMPL_DEVICE_FUNCTION
   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)) {
+  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;
-  }
+  return __ffs(reinterpret_cast<int&>(x)) - 1;
 #elif defined(KOKKOS_ENABLE_SYCL)
   return sycl::ctz(x);
 #else
@@ -364,11 +364,8 @@ 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);
-  }
+  if constexpr (sizeof(T) == sizeof(long long int)) return __popcll(x);
+  return __popc(x);
 #elif defined(KOKKOS_ENABLE_SYCL)
   return sycl::popcount(x);
 #else
diff --git a/core/src/Kokkos_Clamp.hpp b/core/src/Kokkos_Clamp.hpp
new file mode 100644
index 0000000000..033cde9ab8
--- /dev/null
+++ b/core/src/Kokkos_Clamp.hpp
@@ -0,0 +1,41 @@
+//@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_CLAMP_HPP
+#define KOKKOS_CLAMP_HPP
+
+#include <Kokkos_Macros.hpp>
+
+namespace Kokkos {
+
+template <class T>
+constexpr KOKKOS_INLINE_FUNCTION const T& clamp(const T& value, const T& lo,
+                                                const T& hi) {
+  KOKKOS_EXPECTS(!(hi < lo));
+  return (value < lo) ? lo : (hi < value) ? hi : value;
+}
+
+template <class T, class ComparatorType>
+constexpr KOKKOS_INLINE_FUNCTION const T& clamp(const T& value, const T& lo,
+                                                const T& hi,
+                                                ComparatorType comp) {
+  KOKKOS_EXPECTS(!comp(hi, lo));
+  return comp(value, lo) ? lo : comp(hi, value) ? hi : value;
+}
+
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Kokkos_Complex.hpp b/core/src/Kokkos_Complex.hpp
index 4cecbe4cfe..7dd2a9ddbb 100644
--- a/core/src/Kokkos_Complex.hpp
+++ b/core/src/Kokkos_Complex.hpp
@@ -28,6 +28,7 @@
 #include <complex>
 #include <type_traits>
 #include <iosfwd>
+#include <tuple>
 
 namespace Kokkos {
 
@@ -44,6 +45,11 @@ class
     alignas(2 * sizeof(RealType))
 #endif
         complex {
+  static_assert(std::is_floating_point_v<RealType> &&
+                    std::is_same_v<RealType, std::remove_cv_t<RealType>>,
+                "Kokkos::complex can only be instantiated for a cv-unqualified "
+                "floating point type");
+
  private:
   RealType re_{};
   RealType im_{};
@@ -251,6 +257,12 @@ class
     return *this;
   }
 
+  template <size_t I, typename RT>
+  friend constexpr const RT& get(const complex<RT>&) noexcept;
+
+  template <size_t I, typename RT>
+  friend constexpr const RT&& get(const complex<RT>&&) noexcept;
+
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   //! Copy constructor from volatile.
   template <
@@ -418,6 +430,75 @@ class
 #endif  // KOKKOS_ENABLE_DEPRECATED_CODE_4
 };
 
+}  // namespace Kokkos
+
+// Tuple protocol for complex based on https://wg21.link/P2819R2 (voted into
+// the C++26 working draft on 2023-11)
+
+template <typename RealType>
+struct std::tuple_size<Kokkos::complex<RealType>>
+    : std::integral_constant<size_t, 2> {};
+
+template <size_t I, typename RealType>
+struct std::tuple_element<I, Kokkos::complex<RealType>> {
+  static_assert(I < 2);
+  using type = RealType;
+};
+
+namespace Kokkos {
+
+// get<...>(...) defined here so as not to be hidden friends, as per P2819R2
+
+template <size_t I, typename RealType>
+KOKKOS_FUNCTION constexpr RealType& get(complex<RealType>& z) noexcept {
+  static_assert(I < 2);
+  if constexpr (I == 0)
+    return z.real();
+  else
+    return z.imag();
+#ifdef KOKKOS_COMPILER_INTEL
+  __builtin_unreachable();
+#endif
+}
+
+template <size_t I, typename RealType>
+KOKKOS_FUNCTION constexpr RealType&& get(complex<RealType>&& z) noexcept {
+  static_assert(I < 2);
+  if constexpr (I == 0)
+    return std::move(z.real());
+  else
+    return std::move(z.imag());
+#ifdef KOKKOS_COMPILER_INTEL
+  __builtin_unreachable();
+#endif
+}
+
+template <size_t I, typename RealType>
+KOKKOS_FUNCTION constexpr const RealType& get(
+    const complex<RealType>& z) noexcept {
+  static_assert(I < 2);
+  if constexpr (I == 0)
+    return z.re_;
+  else
+    return z.im_;
+#ifdef KOKKOS_COMPILER_INTEL
+  __builtin_unreachable();
+#endif
+}
+
+template <size_t I, typename RealType>
+KOKKOS_FUNCTION constexpr const RealType&& get(
+    const complex<RealType>&& z) noexcept {
+  static_assert(I < 2);
+  if constexpr (I == 0)
+    return std::move(z.re_);
+  else
+    return std::move(z.im_);
+#ifdef KOKKOS_COMPILER_INTEL
+  __builtin_unreachable();
+#endif
+}
+
 //==============================================================================
 // <editor-fold desc="Equality and inequality"> {{{1
 
diff --git a/core/src/Kokkos_Concepts.hpp b/core/src/Kokkos_Concepts.hpp
index 2448efab04..df78a644a0 100644
--- a/core/src/Kokkos_Concepts.hpp
+++ b/core/src/Kokkos_Concepts.hpp
@@ -117,8 +117,8 @@ template <unsigned int maxT = 0 /* Max threads per block */
 struct LaunchBounds {
   using launch_bounds = LaunchBounds;
   using type          = LaunchBounds<maxT, minB>;
-  static unsigned int constexpr maxTperB{maxT};
-  static unsigned int constexpr minBperSM{minB};
+  static constexpr unsigned int maxTperB{maxT};
+  static constexpr unsigned int minBperSM{minB};
 };
 
 }  // namespace Kokkos
diff --git a/core/src/Kokkos_CopyViews.hpp b/core/src/Kokkos_CopyViews.hpp
index 02b9cc8bd1..e856b19247 100644
--- a/core/src/Kokkos_CopyViews.hpp
+++ b/core/src/Kokkos_CopyViews.hpp
@@ -22,6 +22,7 @@ static_assert(false,
 #ifndef KOKKOS_COPYVIEWS_HPP_
 #define KOKKOS_COPYVIEWS_HPP_
 #include <string>
+#include <sstream>
 #include <Kokkos_Parallel.hpp>
 #include <KokkosExp_MDRangePolicy.hpp>
 #include <Kokkos_Layout.hpp>
@@ -220,10 +221,12 @@ struct ViewFill<ViewType, Layout, ExecSpace, 7, iType> {
   ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_,
            const ExecSpace& space)
       : a(a_), val(val_) {
+    // MDRangePolicy is not supported for 7D views
+    // Iterate separately over extent(2)
     Kokkos::parallel_for("Kokkos::ViewFill-7D",
                          policy_type(space, {0, 0, 0, 0, 0, 0},
-                                     {a.extent(0), a.extent(1), a.extent(2),
-                                      a.extent(3), a.extent(5), a.extent(6)}),
+                                     {a.extent(0), a.extent(1), a.extent(3),
+                                      a.extent(4), a.extent(5), a.extent(6)}),
                          *this);
   }
 
@@ -248,6 +251,8 @@ struct ViewFill<ViewType, Layout, ExecSpace, 8, iType> {
   ViewFill(const ViewType& a_, typename ViewType::const_value_type& val_,
            const ExecSpace& space)
       : a(a_), val(val_) {
+    // MDRangePolicy is not supported for 8D views
+    // Iterate separately over extent(2) and extent(4)
     Kokkos::parallel_for("Kokkos::ViewFill-8D",
                          policy_type(space, {0, 0, 0, 0, 0, 0},
                                      {a.extent(0), a.extent(1), a.extent(3),
@@ -292,9 +297,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 2, iType> {
   ViewTypeA a;
   ViewTypeB b;
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<2, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -322,9 +329,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 3, iType> {
   ViewTypeB b;
 
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<3, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -353,9 +362,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 4, iType> {
   ViewTypeB b;
 
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<4, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -385,9 +396,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 5, iType> {
   ViewTypeB b;
 
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<5, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -417,9 +430,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 6, iType> {
   ViewTypeB b;
 
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<6, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -449,9 +464,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 7, iType> {
   ViewTypeB b;
 
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<6, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -460,6 +477,8 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 7, iType> {
   ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_,
            const ExecSpace space = ExecSpace())
       : a(a_), b(b_) {
+    // MDRangePolicy is not supported for 7D views
+    // Iterate separately over extent(2)
     Kokkos::parallel_for("Kokkos::ViewCopy-7D",
                          policy_type(space, {0, 0, 0, 0, 0, 0},
                                      {a.extent(0), a.extent(1), a.extent(3),
@@ -482,9 +501,11 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 8, iType> {
   ViewTypeB b;
 
   static const Kokkos::Iterate outer_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::outer_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::outer_iteration_pattern;
   static const Kokkos::Iterate inner_iteration_pattern =
-      Kokkos::layout_iterate_type_selector<Layout>::inner_iteration_pattern;
+      Kokkos::Impl::layout_iterate_type_selector<
+          Layout>::inner_iteration_pattern;
   using iterate_type =
       Kokkos::Rank<6, outer_iteration_pattern, inner_iteration_pattern>;
   using policy_type =
@@ -493,6 +514,8 @@ struct ViewCopy<ViewTypeA, ViewTypeB, Layout, ExecSpace, 8, iType> {
   ViewCopy(const ViewTypeA& a_, const ViewTypeB& b_,
            const ExecSpace space = ExecSpace())
       : a(a_), b(b_) {
+    // MDRangePolicy is not supported for 8D views
+    // Iterate separately over extent(2) and extent(4)
     Kokkos::parallel_for("Kokkos::ViewCopy-8D",
                          policy_type(space, {0, 0, 0, 0, 0, 0},
                                      {a.extent(0), a.extent(1), a.extent(3),
@@ -538,11 +561,8 @@ void view_copy(const ExecutionSpace& space, const DstType& dst,
     int64_t strides[DstType::rank + 1];
     dst.stride(strides);
     Kokkos::Iterate iterate;
-    if (Kokkos::is_layouttiled<typename DstType::array_layout>::value) {
-      iterate = Kokkos::layout_iterate_type_selector<
-          typename DstType::array_layout>::outer_iteration_pattern;
-    } else if (std::is_same<typename DstType::array_layout,
-                            Kokkos::LayoutRight>::value) {
+    if (std::is_same<typename DstType::array_layout,
+                     Kokkos::LayoutRight>::value) {
       iterate = Kokkos::Iterate::Right;
     } else if (std::is_same<typename DstType::array_layout,
                             Kokkos::LayoutLeft>::value) {
@@ -612,23 +632,25 @@ void view_copy(const DstType& dst, const SrcType& src) {
   };
 
   if (!DstExecCanAccessSrc && !SrcExecCanAccessDst) {
-    std::string message(
-        "Error: Kokkos::deep_copy with no available copy mechanism: ");
-    message += src.label();
-    message += " to ";
-    message += dst.label();
-    Kokkos::Impl::throw_runtime_exception(message);
+    std::ostringstream ss;
+    ss << "Error: Kokkos::deep_copy with no available copy mechanism: "
+       << "from source view (\"" << src.label() << "\") to destination view (\""
+       << dst.label() << "\").\n"
+       << "There is no common execution space that can access both source's "
+          "space\n"
+       << "(" << src_memory_space().name() << ") and destination's space ("
+       << dst_memory_space().name() << "), "
+       << "so source and destination\n"
+       << "must be contiguous and have the same layout.\n";
+    Kokkos::Impl::throw_runtime_exception(ss.str());
   }
 
   // Figure out iteration order in case we need it
   int64_t strides[DstType::rank + 1];
   dst.stride(strides);
   Kokkos::Iterate iterate;
-  if (Kokkos::is_layouttiled<typename DstType::array_layout>::value) {
-    iterate = Kokkos::layout_iterate_type_selector<
-        typename DstType::array_layout>::outer_iteration_pattern;
-  } else if (std::is_same<typename DstType::array_layout,
-                          Kokkos::LayoutRight>::value) {
+  if (std::is_same<typename DstType::array_layout,
+                   Kokkos::LayoutRight>::value) {
     iterate = Kokkos::Iterate::Right;
   } else if (std::is_same<typename DstType::array_layout,
                           Kokkos::LayoutLeft>::value) {
@@ -1330,13 +1352,12 @@ inline void contiguous_fill(
 // Default implementation for execution spaces that don't provide a definition
 template <typename ExecutionSpace, class ViewType>
 struct ZeroMemset {
-  ZeroMemset(const ExecutionSpace& exec_space, const ViewType& dst,
-             typename ViewType::const_value_type& value) {
-    contiguous_fill(exec_space, dst, value);
-  }
-
-  ZeroMemset(const ViewType& dst, typename ViewType::const_value_type& value) {
-    contiguous_fill(ExecutionSpace(), dst, value);
+  ZeroMemset(const ExecutionSpace& exec_space, const ViewType& dst) {
+    using ValueType = typename ViewType::value_type;
+    alignas(alignof(ValueType)) unsigned char
+        zero_initialized_storage[sizeof(ValueType)] = {};
+    contiguous_fill(exec_space, dst,
+                    *reinterpret_cast<ValueType*>(zero_initialized_storage));
   }
 };
 
@@ -1348,13 +1369,18 @@ inline std::enable_if_t<
 contiguous_fill_or_memset(
     const ExecutionSpace& exec_space, const View<DT, DP...>& dst,
     typename ViewTraits<DT, DP...>::const_value_type& value) {
-// On A64FX memset seems to do the wrong thing with regards to first touch
-// leading to the significant performance issues
-#ifndef KOKKOS_ARCH_A64FX
-  if (Impl::is_zero_byte(value))
-    ZeroMemset<ExecutionSpace, View<DT, DP...>>(exec_space, dst, value);
-  else
+  // With OpenMP, using memset has significant performance issues.
+  if (Impl::is_zero_byte(value)
+#ifdef KOKKOS_ENABLE_OPENMP
+      && !std::is_same_v<ExecutionSpace, Kokkos::OpenMP>
 #endif
+  )
+    // FIXME intel/19 icpc fails to deduce template parameters here,
+    // resulting in compilation errors; explicitly passing the template
+    // parameters to ZeroMemset helps workaround the issue
+    // See https://github.com/kokkos/kokkos/issues/6775
+    ZeroMemset<ExecutionSpace, View<DT, DP...>>(exec_space, dst);
+  else
     contiguous_fill(exec_space, dst, value);
 }
 
@@ -1379,15 +1405,20 @@ contiguous_fill_or_memset(
     typename ViewTraits<DT, DP...>::const_value_type& value) {
   using ViewType        = View<DT, DP...>;
   using exec_space_type = typename ViewType::execution_space;
+  exec_space_type exec;
 
 // On A64FX memset seems to do the wrong thing with regards to first touch
 // leading to the significant performance issues
 #ifndef KOKKOS_ARCH_A64FX
   if (Impl::is_zero_byte(value))
-    ZeroMemset<exec_space_type, View<DT, DP...>>(dst, value);
+    // FIXME intel/19 icpc fails to deduce template parameters here,
+    // resulting in compilation errors; explicitly passing the template
+    // parameters to ZeroMemset helps workaround the issue
+    // See https://github.com/kokkos/kokkos/issues/6775
+    ZeroMemset<exec_space_type, ViewType>(exec, dst);
   else
 #endif
-    contiguous_fill(exec_space_type(), dst, value);
+    contiguous_fill(exec, dst, value);
 }
 
 template <class DT, class... DP>
@@ -1759,7 +1790,7 @@ inline void deep_copy(
     Kokkos::fence(
         "Kokkos::deep_copy: copy between contiguous views, pre view equality "
         "check");
-    if ((void*)dst.data() != (void*)src.data()) {
+    if ((void*)dst.data() != (void*)src.data() && 0 < nbytes) {
       Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space>(
           dst.data(), src.data(), nbytes);
       Kokkos::fence(
@@ -2906,7 +2937,7 @@ inline void deep_copy(
       ((dst_type::rank < 7) || (dst.stride_6() == src.stride_6())) &&
       ((dst_type::rank < 8) || (dst.stride_7() == src.stride_7()))) {
     const size_t nbytes = sizeof(typename dst_type::value_type) * dst.span();
-    if ((void*)dst.data() != (void*)src.data()) {
+    if ((void*)dst.data() != (void*)src.data() && 0 < nbytes) {
       Kokkos::Impl::DeepCopy<dst_memory_space, src_memory_space, ExecSpace>(
           exec_space, dst.data(), src.data(), nbytes);
     }
@@ -3077,8 +3108,7 @@ inline std::enable_if_t<
     std::is_same<typename Kokkos::View<T, P...>::array_layout,
                  Kokkos::LayoutRight>::value ||
     std::is_same<typename Kokkos::View<T, P...>::array_layout,
-                 Kokkos::LayoutStride>::value ||
-    is_layouttiled<typename Kokkos::View<T, P...>::array_layout>::value>
+                 Kokkos::LayoutStride>::value>
 impl_resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
             Kokkos::View<T, P...>& v,
             const typename Kokkos::View<T, P...>::array_layout& layout) {
@@ -3124,8 +3154,7 @@ inline std::enable_if_t<
       std::is_same<typename Kokkos::View<T, P...>::array_layout,
                    Kokkos::LayoutRight>::value ||
       std::is_same<typename Kokkos::View<T, P...>::array_layout,
-                   Kokkos::LayoutStride>::value ||
-      is_layouttiled<typename Kokkos::View<T, P...>::array_layout>::value)>
+                   Kokkos::LayoutStride>::value)>
 impl_resize(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
             Kokkos::View<T, P...>& v,
             const typename Kokkos::View<T, P...>::array_layout& layout) {
@@ -3220,7 +3249,10 @@ impl_realloc(Kokkos::View<T, P...>& v, const size_t n0, const size_t n1,
     v = view_type();  // Best effort to deallocate in case no other view refers
                       // to the shared allocation
     v = view_type(arg_prop_copy, n0, n1, n2, n3, n4, n5, n6, n7);
-  } else if (alloc_prop_input::initialize) {
+    return;
+  }
+
+  if constexpr (alloc_prop_input::initialize) {
     if constexpr (alloc_prop_input::has_execution_space) {
       const auto& exec_space =
           Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop);
@@ -3293,8 +3325,7 @@ inline std::enable_if_t<
     std::is_same<typename Kokkos::View<T, P...>::array_layout,
                  Kokkos::LayoutRight>::value ||
     std::is_same<typename Kokkos::View<T, P...>::array_layout,
-                 Kokkos::LayoutStride>::value ||
-    is_layouttiled<typename Kokkos::View<T, P...>::array_layout>::value>
+                 Kokkos::LayoutStride>::value>
 impl_realloc(Kokkos::View<T, P...>& v,
              const typename Kokkos::View<T, P...>::array_layout& layout,
              const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
@@ -3316,7 +3347,10 @@ impl_realloc(Kokkos::View<T, P...>& v,
   if (v.layout() != layout) {
     v = view_type();  // Deallocate first, if the only view to allocation
     v = view_type(arg_prop, layout);
-  } else if (alloc_prop_input::initialize) {
+    return;
+  }
+
+  if constexpr (alloc_prop_input::initialize) {
     if constexpr (alloc_prop_input::has_execution_space) {
       const auto& exec_space =
           Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop);
@@ -3336,8 +3370,7 @@ inline std::enable_if_t<
       std::is_same<typename Kokkos::View<T, P...>::array_layout,
                    Kokkos::LayoutRight>::value ||
       std::is_same<typename Kokkos::View<T, P...>::array_layout,
-                   Kokkos::LayoutStride>::value ||
-      is_layouttiled<typename Kokkos::View<T, P...>::array_layout>::value)>
+                   Kokkos::LayoutStride>::value)>
 impl_realloc(Kokkos::View<T, P...>& v,
              const typename Kokkos::View<T, P...>::array_layout& layout,
              const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
@@ -3437,255 +3470,250 @@ struct MirrorType {
   using view_type = Kokkos::View<data_type, array_layout, Space>;
 };
 
-template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space,
-                        typename Kokkos::View<T, P...>::HostMirror>
-create_mirror(const Kokkos::View<T, P...>& src,
-              const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  using src_type         = View<T, P...>;
-  using dst_type         = typename src_type::HostMirror;
+// collection of static asserts for create_mirror and create_mirror_view
+template <class... ViewCtorArgs>
+void check_view_ctor_args_create_mirror() {
   using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
 
   static_assert(
       !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
+      "The view constructor arguments passed to Kokkos::create_mirror[_view] "
       "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
-
-  auto prop_copy = Impl::with_properties_if_unset(
-      arg_prop, std::string(src.label()).append("_mirror"));
-
-  return dst_type(prop_copy, src.layout());
+  static_assert(!alloc_prop_input::has_pointer,
+                "The view constructor arguments passed to "
+                "Kokkos::create_mirror[_view] must "
+                "not include a pointer!");
+  static_assert(!alloc_prop_input::allow_padding,
+                "The view constructor arguments passed to "
+                "Kokkos::create_mirror[_view] must "
+                "not explicitly allow padding!");
 }
 
-// Create a mirror in a new space (specialization for different space)
-template <class T, class... P, class... ViewCtorArgs,
-          class Enable = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-auto create_mirror(const Kokkos::View<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-
-  static_assert(
-      !alloc_prop_input::has_label,
-      "The view constructor arguments passed to Kokkos::create_mirror "
-      "must not include a label!");
-  static_assert(
-      !alloc_prop_input::has_pointer,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not include a pointer!");
-  static_assert(
-      !alloc_prop_input::allow_padding,
-      "The view constructor arguments passed to Kokkos::create_mirror must "
-      "not explicitly allow padding!");
+// create a mirror
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs>
+inline auto create_mirror(const Kokkos::View<T, P...>& src,
+                          const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
+  check_view_ctor_args_create_mirror<ViewCtorArgs...>();
 
   auto prop_copy = Impl::with_properties_if_unset(
       arg_prop, std::string(src.label()).append("_mirror"));
-  using alloc_prop = decltype(prop_copy);
 
-  return typename Impl::MirrorType<typename alloc_prop::memory_space, T,
-                                   P...>::view_type(prop_copy, src.layout());
+  if constexpr (Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    using memory_space = typename decltype(prop_copy)::memory_space;
+    using dst_type =
+        typename Impl::MirrorType<memory_space, T, P...>::view_type;
+    return dst_type(prop_copy, src.layout());
+  } else {
+    using dst_type = typename View<T, P...>::HostMirror;
+    return dst_type(prop_copy, src.layout());
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 }  // namespace Impl
 
-template <class T, class... P>
-std::enable_if_t<std::is_void<typename ViewTraits<T, P...>::specialize>::value,
-                 typename Kokkos::View<T, P...>::HostMirror>
-create_mirror(Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror(v, Impl::ViewCtorProp<>{});
+// public interface
+template <class T, class... P,
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+auto create_mirror(Kokkos::View<T, P...> const& src) {
+  return Impl::create_mirror(src, Impl::ViewCtorProp<>{});
 }
 
-template <class T, class... P>
-std::enable_if_t<std::is_void<typename ViewTraits<T, P...>::specialize>::value,
-                 typename Kokkos::View<T, P...>::HostMirror>
-create_mirror(Kokkos::Impl::WithoutInitializing_t wi,
-              Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror(v, view_alloc(wi));
+// public interface that accepts a without initializing flag
+template <class T, class... P,
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi,
+                   Kokkos::View<T, P...> const& src) {
+  return Impl::create_mirror(src, view_alloc(wi));
 }
 
+// public interface that accepts a space
 template <class Space, class T, class... P,
-          typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-std::enable_if_t<std::is_void<typename ViewTraits<T, P...>::specialize>::value,
-                 typename Impl::MirrorType<Space, T, P...>::view_type>
-create_mirror(Space const&, Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror(v, view_alloc(typename Space::memory_space{}));
+          typename Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+auto create_mirror(Space const&, Kokkos::View<T, P...> const& src) {
+  return Impl::create_mirror(src, view_alloc(typename Space::memory_space{}));
 }
 
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs,
-          typename Enable = std::enable_if_t<
-              std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 auto create_mirror(Impl::ViewCtorProp<ViewCtorArgs...> const& arg_prop,
-                   Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror(v, arg_prop);
-}
-
-template <class T, class... P, class... ViewCtorArgs>
-std::enable_if_t<
-    std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space,
-    typename Kokkos::View<T, P...>::HostMirror>
-create_mirror(Impl::ViewCtorProp<ViewCtorArgs...> const& arg_prop,
-              Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror(v, arg_prop);
+                   Kokkos::View<T, P...> const& src) {
+  return Impl::create_mirror(src, arg_prop);
 }
 
+// public interface that accepts a space and a without initializing flag
 template <class Space, class T, class... P,
-          typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-std::enable_if_t<std::is_void<typename ViewTraits<T, P...>::specialize>::value,
-                 typename Impl::MirrorType<Space, T, P...>::view_type>
-create_mirror(Kokkos::Impl::WithoutInitializing_t wi, Space const&,
-              Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror(v, view_alloc(typename Space::memory_space{}, wi));
+          typename Enable = std::enable_if_t<
+              Kokkos::is_space<Space>::value &&
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
+auto create_mirror(Kokkos::Impl::WithoutInitializing_t wi, Space const&,
+                   Kokkos::View<T, P...> const& src) {
+  return Impl::create_mirror(src,
+                             view_alloc(typename Space::memory_space{}, wi));
 }
 
 namespace Impl {
 
-template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        (std::is_same<
-             typename Kokkos::View<T, P...>::memory_space,
-             typename Kokkos::View<T, P...>::HostMirror::memory_space>::value &&
-         std::is_same<
-             typename Kokkos::View<T, P...>::data_type,
-             typename Kokkos::View<T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::View<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::View<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
+// choose a `Kokkos::create_mirror` adapted for the provided view and the
+// provided arguments
+template <class View, class... ViewCtorArgs>
+inline auto choose_create_mirror(
+    const View& src, const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
+  // Due to the fact that users can overload `Kokkos::create_mirror`, but also
+  // that they may not have implemented all of its different possible
+  // variations, this function chooses the correct private or public version of
+  // it to call.
+  // This helper should be used by any overload of
+  // `Kokkos::Impl::create_mirror_view`.
+
+  if constexpr (std::is_void_v<typename View::traits::specialize>) {
+    // if the view is not specialized, just call the Impl function
+
+    // using ADL to find the later defined overload of the function
+    using namespace Kokkos::Impl;
+
+    return create_mirror(src, arg_prop);
+  } else {
+    // otherwise, recreate the public call
+    using ViewProp = Impl::ViewCtorProp<ViewCtorArgs...>;
+
+    // using ADL to find the later defined overload of the function
+    using namespace Kokkos;
+
+    if constexpr (sizeof...(ViewCtorArgs) == 0) {
+      // if there are no view constructor args, call the specific public
+      // function
+      return create_mirror(src);
+    } else if constexpr (sizeof...(ViewCtorArgs) == 1 &&
+                         ViewProp::has_memory_space) {
+      // if there is one view constructor arg and it has a memory space, call
+      // the specific public function
+      return create_mirror(typename ViewProp::memory_space{}, src);
+    } else if constexpr (sizeof...(ViewCtorArgs) == 1 &&
+                         !ViewProp::initialize) {
+      // if there is one view constructor arg and it has a without initializing
+      // mark, call the specific public function
+      return create_mirror(typename Kokkos::Impl::WithoutInitializing_t{}, src);
+    } else if constexpr (sizeof...(ViewCtorArgs) == 2 &&
+                         ViewProp::has_memory_space && !ViewProp::initialize) {
+      // if there is two view constructor args and they have a memory space and
+      // a without initializing mark, call the specific public function
+      return create_mirror(typename Kokkos::Impl::WithoutInitializing_t{},
+                           typename ViewProp::memory_space{}, src);
+    } else {
+      // if there are other constructor args, call the generic public function
+
+      // Beware, there are some libraries using Kokkos that don't implement
+      // this overload (hence the reason for this present function to exist).
+      return create_mirror(arg_prop, src);
+    }
+  }
+
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 
+// create a mirror view
+// private interface that accepts arbitrary view constructor args passed by a
+// view_alloc
 template <class T, class... P, class... ViewCtorArgs>
-inline std::enable_if_t<
-    !Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space &&
-        !(std::is_same<typename Kokkos::View<T, P...>::memory_space,
-                       typename Kokkos::View<
-                           T, P...>::HostMirror::memory_space>::value &&
-          std::is_same<
-              typename Kokkos::View<T, P...>::data_type,
-              typename Kokkos::View<T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::View<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::View<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::Impl::create_mirror(src, arg_prop);
-}
-
-// Create a mirror view in a new space (specialization for same space)
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-std::enable_if_t<Impl::MirrorViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::is_same_memspace,
-                 typename Impl::MirrorViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::view_type>
-create_mirror_view(const Kokkos::View<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>&) {
-  return src;
-}
-
-// Create a mirror view in a new space (specialization for different space)
-template <class T, class... P, class... ViewCtorArgs,
-          class = std::enable_if_t<
-              Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space>>
-std::enable_if_t<!Impl::MirrorViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::is_same_memspace,
-                 typename Impl::MirrorViewType<
-                     typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space,
-                     T, P...>::view_type>
-create_mirror_view(const Kokkos::View<T, P...>& src,
-                   const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
-  return Kokkos::Impl::create_mirror(src, arg_prop);
+inline auto create_mirror_view(
+    const Kokkos::View<T, P...>& src,
+    [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop) {
+  if constexpr (!Impl::ViewCtorProp<ViewCtorArgs...>::has_memory_space) {
+    if constexpr (std::is_same<typename Kokkos::View<T, P...>::memory_space,
+                               typename Kokkos::View<
+                                   T, P...>::HostMirror::memory_space>::value &&
+                  std::is_same<typename Kokkos::View<T, P...>::data_type,
+                               typename Kokkos::View<
+                                   T, P...>::HostMirror::data_type>::value) {
+      check_view_ctor_args_create_mirror<ViewCtorArgs...>();
+      return typename Kokkos::View<T, P...>::HostMirror(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  } else {
+    if constexpr (Impl::MirrorViewType<typename Impl::ViewCtorProp<
+                                           ViewCtorArgs...>::memory_space,
+                                       T, P...>::is_same_memspace) {
+      check_view_ctor_args_create_mirror<ViewCtorArgs...>();
+      return typename Impl::MirrorViewType<
+          typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
+          P...>::view_type(src);
+    } else {
+      return Kokkos::Impl::choose_create_mirror(src, arg_prop);
+    }
+  }
+#if defined(KOKKOS_COMPILER_INTEL) ||                                 \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+  __builtin_unreachable();
+#endif
 }
 }  // namespace Impl
 
+// public interface
 template <class T, class... P>
-std::enable_if_t<
-    std::is_same<
-        typename Kokkos::View<T, P...>::memory_space,
-        typename Kokkos::View<T, P...>::HostMirror::memory_space>::value &&
-        std::is_same<
-            typename Kokkos::View<T, P...>::data_type,
-            typename Kokkos::View<T, P...>::HostMirror::data_type>::value,
-    typename Kokkos::View<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::View<T, P...>& src) {
-  return src;
-}
-
-template <class T, class... P>
-std::enable_if_t<
-    !(std::is_same<
-          typename Kokkos::View<T, P...>::memory_space,
-          typename Kokkos::View<T, P...>::HostMirror::memory_space>::value &&
-      std::is_same<
-          typename Kokkos::View<T, P...>::data_type,
-          typename Kokkos::View<T, P...>::HostMirror::data_type>::value),
-    typename Kokkos::View<T, P...>::HostMirror>
-create_mirror_view(const Kokkos::View<T, P...>& src) {
-  return Kokkos::create_mirror(src);
+auto create_mirror_view(const Kokkos::View<T, P...>& src) {
+  return Impl::create_mirror_view(src, view_alloc());
 }
 
+// public interface that accepts a without initializing flag
 template <class T, class... P>
-typename Kokkos::View<T, P...>::HostMirror create_mirror_view(
-    Kokkos::Impl::WithoutInitializing_t wi, Kokkos::View<T, P...> const& v) {
-  return Impl::create_mirror_view(v, view_alloc(wi));
-}
-
-// FIXME_C++17 Improve SFINAE here.
-template <class Space, class T, class... P,
-          class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
-    const Space&, const Kokkos::View<T, P...>& src,
-    std::enable_if_t<Impl::MirrorViewType<Space, T, P...>::is_same_memspace>* =
-        nullptr) {
-  return src;
+auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi,
+                        Kokkos::View<T, P...> const& src) {
+  return Impl::create_mirror_view(src, view_alloc(wi));
 }
 
-// FIXME_C++17 Improve SFINAE here.
+// public interface that accepts a space
 template <class Space, class T, class... P,
           class Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
-    const Space& space, const Kokkos::View<T, P...>& src,
-    std::enable_if_t<!Impl::MirrorViewType<Space, T, P...>::is_same_memspace>* =
-        nullptr) {
-  return Kokkos::create_mirror(space, src);
+auto create_mirror_view(const Space&, const Kokkos::View<T, P...>& src) {
+  return Impl::create_mirror_view(src,
+                                  view_alloc(typename Space::memory_space()));
 }
 
+// public interface that accepts a space and a without initializing flag
 template <class Space, class T, class... P,
           typename Enable = std::enable_if_t<Kokkos::is_space<Space>::value>>
-typename Impl::MirrorViewType<Space, T, P...>::view_type create_mirror_view(
-    Kokkos::Impl::WithoutInitializing_t wi, Space const&,
-    Kokkos::View<T, P...> const& v) {
+auto create_mirror_view(Kokkos::Impl::WithoutInitializing_t wi, Space const&,
+                        Kokkos::View<T, P...> const& src) {
   return Impl::create_mirror_view(
-      v, view_alloc(typename Space::memory_space{}, wi));
+      src, view_alloc(typename Space::memory_space{}, wi));
 }
 
-template <class T, class... P, class... ViewCtorArgs>
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class T, class... P, class... ViewCtorArgs,
+          typename = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 auto create_mirror_view(const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-                        const Kokkos::View<T, P...>& v) {
-  return Impl::create_mirror_view(v, arg_prop);
+                        const Kokkos::View<T, P...>& src) {
+  return Impl::create_mirror_view(src, arg_prop);
 }
 
-template <class... ViewCtorArgs, class T, class... P>
-auto create_mirror_view_and_copy(
-    const Impl::ViewCtorProp<ViewCtorArgs...>&,
-    const Kokkos::View<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        Impl::MirrorViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace>* = nullptr) {
+namespace Impl {
+
+// collection of static asserts for create_mirror_view_and_copy
+template <class... ViewCtorArgs>
+void check_view_ctor_args_create_mirror_view_and_copy() {
   using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
+
   static_assert(
       alloc_prop_input::has_memory_space,
       "The view constructor arguments passed to "
@@ -3698,52 +3726,53 @@ auto create_mirror_view_and_copy(
                 "The view constructor arguments passed to "
                 "Kokkos::create_mirror_view_and_copy must "
                 "not explicitly allow padding!");
-
-  // same behavior as deep_copy(src, src)
-  if (!alloc_prop_input::has_execution_space)
-    fence(
-        "Kokkos::create_mirror_view_and_copy: fence before returning src view");
-  return src;
 }
 
-template <class... ViewCtorArgs, class T, class... P>
+}  // namespace Impl
+
+// create a mirror view and deep copy it
+// public interface that accepts arbitrary view constructor args passed by a
+// view_alloc
+template <class... ViewCtorArgs, class T, class... P,
+          class Enable = std::enable_if_t<
+              std::is_void_v<typename ViewTraits<T, P...>::specialize>>>
 auto create_mirror_view_and_copy(
-    const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
-    const Kokkos::View<T, P...>& src,
-    std::enable_if_t<
-        std::is_void<typename ViewTraits<T, P...>::specialize>::value &&
-        !Impl::MirrorViewType<
-            typename Impl::ViewCtorProp<ViewCtorArgs...>::memory_space, T,
-            P...>::is_same_memspace>* = nullptr) {
+    [[maybe_unused]] const Impl::ViewCtorProp<ViewCtorArgs...>& arg_prop,
+    const Kokkos::View<T, P...>& src) {
   using alloc_prop_input = Impl::ViewCtorProp<ViewCtorArgs...>;
-  static_assert(
-      alloc_prop_input::has_memory_space,
-      "The view constructor arguments passed to "
-      "Kokkos::create_mirror_view_and_copy must include a memory space!");
-  static_assert(!alloc_prop_input::has_pointer,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not include a pointer!");
-  static_assert(!alloc_prop_input::allow_padding,
-                "The view constructor arguments passed to "
-                "Kokkos::create_mirror_view_and_copy must "
-                "not explicitly allow padding!");
-  using Space  = typename alloc_prop_input::memory_space;
-  using Mirror = typename Impl::MirrorViewType<Space, T, P...>::view_type;
-
-  auto arg_prop_copy = Impl::with_properties_if_unset(
-      arg_prop, std::string{}, WithoutInitializing,
-      typename Space::execution_space{});
-
-  std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
-  if (label.empty()) label = src.label();
-  auto mirror = typename Mirror::non_const_type{arg_prop_copy, src.layout()};
-  if constexpr (alloc_prop_input::has_execution_space) {
-    deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
-              mirror, src);
-  } else
-    deep_copy(mirror, src);
-  return mirror;
+
+  Impl::check_view_ctor_args_create_mirror_view_and_copy<ViewCtorArgs...>();
+
+  if constexpr (Impl::MirrorViewType<typename alloc_prop_input::memory_space, T,
+                                     P...>::is_same_memspace) {
+    // same behavior as deep_copy(src, src)
+    if constexpr (!alloc_prop_input::has_execution_space)
+      fence(
+          "Kokkos::create_mirror_view_and_copy: fence before returning src "
+          "view");
+    return src;
+  } else {
+    using Space  = typename alloc_prop_input::memory_space;
+    using Mirror = typename Impl::MirrorViewType<Space, T, P...>::view_type;
+
+    auto arg_prop_copy = Impl::with_properties_if_unset(
+        arg_prop, std::string{}, WithoutInitializing,
+        typename Space::execution_space{});
+
+    std::string& label = Impl::get_property<Impl::LabelTag>(arg_prop_copy);
+    if (label.empty()) label = src.label();
+    auto mirror = typename Mirror::non_const_type{arg_prop_copy, src.layout()};
+    if constexpr (alloc_prop_input::has_execution_space) {
+      deep_copy(Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop_copy),
+                mirror, src);
+    } else
+      deep_copy(mirror, src);
+    return mirror;
+  }
+#if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+    !defined(KOKKOS_COMPILER_MSVC)
+  __builtin_unreachable();
+#endif
 }
 
 // Previously when using auto here, the intel compiler 19.3 would
diff --git a/core/src/Kokkos_Core.hpp b/core/src/Kokkos_Core.hpp
index 805411a699..1f146563be 100644
--- a/core/src/Kokkos_Core.hpp
+++ b/core/src/Kokkos_Core.hpp
@@ -46,14 +46,15 @@
 
 #include <Kokkos_Half.hpp>
 #include <Kokkos_AnonymousSpace.hpp>
-#include <Kokkos_LogicalSpaces.hpp>
 #include <Kokkos_Pair.hpp>
-#include <Kokkos_MinMaxClamp.hpp>
+#include <Kokkos_Clamp.hpp>
+#include <Kokkos_MinMax.hpp>
 #include <Kokkos_MathematicalConstants.hpp>
 #include <Kokkos_MathematicalFunctions.hpp>
 #include <Kokkos_MathematicalSpecialFunctions.hpp>
 #include <Kokkos_NumericTraits.hpp>
 #include <Kokkos_BitManipulation.hpp>
+#include <Kokkos_Swap.hpp>
 #include <Kokkos_MemoryPool.hpp>
 #include <Kokkos_Array.hpp>
 #include <Kokkos_View.hpp>
@@ -101,6 +102,7 @@ void declare_configuration_metadata(const std::string& category,
 [[nodiscard]] bool is_finalized() noexcept;
 
 [[nodiscard]] int device_id() noexcept;
+[[nodiscard]] int num_devices() noexcept;
 [[nodiscard]] int num_threads() noexcept;
 
 bool show_warnings() noexcept;
@@ -300,9 +302,6 @@ std::vector<ExecSpace> partition_space(ExecSpace const& space,
 // implementation of the RAII wrapper is using Kokkos::single.
 #include <Kokkos_AcquireUniqueTokenImpl.hpp>
 
-// Specializations required after core definitions
-#include <KokkosCore_Config_PostInclude.hpp>
-
 //----------------------------------------------------------------------------
 // Redefinition of the macros min and max if we pushed them at entry of
 // Kokkos_Core.hpp
diff --git a/core/src/Kokkos_Core_fwd.hpp b/core/src/Kokkos_Core_fwd.hpp
index 25f89ae3c7..7edb35f00e 100644
--- a/core/src/Kokkos_Core_fwd.hpp
+++ b/core/src/Kokkos_Core_fwd.hpp
@@ -26,13 +26,10 @@
 // and compiler environment then sets a collection of #define macros.
 
 #include <Kokkos_Macros.hpp>
+#include <Kokkos_Printf.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_Utilities.hpp>
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-#include <Kokkos_MasterLock.hpp>
-#endif
-
 //----------------------------------------------------------------------------
 // Have assumed a 64-bit build (8-byte pointers) throughout the code base.
 // 32-bit build allowed but unsupported.
@@ -74,9 +71,6 @@ template <class ExecutionSpace, class MemorySpace>
 struct Device;
 
 // forward declare here so that backend initializer calls can use it.
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-struct InitArguments;
-#endif
 class InitializationSettings;
 
 }  // namespace Kokkos
@@ -261,12 +255,6 @@ KOKKOS_FUNCTION void runtime_check_memory_access_violation(
 }
 
 }  // namespace Impl
-
-namespace Experimental {
-template <class, class, class, class>
-class LogicalMemorySpace;
-}
-
 }  // namespace Kokkos
 
 //----------------------------------------------------------------------------
diff --git a/core/src/Kokkos_ExecPolicy.hpp b/core/src/Kokkos_ExecPolicy.hpp
index ae1585a498..b8d7f77deb 100644
--- a/core/src/Kokkos_ExecPolicy.hpp
+++ b/core/src/Kokkos_ExecPolicy.hpp
@@ -28,6 +28,7 @@ static_assert(false,
 #include <impl/Kokkos_AnalyzePolicy.hpp>
 #include <Kokkos_Concepts.hpp>
 #include <typeinfo>
+#include <limits>
 
 //----------------------------------------------------------------------------
 
@@ -39,7 +40,12 @@ struct ParallelReduceTag {};
 
 struct ChunkSize {
   int value;
+  explicit ChunkSize(int value_) : value(value_) {}
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT("ChunkSize should be constructed explicitly.")
   ChunkSize(int value_) : value(value_) {}
+#endif
 };
 
 /** \brief  Execution policy for work over a range of an integral type.
@@ -114,62 +120,67 @@ class RangePolicy : public Impl::PolicyTraits<Properties...> {
         m_granularity_mask(0) {}
 
   /** \brief  Total range */
+  template <typename IndexType1, typename IndexType2,
+            std::enable_if_t<(std::is_convertible_v<IndexType1, member_type> &&
+                              std::is_convertible_v<IndexType2, member_type>),
+                             bool> = false>
+  inline RangePolicy(const IndexType1 work_begin, const IndexType2 work_end)
+      : RangePolicy(typename traits::execution_space(), work_begin, work_end) {}
+
+  /** \brief  Total range */
+  template <typename IndexType1, typename IndexType2,
+            std::enable_if_t<(std::is_convertible_v<IndexType1, member_type> &&
+                              std::is_convertible_v<IndexType2, member_type>),
+                             bool> = false>
   inline RangePolicy(const typename traits::execution_space& work_space,
-                     const member_type work_begin, const member_type work_end)
+                     const IndexType1 work_begin, const IndexType2 work_end)
       : m_space(work_space),
-        m_begin(work_begin < work_end ? work_begin : 0),
-        m_end(work_begin < work_end ? work_end : 0),
+        m_begin(work_begin),
+        m_end(work_end),
         m_granularity(0),
         m_granularity_mask(0) {
+    check_conversion_safety(work_begin);
+    check_conversion_safety(work_end);
+    check_bounds_validity();
     set_auto_chunk_size();
   }
 
-  /** \brief  Total range */
-  inline RangePolicy(const member_type work_begin, const member_type work_end)
-      : RangePolicy(typename traits::execution_space(), work_begin, work_end) {
-    set_auto_chunk_size();
-  }
-
-  /** \brief  Total range */
-  template <class... Args>
-  inline RangePolicy(const typename traits::execution_space& work_space,
-                     const member_type work_begin, const member_type work_end,
-                     Args... args)
+  template <typename IndexType1, typename IndexType2,
+            std::enable_if_t<(std::is_convertible_v<IndexType1, member_type> &&
+                              std::is_convertible_v<IndexType2, member_type>),
+                             bool> = false>
+  RangePolicy(const typename traits::execution_space& work_space,
+              const IndexType1 work_begin, const IndexType2 work_end,
+              const ChunkSize chunk_size)
       : m_space(work_space),
-        m_begin(work_begin < work_end ? work_begin : 0),
-        m_end(work_begin < work_end ? work_end : 0),
+        m_begin(work_begin),
+        m_end(work_end),
         m_granularity(0),
         m_granularity_mask(0) {
-    set_auto_chunk_size();
-    set(args...);
+    check_conversion_safety(work_begin);
+    check_conversion_safety(work_end);
+    check_bounds_validity();
+    set_chunk_size(chunk_size.value);
   }
 
   /** \brief  Total range */
-  template <class... Args>
-  inline RangePolicy(const member_type work_begin, const member_type work_end,
-                     Args... args)
-      : RangePolicy(typename traits::execution_space(), work_begin, work_end) {
-    set_auto_chunk_size();
-    set(args...);
-  }
-
- private:
-  inline void set() {}
+  template <typename IndexType1, typename IndexType2, typename... Args,
+            std::enable_if_t<(std::is_convertible_v<IndexType1, member_type> &&
+                              std::is_convertible_v<IndexType2, member_type>),
+                             bool> = false>
+  RangePolicy(const IndexType1 work_begin, const IndexType2 work_end,
+              const ChunkSize chunk_size)
+      : RangePolicy(typename traits::execution_space(), work_begin, work_end,
+                    chunk_size) {}
 
  public:
-  template <class... Args>
-  inline void set(Args...) {
-    static_assert(
-        0 == sizeof...(Args),
-        "Kokkos::RangePolicy: unhandled constructor arguments encountered.");
-  }
-
-  template <class... Args>
-  inline void set(const ChunkSize& chunksize, Args... args) {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED_WITH_COMMENT("Use set_chunk_size instead")
+  inline void set(ChunkSize chunksize) {
     m_granularity      = chunksize.value;
     m_granularity_mask = m_granularity - 1;
-    set(args...);
   }
+#endif
 
  public:
   /** \brief return chunk_size */
@@ -218,6 +229,67 @@ class RangePolicy : public Impl::PolicyTraits<Properties...> {
     m_granularity_mask = m_granularity - 1;
   }
 
+  void check_bounds_validity() {
+    if (m_end < m_begin) {
+      std::string msg = "Kokkos::RangePolicy bounds error: The lower bound (" +
+                        std::to_string(m_begin) +
+                        ") is greater than the upper bound (" +
+                        std::to_string(m_end) + ").\n";
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_4
+      Kokkos::abort(msg.c_str());
+#endif
+      m_begin = 0;
+      m_end   = 0;
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+      Kokkos::Impl::log_warning(msg);
+#endif
+    }
+  }
+
+  // To be replaced with std::in_range (c++20)
+  template <typename IndexType>
+  static void check_conversion_safety(const IndexType bound) {
+#if !defined(KOKKOS_ENABLE_DEPRECATED_CODE_4) || \
+    defined(KOKKOS_ENABLE_DEPRECATION_WARNINGS)
+
+    std::string msg =
+        "Kokkos::RangePolicy bound type error: an unsafe implicit conversion "
+        "is performed on a bound (" +
+        std::to_string(bound) +
+        "), which may "
+        "not preserve its original value.\n";
+    bool warn = false;
+
+    if constexpr (std::is_signed_v<IndexType> !=
+                  std::is_signed_v<member_type>) {
+      // check signed to unsigned
+      if constexpr (std::is_signed_v<IndexType>)
+        warn |= (bound < static_cast<IndexType>(
+                             std::numeric_limits<member_type>::min()));
+
+      // check unsigned to signed
+      if constexpr (std::is_signed_v<member_type>)
+        warn |= (bound > static_cast<IndexType>(
+                             std::numeric_limits<member_type>::max()));
+    }
+
+    // check narrowing
+    warn |= (static_cast<IndexType>(static_cast<member_type>(bound)) != bound);
+
+    if (warn) {
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_4
+      Kokkos::abort(msg.c_str());
+#endif
+
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+      Kokkos::Impl::log_warning(msg);
+#endif
+    }
+#else
+    (void)bound;
+#endif
+  }
+
  public:
   /** \brief  Subrange for a partition's rank and size.
    *
@@ -261,6 +333,21 @@ class RangePolicy : public Impl::PolicyTraits<Properties...> {
   };
 };
 
+RangePolicy()->RangePolicy<>;
+
+RangePolicy(int64_t, int64_t)->RangePolicy<>;
+RangePolicy(int64_t, int64_t, ChunkSize const&)->RangePolicy<>;
+
+RangePolicy(DefaultExecutionSpace const&, int64_t, int64_t)->RangePolicy<>;
+RangePolicy(DefaultExecutionSpace const&, int64_t, int64_t, ChunkSize const&)
+    ->RangePolicy<>;
+
+template <typename ES, typename = std::enable_if_t<is_execution_space_v<ES>>>
+RangePolicy(ES const&, int64_t, int64_t)->RangePolicy<ES>;
+
+template <typename ES, typename = std::enable_if_t<is_execution_space_v<ES>>>
+RangePolicy(ES const&, int64_t, int64_t, ChunkSize const&)->RangePolicy<ES>;
+
 }  // namespace Kokkos
 
 //----------------------------------------------------------------------------
@@ -632,6 +719,58 @@ class TeamPolicy
   }
 };
 
+// Execution space not provided deduces to TeamPolicy<>
+
+TeamPolicy()->TeamPolicy<>;
+
+TeamPolicy(int, int)->TeamPolicy<>;
+TeamPolicy(int, int, int)->TeamPolicy<>;
+TeamPolicy(int, Kokkos::AUTO_t const&)->TeamPolicy<>;
+TeamPolicy(int, Kokkos::AUTO_t const&, int)->TeamPolicy<>;
+TeamPolicy(int, Kokkos::AUTO_t const&, Kokkos::AUTO_t const&)->TeamPolicy<>;
+TeamPolicy(int, int, Kokkos::AUTO_t const&)->TeamPolicy<>;
+
+// DefaultExecutionSpace deduces to TeamPolicy<>
+
+TeamPolicy(DefaultExecutionSpace const&, int, int)->TeamPolicy<>;
+TeamPolicy(DefaultExecutionSpace const&, int, int, int)->TeamPolicy<>;
+TeamPolicy(DefaultExecutionSpace const&, int, Kokkos::AUTO_t const&)
+    ->TeamPolicy<>;
+TeamPolicy(DefaultExecutionSpace const&, int, Kokkos::AUTO_t const&, int)
+    ->TeamPolicy<>;
+TeamPolicy(DefaultExecutionSpace const&, int, Kokkos::AUTO_t const&,
+           Kokkos::AUTO_t const&)
+    ->TeamPolicy<>;
+TeamPolicy(DefaultExecutionSpace const&, int, int, Kokkos::AUTO_t const&)
+    ->TeamPolicy<>;
+
+// ES != DefaultExecutionSpace deduces to TeamPolicy<ES>
+
+template <typename ES,
+          typename = std::enable_if_t<Kokkos::is_execution_space_v<ES>>>
+TeamPolicy(ES const&, int, int)->TeamPolicy<ES>;
+
+template <typename ES,
+          typename = std::enable_if_t<Kokkos::is_execution_space_v<ES>>>
+TeamPolicy(ES const&, int, int, int)->TeamPolicy<ES>;
+
+template <typename ES,
+          typename = std::enable_if_t<Kokkos::is_execution_space_v<ES>>>
+TeamPolicy(ES const&, int, Kokkos::AUTO_t const&)->TeamPolicy<ES>;
+
+template <typename ES,
+          typename = std::enable_if_t<Kokkos::is_execution_space_v<ES>>>
+TeamPolicy(ES const&, int, Kokkos::AUTO_t const&, int)->TeamPolicy<ES>;
+
+template <typename ES,
+          typename = std::enable_if_t<Kokkos::is_execution_space_v<ES>>>
+TeamPolicy(ES const&, int, Kokkos::AUTO_t const&, Kokkos::AUTO_t const&)
+    ->TeamPolicy<ES>;
+
+template <typename ES,
+          typename = std::enable_if_t<Kokkos::is_execution_space_v<ES>>>
+TeamPolicy(ES const&, int, int, Kokkos::AUTO_t const&)->TeamPolicy<ES>;
+
 namespace Impl {
 
 template <typename iType, class TeamMemberType>
@@ -886,9 +1025,9 @@ struct TeamThreadMDRange<Rank<N, OuterDir, InnerDir>, TeamHandle> {
   static constexpr auto par_vector = Impl::TeamMDRangeParVector::NotParVector;
 
   static constexpr Iterate direction =
-      OuterDir == Iterate::Default
-          ? layout_iterate_type_selector<ArrayLayout>::outer_iteration_pattern
-          : iter;
+      OuterDir == Iterate::Default ? Impl::layout_iterate_type_selector<
+                                         ArrayLayout>::outer_iteration_pattern
+                                   : iter;
 
   template <class... Args>
   KOKKOS_FUNCTION TeamThreadMDRange(TeamHandleType const& team_, Args&&... args)
@@ -901,7 +1040,7 @@ struct TeamThreadMDRange<Rank<N, OuterDir, InnerDir>, TeamHandle> {
 };
 
 template <typename TeamHandle, typename... Args>
-TeamThreadMDRange(TeamHandle const&, Args&&...)
+KOKKOS_DEDUCTION_GUIDE TeamThreadMDRange(TeamHandle const&, Args&&...)
     ->TeamThreadMDRange<Rank<sizeof...(Args), Iterate::Default>, TeamHandle>;
 
 template <typename Rank, typename TeamHandle>
@@ -922,9 +1061,9 @@ struct ThreadVectorMDRange<Rank<N, OuterDir, InnerDir>, TeamHandle> {
   static constexpr auto par_vector = Impl::TeamMDRangeParVector::ParVector;
 
   static constexpr Iterate direction =
-      OuterDir == Iterate::Default
-          ? layout_iterate_type_selector<ArrayLayout>::outer_iteration_pattern
-          : iter;
+      OuterDir == Iterate::Default ? Impl::layout_iterate_type_selector<
+                                         ArrayLayout>::outer_iteration_pattern
+                                   : iter;
 
   template <class... Args>
   KOKKOS_INLINE_FUNCTION ThreadVectorMDRange(TeamHandleType const& team_,
@@ -938,7 +1077,7 @@ struct ThreadVectorMDRange<Rank<N, OuterDir, InnerDir>, TeamHandle> {
 };
 
 template <typename TeamHandle, typename... Args>
-ThreadVectorMDRange(TeamHandle const&, Args&&...)
+KOKKOS_DEDUCTION_GUIDE ThreadVectorMDRange(TeamHandle const&, Args&&...)
     ->ThreadVectorMDRange<Rank<sizeof...(Args), Iterate::Default>, TeamHandle>;
 
 template <typename Rank, typename TeamHandle>
@@ -959,9 +1098,9 @@ struct TeamVectorMDRange<Rank<N, OuterDir, InnerDir>, TeamHandle> {
   static constexpr auto par_vector = Impl::TeamMDRangeParVector::ParVector;
 
   static constexpr Iterate direction =
-      iter == Iterate::Default
-          ? layout_iterate_type_selector<ArrayLayout>::outer_iteration_pattern
-          : iter;
+      iter == Iterate::Default ? Impl::layout_iterate_type_selector<
+                                     ArrayLayout>::outer_iteration_pattern
+                               : iter;
 
   template <class... Args>
   KOKKOS_INLINE_FUNCTION TeamVectorMDRange(TeamHandleType const& team_,
@@ -975,7 +1114,7 @@ struct TeamVectorMDRange<Rank<N, OuterDir, InnerDir>, TeamHandle> {
 };
 
 template <typename TeamHandle, typename... Args>
-TeamVectorMDRange(TeamHandle const&, Args&&...)
+KOKKOS_DEDUCTION_GUIDE TeamVectorMDRange(TeamHandle const&, Args&&...)
     ->TeamVectorMDRange<Rank<sizeof...(Args), Iterate::Default>, TeamHandle>;
 
 template <typename Rank, typename TeamHandle, typename Lambda,
@@ -983,7 +1122,16 @@ template <typename Rank, typename TeamHandle, typename Lambda,
 KOKKOS_INLINE_FUNCTION void parallel_reduce(
     TeamThreadMDRange<Rank, TeamHandle> const& policy, Lambda const& lambda,
     ReducerValueType& val) {
+  static_assert(/*!Kokkos::is_view_v<ReducerValueType> &&*/
+                !std::is_array_v<ReducerValueType> &&
+                    !std::is_pointer_v<ReducerValueType> &&
+                    !Kokkos::is_reducer_v<ReducerValueType>,
+                "Only scalar return types are allowed!");
+
+  val = ReducerValueType{};
   Impl::md_parallel_impl<Rank>(policy, lambda, val);
+  policy.team.team_reduce(
+      Kokkos::Sum<ReducerValueType, typename TeamHandle::execution_space>{val});
 }
 
 template <typename Rank, typename TeamHandle, typename Lambda>
@@ -997,7 +1145,29 @@ template <typename Rank, typename TeamHandle, typename Lambda,
 KOKKOS_INLINE_FUNCTION void parallel_reduce(
     ThreadVectorMDRange<Rank, TeamHandle> const& policy, Lambda const& lambda,
     ReducerValueType& val) {
+  static_assert(/*!Kokkos::is_view_v<ReducerValueType> &&*/
+                !std::is_array_v<ReducerValueType> &&
+                    !std::is_pointer_v<ReducerValueType> &&
+                    !Kokkos::is_reducer_v<ReducerValueType>,
+                "Only a scalar return types are allowed!");
+
+  val = ReducerValueType{};
   Impl::md_parallel_impl<Rank>(policy, lambda, val);
+  if constexpr (false
+#ifdef KOKKOS_ENABLE_CUDA
+                || std::is_same_v<typename TeamHandle::execution_space,
+                                  Kokkos::Cuda>
+#elif defined(KOKKOS_ENABLE_HIP)
+                || std::is_same_v<typename TeamHandle::execution_space,
+                                  Kokkos::HIP>
+#elif defined(KOKKOS_ENABLE_SYCL)
+                || std::is_same_v<typename TeamHandle::execution_space,
+                                  Kokkos::Experimental::SYCL>
+#endif
+  )
+    policy.team.vector_reduce(
+        Kokkos::Sum<ReducerValueType, typename TeamHandle::execution_space>{
+            val});
 }
 
 template <typename Rank, typename TeamHandle, typename Lambda>
@@ -1011,7 +1181,31 @@ template <typename Rank, typename TeamHandle, typename Lambda,
 KOKKOS_INLINE_FUNCTION void parallel_reduce(
     TeamVectorMDRange<Rank, TeamHandle> const& policy, Lambda const& lambda,
     ReducerValueType& val) {
+  static_assert(/*!Kokkos::is_view_v<ReducerValueType> &&*/
+                !std::is_array_v<ReducerValueType> &&
+                    !std::is_pointer_v<ReducerValueType> &&
+                    !Kokkos::is_reducer_v<ReducerValueType>,
+                "Only a scalar return types are allowed!");
+
+  val = ReducerValueType{};
   Impl::md_parallel_impl<Rank>(policy, lambda, val);
+  if constexpr (false
+#ifdef KOKKOS_ENABLE_CUDA
+                || std::is_same_v<typename TeamHandle::execution_space,
+                                  Kokkos::Cuda>
+#elif defined(KOKKOS_ENABLE_HIP)
+                || std::is_same_v<typename TeamHandle::execution_space,
+                                  Kokkos::HIP>
+#elif defined(KOKKOS_ENABLE_SYCL)
+                || std::is_same_v<typename TeamHandle::execution_space,
+                                  Kokkos::Experimental::SYCL>
+#endif
+  )
+    policy.team.vector_reduce(
+        Kokkos::Sum<ReducerValueType, typename TeamHandle::execution_space>{
+            val});
+  policy.team.team_reduce(
+      Kokkos::Sum<ReducerValueType, typename TeamHandle::execution_space>{val});
 }
 
 template <typename Rank, typename TeamHandle, typename Lambda>
diff --git a/core/src/Kokkos_Extents.hpp b/core/src/Kokkos_Extents.hpp
index 7968fab3aa..9bc2eda604 100644
--- a/core/src/Kokkos_Extents.hpp
+++ b/core/src/Kokkos_Extents.hpp
@@ -25,33 +25,40 @@ static_assert(false,
 #include <cstddef>
 #include <type_traits>
 #include <Kokkos_Macros.hpp>
+#ifdef KOKKOS_ENABLE_IMPL_MDSPAN
+#include <mdspan/mdspan.hpp>
+#else
+#include <limits>
+#endif
 
 namespace Kokkos {
-namespace Experimental {
 
-constexpr ptrdiff_t dynamic_extent = -1;
+#ifndef KOKKOS_ENABLE_IMPL_MDSPAN
+constexpr size_t dynamic_extent = std::numeric_limits<size_t>::max();
+#endif
 
-template <ptrdiff_t... ExtentSpecs>
+namespace Experimental {
+
+template <size_t... ExtentSpecs>
 struct Extents {
   /* TODO @enhancement flesh this out more */
 };
 
-template <class Exts, ptrdiff_t NewExtent>
+template <class Exts, size_t NewExtent>
 struct PrependExtent;
 
-template <ptrdiff_t... Exts, ptrdiff_t NewExtent>
+template <size_t... Exts, size_t NewExtent>
 struct PrependExtent<Extents<Exts...>, NewExtent> {
   using type = Extents<NewExtent, Exts...>;
 };
 
-template <class Exts, ptrdiff_t NewExtent>
+template <class Exts, size_t NewExtent>
 struct AppendExtent;
 
-template <ptrdiff_t... Exts, ptrdiff_t NewExtent>
+template <size_t... Exts, size_t NewExtent>
 struct AppendExtent<Extents<Exts...>, NewExtent> {
   using type = Extents<Exts..., NewExtent>;
 };
-
 }  // end namespace Experimental
 
 namespace Impl {
@@ -75,33 +82,32 @@ struct _parse_impl {
 
 // We have to treat the case of int**[x] specially, since it *doesn't* go
 // backwards
-template <class T, ptrdiff_t... ExtentSpec>
+template <class T, size_t... ExtentSpec>
 struct _parse_impl<T*, Kokkos::Experimental::Extents<ExtentSpec...>,
                    std::enable_if_t<_all_remaining_extents_dynamic<T>::value>>
-    : _parse_impl<T, Kokkos::Experimental::Extents<
-                         Kokkos::Experimental::dynamic_extent, ExtentSpec...>> {
-};
+    : _parse_impl<T, Kokkos::Experimental::Extents<Kokkos::dynamic_extent,
+                                                   ExtentSpec...>> {};
 
 // int*(*[x])[y] should still work also (meaning int[][x][][y])
-template <class T, ptrdiff_t... ExtentSpec>
+template <class T, size_t... ExtentSpec>
 struct _parse_impl<
     T*, Kokkos::Experimental::Extents<ExtentSpec...>,
     std::enable_if_t<!_all_remaining_extents_dynamic<T>::value>> {
   using _next = Kokkos::Experimental::AppendExtent<
       typename _parse_impl<T, Kokkos::Experimental::Extents<ExtentSpec...>,
                            void>::type,
-      Kokkos::Experimental::dynamic_extent>;
+      Kokkos::dynamic_extent>;
   using type = typename _next::type;
 };
 
-template <class T, ptrdiff_t... ExtentSpec, unsigned N>
+template <class T, size_t... ExtentSpec, unsigned N>
 struct _parse_impl<T[N], Kokkos::Experimental::Extents<ExtentSpec...>, void>
-    : _parse_impl<
-          T, Kokkos::Experimental::Extents<ExtentSpec...,
-                                           ptrdiff_t(N)>  // TODO @pedantic this
-                                                          // could be a
-                                                          // narrowing cast
-          > {};
+    : _parse_impl<T,
+                  Kokkos::Experimental::Extents<ExtentSpec...,
+                                                size_t(N)>  // TODO @pedantic
+                                                            // this could be a
+                                                            // narrowing cast
+                  > {};
 
 }  // end namespace _parse_view_extents_impl
 
@@ -111,38 +117,34 @@ struct ParseViewExtents {
       DataType, Kokkos::Experimental::Extents<>>::type;
 };
 
-template <class ValueType, ptrdiff_t Ext>
+template <class ValueType, size_t Ext>
 struct ApplyExtent {
   using type = ValueType[Ext];
 };
 
 template <class ValueType>
-struct ApplyExtent<ValueType, Kokkos::Experimental::dynamic_extent> {
+struct ApplyExtent<ValueType, Kokkos::dynamic_extent> {
   using type = ValueType*;
 };
 
-template <class ValueType, unsigned N, ptrdiff_t Ext>
+template <class ValueType, unsigned N, size_t Ext>
 struct ApplyExtent<ValueType[N], Ext> {
   using type = typename ApplyExtent<ValueType, Ext>::type[N];
 };
 
-template <class ValueType, ptrdiff_t Ext>
+template <class ValueType, size_t Ext>
 struct ApplyExtent<ValueType*, Ext> {
   using type = ValueType * [Ext];
 };
 
 template <class ValueType>
-struct ApplyExtent<ValueType*, Kokkos::Experimental::dynamic_extent> {
-  using type =
-      typename ApplyExtent<ValueType,
-                           Kokkos::Experimental::dynamic_extent>::type*;
+struct ApplyExtent<ValueType*, dynamic_extent> {
+  using type = typename ApplyExtent<ValueType, dynamic_extent>::type*;
 };
 
 template <class ValueType, unsigned N>
-struct ApplyExtent<ValueType[N], Kokkos::Experimental::dynamic_extent> {
-  using type =
-      typename ApplyExtent<ValueType,
-                           Kokkos::Experimental::dynamic_extent>::type[N];
+struct ApplyExtent<ValueType[N], dynamic_extent> {
+  using type = typename ApplyExtent<ValueType, dynamic_extent>::type[N];
 };
 
 }  // end namespace Impl
diff --git a/core/src/Kokkos_Graph.hpp b/core/src/Kokkos_Graph.hpp
index 7f77c00b2d..9cc6650e26 100644
--- a/core/src/Kokkos_Graph.hpp
+++ b/core/src/Kokkos_Graph.hpp
@@ -161,6 +161,15 @@ Graph<ExecutionSpace> create_graph(Closure&& arg_closure) {
 #include <impl/Kokkos_GraphNodeImpl.hpp>
 #include <impl/Kokkos_Default_Graph_Impl.hpp>
 #include <Cuda/Kokkos_Cuda_Graph_Impl.hpp>
+#if defined(KOKKOS_ENABLE_HIP)
+// The implementation of hipGraph in ROCm 5.2 is bugged, so we cannot use it.
+#if !((HIP_VERSION_MAJOR == 5) && (HIP_VERSION_MINOR == 2))
+#include <HIP/Kokkos_HIP_Graph_Impl.hpp>
+#endif
+#endif
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+#include <SYCL/Kokkos_SYCL_Graph_Impl.hpp>
+#endif
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_GRAPH
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_GRAPH
diff --git a/core/src/Kokkos_HBWSpace.hpp b/core/src/Kokkos_HBWSpace.hpp
deleted file mode 100644
index 369b7bafb7..0000000000
--- a/core/src/Kokkos_HBWSpace.hpp
+++ /dev/null
@@ -1,308 +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_HBWSPACE_HPP
-#define KOKKOS_HBWSPACE_HPP
-
-#include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_HBWSPACE
-
-#include <Kokkos_HostSpace.hpp>
-
-namespace Kokkos {
-
-namespace Experimental {
-
-/// \class HBWSpace
-/// \brief Memory management for host memory.
-///
-/// HBWSpace is a memory space that governs host memory.  "Host"
-/// memory means the usual CPU-accessible memory.
-class HBWSpace {
- public:
-  //! Tag this class as a kokkos memory space
-  using memory_space = HBWSpace;
-  using size_type    = size_t;
-
-  /// \typedef execution_space
-  /// \brief Default execution space for this memory space.
-  ///
-  /// Every memory space has a default execution space.  This is
-  /// useful for things like initializing a View (which happens in
-  /// parallel using the View's default execution space).
-  using execution_space = Kokkos::DefaultHostExecutionSpace;
-
-  //! This memory space preferred device_type
-  using device_type = Kokkos::Device<execution_space, memory_space>;
-
-  /**\brief  Default memory space instance */
-  HBWSpace();
-  HBWSpace(const HBWSpace& rhs) = default;
-  HBWSpace& operator=(const HBWSpace&) = default;
-  ~HBWSpace()                          = default;
-
-  /**\brief  Non-default memory space instance to choose allocation mechansim,
-   * if available */
-
-  enum AllocationMechanism {
-    STD_MALLOC,
-    POSIX_MEMALIGN,
-    POSIX_MMAP,
-    INTEL_MM_ALLOC
-  };
-
-  explicit HBWSpace(const AllocationMechanism&);
-
-  /**\brief  Allocate untracked memory in the space */
-  void* allocate(const size_t arg_alloc_size) const;
-  void* allocate(const char* arg_label, const size_t arg_alloc_size,
-                 const size_t arg_logical_size = 0) const;
-
-  /**\brief  Deallocate untracked memory in the space */
-  void deallocate(void* const arg_alloc_ptr, const size_t arg_alloc_size) const;
-  void deallocate(const char* arg_label, void* const arg_alloc_ptr,
-                  const size_t arg_alloc_size,
-                  const size_t arg_logical_size = 0) const;
-
- private:
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
-
-  void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
-                      const size_t arg_logical_size = 0,
-                      const Kokkos::Tools::SpaceHandle =
-                          Kokkos::Tools::make_space_handle(name())) const;
-  void impl_deallocate(const char* arg_label, void* const arg_alloc_ptr,
-                       const size_t arg_alloc_size,
-                       const size_t arg_logical_size = 0,
-                       const Kokkos::Tools::SpaceHandle =
-                           Kokkos::Tools::make_space_handle(name())) const;
-
- public:
-  /**\brief Return Name of the MemorySpace */
-  static constexpr const char* name() { return "HBW"; }
-
- private:
-  AllocationMechanism m_alloc_mech;
-  friend class Kokkos::Impl::SharedAllocationRecord<
-      Kokkos::Experimental::HBWSpace, void>;
-};
-
-}  // namespace Experimental
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-
-template <>
-class SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>
-    : public SharedAllocationRecord<void, void> {
- private:
-  friend Kokkos::Experimental::HBWSpace;
-
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-  static void deallocate(RecordBase*);
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  /**\brief  Root record for tracked allocations from this HBWSpace instance */
-  static RecordBase s_root_record;
-#endif
-
-  const Kokkos::Experimental::HBWSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::HBWSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate);
-
- public:
-  inline std::string get_label() const {
-    return std::string(RecordBase::head()->m_label);
-  }
-
-  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
-      const Kokkos::Experimental::HBWSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size) {
-    KOKKOS_IF_ON_HOST((return new SharedAllocationRecord(arg_space, arg_label,
-                                                         arg_alloc_size);))
-    KOKKOS_IF_ON_DEVICE(((void)arg_space; (void)arg_label; (void)arg_alloc_size;
-                         return nullptr;))
-  }
-
-  /**\brief  Allocate tracked memory in the space */
-  static void* allocate_tracked(const Kokkos::Experimental::HBWSpace& arg_space,
-                                const std::string& arg_label,
-                                const size_t arg_alloc_size);
-
-  /**\brief  Reallocate tracked memory in the space */
-  static void* reallocate_tracked(void* const arg_alloc_ptr,
-                                  const size_t arg_alloc_size);
-
-  /**\brief  Deallocate tracked memory in the space */
-  static void deallocate_tracked(void* const arg_alloc_ptr);
-
-  static SharedAllocationRecord* get_record(void* arg_alloc_ptr);
-
-  static void print_records(std::ostream&,
-                            const Kokkos::Experimental::HBWSpace&,
-                            bool detail = false);
-};
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-
-static_assert(
-    Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::HBWSpace,
-                                    Kokkos::Experimental::HBWSpace>::assignable,
-    "");
-
-template <>
-struct MemorySpaceAccess<Kokkos::HostSpace, Kokkos::Experimental::HBWSpace> {
-  enum : bool { assignable = true };
-  enum : bool { accessible = true };
-  enum : bool { deepcopy = true };
-};
-
-template <>
-struct MemorySpaceAccess<Kokkos::Experimental::HBWSpace, Kokkos::HostSpace> {
-  enum : bool { assignable = false };
-  enum : bool { accessible = true };
-  enum : bool { deepcopy = true };
-};
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-
-template <>
-struct DeepCopy<Kokkos::Experimental::HBWSpace, Kokkos::Experimental::HBWSpace,
-                DefaultHostExecutionSpace> {
-  DeepCopy(void* dst, const void* src, size_t n) {
-    hostspace_parallel_deepcopy(dst, src, n);
-  }
-
-  DeepCopy(const DefaultHostExecutionSpace& exec, void* dst, const void* src,
-           size_t n) {
-    hostspace_parallel_deepcopy(exec, dst, src, n);
-  }
-};
-
-template <class ExecutionSpace>
-struct DeepCopy<Kokkos::Experimental::HBWSpace, Kokkos::Experimental::HBWSpace,
-                ExecutionSpace> {
-  DeepCopy(void* dst, const void* src, size_t n) {
-    hostspace_parallel_deepcopy(dst, src, n);
-  }
-
-  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
-    exec.fence(
-        "Kokkos::Impl::DeepCopy<Kokkos::Experimental::HBWSpace, "
-        "Kokkos::Experimental::HBWSpace,ExecutionSpace::DeepCopy: fence "
-        "before copy");
-    hostspace_parallel_deepcopy_async(dst, src, n);
-  }
-};
-
-template <>
-struct DeepCopy<HostSpace, Kokkos::Experimental::HBWSpace,
-                DefaultHostExecutionSpace> {
-  DeepCopy(void* dst, const void* src, size_t n) {
-    hostspace_parallel_deepcopy(dst, src, n);
-  }
-
-  DeepCopy(const DefaultHostExecutionSpace& exec, void* dst, const void* src,
-           size_t n) {
-    hostspace_parallel_deepcopy(exec, dst, src, n);
-  }
-};
-
-template <class ExecutionSpace>
-struct DeepCopy<HostSpace, Kokkos::Experimental::HBWSpace, ExecutionSpace> {
-  DeepCopy(void* dst, const void* src, size_t n) {
-    hostspace_parallel_deepcopy(dst, src, n);
-  }
-
-  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
-    exec.fence(
-        "Kokkos::Impl::DeepCopy<HostSpace, Kokkos::Experimental::HBWSpace, "
-        "ExecutionSpace>::DeepCopy: fence before copy");
-    hostspace_parallel_deepcopy_async(copy_space, dst, src, n);
-  }
-};
-
-template <>
-struct DeepCopy<Kokkos::Experimental::HBWSpace, HostSpace,
-                DefaultHostExecutionSpace> {
-  DeepCopy(void* dst, const void* src, size_t n) {
-    hostspace_parallel_deepcopy(dst, src, n);
-  }
-
-  DeepCopy(const DefaultHostExecutionSpace& exec, void* dst, const void* src,
-           size_t n) {
-    hostspace_parallel_deepcopy(exec, dst, src, n);
-  }
-};
-
-template <class ExecutionSpace>
-struct DeepCopy<Kokkos::Experimental::HBWSpace, HostSpace, ExecutionSpace> {
-  DeepCopy(void* dst, const void* src, size_t n) {
-    hostspace_parallel_deepcopy(dst, src, n);
-  }
-
-  DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
-    exec.fence(
-        "Kokkos::Impl::DeepCopy<Kokkos::Experimental::HBWSpace, HostSpace, "
-        "ExecutionSpace>::DeepCopy: fence before copy");
-    hostspace_parallel_deepcopy_async(dst, src, n);
-  }
-};
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-#endif
-#endif  // #define KOKKOS_HBWSPACE_HPP
diff --git a/core/src/Kokkos_Half.hpp b/core/src/Kokkos_Half.hpp
index 91b94b4cfa..33217efe80 100644
--- a/core/src/Kokkos_Half.hpp
+++ b/core/src/Kokkos_Half.hpp
@@ -23,6 +23,7 @@
 
 #include <impl/Kokkos_Half_FloatingPointWrapper.hpp>
 #include <impl/Kokkos_Half_NumericTraits.hpp>
+#include <impl/Kokkos_Half_MathematicalFunctions.hpp>
 
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_HALF
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
diff --git a/core/src/Kokkos_HostSpace.hpp b/core/src/Kokkos_HostSpace.hpp
index 4990337ab9..8b5f29f95b 100644
--- a/core/src/Kokkos_HostSpace.hpp
+++ b/core/src/Kokkos_HostSpace.hpp
@@ -37,7 +37,6 @@ static_assert(false,
 #include <impl/Kokkos_Tools.hpp>
 
 #include "impl/Kokkos_HostSpace_deepcopy.hpp"
-#include <impl/Kokkos_MemorySpace.hpp>
 
 /*--------------------------------------------------------------------------*/
 
@@ -64,27 +63,46 @@ class HostSpace {
   //! This memory space preferred device_type
   using device_type = Kokkos::Device<execution_space, memory_space>;
 
-  /**\brief  Default memory space instance */
-  HostSpace();
+  HostSpace()                     = default;
   HostSpace(HostSpace&& rhs)      = default;
   HostSpace(const HostSpace& rhs) = default;
   HostSpace& operator=(HostSpace&&) = default;
   HostSpace& operator=(const HostSpace&) = default;
   ~HostSpace()                           = default;
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   /**\brief  Non-default memory space instance to choose allocation mechansim,
    * if available */
 
-  enum AllocationMechanism {
-    STD_MALLOC,
-    POSIX_MEMALIGN,
-    POSIX_MMAP,
-    INTEL_MM_ALLOC
-  };
-
+#if defined(KOKKOS_COMPILER_GNU) && KOKKOS_COMPILER_GNU < 1100
+  // We see deprecation warnings even when not using the deprecated
+  // HostSpace constructor below when using gcc before release 11.
+  enum
+#else
+  enum KOKKOS_DEPRECATED
+#endif
+      AllocationMechanism {
+        STD_MALLOC,
+        POSIX_MEMALIGN,
+        POSIX_MMAP,
+        INTEL_MM_ALLOC
+      };
+
+  KOKKOS_DEPRECATED
   explicit HostSpace(const AllocationMechanism&);
+#endif
 
   /**\brief  Allocate untracked memory in the space */
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -95,10 +113,6 @@ class HostSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
- private:
-  template <class, class, class, class>
-  friend class Kokkos::Experimental::LogicalMemorySpace;
-
   void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
                       const size_t arg_logical_size = 0,
                       const Kokkos::Tools::SpaceHandle =
@@ -109,14 +123,11 @@ class HostSpace {
                        const Kokkos::Tools::SpaceHandle =
                            Kokkos::Tools::make_space_handle(name())) const;
 
- public:
   /**\brief Return Name of the MemorySpace */
   static constexpr const char* name() { return m_name; }
 
  private:
-  AllocationMechanism m_alloc_mech;
   static constexpr const char* m_name = "Host";
-  friend class Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void>;
 };
 
 }  // namespace Kokkos
@@ -128,8 +139,7 @@ namespace Kokkos {
 namespace Impl {
 
 static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                              Kokkos::HostSpace>::assignable,
-              "");
+                                              Kokkos::HostSpace>::assignable);
 
 template <typename S>
 struct HostMirror {
@@ -165,75 +175,7 @@ struct HostMirror {
 
 //----------------------------------------------------------------------------
 
-namespace Kokkos {
-
-namespace Impl {
-
-template <>
-class SharedAllocationRecord<Kokkos::HostSpace, void>
-    : public SharedAllocationRecordCommon<Kokkos::HostSpace> {
- private:
-  friend Kokkos::HostSpace;
-  friend class SharedAllocationRecordCommon<Kokkos::HostSpace>;
-
-  using base_t     = SharedAllocationRecordCommon<Kokkos::HostSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  /**\brief  Root record for tracked allocations from this HostSpace instance */
-  static RecordBase s_root_record;
-#endif
-
-  const Kokkos::HostSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  // This constructor does not forward to the one without exec_space arg
-  // in order to work around https://github.com/kokkos/kokkos/issues/5258
-  // This constructor is templated so I can't just put it into the cpp file
-  // like the other constructor.
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /* exec_space*/, const Kokkos::HostSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate)
-      : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-            &SharedAllocationRecord<Kokkos::HostSpace, void>::s_root_record,
-#endif
-            Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                 arg_alloc_size),
-            sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-            arg_label),
-        m_space(arg_space) {
-    this->base_t::_fill_host_accessible_header_info(*RecordBase::m_alloc_ptr,
-                                                    arg_label);
-  }
-
-  SharedAllocationRecord(
-      const Kokkos::HostSpace& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate);
-
- public:
-  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
-      const Kokkos::HostSpace& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size) {
-    KOKKOS_IF_ON_HOST((return new SharedAllocationRecord(arg_space, arg_label,
-                                                         arg_alloc_size);))
-    KOKKOS_IF_ON_DEVICE(((void)arg_space; (void)arg_label; (void)arg_alloc_size;
-                         return nullptr;))
-  }
-};
-
-}  // namespace Impl
-
-}  // namespace Kokkos
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(Kokkos::HostSpace);
 
 //----------------------------------------------------------------------------
 
diff --git a/core/src/Kokkos_Layout.hpp b/core/src/Kokkos_Layout.hpp
index ca4d956784..37b80e54a8 100644
--- a/core/src/Kokkos_Layout.hpp
+++ b/core/src/Kokkos_Layout.hpp
@@ -217,81 +217,12 @@ enum class Iterate {
   Right  // Right indices stride fastest
 };
 
-// To check for LayoutTiled
-// This is to hide extra compile-time 'identifier' info within the LayoutTiled
-// class by not relying on template specialization to include the ArgN*'s
-template <typename LayoutTiledCheck, class Enable = void>
-struct is_layouttiled : std::false_type {};
-
-template <typename LayoutTiledCheck>
-struct is_layouttiled<LayoutTiledCheck,
-                      std::enable_if_t<LayoutTiledCheck::is_array_layout_tiled>>
-    : std::true_type {};
-
-namespace Experimental {
-
-/// LayoutTiled
-// Must have Rank >= 2
-template <
-    Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-    unsigned ArgN1, unsigned ArgN2 = 0, unsigned ArgN3 = 0, unsigned ArgN4 = 0,
-    unsigned ArgN5 = 0, unsigned ArgN6 = 0, unsigned ArgN7 = 0,
-    bool IsPowerOfTwo =
-        (Kokkos::Impl::is_integral_power_of_two(ArgN0) &&
-         Kokkos::Impl::is_integral_power_of_two(ArgN1) &&
-         (Kokkos::Impl::is_integral_power_of_two(ArgN2) || (ArgN2 == 0)) &&
-         (Kokkos::Impl::is_integral_power_of_two(ArgN3) || (ArgN3 == 0)) &&
-         (Kokkos::Impl::is_integral_power_of_two(ArgN4) || (ArgN4 == 0)) &&
-         (Kokkos::Impl::is_integral_power_of_two(ArgN5) || (ArgN5 == 0)) &&
-         (Kokkos::Impl::is_integral_power_of_two(ArgN6) || (ArgN6 == 0)) &&
-         (Kokkos::Impl::is_integral_power_of_two(ArgN7) || (ArgN7 == 0)))>
-struct LayoutTiled {
-  static_assert(IsPowerOfTwo,
-                "LayoutTiled must be given power-of-two tile dimensions");
-
-  using array_layout = LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3,
-                                   ArgN4, ArgN5, ArgN6, ArgN7, IsPowerOfTwo>;
-  static constexpr Iterate outer_pattern = OuterP;
-  static constexpr Iterate inner_pattern = InnerP;
-
-  enum { N0 = ArgN0 };
-  enum { N1 = ArgN1 };
-  enum { N2 = ArgN2 };
-  enum { N3 = ArgN3 };
-  enum { N4 = ArgN4 };
-  enum { N5 = ArgN5 };
-  enum { N6 = ArgN6 };
-  enum { N7 = ArgN7 };
-
-  size_t dimension[ARRAY_LAYOUT_MAX_RANK];
-
-  enum : bool { is_extent_constructible = true };
-
-  LayoutTiled(LayoutTiled const&) = default;
-  LayoutTiled(LayoutTiled&&)      = default;
-  LayoutTiled& operator=(LayoutTiled const&) = default;
-  LayoutTiled& operator=(LayoutTiled&&) = default;
-
-  KOKKOS_INLINE_FUNCTION
-  explicit constexpr LayoutTiled(size_t argN0 = 0, size_t argN1 = 0,
-                                 size_t argN2 = 0, size_t argN3 = 0,
-                                 size_t argN4 = 0, size_t argN5 = 0,
-                                 size_t argN6 = 0, size_t argN7 = 0)
-      : dimension{argN0, argN1, argN2, argN3, argN4, argN5, argN6, argN7} {}
-
-  friend bool operator==(const LayoutTiled& left, const LayoutTiled& right) {
-    for (unsigned int rank = 0; rank < ARRAY_LAYOUT_MAX_RANK; ++rank)
-      if (left.dimension[rank] != right.dimension[rank]) return false;
-    return true;
-  }
-
-  friend bool operator!=(const LayoutTiled& left, const LayoutTiled& right) {
-    return !(left == right);
-  }
-};
-
-}  // namespace Experimental
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+template <typename Layout, class Enable = void>
+struct KOKKOS_DEPRECATED is_layouttiled : std::false_type {};
+#endif
 
+namespace Impl {
 // For use with view_copy
 template <typename... Layout>
 struct layout_iterate_type_selector {
@@ -320,42 +251,13 @@ struct layout_iterate_type_selector<Kokkos::LayoutStride> {
   static const Kokkos::Iterate inner_iteration_pattern =
       Kokkos::Iterate::Default;
 };
+}  // namespace Impl
 
-template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
-          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
-struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
-    Kokkos::Iterate::Left, Kokkos::Iterate::Left, ArgN0, ArgN1, ArgN2, ArgN3,
-    ArgN4, ArgN5, ArgN6, ArgN7, true>> {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left;
-};
-
-template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
-          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
-struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
-    Kokkos::Iterate::Right, Kokkos::Iterate::Left, ArgN0, ArgN1, ArgN2, ArgN3,
-    ArgN4, ArgN5, ArgN6, ArgN7, true>> {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Left;
-};
-
-template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
-          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
-struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
-    Kokkos::Iterate::Left, Kokkos::Iterate::Right, ArgN0, ArgN1, ArgN2, ArgN3,
-    ArgN4, ArgN5, ArgN6, ArgN7, true>> {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Left;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right;
-};
-
-template <unsigned ArgN0, unsigned ArgN1, unsigned ArgN2, unsigned ArgN3,
-          unsigned ArgN4, unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
-struct layout_iterate_type_selector<Kokkos::Experimental::LayoutTiled<
-    Kokkos::Iterate::Right, Kokkos::Iterate::Right, ArgN0, ArgN1, ArgN2, ArgN3,
-    ArgN4, ArgN5, ArgN6, ArgN7, true>> {
-  static const Kokkos::Iterate outer_iteration_pattern = Kokkos::Iterate::Right;
-  static const Kokkos::Iterate inner_iteration_pattern = Kokkos::Iterate::Right;
-};
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+template <typename... Layout>
+using layout_iterate_type_selector KOKKOS_DEPRECATED =
+    Impl::layout_iterate_type_selector<Layout...>;
+#endif
 
 }  // namespace Kokkos
 
diff --git a/core/src/Kokkos_LogicalSpaces.hpp b/core/src/Kokkos_LogicalSpaces.hpp
deleted file mode 100644
index 1ee1d2c81f..0000000000
--- a/core/src/Kokkos_LogicalSpaces.hpp
+++ /dev/null
@@ -1,413 +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_LOGICALSPACES_HPP
-#define KOKKOS_LOGICALSPACES_HPP
-
-#include <Kokkos_Macros.hpp>
-#include <Kokkos_Core_fwd.hpp>
-#include <Kokkos_ScratchSpace.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
-#include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_SharedAlloc.hpp>
-#include <impl/Kokkos_Profiling.hpp>
-#include <cstring>
-namespace Kokkos {
-namespace Experimental {
-struct DefaultMemorySpaceNamer {
-  static constexpr const char* get_name() {
-    return "DefaultLogicalMemorySpaceName";
-  }
-};
-
-struct LogicalSpaceSharesAccess {
-  struct shared_access {};
-  struct no_shared_access {};
-};
-
-/// \class LogicalMemorySpace
-/// \brief
-///
-/// LogicalMemorySpace is a space that is identical to another space,
-/// but differentiable by name and template argument
-template <class BaseSpace, class DefaultBaseExecutionSpace = void,
-          class Namer                = DefaultMemorySpaceNamer,
-          class SharesAccessWithBase = LogicalSpaceSharesAccess::shared_access>
-class LogicalMemorySpace {
-#ifdef KOKKOS_ENABLE_OPENMPTARGET
-  // [DZP] For some reason I don't yet know, using LogicalMemorySpaces
-  // inside an OpenMPTarget build causes errors in the
-  // SharedAllocationRecords of other types. This is my way of erroring
-  // a build if we instantiate a LogicalMemSpace in an OMPTarget build
-  static_assert(!std::is_same<BaseSpace, BaseSpace>::value,
-                "Can't use LogicalMemorySpaces in an OpenMPTarget build, we're "
-                "debugging memory issues");
-#endif
- public:
-  //! Tag this class as a kokkos memory space
-  using memory_space = LogicalMemorySpace<BaseSpace, DefaultBaseExecutionSpace,
-                                          Namer, SharesAccessWithBase>;
-  using size_type    = typename BaseSpace::size_type;
-
-  /// \typedef execution_space
-  /// \brief Default execution space for this memory space.
-  ///
-  /// Every memory space has a default execution space.  This is
-  /// useful for things like initializing a View (which happens in
-  /// parallel using the View's default execution space).
-
-  using execution_space =
-      std::conditional_t<std::is_void<DefaultBaseExecutionSpace>::value,
-                         typename BaseSpace::execution_space,
-                         DefaultBaseExecutionSpace>;
-
-  using device_type = Kokkos::Device<execution_space, memory_space>;
-
-  LogicalMemorySpace() = default;
-
-  template <typename... Args>
-  LogicalMemorySpace(Args&&... args) : underlying_space((Args &&) args...) {}
-
-  /**\brief  Allocate untracked memory in the space */
-  void* allocate(const size_t arg_alloc_size) const {
-    return allocate("[unlabeled]", arg_alloc_size);
-  }
-  void* allocate(const char* arg_label, const size_t arg_alloc_size,
-                 const size_t arg_logical_size = 0) const {
-    return impl_allocate(arg_label, arg_alloc_size, arg_logical_size);
-  }
-
-  /**\brief  Deallocate untracked memory in the space */
-  void deallocate(void* const arg_alloc_ptr,
-                  const size_t arg_alloc_size) const {
-    deallocate("[unlabeled]", arg_alloc_ptr, arg_alloc_size);
-  }
-  void deallocate(const char* arg_label, void* const arg_alloc_ptr,
-                  const size_t arg_alloc_size,
-                  const size_t arg_logical_size = 0) const {
-    impl_deallocate(arg_label, arg_alloc_ptr, arg_alloc_size, arg_logical_size);
-  }
-
-  /**\brief Return Name of the MemorySpace */
-  constexpr static const char* name() { return Namer::get_name(); }
-
- private:
-  BaseSpace underlying_space;
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
-  friend class Kokkos::Impl::SharedAllocationRecord<memory_space, void>;
-
-  void* impl_allocate(const char* arg_label, const size_t arg_alloc_size,
-                      const size_t arg_logical_size = 0,
-                      Kokkos::Tools::SpaceHandle arg_handle =
-                          Kokkos::Tools::make_space_handle(name())) const {
-    return underlying_space.impl_allocate(arg_label, arg_alloc_size,
-                                          arg_logical_size, arg_handle);
-  }
-  void impl_deallocate(const char* arg_label, void* const arg_alloc_ptr,
-                       const size_t arg_alloc_size,
-                       const size_t arg_logical_size = 0,
-                       const Kokkos::Tools::SpaceHandle arg_handle =
-                           Kokkos::Tools::make_space_handle(name())) const {
-    underlying_space.impl_deallocate(arg_label, arg_alloc_ptr, arg_alloc_size,
-                                     arg_logical_size, arg_handle);
-  }
-};
-}  // namespace Experimental
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-
-template <typename BaseSpace, typename DefaultBaseExecutionSpace, class Namer,
-          typename OtherSpace>
-struct MemorySpaceAccess<
-    Kokkos::Experimental::LogicalMemorySpace<
-        BaseSpace, DefaultBaseExecutionSpace, Namer,
-        Kokkos::Experimental::LogicalSpaceSharesAccess::shared_access>,
-    OtherSpace> {
-  enum { assignable = MemorySpaceAccess<BaseSpace, OtherSpace>::assignable };
-  enum { accessible = MemorySpaceAccess<BaseSpace, OtherSpace>::accessible };
-  enum { deepcopy = MemorySpaceAccess<BaseSpace, OtherSpace>::deepcopy };
-};
-
-template <typename BaseSpace, typename DefaultBaseExecutionSpace, class Namer,
-          typename OtherSpace>
-struct MemorySpaceAccess<
-    OtherSpace,
-    Kokkos::Experimental::LogicalMemorySpace<
-        BaseSpace, DefaultBaseExecutionSpace, Namer,
-        Kokkos::Experimental::LogicalSpaceSharesAccess::shared_access>> {
-  enum { assignable = MemorySpaceAccess<OtherSpace, BaseSpace>::assignable };
-  enum { accessible = MemorySpaceAccess<OtherSpace, BaseSpace>::accessible };
-  enum { deepcopy = MemorySpaceAccess<OtherSpace, BaseSpace>::deepcopy };
-};
-
-template <typename BaseSpace, typename DefaultBaseExecutionSpace, class Namer>
-struct MemorySpaceAccess<
-    Kokkos::Experimental::LogicalMemorySpace<
-        BaseSpace, DefaultBaseExecutionSpace, Namer,
-        Kokkos::Experimental::LogicalSpaceSharesAccess::shared_access>,
-    Kokkos::Experimental::LogicalMemorySpace<
-        BaseSpace, DefaultBaseExecutionSpace, Namer,
-        Kokkos::Experimental::LogicalSpaceSharesAccess::shared_access>> {
-  enum { assignable = true };
-  enum { accessible = true };
-  enum { deepcopy = true };
-};
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-template <class BaseSpace, class DefaultBaseExecutionSpace, class Namer,
-          class SharesAccessSemanticsWithBase>
-class SharedAllocationRecord<Kokkos::Experimental::LogicalMemorySpace<
-                                 BaseSpace, DefaultBaseExecutionSpace, Namer,
-                                 SharesAccessSemanticsWithBase>,
-                             void> : public SharedAllocationRecord<void, void> {
- private:
-  using SpaceType =
-      Kokkos::Experimental::LogicalMemorySpace<BaseSpace,
-                                               DefaultBaseExecutionSpace, Namer,
-                                               SharesAccessSemanticsWithBase>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-  static void deallocate(RecordBase* arg_rec) {
-    delete static_cast<SharedAllocationRecord*>(arg_rec);
-  }
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  /**\brief  Root record for tracked allocations from this
-   * LogicalMemorySpace instance */
-  static RecordBase s_root_record;
-#endif
-
-  const SpaceType m_space;
-
- protected:
-  ~SharedAllocationRecord() {
-    m_space.deallocate(RecordBase::m_alloc_ptr->m_label,
-                       SharedAllocationRecord<void, void>::m_alloc_ptr,
-                       SharedAllocationRecord<void, void>::m_alloc_size,
-                       (SharedAllocationRecord<void, void>::m_alloc_size -
-                        sizeof(SharedAllocationHeader)));
-  }
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/, const SpaceType& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const SpaceType& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate)
-      : SharedAllocationRecord<void, void>(
-#ifdef KOKKOS_ENABLE_DEBUG
-            &SharedAllocationRecord<SpaceType, void>::s_root_record,
-#endif
-            Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                 arg_alloc_size),
-            sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-            arg_label),
-        m_space(arg_space) {
-    // Fill in the Header information
-    RecordBase::m_alloc_ptr->m_record =
-        static_cast<SharedAllocationRecord<void, void>*>(this);
-
-    strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
-            SharedAllocationHeader::maximum_label_length - 1);
-    // Set last element zero, in case c_str is too long
-    RecordBase::m_alloc_ptr
-        ->m_label[SharedAllocationHeader::maximum_label_length - 1] = '\0';
-  }
-
- public:
-  inline std::string get_label() const {
-    return std::string(RecordBase::head()->m_label);
-  }
-  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
-      const SpaceType& arg_space, const std::string& arg_label,
-      const size_t arg_alloc_size) {
-    KOKKOS_IF_ON_HOST((return new SharedAllocationRecord(arg_space, arg_label,
-                                                         arg_alloc_size);))
-    KOKKOS_IF_ON_DEVICE(((void)arg_space; (void)arg_label; (void)arg_alloc_size;
-                         return nullptr;))
-  }
-
-  /**\brief  Allocate tracked memory in the space */
-  static void* allocate_tracked(const SpaceType& arg_space,
-                                const std::string& arg_label,
-                                const size_t arg_alloc_size) {
-    if (!arg_alloc_size) return (void*)nullptr;
-
-    SharedAllocationRecord* const r =
-        allocate(arg_space, arg_label, arg_alloc_size);
-
-    RecordBase::increment(r);
-
-    return r->data();
-  }
-
-  /**\brief  Reallocate tracked memory in the space */
-  static void* reallocate_tracked(void* const arg_alloc_ptr,
-                                  const size_t arg_alloc_size) {
-    SharedAllocationRecord* const r_old = get_record(arg_alloc_ptr);
-    SharedAllocationRecord* const r_new =
-        allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
-
-    Kokkos::Impl::DeepCopy<SpaceType, SpaceType>(
-        r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
-    Kokkos::fence(
-        "SharedAllocationRecord<Kokkos::Experimental::LogicalMemorySpace, "
-        "void>::reallocate_tracked: fence after copying data");
-
-    RecordBase::increment(r_new);
-    RecordBase::decrement(r_old);
-
-    return r_new->data();
-  }
-  /**\brief  Deallocate tracked memory in the space */
-  static void deallocate_tracked(void* const arg_alloc_ptr) {
-    if (arg_alloc_ptr != nullptr) {
-      SharedAllocationRecord* const r = get_record(arg_alloc_ptr);
-
-      RecordBase::decrement(r);
-    }
-  }
-
-  static SharedAllocationRecord* get_record(void* alloc_ptr) {
-    using Header     = SharedAllocationHeader;
-    using RecordHost = SharedAllocationRecord<SpaceType, void>;
-
-    SharedAllocationHeader const* const head =
-        alloc_ptr ? Header::get_header(alloc_ptr)
-                  : (SharedAllocationHeader*)nullptr;
-    RecordHost* const record =
-        head ? static_cast<RecordHost*>(head->m_record) : (RecordHost*)nullptr;
-
-    if (!alloc_ptr || record->m_alloc_ptr != head) {
-      Kokkos::Impl::throw_runtime_exception(std::string(
-          "Kokkos::Impl::SharedAllocationRecord< LogicalMemorySpace<> , "
-          "void >::get_record ERROR"));
-    }
-
-    return record;
-  }
-#ifdef KOKKOS_ENABLE_DEBUG
-  static void print_records(std::ostream& s, const SpaceType&,
-                            bool detail = false) {
-    SharedAllocationRecord<void, void>::print_host_accessible_records(
-        s, "HostSpace", &s_root_record, detail);
-  }
-#else
-  static void print_records(std::ostream&, const SpaceType&,
-                            bool detail = false) {
-    (void)detail;
-    throw_runtime_exception(
-        "SharedAllocationRecord<HostSpace>::print_records only works "
-        "with KOKKOS_ENABLE_DEBUG enabled");
-  }
-#endif
-};
-#ifdef KOKKOS_ENABLE_DEBUG
-/**\brief  Root record for tracked allocations from this LogicalSpace
- * instance */
-template <class BaseSpace, class DefaultBaseExecutionSpace, class Namer,
-          class SharesAccessSemanticsWithBase>
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<Kokkos::Experimental::LogicalMemorySpace<
-                               BaseSpace, DefaultBaseExecutionSpace, Namer,
-                               SharesAccessSemanticsWithBase>,
-                           void>::s_root_record;
-#endif
-
-}  // namespace Impl
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-
-template <class Namer, class BaseSpace, class DefaultBaseExecutionSpace,
-          class SharesAccess, class ExecutionSpace>
-struct DeepCopy<Kokkos::Experimental::LogicalMemorySpace<
-                    BaseSpace, DefaultBaseExecutionSpace, Namer, SharesAccess>,
-                Kokkos::Experimental::LogicalMemorySpace<
-                    BaseSpace, DefaultBaseExecutionSpace, Namer, SharesAccess>,
-                ExecutionSpace> {
-  DeepCopy(void* dst, void* src, size_t n) {
-    DeepCopy<BaseSpace, BaseSpace, ExecutionSpace>(dst, src, n);
-  }
-  DeepCopy(const ExecutionSpace& exec, void* dst, void* src, size_t n) {
-    DeepCopy<BaseSpace, BaseSpace, ExecutionSpace>(exec, dst, src, n);
-  }
-};
-
-template <class Namer, class BaseSpace, class DefaultBaseExecutionSpace,
-          class SharesAccess, class ExecutionSpace, class SourceSpace>
-struct DeepCopy<SourceSpace,
-                Kokkos::Experimental::LogicalMemorySpace<
-                    BaseSpace, DefaultBaseExecutionSpace, Namer, SharesAccess>,
-                ExecutionSpace> {
-  DeepCopy(void* dst, void* src, size_t n) {
-    DeepCopy<SourceSpace, BaseSpace, ExecutionSpace>(dst, src, n);
-  }
-  DeepCopy(const ExecutionSpace& exec, void* dst, void* src, size_t n) {
-    DeepCopy<SourceSpace, BaseSpace, ExecutionSpace>(exec, dst, src, n);
-  }
-};
-
-template <class Namer, class BaseSpace, class DefaultBaseExecutionSpace,
-          class SharesAccess, class ExecutionSpace, class DestinationSpace>
-struct DeepCopy<Kokkos::Experimental::LogicalMemorySpace<
-                    BaseSpace, DefaultBaseExecutionSpace, Namer, SharesAccess>,
-                DestinationSpace, ExecutionSpace> {
-  DeepCopy(void* dst, void* src, size_t n) {
-    DeepCopy<BaseSpace, DestinationSpace, ExecutionSpace>(dst, src, n);
-  }
-  DeepCopy(const ExecutionSpace& exec, void* dst, void* src, size_t n) {
-    DeepCopy<BaseSpace, DestinationSpace, ExecutionSpace>(exec, dst, src, n);
-  }
-};
-}  // namespace Impl
-
-}  // namespace Kokkos
-#endif  // KOKKOS_LOGICALSPACES_HPP
diff --git a/core/src/Kokkos_Macros.hpp b/core/src/Kokkos_Macros.hpp
index 3e10690c1e..0a0acd303f 100644
--- a/core/src/Kokkos_Macros.hpp
+++ b/core/src/Kokkos_Macros.hpp
@@ -55,9 +55,22 @@
 
 #ifndef KOKKOS_DONT_INCLUDE_CORE_CONFIG_H
 #include <KokkosCore_config.h>
+#include <impl/Kokkos_DesulAtomicsConfig.hpp>
 #include <impl/Kokkos_NvidiaGpuArchitectures.hpp>
 #endif
 
+#if !defined(KOKKOS_ENABLE_CXX17)
+#if __has_include(<version>)
+#include <version>
+#else
+#include <ciso646>
+#endif
+#if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 10
+#error \
+    "Compiling with support for C++20 or later requires a libstdc++ version later than 9"
+#endif
+#endif
+
 //----------------------------------------------------------------------------
 /** Pick up compiler specific #define macros:
  *
@@ -84,11 +97,12 @@
 
 //----------------------------------------------------------------------------
 
-#if !defined(KOKKOS_ENABLE_THREADS) && !defined(KOKKOS_ENABLE_CUDA) &&     \
-    !defined(KOKKOS_ENABLE_OPENMP) && !defined(KOKKOS_ENABLE_HPX) &&       \
-    !defined(KOKKOS_ENABLE_OPENMPTARGET) && !defined(KOKKOS_ENABLE_HIP) && \
-    !defined(KOKKOS_ENABLE_SYCL)
-#define KOKKOS_INTERNAL_NOT_PARALLEL
+#if defined(KOKKOS_ENABLE_ATOMICS_BYPASS) &&                              \
+    (defined(KOKKOS_ENABLE_THREADS) || defined(KOKKOS_ENABLE_CUDA) ||     \
+     defined(KOKKOS_ENABLE_OPENMP) || defined(KOKKOS_ENABLE_HPX) ||       \
+     defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_HIP) || \
+     defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENACC))
+#error Atomics may only be disabled if neither a host parallel nor a device backend is enabled
 #endif
 
 #define KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA
@@ -331,6 +345,10 @@
 #define KOKKOS_DEFAULTED_FUNCTION
 #endif
 
+#if !defined(KOKKOS_DEDUCTION_GUIDE)
+#define KOKKOS_DEDUCTION_GUIDE
+#endif
+
 #if !defined(KOKKOS_IMPL_HOST_FUNCTION)
 #define KOKKOS_IMPL_HOST_FUNCTION
 #endif
@@ -339,12 +357,6 @@
 #define KOKKOS_IMPL_DEVICE_FUNCTION
 #endif
 
-// Temporary solution for SYCL not supporting printf in kernels.
-// Might disappear at any point once we have found another solution.
-#if !defined(KOKKOS_IMPL_DO_NOT_USE_PRINTF)
-#define KOKKOS_IMPL_DO_NOT_USE_PRINTF(...) printf(__VA_ARGS__)
-#endif
-
 //----------------------------------------------------------------------------
 // Define final version of functions. This is so that clang tidy can find these
 // macros more easily
@@ -433,22 +445,6 @@
 #define KOKKOS_ENABLE_DEFAULT_DEVICE_TYPE_SERIAL
 #endif
 
-//----------------------------------------------------------------------------
-// Determine for what space the code is being compiled:
-#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_3)
-
-#if defined(__CUDACC__) && defined(__CUDA_ARCH__) && defined(KOKKOS_ENABLE_CUDA)
-#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_CUDA
-#elif defined(__SYCL_DEVICE_ONLY__) && defined(KOKKOS_ENABLE_SYCL)
-#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_SYCL
-#elif defined(__HIPCC__) && defined(__HIP_DEVICE_COMPILE__) && \
-    defined(KOKKOS_ENABLE_HIP)
-#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HIP_GPU
-#else
-#define KOKKOS_ACTIVE_EXECUTION_MEMORY_SPACE_HOST
-#endif
-
-#endif
 //----------------------------------------------------------------------------
 
 // Remove surrounding parentheses if present
@@ -583,8 +579,44 @@ static constexpr bool kokkos_omp_on_host() { return false; }
 #define KOKKOS_IMPL_WARNING(desc) KOKKOS_IMPL_DO_PRAGMA(message(#desc))
 #endif
 
+// clang-format off
+#if defined(__NVCOMPILER)
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
+    _Pragma("diag_suppress 1216")
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
+    _Pragma("diag_default 1216")
+#elif defined(__EDG__)
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
+    _Pragma("warning push")                              \
+    _Pragma("warning disable 1478")
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
+    _Pragma("warning pop")
+#elif defined(__GNUC__) || defined(__clang__)
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
+    _Pragma("GCC diagnostic push")                       \
+    _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
+    _Pragma("GCC diagnostic pop")
+#elif defined(_MSC_VER)
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH() \
+    _Pragma("warning(push)")                             \
+    _Pragma("warning(disable: 4996)")
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP() \
+    _Pragma("warning(pop)")
+#else
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
+  #define KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP()
+#endif
+// clang-format on
+
 #define KOKKOS_ATTRIBUTE_NODISCARD [[nodiscard]]
 
+#ifndef KOKKOS_ENABLE_CXX17
+#define KOKKOS_IMPL_ATTRIBUTE_UNLIKELY [[unlikely]]
+#else
+#define KOKKOS_IMPL_ATTRIBUTE_UNLIKELY
+#endif
+
 #if (defined(KOKKOS_COMPILER_GNU) || defined(KOKKOS_COMPILER_CLANG) ||        \
      defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM) || \
      defined(KOKKOS_COMPILER_NVHPC)) &&                                       \
diff --git a/core/src/Kokkos_MasterLock.hpp b/core/src/Kokkos_MasterLock.hpp
deleted file mode 100644
index 1d09617371..0000000000
--- a/core/src/Kokkos_MasterLock.hpp
+++ /dev/null
@@ -1,56 +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_MASTER_LOCK_HPP
-#define KOKKOS_MASTER_LOCK_HPP
-
-#include <Kokkos_Macros.hpp>
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-
-namespace Kokkos {
-namespace Experimental {
-
-// my be used to coordinate work between master instances
-// SHOULD NOT be used within a parallel algorithm
-//
-// This lock should be used with with a scoped lock guard
-// i.e. std::unique_lock<Lock>, std::lock_guard
-//
-// cannot be copied or moved
-// has the following functions available
-//
-// Lock()
-// ~Lock()
-//
-// void lock()
-// void unlock()
-// bool try_lock()
-//
-template <typename ExecutionSpace>
-class MasterLock;
-
-}  // namespace Experimental
-}  // namespace Kokkos
-
-#endif
-
-#endif  // KOKKOS_MASTER_LOCK_HPP
diff --git a/core/src/Kokkos_MathematicalConstants.hpp b/core/src/Kokkos_MathematicalConstants.hpp
index 51a50d347d..1a77f373fd 100644
--- a/core/src/Kokkos_MathematicalConstants.hpp
+++ b/core/src/Kokkos_MathematicalConstants.hpp
@@ -51,24 +51,6 @@ KOKKOS_IMPL_MATH_CONSTANT(phi,        1.618033988749894848204586834365638118L);
 
 }  // namespace Kokkos::numbers
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-namespace Kokkos::Experimental {
-using Kokkos::numbers::e_v;
-using Kokkos::numbers::egamma_v;
-using Kokkos::numbers::inv_pi_v;
-using Kokkos::numbers::inv_sqrt3_v;
-using Kokkos::numbers::inv_sqrtpi_v;
-using Kokkos::numbers::ln10_v;
-using Kokkos::numbers::ln2_v;
-using Kokkos::numbers::log10e_v;
-using Kokkos::numbers::log2e_v;
-using Kokkos::numbers::phi_v;
-using Kokkos::numbers::pi_v;
-using Kokkos::numbers::sqrt2_v;
-using Kokkos::numbers::sqrt3_v;
-}  // namespace Kokkos::Experimental
-#endif
-
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_MATHCONSTANTS
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_MATHCONSTANTS
diff --git a/core/src/Kokkos_MathematicalFunctions.hpp b/core/src/Kokkos_MathematicalFunctions.hpp
index a795f700fa..19967782e5 100644
--- a/core/src/Kokkos_MathematicalFunctions.hpp
+++ b/core/src/Kokkos_MathematicalFunctions.hpp
@@ -92,16 +92,6 @@ using promote_3_t = typename promote_3<T, U, V>::type;
 #endif
 #endif
 
-#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_3)
-#define KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED( \
-    USING_DECLARATIONS_IN_EXPERIMENTAL_NAMESPACE)                      \
-  USING_DECLARATIONS_IN_EXPERIMENTAL_NAMESPACE
-#else
-#define KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED( \
-    USING_DECLARATIONS_IN_EXPERIMENTAL_NAMESPACE)                      \
-  /* nothing */
-#endif
-
 #define KOKKOS_IMPL_MATH_UNARY_FUNCTION(FUNC)                                  \
   KOKKOS_INLINE_FUNCTION float FUNC(float x) {                                 \
     using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::FUNC;                          \
@@ -128,13 +118,7 @@ using promote_3_t = typename promote_3<T, U, V>::type;
       T x) {                                                                   \
     using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::FUNC;                          \
     return FUNC(static_cast<double>(x));                                       \
-  }                                                                            \
-  KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED(               \
-      namespace Experimental {                                                 \
-        using ::Kokkos::FUNC;                                                  \
-        using ::Kokkos::FUNC##f;                                               \
-        using ::Kokkos::FUNC##l;                                               \
-      })
+  }
 
 // isinf, isnan, and isinfinite do not work on Windows with CUDA with std::
 // getting warnings about calling host function in device function then
@@ -151,9 +135,7 @@ using promote_3_t = typename promote_3<T, U, V>::type;
   KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_integral_v<T>, bool> FUNC( \
       T x) {                                                                 \
     return ::FUNC(static_cast<double>(x));                                   \
-  }                                                                          \
-  KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED(             \
-      namespace Experimental { using ::Kokkos::FUNC; })
+  }
 #else
 #define KOKKOS_IMPL_MATH_UNARY_PREDICATE(FUNC)                               \
   KOKKOS_INLINE_FUNCTION bool FUNC(float x) {                                \
@@ -173,9 +155,7 @@ using promote_3_t = typename promote_3<T, U, V>::type;
       T x) {                                                                 \
     using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::FUNC;                        \
     return FUNC(static_cast<double>(x));                                     \
-  }                                                                          \
-  KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED(             \
-      namespace Experimental { using ::Kokkos::FUNC; })
+  }
 #endif
 
 #define KOKKOS_IMPL_MATH_BINARY_FUNCTION(FUNC)                                 \
@@ -218,16 +198,10 @@ using promote_3_t = typename promote_3<T, U, V>::type;
                           long double>                                         \
   FUNC(T1 x, T2 y) {                                                           \
     using Promoted = Kokkos::Impl::promote_2_t<T1, T2>;                        \
-    static_assert(std::is_same_v<Promoted, long double>, "");                  \
+    static_assert(std::is_same_v<Promoted, long double>);                      \
     using std::FUNC;                                                           \
     return FUNC(static_cast<Promoted>(x), static_cast<Promoted>(y));           \
-  }                                                                            \
-  KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED(               \
-      namespace Experimental {                                                 \
-        using ::Kokkos::FUNC;                                                  \
-        using ::Kokkos::FUNC##f;                                               \
-        using ::Kokkos::FUNC##l;                                               \
-      })
+  }
 
 #define KOKKOS_IMPL_MATH_TERNARY_FUNCTION(FUNC)                             \
   KOKKOS_INLINE_FUNCTION float FUNC(float x, float y, float z) {            \
@@ -286,7 +260,7 @@ KOKKOS_INLINE_FUNCTION int abs(int n) {
 }
 KOKKOS_INLINE_FUNCTION long abs(long n) {
 // FIXME_NVHPC ptxas fatal   : unresolved extern function 'labs'
-#ifdef KOKKOS_COMPILER_NVHPC
+#if defined(KOKKOS_COMPILER_NVHPC) && KOKKOS_COMPILER_NVHPC < 230700
   return n > 0 ? n : -n;
 #else
   using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::abs;
@@ -295,7 +269,7 @@ KOKKOS_INLINE_FUNCTION long abs(long n) {
 }
 KOKKOS_INLINE_FUNCTION long long abs(long long n) {
 // FIXME_NVHPC ptxas fatal   : unresolved extern function 'labs'
-#ifdef KOKKOS_COMPILER_NVHPC
+#if defined(KOKKOS_COMPILER_NVHPC) && KOKKOS_COMPILER_NVHPC < 230700
   return n > 0 ? n : -n;
 #else
   using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::abs;
@@ -303,19 +277,25 @@ KOKKOS_INLINE_FUNCTION long long abs(long long n) {
 #endif
 }
 KOKKOS_INLINE_FUNCTION float abs(float x) {
+#ifdef KOKKOS_ENABLE_SYCL
+  return sycl::fabs(x);  // sycl::abs is only provided for integral types
+#else
   using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::abs;
   return abs(x);
+#endif
 }
 KOKKOS_INLINE_FUNCTION double abs(double x) {
+#ifdef KOKKOS_ENABLE_SYCL
+  return sycl::fabs(x);  // sycl::abs is only provided for integral types
+#else
   using KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE::abs;
   return abs(x);
+#endif
 }
 inline long double abs(long double x) {
   using std::abs;
   return abs(x);
 }
-KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED(
-    namespace Experimental { using ::Kokkos::abs; })
 KOKKOS_IMPL_MATH_UNARY_FUNCTION(fabs)
 KOKKOS_IMPL_MATH_BINARY_FUNCTION(fmod)
 KOKKOS_IMPL_MATH_BINARY_FUNCTION(remainder)
@@ -336,18 +316,10 @@ KOKKOS_INLINE_FUNCTION float nanf(char const*) { return sycl::nan(0u); }
 KOKKOS_INLINE_FUNCTION double nan(char const*) { return sycl::nan(0ul); }
 #endif
 inline long double nanl(char const* arg) { return ::nanl(arg); }
-KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED(
-    namespace Experimental {
-      using ::Kokkos::nan;
-      using ::Kokkos::nanf;
-      using ::Kokkos::nanl;
-    })
 // Exponential functions
 KOKKOS_IMPL_MATH_UNARY_FUNCTION(exp)
 // FIXME_NVHPC nvc++ has issues with exp2
-#ifndef KOKKOS_COMPILER_NVHPC
-KOKKOS_IMPL_MATH_UNARY_FUNCTION(exp2)
-#else
+#if defined(KOKKOS_COMPILER_NVHPC) && KOKKOS_COMPILER_NVHPC < 230700
 KOKKOS_INLINE_FUNCTION float exp2(float val) {
   constexpr float ln2 = 0.693147180559945309417232121458176568L;
   return exp(ln2 * val);
@@ -365,6 +337,8 @@ KOKKOS_INLINE_FUNCTION double exp2(T val) {
   constexpr double ln2 = 0.693147180559945309417232121458176568L;
   return exp(ln2 * static_cast<double>(val));
 }
+#else
+KOKKOS_IMPL_MATH_UNARY_FUNCTION(exp2)
 #endif
 KOKKOS_IMPL_MATH_UNARY_FUNCTION(expm1)
 KOKKOS_IMPL_MATH_UNARY_FUNCTION(log)
@@ -478,7 +452,6 @@ KOKKOS_IMPL_MATH_UNARY_PREDICATE(signbit)
 // islessgreater
 // isunordered
 
-#undef KOKKOS_IMPL_MATH_FUNCTIONS_DEFINED_IF_DEPRECATED_CODE_ENABLED
 #undef KOKKOS_IMPL_MATH_FUNCTIONS_NAMESPACE
 #undef KOKKOS_IMPL_MATH_UNARY_FUNCTION
 #undef KOKKOS_IMPL_MATH_UNARY_PREDICATE
diff --git a/core/src/Kokkos_MathematicalSpecialFunctions.hpp b/core/src/Kokkos_MathematicalSpecialFunctions.hpp
index 63c2b58ef5..2118a0ad93 100644
--- a/core/src/Kokkos_MathematicalSpecialFunctions.hpp
+++ b/core/src/Kokkos_MathematicalSpecialFunctions.hpp
@@ -846,69 +846,52 @@ KOKKOS_INLINE_FUNCTION CmplxType cyl_bessel_y1(const CmplxType& z,
 //! for a complex argument
 template <class CmplxType, class RealType, class IntType>
 KOKKOS_INLINE_FUNCTION CmplxType cyl_bessel_i0(const CmplxType& z,
-                                               const RealType& joint_val = 25,
-                                               const IntType& bw_start   = 70) {
+                                               const RealType& joint_val = 18,
+                                               const IntType& n_terms    = 50) {
   // This function is converted and modified from the corresponding Fortran
-  // programs CIKNB and CIK01 in S. Zhang & J. Jin "Computation of Special
+  // programs CIK01 in S. Zhang & J. Jin "Computation of Special
   // Functions" (Wiley, 1996).
   //    Input :  z         --- Complex argument
   //             joint_val --- Joint point of abs(z) separating small and large
   //                           argument regions
-  //             bw_start  --- Starting point for backward recurrence
+  //             n_terms   --- Numbers of terms used in the power series
   //    Output:  cbi0      --- I0(z)
-  using Kokkos::numbers::pi_v;
-
-  CmplxType cbi0;
-  constexpr auto pi    = pi_v<RealType>;
-  const RealType a[12] = {0.125,
-                          7.03125e-2,
-                          7.32421875e-2,
-                          1.1215209960938e-1,
-                          2.2710800170898e-1,
-                          5.7250142097473e-1,
-                          1.7277275025845e0,
-                          6.0740420012735e0,
-                          2.4380529699556e1,
-                          1.1001714026925e2,
-                          5.5133589612202e2,
-                          3.0380905109224e3};
 
+  CmplxType cbi0(1.0, 0.0);
   RealType a0  = Kokkos::abs(z);
   CmplxType z1 = z;
 
-  if (a0 < 1e-100) {  // Treat z=0 as a special case
-    cbi0 = CmplxType(1.0, 0.0);
-  } else {
+  if (a0 > 1e-100) {
     if (z.real() < 0.0) z1 = -z;
-    if (a0 <= joint_val) {  // Using backward recurrence for |z|<=joint_val
-                            // (default:25)
-      CmplxType cbs = CmplxType(0.0, 0.0);
-      // CmplxType csk0 = CmplxType(0.0,0.0);
-      CmplxType cf0 = CmplxType(0.0, 0.0);
-      CmplxType cf1 = CmplxType(1e-100, 0.0);
-      CmplxType cf, cs0;
-      for (int k = bw_start; k >= 0; k--) {  // Backward recurrence (default:
-                                             // 70)
-        cf = 2.0 * (k + 1.0) * cf1 / z1 + cf0;
-        if (k == 0) cbi0 = cf;
-        // if ((k == 2*(k/2)) && (k != 0)) {
-        //  csk0 = csk0+4.0*cf/static_cast<RealType>(k);
-        //}
-        cbs = cbs + 2.0 * cf;
-        cf0 = cf1;
-        cf1 = cf;
+    if (a0 <= joint_val) {
+      // Using power series definition for |z|<=joint_val (default:18)
+      CmplxType cr = CmplxType(1.0e+00, 0.0e+00);
+      CmplxType z2 = z * z;
+      for (int k = 1; k < n_terms; ++k) {
+        cr = RealType(.25) * cr * z2 / CmplxType(k * k);
+        cbi0 += cr;
+        if (Kokkos::abs(cr / cbi0) < RealType(1.e-15)) continue;
       }
-      cs0  = Kokkos::exp(z1) / (cbs - cf);
-      cbi0 = cbi0 * cs0;
-    } else {  // Using asymptotic expansion (6.2.1) for |z|>joint_val
-              // (default:25)
-      CmplxType ca = Kokkos::exp(z1) / Kokkos::sqrt(2.0 * pi * z1);
-      cbi0         = CmplxType(1.0, 0.0);
-      CmplxType zr = 1.0 / z1;
+    } else {
+      // Using asymptotic expansion (6.2.1) for |z|>joint_val (default:18)
+      const RealType a[12] = {0.125,
+                              7.03125e-2,
+                              7.32421875e-2,
+                              1.1215209960938e-1,
+                              2.2710800170898e-1,
+                              5.7250142097473e-1,
+                              1.7277275025845e0,
+                              6.0740420012735e0,
+                              2.4380529699556e1,
+                              1.1001714026925e2,
+                              5.5133589612202e2,
+                              3.0380905109224e3};
+
       for (int k = 1; k <= 12; k++) {
-        cbi0 = cbi0 + a[k - 1] * Kokkos::pow(zr, 1.0 * k);
+        cbi0 += a[k - 1] * Kokkos::pow(z1, -k);
       }
-      cbi0 = ca * cbi0;
+      cbi0 *= Kokkos::exp(z1) /
+              Kokkos::sqrt(2.0 * Kokkos::numbers::pi_v<RealType> * z1);
     }
   }
   return cbi0;
diff --git a/core/src/Kokkos_MemoryPool.hpp b/core/src/Kokkos_MemoryPool.hpp
index 6b47c43727..ce8c9e152f 100644
--- a/core/src/Kokkos_MemoryPool.hpp
+++ b/core/src/Kokkos_MemoryPool.hpp
@@ -29,8 +29,6 @@ static_assert(false,
 #include <impl/Kokkos_Error.hpp>
 #include <impl/Kokkos_SharedAlloc.hpp>
 
-#include <iostream>
-
 namespace Kokkos {
 namespace Impl {
 /* Report violation of size constraints:
diff --git a/core/src/Kokkos_MinMaxClamp.hpp b/core/src/Kokkos_MinMax.hpp
similarity index 83%
rename from core/src/Kokkos_MinMaxClamp.hpp
rename to core/src/Kokkos_MinMax.hpp
index 37a28a80b6..5c60a88bfb 100644
--- a/core/src/Kokkos_MinMaxClamp.hpp
+++ b/core/src/Kokkos_MinMax.hpp
@@ -14,13 +14,8 @@
 //
 //@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_MIN_MAX_CLAMP_HPP
-#define KOKKOS_MIN_MAX_CLAMP_HPP
+#ifndef KOKKOS_MIN_MAX_HPP
+#define KOKKOS_MIN_MAX_HPP
 
 #include <Kokkos_Macros.hpp>
 #include <Kokkos_Pair.hpp>
@@ -29,22 +24,6 @@ static_assert(false,
 
 namespace Kokkos {
 
-// clamp
-template <class T>
-constexpr KOKKOS_INLINE_FUNCTION const T& clamp(const T& value, const T& lo,
-                                                const T& hi) {
-  KOKKOS_EXPECTS(!(hi < lo));
-  return (value < lo) ? lo : (hi < value) ? hi : value;
-}
-
-template <class T, class ComparatorType>
-constexpr KOKKOS_INLINE_FUNCTION const T& clamp(const T& value, const T& lo,
-                                                const T& hi,
-                                                ComparatorType comp) {
-  KOKKOS_EXPECTS(!comp(hi, lo));
-  return comp(value, lo) ? lo : comp(hi, value) ? hi : value;
-}
-
 // max
 template <class T>
 constexpr KOKKOS_INLINE_FUNCTION const T& max(const T& a, const T& b) {
@@ -199,15 +178,6 @@ KOKKOS_INLINE_FUNCTION constexpr Kokkos::pair<T, T> minmax(
   return result;
 }
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-namespace Experimental {
-using ::Kokkos::clamp;
-using ::Kokkos::max;
-using ::Kokkos::min;
-using ::Kokkos::minmax;
-}  // namespace Experimental
-#endif
-
 }  // namespace Kokkos
 
 #endif
diff --git a/core/src/Kokkos_Pair.hpp b/core/src/Kokkos_Pair.hpp
index d42e07aa42..e569fefc14 100644
--- a/core/src/Kokkos_Pair.hpp
+++ b/core/src/Kokkos_Pair.hpp
@@ -28,6 +28,7 @@
 #endif
 
 #include <Kokkos_Macros.hpp>
+#include <Kokkos_Swap.hpp>
 #include <utility>
 
 namespace Kokkos {
@@ -62,8 +63,7 @@ struct pair {
   ///
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
-#ifdef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC bug in NVHPC regarding constexpr
-                              // constructors used in device code
+#if defined(KOKKOS_COMPILER_NVHPC) && KOKKOS_COMPILER_NVHPC < 230700
   KOKKOS_FORCEINLINE_FUNCTION
 #else
   KOKKOS_FORCEINLINE_FUNCTION constexpr
@@ -75,8 +75,7 @@ struct pair {
   /// This calls the copy constructors of T1 and T2.  It won't compile
   /// if those copy constructors are not defined and public.
   template <class U, class V>
-#ifdef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC bug in NVHPC regarding constexpr
-                              // constructors used in device code
+#if defined(KOKKOS_COMPILER_NVHPC) && KOKKOS_COMPILER_NVHPC < 230700
   KOKKOS_FORCEINLINE_FUNCTION
 #else
   KOKKOS_FORCEINLINE_FUNCTION constexpr
@@ -414,12 +413,13 @@ KOKKOS_FORCEINLINE_FUNCTION pair<T1&, T2&> tie(T1& x, T2& y) {
   return (pair<T1&, T2&>(x, y));
 }
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
 //
 // Specialization of Kokkos::pair for a \c void second argument.  This
 // is not actually a "pair"; it only contains one element, the first.
 //
 template <class T1>
-struct pair<T1, void> {
+struct KOKKOS_DEPRECATED pair<T1, void> {
   using first_type  = T1;
   using second_type = void;
 
@@ -449,44 +449,50 @@ struct pair<T1, void> {
 // Specialization of relational operators for Kokkos::pair<T1,void>.
 //
 
+#if defined(KOKKOS_COMPILER_GNU) && (KOKKOS_COMPILER_GNU < 1110)
+KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
+#endif
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator==(
+KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator==(
     const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
   return lhs.first == rhs.first;
 }
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator!=(
+KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator!=(
     const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
   return !(lhs == rhs);
 }
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<(
+KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<(
     const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
   return lhs.first < rhs.first;
 }
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<=(
+KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator<=(
     const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
   return !(rhs < lhs);
 }
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>(
+KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>(
     const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
   return rhs < lhs;
 }
 
 template <class T1>
-KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>=(
+KOKKOS_DEPRECATED KOKKOS_FORCEINLINE_FUNCTION constexpr bool operator>=(
     const pair<T1, void>& lhs, const pair<T1, void>& rhs) {
   return !(lhs < rhs);
 }
+#if defined(KOKKOS_COMPILER_GNU) && (KOKKOS_COMPILER_GNU < 1110)
+KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP()
+#endif
+#endif
 
 namespace Impl {
-
 template <class T>
 struct is_pair_like : std::false_type {};
 template <class T, class U>
diff --git a/core/src/Kokkos_Parallel.hpp b/core/src/Kokkos_Parallel.hpp
index 484f6c0d5f..122239df79 100644
--- a/core/src/Kokkos_Parallel.hpp
+++ b/core/src/Kokkos_Parallel.hpp
@@ -137,9 +137,9 @@ inline void parallel_for(const std::string& str, const ExecPolicy& policy,
   ExecPolicy inner_policy = policy;
   Kokkos::Tools::Impl::begin_parallel_for(inner_policy, functor, str, kpID);
 
-  Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelFor<FunctorType, ExecPolicy> closure(functor, inner_policy);
-  Kokkos::Impl::shared_allocation_tracking_enable();
+  auto closure =
+      Kokkos::Impl::construct_with_shared_allocation_tracking_disabled<
+          Impl::ParallelFor<FunctorType, ExecPolicy>>(functor, inner_policy);
 
   closure.execute();
 
@@ -352,10 +352,10 @@ inline void parallel_scan(const std::string& str, const ExecutionPolicy& policy,
   ExecutionPolicy inner_policy = policy;
   Kokkos::Tools::Impl::begin_parallel_scan(inner_policy, functor, str, kpID);
 
-  Kokkos::Impl::shared_allocation_tracking_disable();
-  Impl::ParallelScan<FunctorType, ExecutionPolicy> closure(functor,
-                                                           inner_policy);
-  Kokkos::Impl::shared_allocation_tracking_enable();
+  auto closure =
+      Kokkos::Impl::construct_with_shared_allocation_tracking_disabled<
+          Impl::ParallelScan<FunctorType, ExecutionPolicy>>(functor,
+                                                            inner_policy);
 
   closure.execute();
 
@@ -398,18 +398,19 @@ inline void parallel_scan(const std::string& str, const ExecutionPolicy& policy,
   Kokkos::Tools::Impl::begin_parallel_scan(inner_policy, functor, str, kpID);
 
   if constexpr (Kokkos::is_view<ReturnType>::value) {
-    Kokkos::Impl::shared_allocation_tracking_disable();
-    Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy,
-                                typename ReturnType::value_type>
-        closure(functor, inner_policy, return_value);
-    Kokkos::Impl::shared_allocation_tracking_enable();
+    auto closure =
+        Kokkos::Impl::construct_with_shared_allocation_tracking_disabled<
+            Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy,
+                                        typename ReturnType::value_type>>(
+            functor, inner_policy, return_value);
     closure.execute();
   } else {
-    Kokkos::Impl::shared_allocation_tracking_disable();
     Kokkos::View<ReturnType, Kokkos::HostSpace> view(&return_value);
-    Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy, ReturnType>
-        closure(functor, inner_policy, view);
-    Kokkos::Impl::shared_allocation_tracking_enable();
+    auto closure =
+        Kokkos::Impl::construct_with_shared_allocation_tracking_disabled<
+            Impl::ParallelScanWithTotal<FunctorType, ExecutionPolicy,
+                                        ReturnType>>(functor, inner_policy,
+                                                     view);
     closure.execute();
   }
 
diff --git a/core/src/Kokkos_Parallel_Reduce.hpp b/core/src/Kokkos_Parallel_Reduce.hpp
index 34897ab1ee..53913266f1 100644
--- a/core/src/Kokkos_Parallel_Reduce.hpp
+++ b/core/src/Kokkos_Parallel_Reduce.hpp
@@ -27,7 +27,6 @@ static_assert(false,
 #include <impl/Kokkos_FunctorAnalysis.hpp>
 #include <impl/Kokkos_Tools_Generic.hpp>
 #include <type_traits>
-#include <iostream>
 
 namespace Kokkos {
 
@@ -73,7 +72,7 @@ struct Sum {
 };
 
 template <typename Scalar, typename... Properties>
-Sum(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE Sum(View<Scalar, Properties...> const&)
     ->Sum<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -118,7 +117,7 @@ struct Prod {
 };
 
 template <typename Scalar, typename... Properties>
-Prod(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE Prod(View<Scalar, Properties...> const&)
     ->Prod<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -165,7 +164,7 @@ struct Min {
 };
 
 template <typename Scalar, typename... Properties>
-Min(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE Min(View<Scalar, Properties...> const&)
     ->Min<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -213,7 +212,7 @@ struct Max {
 };
 
 template <typename Scalar, typename... Properties>
-Max(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE Max(View<Scalar, Properties...> const&)
     ->Max<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -259,7 +258,7 @@ struct LAnd {
 };
 
 template <typename Scalar, typename... Properties>
-LAnd(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE LAnd(View<Scalar, Properties...> const&)
     ->LAnd<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -306,7 +305,7 @@ struct LOr {
 };
 
 template <typename Scalar, typename... Properties>
-LOr(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE LOr(View<Scalar, Properties...> const&)
     ->LOr<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -353,7 +352,7 @@ struct BAnd {
 };
 
 template <typename Scalar, typename... Properties>
-BAnd(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE BAnd(View<Scalar, Properties...> const&)
     ->BAnd<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Space>
@@ -400,7 +399,7 @@ struct BOr {
 };
 
 template <typename Scalar, typename... Properties>
-BOr(View<Scalar, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE BOr(View<Scalar, Properties...> const&)
     ->BOr<Scalar, typename View<Scalar, Properties...>::memory_space>;
 
 template <class Scalar, class Index>
@@ -459,7 +458,8 @@ struct MinLoc {
 };
 
 template <typename Scalar, typename Index, typename... Properties>
-MinLoc(View<ValLocScalar<Scalar, Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MinLoc(
+    View<ValLocScalar<Scalar, Index>, Properties...> const&)
     ->MinLoc<Scalar, Index,
              typename View<ValLocScalar<Scalar, Index>,
                            Properties...>::memory_space>;
@@ -514,7 +514,8 @@ struct MaxLoc {
 };
 
 template <typename Scalar, typename Index, typename... Properties>
-MaxLoc(View<ValLocScalar<Scalar, Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MaxLoc(
+    View<ValLocScalar<Scalar, Index>, Properties...> const&)
     ->MaxLoc<Scalar, Index,
              typename View<ValLocScalar<Scalar, Index>,
                            Properties...>::memory_space>;
@@ -578,7 +579,7 @@ struct MinMax {
 };
 
 template <typename Scalar, typename... Properties>
-MinMax(View<MinMaxScalar<Scalar>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MinMax(View<MinMaxScalar<Scalar>, Properties...> const&)
     ->MinMax<Scalar,
              typename View<MinMaxScalar<Scalar>, Properties...>::memory_space>;
 
@@ -647,7 +648,8 @@ struct MinMaxLoc {
 };
 
 template <typename Scalar, typename Index, typename... Properties>
-MinMaxLoc(View<MinMaxLocScalar<Scalar, Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MinMaxLoc(
+    View<MinMaxLocScalar<Scalar, Index>, Properties...> const&)
     ->MinMaxLoc<Scalar, Index,
                 typename View<MinMaxLocScalar<Scalar, Index>,
                               Properties...>::memory_space>;
@@ -714,7 +716,8 @@ struct MaxFirstLoc {
 };
 
 template <typename Scalar, typename Index, typename... Properties>
-MaxFirstLoc(View<ValLocScalar<Scalar, Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MaxFirstLoc(
+    View<ValLocScalar<Scalar, Index>, Properties...> const&)
     ->MaxFirstLoc<Scalar, Index,
                   typename View<ValLocScalar<Scalar, Index>,
                                 Properties...>::memory_space>;
@@ -783,7 +786,7 @@ struct MaxFirstLocCustomComparator {
 
 template <typename Scalar, typename Index, typename ComparatorType,
           typename... Properties>
-MaxFirstLocCustomComparator(
+KOKKOS_DEDUCTION_GUIDE MaxFirstLocCustomComparator(
     View<ValLocScalar<Scalar, Index>, Properties...> const&, ComparatorType)
     ->MaxFirstLocCustomComparator<Scalar, Index, ComparatorType,
                                   typename View<ValLocScalar<Scalar, Index>,
@@ -847,7 +850,8 @@ struct MinFirstLoc {
 };
 
 template <typename Scalar, typename Index, typename... Properties>
-MinFirstLoc(View<ValLocScalar<Scalar, Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MinFirstLoc(
+    View<ValLocScalar<Scalar, Index>, Properties...> const&)
     ->MinFirstLoc<Scalar, Index,
                   typename View<ValLocScalar<Scalar, Index>,
                                 Properties...>::memory_space>;
@@ -916,7 +920,7 @@ struct MinFirstLocCustomComparator {
 
 template <typename Scalar, typename Index, typename ComparatorType,
           typename... Properties>
-MinFirstLocCustomComparator(
+KOKKOS_DEDUCTION_GUIDE MinFirstLocCustomComparator(
     View<ValLocScalar<Scalar, Index>, Properties...> const&, ComparatorType)
     ->MinFirstLocCustomComparator<Scalar, Index, ComparatorType,
                                   typename View<ValLocScalar<Scalar, Index>,
@@ -991,7 +995,8 @@ struct MinMaxFirstLastLoc {
 };
 
 template <typename Scalar, typename Index, typename... Properties>
-MinMaxFirstLastLoc(View<MinMaxLocScalar<Scalar, Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE MinMaxFirstLastLoc(
+    View<MinMaxLocScalar<Scalar, Index>, Properties...> const&)
     ->MinMaxFirstLastLoc<Scalar, Index,
                          typename View<MinMaxLocScalar<Scalar, Index>,
                                        Properties...>::memory_space>;
@@ -1070,7 +1075,7 @@ struct MinMaxFirstLastLocCustomComparator {
 
 template <typename Scalar, typename Index, typename ComparatorType,
           typename... Properties>
-MinMaxFirstLastLocCustomComparator(
+KOKKOS_DEDUCTION_GUIDE MinMaxFirstLastLocCustomComparator(
     View<MinMaxLocScalar<Scalar, Index>, Properties...> const&, ComparatorType)
     ->MinMaxFirstLastLocCustomComparator<
         Scalar, Index, ComparatorType,
@@ -1134,7 +1139,8 @@ struct FirstLoc {
 };
 
 template <typename Index, typename... Properties>
-FirstLoc(View<FirstLocScalar<Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE FirstLoc(
+    View<FirstLocScalar<Index>, Properties...> const&)
     ->FirstLoc<Index, typename View<FirstLocScalar<Index>,
                                     Properties...>::memory_space>;
 
@@ -1195,7 +1201,7 @@ struct LastLoc {
 };
 
 template <typename Index, typename... Properties>
-LastLoc(View<LastLocScalar<Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE LastLoc(View<LastLocScalar<Index>, Properties...> const&)
     ->LastLoc<Index,
               typename View<LastLocScalar<Index>, Properties...>::memory_space>;
 
@@ -1262,7 +1268,8 @@ struct StdIsPartitioned {
 };
 
 template <typename Index, typename... Properties>
-StdIsPartitioned(View<StdIsPartScalar<Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE StdIsPartitioned(
+    View<StdIsPartScalar<Index>, Properties...> const&)
     ->StdIsPartitioned<Index, typename View<StdIsPartScalar<Index>,
                                             Properties...>::memory_space>;
 
@@ -1324,7 +1331,8 @@ struct StdPartitionPoint {
 };
 
 template <typename Index, typename... Properties>
-StdPartitionPoint(View<StdPartPointScalar<Index>, Properties...> const&)
+KOKKOS_DEDUCTION_GUIDE StdPartitionPoint(
+    View<StdPartPointScalar<Index>, Properties...> const&)
     ->StdPartitionPoint<Index, typename View<StdPartPointScalar<Index>,
                                              Properties...>::memory_space>;
 
@@ -1503,18 +1511,18 @@ struct ParallelReduceAdaptor {
     using Analysis = FunctorAnalysis<FunctorPatternInterface::REDUCE,
                                      PolicyType, typename ReducerSelector::type,
                                      typename return_value_adapter::value_type>;
-    Kokkos::Impl::shared_allocation_tracking_disable();
-    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();
+
+    using CombinedFunctorReducerType =
+        CombinedFunctorReducer<FunctorType, typename Analysis::Reducer>;
+    auto closure = construct_with_shared_allocation_tracking_disabled<
+        Impl::ParallelReduce<CombinedFunctorReducerType, PolicyType,
+                             typename Impl::FunctorPolicyExecutionSpace<
+                                 FunctorType, PolicyType>::execution_space>>(
+        CombinedFunctorReducerType(
+            functor, typename Analysis::Reducer(
+                         ReducerSelector::select(functor, return_value))),
+        inner_policy,
+        return_value_adapter::return_value(return_value, functor));
     closure.execute();
 
     Kokkos::Tools::Impl::end_parallel_reduce<PassedReducerType>(
diff --git a/core/src/Kokkos_Printf.hpp b/core/src/Kokkos_Printf.hpp
new file mode 100644
index 0000000000..63a4cce2ae
--- /dev/null
+++ b/core/src/Kokkos_Printf.hpp
@@ -0,0 +1,55 @@
+//@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_PRINTF_HPP
+#define KOKKOS_PRINTF_HPP
+
+#include <Kokkos_Macros.hpp>
+
+#ifdef KOKKOS_ENABLE_SYCL
+#include <sycl/sycl.hpp>
+#else
+#include <cstdio>
+#endif
+
+namespace Kokkos {
+
+// In contrast to std::printf, return void to get a consistent behavior across
+// backends. The GPU backends always return 1 and NVHPC only compiles if we
+// don't ask for the return value.
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+using ::printf;
+#else
+template <typename... Args>
+KOKKOS_FORCEINLINE_FUNCTION void printf(const char* format, Args... args) {
+#ifdef KOKKOS_ENABLE_SYCL
+  // Some compilers warn if "args" is empty and format is not a string literal
+  if constexpr (sizeof...(Args) == 0)
+    sycl::ext::oneapi::experimental::printf("%s", format);
+  else
+    sycl::ext::oneapi::experimental::printf(format, args...);
+#else
+  if constexpr (sizeof...(Args) == 0)
+    ::printf("%s", format);
+  else
+    ::printf(format, args...);
+#endif
+}
+#endif
+
+}  // namespace Kokkos
+
+#endif /* #ifndef KOKKOS_PRINTF_HPP */
diff --git a/core/src/Kokkos_Profiling_ProfileSection.hpp b/core/src/Kokkos_Profiling_ProfileSection.hpp
index 29a04ac3b0..e7a9ba0c7e 100644
--- a/core/src/Kokkos_Profiling_ProfileSection.hpp
+++ b/core/src/Kokkos_Profiling_ProfileSection.hpp
@@ -22,49 +22,34 @@
 #endif
 
 #include <Kokkos_Macros.hpp>
-#include <impl/Kokkos_Profiling_Interface.hpp>
 #include <impl/Kokkos_Profiling.hpp>
 
 #include <string>
 
-namespace Kokkos {
-namespace Profiling {
+namespace Kokkos::Profiling {
+
+class [[nodiscard]] ProfilingSection {
+  uint32_t sectionID;
 
-class ProfilingSection {
  public:
   ProfilingSection(ProfilingSection const&) = delete;
   ProfilingSection& operator=(ProfilingSection const&) = delete;
 
-  ProfilingSection(const std::string& sectionName) {
-    if (Kokkos::Profiling::profileLibraryLoaded()) {
-      Kokkos::Profiling::createProfileSection(sectionName, &secID);
-    }
-  }
-
-  void start() {
-    if (Kokkos::Profiling::profileLibraryLoaded()) {
-      Kokkos::Profiling::startSection(secID);
-    }
+#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard) >= 201907
+  [[nodiscard]]
+#endif
+  explicit ProfilingSection(const std::string& sectionName) {
+    Kokkos::Profiling::createProfileSection(sectionName, &sectionID);
   }
 
-  void stop() {
-    if (Kokkos::Profiling::profileLibraryLoaded()) {
-      Kokkos::Profiling::stopSection(secID);
-    }
-  }
+  void start() { Kokkos::Profiling::startSection(sectionID); }
 
-  ~ProfilingSection() {
-    if (Kokkos::Profiling::profileLibraryLoaded()) {
-      Kokkos::Profiling::destroyProfileSection(secID);
-    }
-  }
+  void stop() { Kokkos::Profiling::stopSection(sectionID); }
 
- protected:
-  uint32_t secID;
+  ~ProfilingSection() { Kokkos::Profiling::destroyProfileSection(sectionID); }
 };
 
-}  // namespace Profiling
-}  // namespace Kokkos
+}  // namespace Kokkos::Profiling
 
 #ifdef KOKKOS_IMPL_PUBLIC_INCLUDE_NOTDEFINED_CORE
 #undef KOKKOS_IMPL_PUBLIC_INCLUDE
diff --git a/core/src/Kokkos_ScratchSpace.hpp b/core/src/Kokkos_ScratchSpace.hpp
index a192b77f28..a925e32a33 100644
--- a/core/src/Kokkos_ScratchSpace.hpp
+++ b/core/src/Kokkos_ScratchSpace.hpp
@@ -126,7 +126,7 @@ class ScratchMemorySpace {
       // mfh 23 Jun 2015: printf call consumes 25 registers
       // in a CUDA build, so only print in debug mode.  The
       // function still returns nullptr if not enough memory.
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+      Kokkos::printf(
           "ScratchMemorySpace<...>::get_shmem: Failed to allocate "
           "%ld byte(s); remaining capacity is %ld byte(s)\n",
           long(size), long(capacity));
diff --git a/core/src/Kokkos_Swap.hpp b/core/src/Kokkos_Swap.hpp
new file mode 100644
index 0000000000..2f849a13ab
--- /dev/null
+++ b/core/src/Kokkos_Swap.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
+
+#ifndef KOKKOS_SWAP_HPP
+#define KOKKOS_SWAP_HPP
+
+#include <Kokkos_Macros.hpp>
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace Kokkos {
+
+template <class T>
+KOKKOS_FUNCTION constexpr std::enable_if_t<std::is_move_constructible_v<T> &&
+                                           std::is_move_assignable_v<T>>
+kokkos_swap(T& a, T& b) noexcept(std::is_nothrow_move_constructible_v<T>&&
+                                     std::is_nothrow_move_assignable_v<T>) {
+  T t(std::move(a));
+  a = std::move(b);
+  b = std::move(t);
+}
+
+namespace Impl {
+
+template <class T>
+struct is_swappable {
+  template <class U>
+  static decltype(kokkos_swap(std::declval<T&>(), std::declval<T&>()))
+  test_swap(int);
+  struct Nope;
+  template <class U>
+  static Nope test_swap(long);
+  static constexpr bool value =
+      !std::is_same_v<decltype(test_swap<T>(0)), Nope>;
+};
+
+template <class T>
+inline constexpr bool is_nothrow_swappable_v =
+    noexcept(kokkos_swap(std::declval<T&>(), std::declval<T&>()));
+
+}  // namespace Impl
+
+template <class T, std::size_t N>
+KOKKOS_FUNCTION constexpr std::enable_if_t<Impl::is_swappable<T>::value>
+kokkos_swap(T (&a)[N], T (&b)[N]) noexcept(Impl::is_nothrow_swappable_v<T>) {
+  for (std::size_t i = 0; i < N; ++i) {
+    kokkos_swap(a[i], b[i]);
+  }
+}
+
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Kokkos_Tuners.hpp b/core/src/Kokkos_Tuners.hpp
index 618401654e..f5ffc66af5 100644
--- a/core/src/Kokkos_Tuners.hpp
+++ b/core/src/Kokkos_Tuners.hpp
@@ -256,13 +256,14 @@ auto get_point_helper(const PointType& in, const ArrayType& indices,
 template <typename PointType, typename ArrayType>
 struct GetPoint;
 
-template <typename PointType, size_t X>
-struct GetPoint<PointType,
-                std::array<Kokkos::Tools::Experimental::VariableValue, X>> {
+template <typename PointType, size_t ArraySize>
+struct GetPoint<
+    PointType,
+    std::array<Kokkos::Tools::Experimental::VariableValue, ArraySize>> {
   using index_set_type =
-      std::array<Kokkos::Tools::Experimental::VariableValue, X>;
+      std::array<Kokkos::Tools::Experimental::VariableValue, ArraySize>;
   static auto build(const PointType& in, const index_set_type& indices) {
-    return get_point_helper(in, indices, std::make_index_sequence<X>{});
+    return get_point_helper(in, indices, std::make_index_sequence<ArraySize>{});
   }
 };
 
diff --git a/core/src/Kokkos_View.hpp b/core/src/Kokkos_View.hpp
index bcbb28014c..820a40a5f5 100644
--- a/core/src/Kokkos_View.hpp
+++ b/core/src/Kokkos_View.hpp
@@ -38,8 +38,10 @@ static_assert(false,
 
 #ifdef KOKKOS_ENABLE_IMPL_MDSPAN
 #include <View/MDSpan/Kokkos_MDSpan_Extents.hpp>
+#include <View/MDSpan/Kokkos_MDSpan_Layout.hpp>
+#include <View/MDSpan/Kokkos_MDSpan_Accessor.hpp>
 #endif
-#include <Kokkos_MinMaxClamp.hpp>
+#include <Kokkos_MinMax.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -75,25 +77,59 @@ constexpr KOKKOS_INLINE_FUNCTION std::size_t count_valid_integers(
          (i6 != KOKKOS_INVALID_INDEX) + (i7 != KOKKOS_INVALID_INDEX);
 }
 
-KOKKOS_INLINE_FUNCTION
-void runtime_check_rank(const size_t rank, const size_t dyn_rank,
-                        const bool is_void_spec, const size_t i0,
-                        const size_t i1, const size_t i2, const size_t i3,
-                        const size_t i4, const size_t i5, const size_t i6,
-                        const size_t i7, const std::string& label) {
+// FIXME Ideally, we would not instantiate this function for every possible View
+// type. We should be able to only pass "extent" when we use mdspan.
+template <typename View>
+KOKKOS_INLINE_FUNCTION void runtime_check_rank(
+    const View&, const bool is_void_spec, const size_t i0, const size_t i1,
+    const size_t i2, const size_t i3, const size_t i4, const size_t i5,
+    const size_t i6, const size_t i7, const char* label) {
   (void)(label);
 
   if (is_void_spec) {
     const size_t num_passed_args =
         count_valid_integers(i0, i1, i2, i3, i4, i5, i6, i7);
+    // We either allow to pass as many extents as the dynamic rank is, or
+    // as many extents as the total rank is. In the latter case, the given
+    // extents for the static dimensions must match the
+    // compile-time extents.
+    constexpr int rank            = View::rank();
+    constexpr int dyn_rank        = View::rank_dynamic();
+    const bool n_args_is_dyn_rank = num_passed_args == dyn_rank;
+    const bool n_args_is_rank     = num_passed_args == rank;
+
+    if constexpr (rank != dyn_rank) {
+      if (n_args_is_rank) {
+        size_t new_extents[8] = {i0, i1, i2, i3, i4, i5, i6, i7};
+        for (int i = dyn_rank; i < rank; ++i)
+          if (new_extents[i] != View::static_extent(i)) {
+            KOKKOS_IF_ON_HOST(
+                const std::string message =
+                    "The specified run-time extent for Kokkos::View '" +
+                    std::string(label) +
+                    "' does not match the compile-time extent in dimension " +
+                    std::to_string(i) + ". The given extent is " +
+                    std::to_string(new_extents[i]) + " but should be " +
+                    std::to_string(View::static_extent(i)) + ".\n";
+                Kokkos::abort(message.c_str());)
+            KOKKOS_IF_ON_DEVICE(
+                Kokkos::abort(
+                    "The specified run-time extents for a Kokkos::View "
+                    "do not match the compile-time extents.");)
+          }
+      }
+    }
 
-    if (num_passed_args != dyn_rank && num_passed_args != rank) {
+    if (!n_args_is_dyn_rank && !n_args_is_rank) {
       KOKKOS_IF_ON_HOST(
           const std::string message =
-              "Constructor for Kokkos View '" + label +
-              "' has mismatched number of arguments. Number of arguments = " +
+              "Constructor for Kokkos::View '" + std::string(label) +
+              "' has mismatched number of arguments. The number "
+              "of arguments = " +
               std::to_string(num_passed_args) +
-              " but dynamic rank = " + std::to_string(dyn_rank) + " \n";
+              " neither matches the dynamic rank = " +
+              std::to_string(dyn_rank) +
+              " nor the total rank = " + std::to_string(rank) + "\n";
           Kokkos::abort(message.c_str());)
       KOKKOS_IF_ON_DEVICE(Kokkos::abort("Constructor for Kokkos View has "
                                         "mismatched number of arguments.");)
@@ -338,6 +374,35 @@ struct ViewTraits {
   //------------------------------------
 };
 
+#ifdef KOKKOS_ENABLE_IMPL_MDSPAN
+namespace Impl {
+struct UnsupportedKokkosArrayLayout;
+
+template <class Traits, class Enabled = void>
+struct MDSpanViewTraits {
+  using mdspan_type = UnsupportedKokkosArrayLayout;
+};
+
+// "Natural" mdspan for a view if the View's ArrayLayout is supported.
+template <class Traits>
+struct MDSpanViewTraits<Traits,
+                        std::void_t<typename Impl::LayoutFromArrayLayout<
+                            typename Traits::array_layout>::type>> {
+  using index_type = std::size_t;
+  using extents_type =
+      typename Impl::ExtentsFromDataType<index_type,
+                                         typename Traits::data_type>::type;
+  using mdspan_layout_type =
+      typename Impl::LayoutFromArrayLayout<typename Traits::array_layout>::type;
+  using accessor_type = Impl::SpaceAwareAccessor<
+      typename Traits::memory_space,
+      Kokkos::default_accessor<typename Traits::value_type>>;
+  using mdspan_type = mdspan<typename Traits::value_type, extents_type,
+                             mdspan_layout_type, accessor_type>;
+};
+}  // namespace Impl
+#endif  // KOKKOS_ENABLE_IMPL_MDSPAN
+
 /** \class View
  *  \brief View to an array of data.
  *
@@ -488,7 +553,6 @@ constexpr bool is_assignable(const Kokkos::View<ViewTDst...>& dst,
 //----------------------------------------------------------------------------
 
 #include <impl/Kokkos_ViewMapping.hpp>
-#include <impl/Kokkos_ViewArray.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -814,15 +878,15 @@ 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(sizeof...(Is) <= 8, "");
-    static_assert(Kokkos::Impl::are_integral<Is...>::value, "");
+    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(Kokkos::Impl::are_integral<Is...>::value, "");
+    static_assert(rank == sizeof...(Is));
+    static_assert(Kokkos::Impl::are_integral<Is...>::value);
   }
 
  public:
@@ -889,57 +953,30 @@ 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_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 && (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 && (rank_dynamic == 0)),
+       (2 == rank) && is_default_map &&
+       (is_layout_left || is_layout_right || is_layout_stride)),
       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 && (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];
-  }
-
-  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),
-                       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.S0 +
-                               i1 * m_map.m_impl_offset.m_stride.S1];
+    if constexpr (is_layout_left) {
+      if constexpr (rank_dynamic == 0)
+        return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
+      else
+        return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
+    } else if constexpr (is_layout_right) {
+      if constexpr (rank_dynamic == 0)
+        return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
+      else
+        return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
+    } else {
+      static_assert(is_layout_stride);
+      return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
+                                 i1 * m_map.m_impl_offset.m_stride.S1];
+    }
+#if defined KOKKOS_COMPILER_INTEL
+    __builtin_unreachable();
+#endif
   }
 
   // Rank 0 -> 8 operator() except for rank-1 and rank-2 with default map which
@@ -1032,57 +1069,30 @@ 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 && (rank_dynamic == 0)),
-      reference_type>
-  access(I0 i0, I1 i1, Is... extra) const {
-    check_access_member_function_valid_args(i0, i1, extra...);
-    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
-    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
-  }
-
-  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 && (rank_dynamic != 0)),
-      reference_type>
-  access(I0 i0, I1 i1, Is... extra) const {
-    check_access_member_function_valid_args(i0, i1, extra...);
-    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
-    return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
-  }
-
-  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 && (rank_dynamic == 0)),
-      reference_type>
-  access(I0 i0, I1 i1, Is... extra) const {
-    check_access_member_function_valid_args(i0, i1, extra...);
-    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
-    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
-  }
-
-  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 && (rank_dynamic != 0)),
+       is_default_map &&
+       (is_layout_left || is_layout_right || is_layout_stride)),
       reference_type>
   access(I0 i0, I1 i1, Is... extra) const {
     check_access_member_function_valid_args(i0, i1, extra...);
     KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
-    return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
-  }
-
-  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),
-                       reference_type>
-      access(I0 i0, I1 i1, Is... extra) const {
-    check_access_member_function_valid_args(i0, i1, extra...);
-    KOKKOS_IMPL_VIEW_OPERATOR_VERIFY(m_track, m_map, i0, i1, extra...)
-    return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
-                               i1 * m_map.m_impl_offset.m_stride.S1];
+    if constexpr (is_layout_left) {
+      if constexpr (rank_dynamic == 0)
+        return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_dim.N0 * i1];
+      else
+        return m_map.m_impl_handle[i0 + m_map.m_impl_offset.m_stride * i1];
+    } else if constexpr (is_layout_right) {
+      if constexpr (rank_dynamic == 0)
+        return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_dim.N1 * i0];
+      else
+        return m_map.m_impl_handle[i1 + m_map.m_impl_offset.m_stride * i0];
+    } else {
+      static_assert(is_layout_stride);
+      return m_map.m_impl_handle[i0 * m_map.m_impl_offset.m_stride.S0 +
+                                 i1 * m_map.m_impl_offset.m_stride.S1];
+    }
+#if defined KOKKOS_COMPILER_INTEL
+    __builtin_unreachable();
+#endif
   }
 
   //------------------------------
@@ -1402,21 +1412,29 @@ class View : public ViewTraits<DataType, Properties...> {
           "execution space");
     }
 
-    size_t i0 = arg_layout.dimension[0];
-    size_t i1 = arg_layout.dimension[1];
-    size_t i2 = arg_layout.dimension[2];
-    size_t i3 = arg_layout.dimension[3];
-    size_t i4 = arg_layout.dimension[4];
-    size_t i5 = arg_layout.dimension[5];
-    size_t i6 = arg_layout.dimension[6];
-    size_t i7 = arg_layout.dimension[7];
-
-    const std::string& alloc_name =
-        Impl::get_property<Impl::LabelTag>(prop_copy);
-    Impl::runtime_check_rank(
-        rank, rank_dynamic,
-        std::is_same<typename traits::specialize, void>::value, i0, i1, i2, i3,
-        i4, i5, i6, i7, alloc_name);
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
+    if constexpr (std::is_same_v<typename traits::array_layout,
+                                 Kokkos::LayoutLeft> ||
+                  std::is_same_v<typename traits::array_layout,
+                                 Kokkos::LayoutRight> ||
+                  std::is_same_v<typename traits::array_layout,
+                                 Kokkos::LayoutStride>) {
+      size_t i0 = arg_layout.dimension[0];
+      size_t i1 = arg_layout.dimension[1];
+      size_t i2 = arg_layout.dimension[2];
+      size_t i3 = arg_layout.dimension[3];
+      size_t i4 = arg_layout.dimension[4];
+      size_t i5 = arg_layout.dimension[5];
+      size_t i6 = arg_layout.dimension[6];
+      size_t i7 = arg_layout.dimension[7];
+
+      const std::string& alloc_name =
+          Impl::get_property<Impl::LabelTag>(prop_copy);
+      Impl::runtime_check_rank(
+          *this, std::is_same<typename traits::specialize, void>::value, i0, i1,
+          i2, i3, i4, i5, i6, i7, alloc_name.c_str());
+    }
+#endif
 
     Kokkos::Impl::SharedAllocationRecord<>* record = m_map.allocate_shared(
         prop_copy, arg_layout, Impl::ViewCtorProp<P...>::has_execution_space);
@@ -1445,6 +1463,28 @@ class View : public ViewTraits<DataType, Properties...> {
                      typename Impl::ViewCtorProp<P...>::pointer_type>::value,
         "Constructing View to wrap user memory must supply matching pointer "
         "type");
+
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
+    if constexpr (std::is_same_v<typename traits::array_layout,
+                                 Kokkos::LayoutLeft> ||
+                  std::is_same_v<typename traits::array_layout,
+                                 Kokkos::LayoutRight> ||
+                  std::is_same_v<typename traits::array_layout,
+                                 Kokkos::LayoutStride>) {
+      size_t i0 = arg_layout.dimension[0];
+      size_t i1 = arg_layout.dimension[1];
+      size_t i2 = arg_layout.dimension[2];
+      size_t i3 = arg_layout.dimension[3];
+      size_t i4 = arg_layout.dimension[4];
+      size_t i5 = arg_layout.dimension[5];
+      size_t i6 = arg_layout.dimension[6];
+      size_t i7 = arg_layout.dimension[7];
+
+      Impl::runtime_check_rank(
+          *this, std::is_same<typename traits::specialize, void>::value, i0, i1,
+          i2, i3, i4, i5, i6, i7, "UNMANAGED");
+    }
+#endif
   }
 
   // Simple dimension-only layout
@@ -1659,6 +1699,79 @@ class View : public ViewTraits<DataType, Properties...> {
                   "Layout is not constructible from extent arguments. Use "
                   "overload taking a layout object instead.");
   }
+
+  //----------------------------------------
+  // MDSpan converting constructors
+#ifdef KOKKOS_ENABLE_IMPL_MDSPAN
+  template <typename U = typename Impl::MDSpanViewTraits<traits>::mdspan_type>
+  KOKKOS_INLINE_FUNCTION
+#ifndef KOKKOS_ENABLE_CXX17
+      explicit(traits::is_managed)
+#endif
+          View(const typename Impl::MDSpanViewTraits<traits>::mdspan_type& mds,
+               std::enable_if_t<
+                   !std::is_same_v<Impl::UnsupportedKokkosArrayLayout, U>>* =
+                   nullptr)
+      : View(mds.data_handle(),
+             Impl::array_layout_from_mapping<
+                 typename traits::array_layout,
+                 typename Impl::MDSpanViewTraits<traits>::mdspan_type>(
+                 mds.mapping())) {
+  }
+
+  template <class ElementType, class ExtentsType, class LayoutType,
+            class AccessorType>
+  KOKKOS_INLINE_FUNCTION
+#ifndef KOKKOS_ENABLE_CXX17
+      explicit(!std::is_convertible_v<
+               Kokkos::mdspan<ElementType, ExtentsType, LayoutType,
+                              AccessorType>,
+               typename Impl::MDSpanViewTraits<traits>::mdspan_type>)
+#endif
+          View(const Kokkos::mdspan<ElementType, ExtentsType, LayoutType,
+                                    AccessorType>& mds)
+      : View(typename Impl::MDSpanViewTraits<traits>::mdspan_type(mds)) {
+  }
+
+  //----------------------------------------
+  // Conversion to MDSpan
+  template <class OtherElementType, class OtherExtents, class OtherLayoutPolicy,
+            class OtherAccessor,
+            class ImplNaturalMDSpanType =
+                typename Impl::MDSpanViewTraits<traits>::mdspan_type,
+            typename = std::enable_if_t<std::conditional_t<
+                std::is_same_v<Impl::UnsupportedKokkosArrayLayout,
+                               ImplNaturalMDSpanType>,
+                std::false_type,
+                std::is_assignable<mdspan<OtherElementType, OtherExtents,
+                                          OtherLayoutPolicy, OtherAccessor>,
+                                   ImplNaturalMDSpanType>>::value>>
+  KOKKOS_INLINE_FUNCTION constexpr operator mdspan<
+      OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>() {
+    using mdspan_type = typename Impl::MDSpanViewTraits<traits>::mdspan_type;
+    return mdspan_type{data(),
+                       Impl::mapping_from_view_mapping<mdspan_type>(m_map)};
+  }
+
+  template <class OtherAccessorType = Impl::SpaceAwareAccessor<
+                typename traits::memory_space,
+                Kokkos::default_accessor<typename traits::value_type>>,
+            typename = std::enable_if_t<std::is_assignable_v<
+                typename traits::value_type*&,
+                typename OtherAccessorType::data_handle_type>>>
+  KOKKOS_INLINE_FUNCTION constexpr auto to_mdspan(
+      const OtherAccessorType& other_accessor =
+          typename Impl::MDSpanViewTraits<traits>::accessor_type()) {
+    using mdspan_type = typename Impl::MDSpanViewTraits<traits>::mdspan_type;
+    using ret_mdspan_type =
+        mdspan<typename mdspan_type::element_type,
+               typename mdspan_type::extents_type,
+               typename mdspan_type::layout_type, OtherAccessorType>;
+    return ret_mdspan_type{data(),
+                           Impl::mapping_from_view_mapping<mdspan_type>(m_map),
+                           other_accessor};
+  }
+#endif  // KOKKOS_ENABLE_IMPL_MDSPAN
 };
 
 template <typename D, class... P>
@@ -1812,23 +1925,6 @@ KOKKOS_INLINE_FUNCTION bool operator!=(const View<LT, LP...>& lhs,
 namespace Kokkos {
 namespace Impl {
 
-inline void shared_allocation_tracking_disable() {
-  Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_disable();
-}
-
-inline void shared_allocation_tracking_enable() {
-  Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_enable();
-}
-
-} /* namespace Impl */
-} /* namespace Kokkos */
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
 template <class Specialize, typename A, typename B>
 struct CommonViewValueType;
 
diff --git a/core/src/OpenACC/Kokkos_OpenACC.cpp b/core/src/OpenACC/Kokkos_OpenACC.cpp
index f54c44d66f..99daf379b6 100644
--- a/core/src/OpenACC/Kokkos_OpenACC.cpp
+++ b/core/src/OpenACC/Kokkos_OpenACC.cpp
@@ -58,8 +58,10 @@ void Kokkos::Experimental::OpenACC::impl_initialize(
     Impl::OpenACCInternal::m_acc_device_num =
         acc_get_device_num(acc_device_host);
   } else {
+    using Kokkos::Impl::get_visible_devices;
+    std::vector<int> const& visible_devices = get_visible_devices();
     using Kokkos::Impl::get_gpu;
-    int const dev_num = get_gpu(settings);
+    int const dev_num = get_gpu(settings).value_or(visible_devices[0]);
     acc_set_device_num(dev_num, Impl::OpenACC_Traits::dev_type);
     Impl::OpenACCInternal::m_acc_device_num = dev_num;
   }
diff --git a/core/src/OpenACC/Kokkos_OpenACC.hpp b/core/src/OpenACC/Kokkos_OpenACC.hpp
index a115bc90f8..5155bee33d 100644
--- a/core/src/OpenACC/Kokkos_OpenACC.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC.hpp
@@ -39,7 +39,10 @@ static_assert(false,
 
 // FIXME_OPENACC: Below macro is temporarily enabled to avoid issues on existing
 // OpenACC compilers not supporting lambda with parallel loops.
+// LLVM/Clacc compiler does not need this.
+#ifndef KOKKOS_COMPILER_CLANG
 #define KOKKOS_ENABLE_OPENACC_COLLAPSE_HIERARCHICAL_CONSTRUCTS
+#endif
 
 namespace Kokkos::Experimental::Impl {
 class OpenACCInternal;
@@ -88,7 +91,11 @@ class OpenACC {
 #else
   int concurrency() const { return 256000; }  // FIXME_OPENACC
 #endif
-  static bool in_parallel() { return acc_on_device(acc_device_not_host); }
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED static bool in_parallel() {
+    return acc_on_device(acc_device_not_host);
+  }
+#endif
   uint32_t impl_instance_id() const noexcept;
   Impl::OpenACCInternal* impl_internal_space_instance() const {
     return m_space_instance.get();
diff --git a/core/src/OpenACC/Kokkos_OpenACCSpace.cpp b/core/src/OpenACC/Kokkos_OpenACCSpace.cpp
index 141ec77fd1..c8a5d28ba8 100644
--- a/core/src/OpenACC/Kokkos_OpenACCSpace.cpp
+++ b/core/src/OpenACC/Kokkos_OpenACCSpace.cpp
@@ -19,8 +19,8 @@
 #include <OpenACC/Kokkos_OpenACC.hpp>
 #include <OpenACC/Kokkos_OpenACCSpace.hpp>
 #include <OpenACC/Kokkos_OpenACC_DeepCopy.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
 #include <impl/Kokkos_Profiling_Interface.hpp>
+#include <impl/Kokkos_Error.hpp>
 
 #include <openacc.h>
 
@@ -66,6 +66,10 @@ void *Kokkos::Experimental::OpenACCSpace::impl_allocate(
 
   ptr = acc_malloc(arg_alloc_size);
 
+  if (!ptr) {
+    Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
+  }
+
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     const size_t reported_size =
         (arg_logical_size > 0) ? arg_logical_size : arg_alloc_size;
diff --git a/core/src/OpenACC/Kokkos_OpenACC_DeepCopy.hpp b/core/src/OpenACC/Kokkos_OpenACC_DeepCopy.hpp
index 4aed7e00f7..ca022192b0 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_DeepCopy.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_DeepCopy.hpp
@@ -34,7 +34,7 @@ struct Kokkos::Impl::DeepCopy<Kokkos::Experimental::OpenACCSpace,
     // value checking is added as a safeguard. (The current NVHPC (V22.5)
     // supports OpenACC V2.7.)
     if (n > 0) {
-      acc_memcpy_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_device_async(dst, const_cast<void*>(src), n, acc_async_noval);
     }
   }
   DeepCopy(const Kokkos::Experimental::OpenACC& exec, void* dst,
@@ -52,7 +52,7 @@ struct Kokkos::Impl::DeepCopy<Kokkos::Experimental::OpenACCSpace,
                               ExecutionSpace> {
   DeepCopy(void* dst, const void* src, size_t n) {
     if (n > 0) {
-      acc_memcpy_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_device_async(dst, const_cast<void*>(src), n, acc_async_noval);
     }
   }
   DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
@@ -60,7 +60,7 @@ struct Kokkos::Impl::DeepCopy<Kokkos::Experimental::OpenACCSpace,
         "Kokkos::Impl::DeepCopy<OpenACCSpace, OpenACCSpace, "
         "ExecutionSpace>::DeepCopy: fence before copy");
     if (n > 0) {
-      acc_memcpy_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_device_async(dst, const_cast<void*>(src), n, acc_async_noval);
     }
   }
 };
@@ -70,7 +70,9 @@ struct Kokkos::Impl::DeepCopy<Kokkos::Experimental::OpenACCSpace,
                               Kokkos::HostSpace,
                               Kokkos::Experimental::OpenACC> {
   DeepCopy(void* dst, const void* src, size_t n) {
-    if (n > 0) acc_memcpy_to_device(dst, const_cast<void*>(src), n);
+    if (n > 0)
+      acc_memcpy_to_device_async(dst, const_cast<void*>(src), n,
+                                 acc_async_noval);
   }
   DeepCopy(const Kokkos::Experimental::OpenACC& exec, void* dst,
            const void* src, size_t n) {
@@ -85,7 +87,8 @@ struct Kokkos::Impl::DeepCopy<Kokkos::Experimental::OpenACCSpace,
                               Kokkos::HostSpace, ExecutionSpace> {
   DeepCopy(void* dst, const void* src, size_t n) {
     if (n > 0) {
-      acc_memcpy_to_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_to_device_async(dst, const_cast<void*>(src), n,
+                                 acc_async_noval);
     }
   }
   DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
@@ -93,7 +96,8 @@ struct Kokkos::Impl::DeepCopy<Kokkos::Experimental::OpenACCSpace,
         "Kokkos::Impl::DeepCopy<OpenACCSpace, HostSpace, "
         "ExecutionSpace>::DeepCopy: fence before copy");
     if (n > 0) {
-      acc_memcpy_to_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_to_device_async(dst, const_cast<void*>(src), n,
+                                 acc_async_noval);
     }
   }
 };
@@ -104,7 +108,8 @@ struct Kokkos::Impl::DeepCopy<Kokkos::HostSpace,
                               Kokkos::Experimental::OpenACC> {
   DeepCopy(void* dst, const void* src, size_t n) {
     if (n > 0) {
-      acc_memcpy_from_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_from_device_async(dst, const_cast<void*>(src), n,
+                                   acc_async_noval);
     }
   }
   DeepCopy(const Kokkos::Experimental::OpenACC& exec, void* dst,
@@ -120,14 +125,17 @@ template <class ExecutionSpace>
 struct Kokkos::Impl::DeepCopy<
     Kokkos::HostSpace, Kokkos::Experimental::OpenACCSpace, ExecutionSpace> {
   DeepCopy(void* dst, const void* src, size_t n) {
-    if (n > 0) acc_memcpy_from_device(dst, const_cast<void*>(src), n);
+    if (n > 0)
+      acc_memcpy_from_device_async(dst, const_cast<void*>(src), n,
+                                   acc_async_noval);
   }
   DeepCopy(const ExecutionSpace& exec, void* dst, const void* src, size_t n) {
     exec.fence(
         "Kokkos::Impl::DeepCopy<HostSpace, OpenACCSpace, "
         "ExecutionSpace>::DeepCopy: fence before copy");
     if (n > 0) {
-      acc_memcpy_from_device(dst, const_cast<void*>(src), n);
+      acc_memcpy_from_device_async(dst, const_cast<void*>(src), n,
+                                   acc_async_noval);
     }
   }
 };
diff --git a/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp b/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp
index f2fd1a3619..82d38586eb 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp
@@ -36,7 +36,7 @@ class FunctorAdapter;
    public:                                                         \
     FunctorAdapter(Functor const &functor) : m_functor(functor) {} \
                                                                    \
-    KOKKOS_IMPL_ACC_PRAGMA_HELPER(routine CLAUSE)                  \
+    KOKKOS_IMPL_ACC_PRAGMA(routine CLAUSE)                         \
     template <class... Args>                                       \
     KOKKOS_FUNCTION void operator()(Args &&... args) const {       \
       if constexpr (std::is_void_v<WorkTag>) {                     \
diff --git a/core/src/OpenACC/Kokkos_OpenACC_Instance.hpp b/core/src/OpenACC/Kokkos_OpenACC_Instance.hpp
index 6645616ba5..c3d7236872 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_Instance.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_Instance.hpp
@@ -35,7 +35,7 @@ class OpenACCInternal {
 
  public:
   static int m_acc_device_num;
-  int m_async_arg = acc_async_sync;
+  int m_async_arg = acc_async_noval;
 
   OpenACCInternal() = default;
 
@@ -43,7 +43,7 @@ class OpenACCInternal {
 
   bool verify_is_initialized(const char* const label) const;
 
-  void initialize(int async_arg = acc_async_sync);
+  void initialize(int async_arg = acc_async_noval);
   void finalize();
   bool is_initialized() const;
 
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp
index b5cf670791..2b98018e3b 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelFor_Team.hpp
@@ -44,10 +44,12 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
     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();
+
     auto const a_functor(m_functor);
 
 #pragma acc parallel loop gang vector num_gangs(league_size) \
-    vector_length(team_size* vector_length) copyin(a_functor)
+    vector_length(team_size* vector_length) copyin(a_functor) async(async_arg)
     for (int i = 0; i < league_size * team_size * vector_length; i++) {
       int league_id = i / (team_size * vector_length);
       typename Policy::member_type team(league_id, league_size, team_size,
@@ -132,7 +134,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, worker>
+  Kokkos::Experimental::Impl::FunctorAdapter<
+      FunctorType, Policy, Kokkos::Experimental::Impl::RoutineClause::worker>
       m_functor;
   using Member = typename Policy::member_type;
 
@@ -144,10 +147,12 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
     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();
+
     auto const a_functor(m_functor);
 
 #pragma acc parallel loop gang num_gangs(league_size) num_workers(team_size) \
-    vector_length(vector_length) copyin(a_functor)
+    vector_length(vector_length) copyin(a_functor) async(async_arg)
     for (int i = 0; i < league_size; i++) {
       int league_id = i;
       typename Policy::member_type team(league_id, league_size, team_size,
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp
index 2c7793dc11..5afb5e75d3 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_MDRange.hpp
@@ -31,7 +31,7 @@ template <class Functor, class Reducer, class Policy,
 struct OpenACCParallelReduceMDRangeHelper {
   OpenACCParallelReduceMDRangeHelper(Functor const&, Reducer const&,
                                      Policy const&) {
-    static_assert(!Kokkos::Impl::always_true<Functor>::value,
+    static_assert(Kokkos::Impl::always_false<Functor>::value,
                   "not implemented");
   }
 };
@@ -136,6 +136,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         functor(i0, i1, val);                                                 \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -159,6 +160,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         functor(i0, i1, val);                                                 \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -188,6 +190,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -217,6 +220,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -248,6 +252,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -279,6 +284,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -314,6 +320,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -349,6 +356,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -388,6 +396,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
                                                                               \
@@ -427,6 +436,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         }                                                                     \
       }                                                                       \
     }                                                                         \
+    acc_wait(async_arg);                                                      \
     aval = val;                                                               \
   }                                                                           \
   }  // namespace Kokkos::Experimental::Impl
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp
index b61a05a8ee..f9039e3bb4 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Range.hpp
@@ -31,7 +31,7 @@ template <class Functor, class Reducer, class Policy,
           bool = std::is_arithmetic_v<typename Reducer::value_type>>
 struct OpenACCParallelReduceHelper {
   OpenACCParallelReduceHelper(Functor const&, Reducer const&, Policy const&) {
-    static_assert(!Kokkos::Impl::always_true<Functor>::value,
+    static_assert(Kokkos::Impl::always_false<Functor>::value,
                   "not implemented");
   }
 };
@@ -140,6 +140,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         functor(i, val);                                                  \
       }                                                                   \
     }                                                                     \
+    acc_wait(async_arg);                                                  \
     aval = val;                                                           \
   }                                                                       \
                                                                           \
@@ -169,6 +170,7 @@ class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
         functor(i, val);                                                  \
       }                                                                   \
     }                                                                     \
+    acc_wait(async_arg);                                                  \
     aval = val;                                                           \
   }                                                                       \
   }  // namespace Kokkos::Experimental::Impl
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp
index 3223ce3f9a..430bdcb680 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelReduce_Team.hpp
@@ -40,7 +40,7 @@ template <class Functor, class Reducer, class Policy,
 struct OpenACCParallelReduceTeamHelper {
   OpenACCParallelReduceTeamHelper(Functor const&, Reducer const&,
                                   Policy const&) {
-    static_assert(!Kokkos::Impl::always_true<Functor>::value,
+    static_assert(Kokkos::Impl::always_false<Functor>::value,
                   "not implemented");
   }
 };
@@ -129,7 +129,7 @@ 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,
+  static_assert(Kokkos::Impl::always_false<Lambda>::value,
                 "custom reduction is not implemented");
 }
 
@@ -140,7 +140,7 @@ 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,
+  static_assert(Kokkos::Impl::always_false<Lambda>::value,
                 "custom reduction is not implemented");
 }
 
@@ -394,6 +394,7 @@ KOKKOS_INLINE_FUNCTION void parallel_reduce(
                                         vector_length);                    \
       functor(team, val);                                                  \
     }                                                                      \
+    acc_wait(async_arg);                                                   \
     aval = val;                                                            \
   }                                                                        \
   }  // namespace Kokkos::Experimental::Impl
diff --git a/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp b/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp
index 00b0a5d25c..c6d3267bdb 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_ParallelScan_Range.hpp
@@ -19,8 +19,25 @@
 
 #include <OpenACC/Kokkos_OpenACC.hpp>
 #include <OpenACC/Kokkos_OpenACC_FunctorAdapter.hpp>
+#include <OpenACC/Kokkos_OpenACC_Macros.hpp>
 #include <Kokkos_Parallel.hpp>
 
+// Clacc uses an alternative implementation to work around not-yet-implemented
+// OpenACC features: Clacc does not fully support private clauses for
+// gang-private variables, and the alternative implementation allocates
+// the gang-private arrays on GPU global memory using array expansion,
+// instead of using the private clause.
+/* clang-format off */
+#ifdef KOKKOS_COMPILER_CLANG
+#define KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(THREADID) \
+  element_values[team_id * 2 * chunk_size + THREADID]
+#define KOKKOS_IMPL_ACC_ELEMENT_VALUES_CLAUSE create(element_values [0:num_elements])
+#else
+#define KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(THREADID) element_values[THREADID]
+#define KOKKOS_IMPL_ACC_ELEMENT_VALUES_CLAUSE private(element_values [0:num_elements])
+#endif
+/* clang-format on */
+
 namespace Kokkos::Impl {
 
 template <class Functor, class GivenValueType, class... Traits>
@@ -69,6 +86,11 @@ class ParallelScanOpenACCBase {
         functor(m_functor);
     const IndexType N        = end - begin;
     const IndexType n_chunks = (N + chunk_size - 1) / chunk_size;
+#ifdef KOKKOS_COMPILER_CLANG
+    int const num_elements = n_chunks * 2 * chunk_size;
+#else
+    int const num_elements = 2 * chunk_size;
+#endif
     Kokkos::View<ValueType*, Kokkos::Experimental::OpenACCSpace> chunk_values(
         "Kokkos::OpenACCParallelScan::chunk_values", n_chunks);
     Kokkos::View<ValueType*, Kokkos::Experimental::OpenACCSpace> offset_values(
@@ -76,16 +98,16 @@ class ParallelScanOpenACCBase {
     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]);
+        new ValueType[num_elements]);
     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)
+    /* clang-format off */
+KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector_length(chunk_size) KOKKOS_IMPL_ACC_ELEMENT_VALUES_CLAUSE present(functor, chunk_values, final_reducer) async(async_arg))
+    /* clang-format on */
     for (IndexType team_id = 0; team_id < n_chunks; ++team_id) {
       IndexType current_step = 0;
       IndexType next_step    = 1;
@@ -97,34 +119,37 @@ class ParallelScanOpenACCBase {
         ValueType update;
         final_reducer.init(&update);
         if ((idx > 0) && (idx < N)) functor(idx - 1, update, false);
-        element_values[thread_id] = update;
+        KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(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];
+            KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(next_step * chunk_size +
+                                            thread_id) =
+                KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(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;
+            ValueType localValue = KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(
+                current_step * chunk_size + thread_id);
+            final_reducer.join(&localValue, &KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(
+                                                current_step * chunk_size +
+                                                thread_id - step_size));
+            KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(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];
+      chunk_values(team_id) = KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(
+          current_step * chunk_size + chunk_size - 1);
     }
 
     ValueType tempValue;
-#pragma acc serial loop present(chunk_values, offset_values, final_reducer) \
-    async(async_arg)
+#pragma acc parallel loop seq num_gangs(1) num_workers(1) vector_length(1) \
+    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));
@@ -135,10 +160,9 @@ class ParallelScanOpenACCBase {
       }
     }
 
-#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)
+    /* clang-format off */
+KOKKOS_IMPL_ACC_PRAGMA(parallel loop gang vector_length(chunk_size) KOKKOS_IMPL_ACC_ELEMENT_VALUES_CLAUSE present(functor, offset_values, final_reducer) copyin(m_result_total) async(async_arg))
+    /* clang-format on */
     for (IndexType team_id = 0; team_id < n_chunks; ++team_id) {
       IndexType current_step = 0;
       IndexType next_step    = 1;
@@ -153,21 +177,24 @@ class ParallelScanOpenACCBase {
           final_reducer.join(&update, &offset_values(team_id));
         }
         if ((idx > 0) && (idx < N)) functor(idx - 1, update, false);
-        element_values[thread_id] = update;
+        KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(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];
+            KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(next_step * chunk_size +
+                                            thread_id) =
+                KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(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;
+            ValueType localValue = KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(
+                current_step * chunk_size + thread_id);
+            final_reducer.join(&localValue, &KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(
+                                                current_step * chunk_size +
+                                                thread_id - step_size));
+            KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(next_step * chunk_size +
+                                            thread_id) = localValue;
           }
         }
         temp         = current_step;
@@ -178,8 +205,8 @@ class ParallelScanOpenACCBase {
       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];
+        ValueType update             = KOKKOS_IMPL_ACC_ACCESS_ELEMENTS(
+            current_step * chunk_size + thread_id);
         if (idx < N) functor(idx, update, true);
         if (idx == N - 1) {
           if (m_result_ptr_device_accessible) {
@@ -240,7 +267,7 @@ class Kokkos::Impl::ParallelScan<Functor, Kokkos::RangePolicy<Traits...>,
 
     int const async_arg = base_t::m_policy.space().acc_async_queue();
 
-    OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
+    base_t::OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
   }
 
   ParallelScan(const Functor& arg_functor,
@@ -272,7 +299,7 @@ class Kokkos::Impl::ParallelScanWithTotal<
 
     int const async_arg = base_t::m_policy.space().acc_async_queue();
 
-    OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
+    base_t::OpenACCParallelScanRangePolicy(begin, end, chunk_size, async_arg);
   }
 
   template <class ViewType>
@@ -285,4 +312,7 @@ class Kokkos::Impl::ParallelScanWithTotal<
   }
 };
 
+#undef KOKKOS_IMPL_ACC_ACCESS_ELEMENTS
+#undef KOKKOS_IMPL_ACC_ELEMENT_VALUES_CLAUSE
+
 #endif
diff --git a/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.cpp b/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.cpp
index 91faa64f73..76e1514476 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.cpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.cpp
@@ -16,92 +16,11 @@
 
 #define KOKKOS_IMPL_PUBLIC_INCLUDE
 
-#include <OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp>
+#include <OpenACC/Kokkos_OpenACC.hpp>
 #include <OpenACC/Kokkos_OpenACC_DeepCopy.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
-#include <Kokkos_HostSpace.hpp>
-
-#ifdef KOKKOS_ENABLE_DEBUG
-Kokkos::Impl::SharedAllocationRecord<void, void> SharedAllocationRecord<
-    Kokkos::Experimental::OpenACCSpace, void>::s_root_record;
-#endif
-
-Kokkos::Impl::SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace,
-                                     void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     (SharedAllocationRecord<void, void>::m_alloc_size -
-                      sizeof(SharedAllocationHeader)));
-}
-
-Kokkos::Impl::SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::OpenACCSpace &arg_space,
-        const std::string &arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  Kokkos::Impl::DeepCopy<Experimental::OpenACCSpace, HostSpace>(
-      RecordBase::m_alloc_ptr, &header, sizeof(SharedAllocationHeader));
-  Kokkos::fence(
-      "SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace, "
-      "void>::SharedAllocationRecord(): fence after copying header from "
-      "HostSpace");
-}
-
-Kokkos::Impl::SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::OpenACC &arg_exec_space,
-        const Kokkos::Experimental::OpenACCSpace &arg_space,
-        const std::string &arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_exec_space, arg_space,
-                                               arg_label, arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  Kokkos::Impl::DeepCopy<Experimental::OpenACCSpace, HostSpace>(
-      arg_exec_space, RecordBase::m_alloc_ptr, &header,
-      sizeof(SharedAllocationHeader));
-}
-
-//==============================================================================
-// <editor-fold desc="Explicit instantiations of CRTP Base classes"> {{{1
+#include <OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp>
 
 #include <impl/Kokkos_SharedAlloc_timpl.hpp>
 
-// To avoid additional compilation cost for something that's (mostly?) not
-// performance sensitive, we explicitly instantiate these CRTP base classes
-// here, where we have access to the associated *_timpl.hpp header files.
-template class Kokkos::Impl::HostInaccessibleSharedAllocationRecordCommon<
-    Kokkos::Experimental::OpenACCSpace>;
-template class Kokkos::Impl::SharedAllocationRecordCommon<
-    Kokkos::Experimental::OpenACCSpace>;
-
-// </editor-fold> end Explicit instantiations of CRTP Base classes }}}1
-//==============================================================================
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::Experimental::OpenACCSpace);
diff --git a/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp b/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp
index cf83a5b27b..cde5ecdcb7 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_SharedAllocationRecord.hpp
@@ -20,55 +20,7 @@
 #include <OpenACC/Kokkos_OpenACCSpace.hpp>
 #include <impl/Kokkos_SharedAlloc.hpp>
 
-#include <openacc.h>
-
-template <>
-class Kokkos::Impl::SharedAllocationRecord<Kokkos::Experimental::OpenACCSpace,
-                                           void>
-    : public HostInaccessibleSharedAllocationRecordCommon<
-          Kokkos::Experimental::OpenACCSpace> {
- private:
-  friend class HostInaccessibleSharedAllocationRecordCommon<
-      Kokkos::Experimental::OpenACCSpace>;
-  friend class SharedAllocationRecordCommon<Kokkos::Experimental::OpenACCSpace>;
-  friend Kokkos::Experimental::OpenACCSpace;
-
-  using base_t = HostInaccessibleSharedAllocationRecordCommon<
-      Kokkos::Experimental::OpenACCSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-  /**\brief  Root record for tracked allocations from this OpenACCSpace
-   * instance */
-  static RecordBase s_root_record;
-
-  const Kokkos::Experimental::OpenACCSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      const Kokkos::Experimental::OpenACCSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::OpenACC& exec_space,
-      const Kokkos::Experimental::OpenACCSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate);
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::OpenACCSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate);
-};
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::Experimental::OpenACCSpace);
 
 #endif
diff --git a/core/src/OpenACC/Kokkos_OpenACC_Team.hpp b/core/src/OpenACC/Kokkos_OpenACC_Team.hpp
index 4ec71f56ef..20ea392452 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_true<ValueType>::value,
+    static_assert(Kokkos::Impl::always_false<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_true<ValueType>::value,
+    static_assert(Kokkos::Impl::always_false<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_true<ArgType>::value,
+        Kokkos::Impl::always_false<ArgType>::value,
         "Kokkos Error: team_scan() is not implemented for the OpenACC backend");
     return ArgType();
   }
diff --git a/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp b/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp
index 88140a7647..faa50aa7c3 100644
--- a/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp
+++ b/core/src/OpenACC/Kokkos_OpenACC_Traits.hpp
@@ -25,6 +25,9 @@ struct OpenACC_Traits {
 #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;
+#elif defined(KOKKOS_ARCH_AMD_GPU)
+  static constexpr acc_device_t dev_type     = acc_device_radeon;
+  static constexpr bool may_fallback_to_host = false;
 #else
   static constexpr acc_device_t dev_type     = acc_device_not_host;
   static constexpr bool may_fallback_to_host = true;
diff --git a/core/src/OpenMP/Kokkos_OpenMP.cpp b/core/src/OpenMP/Kokkos_OpenMP.cpp
index aa185a0bc0..82199d0d72 100644
--- a/core/src/OpenMP/Kokkos_OpenMP.cpp
+++ b/core/src/OpenMP/Kokkos_OpenMP.cpp
@@ -18,6 +18,8 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE
 #endif
 
+#include <iostream>
+
 #include <OpenMP/Kokkos_OpenMP.hpp>
 #include <OpenMP/Kokkos_OpenMP_Instance.hpp>
 
@@ -70,38 +72,44 @@ int OpenMP::concurrency(OpenMP const &instance) {
 int OpenMP::concurrency() const { return impl_thread_pool_size(); }
 #endif
 
+void OpenMP::impl_static_fence(std::string const &name) {
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::OpenMP>(
+      name,
+      Kokkos::Tools::Experimental::SpecialSynchronizationCases::
+          GlobalDeviceSynchronization,
+      []() {
+        std::lock_guard<std::mutex> lock_all_instances(
+            Impl::OpenMPInternal::all_instances_mutex);
+        for (auto *instance_ptr : Impl::OpenMPInternal::all_instances) {
+          std::lock_guard<std::mutex> lock_instance(
+              instance_ptr->m_instance_mutex);
+        }
+      });
+}
+
 void OpenMP::fence(const std::string &name) const {
   Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::OpenMP>(
-      name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1}, []() {});
+      name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1},
+      [this]() {
+        auto *internal_instance = this->impl_internal_space_instance();
+        std::lock_guard<std::mutex> lock(internal_instance->m_instance_mutex);
+      });
 }
 
 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
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+KOKKOS_DEPRECATED bool OpenMP::in_parallel(OpenMP const &exec_space) noexcept {
   return exec_space.impl_internal_space_instance()->m_level < omp_get_level();
-#endif
 }
+#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)
+  return (impl_internal_space_instance()->get_level() < omp_get_level())
              ? omp_get_num_threads()
              : impl_internal_space_instance()->m_pool_size;
-#endif
 }
 
 int OpenMP::impl_max_hardware_threads() noexcept {
diff --git a/core/src/OpenMP/Kokkos_OpenMP.hpp b/core/src/OpenMP/Kokkos_OpenMP.hpp
index 56937f32f5..a403909f67 100644
--- a/core/src/OpenMP/Kokkos_OpenMP.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP.hpp
@@ -27,14 +27,7 @@ static_assert(false,
 
 #include <Kokkos_Core_fwd.hpp>
 
-#include <cstddef>
-#include <iosfwd>
 #include <Kokkos_HostSpace.hpp>
-
-#ifdef KOKKOS_ENABLE_HBWSPACE
-#include <Kokkos_HBWSpace.hpp>
-#endif
-
 #include <Kokkos_ScratchSpace.hpp>
 #include <Kokkos_Parallel.hpp>
 #include <Kokkos_TaskScheduler.hpp>
@@ -45,6 +38,8 @@ static_assert(false,
 
 #include <omp.h>
 
+#include <cstddef>
+#include <iosfwd>
 #include <vector>
 
 /*--------------------------------------------------------------------------*/
@@ -53,11 +48,6 @@ 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
@@ -67,12 +57,7 @@ class OpenMP {
   //! Tag this class as a kokkos execution space
   using execution_space = OpenMP;
 
-  using memory_space =
-#ifdef KOKKOS_ENABLE_HBWSPACE
-      Experimental::HBWSpace;
-#else
-      HostSpace;
-#endif
+  using memory_space = HostSpace;
 
   //! This execution space preferred device_type
   using device_type          = Kokkos::Device<execution_space, memory_space>;
@@ -82,13 +67,23 @@ class OpenMP {
 
   OpenMP();
 
-  OpenMP(int pool_size);
+  explicit OpenMP(int pool_size);
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT(
+      "OpenMP execution space should be constructed explicitly.")
+  OpenMP(int pool_size)
+      : OpenMP(pool_size) {}
+#endif
 
   /// \brief Print configuration information to the given output stream.
   void print_configuration(std::ostream& os, bool verbose = false) const;
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   /// \brief is the instance running a parallel algorithm
-  static bool in_parallel(OpenMP const& = OpenMP()) noexcept;
+  KOKKOS_DEPRECATED static bool in_parallel(OpenMP const& = OpenMP()) noexcept;
+#endif
 
   /// \brief Wait until all dispatched functors complete on the given instance
   ///
@@ -104,18 +99,6 @@ class OpenMP {
   /// This always returns false on OpenMP
   inline static bool is_asynchronous(OpenMP const& = OpenMP()) noexcept;
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-  /// \brief Partition the default instance and call 'f' on each new 'master'
-  /// thread
-  ///
-  /// Func is a functor with the following signiture
-  ///   void( int partition_id, int num_partitions )
-  template <typename F>
-  KOKKOS_DEPRECATED static void partition_master(
-      F const& f, int requested_num_partitions = 0,
-      int requested_partition_size = 0);
-#endif
-
 #ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
   static int concurrency(OpenMP const& = OpenMP());
 #else
@@ -166,26 +149,11 @@ class OpenMP {
 };
 
 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;
 }
@@ -234,7 +202,6 @@ struct MemorySpaceAccess<Kokkos::OpenMP::memory_space,
 
 #include <OpenMP/Kokkos_OpenMP_Instance.hpp>
 #include <OpenMP/Kokkos_OpenMP_Team.hpp>
-#include <OpenMP/Kokkos_OpenMP_Parallel.hpp>
 #include <OpenMP/Kokkos_OpenMP_Task.hpp>
 
 #include <KokkosExp_MDRangePolicy.hpp>
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp b/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
index 57f2d82194..0f4c7d6052 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Instance.cpp
@@ -34,73 +34,8 @@
 namespace Kokkos {
 namespace Impl {
 
-void OpenMPInternal::acquire_lock() {
-  while (1 == desul::atomic_compare_exchange(&m_pool_mutex, 0, 1,
-                                             desul::MemoryOrderAcquire(),
-                                             desul::MemoryScopeDevice())) {
-    // do nothing
-  }
-}
-
-void OpenMPInternal::release_lock() {
-  desul::atomic_store(&m_pool_mutex, 0, desul::MemoryOrderRelease(),
-                      desul::MemoryScopeDevice());
-}
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-void OpenMPInternal::validate_partition_impl(const int nthreads,
-                                             int &num_partitions,
-                                             int &partition_size) {
-  if (nthreads == 1) {
-    num_partitions = 1;
-    partition_size = 1;
-  } else if (num_partitions < 1 && partition_size < 1) {
-    int idle = nthreads;
-    for (int np = 2; np <= nthreads; ++np) {
-      for (int ps = 1; ps <= nthreads / np; ++ps) {
-        if (nthreads - np * ps < idle) {
-          idle           = nthreads - np * ps;
-          num_partitions = np;
-          partition_size = ps;
-        }
-        if (idle == 0) {
-          break;
-        }
-      }
-    }
-  } else if (num_partitions < 1 && partition_size > 0) {
-    if (partition_size <= nthreads) {
-      num_partitions = nthreads / partition_size;
-    } else {
-      num_partitions = 1;
-      partition_size = nthreads;
-    }
-  } else if (num_partitions > 0 && partition_size < 1) {
-    if (num_partitions <= nthreads) {
-      partition_size = nthreads / num_partitions;
-    } else {
-      num_partitions = nthreads;
-      partition_size = 1;
-    }
-  } else if (num_partitions * partition_size > nthreads) {
-    int idle     = nthreads;
-    const int NP = num_partitions;
-    const int PS = partition_size;
-    for (int np = NP; np > 0; --np) {
-      for (int ps = PS; ps > 0; --ps) {
-        if ((np * ps <= nthreads) && (nthreads - np * ps < idle)) {
-          idle           = nthreads - np * ps;
-          num_partitions = np;
-          partition_size = ps;
-        }
-        if (idle == 0) {
-          break;
-        }
-      }
-    }
-  }
-}
-#endif
+std::vector<OpenMPInternal *> OpenMPInternal::all_instances;
+std::mutex OpenMPInternal::all_instances_mutex;
 
 void OpenMPInternal::clear_thread_data() {
   const size_t member_bytes =
@@ -178,17 +113,11 @@ void OpenMPInternal::resize_thread_data(size_t pool_reduce_bytes,
       if (nullptr != m_pool[rank]) {
         m_pool[rank]->disband_pool();
 
-        space.deallocate(m_pool[rank], old_alloc_bytes);
+        // impl_deallocate to not fence here
+        space.impl_deallocate("[unlabeled]", m_pool[rank], old_alloc_bytes);
       }
 
-      void *ptr = nullptr;
-      try {
-        ptr = space.allocate(alloc_bytes);
-      } catch (
-          Kokkos::Experimental::RawMemoryAllocationFailure const &failure) {
-        // For now, just rethrow the error message the existing way
-        Kokkos::Impl::throw_runtime_exception(failure.get_error_message());
-      }
+      void *ptr = space.allocate("Kokkos::OpenMP::scratch_mem", alloc_bytes);
 
       m_pool[rank] = new (ptr) HostThreadTeamData();
 
@@ -256,8 +185,6 @@ void OpenMPInternal::initialize(int thread_count) {
       }
     }
 
-    OpenMP::memory_space space;
-
     // Before any other call to OMP query the maximum number of threads
     // and save the value for re-initialization unit testing.
 
@@ -362,7 +289,17 @@ void OpenMPInternal::finalize() {
 
   m_initialized = false;
 
-  Kokkos::Profiling::finalize();
+  // guard erasing from all_instances
+  {
+    std::scoped_lock lock(all_instances_mutex);
+
+    auto it = std::find(all_instances.begin(), all_instances.end(), this);
+    if (it == all_instances.end())
+      Kokkos::abort(
+          "Execution space instance to be removed couldn't be found!");
+    *it = all_instances.back();
+    all_instances.pop_back();
+  }
 }
 
 void OpenMPInternal::print_configuration(std::ostream &s) const {
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp b/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp
index f8b55fda41..f4a0d3e201 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Instance.hpp
@@ -40,6 +40,8 @@
 #include <type_traits>
 #include <vector>
 
+/*--------------------------------------------------------------------------*/
+
 namespace Kokkos {
 namespace Impl {
 
@@ -48,13 +50,19 @@ class OpenMPInternal;
 inline int g_openmp_hardware_max_threads = 1;
 
 struct OpenMPTraits {
-  static int constexpr MAX_THREAD_COUNT = 512;
+  static constexpr int MAX_THREAD_COUNT = 512;
 };
 
 class OpenMPInternal {
  private:
   OpenMPInternal(int arg_pool_size)
-      : m_pool_size{arg_pool_size}, m_level{omp_get_level()}, m_pool() {}
+      : m_pool_size{arg_pool_size}, m_level{omp_get_level()}, m_pool() {
+    // guard pushing to all_instances
+    {
+      std::scoped_lock lock(all_instances_mutex);
+      all_instances.push_back(this);
+    }
+  }
 
   ~OpenMPInternal() { clear_thread_data(); }
 
@@ -64,7 +72,6 @@ class OpenMPInternal {
 
   int m_pool_size;
   int m_level;
-  int m_pool_mutex = 0;
 
   HostThreadTeamData* m_pool[OpenMPTraits::MAX_THREAD_COUNT];
 
@@ -81,17 +88,6 @@ class OpenMPInternal {
 
   int thread_pool_size() const { return m_pool_size; }
 
-  // Acquire lock used to protect access to m_pool
-  void acquire_lock();
-
-  // Release lock used to protect access to m_pool
-  void release_lock();
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-  static void validate_partition_impl(const int nthreads, int& num_partitions,
-                                      int& partition_size);
-#endif
-
   void resize_thread_data(size_t pool_reduce_bytes, size_t team_reduce_bytes,
                           size_t team_shared_bytes, size_t thread_local_bytes);
 
@@ -103,39 +99,34 @@ class OpenMPInternal {
     return m_pool[i];
   }
 
+  int get_level() const { return m_level; }
+
   bool is_initialized() const { return m_initialized; }
 
   bool verify_is_initialized(const char* const label) const;
 
   void print_configuration(std::ostream& s) const;
-};
 
-}  // namespace Impl
-
-namespace Experimental {
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-template <>
-class MasterLock<OpenMP> {
- public:
-  void lock() { omp_set_lock(&m_lock); }
-  void unlock() { omp_unset_lock(&m_lock); }
-  bool try_lock() { return static_cast<bool>(omp_test_lock(&m_lock)); }
+  std::mutex m_instance_mutex;
 
-  KOKKOS_DEPRECATED MasterLock() { omp_init_lock(&m_lock); }
-  ~MasterLock() { omp_destroy_lock(&m_lock); }
-
-  MasterLock(MasterLock const&) = delete;
-  MasterLock(MasterLock&&)      = delete;
-  MasterLock& operator=(MasterLock const&) = delete;
-  MasterLock& operator=(MasterLock&&) = delete;
-
- private:
-  omp_lock_t m_lock;
+  static std::vector<OpenMPInternal*> all_instances;
+  static std::mutex all_instances_mutex;
 };
+
+inline bool execute_in_serial(OpenMP const& space = OpenMP()) {
+// The default value returned by `omp_get_max_active_levels` with gcc version
+// lower than 11.1.0 is 2147483647 instead of 1.
+#if (!defined(KOKKOS_COMPILER_GNU) || KOKKOS_COMPILER_GNU >= 1110) && \
+    _OPENMP >= 201511
+  bool is_nested = omp_get_max_active_levels() > 1;
+#else
+  bool is_nested = static_cast<bool>(omp_get_nested());
 #endif
+  return (space.impl_internal_space_instance()->get_level() < omp_get_level() &&
+          !(is_nested && (omp_get_level() == 1)));
+}
 
-}  // namespace Experimental
+}  // namespace Impl
 
 namespace Experimental {
 namespace Impl {
@@ -170,7 +161,7 @@ inline std::vector<OpenMP> create_OpenMP_instances(
         "Kokkos::abort: Partition not enough resources left to create the last "
         "instance.");
   }
-  instances[weights.size() - 1] = resources_left;
+  instances[weights.size() - 1] = OpenMP(resources_left);
 
   return instances;
 }
@@ -190,50 +181,6 @@ std::vector<OpenMP> partition_space(OpenMP const& main_instance,
   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
deleted file mode 100644
index 3bfd6dea50..0000000000
--- a/core/src/OpenMP/Kokkos_OpenMP_Parallel.hpp
+++ /dev/null
@@ -1,1267 +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_OPENMP_PARALLEL_HPP
-#define KOKKOS_OPENMP_PARALLEL_HPP
-
-#include <Kokkos_Macros.hpp>
-#if defined(KOKKOS_ENABLE_OPENMP)
-
-#include <omp.h>
-#include <OpenMP/Kokkos_OpenMP_Instance.hpp>
-
-#include <KokkosExp_MDRangePolicy.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#define KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#undef KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-#define KOKKOS_PRAGMA_IVDEP_IF_ENABLED _Pragma("ivdep")
-#endif
-
-#ifndef KOKKOS_COMPILER_NVHPC
-#define KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE , m_policy.chunk_size()
-#else
-#define KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-inline bool execute_in_serial(OpenMP const& space = OpenMP()) {
-  return (OpenMP::in_parallel(space) &&
-          !(omp_get_nested() && (omp_get_level() == 1)));
-}
-
-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 Member  = typename Policy::member_type;
-
-  OpenMPInternal* m_instance;
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  inline static void exec_range(const FunctorType& functor, const Member ibeg,
-                                const Member iend) {
-    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-    for (auto iwork = ibeg; iwork < iend; ++iwork) {
-      exec_work(functor, iwork);
-    }
-  }
-
-  template <class Enable = WorkTag>
-  inline static std::enable_if_t<std::is_void<WorkTag>::value &&
-                                 std::is_same<Enable, WorkTag>::value>
-  exec_work(const FunctorType& functor, const Member iwork) {
-    functor(iwork);
-  }
-
-  template <class Enable = WorkTag>
-  inline static std::enable_if_t<!std::is_void<WorkTag>::value &&
-                                 std::is_same<Enable, WorkTag>::value>
-  exec_work(const FunctorType& functor, const Member iwork) {
-    functor(WorkTag{}, iwork);
-  }
-
-  template <class Policy>
-  std::enable_if_t<std::is_same<typename Policy::schedule_type::type,
-                                Kokkos::Dynamic>::value>
-  execute_parallel() const {
-    // prevent bug in NVHPC 21.9/CUDA 11.4 (entering zero iterations loop)
-    if (m_policy.begin() >= m_policy.end()) return;
-#pragma omp parallel for schedule(dynamic KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE) \
-    num_threads(m_instance->thread_pool_size())
-    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-    for (auto iwork = m_policy.begin(); iwork < m_policy.end(); ++iwork) {
-      exec_work(m_functor, iwork);
-    }
-  }
-
-  template <class Policy>
-  std::enable_if_t<!std::is_same<typename Policy::schedule_type::type,
-                                 Kokkos::Dynamic>::value>
-  execute_parallel() const {
-// Specifying an chunksize with GCC compiler leads to performance regression
-// with static schedule.
-#ifdef KOKKOS_COMPILER_GNU
-#pragma omp parallel for schedule(static) \
-    num_threads(m_instance->thread_pool_size())
-#else
-#pragma omp parallel for schedule(static KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE) \
-    num_threads(m_instance->thread_pool_size())
-#endif
-    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-    for (auto iwork = m_policy.begin(); iwork < m_policy.end(); ++iwork) {
-      exec_work(m_functor, iwork);
-    }
-  }
-
- public:
-  inline void execute() const {
-    if (execute_in_serial(m_policy.space())) {
-      exec_range(m_functor, m_policy.begin(), m_policy.end());
-      return;
-    }
-
-#ifndef KOKKOS_INTERNAL_DISABLE_NATIVE_OPENMP
-    execute_parallel<Policy>();
-#else
-    constexpr bool is_dynamic =
-        std::is_same<typename Policy::schedule_type::type,
-                     Kokkos::Dynamic>::value;
-#pragma omp parallel num_threads(m_instance->thread_pool_size())
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-
-      data.set_work_partition(m_policy.end() - m_policy.begin(),
-                              m_policy.chunk_size());
-
-      if (is_dynamic) {
-        // Make sure work partition is set before stealing
-        if (data.pool_rendezvous()) data.pool_rendezvous_release();
-      }
-
-      std::pair<int64_t, int64_t> range(0, 0);
-
-      do {
-        range = is_dynamic ? data.get_work_stealing_chunk()
-                           : data.get_work_partition();
-
-        exec_range(m_functor, range.first + m_policy.begin(),
-                   range.second + m_policy.begin());
-
-      } while (is_dynamic && 0 <= range.first);
-    }
-#endif
-  }
-
-  inline ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
-      : m_instance(nullptr), m_functor(arg_functor), m_policy(arg_policy) {
-#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
-  }
-};
-
-// MDRangePolicy impl
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
-                  Kokkos::OpenMP> {
- 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 index_type   = typename Policy::index_type;
-  using iterate_type = typename Kokkos::Impl::HostIterateTile<
-      MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void>;
-
-  OpenMPInternal* m_instance;
-  const iterate_type m_iter;
-
-  inline void exec_range(const Member ibeg, const Member iend) const {
-    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      m_iter(iwork);
-    }
-  }
-
-  template <class Policy>
-  typename std::enable_if_t<std::is_same<typename Policy::schedule_type::type,
-                                         Kokkos::Dynamic>::value>
-  execute_parallel() const {
-#pragma omp parallel for schedule(dynamic, 1) \
-    num_threads(m_instance->thread_pool_size())
-    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-    for (index_type iwork = 0; iwork < m_iter.m_rp.m_num_tiles; ++iwork) {
-      m_iter(iwork);
-    }
-  }
-
-  template <class Policy>
-  typename std::enable_if<!std::is_same<typename Policy::schedule_type::type,
-                                        Kokkos::Dynamic>::value>::type
-  execute_parallel() const {
-#pragma omp parallel for schedule(static, 1) \
-    num_threads(m_instance->thread_pool_size())
-    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-    for (index_type iwork = 0; iwork < m_iter.m_rp.m_num_tiles; ++iwork) {
-      m_iter(iwork);
-    }
-  }
-
- public:
-  inline void execute() const {
-#ifndef KOKKOS_COMPILER_INTEL
-    if (execute_in_serial(m_iter.m_rp.space())) {
-      exec_range(0, m_iter.m_rp.m_num_tiles);
-      return;
-    }
-#endif
-
-#ifndef KOKKOS_INTERNAL_DISABLE_NATIVE_OPENMP
-    execute_parallel<Policy>();
-#else
-    constexpr bool is_dynamic =
-        std::is_same<typename Policy::schedule_type::type,
-                     Kokkos::Dynamic>::value;
-
-#pragma omp parallel num_threads(m_instance->thread_pool_size())
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-
-      data.set_work_partition(m_iter.m_rp.m_num_tiles, 1);
-
-      if (is_dynamic) {
-        // Make sure work partition is set before stealing
-        if (data.pool_rendezvous()) data.pool_rendezvous_release();
-      }
-
-      std::pair<int64_t, int64_t> range(0, 0);
-
-      do {
-        range = is_dynamic ? data.get_work_stealing_chunk()
-                           : data.get_work_partition();
-
-        exec_range(range.first, range.second);
-
-      } while (is_dynamic && 0 <= range.first);
-    }
-    // END #pragma omp parallel
-#endif
-  }
-
-  inline ParallelFor(const FunctorType& arg_functor, MDRangePolicy arg_policy)
-      : m_instance(nullptr), m_iter(arg_policy, arg_functor) {
-#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
-  }
-  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::OpenMP> {
- 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 pointer_type   = typename ReducerType::pointer_type;
-  using reference_type = typename ReducerType::reference_type;
-
-  OpenMPInternal* m_instance;
-  const CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType& functor, const Member ibeg, const Member iend,
-      reference_type update) {
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      functor(iwork, update);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType& functor, const Member ibeg, const Member iend,
-      reference_type update) {
-    const TagType t{};
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      functor(t, iwork, update);
-    }
-  }
-
- public:
-  inline void execute() const {
-    const ReducerType& reducer = m_functor_reducer.get_reducer();
-
-    if (m_policy.end() <= m_policy.begin()) {
-      if (m_result_ptr) {
-        reducer.init(m_result_ptr);
-        reducer.final(m_result_ptr);
-      }
-      return;
-    }
-    enum {
-      is_dynamic = std::is_same<typename Policy::schedule_type::type,
-                                Kokkos::Dynamic>::value
-    };
-
-    const size_t pool_reduce_bytes = reducer.value_size();
-
-    m_instance->acquire_lock();
-
-    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
-                                   ,
-                                   0  // team_shared_bytes
-                                   ,
-                                   0  // thread_local_bytes
-    );
-
-    if (execute_in_serial(m_policy.space())) {
-      const pointer_type ptr =
-          m_result_ptr
-              ? m_result_ptr
-              : pointer_type(
-                    m_instance->get_thread_data(0)->pool_reduce_local());
-
-      reference_type update = reducer.init(ptr);
-
-      ParallelReduce::template exec_range<WorkTag>(
-          m_functor_reducer.get_functor(), m_policy.begin(), m_policy.end(),
-          update);
-
-      reducer.final(ptr);
-      return;
-    }
-    const int pool_size = m_instance->thread_pool_size();
-#pragma omp parallel num_threads(pool_size)
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-
-      data.set_work_partition(m_policy.end() - m_policy.begin(),
-                              m_policy.chunk_size());
-
-      if (is_dynamic) {
-        // Make sure work partition is set before stealing
-        if (data.pool_rendezvous()) data.pool_rendezvous_release();
-      }
-
-      reference_type update = reducer.init(
-          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
-
-      std::pair<int64_t, int64_t> range(0, 0);
-
-      do {
-        range = is_dynamic ? data.get_work_stealing_chunk()
-                           : data.get_work_partition();
-
-        ParallelReduce::template exec_range<WorkTag>(
-            m_functor_reducer.get_functor(), range.first + m_policy.begin(),
-            range.second + m_policy.begin(), update);
-
-      } while (is_dynamic && 0 <= range.first);
-    }
-
-    // Reduction:
-
-    const pointer_type ptr =
-        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
-
-    for (int i = 1; i < pool_size; ++i) {
-      reducer.join(ptr,
-                   reinterpret_cast<pointer_type>(
-                       m_instance->get_thread_data(i)->pool_reduce_local()));
-    }
-
-    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];
-      }
-    }
-
-    m_instance->release_lock();
-  }
-
-  //----------------------------------------
-
-  template <class ViewType>
-  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
-                        Policy arg_policy, const ViewType& arg_view)
-      : m_instance(nullptr),
-        m_functor_reducer(arg_functor_reducer),
-        m_policy(arg_policy),
-        m_result_ptr(arg_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(
-        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 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 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>;
-
-  OpenMPInternal* m_instance;
-  const iterate_type m_iter;
-  const pointer_type m_result_ptr;
-
-  inline void exec_range(const Member ibeg, const Member iend,
-                         reference_type update) const {
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      m_iter(iwork, update);
-    }
-  }
-
- public:
-  inline void execute() const {
-    const ReducerType& reducer     = m_iter.m_func.get_reducer();
-    const size_t pool_reduce_bytes = reducer.value_size();
-
-    m_instance->acquire_lock();
-
-    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
-                                   ,
-                                   0  // team_shared_bytes
-                                   ,
-                                   0  // thread_local_bytes
-    );
-
-#ifndef KOKKOS_COMPILER_INTEL
-    if (execute_in_serial(m_iter.m_rp.space())) {
-      const pointer_type ptr =
-          m_result_ptr
-              ? m_result_ptr
-              : pointer_type(
-                    m_instance->get_thread_data(0)->pool_reduce_local());
-
-      reference_type update = reducer.init(ptr);
-
-      ParallelReduce::exec_range(0, m_iter.m_rp.m_num_tiles, update);
-
-      reducer.final(ptr);
-
-      m_instance->release_lock();
-
-      return;
-    }
-#endif
-
-    enum {
-      is_dynamic = std::is_same<typename Policy::schedule_type::type,
-                                Kokkos::Dynamic>::value
-    };
-
-    const int pool_size = m_instance->thread_pool_size();
-#pragma omp parallel num_threads(pool_size)
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-
-      data.set_work_partition(m_iter.m_rp.m_num_tiles, 1);
-
-      if (is_dynamic) {
-        // Make sure work partition is set before stealing
-        if (data.pool_rendezvous()) data.pool_rendezvous_release();
-      }
-
-      reference_type update = reducer.init(
-          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
-
-      std::pair<int64_t, int64_t> range(0, 0);
-
-      do {
-        range = is_dynamic ? data.get_work_stealing_chunk()
-                           : data.get_work_partition();
-
-        ParallelReduce::exec_range(range.first, range.second, update);
-
-      } while (is_dynamic && 0 <= range.first);
-    }
-    // END #pragma omp parallel
-
-    // Reduction:
-
-    const pointer_type ptr =
-        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
-
-    for (int i = 1; i < pool_size; ++i) {
-      reducer.join(ptr,
-                   reinterpret_cast<pointer_type>(
-                       m_instance->get_thread_data(i)->pool_reduce_local()));
-    }
-
-    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];
-      }
-    }
-
-    m_instance->release_lock();
-  }
-
-  //----------------------------------------
-
-  template <class ViewType>
-  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
-                 MDRangePolicy arg_policy, const ViewType& arg_view)
-      : m_instance(nullptr),
-        m_iter(arg_policy, arg_functor_reducer),
-        m_result_ptr(arg_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(
-        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
-                                        Kokkos::HostSpace>::accessible,
-        "Kokkos::OpenMP 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::OpenMP> {
- private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-
-  using Analysis =
-      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType, void>;
-
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  OpenMPInternal* m_instance;
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType& functor, const Member ibeg, const Member iend,
-      reference_type update, const bool final) {
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      functor(iwork, update, final);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType& functor, const Member ibeg, const Member iend,
-      reference_type update, const bool final) {
-    const TagType t{};
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      functor(t, iwork, update, final);
-    }
-  }
-
- public:
-  inline void execute() const {
-    const int value_count          = Analysis::value_count(m_functor);
-    const size_t pool_reduce_bytes = 2 * Analysis::value_size(m_functor);
-
-    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
-                                   ,
-                                   0  // team_shared_bytes
-                                   ,
-                                   0  // thread_local_bytes
-    );
-
-    if (execute_in_serial(m_policy.space())) {
-      typename Analysis::Reducer final_reducer(m_functor);
-
-      reference_type update = final_reducer.init(
-          pointer_type(m_instance->get_thread_data(0)->pool_reduce_local()));
-
-      ParallelScan::template exec_range<WorkTag>(m_functor, m_policy.begin(),
-                                                 m_policy.end(), update, true);
-
-      return;
-    }
-
-#pragma omp parallel num_threads(m_instance->thread_pool_size())
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-      typename Analysis::Reducer final_reducer(m_functor);
-
-      const WorkRange range(m_policy, omp_get_thread_num(),
-                            omp_get_num_threads());
-
-      reference_type update_sum = final_reducer.init(
-          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
-
-      ParallelScan::template exec_range<WorkTag>(
-          m_functor, range.begin(), range.end(), update_sum, false);
-
-      if (data.pool_rendezvous()) {
-        pointer_type ptr_prev = nullptr;
-
-        const int n = omp_get_num_threads();
-
-        for (int i = 0; i < n; ++i) {
-          pointer_type ptr =
-              (pointer_type)data.pool_member(i)->pool_reduce_local();
-
-          if (i) {
-            for (int j = 0; j < value_count; ++j) {
-              ptr[j + value_count] = ptr_prev[j + value_count];
-            }
-            final_reducer.join(ptr + value_count, ptr_prev);
-          } else {
-            final_reducer.init(ptr + value_count);
-          }
-
-          ptr_prev = ptr;
-        }
-
-        data.pool_rendezvous_release();
-      }
-
-      reference_type update_base = final_reducer.reference(
-          reinterpret_cast<pointer_type>(data.pool_reduce_local()) +
-          value_count);
-
-      ParallelScan::template exec_range<WorkTag>(
-          m_functor, range.begin(), range.end(), update_base, true);
-    }
-  }
-
-  //----------------------------------------
-
-  inline ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_instance(nullptr), m_functor(arg_functor), m_policy(arg_policy) {
-#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
-  }
-
-  //----------------------------------------
-};
-
-template <class FunctorType, class ReturnType, class... Traits>
-class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
-                            ReturnType, Kokkos::OpenMP> {
- private:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-
-  using Analysis = FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
-                                   FunctorType, ReturnType>;
-
-  using WorkTag   = typename Policy::work_tag;
-  using WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_type;
-
-  using value_type     = typename Analysis::value_type;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  OpenMPInternal* m_instance;
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType& functor, const Member ibeg, const Member iend,
-      reference_type update, const bool final) {
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      functor(iwork, update, final);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType& functor, const Member ibeg, const Member iend,
-      reference_type update, const bool final) {
-    const TagType t{};
-    for (Member iwork = ibeg; iwork < iend; ++iwork) {
-      functor(t, iwork, update, final);
-    }
-  }
-
- public:
-  inline void execute() const {
-    const int value_count          = Analysis::value_count(m_functor);
-    const size_t pool_reduce_bytes = 2 * Analysis::value_size(m_functor);
-
-    m_instance->acquire_lock();
-
-    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
-                                   ,
-                                   0  // team_shared_bytes
-                                   ,
-                                   0  // thread_local_bytes
-    );
-
-    if (execute_in_serial(m_policy.space())) {
-      typename Analysis::Reducer final_reducer(m_functor);
-
-      reference_type update = final_reducer.init(
-          pointer_type(m_instance->get_thread_data(0)->pool_reduce_local()));
-
-      this->template exec_range<WorkTag>(m_functor, m_policy.begin(),
-                                         m_policy.end(), update, true);
-
-      *m_result_ptr = update;
-
-      m_instance->release_lock();
-
-      return;
-    }
-
-#pragma omp parallel num_threads(m_instance->thread_pool_size())
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-      typename Analysis::Reducer final_reducer(m_functor);
-
-      const WorkRange range(m_policy, omp_get_thread_num(),
-                            omp_get_num_threads());
-      reference_type update_sum = final_reducer.init(
-          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
-
-      ParallelScanWithTotal::template exec_range<WorkTag>(
-          m_functor, range.begin(), range.end(), update_sum, false);
-
-      if (data.pool_rendezvous()) {
-        pointer_type ptr_prev = nullptr;
-
-        const int n = omp_get_num_threads();
-
-        for (int i = 0; i < n; ++i) {
-          pointer_type ptr =
-              (pointer_type)data.pool_member(i)->pool_reduce_local();
-
-          if (i) {
-            for (int j = 0; j < value_count; ++j) {
-              ptr[j + value_count] = ptr_prev[j + value_count];
-            }
-            final_reducer.join(ptr + value_count, ptr_prev);
-          } else {
-            final_reducer.init(ptr + value_count);
-          }
-
-          ptr_prev = ptr;
-        }
-
-        data.pool_rendezvous_release();
-      }
-
-      reference_type update_base = final_reducer.reference(
-          reinterpret_cast<pointer_type>(data.pool_reduce_local()) +
-          value_count);
-
-      ParallelScanWithTotal::template exec_range<WorkTag>(
-          m_functor, range.begin(), range.end(), update_base, true);
-
-      if (omp_get_thread_num() == omp_get_num_threads() - 1) {
-        *m_result_ptr = update_base;
-      }
-    }
-
-    m_instance->release_lock();
-  }
-
-  //----------------------------------------
-
-  template <class ViewType>
-  ParallelScanWithTotal(const FunctorType& arg_functor,
-                        const Policy& arg_policy,
-                        const ViewType& arg_result_view)
-      : m_instance(nullptr),
-        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::OpenMP parallel_scan result must be host-accessible!");
-#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
-  }
-
-  //----------------------------------------
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template <class FunctorType, class... Properties>
-class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                  Kokkos::OpenMP> {
- private:
-  enum { TEAM_REDUCE_SIZE = 512 };
-
-  using Policy =
-      Kokkos::Impl::TeamPolicyInternal<Kokkos::OpenMP, Properties...>;
-  using WorkTag  = typename Policy::work_tag;
-  using SchedTag = typename Policy::schedule_type::type;
-  using Member   = typename Policy::member_type;
-
-  OpenMPInternal* m_instance;
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const size_t m_shmem_size;
-
-  template <class TagType>
-  inline static std::enable_if_t<(std::is_void<TagType>::value)> exec_team(
-      const FunctorType& functor, HostThreadTeamData& data,
-      const int league_rank_begin, const int league_rank_end,
-      const int league_size) {
-    for (int r = league_rank_begin; r < league_rank_end;) {
-      functor(Member(data, r, league_size));
-
-      if (++r < league_rank_end) {
-        // Don't allow team members to lap one another
-        // so that they don't overwrite shared memory.
-        if (data.team_rendezvous()) {
-          data.team_rendezvous_release();
-        }
-      }
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<(!std::is_void<TagType>::value)> exec_team(
-      const FunctorType& functor, HostThreadTeamData& data,
-      const int league_rank_begin, const int league_rank_end,
-      const int league_size) {
-    const TagType t{};
-
-    for (int r = league_rank_begin; r < league_rank_end;) {
-      functor(t, Member(data, r, league_size));
-
-      if (++r < league_rank_end) {
-        // Don't allow team members to lap one another
-        // so that they don't overwrite shared memory.
-        if (data.team_rendezvous()) {
-          data.team_rendezvous_release();
-        }
-      }
-    }
-  }
-
- public:
-  inline void execute() const {
-    enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
-
-    const size_t pool_reduce_size  = 0;  // Never shrinks
-    const size_t team_reduce_size  = TEAM_REDUCE_SIZE * m_policy.team_size();
-    const size_t team_shared_size  = m_shmem_size;
-    const size_t thread_local_size = 0;  // Never shrinks
-
-    m_instance->acquire_lock();
-
-    m_instance->resize_thread_data(pool_reduce_size, team_reduce_size,
-                                   team_shared_size, thread_local_size);
-
-    if (execute_in_serial(m_policy.space())) {
-      ParallelFor::template exec_team<WorkTag>(
-          m_functor, *(m_instance->get_thread_data()), 0,
-          m_policy.league_size(), m_policy.league_size());
-
-      m_instance->release_lock();
-
-      return;
-    }
-
-#pragma omp parallel num_threads(m_instance->thread_pool_size())
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-
-      const int active = data.organize_team(m_policy.team_size());
-
-      if (active) {
-        data.set_work_partition(
-            m_policy.league_size(),
-            (0 < m_policy.chunk_size() ? m_policy.chunk_size()
-                                       : m_policy.team_iter()));
-      }
-
-      if (is_dynamic) {
-        // Must synchronize to make sure each team has set its
-        // partition before beginning the work stealing loop.
-        if (data.pool_rendezvous()) data.pool_rendezvous_release();
-      }
-
-      if (active) {
-        std::pair<int64_t, int64_t> range(0, 0);
-
-        do {
-          range = is_dynamic ? data.get_work_stealing_chunk()
-                             : data.get_work_partition();
-
-          ParallelFor::template exec_team<WorkTag>(m_functor, data, range.first,
-                                                   range.second,
-                                                   m_policy.league_size());
-
-        } while (is_dynamic && 0 <= range.first);
-      }
-
-      data.disband_team();
-    }
-
-    m_instance->release_lock();
-  }
-
-  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_instance(nullptr),
-        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())) {
-#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
-  }
-};
-
-//----------------------------------------------------------------------------
-
-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 pointer_type   = typename ReducerType::pointer_type;
-  using reference_type = typename ReducerType::reference_type;
-
-  OpenMPInternal* m_instance;
-  const CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-  const int m_shmem_size;
-
-  template <class TagType>
-  inline static std::enable_if_t<(std::is_void<TagType>::value)> exec_team(
-      const FunctorType& functor, HostThreadTeamData& data,
-      reference_type& update, const int league_rank_begin,
-      const int league_rank_end, const int league_size) {
-    for (int r = league_rank_begin; r < league_rank_end;) {
-      functor(Member(data, r, league_size), update);
-
-      if (++r < league_rank_end) {
-        // Don't allow team members to lap one another
-        // so that they don't overwrite shared memory.
-        if (data.team_rendezvous()) {
-          data.team_rendezvous_release();
-        }
-      }
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<(!std::is_void<TagType>::value)> exec_team(
-      const FunctorType& functor, HostThreadTeamData& data,
-      reference_type& update, const int league_rank_begin,
-      const int league_rank_end, const int league_size) {
-    const TagType t{};
-
-    for (int r = league_rank_begin; r < league_rank_end;) {
-      functor(t, Member(data, r, league_size), update);
-
-      if (++r < league_rank_end) {
-        // Don't allow team members to lap one another
-        // so that they don't overwrite shared memory.
-        if (data.team_rendezvous()) {
-          data.team_rendezvous_release();
-        }
-      }
-    }
-  }
-
- public:
-  inline void execute() const {
-    enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
-
-    const ReducerType& reducer = m_functor_reducer.get_reducer();
-
-    if (m_policy.league_size() == 0 || m_policy.team_size() == 0) {
-      if (m_result_ptr) {
-        reducer.init(m_result_ptr);
-        reducer.final(m_result_ptr);
-      }
-      return;
-    }
-
-    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);
-    const size_t thread_local_size = 0;  // Never shrinks
-
-    m_instance->acquire_lock();
-
-    m_instance->resize_thread_data(pool_reduce_size, team_reduce_size,
-                                   team_shared_size, thread_local_size);
-
-    if (execute_in_serial(m_policy.space())) {
-      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       = 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_reducer.get_functor(), data, update, league_rank_begin,
-          league_rank_end, m_policy.league_size());
-
-      reducer.final(ptr);
-
-      m_instance->release_lock();
-
-      return;
-    }
-
-    const int pool_size = m_instance->thread_pool_size();
-#pragma omp parallel num_threads(pool_size)
-    {
-      HostThreadTeamData& data = *(m_instance->get_thread_data());
-
-      const int active = data.organize_team(m_policy.team_size());
-
-      if (active) {
-        data.set_work_partition(
-            m_policy.league_size(),
-            (0 < m_policy.chunk_size() ? m_policy.chunk_size()
-                                       : m_policy.team_iter()));
-      }
-
-      if (is_dynamic) {
-        // Must synchronize to make sure each team has set its
-        // partition before beginning the work stealing loop.
-        if (data.pool_rendezvous()) data.pool_rendezvous_release();
-      }
-
-      if (active) {
-        reference_type update = reducer.init(
-            reinterpret_cast<pointer_type>(data.pool_reduce_local()));
-
-        std::pair<int64_t, int64_t> range(0, 0);
-
-        do {
-          range = is_dynamic ? data.get_work_stealing_chunk()
-                             : data.get_work_partition();
-
-          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 {
-        reducer.init(reinterpret_cast<pointer_type>(data.pool_reduce_local()));
-      }
-
-      data.disband_team();
-
-      //  This thread has updated 'pool_reduce_local()' with its
-      //  contributions to the reduction.  The parallel region is
-      //  about to terminate and the master thread will load and
-      //  reduce each 'pool_reduce_local()' contribution.
-      //  Must 'memory_fence()' to guarantee that storing the update to
-      //  'pool_reduce_local()' will complete before this thread
-      //  exits the parallel region.
-
-      memory_fence();
-    }
-
-    // Reduction:
-
-    const pointer_type ptr =
-        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
-
-    for (int i = 1; i < pool_size; ++i) {
-      reducer.join(ptr,
-                   reinterpret_cast<pointer_type>(
-                       m_instance->get_thread_data(i)->pool_reduce_local()));
-    }
-
-    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];
-      }
-    }
-
-    m_instance->release_lock();
-  }
-
-  //----------------------------------------
-
-  template <class ViewType>
-  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
-                        const Policy& arg_policy, const ViewType& arg_result)
-      : m_instance(nullptr),
-        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())) {
-#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(
-        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
-                                        Kokkos::HostSpace>::accessible,
-        "Kokkos::OpenMP reduce result must be a View accessible from "
-        "HostSpace");
-  }
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#undef KOKKOS_PRAGMA_IVDEP_IF_ENABLED
-#undef KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE
-
-#endif
-#endif /* KOKKOS_OPENMP_PARALLEL_HPP */
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Parallel_For.hpp b/core/src/OpenMP/Kokkos_OpenMP_Parallel_For.hpp
new file mode 100644
index 0000000000..79d7d295c0
--- /dev/null
+++ b/core/src/OpenMP/Kokkos_OpenMP_Parallel_For.hpp
@@ -0,0 +1,412 @@
+//@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_PARALLEL_FOR_HPP
+#define KOKKOS_OPENMP_PARALLEL_FOR_HPP
+
+#include <omp.h>
+#include <OpenMP/Kokkos_OpenMP_Instance.hpp>
+#include <KokkosExp_MDRangePolicy.hpp>
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+#define KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#undef KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+#define KOKKOS_PRAGMA_IVDEP_IF_ENABLED _Pragma("ivdep")
+#endif
+
+#ifndef KOKKOS_COMPILER_NVHPC
+#define KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE , m_policy.chunk_size()
+#else
+#define KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE
+#endif
+
+namespace Kokkos {
+namespace Impl {
+
+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 Member  = typename Policy::member_type;
+
+  OpenMPInternal* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+  inline static void exec_range(const FunctorType& functor, const Member ibeg,
+                                const Member iend) {
+    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+    for (auto iwork = ibeg; iwork < iend; ++iwork) {
+      exec_work(functor, iwork);
+    }
+  }
+
+  template <class Enable = WorkTag>
+  inline static std::enable_if_t<std::is_void<WorkTag>::value &&
+                                 std::is_same<Enable, WorkTag>::value>
+  exec_work(const FunctorType& functor, const Member iwork) {
+    functor(iwork);
+  }
+
+  template <class Enable = WorkTag>
+  inline static std::enable_if_t<!std::is_void<WorkTag>::value &&
+                                 std::is_same<Enable, WorkTag>::value>
+  exec_work(const FunctorType& functor, const Member iwork) {
+    functor(WorkTag{}, iwork);
+  }
+
+  template <class Policy>
+  std::enable_if_t<std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value>
+  execute_parallel() const {
+    // prevent bug in NVHPC 21.9/CUDA 11.4 (entering zero iterations loop)
+    if (m_policy.begin() >= m_policy.end()) return;
+#pragma omp parallel for schedule(dynamic KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE) \
+    num_threads(m_instance->thread_pool_size())
+    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+    for (auto iwork = m_policy.begin(); iwork < m_policy.end(); ++iwork) {
+      exec_work(m_functor, iwork);
+    }
+  }
+
+  template <class Policy>
+  std::enable_if_t<!std::is_same<typename Policy::schedule_type::type,
+                                 Kokkos::Dynamic>::value>
+  execute_parallel() const {
+// Specifying an chunksize with GCC compiler leads to performance regression
+// with static schedule.
+#ifdef KOKKOS_COMPILER_GNU
+#pragma omp parallel for schedule(static) \
+    num_threads(m_instance->thread_pool_size())
+#else
+#pragma omp parallel for schedule(static KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE) \
+    num_threads(m_instance->thread_pool_size())
+#endif
+    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+    for (auto iwork = m_policy.begin(); iwork < m_policy.end(); ++iwork) {
+      exec_work(m_functor, iwork);
+    }
+  }
+
+ public:
+  inline void execute() const {
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+    if (execute_in_serial(m_policy.space())) {
+      exec_range(m_functor, m_policy.begin(), m_policy.end());
+      return;
+    }
+
+#ifndef KOKKOS_INTERNAL_DISABLE_NATIVE_OPENMP
+    execute_parallel<Policy>();
+#else
+    constexpr bool is_dynamic =
+        std::is_same<typename Policy::schedule_type::type,
+                     Kokkos::Dynamic>::value;
+#pragma omp parallel num_threads(m_instance->thread_pool_size())
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+
+      data.set_work_partition(m_policy.end() - m_policy.begin(),
+                              m_policy.chunk_size());
+
+      if (is_dynamic) {
+        // Make sure work partition is set before stealing
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
+
+      std::pair<int64_t, int64_t> range(0, 0);
+
+      do {
+        range = is_dynamic ? data.get_work_stealing_chunk()
+                           : data.get_work_partition();
+
+        exec_range(m_functor, range.first + m_policy.begin(),
+                   range.second + m_policy.begin());
+
+      } while (is_dynamic && 0 <= range.first);
+    }
+#endif
+  }
+
+  inline ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_instance(nullptr), m_functor(arg_functor), m_policy(arg_policy) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+  }
+};
+
+// MDRangePolicy impl
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::OpenMP> {
+ 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 index_type   = typename Policy::index_type;
+  using iterate_type = typename Kokkos::Impl::HostIterateTile<
+      MDRangePolicy, FunctorType, typename MDRangePolicy::work_tag, void>;
+
+  OpenMPInternal* m_instance;
+  const iterate_type m_iter;
+
+  inline void exec_range(const Member ibeg, const Member iend) const {
+    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      m_iter(iwork);
+    }
+  }
+
+  template <class Policy>
+  typename std::enable_if_t<std::is_same<typename Policy::schedule_type::type,
+                                         Kokkos::Dynamic>::value>
+  execute_parallel() const {
+#pragma omp parallel for schedule(dynamic, 1) \
+    num_threads(m_instance->thread_pool_size())
+    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+    for (index_type iwork = 0; iwork < m_iter.m_rp.m_num_tiles; ++iwork) {
+      m_iter(iwork);
+    }
+  }
+
+  template <class Policy>
+  typename std::enable_if<!std::is_same<typename Policy::schedule_type::type,
+                                        Kokkos::Dynamic>::value>::type
+  execute_parallel() const {
+#pragma omp parallel for schedule(static, 1) \
+    num_threads(m_instance->thread_pool_size())
+    KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+    for (index_type iwork = 0; iwork < m_iter.m_rp.m_num_tiles; ++iwork) {
+      m_iter(iwork);
+    }
+  }
+
+ public:
+  inline void execute() const {
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+#ifndef KOKKOS_COMPILER_INTEL
+    if (execute_in_serial(m_iter.m_rp.space())) {
+      exec_range(0, m_iter.m_rp.m_num_tiles);
+      return;
+    }
+#endif
+
+#ifndef KOKKOS_INTERNAL_DISABLE_NATIVE_OPENMP
+    execute_parallel<Policy>();
+#else
+    constexpr bool is_dynamic =
+        std::is_same<typename Policy::schedule_type::type,
+                     Kokkos::Dynamic>::value;
+
+#pragma omp parallel num_threads(m_instance->thread_pool_size())
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+
+      data.set_work_partition(m_iter.m_rp.m_num_tiles, 1);
+
+      if (is_dynamic) {
+        // Make sure work partition is set before stealing
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
+
+      std::pair<int64_t, int64_t> range(0, 0);
+
+      do {
+        range = is_dynamic ? data.get_work_stealing_chunk()
+                           : data.get_work_partition();
+
+        exec_range(range.first, range.second);
+
+      } while (is_dynamic && 0 <= range.first);
+    }
+    // END #pragma omp parallel
+#endif
+  }
+
+  inline ParallelFor(const FunctorType& arg_functor, MDRangePolicy arg_policy)
+      : m_instance(nullptr), m_iter(arg_policy, arg_functor) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+  }
+
+  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... Properties>
+class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                  Kokkos::OpenMP> {
+ private:
+  enum { TEAM_REDUCE_SIZE = 512 };
+
+  using Policy =
+      Kokkos::Impl::TeamPolicyInternal<Kokkos::OpenMP, Properties...>;
+  using WorkTag  = typename Policy::work_tag;
+  using SchedTag = typename Policy::schedule_type::type;
+  using Member   = typename Policy::member_type;
+
+  OpenMPInternal* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const size_t m_shmem_size;
+
+  template <class TagType>
+  inline static std::enable_if_t<(std::is_void<TagType>::value)> exec_team(
+      const FunctorType& functor, HostThreadTeamData& data,
+      const int league_rank_begin, const int league_rank_end,
+      const int league_size) {
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(Member(data, r, league_size));
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
+        }
+      }
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<(!std::is_void<TagType>::value)> exec_team(
+      const FunctorType& functor, HostThreadTeamData& data,
+      const int league_rank_begin, const int league_rank_end,
+      const int league_size) {
+    const TagType t{};
+
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(t, Member(data, r, league_size));
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
+        }
+      }
+    }
+  }
+
+ public:
+  inline void execute() const {
+    enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
+
+    const size_t pool_reduce_size  = 0;  // Never shrinks
+    const size_t team_reduce_size  = TEAM_REDUCE_SIZE * m_policy.team_size();
+    const size_t team_shared_size  = m_shmem_size;
+    const size_t thread_local_size = 0;  // Never shrinks
+
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+    m_instance->resize_thread_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
+
+    if (execute_in_serial(m_policy.space())) {
+      ParallelFor::template exec_team<WorkTag>(
+          m_functor, *(m_instance->get_thread_data()), 0,
+          m_policy.league_size(), m_policy.league_size());
+
+      return;
+    }
+
+#pragma omp parallel num_threads(m_instance->thread_pool_size())
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+
+      const int active = data.organize_team(m_policy.team_size());
+
+      if (active) {
+        data.set_work_partition(
+            m_policy.league_size(),
+            (0 < m_policy.chunk_size() ? m_policy.chunk_size()
+                                       : m_policy.team_iter()));
+      }
+
+      if (is_dynamic) {
+        // Must synchronize to make sure each team has set its
+        // partition before beginning the work stealing loop.
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
+
+      if (active) {
+        std::pair<int64_t, int64_t> range(0, 0);
+
+        do {
+          range = is_dynamic ? data.get_work_stealing_chunk()
+                             : data.get_work_partition();
+
+          ParallelFor::template exec_team<WorkTag>(m_functor, data, range.first,
+                                                   range.second,
+                                                   m_policy.league_size());
+
+        } while (is_dynamic && 0 <= range.first);
+      }
+
+      data.disband_team();
+    }
+  }
+
+  inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_instance(nullptr),
+        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())) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+#undef KOKKOS_PRAGMA_IVDEP_IF_ENABLED
+#undef KOKKOS_OPENMP_OPTIONAL_CHUNK_SIZE
+
+#endif /* KOKKOS_OPENMP_PARALLEL_FOR_HPP */
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Parallel_Reduce.hpp b/core/src/OpenMP/Kokkos_OpenMP_Parallel_Reduce.hpp
new file mode 100644
index 0000000000..d22e1e7eda
--- /dev/null
+++ b/core/src/OpenMP/Kokkos_OpenMP_Parallel_Reduce.hpp
@@ -0,0 +1,537 @@
+//@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_PARALLEL_REDUCE_HPP
+#define KOKKOS_OPENMP_PARALLEL_REDUCE_HPP
+
+#include <omp.h>
+#include <OpenMP/Kokkos_OpenMP_Instance.hpp>
+#include <KokkosExp_MDRangePolicy.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
+                     Kokkos::OpenMP> {
+ 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 pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+
+  OpenMPInternal* m_instance;
+  const CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+
+  template <class TagType>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType& functor, const Member ibeg, const Member iend,
+      reference_type update) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork, update);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType& functor, const Member ibeg, const Member iend,
+      reference_type update) {
+    const TagType t{};
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork, update);
+    }
+  }
+
+ public:
+  inline void execute() const {
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+
+    if (m_policy.end() <= m_policy.begin()) {
+      if (m_result_ptr) {
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
+      }
+      return;
+    }
+    enum {
+      is_dynamic = std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value
+    };
+
+    const size_t pool_reduce_bytes = reducer.value_size();
+
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
+
+    if (execute_in_serial(m_policy.space())) {
+      const pointer_type ptr =
+          m_result_ptr
+              ? m_result_ptr
+              : pointer_type(
+                    m_instance->get_thread_data(0)->pool_reduce_local());
+
+      reference_type update = reducer.init(ptr);
+
+      ParallelReduce::template exec_range<WorkTag>(
+          m_functor_reducer.get_functor(), m_policy.begin(), m_policy.end(),
+          update);
+
+      reducer.final(ptr);
+
+      return;
+    }
+    const int pool_size = m_instance->thread_pool_size();
+#pragma omp parallel num_threads(pool_size)
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+
+      data.set_work_partition(m_policy.end() - m_policy.begin(),
+                              m_policy.chunk_size());
+
+      if (is_dynamic) {
+        // Make sure work partition is set before stealing
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
+
+      reference_type update = reducer.init(
+          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+
+      std::pair<int64_t, int64_t> range(0, 0);
+
+      do {
+        range = is_dynamic ? data.get_work_stealing_chunk()
+                           : data.get_work_partition();
+
+        ParallelReduce::template exec_range<WorkTag>(
+            m_functor_reducer.get_functor(), range.first + m_policy.begin(),
+            range.second + m_policy.begin(), update);
+
+      } while (is_dynamic && 0 <= range.first);
+    }
+
+    // Reduction:
+
+    const pointer_type ptr =
+        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
+
+    for (int i = 1; i < pool_size; ++i) {
+      reducer.join(ptr,
+                   reinterpret_cast<pointer_type>(
+                       m_instance->get_thread_data(i)->pool_reduce_local()));
+    }
+
+    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];
+      }
+    }
+  }
+
+  //----------------------------------------
+
+  template <class ViewType>
+  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                        Policy arg_policy, const ViewType& arg_view)
+      : m_instance(nullptr),
+        m_functor_reducer(arg_functor_reducer),
+        m_policy(arg_policy),
+        m_result_ptr(arg_view.data()) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+    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 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 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>;
+
+  OpenMPInternal* m_instance;
+  const iterate_type m_iter;
+  const pointer_type m_result_ptr;
+
+  inline void exec_range(const Member ibeg, const Member iend,
+                         reference_type update) const {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      m_iter(iwork, update);
+    }
+  }
+
+ public:
+  inline void execute() const {
+    const ReducerType& reducer     = m_iter.m_func.get_reducer();
+    const size_t pool_reduce_bytes = reducer.value_size();
+
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
+
+#ifndef KOKKOS_COMPILER_INTEL
+    if (execute_in_serial(m_iter.m_rp.space())) {
+      const pointer_type ptr =
+          m_result_ptr
+              ? m_result_ptr
+              : pointer_type(
+                    m_instance->get_thread_data(0)->pool_reduce_local());
+
+      reference_type update = reducer.init(ptr);
+
+      ParallelReduce::exec_range(0, m_iter.m_rp.m_num_tiles, update);
+
+      reducer.final(ptr);
+
+      return;
+    }
+#endif
+
+    enum {
+      is_dynamic = std::is_same<typename Policy::schedule_type::type,
+                                Kokkos::Dynamic>::value
+    };
+
+    const int pool_size = m_instance->thread_pool_size();
+#pragma omp parallel num_threads(pool_size)
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+
+      data.set_work_partition(m_iter.m_rp.m_num_tiles, 1);
+
+      if (is_dynamic) {
+        // Make sure work partition is set before stealing
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
+
+      reference_type update = reducer.init(
+          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+
+      std::pair<int64_t, int64_t> range(0, 0);
+
+      do {
+        range = is_dynamic ? data.get_work_stealing_chunk()
+                           : data.get_work_partition();
+
+        ParallelReduce::exec_range(range.first, range.second, update);
+
+      } while (is_dynamic && 0 <= range.first);
+    }
+    // END #pragma omp parallel
+
+    // Reduction:
+
+    const pointer_type ptr =
+        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
+
+    for (int i = 1; i < pool_size; ++i) {
+      reducer.join(ptr,
+                   reinterpret_cast<pointer_type>(
+                       m_instance->get_thread_data(i)->pool_reduce_local()));
+    }
+
+    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];
+      }
+    }
+  }
+
+  //----------------------------------------
+
+  template <class ViewType>
+  ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                 MDRangePolicy arg_policy, const ViewType& arg_view)
+      : m_instance(nullptr),
+        m_iter(arg_policy, arg_functor_reducer),
+        m_result_ptr(arg_view.data()) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::OpenMP 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;
+  }
+};
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+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 pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+
+  OpenMPInternal* m_instance;
+  const CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const int m_shmem_size;
+
+  template <class TagType>
+  inline static std::enable_if_t<(std::is_void<TagType>::value)> exec_team(
+      const FunctorType& functor, HostThreadTeamData& data,
+      reference_type& update, const int league_rank_begin,
+      const int league_rank_end, const int league_size) {
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(Member(data, r, league_size), update);
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
+        }
+      }
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<(!std::is_void<TagType>::value)> exec_team(
+      const FunctorType& functor, HostThreadTeamData& data,
+      reference_type& update, const int league_rank_begin,
+      const int league_rank_end, const int league_size) {
+    const TagType t{};
+
+    for (int r = league_rank_begin; r < league_rank_end;) {
+      functor(t, Member(data, r, league_size), update);
+
+      if (++r < league_rank_end) {
+        // Don't allow team members to lap one another
+        // so that they don't overwrite shared memory.
+        if (data.team_rendezvous()) {
+          data.team_rendezvous_release();
+        }
+      }
+    }
+  }
+
+ public:
+  inline void execute() const {
+    enum { is_dynamic = std::is_same<SchedTag, Kokkos::Dynamic>::value };
+
+    const ReducerType& reducer = m_functor_reducer.get_reducer();
+
+    if (m_policy.league_size() == 0 || m_policy.team_size() == 0) {
+      if (m_result_ptr) {
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
+      }
+      return;
+    }
+
+    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);
+    const size_t thread_local_size = 0;  // Never shrinks
+
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+    m_instance->resize_thread_data(pool_reduce_size, team_reduce_size,
+                                   team_shared_size, thread_local_size);
+
+    if (execute_in_serial(m_policy.space())) {
+      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       = 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_reducer.get_functor(), data, update, league_rank_begin,
+          league_rank_end, m_policy.league_size());
+
+      reducer.final(ptr);
+
+      return;
+    }
+
+    const int pool_size = m_instance->thread_pool_size();
+#pragma omp parallel num_threads(pool_size)
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+
+      const int active = data.organize_team(m_policy.team_size());
+
+      if (active) {
+        data.set_work_partition(
+            m_policy.league_size(),
+            (0 < m_policy.chunk_size() ? m_policy.chunk_size()
+                                       : m_policy.team_iter()));
+      }
+
+      if (is_dynamic) {
+        // Must synchronize to make sure each team has set its
+        // partition before beginning the work stealing loop.
+        if (data.pool_rendezvous()) data.pool_rendezvous_release();
+      }
+
+      if (active) {
+        reference_type update = reducer.init(
+            reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+
+        std::pair<int64_t, int64_t> range(0, 0);
+
+        do {
+          range = is_dynamic ? data.get_work_stealing_chunk()
+                             : data.get_work_partition();
+
+          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 {
+        reducer.init(reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+      }
+
+      data.disband_team();
+
+      //  This thread has updated 'pool_reduce_local()' with its
+      //  contributions to the reduction.  The parallel region is
+      //  about to terminate and the master thread will load and
+      //  reduce each 'pool_reduce_local()' contribution.
+      //  Must 'memory_fence()' to guarantee that storing the update to
+      //  'pool_reduce_local()' will complete before this thread
+      //  exits the parallel region.
+
+      memory_fence();
+    }
+
+    // Reduction:
+
+    const pointer_type ptr =
+        pointer_type(m_instance->get_thread_data(0)->pool_reduce_local());
+
+    for (int i = 1; i < pool_size; ++i) {
+      reducer.join(ptr,
+                   reinterpret_cast<pointer_type>(
+                       m_instance->get_thread_data(i)->pool_reduce_local()));
+    }
+
+    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];
+      }
+    }
+  }
+
+  //----------------------------------------
+
+  template <class ViewType>
+  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                        const Policy& arg_policy, const ViewType& arg_result)
+      : m_instance(nullptr),
+        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())) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::OpenMP reduce result must be a View accessible from "
+        "HostSpace");
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif /* KOKKOS_OPENMP_PARALLEL_REDUCE_HPP */
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Parallel_Scan.hpp b/core/src/OpenMP/Kokkos_OpenMP_Parallel_Scan.hpp
new file mode 100644
index 0000000000..b9ce25d3ee
--- /dev/null
+++ b/core/src/OpenMP/Kokkos_OpenMP_Parallel_Scan.hpp
@@ -0,0 +1,296 @@
+//@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_PARALLEL_SCAN_HPP
+#define KOKKOS_OPENMP_PARALLEL_SCAN_HPP
+
+#include <omp.h>
+#include <OpenMP/Kokkos_OpenMP_Instance.hpp>
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::OpenMP> {
+ private:
+  using Policy = Kokkos::RangePolicy<Traits...>;
+
+  using Analysis =
+      FunctorAnalysis<FunctorPatternInterface::SCAN, Policy, FunctorType, void>;
+
+  using WorkTag   = typename Policy::work_tag;
+  using WorkRange = typename Policy::WorkRange;
+  using Member    = typename Policy::member_type;
+
+  using pointer_type   = typename Analysis::pointer_type;
+  using reference_type = typename Analysis::reference_type;
+
+  OpenMPInternal* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+  template <class TagType>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType& functor, const Member ibeg, const Member iend,
+      reference_type update, const bool final) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork, update, final);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType& functor, const Member ibeg, const Member iend,
+      reference_type update, const bool final) {
+    const TagType t{};
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork, update, final);
+    }
+  }
+
+ public:
+  inline void execute() const {
+    const int value_count          = Analysis::value_count(m_functor);
+    const size_t pool_reduce_bytes = 2 * Analysis::value_size(m_functor);
+
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
+
+    if (execute_in_serial(m_policy.space())) {
+      typename Analysis::Reducer final_reducer(m_functor);
+
+      reference_type update = final_reducer.init(
+          pointer_type(m_instance->get_thread_data(0)->pool_reduce_local()));
+
+      ParallelScan::template exec_range<WorkTag>(m_functor, m_policy.begin(),
+                                                 m_policy.end(), update, true);
+
+      return;
+    }
+
+#pragma omp parallel num_threads(m_instance->thread_pool_size())
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+      typename Analysis::Reducer final_reducer(m_functor);
+
+      const WorkRange range(m_policy, omp_get_thread_num(),
+                            omp_get_num_threads());
+
+      reference_type update_sum = final_reducer.init(
+          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+
+      ParallelScan::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_sum, false);
+
+      if (data.pool_rendezvous()) {
+        pointer_type ptr_prev = nullptr;
+
+        const int n = omp_get_num_threads();
+
+        for (int i = 0; i < n; ++i) {
+          pointer_type ptr =
+              (pointer_type)data.pool_member(i)->pool_reduce_local();
+
+          if (i) {
+            for (int j = 0; j < value_count; ++j) {
+              ptr[j + value_count] = ptr_prev[j + value_count];
+            }
+            final_reducer.join(ptr + value_count, ptr_prev);
+          } else {
+            final_reducer.init(ptr + value_count);
+          }
+
+          ptr_prev = ptr;
+        }
+
+        data.pool_rendezvous_release();
+      }
+
+      reference_type update_base = final_reducer.reference(
+          reinterpret_cast<pointer_type>(data.pool_reduce_local()) +
+          value_count);
+
+      ParallelScan::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_base, true);
+    }
+  }
+
+  //----------------------------------------
+
+  inline ParallelScan(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_instance(nullptr), m_functor(arg_functor), m_policy(arg_policy) {
+    m_instance = arg_policy.space().impl_internal_space_instance();
+  }
+};
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+template <class FunctorType, class ReturnType, class... Traits>
+class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
+                            ReturnType, Kokkos::OpenMP> {
+ private:
+  using Policy = Kokkos::RangePolicy<Traits...>;
+
+  using Analysis = FunctorAnalysis<FunctorPatternInterface::SCAN, Policy,
+                                   FunctorType, ReturnType>;
+
+  using WorkTag   = typename Policy::work_tag;
+  using WorkRange = typename Policy::WorkRange;
+  using Member    = typename Policy::member_type;
+
+  using value_type     = typename Analysis::value_type;
+  using pointer_type   = typename Analysis::pointer_type;
+  using reference_type = typename Analysis::reference_type;
+
+  OpenMPInternal* m_instance;
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+
+  template <class TagType>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType& functor, const Member ibeg, const Member iend,
+      reference_type update, const bool final) {
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(iwork, update, final);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType& functor, const Member ibeg, const Member iend,
+      reference_type update, const bool final) {
+    const TagType t{};
+    for (Member iwork = ibeg; iwork < iend; ++iwork) {
+      functor(t, iwork, update, final);
+    }
+  }
+
+ public:
+  inline void execute() const {
+    const int value_count          = Analysis::value_count(m_functor);
+    const size_t pool_reduce_bytes = 2 * Analysis::value_size(m_functor);
+
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(m_instance->m_instance_mutex);
+
+    m_instance->resize_thread_data(pool_reduce_bytes, 0  // team_reduce_bytes
+                                   ,
+                                   0  // team_shared_bytes
+                                   ,
+                                   0  // thread_local_bytes
+    );
+
+    if (execute_in_serial(m_policy.space())) {
+      typename Analysis::Reducer final_reducer(m_functor);
+
+      reference_type update = final_reducer.init(
+          pointer_type(m_instance->get_thread_data(0)->pool_reduce_local()));
+
+      this->template exec_range<WorkTag>(m_functor, m_policy.begin(),
+                                         m_policy.end(), update, true);
+
+      *m_result_ptr = update;
+
+      return;
+    }
+
+#pragma omp parallel num_threads(m_instance->thread_pool_size())
+    {
+      HostThreadTeamData& data = *(m_instance->get_thread_data());
+      typename Analysis::Reducer final_reducer(m_functor);
+
+      const WorkRange range(m_policy, omp_get_thread_num(),
+                            omp_get_num_threads());
+      reference_type update_sum = final_reducer.init(
+          reinterpret_cast<pointer_type>(data.pool_reduce_local()));
+
+      ParallelScanWithTotal::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_sum, false);
+
+      if (data.pool_rendezvous()) {
+        pointer_type ptr_prev = nullptr;
+
+        const int n = omp_get_num_threads();
+
+        for (int i = 0; i < n; ++i) {
+          pointer_type ptr =
+              (pointer_type)data.pool_member(i)->pool_reduce_local();
+
+          if (i) {
+            for (int j = 0; j < value_count; ++j) {
+              ptr[j + value_count] = ptr_prev[j + value_count];
+            }
+            final_reducer.join(ptr + value_count, ptr_prev);
+          } else {
+            final_reducer.init(ptr + value_count);
+          }
+
+          ptr_prev = ptr;
+        }
+
+        data.pool_rendezvous_release();
+      }
+
+      reference_type update_base = final_reducer.reference(
+          reinterpret_cast<pointer_type>(data.pool_reduce_local()) +
+          value_count);
+
+      ParallelScanWithTotal::template exec_range<WorkTag>(
+          m_functor, range.begin(), range.end(), update_base, true);
+
+      if (omp_get_thread_num() == omp_get_num_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_instance(nullptr),
+        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::OpenMP parallel_scan result must be host-accessible!");
+    m_instance = arg_policy.space().impl_internal_space_instance();
+  }
+
+  //----------------------------------------
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif /* KOKKOS_OPENMP_PARALLEL_REDUCE_SCAN_HPP */
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Task.cpp b/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
index 3e67d8d625..54c1574d71 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Task.cpp
@@ -52,18 +52,7 @@ HostThreadTeamDataSingleton::HostThreadTeamDataSingleton()
       num_pool_reduce_bytes, num_team_reduce_bytes, num_team_shared_bytes,
       num_thread_local_bytes);
 
-  void* ptr = nullptr;
-  try {
-    ptr = space.allocate(alloc_bytes);
-  } catch (Kokkos::Experimental::RawMemoryAllocationFailure const& f) {
-    // For now, just rethrow the error message with a note
-    // Note that this could, in turn, trigger an out of memory exception,
-    // but it's pretty unlikely, so we won't worry about it for now.
-    // TODO reasonable error message when `std::string` causes OOM error
-    Kokkos::Impl::throw_runtime_exception(
-        std::string("Failure to allocate scratch memory:  ") +
-        f.get_error_message());
-  }
+  void* ptr = space.allocate("Kokkos::Impl::HostThreadTeamData", alloc_bytes);
 
   HostThreadTeamData::scratch_assign(
       ptr, alloc_bytes, num_pool_reduce_bytes, num_team_reduce_bytes,
diff --git a/core/src/OpenMP/Kokkos_OpenMP_Task.hpp b/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
index 669607392b..2877d940fa 100644
--- a/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
+++ b/core/src/OpenMP/Kokkos_OpenMP_Task.hpp
@@ -20,6 +20,7 @@
 #include <Kokkos_Macros.hpp>
 #if defined(KOKKOS_ENABLE_OPENMP) && defined(KOKKOS_ENABLE_TASKDAG)
 
+#include <Kokkos_Atomic.hpp>
 #include <Kokkos_TaskScheduler_fwd.hpp>
 
 #include <impl/Kokkos_HostThreadTeam.hpp>
@@ -72,7 +73,8 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::OpenMP, QueueType>> {
         execution_space().impl_internal_space_instance();
     const int pool_size = get_max_team_count(scheduler.get_execution_space());
 
-    instance->acquire_lock();
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(instance->m_instance_mutex);
 
     // TODO @tasking @new_feature DSH allow team sizes other than 1
     const int team_size = 1;                      // Threads per core
@@ -151,8 +153,6 @@ class TaskQueueSpecialization<SimpleTaskScheduler<Kokkos::OpenMP, QueueType>> {
       }
       self.disband_team();
     }  // end pragma omp parallel
-
-    instance->release_lock();
   }
 
   static uint32_t get_max_team_count(execution_space const& espace) {
@@ -237,7 +237,8 @@ class TaskQueueSpecializationConstrained<
         execution_space().impl_internal_space_instance();
     const int pool_size = instance->thread_pool_size();
 
-    instance->acquire_lock();
+    // Serialize kernels on the same execution space instance
+    std::lock_guard<std::mutex> lock(instance->m_instance_mutex);
 
     const int team_size = 1;       // Threads per core
     instance->resize_thread_data(0 /* global reduce buffer */
@@ -249,6 +250,7 @@ class TaskQueueSpecializationConstrained<
                                  0 /* thread local buffer */
     );
     assert(pool_size % team_size == 0);
+
     auto& queue = scheduler.queue();
     queue.initialize_team_queues(pool_size / team_size);
 
@@ -287,7 +289,9 @@ class TaskQueueSpecializationConstrained<
 
               // If 0 == m_ready_count then set task = 0
 
-              if (*((volatile int*)&team_queue.m_ready_count) > 0) {
+              if (desul::atomic_load(&team_queue.m_ready_count,
+                                     desul::MemoryOrderAcquire(),
+                                     desul::MemoryScopeDevice()) > 0) {
                 task = end;
                 // Attempt to acquire a task
                 // Loop by priority and then type
@@ -340,8 +344,6 @@ class TaskQueueSpecializationConstrained<
       }
       self.disband_team();
     }  // end pragma omp parallel
-
-    instance->release_lock();
   }
 
   template <typename TaskType>
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp
index adf972dd08..84c7b85f11 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget.hpp
@@ -65,7 +65,11 @@ class OpenMPTarget {
 
   using scratch_memory_space = ScratchMemorySpace<OpenMPTarget>;
 
-  inline static bool in_parallel() { return omp_in_parallel(); }
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED inline static bool in_parallel() {
+    return omp_in_parallel();
+  }
+#endif
 
   static void fence(const std::string& name =
                         "Kokkos::OpenMPTarget::fence: Unnamed Instance Fence");
@@ -142,7 +146,8 @@ struct DeviceTypeTraits<::Kokkos::Experimental::OpenMPTarget> {
 /*--------------------------------------------------------------------------*/
 
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
-#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_MDRange.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_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 81fbc56de0..635b0e0504 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.cpp
@@ -37,7 +37,6 @@
 #include <OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <Kokkos_Atomic.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -55,9 +54,11 @@ void* OpenMPTargetSpace::impl_allocate(
   static_assert(sizeof(void*) == sizeof(uintptr_t),
                 "Error sizeof(void*) != sizeof(uintptr_t)");
 
-  void* ptr;
+  void* ptr = omp_target_alloc(arg_alloc_size, omp_get_default_device());
 
-  ptr = omp_target_alloc(arg_alloc_size, omp_get_default_device());
+  if (!ptr) {
+    Kokkos::Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
+  }
 
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     const size_t reported_size =
@@ -110,79 +111,13 @@ void OpenMPTargetSpace::deallocate(const char* arg_label,
 }  // namespace Experimental
 }  // namespace Kokkos
 
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-#ifdef KOKKOS_ENABLE_DEBUG
-SharedAllocationRecord<void, void> SharedAllocationRecord<
-    Kokkos::Experimental::OpenMPTargetSpace, void>::s_root_record;
-#endif
-
-SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
-                       void>::~SharedAllocationRecord() {
-  auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     alloc_size, (alloc_size - sizeof(SharedAllocationHeader)));
-}
-
-SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
-        const std::string& arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace,
-                                  void>::s_root_record,
-#endif
-          Kokkos::Impl::checked_allocation_with_header(arg_space, arg_label,
-                                                       arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, arg_label);
-
-  // TODO DeepCopy
-  // DeepCopy
-  Kokkos::Impl::DeepCopy<Experimental::OpenMPTargetSpace, HostSpace>(
-      RecordBase::m_alloc_ptr, &header, sizeof(SharedAllocationHeader));
-  Kokkos::fence(
-      "SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, "
-      "void>::SharedAllocationRecord(): fence after copying header from "
-      "HostSpace");
-}
-
-//----------------------------------------------------------------------------
-
-}  // namespace Impl
-}  // namespace Kokkos
-
 //==============================================================================
 // <editor-fold desc="Explicit instantiations of CRTP Base classes"> {{{1
 
 #include <impl/Kokkos_SharedAlloc_timpl.hpp>
 
-namespace Kokkos {
-namespace Impl {
-
-// To avoid additional compilation cost for something that's (mostly?) not
-// performance sensitive, we explicity instantiate these CRTP base classes here,
-// where we have access to the associated *_timpl.hpp header files.
-template class HostInaccessibleSharedAllocationRecordCommon<
-    Kokkos::Experimental::OpenMPTargetSpace>;
-template class SharedAllocationRecordCommon<
-    Kokkos::Experimental::OpenMPTargetSpace>;
-
-}  // end namespace Impl
-}  // end namespace Kokkos
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::Experimental::OpenMPTargetSpace);
 
 // </editor-fold> end Explicit instantiations of CRTP Base classes }}}1
 //==============================================================================
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp
index e5b33d0982..ed625cfcc8 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTargetSpace.hpp
@@ -98,6 +98,16 @@ class OpenMPTargetSpace {
   ~OpenMPTargetSpace()                                   = default;
 
   /**\brief  Allocate untracked memory in the space */
+  // FIXME_OPENMPTARGET Use execution space instance
+  void* allocate(const OpenMPTarget&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  // FIXME_OPENMPTARGET Use execution space instance
+  void* allocate(const OpenMPTarget&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const size_t arg_alloc_size) const;
   void* allocate(const char* arg_label, const size_t arg_alloc_size,
                  const size_t arg_logical_size = 0) const;
@@ -121,9 +131,6 @@ class OpenMPTargetSpace {
                        const size_t arg_logical_size = 0,
                        const Kokkos::Tools::SpaceHandle =
                            Kokkos::Tools::make_space_handle(name())) const;
-
-  friend class Kokkos::Impl::SharedAllocationRecord<
-      Kokkos::Experimental::OpenMPTargetSpace, void>;
 };
 }  // namespace Experimental
 }  // namespace Kokkos
@@ -131,64 +138,8 @@ class OpenMPTargetSpace {
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
-namespace Kokkos {
-namespace Impl {
-
-template <>
-class SharedAllocationRecord<Kokkos::Experimental::OpenMPTargetSpace, void>
-    : public HostInaccessibleSharedAllocationRecordCommon<
-          Kokkos::Experimental::OpenMPTargetSpace> {
- private:
-  friend class HostInaccessibleSharedAllocationRecordCommon<
-      Kokkos::Experimental::OpenMPTargetSpace>;
-  friend class SharedAllocationRecordCommon<
-      Kokkos::Experimental::OpenMPTargetSpace>;
-  friend Kokkos::Experimental::OpenMPTargetSpace;
-
-  using base_t = HostInaccessibleSharedAllocationRecordCommon<
-      Kokkos::Experimental::OpenMPTargetSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-
-  /**\brief  Root record for tracked allocations from this OpenMPTargetSpace
-   * instance */
-  static RecordBase s_root_record;
-
-  const Kokkos::Experimental::OpenMPTargetSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &deallocate);
-
- public:
-  KOKKOS_INLINE_FUNCTION static SharedAllocationRecord* allocate(
-      const Kokkos::Experimental::OpenMPTargetSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc) {
-    KOKKOS_IF_ON_HOST(
-        (return new SharedAllocationRecord(arg_space, arg_label, arg_alloc);))
-    KOKKOS_IF_ON_DEVICE(
-        ((void)arg_space; (void)arg_label; (void)arg_alloc; return nullptr;))
-  }
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::Experimental::OpenMPTargetSpace);
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
index f794f2fc52..6c5eb048e3 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Exec.cpp
@@ -67,16 +67,13 @@ 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;
-uint64_t OpenMPTargetExec::m_lock_size        = 0;
 uint32_t* OpenMPTargetExec::m_uniquetoken_ptr = nullptr;
 int OpenMPTargetExec::MAX_ACTIVE_THREADS      = 0;
+std::mutex OpenMPTargetExec::m_mutex_scratch_ptr;
 
 void OpenMPTargetExec::clear_scratch() {
   Kokkos::Experimental::OpenMPTargetSpace space;
@@ -85,21 +82,17 @@ void OpenMPTargetExec::clear_scratch() {
   m_scratch_size = 0;
 }
 
-void OpenMPTargetExec::clear_lock_array() {
-  if (m_lock_array != nullptr) {
-    Kokkos::Experimental::OpenMPTargetSpace space;
-    space.deallocate(m_lock_array, m_lock_size);
-    m_lock_array = nullptr;
-    m_lock_size  = 0;
-  }
-}
-
 void* OpenMPTargetExec::get_scratch_ptr() { return m_scratch_ptr; }
 
 void OpenMPTargetExec::resize_scratch(int64_t team_size, int64_t shmem_size_L0,
                                       int64_t shmem_size_L1,
                                       int64_t league_size) {
   Kokkos::Experimental::OpenMPTargetSpace space;
+  // Level-0 scratch when using clang/17 and higher comes from their OpenMP
+  // extension, `ompx_dyn_cgroup_mem`.
+#if defined(KOKKOS_IMPL_OPENMPTARGET_LLVM_EXTENSIONS)
+  shmem_size_L0 = 0;
+#endif
   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.
@@ -131,34 +124,6 @@ void OpenMPTargetExec::resize_scratch(int64_t team_size, int64_t shmem_size_L0,
   }
 }
 
-int* OpenMPTargetExec::get_lock_array(int num_teams) {
-  Kokkos::Experimental::OpenMPTargetSpace space;
-  int max_active_league_size = MAX_ACTIVE_THREADS / 32;
-  int lock_array_elem =
-      (num_teams > max_active_league_size) ? num_teams : max_active_league_size;
-  if (m_lock_size < (lock_array_elem * sizeof(int))) {
-    space.deallocate(m_lock_array, m_lock_size);
-    m_lock_size  = lock_array_elem * sizeof(int);
-    m_lock_array = static_cast<int*>(space.allocate(m_lock_size));
-
-    // FIXME_OPENMPTARGET - Creating a target region here to initialize the
-    // lock_array with 0's fails. Hence creating an equivalent host array to
-    // achieve the same. Value of host array are then copied to the lock_array.
-    int* h_lock_array = static_cast<int*>(
-        omp_target_alloc(m_lock_size, omp_get_initial_device()));
-
-    for (int i = 0; i < lock_array_elem; ++i) h_lock_array[i] = 0;
-
-    KOKKOS_IMPL_OMPT_SAFE_CALL(
-        omp_target_memcpy(m_lock_array, h_lock_array, m_lock_size, 0, 0,
-                          omp_get_default_device(), omp_get_initial_device()));
-
-    omp_target_free(h_lock_array, omp_get_initial_device());
-  }
-
-  return m_lock_array;
-}
-
 }  // namespace Impl
 }  // namespace Kokkos
 
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp
index 0846d570ae..44e9119ea8 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Instance.cpp
@@ -106,15 +106,17 @@ void OpenMPTargetInternal::print_configuration(std::ostream& os,
 void OpenMPTargetInternal::impl_finalize() {
   m_is_initialized = false;
   Kokkos::Impl::OpenMPTargetExec space;
-  if (space.m_lock_array != nullptr) space.clear_lock_array();
 
   if (space.m_uniquetoken_ptr != nullptr)
     Kokkos::kokkos_free<Kokkos::Experimental::OpenMPTargetSpace>(
         space.m_uniquetoken_ptr);
 }
+
 void OpenMPTargetInternal::impl_initialize() {
   m_is_initialized = true;
 
+  Kokkos::Impl::OpenMPTargetExec::MAX_ACTIVE_THREADS = concurrency();
+
   // FIXME_OPENMPTARGET:  Only fix the number of teams for NVIDIA architectures
   // from Pascal and upwards.
   // FIXME_OPENMPTARGTE: Cray compiler did not yet implement omp_set_num_teams.
@@ -175,8 +177,10 @@ void OpenMPTarget::impl_static_fence(const std::string& name) {
 }
 
 void OpenMPTarget::impl_initialize(InitializationSettings const& settings) {
+  using Kokkos::Impl::get_visible_devices;
+  std::vector<int> const& visible_devices = get_visible_devices();
   using Kokkos::Impl::get_gpu;
-  const int device_num = get_gpu(settings);
+  const int device_num = get_gpu(settings).value_or(visible_devices[0]);
   omp_set_default_device(device_num);
 
   Impl::OpenMPTargetInternal::impl_singleton()->impl_initialize();
@@ -212,9 +216,10 @@ UniqueToken<Kokkos::Experimental::OpenMPTarget,
         Kokkos::kokkos_malloc<Kokkos::Experimental::OpenMPTargetSpace>(
             "Kokkos::OpenMPTarget::m_uniquetoken_ptr", size));
     std::vector<uint32_t> h_buf(count, 0);
-    KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(ptr, h_buf.data(), size, 0, 0,
-                                                 omp_get_default_device(),
-                                                 omp_get_initial_device()));
+    if (0 < size)
+      KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(ptr, h_buf.data(), size, 0,
+                                                   0, omp_get_default_device(),
+                                                   omp_get_initial_device()));
 
     Kokkos::Impl::OpenMPTargetExec::m_uniquetoken_ptr = ptr;
   }
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_MDRangePolicy.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_MDRangePolicy.hpp
index d718f56d38..e353676b61 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_MDRangePolicy.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_MDRangePolicy.hpp
@@ -22,6 +22,10 @@
 namespace Kokkos {
 namespace Impl {
 
+using OpenMPTargetIterateLeft = std::integral_constant<Iterate, Iterate::Left>;
+using OpenMPTargetIterateRight =
+    std::integral_constant<Iterate, Iterate::Right>;
+
 template <typename Rank,
           ::Kokkos::Impl::TeamMDRangeThreadAndVector ThreadAndVector>
 struct ThreadAndVectorNestLevel<Rank, Kokkos::Experimental::OpenMPTarget,
@@ -30,4 +34,5 @@ struct ThreadAndVectorNestLevel<Rank, Kokkos::Experimental::OpenMPTarget,
 
 }  // namespace Impl
 }  // namespace Kokkos
+
 #endif
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Macros.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Macros.hpp
new file mode 100644
index 0000000000..2bd672f4d0
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Macros.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_OPENMPTARGET_MACROS_HPP
+#define KOKKOS_OPENMPTARGET_MACROS_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
+
+// Define a macro for llvm compiler greater than version 17 and on NVIDIA and
+// AMD GPUs. This would be useful in cases where non-OpenMP standard llvm
+// extensions can be used.
+#if defined(KOKKOS_COMPILER_CLANG) && (KOKKOS_COMPILER_CLANG >= 1700) && \
+    (defined(KOKKOS_ARCH_AMD_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU))
+#define KOKKOS_IMPL_OPENMPTARGET_LLVM_EXTENSIONS
+#endif
+
+#define KOKKOS_IMPL_OPENMPTARGET_PRAGMA_HELPER(x) _Pragma(#x)
+#define KOKKOS_IMPL_OMPTARGET_PRAGMA(x) \
+  KOKKOS_IMPL_OPENMPTARGET_PRAGMA_HELPER(omp target x)
+
+// Use scratch memory extensions to request dynamic shared memory for the
+// right compiler/architecture combination.
+#ifdef KOKKOS_IMPL_OPENMPTARGET_LLVM_EXTENSIONS
+#define KOKKOS_IMPL_OMPX_DYN_CGROUP_MEM(N) ompx_dyn_cgroup_mem(N)
+#else
+#define KOKKOS_IMPL_OMPX_DYN_CGROUP_MEM(N)
+#endif
+
+#endif  // KOKKOS_OPENMPTARGET_MACROS_HPP
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
index 9767d8e53e..e222d65250 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp
@@ -21,16 +21,10 @@
 #include <sstream>
 #include <Kokkos_Parallel.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
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Macros.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -113,14 +107,20 @@ class OpenMPTargetExecTeamMember {
     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 {
+  template <typename ReducerType>
+  KOKKOS_INLINE_FUNCTION std::enable_if_t<is_reducer<ReducerType>::value>
+  team_reduce(ReducerType const& reducer) const noexcept {
+    team_reduce(reducer, reducer.reference());
+  }
+
+  // FIXME_OPENMPTARGET this function currently ignores the reducer passed.
+  template <typename ReducerType>
+  KOKKOS_INLINE_FUNCTION std::enable_if_t<is_reducer<ReducerType>::value>
+  team_reduce(ReducerType const&, typename ReducerType::value_type& value) const
+      noexcept {
 #pragma omp barrier
 
-    using value_type = ValueType;
+    using value_type = typename ReducerType::value_type;
     //    const JoinLambdaAdapter<value_type, JoinOp> op(op_in);
 
     // Make sure there is enough scratch space:
@@ -149,8 +149,9 @@ class OpenMPTargetExecTeamMember {
       }
 #pragma omp barrier
     }
-    return team_scratch[0];
+    value = team_scratch[0];
   }
+
   /** \brief  Intra-team exclusive prefix sum with team_rank() ordering
    *          with intra-team non-deterministic ordering accumulation.
    *
@@ -249,15 +250,37 @@ class OpenMPTargetExecTeamMember {
     // 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.
+    //
+    // Use llvm extensions for dynamic shared memory with compilers/architecture
+    // combinations where it is supported.
+    //
+    // Size allocated in HBM will now change based on whether we use llvm
+    // extensions.
+#if defined(KOKKOS_IMPL_OPENMPTARGET_LLVM_EXTENSIONS)
+    const int total_shmem = shmem_size_L1 + shmem_size_L1 * 0.1;
+#else
+    const int total_shmem =
+        shmem_size_L0 + shmem_size_L1 + (shmem_size_L0 + shmem_size_L1) * 0.1;
+#endif
+
+    // Per team offset for buffer in HBM.
     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);
+        m_shmem_block_index * (total_shmem + TEAM_REDUCE_SIZE);
+
+#if defined(KOKKOS_IMPL_OPENMPTARGET_LLVM_EXTENSIONS)
+    const int l1_offset = reduce_offset + TEAM_REDUCE_SIZE;
+    char* l0_scratch =
+        static_cast<char*>(llvm_omp_target_dynamic_shared_alloc());
+    m_team_shared = scratch_memory_space(
+        l0_scratch, shmem_size_L0, static_cast<char*>(glb_scratch) + l1_offset,
+        shmem_size_L1);
+#else
     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);
+#endif
     m_reduce_scratch = static_cast<char*>(glb_scratch) + reduce_offset;
     m_league_rank    = league_rank;
     m_team_rank      = omp_tid;
@@ -742,18 +765,15 @@ class OpenMPTargetExec {
   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 std::mutex m_mutex_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;
 };
 
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_MDRange.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_MDRange.hpp
new file mode 100644
index 0000000000..bd7d3eef5d
--- /dev/null
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_MDRange.hpp
@@ -0,0 +1,383 @@
+//@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_PARALLELFOR_MDRANGE_HPP
+#define KOKKOS_OPENMPTARGET_PARALLELFOR_MDRANGE_HPP
+
+#include <omp.h>
+#include <Kokkos_Parallel.hpp>
+#include "Kokkos_OpenMPTarget_MDRangePolicy.hpp"
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::Experimental::OpenMPTarget> {
+ private:
+  using Policy  = Kokkos::MDRangePolicy<Traits...>;
+  using WorkTag = typename Policy::work_tag;
+  using Member  = typename Policy::member_type;
+  using Index   = typename Policy::index_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+ public:
+  inline void execute() const {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget parallel_for");
+    FunctorType functor(m_functor);
+    Policy policy = m_policy;
+
+    typename Policy::point_type unused;
+    static_assert(1 < Policy::rank && Policy::rank < 7);
+    static_assert(Policy::inner_direction == Iterate::Left ||
+                  Policy::inner_direction == Iterate::Right);
+
+    execute_tile<Policy::rank>(
+        unused, functor, policy,
+        std::integral_constant<Iterate, Policy::inner_direction>());
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 2> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateRight) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+
+#pragma omp target teams distribute parallel for collapse(2) map(to : functor)
+    for (auto i0 = begin_0; i0 < end_0; ++i0)
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        if constexpr (std::is_void<typename Policy::work_tag>::value)
+          functor(i0, i1);
+        else
+          functor(typename Policy::work_tag(), i0, i1);
+      }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 3> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateRight) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+
+#pragma omp target teams distribute parallel for collapse(3) map(to : functor)
+    for (auto i0 = begin_0; i0 < end_0; ++i0) {
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+          if constexpr (std::is_void<typename Policy::work_tag>::value)
+            functor(i0, i1, i2);
+          else
+            functor(typename Policy::work_tag(), i0, i1, i2);
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 4> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateRight) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+    const Index begin_3 = policy.m_lower[3];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+    const Index end_3 = policy.m_upper[3];
+
+#pragma omp target teams distribute parallel for collapse(4) map(to : functor)
+    for (auto i0 = begin_0; i0 < end_0; ++i0) {
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+          for (auto i3 = begin_3; i3 < end_3; ++i3) {
+            if constexpr (std::is_void<typename Policy::work_tag>::value)
+              functor(i0, i1, i2, i3);
+            else
+              functor(typename Policy::work_tag(), i0, i1, i2, i3);
+          }
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 5> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateRight) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+    const Index begin_3 = policy.m_lower[3];
+    const Index begin_4 = policy.m_lower[4];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+    const Index end_3 = policy.m_upper[3];
+    const Index end_4 = policy.m_upper[4];
+
+#pragma omp target teams distribute parallel for collapse(5) map(to : functor)
+    for (auto i0 = begin_0; i0 < end_0; ++i0) {
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+          for (auto i3 = begin_3; i3 < end_3; ++i3) {
+            for (auto i4 = begin_4; i4 < end_4; ++i4) {
+              if constexpr (std::is_same<typename Policy::work_tag,
+                                         void>::value)
+                functor(i0, i1, i2, i3, i4);
+              else
+                functor(typename Policy::work_tag(), i0, i1, i2, i3, i4);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 6> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateRight) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+    const Index begin_3 = policy.m_lower[3];
+    const Index begin_4 = policy.m_lower[4];
+    const Index begin_5 = policy.m_lower[5];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+    const Index end_3 = policy.m_upper[3];
+    const Index end_4 = policy.m_upper[4];
+    const Index end_5 = policy.m_upper[5];
+
+#pragma omp target teams distribute parallel for collapse(6) map(to : functor)
+    for (auto i0 = begin_0; i0 < end_0; ++i0) {
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+          for (auto i3 = begin_3; i3 < end_3; ++i3) {
+            for (auto i4 = begin_4; i4 < end_4; ++i4) {
+              for (auto i5 = begin_5; i5 < end_5; ++i5) {
+                {
+                  if constexpr (std::is_same<typename Policy::work_tag,
+                                             void>::value)
+                    functor(i0, i1, i2, i3, i4, i5);
+                  else
+                    functor(typename Policy::work_tag(), i0, i1, i2, i3, i4,
+                            i5);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 2> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateLeft) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+
+#pragma omp target teams distribute parallel for collapse(2) map(to : functor)
+    for (auto i1 = begin_1; i1 < end_1; ++i1)
+      for (auto i0 = begin_0; i0 < end_0; ++i0) {
+        if constexpr (std::is_void<typename Policy::work_tag>::value)
+          functor(i0, i1);
+        else
+          functor(typename Policy::work_tag(), i0, i1);
+      }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 3> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateLeft) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+
+#pragma omp target teams distribute parallel for collapse(3) map(to : functor)
+    for (auto i2 = begin_2; i2 < end_2; ++i2) {
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        for (auto i0 = begin_0; i0 < end_0; ++i0) {
+          if constexpr (std::is_void<typename Policy::work_tag>::value)
+            functor(i0, i1, i2);
+          else
+            functor(typename Policy::work_tag(), i0, i1, i2);
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 4> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateLeft) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+    const Index begin_3 = policy.m_lower[3];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+    const Index end_3 = policy.m_upper[3];
+
+#pragma omp target teams distribute parallel for collapse(4) map(to : functor)
+    for (auto i3 = begin_3; i3 < end_3; ++i3) {
+      for (auto i2 = begin_2; i2 < end_2; ++i2) {
+        for (auto i1 = begin_1; i1 < end_1; ++i1) {
+          for (auto i0 = begin_0; i0 < end_0; ++i0) {
+            if constexpr (std::is_void<typename Policy::work_tag>::value)
+              functor(i0, i1, i2, i3);
+            else
+              functor(typename Policy::work_tag(), i0, i1, i2, i3);
+          }
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 5> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateLeft) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+    const Index begin_3 = policy.m_lower[3];
+    const Index begin_4 = policy.m_lower[4];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+    const Index end_3 = policy.m_upper[3];
+    const Index end_4 = policy.m_upper[4];
+
+#pragma omp target teams distribute parallel for collapse(5) map(to : functor)
+    for (auto i4 = begin_4; i4 < end_4; ++i4) {
+      for (auto i3 = begin_3; i3 < end_3; ++i3) {
+        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+          for (auto i1 = begin_1; i1 < end_1; ++i1) {
+            for (auto i0 = begin_0; i0 < end_0; ++i0) {
+              if constexpr (std::is_same<typename Policy::work_tag,
+                                         void>::value)
+                functor(i0, i1, i2, i3, i4);
+              else
+                functor(typename Policy::work_tag(), i0, i1, i2, i3, i4);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  template <int Rank>
+  inline std::enable_if_t<Rank == 6> execute_tile(
+      typename Policy::point_type offset, const FunctorType& functor,
+      const Policy& policy, OpenMPTargetIterateLeft) const {
+    (void)offset;
+    const Index begin_0 = policy.m_lower[0];
+    const Index begin_1 = policy.m_lower[1];
+    const Index begin_2 = policy.m_lower[2];
+    const Index begin_3 = policy.m_lower[3];
+    const Index begin_4 = policy.m_lower[4];
+    const Index begin_5 = policy.m_lower[5];
+
+    const Index end_0 = policy.m_upper[0];
+    const Index end_1 = policy.m_upper[1];
+    const Index end_2 = policy.m_upper[2];
+    const Index end_3 = policy.m_upper[3];
+    const Index end_4 = policy.m_upper[4];
+    const Index end_5 = policy.m_upper[5];
+
+#pragma omp target teams distribute parallel for collapse(6) map(to : functor)
+    for (auto i5 = begin_5; i5 < end_5; ++i5) {
+      for (auto i4 = begin_4; i4 < end_4; ++i4) {
+        for (auto i3 = begin_3; i3 < end_3; ++i3) {
+          for (auto i2 = begin_2; i2 < end_2; ++i2) {
+            for (auto i1 = begin_1; i1 < end_1; ++i1) {
+              for (auto i0 = begin_0; i0 < end_0; ++i0) {
+                {
+                  if constexpr (std::is_same<typename Policy::work_tag,
+                                             void>::value)
+                    functor(i0, i1, i2, i3, i4, i5);
+                  else
+                    functor(typename Policy::work_tag(), i0, i1, i2, i3, i4,
+                            i5);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  inline ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+  // TODO DZP: based on a conversation with Christian, we're using 256 as a
+  // heuristic here. We need something better once we can query these kinds of
+  // properties
+  template <typename Policy, typename Functor>
+  static int max_tile_size_product(const Policy&, const Functor&) {
+    return 256;
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif /* KOKKOS_OPENMPTARGET_PARALLELFOR_MDRANGE_HPP */
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp
index 1abc925cae..26085f1140 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelFor_Team.hpp
@@ -19,6 +19,7 @@
 
 #include <omp.h>
 #include <sstream>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Macros.hpp>
 #include <Kokkos_Parallel.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
 
@@ -140,8 +141,10 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
 // 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)
+    KOKKOS_IMPL_OMPTARGET_PRAGMA(
+        teams thread_limit(team_size) firstprivate(a_functor)
+            num_teams(max_active_teams) is_device_ptr(scratch_ptr)
+                KOKKOS_IMPL_OMPX_DYN_CGROUP_MEM(shmem_size_L0))
 #pragma omp parallel
     {
       if (omp_get_num_teams() > max_active_teams)
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_MDRange.hpp
similarity index 62%
rename from core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp
rename to core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_MDRange.hpp
index 41e62ce6e6..e86a121974 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_MDRange.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_MDRange.hpp
@@ -14,128 +14,120 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_OPENMPTARGET_PARALLEL_MDRANGE_HPP
-#define KOKKOS_OPENMPTARGET_PARALLEL_MDRANGE_HPP
+#ifndef KOKKOS_OPENMPTARGET_PARALLELREDUCE_MDRANGE_HPP
+#define KOKKOS_OPENMPTARGET_PARALLELREDUCE_MDRANGE_HPP
 
 #include <omp.h>
 #include <Kokkos_Parallel.hpp>
-#include <OpenMPTarget/Kokkos_OpenMPTarget_Parallel.hpp>
+#include "Kokkos_OpenMPTarget_MDRangePolicy.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
-// with arrays of long in it. Arrays of int might be fine though ...
-#define KOKKOS_IMPL_MDRANGE_USE_NO_TILES  // undef EOF
-
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
-                  Kokkos::Experimental::OpenMPTarget> {
+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;
 
-  const FunctorType m_functor;
+  using pointer_type   = typename ReducerType::pointer_type;
+  using reference_type = typename ReducerType::reference_type;
+
+  static constexpr bool UseReducer =
+      !std::is_same_v<FunctorType, typename ReducerType::functor_type>;
+
+  const pointer_type m_result_ptr;
+  const CombinedFunctorReducerType m_functor_reducer;
   const Policy m_policy;
 
+  using ParReduceCopy = ParallelReduceCopy<pointer_type>;
+
+  bool m_result_ptr_on_device;
+
  public:
   inline void execute() const {
-    OpenMPTargetExec::verify_is_process(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
-    FunctorType functor(m_functor);
-    Policy policy = m_policy;
-
-#ifdef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-    typename Policy::point_type unused;
-
-    execute_tile<Policy::rank>(unused, functor, policy);
-#else
-    const int64_t begin = 0;
-    const int64_t end   = m_policy.m_num_tiles;
-
-#pragma omp target teams distribute map(to : functor) num_teams(end - begin)
-    {
-      for (ptrdiff_t tile_idx = begin; tile_idx < end; ++tile_idx) {
-
-#pragma omp parallel
-        {
-          typename Policy::point_type offset;
-          if (Policy::outer_direction == Policy::Left) {
-            for (int i = 0; i < Policy::rank; ++i) {
-              offset[i] = (tile_idx % policy.m_tile_end[i]) * policy.m_tile[i] +
-                          policy.m_lower[i];
-              tile_idx /= policy.m_tile_end[i];
-            }
-          } else {
-            for (int i = Policy::rank - 1; i >= 0; --i) {
-              offset[i] = (tile_idx % policy.m_tile_end[i]) * policy.m_tile[i] +
-                          policy.m_lower[i];
-              tile_idx /= policy.m_tile_end[i];
-            }
-          }
-          execute_tile<Policy::rank>(offset, functor, policy);
-        }
-      }
-    }
-#endif
+    // Only let one ParallelReduce instance at a time use the scratch memory.
+    std::scoped_lock<std::mutex> scratch_memory_lock(
+        OpenMPTargetExec::m_mutex_scratch_ptr);
+    execute_tile<Policy::rank, typename ReducerType::value_type>(
+        m_functor_reducer.get_functor(), m_policy, m_result_ptr,
+        std::integral_constant<Iterate, Policy::inner_direction>());
   }
 
-  template <int Rank>
+  template <class ViewType>
+  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
+                        Policy arg_policy, const ViewType& arg_result_view)
+      : m_result_ptr(arg_result_view.data()),
+        m_functor_reducer(arg_functor_reducer),
+        m_policy(arg_policy),
+        m_result_ptr_on_device(
+            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
+                              typename ViewType::memory_space>::accessible) {}
+
+  template <int Rank, class ValueType>
   inline std::enable_if_t<Rank == 2> execute_tile(
-      typename Policy::point_type offset, const FunctorType& functor,
-      const Policy& policy) const {
-#ifdef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-    (void)offset;
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateLeft) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
 
     const Index end_0 = policy.m_upper[0];
     const Index end_1 = policy.m_upper[1];
 
-#pragma omp target teams distribute parallel for collapse(2) map(to : functor)
-    for (auto i0 = begin_0; i0 < end_0; ++i0) {
+    ValueType result = ValueType();
+
+    // 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 target teams distribute parallel for collapse(2) map(to         \
+                                                                 : functor) \
+    reduction(custom                                                        \
+              : result)
       for (auto i1 = begin_1; i1 < end_1; ++i1) {
-        if constexpr (std::is_void<typename Policy::work_tag>::value)
-          functor(i0, i1);
-        else
-          functor(typename Policy::work_tag(), i0, i1);
+        for (auto i0 = begin_0; i0 < end_0; ++i0) {
+          if constexpr (std::is_void<typename Policy::work_tag>::value)
+            functor(i0, i1, result);
+          else
+            functor(typename Policy::work_tag(), i0, i1, result);
+        }
       }
-    }
-#else
-    const ptrdiff_t begin_0 = offset[0];
-    ptrdiff_t end_0         = begin_0 + policy.m_tile[0];
-    end_0 = end_0 < policy.m_upper[0] ? end_0 : policy.m_upper[0];
-
-    const ptrdiff_t begin_1 = offset[1];
-    ptrdiff_t end_1         = begin_1 + policy.m_tile[1];
-    end_1 = end_1 < policy.m_upper[1] ? end_1 : policy.m_upper[1];
-
-#pragma omp for collapse(2)
-    for (ptrdiff_t i0 = begin_0; i0 < end_0; ++i0)
-      for (ptrdiff_t i1 = begin_1; i1 < end_1; ++i1) {
-        if constexpr (std::is_void<typename Policy::work_tag>::value)
-          functor(i0, i1);
-        else
-          functor(typename Policy::work_tag(), i0, i1);
+    } else {
+#pragma omp target teams distribute parallel for collapse(2) map(to : functor) \
+reduction(+:result)
+      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+        for (auto i0 = begin_0; i0 < end_0; ++i0) {
+          if constexpr (std::is_void<typename Policy::work_tag>::value)
+            functor(i0, i1, result);
+          else
+            functor(typename Policy::work_tag(), i0, i1, result);
+        }
       }
-#endif
+    }
+
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
-  template <int Rank>
+  template <int Rank, class ValueType>
   inline std::enable_if_t<Rank == 3> execute_tile(
-      typename Policy::point_type offset, const FunctorType& functor,
-      const Policy& policy) const {
-#ifdef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-    (void)offset;
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateLeft) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[2];
@@ -144,107 +136,119 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
     const Index end_1 = policy.m_upper[1];
     const Index end_2 = policy.m_upper[2];
 
-#pragma omp target teams distribute parallel for collapse(3) map(to : functor)
-    for (auto i0 = begin_0; i0 < end_0; ++i0) {
-      for (auto i1 = begin_1; i1 < end_1; ++i1) {
-        for (auto i2 = begin_2; i2 < end_2; ++i2) {
-          if constexpr (std::is_void<typename Policy::work_tag>::value)
-            functor(i0, i1, i2);
-          else
-            functor(typename Policy::work_tag(), i0, i1, i2);
+    ValueType result = ValueType();
+
+    // 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 <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) \
+    reduction(custom                                                        \
+              : result)
+      for (auto i2 = begin_2; i2 < end_2; ++i2) {
+        for (auto i1 = begin_1; i1 < end_1; ++i1) {
+          for (auto i0 = begin_0; i0 < end_0; ++i0) {
+            if constexpr (std::is_void<typename Policy::work_tag>::value)
+              functor(i0, i1, i2, result);
+            else
+              functor(typename Policy::work_tag(), i0, i1, i2, result);
+          }
         }
       }
-    }
-#else
-    const ptrdiff_t begin_0 = offset[0];
-    ptrdiff_t end_0         = begin_0 + policy.m_tile[0];
-    end_0 = end_0 < policy.m_upper[0] ? end_0 : policy.m_upper[0];
-
-    const ptrdiff_t begin_1 = offset[1];
-    ptrdiff_t end_1         = begin_1 + policy.m_tile[1];
-    end_1 = end_1 < policy.m_upper[1] ? end_1 : policy.m_upper[1];
-
-    const ptrdiff_t begin_2 = offset[2];
-    ptrdiff_t end_2         = begin_2 + policy.m_tile[2];
-    end_2 = end_2 < policy.m_upper[2] ? end_2 : policy.m_upper[2];
-
-#pragma omp for collapse(3)
-    for (ptrdiff_t i0 = begin_0; i0 < end_0; ++i0)
-      for (ptrdiff_t i1 = begin_1; i1 < end_1; ++i1)
-        for (ptrdiff_t i2 = begin_2; i2 < end_2; ++i2) {
-          if constexpr (std::is_void<typename Policy::work_tag>::value)
-            functor(i0, i1, i2);
-          else
-            functor(typename Policy::work_tag(), i0, i1, i2);
+    } else {
+#pragma omp target teams distribute parallel for collapse(3) map(to : functor) \
+reduction(+:result)
+      for (auto i2 = begin_2; i2 < end_2; ++i2) {
+        for (auto i1 = begin_1; i1 < end_1; ++i1) {
+          for (auto i0 = begin_0; i0 < end_0; ++i0) {
+            if constexpr (std::is_void<typename Policy::work_tag>::value)
+              functor(i0, i1, i2, result);
+            else
+              functor(typename Policy::work_tag(), i0, i1, i2, result);
+          }
         }
-#endif
+      }
+    }
+
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
-  template <int Rank>
+  template <int Rank, class ValueType>
   inline std::enable_if_t<Rank == 4> execute_tile(
-      typename Policy::point_type offset, const FunctorType& functor,
-      const Policy& policy) const {
-#ifdef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-    (void)offset;
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateLeft) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
-    const Index begin_2 = policy.m_lower[2];
-    const Index begin_3 = policy.m_lower[3];
+    const Index begin_2 = policy.m_lower[3];
+    const Index begin_3 = policy.m_lower[2];
 
     const Index end_0 = policy.m_upper[0];
     const Index end_1 = policy.m_upper[1];
     const Index end_2 = policy.m_upper[2];
     const Index end_3 = policy.m_upper[3];
 
-#pragma omp target teams distribute parallel for collapse(4) map(to : functor)
-    for (auto i0 = begin_0; i0 < end_0; ++i0) {
-      for (auto i1 = begin_1; i1 < end_1; ++i1) {
+    ValueType result = ValueType();
+
+    // 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 target teams distribute parallel for collapse(4) map(to         \
+                                                                 : functor) \
+    reduction(custom                                                        \
+              : result)
+      for (auto i3 = begin_3; i3 < end_3; ++i3) {
         for (auto i2 = begin_2; i2 < end_2; ++i2) {
-          for (auto i3 = begin_3; i3 < end_3; ++i3) {
-            if constexpr (std::is_void<typename Policy::work_tag>::value)
-              functor(i0, i1, i2, i3);
-            else
-              functor(typename Policy::work_tag(), i0, i1, i2, i3);
+          for (auto i1 = begin_1; i1 < end_1; ++i1) {
+            for (auto i0 = begin_0; i0 < end_0; ++i0) {
+              if constexpr (std::is_same<typename Policy::work_tag,
+                                         void>::value)
+                functor(i0, i1, i2, i3, result);
+              else
+                functor(typename Policy::work_tag(), i0, i1, i2, i3, result);
+            }
           }
         }
       }
-    }
-#else
-    const ptrdiff_t begin_0 = offset[0];
-    ptrdiff_t end_0         = begin_0 + policy.m_tile[0];
-    end_0 = end_0 < policy.m_upper[0] ? end_0 : policy.m_upper[0];
-
-    const ptrdiff_t begin_1 = offset[1];
-    ptrdiff_t end_1         = begin_1 + policy.m_tile[1];
-    end_1 = end_1 < policy.m_upper[1] ? end_1 : policy.m_upper[1];
-
-    const ptrdiff_t begin_2 = offset[2];
-    ptrdiff_t end_2         = begin_2 + policy.m_tile[2];
-    end_2 = end_2 < policy.m_upper[2] ? end_2 : policy.m_upper[2];
-
-    const ptrdiff_t begin_3 = offset[3];
-    ptrdiff_t end_3         = begin_3 + policy.m_tile[3];
-    end_3 = end_3 < policy.m_upper[3] ? end_3 : policy.m_upper[3];
-
-#pragma omp for collapse(4)
-    for (ptrdiff_t i0 = begin_0; i0 < end_0; ++i0)
-      for (ptrdiff_t i1 = begin_1; i1 < end_1; ++i1)
-        for (ptrdiff_t i2 = begin_2; i2 < end_2; ++i2)
-          for (ptrdiff_t i3 = begin_3; i3 < end_3; ++i3) {
-            if constexpr (std::is_void<typename Policy::work_tag>::value)
-              functor(i0, i1, i2, i3);
-            else
-              functor(typename Policy::work_tag(), i0, i1, i2, i3);
+    } else {
+#pragma omp target teams distribute parallel for collapse(4) map(to : functor) \
+reduction(+:result)
+      for (auto i3 = begin_3; i3 < end_3; ++i3) {
+        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+          for (auto i1 = begin_1; i1 < end_1; ++i1) {
+            for (auto i0 = begin_0; i0 < end_0; ++i0) {
+              if constexpr (std::is_same<typename Policy::work_tag,
+                                         void>::value)
+                functor(i0, i1, i2, i3, result);
+              else
+                functor(typename Policy::work_tag(), i0, i1, i2, i3, result);
+            }
           }
-#endif
+        }
+      }
+    }
+
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
-  template <int Rank>
+  template <int Rank, class ValueType>
   inline std::enable_if_t<Rank == 5> execute_tile(
-      typename Policy::point_type offset, const FunctorType& functor,
-      const Policy& policy) const {
-#ifdef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-    (void)offset;
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateLeft) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[2];
@@ -257,64 +261,65 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
     const Index end_3 = policy.m_upper[3];
     const Index end_4 = policy.m_upper[4];
 
-#pragma omp target teams distribute parallel for collapse(5) map(to : functor)
-    for (auto i0 = begin_0; i0 < end_0; ++i0) {
-      for (auto i1 = begin_1; i1 < end_1; ++i1) {
-        for (auto i2 = begin_2; i2 < end_2; ++i2) {
-          for (auto i3 = begin_3; i3 < end_3; ++i3) {
-            for (auto i4 = begin_4; i4 < end_4; ++i4) {
-              if constexpr (std::is_same<typename Policy::work_tag,
-                                         void>::value)
-                functor(i0, i1, i2, i3, i4);
-              else
-                functor(typename Policy::work_tag(), i0, i1, i2, i3, i4);
+    ValueType result = ValueType();
+
+    // 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 target teams distribute parallel for collapse(5) map(to         \
+                                                                 : functor) \
+    reduction(custom                                                        \
+              : result)
+      for (auto i4 = begin_4; i4 < end_4; ++i4) {
+        for (auto i3 = begin_3; i3 < end_3; ++i3) {
+          for (auto i2 = begin_2; i2 < end_2; ++i2) {
+            for (auto i1 = begin_1; i1 < end_1; ++i1) {
+              for (auto i0 = begin_0; i0 < end_0; ++i0) {
+                if constexpr (std::is_same<typename Policy::work_tag,
+                                           void>::value)
+                  functor(i0, i1, i2, i3, i4, result);
+                else
+                  functor(typename Policy::work_tag(), i0, i1, i2, i3, i4,
+                          result);
+              }
             }
           }
         }
       }
-    }
-#else
-    const ptrdiff_t begin_0 = offset[0];
-    ptrdiff_t end_0         = begin_0 + policy.m_tile[0];
-    end_0 = end_0 < policy.m_upper[0] ? end_0 : policy.m_upper[0];
-
-    const ptrdiff_t begin_1 = offset[1];
-    ptrdiff_t end_1         = begin_1 + policy.m_tile[1];
-    end_1 = end_1 < policy.m_upper[1] ? end_1 : policy.m_upper[1];
-
-    const ptrdiff_t begin_2 = offset[2];
-    ptrdiff_t end_2         = begin_2 + policy.m_tile[2];
-    end_2 = end_2 < policy.m_upper[2] ? end_2 : policy.m_upper[2];
-
-    const ptrdiff_t begin_3 = offset[3];
-    ptrdiff_t end_3         = begin_3 + policy.m_tile[3];
-    end_3 = end_3 < policy.m_upper[3] ? end_3 : policy.m_upper[3];
-
-    const ptrdiff_t begin_4 = offset[4];
-    ptrdiff_t end_4         = begin_4 + policy.m_tile[4];
-    end_4 = end_4 < policy.m_upper[4] ? end_4 : policy.m_upper[4];
-
-#pragma omp for collapse(5)
-    for (ptrdiff_t i0 = begin_0; i0 < end_0; ++i0)
-      for (ptrdiff_t i1 = begin_1; i1 < end_1; ++i1)
-        for (ptrdiff_t i2 = begin_2; i2 < end_2; ++i2)
-          for (ptrdiff_t i3 = begin_3; i3 < end_3; ++i3)
-            for (ptrdiff_t i4 = begin_4; i4 < end_4; ++i4) {
-              if constexpr (std::is_same<typename Policy::work_tag,
-                                         void>::value)
-                functor(i0, i1, i2, i3, i4);
-              else
-                functor(typename Policy::work_tag(), i0, i1, i2, i3, i4);
+    } else {
+#pragma omp target teams distribute parallel for collapse(5) map(to : functor) \
+reduction(+:result)
+      for (auto i4 = begin_4; i4 < end_4; ++i4) {
+        for (auto i3 = begin_3; i3 < end_3; ++i3) {
+          for (auto i2 = begin_2; i2 < end_2; ++i2) {
+            for (auto i1 = begin_1; i1 < end_1; ++i1) {
+              for (auto i0 = begin_0; i0 < end_0; ++i0) {
+                if constexpr (std::is_same<typename Policy::work_tag,
+                                           void>::value)
+                  functor(i0, i1, i2, i3, i4, result);
+                else
+                  functor(typename Policy::work_tag(), i0, i1, i2, i3, i4,
+                          result);
+              }
             }
-#endif
+          }
+        }
+      }
+    }
+
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
-  template <int Rank>
+  template <int Rank, class ValueType>
   inline std::enable_if_t<Rank == 6> execute_tile(
-      typename Policy::point_type offset, const FunctorType& functor,
-      const Policy& policy) const {
-#ifdef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-    (void)offset;
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateLeft) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[2];
@@ -329,135 +334,69 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
     const Index end_4 = policy.m_upper[4];
     const Index end_5 = policy.m_upper[5];
 
-#pragma omp target teams distribute parallel for collapse(6) map(to : functor)
-    for (auto i0 = begin_0; i0 < end_0; ++i0) {
-      for (auto i1 = begin_1; i1 < end_1; ++i1) {
-        for (auto i2 = begin_2; i2 < end_2; ++i2) {
+    ValueType result = ValueType();
+
+    // 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 target teams distribute parallel for collapse(6) map(to         \
+                                                                 : functor) \
+    reduction(custom                                                        \
+              : result)
+      for (auto i5 = begin_5; i5 < end_5; ++i5) {
+        for (auto i4 = begin_4; i4 < end_4; ++i4) {
           for (auto i3 = begin_3; i3 < end_3; ++i3) {
-            for (auto i4 = begin_4; i4 < end_4; ++i4) {
-              for (auto i5 = begin_5; i5 < end_5; ++i5) {
-                {
+            for (auto i2 = begin_2; i2 < end_2; ++i2) {
+              for (auto i1 = begin_1; i1 < end_1; ++i1) {
+                for (auto i0 = begin_0; i0 < end_0; ++i0) {
                   if constexpr (std::is_same<typename Policy::work_tag,
                                              void>::value)
-                    functor(i0, i1, i2, i3, i4, i5);
+                    functor(i0, i1, i2, i3, i4, i5, result);
                   else
-                    functor(typename Policy::work_tag(), i0, i1, i2, i3, i4,
-                            i5);
+                    functor(typename Policy::work_tag(), i0, i1, i2, i3, i4, i5,
+                            result);
                 }
               }
             }
           }
         }
       }
-    }
-#else
-    const ptrdiff_t begin_0 = offset[0];
-    ptrdiff_t end_0         = begin_0 + policy.m_tile[0];
-    end_0 = end_0 < policy.m_upper[0] ? end_0 : policy.m_upper[0];
-
-    const ptrdiff_t begin_1 = offset[1];
-    ptrdiff_t end_1         = begin_1 + policy.m_tile[1];
-    end_1 = end_1 < policy.m_upper[1] ? end_1 : policy.m_upper[1];
-
-    const ptrdiff_t begin_2 = offset[2];
-    ptrdiff_t end_2         = begin_2 + policy.m_tile[2];
-    end_2 = end_2 < policy.m_upper[2] ? end_2 : policy.m_upper[2];
-
-    const ptrdiff_t begin_3 = offset[3];
-    ptrdiff_t end_3         = begin_3 + policy.m_tile[3];
-    end_3 = end_3 < policy.m_upper[3] ? end_3 : policy.m_upper[3];
-
-    const ptrdiff_t begin_4 = offset[4];
-    ptrdiff_t end_4         = begin_4 + policy.m_tile[4];
-    end_4 = end_4 < policy.m_upper[4] ? end_4 : policy.m_upper[4];
-
-    const ptrdiff_t begin_5 = offset[5];
-    ptrdiff_t end_5         = begin_5 + policy.m_tile[5];
-    end_5 = end_5 < policy.m_upper[5] ? end_5 : policy.m_upper[5];
-
-#pragma omp for collapse(6)
-    for (ptrdiff_t i0 = begin_0; i0 < end_0; ++i0)
-      for (ptrdiff_t i1 = begin_1; i1 < end_1; ++i1)
-        for (ptrdiff_t i2 = begin_2; i2 < end_2; ++i2)
-          for (ptrdiff_t i3 = begin_3; i3 < end_3; ++i3)
-            for (ptrdiff_t i4 = begin_4; i4 < end_4; ++i4)
-              for (ptrdiff_t i5 = begin_5; i5 < end_5; ++i5) {
-                if constexpr (std::is_same<typename Policy::work_tag,
-                                           void>::value)
-                  functor(i0, i1, i2, i3, i4, i5);
-                else
-                  functor(typename Policy::work_tag(), i0, i1, i2, i3, i4, i5);
+    } else {
+#pragma omp target teams distribute parallel for collapse(6) map(to : functor) \
+reduction(+:result)
+      for (auto i5 = begin_5; i5 < end_5; ++i5) {
+        for (auto i4 = begin_4; i4 < end_4; ++i4) {
+          for (auto i3 = begin_3; i3 < end_3; ++i3) {
+            for (auto i2 = begin_2; i2 < end_2; ++i2) {
+              for (auto i1 = begin_1; i1 < end_1; ++i1) {
+                for (auto i0 = begin_0; i0 < end_0; ++i0) {
+                  if constexpr (std::is_same<typename Policy::work_tag,
+                                             void>::value)
+                    functor(i0, i1, i2, i3, i4, i5, result);
+                  else
+                    functor(typename Policy::work_tag(), i0, i1, i2, i3, i4, i5,
+                            result);
+                }
               }
-#endif
-  }
-
-  inline ParallelFor(const FunctorType& arg_functor, Policy arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-  // TODO DZP: based on a conversation with Christian, we're using 256 as a
-  // heuristic here. We need something better once we can query these kinds of
-  // properties
-  template <typename Policy, typename Functor>
-  static int max_tile_size_product(const Policy&, const Functor&) {
-    return 256;
-  }
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template <class CombinedFunctorReducerType, class... Traits>
-class ParallelReduce<CombinedFunctorReducerType,
-                     Kokkos::MDRangePolicy<Traits...>,
-                     Kokkos::Experimental::OpenMPTarget> {
- private:
-  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 pointer_type   = typename ReducerType::pointer_type;
-  using reference_type = typename ReducerType::reference_type;
-
-  static constexpr bool UseReducer =
-      !std::is_same_v<FunctorType, typename ReducerType::functor_type>;
-
-  const pointer_type m_result_ptr;
-  const CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-
-  using ParReduceCopy = ParallelReduceCopy<pointer_type>;
-
-  bool m_result_ptr_on_device;
+            }
+          }
+        }
+      }
+    }
 
- public:
-  inline void execute() const {
-    execute_tile<Policy::rank, typename ReducerType::value_type>(
-        m_functor_reducer.get_functor(), m_policy, m_result_ptr);
+    ParReduceCopy::memcpy_result(ptr, &result, sizeof(ValueType),
+                                 m_result_ptr_on_device);
   }
 
-  template <class ViewType>
-  inline ParallelReduce(const CombinedFunctorReducerType& arg_functor_reducer,
-                        Policy arg_policy, const ViewType& arg_result_view)
-      : m_result_ptr(arg_result_view.data()),
-        m_functor_reducer(arg_functor_reducer),
-        m_policy(arg_policy),
-        m_result_ptr_on_device(
-            MemorySpaceAccess<Kokkos::Experimental::OpenMPTargetSpace,
-                              typename ViewType::memory_space>::accessible) {}
-
   template <int Rank, class ValueType>
-  inline std::enable_if_t<Rank == 2> execute_tile(const FunctorType& functor,
-                                                  const Policy& policy,
-                                                  pointer_type ptr) const {
+  inline std::enable_if_t<Rank == 2> execute_tile(
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateRight) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
 
@@ -504,9 +443,9 @@ reduction(+:result)
   }
 
   template <int Rank, class ValueType>
-  inline std::enable_if_t<Rank == 3> execute_tile(const FunctorType& functor,
-                                                  const Policy& policy,
-                                                  pointer_type ptr) const {
+  inline std::enable_if_t<Rank == 3> execute_tile(
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateRight) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[2];
@@ -562,9 +501,9 @@ reduction(+:result)
   }
 
   template <int Rank, class ValueType>
-  inline std::enable_if_t<Rank == 4> execute_tile(const FunctorType& functor,
-                                                  const Policy& policy,
-                                                  pointer_type ptr) const {
+  inline std::enable_if_t<Rank == 4> execute_tile(
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateRight) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[3];
@@ -625,9 +564,9 @@ reduction(+:result)
   }
 
   template <int Rank, class ValueType>
-  inline std::enable_if_t<Rank == 5> execute_tile(const FunctorType& functor,
-                                                  const Policy& policy,
-                                                  pointer_type ptr) const {
+  inline std::enable_if_t<Rank == 5> execute_tile(
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateRight) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[2];
@@ -696,9 +635,9 @@ reduction(+:result)
   }
 
   template <int Rank, class ValueType>
-  inline std::enable_if_t<Rank == 6> execute_tile(const FunctorType& functor,
-                                                  const Policy& policy,
-                                                  pointer_type ptr) const {
+  inline std::enable_if_t<Rank == 6> execute_tile(
+      const FunctorType& functor, const Policy& policy, pointer_type ptr,
+      OpenMPTargetIterateRight) const {
     const Index begin_0 = policy.m_lower[0];
     const Index begin_1 = policy.m_lower[1];
     const Index begin_2 = policy.m_lower[2];
@@ -783,5 +722,4 @@ reduction(+:result)
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
-#undef KOKKOS_IMPL_MDRANGE_USE_NO_TILES
-#endif /* KOKKOS_OPENMPTARGET_PARALLEL_HPP */
+#endif /* KOKKOS_OPENMPTARGET_PARALLELREDUCE_MDRANGE_HPP */
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp
index 4452af3846..4a112ed11d 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Range.hpp
@@ -59,6 +59,9 @@ class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
 
  public:
   void execute() const {
+    // Only let one ParallelReduce instance at a time use the scratch memory.
+    std::scoped_lock<std::mutex> scratch_memory_lock(
+        OpenMPTargetExec::m_mutex_scratch_ptr);
     const FunctorType& functor = m_functor_reducer.get_functor();
     if constexpr (FunctorHasJoin) {
       // Enter this loop if the Functor has a init-join.
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp
index a302fa7151..16c0eedb81 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelReduce_Team.hpp
@@ -472,6 +472,9 @@ class ParallelReduce<CombinedFunctorReducerType,
 
  public:
   void execute() const {
+    // Only let one ParallelReduce instance at a time use the scratch memory.
+    std::scoped_lock<std::mutex> scratch_memory_lock(
+        OpenMPTargetExec::m_mutex_scratch_ptr);
     const FunctorType& functor = m_functor_reducer.get_functor();
     if constexpr (FunctorHasJoin) {
       ParReduceSpecialize::execute_init_join(functor, m_policy, m_result_ptr,
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp
index 22acb7e3c5..b0d6932802 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Range.hpp
@@ -142,7 +142,8 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
           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 defined(KOKKOS_ARCH_AMD_GPU) && !defined(KOKKOS_ARCH_AMD_GFX1030) && \
+    !defined(KOKKOS_ARCH_AMD_GFX1100)
             if constexpr (Analysis::Reducer::has_join_member_function()) {
               if constexpr (std::is_void_v<WorkTag>)
                 a_functor_reducer.get_functor().join(local_offset_value,
@@ -176,6 +177,10 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
     const idx_type chunk_size = 128;
     const idx_type n_chunks   = (N + chunk_size - 1) / chunk_size;
 
+    // Only let one ParallelReduce instance at a time use the scratch memory.
+    std::scoped_lock<std::mutex> scratch_memory_lock(
+        OpenMPTargetExec::m_mutex_scratch_ptr);
+
     // This could be scratch memory per team
     Kokkos::View<value_type**, Kokkos::LayoutRight,
                  Kokkos::Experimental::OpenMPTargetSpace>
@@ -224,6 +229,10 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     const int64_t n_chunks = (N + chunk_size - 1) / chunk_size;
 
     if (N > 0) {
+      // Only let one ParallelReduce instance at a time use the scratch memory.
+      std::scoped_lock<std::mutex> scratch_memory_lock(
+          OpenMPTargetExec::m_mutex_scratch_ptr);
+
       // This could be scratch memory per team
       Kokkos::View<value_type**, Kokkos::LayoutRight,
                    Kokkos::Experimental::OpenMPTargetSpace>
@@ -237,8 +246,10 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
 
       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);
+        DeepCopy<HostSpace, Kokkos::Experimental::OpenMPTargetSpace,
+                 Kokkos::Experimental::OpenMPTarget>(
+            base_t::m_policy.space(), 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);
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp
index a9e24994e0..ad0b3c4e7f 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_ParallelScan_Team.hpp
@@ -32,15 +32,17 @@
 namespace Kokkos {
 
 // This is largely the same code as in HIP and CUDA except for the member name
-template <typename iType, class FunctorType>
+template <typename iType, class FunctorType, class ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::TeamThreadRangeBoundariesStruct<
         iType, Impl::OpenMPTargetExecTeamMember>& loop_bounds,
-    const FunctorType& lambda) {
-  using Analysis   = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+    const FunctorType& lambda, ValueType& return_val) {
+  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
                                          TeamPolicy<Experimental::OpenMPTarget>,
                                          FunctorType, void>;
-  using value_type = typename Analysis::value_type;
+  using analysis_value_type = typename Analysis::value_type;
+  static_assert(std::is_same_v<analysis_value_type, ValueType>,
+                "Non-matching value types of functor and return type");
 
   const auto start = loop_bounds.start;
   const auto end   = loop_bounds.end;
@@ -50,24 +52,27 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   const auto team_rank = member.team_rank();
 
 #if defined(KOKKOS_IMPL_TEAM_SCAN_WORKAROUND)
-  value_type scan_val = value_type();
+  ValueType scan_val = {};
 
   if (team_rank == 0) {
     for (iType i = start; i < end; ++i) {
       lambda(i, scan_val, true);
     }
   }
+  member.team_broadcast(scan_val, 0);
+  return_val = scan_val;
+
 #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;
+  ValueType accum      = {};
   // 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;
+    ValueType local_accum = {};
     // user updates value with prefix value
     if (ii < loop_bounds.end) lambda(ii, local_accum, false);
     // perform team scan
@@ -81,9 +86,23 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     // broadcast last value to rest of the team
     member.team_broadcast(accum, team_size - 1);
   }
+  return_val = accum;
+
 #endif
 }
 
+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;
+  value_type scan_val;
+  parallel_scan(loop_bounds, lambda, scan_val);
+}
 }  // namespace Kokkos
 
 namespace Kokkos {
@@ -100,17 +119,19 @@ namespace Kokkos {
  * final==true. Scan_val will be set to the final sum value over all vector
  * lanes.
  */
-template <typename iType, class FunctorType>
+template <typename iType, class FunctorType, class ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::ThreadVectorRangeBoundariesStruct<
         iType, Impl::OpenMPTargetExecTeamMember>& loop_boundaries,
-    const FunctorType& lambda) {
-  using Analysis   = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+    const FunctorType& lambda, ValueType& return_val) {
+  using Analysis = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
                                          TeamPolicy<Experimental::OpenMPTarget>,
                                          FunctorType, void>;
-  using value_type = typename Analysis::value_type;
+  using analysis_value_type = typename Analysis::value_type;
+  static_assert(std::is_same_v<analysis_value_type, ValueType>,
+                "Non-matching value types of functor and return type");
 
-  value_type scan_val = value_type();
+  ValueType scan_val = {};
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
@@ -118,6 +139,22 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   for (iType i = loop_boundaries.start; i < loop_boundaries.end; ++i) {
     lambda(i, scan_val, true);
   }
+
+  return_val = scan_val;
+}
+
+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();
+  parallel_scan(loop_boundaries, lambda, scan_val);
 }
 
 }  // namespace Kokkos
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp
index 4206c3b557..eb3dc3773c 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Parallel_Common.hpp
@@ -21,6 +21,7 @@
 #include <sstream>
 #include <Kokkos_Parallel.hpp>
 #include <OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp>
+#include <OpenMPTarget/Kokkos_OpenMPTarget_Macros.hpp>
 
 namespace Kokkos {
 namespace Impl {
@@ -33,9 +34,12 @@ struct ParallelReduceCopy {
   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()));
+      if (0 < size) {
+        KOKKOS_IMPL_OMPT_SAFE_CALL(omp_target_memcpy(dest, src, size, 0, 0,
+                                                     omp_get_default_device(),
+                                                     omp_get_initial_device()));
+      }
+
     } else {
       *dest = *src;
     }
@@ -81,9 +85,11 @@ struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
   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");
+        "Kokkos::Experimental::OpenMPTarget RangePolicy "
+        "parallel_reduce:reducer");
     OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
+        "Kokkos::Experimental::OpenMPTarget RangePolicy "
+        "parallel_reduce:reducer");
     const auto begin = p.begin();
     const auto end   = p.end();
 
@@ -122,9 +128,11 @@ struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
   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");
+        "Kokkos::Experimental::OpenMPTarget RangePolicy "
+        "parallel_reduce:array_reduction");
     OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
+        "Kokkos::Experimental::OpenMPTarget RangePolicy "
+        "parallel_reduce:array_reduction");
     const auto begin = p.begin();
     const auto end   = p.end();
 
@@ -194,6 +202,12 @@ struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
 
   static void execute_init_join(const FunctorType& f, const PolicyType& p,
                                 PointerType ptr, const bool ptr_on_device) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget RangePolicy "
+        "parallel_reduce:init_join");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget RangePolicy "
+        "parallel_reduce:init_join");
     const auto begin = p.begin();
     const auto end   = p.end();
 
@@ -231,14 +245,16 @@ struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
         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()));
+      if (0 < value_count) {
+        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;
     }
@@ -310,14 +326,16 @@ struct ParallelReduceSpecialize<FunctorType, Kokkos::RangePolicy<PolicyArgs...>,
     } 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()));
+    if (0 < value_count) {
+      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()));
+    }
   }
 };
 
@@ -340,9 +358,11 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
   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");
+        "Kokkos::Experimental::OpenMPTarget TeamPolicy "
+        "parallel_reduce:reducer");
     OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
+        "Kokkos::Experimental::OpenMPTarget TeamPolicy "
+        "parallel_reduce:reducer");
 
     const int league_size   = p.league_size();
     const int team_size     = p.team_size();
@@ -375,9 +395,11 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
     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)
+    KOKKOS_IMPL_OMPTARGET_PRAGMA(
+        teams num_teams(max_active_teams) thread_limit(team_size)
+            firstprivate(f) is_device_ptr(scratch_ptr) reduction(custom
+                                                                 : result)
+                KOKKOS_IMPL_OMPX_DYN_CGROUP_MEM(shmem_size_L0))
 #pragma omp parallel reduction(custom : result)
     {
       if (omp_get_num_teams() > max_active_teams)
@@ -428,9 +450,11 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
   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");
+        "Kokkos::Experimental::OpenMPTarget TeamPolicy "
+        "parallel_reduce:array_reduction");
     OpenMPTargetExec::verify_initialized(
-        "Kokkos::Experimental::OpenMPTarget parallel_for");
+        "Kokkos::Experimental::OpenMPTarget TeamPolicy "
+        "parallel_reduce:array_reduction");
 
     const int league_size   = p.league_size();
     const int team_size     = p.team_size();
@@ -461,9 +485,11 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
 
       // 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)
+        // Use scratch memory extensions to request dynamic shared memory for
+        // the right compiler/architecture combination.
+        KOKKOS_IMPL_OMPTARGET_PRAGMA(teams num_teams(max_active_teams) thread_limit(team_size) map(to: f) \
+    is_device_ptr(scratch_ptr) reduction(+: result)               \
+        KOKKOS_IMPL_OMPX_DYN_CGROUP_MEM(shmem_size_L0))
 #pragma omp parallel reduction(+ : result)
         {
           if (omp_get_num_teams() > max_active_teams)
@@ -553,6 +579,12 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
   // RangePolicy. Need a new implementation.
   static void execute_init_join(const FunctorType& f, const PolicyType& p,
                                 PointerType ptr, const bool ptr_on_device) {
+    OpenMPTargetExec::verify_is_process(
+        "Kokkos::Experimental::OpenMPTarget TeamPolicy "
+        "parallel_reduce:init_join ");
+    OpenMPTargetExec::verify_initialized(
+        "Kokkos::Experimental::OpenMPTarget TeamPolicy "
+        "parallel_reduce:init_join");
     using FunctorAnalysis =
         Impl::FunctorAnalysis<Impl::FunctorPatternInterface::REDUCE, PolicyType,
                               FunctorType, ValueType>;
@@ -596,22 +628,26 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
         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()));
+      if (0 < value_count) {
+        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)
-    {
+    // Use scratch memory extensions to request dynamic shared memory for the
+    // right compiler/architecture combination.
+    KOKKOS_IMPL_OMPTARGET_PRAGMA(
+        teams num_teams(nteams) thread_limit(team_size) map(to
+                                                            : f)
+            is_device_ptr(scratch_ptr)
+                KOKKOS_IMPL_OMPX_DYN_CGROUP_MEM(shmem_size_L0)) {
 #pragma omp parallel
       {
         const int team_num      = omp_get_team_num();
@@ -636,9 +672,8 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
 
     int tree_neighbor_offset = 1;
     do {
-#pragma omp target teams distribute parallel for simd map(to               \
-                                                          : final_reducer) \
-    is_device_ptr(scratch_ptr)
+#pragma omp target teams distribute parallel for simd firstprivate( \
+    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);
@@ -658,14 +693,16 @@ struct ParallelReduceSpecialize<FunctorType, TeamPolicyInternal<PolicyArgs...>,
     } 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()));
+    if (0 < value_count) {
+      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()));
+    }
   }
 };
 
diff --git a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp
index 672271ed6b..9b578aca11 100644
--- a/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp
+++ b/core/src/OpenMPTarget/Kokkos_OpenMPTarget_Reducer.hpp
@@ -18,7 +18,6 @@
 #define KOKKOS_OPENMPTARGETREDUCER_HPP
 
 #include <impl/Kokkos_Traits.hpp>
-#include <impl/Kokkos_Spinwait.hpp>
 
 #include <Kokkos_Atomic.hpp>
 #include "Kokkos_OpenMPTarget_Abort.hpp"
diff --git a/core/src/SYCL/Kokkos_SYCL.cpp b/core/src/SYCL/Kokkos_SYCL.cpp
index f8a1efda8e..4de6931918 100644
--- a/core/src/SYCL/Kokkos_SYCL.cpp
+++ b/core/src/SYCL/Kokkos_SYCL.cpp
@@ -59,6 +59,13 @@ SYCL::SYCL(const sycl::queue& stream)
         ptr->finalize();
         delete ptr;
       }) {
+  // In principle could be guarded with
+  // #ifdef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+  // but we chose to require user-provided queues to be in-order
+  // unconditionally so that code downstream does not break
+  // when the backend setting changes.
+  if (!stream.is_in_order())
+    Kokkos::abort("User provided sycl::queues must be in-order!");
   Impl::SYCLInternal::singleton().verify_is_initialized(
       "SYCL instance constructor");
   m_space_instance->initialize(stream);
@@ -81,19 +88,82 @@ bool SYCL::impl_is_initialized() {
 void SYCL::impl_finalize() { Impl::SYCLInternal::singleton().finalize(); }
 
 void SYCL::print_configuration(std::ostream& os, bool verbose) const {
-  os << "Devices:\n";
-  os << "  KOKKOS_ENABLE_SYCL: yes\n";
-
   os << "\nRuntime Configuration:\n";
 
-  os << "macro  KOKKOS_ENABLE_SYCL : defined\n";
+#ifdef KOKKOS_ENABLE_ONEDPL
+  os << "macro  KOKKOS_ENABLE_ONEDPL : defined\n";
+#else
+  os << "macro  KOKKOS_ENABLE_ONEDPL : undefined\n";
+#endif
 #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)
+#ifdef SYCL_EXT_ONEAPI_DEVICE_GLOBAL
+  os << "macro  SYCL_EXT_ONEAPI_DEVICE_GLOBAL : defined\n";
+#else
+  os << "macro  SYCL_EXT_ONEAPI_DEVICE_GLOBAL : undefined\n";
+#endif
+#ifdef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+  os << "macro  KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES : defined\n";
+#else
+  os << "macro  KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES : undefined\n";
+#endif
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+  os << "macro  SYCL_EXT_ONEAPI_GRAPH : defined\n";
+#else
+  os << "macro  SYCL_EXT_ONEAPI_GRAPH : undefined\n";
+#endif
+#ifdef SYCL_EXT_INTEL_QUEUE_IMMEDIATE_COMMAND_LIST
+  if (sycl_queue()
+          .has_property<
+              sycl::ext::intel::property::queue::immediate_command_list>())
+    os << "Immediate command lists enforced\n";
+  else if (sycl_queue()
+               .has_property<sycl::ext::intel::property::queue::
+                                 no_immediate_command_list>())
+    os << "Standard command queue enforced\n";
+  else
+#endif
+  {
+    os << "Immediate command lists and standard command queue allowed.\n";
+    if (const char* environment_setting =
+            std::getenv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS"))
+      os << "SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS="
+         << environment_setting << " takes precedence.\n";
+    else
+      os << "SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS not defined.\n";
+  }
+
+  int counter       = 0;
+  int active_device = Kokkos::device_id();
+  std::cout << "\nAvailable devices: \n";
+  std::vector<sycl::device> devices = Impl::get_sycl_devices();
+  for (const auto& device : devices) {
+    std::string device_type;
+    switch (device.get_info<sycl::info::device::device_type>()) {
+      case sycl::info::device_type::cpu: device_type = "cpu"; break;
+      case sycl::info::device_type::gpu: device_type = "gpu"; break;
+      case sycl::info::device_type::accelerator:
+        device_type = "accelerator";
+        break;
+      case sycl::info::device_type::custom: device_type = "custom"; break;
+      case sycl::info::device_type::automatic: device_type = "automatic"; break;
+      case sycl::info::device_type::host: device_type = "host"; break;
+      case sycl::info::device_type::all: device_type = "all"; break;
+    }
+    os << "[" << device.get_backend() << "]:" << device_type << ':' << counter
+       << "] " << device.get_info<sycl::info::device::name>();
+    if (counter == active_device) os << " : Selected";
+    os << '\n';
+    ++counter;
+  }
+
+  if (verbose) {
+    os << '\n';
     SYCL::impl_sycl_info(os, m_space_instance->m_queue->get_device());
+  }
 }
 
 void SYCL::fence(const std::string& name) const {
@@ -123,20 +193,11 @@ void SYCL::impl_static_fence(const std::string& name) {
 }
 
 void SYCL::impl_initialize(InitializationSettings const& settings) {
-  std::vector<sycl::device> gpu_devices =
-      sycl::device::get_devices(sycl::info::device_type::gpu);
-  // 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_IMPL_ARCH_NVIDIA_GPU)
-  if (!settings.has_device_id() && gpu_devices.empty()) {
-    Impl::SYCLInternal::singleton().initialize(sycl::device());
-    Impl::SYCLInternal::m_syclDev = 0;
-    return;
-  }
-#endif
-  const auto id = ::Kokkos::Impl::get_gpu(settings);
-  Impl::SYCLInternal::singleton().initialize(gpu_devices[id]);
+  const auto& visible_devices = ::Kokkos::Impl::get_visible_devices();
+  const auto id =
+      ::Kokkos::Impl::get_gpu(settings).value_or(visible_devices[0]);
+  std::vector<sycl::device> sycl_devices = Impl::get_sycl_devices();
+  Impl::SYCLInternal::singleton().initialize(sycl_devices[id]);
   Impl::SYCLInternal::m_syclDev = id;
 }
 
@@ -229,9 +290,32 @@ std::ostream& SYCL::impl_sycl_info(std::ostream& os,
 
 namespace Impl {
 
+std::vector<sycl::device> get_sycl_devices() {
+#if defined(KOKKOS_ARCH_INTEL_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU) || \
+    defined(KOKKOS_ARCH_AMD_GPU)
+  std::vector<sycl::device> devices =
+      sycl::device::get_devices(sycl::info::device_type::gpu);
+#if defined(KOKKOS_ARCH_INTEL_GPU)
+  sycl::backend backend = sycl::backend::ext_oneapi_level_zero;
+#elif defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  sycl::backend backend = sycl::backend::ext_oneapi_cuda;
+#elif defined(KOKKOS_ARCH_AMD_GPU)
+  sycl::backend backend = sycl::backend::ext_oneapi_hip;
+#endif
+  devices.erase(std::remove_if(devices.begin(), devices.end(),
+                               [backend](const sycl::device& d) {
+                                 return d.get_backend() != backend;
+                               }),
+                devices.end());
+#else
+  std::vector<sycl::device> devices = sycl::device::get_devices();
+#endif
+  return devices;
+}
+
 int g_sycl_space_factory_initialized =
     Kokkos::Impl::initialize_space_factory<SYCL>("170_SYCL");
 
-}
+}  // namespace Impl
 }  // namespace Experimental
 }  // namespace Kokkos
diff --git a/core/src/SYCL/Kokkos_SYCL.hpp b/core/src/SYCL/Kokkos_SYCL.hpp
index 60d4197af7..0f3d1f0994 100644
--- a/core/src/SYCL/Kokkos_SYCL.hpp
+++ b/core/src/SYCL/Kokkos_SYCL.hpp
@@ -78,19 +78,15 @@ class SYCL {
   //! \name Functions that all Kokkos devices must implement.
   //@{
 
-  KOKKOS_INLINE_FUNCTION static int in_parallel() {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED KOKKOS_INLINE_FUNCTION static int in_parallel() {
 #if defined(__SYCL_DEVICE_ONLY__)
     return true;
 #else
     return false;
 #endif
   }
-
-  /** \brief  Set the device in a "sleep" state. */
-  static bool sleep();
-
-  /** \brief Wake the device from the 'sleep' state. A noop for OpenMP. */
-  static bool wake();
+#endif
 
   /** \brief Wait until all dispatched functors complete. A noop for OpenMP. */
   static void impl_static_fence(const std::string& name);
@@ -163,7 +159,8 @@ std::vector<SYCL> partition_space(const SYCL& sycl_space, Args...) {
   std::vector<SYCL> instances;
   instances.reserve(sizeof...(Args));
   for (unsigned int i = 0; i < sizeof...(Args); ++i)
-    instances.emplace_back(sycl::queue(context, device));
+    instances.emplace_back(
+        sycl::queue(context, device, sycl::property::queue::in_order()));
   return instances;
 }
 
@@ -183,9 +180,14 @@ std::vector<SYCL> partition_space(const SYCL& sycl_space,
   // otherwise.
   instances.reserve(weights.size());
   for (unsigned int i = 0; i < weights.size(); ++i)
-    instances.emplace_back(sycl::queue(context, device));
+    instances.emplace_back(
+        sycl::queue(context, device, sycl::property::queue::in_order()));
   return instances;
 }
+
+namespace Impl {
+std::vector<sycl::device> get_sycl_devices();
+}  // namespace Impl
 }  // namespace Experimental
 
 }  // namespace Kokkos
diff --git a/core/src/SYCL/Kokkos_SYCL_Abort.hpp b/core/src/SYCL/Kokkos_SYCL_Abort.hpp
index 9e6d9fd7e2..4b0a142fe6 100644
--- a/core/src/SYCL/Kokkos_SYCL_Abort.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Abort.hpp
@@ -17,7 +17,7 @@
 #ifndef KOKKOS_SYCL_ABORT_HPP
 #define KOKKOS_SYCL_ABORT_HPP
 
-#include <Kokkos_Macros.hpp>
+#include <Kokkos_Printf.hpp>
 #if defined(KOKKOS_ENABLE_SYCL)
 // FIXME_SYCL
 #if __has_include(<sycl/sycl.hpp>)
@@ -31,7 +31,7 @@ namespace Impl {
 
 inline void sycl_abort(char const* msg) {
 #ifdef NDEBUG
-  KOKKOS_IMPL_DO_NOT_USE_PRINTF("Aborting with message %s.\n", msg);
+  Kokkos::printf("Aborting with message %s.\n", msg);
 #else
   // Choosing "" here causes problems but a single whitespace character works.
   const char* empty = " ";
diff --git a/core/src/SYCL/Kokkos_SYCL_GraphNodeKernel.hpp b/core/src/SYCL/Kokkos_SYCL_GraphNodeKernel.hpp
new file mode 100644
index 0000000000..9c39df9415
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_GraphNodeKernel.hpp
@@ -0,0 +1,157 @@
+//@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_GRAPHNODEKERNEL_HPP
+#define KOKKOS_SYCL_GRAPHNODEKERNEL_HPP
+
+#include <Kokkos_Graph_fwd.hpp>
+
+#include <impl/Kokkos_GraphImpl.hpp>
+
+#include <Kokkos_Parallel.hpp>
+#include <Kokkos_Parallel_Reduce.hpp>
+#include <Kokkos_PointerOwnership.hpp>
+
+#include <SYCL/Kokkos_SYCL_GraphNode_Impl.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <typename PolicyType, typename Functor, typename PatternTag,
+          typename... Args>
+class GraphNodeKernelImpl<Kokkos::Experimental::SYCL, PolicyType, Functor,
+                          PatternTag, Args...>
+    : public PatternImplSpecializationFromTag<
+          PatternTag, Functor, PolicyType, Args...,
+          Kokkos::Experimental::SYCL>::type {
+ public:
+  using Policy       = PolicyType;
+  using graph_kernel = GraphNodeKernelImpl;
+  using base_t       = typename PatternImplSpecializationFromTag<
+      PatternTag, Functor, Policy, Args..., Kokkos::Experimental::SYCL>::type;
+
+  // TODO use the name and executionspace
+  template <typename PolicyDeduced, typename... ArgsDeduced>
+  GraphNodeKernelImpl(std::string, Kokkos::Experimental::SYCL const&,
+                      Functor arg_functor, PolicyDeduced&& arg_policy,
+                      ArgsDeduced&&... args)
+      : base_t(std::move(arg_functor), (PolicyDeduced &&) arg_policy,
+               (ArgsDeduced &&) args...) {}
+
+  template <typename PolicyDeduced>
+  GraphNodeKernelImpl(Kokkos::Experimental::SYCL const& exec_space,
+                      Functor arg_functor, PolicyDeduced&& arg_policy)
+      : GraphNodeKernelImpl("", exec_space, std::move(arg_functor),
+                            (PolicyDeduced &&) arg_policy) {}
+
+  void set_sycl_graph_ptr(
+      sycl::ext::oneapi::experimental::command_graph<
+          sycl::ext::oneapi::experimental::graph_state::modifiable>*
+          arg_graph) {
+    m_graph_ptr = arg_graph;
+  }
+
+  void set_sycl_graph_node_ptr(
+      std::optional<sycl::ext::oneapi::experimental::node>* arg_node) {
+    m_graph_node_ptr = arg_node;
+  }
+
+  std::optional<sycl::ext::oneapi::experimental::node>& get_sycl_graph_node()
+      const {
+    return *m_graph_node_ptr;
+  }
+
+  sycl::ext::oneapi::experimental::command_graph<
+      sycl::ext::oneapi::experimental::graph_state::modifiable>&
+  get_sycl_graph() const {
+    return *m_graph_ptr;
+  }
+
+ private:
+  Kokkos::ObservingRawPtr<sycl::ext::oneapi::experimental::command_graph<
+      sycl::ext::oneapi::experimental::graph_state::modifiable>>
+      m_graph_ptr = nullptr;
+  Kokkos::ObservingRawPtr<std::optional<sycl::ext::oneapi::experimental::node>>
+      m_graph_node_ptr = nullptr;
+};
+
+struct SYCLGraphNodeAggregateKernel {
+  using graph_kernel = SYCLGraphNodeAggregateKernel;
+
+  // Aggregates don't need a policy, but for the purposes of checking the static
+  // assertions about graph kernels,
+  struct Policy {
+    using is_graph_kernel = std::true_type;
+  };
+};
+
+template <typename KernelType,
+          typename Tag =
+              typename PatternTagFromImplSpecialization<KernelType>::type>
+struct get_graph_node_kernel_type
+    : type_identity<GraphNodeKernelImpl<
+          Kokkos::Experimental::SYCL, typename KernelType::Policy,
+          typename KernelType::functor_type, Tag>> {};
+
+template <typename KernelType>
+struct get_graph_node_kernel_type<KernelType, Kokkos::ParallelReduceTag>
+    : type_identity<GraphNodeKernelImpl<
+          Kokkos::Experimental::SYCL, typename KernelType::Policy,
+          CombinedFunctorReducer<typename KernelType::FunctorType,
+                                 typename KernelType::ReducerType>,
+          Kokkos::ParallelReduceTag>> {};
+
+template <typename KernelType>
+auto& get_sycl_graph_from_kernel(KernelType const& kernel) {
+  using graph_node_kernel_t =
+      typename get_graph_node_kernel_type<KernelType>::type;
+  auto const& kernel_as_graph_kernel =
+      static_cast<graph_node_kernel_t const&>(kernel);
+  auto& graph = kernel_as_graph_kernel.get_sycl_graph();
+
+  return graph;
+}
+
+template <typename KernelType>
+auto& get_sycl_graph_node_from_kernel(KernelType const& kernel) {
+  using graph_node_kernel_t =
+      typename get_graph_node_kernel_type<KernelType>::type;
+  auto const& kernel_as_graph_kernel =
+      static_cast<graph_node_kernel_t const&>(kernel);
+  auto& graph_node = kernel_as_graph_kernel.get_sycl_graph_node();
+
+  return graph_node;
+}
+
+template <typename Kernel, typename Lambda>
+void sycl_attach_kernel_to_node(Kernel& kernel, const Lambda& lambda) {
+  sycl::ext::oneapi::experimental::command_graph<
+      sycl::ext::oneapi::experimental::graph_state::modifiable>& graph =
+      Impl::get_sycl_graph_from_kernel(kernel);
+  std::optional<sycl::ext::oneapi::experimental::node>& graph_node =
+      Impl::get_sycl_graph_node_from_kernel(kernel);
+  KOKKOS_ENSURES(!graph_node);
+  graph_node = graph.add(lambda);
+  KOKKOS_ENSURES(graph_node);
+  // FIXME_SYCL_GRAPH not yet implemented in the compiler
+  //   KOKKOS_ENSURES(graph_node.get_type() ==
+  //   sycl::ext::oneapi::experimental::node_type::kernel)
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_GraphNode_Impl.hpp b/core/src/SYCL/Kokkos_SYCL_GraphNode_Impl.hpp
new file mode 100644
index 0000000000..6bbe6711a2
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_GraphNode_Impl.hpp
@@ -0,0 +1,56 @@
+//@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_GRAPHNODE_IMPL_HPP
+#define KOKKOS_SYCL_GRAPHNODE_IMPL_HPP
+
+#include <Kokkos_Graph_fwd.hpp>
+
+#include <impl/Kokkos_GraphImpl.hpp>
+
+#include <SYCL/Kokkos_SYCL.hpp>
+
+#include <optional>
+
+namespace Kokkos {
+namespace Impl {
+template <>
+struct GraphNodeBackendSpecificDetails<Kokkos::Experimental::SYCL> {
+  std::optional<sycl::ext::oneapi::experimental::node> node;
+
+  explicit GraphNodeBackendSpecificDetails() = default;
+
+  explicit GraphNodeBackendSpecificDetails(
+      _graph_node_is_root_ctor_tag) noexcept {}
+};
+
+template <typename Kernel, typename PredecessorRef>
+struct GraphNodeBackendDetailsBeforeTypeErasure<Kokkos::Experimental::SYCL,
+                                                Kernel, PredecessorRef> {
+ protected:
+  GraphNodeBackendDetailsBeforeTypeErasure(
+      Kokkos::Experimental::SYCL const &, Kernel &, PredecessorRef const &,
+      GraphNodeBackendSpecificDetails<Kokkos::Experimental::SYCL> &) noexcept {}
+
+  GraphNodeBackendDetailsBeforeTypeErasure(
+      Kokkos::Experimental::SYCL const &, _graph_node_is_root_ctor_tag,
+      GraphNodeBackendSpecificDetails<Kokkos::Experimental::SYCL> &) noexcept {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Graph_Impl.hpp b/core/src/SYCL/Kokkos_SYCL_Graph_Impl.hpp
new file mode 100644
index 0000000000..1dc4a9c997
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_Graph_Impl.hpp
@@ -0,0 +1,174 @@
+//@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_GRAPH_IMPL_HPP
+#define KOKKOS_SYCL_GRAPH_IMPL_HPP
+
+#include <Kokkos_Macros.hpp>
+
+#include <Kokkos_Graph_fwd.hpp>
+
+#include <impl/Kokkos_GraphImpl.hpp>
+#include <impl/Kokkos_GraphNodeImpl.hpp>
+
+#include <SYCL/Kokkos_SYCL_GraphNodeKernel.hpp>
+
+#include <optional>
+
+namespace Kokkos {
+namespace Impl {
+template <>
+class GraphImpl<Kokkos::Experimental::SYCL> {
+ public:
+  using node_details_t =
+      GraphNodeBackendSpecificDetails<Kokkos::Experimental::SYCL>;
+  using root_node_impl_t        = GraphNodeImpl<Kokkos::Experimental::SYCL,
+                                         Kokkos::Experimental::TypeErasedTag,
+                                         Kokkos::Experimental::TypeErasedTag>;
+  using aggregate_kernel_impl_t = SYCLGraphNodeAggregateKernel;
+  using aggregate_node_impl_t =
+      GraphNodeImpl<Kokkos::Experimental::SYCL, aggregate_kernel_impl_t,
+                    Kokkos::Experimental::TypeErasedTag>;
+
+  // Not movable or copyable; it spends its whole life as a shared_ptr in the
+  // Graph object.
+  GraphImpl()                 = delete;
+  GraphImpl(GraphImpl const&) = delete;
+  GraphImpl(GraphImpl&&)      = delete;
+  GraphImpl& operator=(GraphImpl const&) = delete;
+  GraphImpl& operator=(GraphImpl&&) = delete;
+
+  ~GraphImpl();
+
+  explicit GraphImpl(Kokkos::Experimental::SYCL instance);
+
+  void add_node(std::shared_ptr<aggregate_node_impl_t> const& arg_node_ptr);
+
+  template <class NodeImpl>
+  void add_node(std::shared_ptr<NodeImpl> const& arg_node_ptr);
+
+  template <class NodeImplPtr, class PredecessorRef>
+  void add_predecessor(NodeImplPtr arg_node_ptr, PredecessorRef arg_pred_ref);
+
+  void submit();
+
+  Kokkos::Experimental::SYCL const& get_execution_space() const noexcept;
+
+  auto create_root_node_ptr();
+
+  template <class... PredecessorRefs>
+  auto create_aggregate_ptr(PredecessorRefs&&...);
+
+ private:
+  void instantiate_graph() { m_graph_exec = m_graph.finalize(); }
+
+  Kokkos::Experimental::SYCL m_execution_space;
+  sycl::ext::oneapi::experimental::command_graph<
+      sycl::ext::oneapi::experimental::graph_state::modifiable>
+      m_graph;
+  std::optional<sycl::ext::oneapi::experimental::command_graph<
+      sycl::ext::oneapi::experimental::graph_state::executable>>
+      m_graph_exec;
+};
+
+inline GraphImpl<Kokkos::Experimental::SYCL>::~GraphImpl() {
+  m_execution_space.fence("Kokkos::GraphImpl::~GraphImpl: Graph Destruction");
+}
+
+inline GraphImpl<Kokkos::Experimental::SYCL>::GraphImpl(
+    Kokkos::Experimental::SYCL instance)
+    : m_execution_space(std::move(instance)),
+      m_graph(m_execution_space.sycl_queue().get_context(),
+              m_execution_space.sycl_queue().get_device()) {}
+
+inline void GraphImpl<Kokkos::Experimental::SYCL>::add_node(
+    std::shared_ptr<aggregate_node_impl_t> const& arg_node_ptr) {
+  // add an empty node that needs to be set up before finalizing the graph
+  arg_node_ptr->node_details_t::node = m_graph.add();
+}
+
+// Requires NodeImplPtr is a shared_ptr to specialization of GraphNodeImpl
+// Also requires that the kernel has the graph node tag in its policy
+template <class NodeImpl>
+inline void GraphImpl<Kokkos::Experimental::SYCL>::add_node(
+    std::shared_ptr<NodeImpl> const& arg_node_ptr) {
+  static_assert(NodeImpl::kernel_type::Policy::is_graph_kernel::value);
+  KOKKOS_EXPECTS(arg_node_ptr);
+  // The Kernel launch from the execute() method has been shimmed to insert
+  // the node into the graph
+  auto& kernel = arg_node_ptr->get_kernel();
+  auto& node   = static_cast<node_details_t*>(arg_node_ptr.get())->node;
+  KOKKOS_EXPECTS(!node);
+  kernel.set_sycl_graph_ptr(&m_graph);
+  kernel.set_sycl_graph_node_ptr(&node);
+  kernel.execute();
+  KOKKOS_ENSURES(node);
+}
+
+// Requires PredecessorRef is a specialization of GraphNodeRef that has
+// already been added to this graph and NodeImpl is a specialization of
+// GraphNodeImpl that has already been added to this graph.
+template <class NodeImplPtr, class PredecessorRef>
+inline void GraphImpl<Kokkos::Experimental::SYCL>::add_predecessor(
+    NodeImplPtr arg_node_ptr, PredecessorRef arg_pred_ref) {
+  KOKKOS_EXPECTS(arg_node_ptr);
+  auto pred_ptr = GraphAccess::get_node_ptr(arg_pred_ref);
+  KOKKOS_EXPECTS(pred_ptr);
+
+  auto& pred_node = pred_ptr->node_details_t::node;
+  KOKKOS_EXPECTS(pred_node);
+
+  auto& node = arg_node_ptr->node_details_t::node;
+  KOKKOS_EXPECTS(node);
+
+  m_graph.make_edge(*pred_node, *node);
+}
+
+inline void GraphImpl<Kokkos::Experimental::SYCL>::submit() {
+  if (!m_graph_exec) {
+    instantiate_graph();
+  }
+  m_execution_space.sycl_queue().ext_oneapi_graph(*m_graph_exec);
+}
+
+inline Kokkos::Experimental::SYCL const&
+GraphImpl<Kokkos::Experimental::SYCL>::get_execution_space() const noexcept {
+  return m_execution_space;
+}
+
+inline auto GraphImpl<Kokkos::Experimental::SYCL>::create_root_node_ptr() {
+  KOKKOS_EXPECTS(!m_graph_exec);
+  auto rv = std::make_shared<root_node_impl_t>(get_execution_space(),
+                                               _graph_node_is_root_ctor_tag{});
+  rv->node_details_t::node = m_graph.add();
+  return rv;
+}
+
+template <class... PredecessorRefs>
+inline auto GraphImpl<Kokkos::Experimental::SYCL>::create_aggregate_ptr(
+    PredecessorRefs&&...) {
+  // The attachment to predecessors, which is all we really need, happens
+  // in the generic layer, which calls through to add_predecessor for
+  // each predecessor ref, so all we need to do here is create the (trivial)
+  // aggregate node.
+  return std::make_shared<aggregate_node_impl_t>(m_execution_space,
+                                                 _graph_node_kernel_ctor_tag{},
+                                                 aggregate_kernel_impl_t{});
+}
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Half_Conversion.hpp b/core/src/SYCL/Kokkos_SYCL_Half_Conversion.hpp
index d7b0271e15..14a39fc5da 100644
--- a/core/src/SYCL/Kokkos_SYCL_Half_Conversion.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Half_Conversion.hpp
@@ -53,55 +53,55 @@ half_t cast_to_half(unsigned long val) { return half_t::impl_type(val); }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, float>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, double>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, short>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION
     std::enable_if_t<std::is_same<T, unsigned short>::value, T>
     cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, int>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, unsigned int>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long long>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION
     std::enable_if_t<std::is_same<T, unsigned long long>::value, T>
     cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long>::value, T>
 cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 template <class T>
 KOKKOS_INLINE_FUNCTION
     std::enable_if_t<std::is_same<T, unsigned long>::value, T>
     cast_from_half(half_t val) {
-  return half_t::impl_type(val);
+  return static_cast<T>(half_t::impl_type(val));
 }
 }  // namespace Experimental
 
@@ -128,4 +128,112 @@ struct reduction_identity<Kokkos::Experimental::half_t> {
 
 }  // namespace Kokkos
 #endif  // KOKKOS_IMPL_SYCL_HALF_TYPE_DEFINED
+
+#ifdef KOKKOS_IMPL_SYCL_BHALF_TYPE_DEFINED
+
+namespace Kokkos {
+namespace Experimental {
+
+/************************** bhalf conversions *********************************/
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(bhalf_t val) { return val; }
+
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(float val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(double val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(short val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned short val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(int val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned int val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(long long val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned long long val) {
+  return bhalf_t::impl_type(val);
+}
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(long val) { return bhalf_t::impl_type(val); }
+KOKKOS_INLINE_FUNCTION
+bhalf_t cast_to_bhalf(unsigned long val) { return bhalf_t::impl_type(val); }
+
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, float>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, double>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, short>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned short>::value, T>
+    cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, int>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, unsigned int>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long long>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned long long>::value, T>
+    cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION std::enable_if_t<std::is_same<T, long>::value, T>
+cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+template <class T>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<std::is_same<T, unsigned long>::value, T>
+    cast_from_bhalf(bhalf_t val) {
+  return static_cast<T>(bhalf_t::impl_type(val));
+}
+}  // namespace Experimental
+
+// sycl::bfloat16 doesn't have constexpr constructors so we return float
+template <>
+struct reduction_identity<Kokkos::Experimental::bhalf_t> {
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float sum() noexcept {
+    return 0.f;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float prod() noexcept {
+    return 1.0f;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float max() noexcept {
+    return -0x7f7f;
+  }
+  KOKKOS_FORCEINLINE_FUNCTION constexpr static float min() noexcept {
+    return 0x7f7f;
+  }
+};
+
+}  // namespace Kokkos
+#endif  // KOKKOS_IMPL_SYCL_BHALF_TYPE_DEFINED
+
 #endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Half_Impl_Type.hpp b/core/src/SYCL/Kokkos_SYCL_Half_Impl_Type.hpp
index 8932c15883..1c0a0d94df 100644
--- a/core/src/SYCL/Kokkos_SYCL_Half_Impl_Type.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Half_Impl_Type.hpp
@@ -18,7 +18,6 @@
 #define KOKKOS_SYCL_HALF_IMPL_TYPE_HPP_
 
 #include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_SYCL
 
 // FIXME_SYCL
 #if __has_include(<sycl/sycl.hpp>)
@@ -27,18 +26,40 @@
 #include <CL/sycl.hpp>
 #endif
 
-#ifndef KOKKOS_IMPL_HALF_TYPE_DEFINED
 // Make sure no one else tries to define half_t
+#ifndef KOKKOS_IMPL_HALF_TYPE_DEFINED
 #define KOKKOS_IMPL_HALF_TYPE_DEFINED
 #define KOKKOS_IMPL_SYCL_HALF_TYPE_DEFINED
 
-namespace Kokkos {
-namespace Impl {
+namespace Kokkos::Impl {
 struct half_impl_t {
   using type = sycl::half;
 };
-}  // namespace Impl
-}  // namespace Kokkos
+}  // namespace Kokkos::Impl
 #endif  // KOKKOS_IMPL_HALF_TYPE_DEFINED
-#endif  // KOKKOS_ENABLE_SYCL
-#endif
+
+// Make sure no one else tries to define bhalf_t
+#ifndef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+// FIXME_SYCL Evaluate when to drop the check
+#if __has_include(<sycl/ext/oneapi/bfloat16.hpp>)
+#define KOKKOS_IMPL_BHALF_TYPE_DEFINED
+#define KOKKOS_IMPL_SYCL_BHALF_TYPE_DEFINED
+namespace Kokkos::Impl {
+struct bhalf_impl_t {
+  using type = sycl::ext::oneapi::bfloat16;
+};
+}  // namespace Kokkos::Impl
+#elif defined(SYCL_EXT_ONEAPI_BFLOAT16) && defined(KOKKOS_ARCH_INTEL_GPU)
+// FIXME_SYCL bfloat16 is only supported for compute capability 8.0 or higher
+// on Nvidia GPUs but SYCL_EXT_ONEAPI_BFLOAT16 is defined even for lower compute
+// capability.
+#define KOKKOS_IMPL_BHALF_TYPE_DEFINED
+#define KOKKOS_IMPL_SYCL_BHALF_TYPE_DEFINED
+namespace Kokkos::Impl {
+struct bhalf_impl_t {
+  using type = sycl::ext::oneapi::experimental::bfloat16;
+};
+}  // namespace Kokkos::Impl
+#endif  // test for bfloat16 support
+#endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
+#endif  // KOKKOS_SYCL_HALF_IMPL_TYPE_HPP_
diff --git a/core/src/SYCL/Kokkos_SYCL_Instance.cpp b/core/src/SYCL/Kokkos_SYCL_Instance.cpp
index 472baed744..5843dca812 100644
--- a/core/src/SYCL/Kokkos_SYCL_Instance.cpp
+++ b/core/src/SYCL/Kokkos_SYCL_Instance.cpp
@@ -20,10 +20,25 @@
 
 #include <Kokkos_Core.hpp>  //kokkos_malloc
 
+#include <impl/Kokkos_CheckedIntegerOps.hpp>
+#include <impl/Kokkos_Error.hpp>
+
 namespace Kokkos {
 namespace Experimental {
 namespace Impl {
 
+namespace {
+
+// FIXME_SYCL Should be a multiple of the maximum subgroup size.
+static constexpr auto sizeScratchGrain =
+    sizeof(Kokkos::Experimental::SYCL::size_type[32]);
+
+std::size_t scratch_count(const std::size_t size) {
+  return (size + sizeScratchGrain - 1) / sizeScratchGrain;
+}
+
+}  // namespace
+
 std::vector<std::optional<sycl::queue>*> SYCLInternal::all_queues;
 std::mutex SYCLInternal::mutex;
 
@@ -39,7 +54,7 @@ Kokkos::View<uint32_t*, SYCLDeviceUSMSpace> sycl_global_unique_token_locks(
 }
 
 SYCLInternal::~SYCLInternal() {
-  if (!was_finalized || m_scratchSpace || m_scratchFlags) {
+  if (!was_finalized || m_scratchSpace || m_scratchHost || m_scratchFlags) {
     std::cerr << "Kokkos::Experimental::SYCL ERROR: Failed to call "
                  "Kokkos::Experimental::SYCL::finalize()"
               << std::endl;
@@ -75,9 +90,7 @@ 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)
+#ifdef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
   initialize(
       sycl::queue{d, exception_handler, sycl::property::queue::in_order()});
 #else
@@ -87,51 +100,48 @@ void SYCLInternal::initialize(const sycl::device& d) {
 
 // FIXME_SYCL
 void SYCLInternal::initialize(const sycl::queue& q) {
+  KOKKOS_EXPECTS(!is_initialized());
+
+#define KOKKOS_IMPL_CHECK_SYCL_BACKEND_SUPPORT(BACKEND, REQUIRED)            \
+  if (BACKEND != REQUIRED)                                                   \
+  Kokkos::abort(                                                             \
+      "The SYCL execution space instance was initialized with an "           \
+      "unsupported backend type! For this GPU architecture, only " #REQUIRED \
+      " is supported.")
+#if defined(KOKKOS_ARCH_INTEL_GPU)
+  KOKKOS_IMPL_CHECK_SYCL_BACKEND_SUPPORT(q.get_backend(),
+                                         sycl::backend::ext_oneapi_level_zero);
+#elif defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  KOKKOS_IMPL_CHECK_SYCL_BACKEND_SUPPORT(q.get_backend(),
+                                         sycl::backend::ext_oneapi_cuda);
+#elif defined(KOKKOS_ARCH_AMD_GPU)
+  KOKKOS_IMPL_CHECK_SYCL_BACKEND_SUPPORT(q.get_backend(),
+                                         sycl::backend::ext_oneapi_hip);
+#endif
+
   if (was_finalized)
     Kokkos::abort("Calling SYCL::initialize after SYCL::finalize is illegal\n");
 
-  if (is_initialized()) return;
-
-  if (!HostSpace::execution_space::impl_is_initialized()) {
-    const std::string msg(
-        "SYCL::initialize ERROR : HostSpace::execution_space is not "
-        "initialized");
-    Kokkos::Impl::throw_runtime_exception(msg);
+  m_queue = q;
+  // guard pushing to all_queues
+  {
+    std::scoped_lock lock(mutex);
+    all_queues.push_back(&m_queue);
   }
+  const sycl::device& d = m_queue->get_device();
 
-  const bool ok_init = nullptr == m_scratchSpace || nullptr == m_scratchFlags;
-  const bool ok_dev  = true;
-  if (ok_init && ok_dev) {
-    m_queue = q;
-    // guard pushing to all_queues
-    {
-      std::scoped_lock lock(mutex);
-      all_queues.push_back(&m_queue);
-    }
-    const sycl::device& d = m_queue->get_device();
-
-    m_maxWorkgroupSize =
-        d.template get_info<sycl::info::device::max_work_group_size>();
-    // FIXME_SYCL this should give the correct value for NVIDIA GPUs
-    m_maxConcurrency =
-        m_maxWorkgroupSize * 2 *
-        d.template get_info<sycl::info::device::max_compute_units>();
+  m_maxWorkgroupSize =
+      d.template get_info<sycl::info::device::max_work_group_size>();
+  // FIXME_SYCL this should give the correct value for NVIDIA GPUs
+  m_maxConcurrency =
+      m_maxWorkgroupSize * 2 *
+      d.template get_info<sycl::info::device::max_compute_units>();
 
-    m_maxShmemPerBlock =
-        d.template get_info<sycl::info::device::local_mem_size>();
+  m_maxShmemPerBlock =
+      d.template get_info<sycl::info::device::local_mem_size>();
 
-    for (auto& usm_mem : m_indirectKernelMem) {
-      usm_mem.reset(*m_queue, m_instance_id);
-    }
-
-  } else {
-    std::ostringstream msg;
-    msg << "Kokkos::Experimental::SYCL::initialize(...) FAILED";
-
-    if (!ok_init) {
-      msg << " : Already initialized";
-    }
-    Kokkos::Impl::throw_runtime_exception(msg.str());
+  for (auto& usm_mem : m_indirectKernelMem) {
+    usm_mem.reset(*m_queue, m_instance_id);
   }
 
 #ifdef KOKKOS_IMPL_SYCL_DEVICE_GLOBAL_SUPPORTED
@@ -156,26 +166,27 @@ int SYCLInternal::acquire_team_scratch_space() {
   return current_team_scratch;
 }
 
-sycl::device_ptr<void> SYCLInternal::resize_team_scratch_space(
+Kokkos::Impl::sycl_device_ptr<void> SYCLInternal::resize_team_scratch_space(
     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) {
+  auto mem_space = Kokkos::Experimental::SYCLDeviceUSMSpace(*m_queue);
+  if (m_team_scratch_current_size[scratch_pool_id] == 0 && bytes > 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[scratch_pool_id]);
+    m_team_scratch_ptr[scratch_pool_id]          = mem_space.allocate(
+        "Kokkos::Experimental::SYCL::InternalTeamScratchMemory",
+        m_team_scratch_current_size[scratch_pool_id]);
   }
   if ((bytes > m_team_scratch_current_size[scratch_pool_id]) ||
       ((bytes < m_team_scratch_current_size[scratch_pool_id]) &&
        (force_shrink))) {
+    mem_space.deallocate(m_team_scratch_ptr[scratch_pool_id],
+                         m_team_scratch_current_size[scratch_pool_id]);
     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[scratch_pool_id],
-            m_team_scratch_current_size[scratch_pool_id]);
+    m_team_scratch_ptr[scratch_pool_id]          = mem_space.allocate(
+        "Kokkos::Experimental::SYCL::InternalTeamScratchMemory",
+        m_team_scratch_current_size[scratch_pool_id]);
   }
   return m_team_scratch_ptr[scratch_pool_id];
 }
@@ -203,21 +214,29 @@ void SYCLInternal::finalize() {
 #endif
   }
 
-  using RecordSYCL = Kokkos::Impl::SharedAllocationRecord<SYCLDeviceUSMSpace>;
+  auto device_mem_space = SYCLDeviceUSMSpace(*m_queue);
+  auto host_mem_space   = SYCLHostUSMSpace(*m_queue);
   if (nullptr != m_scratchSpace)
-    RecordSYCL::decrement(RecordSYCL::get_record(m_scratchSpace));
+    device_mem_space.deallocate(m_scratchSpace,
+                                m_scratchSpaceCount * sizeScratchGrain);
+  if (nullptr != m_scratchHost)
+    host_mem_space.deallocate(m_scratchHost,
+                              m_scratchHostCount * sizeScratchGrain);
   if (nullptr != m_scratchFlags)
-    RecordSYCL::decrement(RecordSYCL::get_record(m_scratchFlags));
+    device_mem_space.deallocate(m_scratchFlags,
+                                m_scratchFlagsCount * sizeScratchGrain);
   m_syclDev           = -1;
   m_scratchSpaceCount = 0;
   m_scratchSpace      = nullptr;
+  m_scratchHostCount  = 0;
+  m_scratchHost       = nullptr;
   m_scratchFlagsCount = 0;
   m_scratchFlags      = 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]);
+      device_mem_space.deallocate(m_team_scratch_ptr[i],
+                                  m_team_scratch_current_size[i]);
       m_team_scratch_current_size[i] = 0;
       m_team_scratch_ptr[i]          = nullptr;
     }
@@ -232,57 +251,74 @@ void SYCLInternal::finalize() {
   m_queue.reset();
 }
 
-sycl::device_ptr<void> SYCLInternal::scratch_space(const std::size_t size) {
-  const size_type sizeScratchGrain =
-      sizeof(Kokkos::Experimental::SYCL::size_type);
+Kokkos::Impl::sycl_device_ptr<void> SYCLInternal::scratch_space(
+    const std::size_t size) {
   if (verify_is_initialized("scratch_space") &&
-      m_scratchSpaceCount * sizeScratchGrain < size) {
-    m_scratchSpaceCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
-
-    using Record = Kokkos::Impl::SharedAllocationRecord<
-        Kokkos::Experimental::SYCLDeviceUSMSpace, void>;
+      m_scratchSpaceCount < scratch_count(size)) {
+    auto mem_space = Kokkos::Experimental::SYCLDeviceUSMSpace(*m_queue);
 
     if (nullptr != m_scratchSpace)
-      Record::decrement(Record::get_record(m_scratchSpace));
+      mem_space.deallocate(m_scratchSpace,
+                           m_scratchSpaceCount * sizeScratchGrain);
 
-    Record* const r =
-        Record::allocate(Kokkos::Experimental::SYCLDeviceUSMSpace(*m_queue),
-                         "Kokkos::Experimental::SYCL::InternalScratchSpace",
-                         (sizeScratchGrain * m_scratchSpaceCount));
+    m_scratchSpaceCount = scratch_count(size);
 
-    Record::increment(r);
-
-    m_scratchSpace = reinterpret_cast<size_type*>(r->data());
+    std::size_t alloc_size = Kokkos::Impl::multiply_overflow_abort(
+        m_scratchSpaceCount, sizeScratchGrain);
+    m_scratchSpace = static_cast<size_type*>(mem_space.allocate(
+        "Kokkos::Experimental::SYCL::InternalScratchSpace", alloc_size));
   }
 
   return m_scratchSpace;
 }
 
-sycl::device_ptr<void> SYCLInternal::scratch_flags(const std::size_t size) {
-  const size_type sizeScratchGrain =
-      sizeof(Kokkos::Experimental::SYCL::size_type);
-  if (verify_is_initialized("scratch_flags") &&
-      m_scratchFlagsCount * sizeScratchGrain < size) {
-    m_scratchFlagsCount = (size + sizeScratchGrain - 1) / sizeScratchGrain;
+Kokkos::Impl::sycl_host_ptr<void> SYCLInternal::scratch_host(
+    const std::size_t size) {
+  if (verify_is_initialized("scratch_unified") &&
+      m_scratchHostCount < scratch_count(size)) {
+    auto mem_space = Kokkos::Experimental::SYCLHostUSMSpace(*m_queue);
 
-    using Record = Kokkos::Impl::SharedAllocationRecord<
-        Kokkos::Experimental::SYCLDeviceUSMSpace, void>;
+    if (nullptr != m_scratchHost)
+      mem_space.deallocate(m_scratchHost,
+                           m_scratchHostCount * sizeScratchGrain);
 
-    if (nullptr != m_scratchFlags)
-      Record::decrement(Record::get_record(m_scratchFlags));
+    m_scratchHostCount = scratch_count(size);
 
-    Record* const r =
-        Record::allocate(Kokkos::Experimental::SYCLDeviceUSMSpace(*m_queue),
-                         "Kokkos::Experimental::SYCL::InternalScratchFlags",
-                         (sizeScratchGrain * m_scratchFlagsCount));
+    std::size_t alloc_size = Kokkos::Impl::multiply_overflow_abort(
+        m_scratchHostCount, sizeScratchGrain);
+    m_scratchHost = static_cast<size_type*>(mem_space.allocate(
+        "Kokkos::Experimental::SYCL::InternalScratchHost", alloc_size));
+  }
+
+  return m_scratchHost;
+}
 
-    Record::increment(r);
+Kokkos::Impl::sycl_device_ptr<void> SYCLInternal::scratch_flags(
+    const std::size_t size) {
+  if (verify_is_initialized("scratch_flags") &&
+      m_scratchFlagsCount < scratch_count(size)) {
+    auto mem_space = Kokkos::Experimental::SYCLDeviceUSMSpace(*m_queue);
 
-    m_scratchFlags = reinterpret_cast<size_type*>(r->data());
+    if (nullptr != m_scratchFlags)
+      mem_space.deallocate(m_scratchFlags,
+                           m_scratchFlagsCount * sizeScratchGrain);
+
+    m_scratchFlagsCount = scratch_count(size);
+
+    std::size_t alloc_size = Kokkos::Impl::multiply_overflow_abort(
+        m_scratchFlagsCount, sizeScratchGrain);
+    m_scratchFlags = static_cast<size_type*>(mem_space.allocate(
+        "Kokkos::Experimental::SYCL::InternalScratchFlags", alloc_size));
+
+    // We only zero-initialize the allocation when we actually allocate.
+    // It's the responsibility of the features using scratch_flags,
+    // namely parallel_reduce and parallel_scan, to reset the used values to 0.
+    auto memset_event = m_queue->memset(m_scratchFlags, 0,
+                                        m_scratchFlagsCount * sizeScratchGrain);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+    m_queue->ext_oneapi_submit_barrier(std::vector{memset_event});
+#endif
   }
-  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;
 }
@@ -325,15 +361,12 @@ size_t SYCLInternal::USMObjectMem<Kind>::reserve(size_t n) {
   assert(m_q);
 
   if (m_capacity < n) {
-    using Record = Kokkos::Impl::SharedAllocationRecord<AllocationSpace, void>;
-    // First free what we have (in case malloc can reuse it)
-    if (m_data) Record::decrement(Record::get_record(m_data));
+    AllocationSpace alloc_space(*m_q);
+    if (m_data) alloc_space.deallocate(m_data, m_capacity);
 
-    Record* const r = Record::allocate(
-        AllocationSpace(*m_q), "Kokkos::Experimental::SYCL::USMObjectMem", n);
-    Record::increment(r);
+    m_data =
+        alloc_space.allocate("Kokkos::Experimental::SYCL::USMObjectMem", n);
 
-    m_data = r->data();
     if constexpr (sycl::usm::alloc::device == Kind)
       m_staging.reset(new char[n]);
     m_capacity = n;
@@ -347,8 +380,8 @@ void SYCLInternal::USMObjectMem<Kind>::reset() {
   if (m_data) {
     // This implies a fence since this class is not copyable
     // and deallocating implies a fence across all registered queues.
-    using Record = Kokkos::Impl::SharedAllocationRecord<AllocationSpace, void>;
-    Record::decrement(Record::get_record(m_data));
+    AllocationSpace alloc_space(*m_q);
+    alloc_space.deallocate(m_data, m_capacity);
 
     m_capacity = 0;
     m_data     = nullptr;
diff --git a/core/src/SYCL/Kokkos_SYCL_Instance.hpp b/core/src/SYCL/Kokkos_SYCL_Instance.hpp
index 51a617054d..2d784ef8a5 100644
--- a/core/src/SYCL/Kokkos_SYCL_Instance.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Instance.hpp
@@ -43,12 +43,12 @@ class SYCLInternal {
   SYCLInternal& operator=(SYCLInternal&&) = delete;
   SYCLInternal(SYCLInternal&&)            = delete;
 
-  sycl::device_ptr<void> scratch_space(const std::size_t size);
-  sycl::device_ptr<void> scratch_flags(const std::size_t size);
+  Kokkos::Impl::sycl_device_ptr<void> scratch_space(const std::size_t size);
+  Kokkos::Impl::sycl_device_ptr<void> scratch_flags(const std::size_t size);
+  Kokkos::Impl::sycl_host_ptr<void> scratch_host(const std::size_t size);
   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);
+  Kokkos::Impl::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;
@@ -58,19 +58,22 @@ class SYCLInternal {
   uint32_t m_maxConcurrency   = 0;
   uint64_t m_maxShmemPerBlock = 0;
 
-  std::size_t m_scratchSpaceCount            = 0;
-  sycl::device_ptr<size_type> m_scratchSpace = nullptr;
-  std::size_t m_scratchFlagsCount            = 0;
-  sycl::device_ptr<size_type> m_scratchFlags = nullptr;
+  std::size_t m_scratchSpaceCount                         = 0;
+  Kokkos::Impl::sycl_device_ptr<size_type> m_scratchSpace = nullptr;
+  std::size_t m_scratchHostCount                          = 0;
+  Kokkos::Impl::sycl_host_ptr<size_type> m_scratchHost    = nullptr;
+  std::size_t m_scratchFlagsCount                         = 0;
+  Kokkos::Impl::sycl_device_ptr<size_type> m_scratchFlags = nullptr;
   // mutex to access shared memory
   mutable std::mutex m_mutexScratchSpace;
 
   // 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]          = {};
+  static constexpr int m_n_team_scratch                         = 10;
+  mutable int64_t m_team_scratch_current_size[m_n_team_scratch] = {};
+  mutable Kokkos::Impl::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<
@@ -330,8 +333,8 @@ 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.
+#if (defined(__INTEL_LLVM_COMPILER) && __INTEL_LLVM_COMPILER < 20240000) || \
+    (defined(__LIBSYCL_MAJOR_VERSION) && __LIBSYCL_MAJOR_VERSION < 7)
 template <typename>
 struct NonTriviallyCopyableAndDeviceCopyable {
   NonTriviallyCopyableAndDeviceCopyable(
@@ -356,3 +359,4 @@ struct sycl::is_device_copyable<
     : std::true_type {};
 #endif
 #endif
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Range.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelFor_MDRange.hpp
similarity index 58%
rename from core/src/SYCL/Kokkos_SYCL_Parallel_Range.hpp
rename to core/src/SYCL/Kokkos_SYCL_ParallelFor_MDRange.hpp
index 73475f92a6..cb7b1048da 100644
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Range.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelFor_MDRange.hpp
@@ -14,132 +14,15 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_SYCL_PARALLEL_RANGE_HPP_
-#define KOKKOS_SYCL_PARALLEL_RANGE_HPP_
+#ifndef KOKKOS_SYCL_PARALLEL_FOR_MDRANGE_HPP_
+#define KOKKOS_SYCL_PARALLEL_FOR_MDRANGE_HPP_
 
 #include <impl/KokkosExp_IterateTileGPU.hpp>
 
+#ifdef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
 #include <vector>
-
-namespace Kokkos::Impl {
-template <typename FunctorWrapper, typename Policy>
-struct FunctorWrapperRangePolicyParallelFor {
-  using WorkTag = typename Policy::work_tag;
-
-  void operator()(sycl::item<1> item) const {
-    const typename Policy::index_type id = item.get_linear_id() + m_begin;
-    if constexpr (std::is_void_v<WorkTag>)
-      m_functor_wrapper.get_functor()(id);
-    else
-      m_functor_wrapper.get_functor()(WorkTag(), id);
-  }
-
-  typename Policy::index_type m_begin;
-  FunctorWrapper m_functor_wrapper;
-};
-
-// Same as above but for a user-provided workgroup size
-template <typename FunctorWrapper, typename Policy>
-struct FunctorWrapperRangePolicyParallelForCustom {
-  using WorkTag = typename Policy::work_tag;
-
-  void operator()(sycl::item<1> item) const {
-    const typename Policy::index_type id = item.get_linear_id();
-    if (id < m_work_size) {
-      const auto shifted_id = id + m_begin;
-      if constexpr (std::is_void_v<WorkTag>)
-        m_functor_wrapper.get_functor()(shifted_id);
-      else
-        m_functor_wrapper.get_functor()(WorkTag(), shifted_id);
-    }
-  }
-
-  typename Policy::index_type m_begin;
-  FunctorWrapper m_functor_wrapper;
-  typename Policy::index_type m_work_size;
-};
-}  // namespace Kokkos::Impl
+#endif
 
-template <class FunctorType, class... Traits>
-class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
-                                Kokkos::Experimental::SYCL> {
- public:
-  using Policy = Kokkos::RangePolicy<Traits...>;
-
- private:
-  using Member  = typename Policy::member_type;
-  using WorkTag = typename Policy::work_tag;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  template <typename Functor>
-  static sycl::event sycl_direct_launch(const Policy& policy,
-                                        const Functor& functor,
-                                        const sycl::event& memcpy_event) {
-    // Convenience references
-    const Kokkos::Experimental::SYCL& space = policy.space();
-    sycl::queue& q                          = space.sycl_queue();
-
-    auto parallel_for_event = q.submit([&](sycl::handler& cgh) {
-      cgh.depends_on(memcpy_event);
-      if (policy.chunk_size() <= 1) {
-        FunctorWrapperRangePolicyParallelFor<Functor, Policy> f{policy.begin(),
-                                                                functor};
-        sycl::range<1> range(policy.end() - policy.begin());
-        cgh.parallel_for<FunctorWrapperRangePolicyParallelFor<Functor, Policy>>(
-            range, f);
-      } else {
-        // Use the chunk size as workgroup size. We need to make sure that the
-        // range the kernel is launched with is a multiple of the workgroup
-        // size. Hence, we need to restrict the execution of the functor in the
-        // kernel to the actual range.
-        const auto actual_range = policy.end() - policy.begin();
-        const auto wgroup_size  = policy.chunk_size();
-        const auto launch_range =
-            (actual_range + wgroup_size - 1) / wgroup_size * wgroup_size;
-        FunctorWrapperRangePolicyParallelForCustom<Functor, Policy> f{
-            policy.begin(), functor, actual_range};
-        sycl::nd_range<1> range(launch_range, wgroup_size);
-        cgh.parallel_for<
-            FunctorWrapperRangePolicyParallelForCustom<Functor, Policy>>(range,
-                                                                         f);
-      }
-    });
-    q.ext_oneapi_submit_barrier(std::vector<sycl::event>{parallel_for_event});
-
-    return parallel_for_event;
-  }
-
- public:
-  using functor_type = FunctorType;
-
-  void execute() const {
-    if (m_policy.begin() == m_policy.end()) return;
-
-    Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem&
-        indirectKernelMem = m_policy.space()
-                                .impl_internal_space_instance()
-                                ->get_indirect_kernel_mem();
-
-    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_functor, indirectKernelMem);
-    sycl::event event = sycl_direct_launch(m_policy, functor_wrapper,
-                                           functor_wrapper.get_copy_event());
-    functor_wrapper.register_event(event);
-  }
-
-  ParallelFor(const ParallelFor&) = delete;
-  ParallelFor(ParallelFor&&)      = delete;
-  ParallelFor& operator=(const ParallelFor&) = delete;
-  ParallelFor& operator=(ParallelFor&&) = delete;
-  ~ParallelFor()                        = default;
-
-  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-};
-
-// ParallelFor
 template <class FunctorType, class... Traits>
 class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
                                 Kokkos::Experimental::SYCL> {
@@ -235,7 +118,9 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
 
     const BarePolicy bare_policy(m_policy);
 
-    auto parallel_for_event = q.submit([&](sycl::handler& cgh) {
+    desul::ensure_sycl_lock_arrays_on_device(q);
+
+    auto cgh_lambda = [&](sycl::handler& cgh) {
       const auto range                  = compute_ranges();
       const sycl::range<3> global_range = range.get_global_range();
       const sycl::range<3> local_range  = range.get_local_range();
@@ -243,7 +128,11 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
           sycl::range<3>{global_range[2], global_range[1], global_range[0]},
           sycl::range<3>{local_range[2], local_range[1], local_range[0]}};
 
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
       cgh.depends_on(memcpy_event);
+#else
+      (void)memcpy_event;
+#endif
       cgh.parallel_for(sycl_swapped_range, [functor_wrapper, bare_policy](
                                                sycl::nd_item<3> item) {
         // swap back for correct index calculations in DeviceIterateTile
@@ -264,10 +153,22 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
             {global_x, global_y, global_z}, {local_x, local_y, local_z})
             .exec_range();
       });
-    });
-    q.ext_oneapi_submit_barrier(std::vector<sycl::event>{parallel_for_event});
-
-    return parallel_for_event;
+    };
+
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+    if constexpr (Policy::is_graph_kernel::value) {
+      sycl_attach_kernel_to_node(*this, cgh_lambda);
+      return {};
+    } else
+#endif
+    {
+      auto parallel_for_event = q.submit(cgh_lambda);
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+      q.ext_oneapi_submit_barrier(std::vector<sycl::event>{parallel_for_event});
+#endif
+      return parallel_for_event;
+    }
   }
 
  public:
@@ -290,16 +191,10 @@ class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
     functor_wrapper.register_event(event);
   }
 
-  ParallelFor(const ParallelFor&) = delete;
-  ParallelFor(ParallelFor&&)      = delete;
-  ParallelFor& operator=(const ParallelFor&) = delete;
-  ParallelFor& operator=(ParallelFor&&) = delete;
-  ~ParallelFor()                        = default;
-
   ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
       : m_functor(arg_functor),
         m_policy(arg_policy),
         m_space(arg_policy.space()) {}
 };
 
-#endif  // KOKKOS_SYCL_PARALLEL_RANGE_HPP_
+#endif  // KOKKOS_SYCL_PARALLEL_FOR_MDRANGE_HPP_
diff --git a/core/src/SYCL/Kokkos_SYCL_ParallelFor_Range.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelFor_Range.hpp
new file mode 100644
index 0000000000..8ef43d392c
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelFor_Range.hpp
@@ -0,0 +1,179 @@
+//@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_PARALLEL_FOR_RANGE_HPP_
+#define KOKKOS_SYCL_PARALLEL_FOR_RANGE_HPP_
+
+#ifdef SYCL_EXT_ONEAPI_AUTO_LOCAL_RANGE
+#include <Kokkos_BitManipulation.hpp>
+#endif
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+#include <vector>
+#endif
+
+namespace Kokkos::Impl {
+#ifndef SYCL_EXT_ONEAPI_AUTO_LOCAL_RANGE
+template <typename FunctorWrapper, typename Policy>
+struct FunctorWrapperRangePolicyParallelFor {
+  using WorkTag = typename Policy::work_tag;
+
+  void operator()(sycl::item<1> item) const {
+    const typename Policy::index_type id = item.get_linear_id() + m_begin;
+    if constexpr (std::is_void_v<WorkTag>)
+      m_functor_wrapper.get_functor()(id);
+    else
+      m_functor_wrapper.get_functor()(WorkTag(), id);
+  }
+
+  typename Policy::index_type m_begin;
+  FunctorWrapper m_functor_wrapper;
+};
+#endif
+
+// Same as above but for a user-provided workgroup size
+template <typename FunctorWrapper, typename Policy>
+struct FunctorWrapperRangePolicyParallelForCustom {
+  using WorkTag = typename Policy::work_tag;
+
+  void operator()(sycl::nd_item<1> item) const {
+    const typename Policy::index_type id = item.get_global_linear_id();
+    if (id < m_work_size) {
+      const auto shifted_id = id + m_begin;
+      if constexpr (std::is_void_v<WorkTag>)
+        m_functor_wrapper.get_functor()(shifted_id);
+      else
+        m_functor_wrapper.get_functor()(WorkTag(), shifted_id);
+    }
+  }
+
+  typename Policy::index_type m_begin;
+  FunctorWrapper m_functor_wrapper;
+  typename Policy::index_type m_work_size;
+};
+}  // namespace Kokkos::Impl
+
+template <class FunctorType, class... Traits>
+class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                                Kokkos::Experimental::SYCL> {
+ public:
+  using Policy = Kokkos::RangePolicy<Traits...>;
+
+ private:
+  using Member  = typename Policy::member_type;
+  using WorkTag = typename Policy::work_tag;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+  template <typename Functor>
+  sycl::event sycl_direct_launch(const Policy& policy, const Functor& functor,
+                                 const sycl::event& memcpy_event) const {
+    // Convenience references
+    const Kokkos::Experimental::SYCL& space = policy.space();
+    sycl::queue& q                          = space.sycl_queue();
+
+    desul::ensure_sycl_lock_arrays_on_device(q);
+
+    auto cgh_lambda = [&](sycl::handler& cgh) {
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+      cgh.depends_on(memcpy_event);
+#else
+      (void)memcpy_event;
+#endif
+
+      if (policy.chunk_size() <= 1) {
+#ifdef SYCL_EXT_ONEAPI_AUTO_LOCAL_RANGE
+        const auto actual_range = policy.end() - policy.begin();
+        FunctorWrapperRangePolicyParallelForCustom<Functor, Policy> f{
+            policy.begin(), functor, actual_range};
+        // Round the actual range up to the closest power of two not exceeding
+        // the maximum workgroup size
+        const auto max_wgroup_size =
+            q.get_device().get_info<sycl::info::device::max_work_group_size>();
+        const auto wgroup_size_multiple = Kokkos::bit_floor(
+            std::min<std::size_t>(max_wgroup_size, actual_range));
+
+        const auto launch_range = (actual_range + wgroup_size_multiple - 1) /
+                                  wgroup_size_multiple * wgroup_size_multiple;
+        sycl::nd_range<1> range(
+            launch_range, sycl::ext::oneapi::experimental::auto_range<1>());
+        cgh.parallel_for<
+            FunctorWrapperRangePolicyParallelForCustom<Functor, Policy>>(range,
+                                                                         f);
+#else
+        FunctorWrapperRangePolicyParallelFor<Functor, Policy> f{policy.begin(),
+                                                                functor};
+        sycl::range<1> range(policy.end() - policy.begin());
+        cgh.parallel_for<FunctorWrapperRangePolicyParallelFor<Functor, Policy>>(
+            range, f);
+#endif
+      } else {
+        // Use the chunk size as workgroup size. We need to make sure that the
+        // range the kernel is launched with is a multiple of the workgroup
+        // size. Hence, we need to restrict the execution of the functor in the
+        // kernel to the actual range.
+        const auto actual_range = policy.end() - policy.begin();
+        const auto wgroup_size  = policy.chunk_size();
+        const auto launch_range =
+            (actual_range + wgroup_size - 1) / wgroup_size * wgroup_size;
+        FunctorWrapperRangePolicyParallelForCustom<Functor, Policy> f{
+            policy.begin(), functor, actual_range};
+        sycl::nd_range<1> range(launch_range, wgroup_size);
+        cgh.parallel_for<
+            FunctorWrapperRangePolicyParallelForCustom<Functor, Policy>>(range,
+                                                                         f);
+      }
+    };
+
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+    if constexpr (Policy::is_graph_kernel::value) {
+      sycl_attach_kernel_to_node(*this, cgh_lambda);
+      return {};
+    } else
+#endif
+    {
+      auto parallel_for_event = q.submit(cgh_lambda);
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+      q.ext_oneapi_submit_barrier(std::vector<sycl::event>{parallel_for_event});
+#endif
+      return parallel_for_event;
+    }
+  }
+
+ public:
+  using functor_type = FunctorType;
+
+  void execute() const {
+    if (m_policy.begin() == m_policy.end()) return;
+
+    Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem&
+        indirectKernelMem = m_policy.space()
+                                .impl_internal_space_instance()
+                                ->get_indirect_kernel_mem();
+
+    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
+        m_functor, indirectKernelMem);
+    sycl::event event = sycl_direct_launch(m_policy, functor_wrapper,
+                                           functor_wrapper.get_copy_event());
+    functor_wrapper.register_event(event);
+  }
+
+  ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+};
+
+#endif  // KOKKOS_SYCL_PARALLEL_FOR_RANGE_HPP_
diff --git a/core/src/SYCL/Kokkos_SYCL_ParallelFor_Team.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelFor_Team.hpp
new file mode 100644
index 0000000000..cf7f582bc7
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelFor_Team.hpp
@@ -0,0 +1,200 @@
+//@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_PARALLEL_FOR_TEAM_HPP
+#define KOKKOS_SYCL_PARALLEL_FOR_TEAM_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <SYCL/Kokkos_SYCL_Team.hpp>
+#include <SYCL/Kokkos_SYCL_TeamPolicy.hpp>
+
+#include <sstream>
+#include <vector>
+
+template <typename FunctorType, typename... Properties>
+class Kokkos::Impl::ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
+                                Kokkos::Experimental::SYCL> {
+ public:
+  using Policy       = TeamPolicy<Properties...>;
+  using functor_type = FunctorType;
+  using size_type    = ::Kokkos::Experimental::SYCL::size_type;
+
+ private:
+  using member_type   = typename Policy::member_type;
+  using work_tag      = typename Policy::work_tag;
+  using launch_bounds = typename Policy::launch_bounds;
+
+  FunctorType const m_functor;
+  Policy const m_policy;
+  size_type const m_league_size;
+  int m_team_size;
+  size_type const m_vector_size;
+  int m_shmem_begin;
+  int m_shmem_size;
+  size_t m_scratch_size[2];
+
+  template <typename FunctorWrapper>
+  sycl::event sycl_direct_launch(const sycl_device_ptr<char> global_scratch_ptr,
+                                 const FunctorWrapper& functor_wrapper,
+                                 const sycl::event& memcpy_event) const {
+    // Convenience references
+    const Kokkos::Experimental::SYCL& space = m_policy.space();
+    sycl::queue& q                          = space.sycl_queue();
+
+    desul::ensure_sycl_lock_arrays_on_device(q);
+
+    auto cgh_lambda = [&](sycl::handler& cgh) {
+      // FIXME_SYCL accessors seem to need a size greater than zero at least for
+      // host queues
+      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]};
+
+      auto lambda = [=](sycl::nd_item<2> item) {
+        const member_type team_member(
+            KOKKOS_IMPL_SYCL_GET_MULTI_PTR(team_scratch_memory_L0), shmem_begin,
+            scratch_size[0],
+            global_scratch_ptr + item.get_group(1) * scratch_size[1],
+            scratch_size[1], item, item.get_group_linear_id(),
+            item.get_group_range(1));
+        if constexpr (std::is_void<work_tag>::value)
+          functor_wrapper.get_functor()(team_member);
+        else
+          functor_wrapper.get_functor()(work_tag(), team_member);
+      };
+
+      static sycl::kernel kernel = [&] {
+        sycl::kernel_id functor_kernel_id =
+            sycl::get_kernel_id<decltype(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 max_sg_size =
+          kernel
+              .get_info<sycl::info::kernel_device_specific::max_sub_group_size>(
+                  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);
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+      cgh.depends_on(memcpy_event);
+#else
+      (void)memcpy_event;
+#endif
+      cgh.parallel_for(
+          sycl::nd_range<2>(
+              sycl::range<2>(m_team_size, m_league_size * final_vector_size),
+              sycl::range<2>(m_team_size, final_vector_size)),
+          lambda);
+    };
+
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+    if constexpr (Policy::is_graph_kernel::value) {
+      sycl_attach_kernel_to_node(*this, cgh_lambda);
+      return {};
+    } else
+#endif
+    {
+      auto parallel_for_event = q.submit(cgh_lambda);
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+      q.ext_oneapi_submit_barrier(std::vector<sycl::event>{parallel_for_event});
+#endif
+      return parallel_for_event;
+    }
+  }
+
+ public:
+  inline void execute() const {
+    if (m_league_size == 0) return;
+
+    auto& instance = *m_policy.space().impl_internal_space_instance();
+
+    // Only let one instance at a time resize the instance's scratch memory
+    // allocations.
+    std::scoped_lock<std::mutex> team_scratch_lock(
+        instance.m_team_scratch_mutex);
+
+    // Functor's reduce memory, team scan memory, and team shared memory depend
+    // upon team size.
+    int scratch_pool_id = instance.acquire_team_scratch_space();
+    const sycl_device_ptr<char> global_scratch_ptr =
+        static_cast<sycl_device_ptr<char>>(instance.resize_team_scratch_space(
+            scratch_pool_id,
+            static_cast<ptrdiff_t>(m_scratch_size[1]) * m_league_size));
+
+    Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem&
+        indirectKernelMem = instance.get_indirect_kernel_mem();
+
+    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
+        m_functor, indirectKernelMem);
+
+    sycl::event event = sycl_direct_launch(global_scratch_ptr, functor_wrapper,
+                                           functor_wrapper.get_copy_event());
+    functor_wrapper.register_event(event);
+    instance.register_team_scratch_event(scratch_pool_id, event);
+  }
+
+  ParallelFor(FunctorType const& arg_functor, Policy const& arg_policy)
+      : m_functor(arg_functor),
+        m_policy(arg_policy),
+        m_league_size(arg_policy.league_size()),
+        m_team_size(arg_policy.team_size()),
+        m_vector_size(arg_policy.impl_vector_length()) {
+    // FIXME_SYCL optimize
+    if (m_team_size < 0)
+      m_team_size =
+          m_policy.team_size_recommended(arg_functor, ParallelForTag{});
+
+    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_scratch_size[0] = m_shmem_size;
+    m_scratch_size[1] = m_policy.scratch_size(1, m_team_size);
+
+    const auto& instance = *m_policy.space().impl_internal_space_instance();
+    if (static_cast<int>(instance.m_maxShmemPerBlock) <
+        m_shmem_size - m_shmem_begin) {
+      std::stringstream out;
+      out << "Kokkos::Impl::ParallelFor<SYCL> insufficient shared memory! "
+             "Requested "
+          << m_shmem_size - m_shmem_begin << " bytes but maximum is "
+          << instance.m_maxShmemPerBlock << '\n';
+      Kokkos::Impl::throw_runtime_exception(out.str());
+    }
+
+    const auto max_team_size =
+        m_policy.team_size_max(arg_functor, ParallelForTag{});
+    if (m_team_size > m_policy.team_size_max(arg_functor, ParallelForTag{}))
+      Kokkos::Impl::throw_runtime_exception(
+          "Kokkos::Impl::ParallelFor<SYCL> requested too large team size. The "
+          "maximal team_size is " +
+          std::to_string(max_team_size) + '!');
+  }
+};
+
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_ParallelReduce_MDRange.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelReduce_MDRange.hpp
new file mode 100644
index 0000000000..0774b24bca
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelReduce_MDRange.hpp
@@ -0,0 +1,378 @@
+//@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_PARALLEL_REDUCE_MDRANGE_HPP
+#define KOKKOS_SYCL_PARALLEL_REDUCE_MDRANGE_HPP
+
+#include <Kokkos_Macros.hpp>
+
+#include <Kokkos_Parallel_Reduce.hpp>
+#include <SYCL/Kokkos_SYCL_WorkgroupReduction.hpp>
+#include <Kokkos_BitManipulation.hpp>
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+#include <vector>
+#endif
+
+template <class CombinedFunctorReducerType, class... Traits>
+class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
+                                   Kokkos::MDRangePolicy<Traits...>,
+                                   Kokkos::Experimental::SYCL> {
+ public:
+  using Policy      = Kokkos::MDRangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+ private:
+  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;
+
+  // MDRangePolicy is not trivially copyable. Hence, replicate the data we
+  // really need in DeviceIterateTile in a trivially copyable struct.
+  struct BarePolicy {
+    using index_type = typename Policy::index_type;
+
+    BarePolicy(const Policy& policy)
+        : m_lower(policy.m_lower),
+          m_upper(policy.m_upper),
+          m_tile(policy.m_tile),
+          m_tile_end(policy.m_tile_end),
+          m_num_tiles(policy.m_num_tiles),
+          m_prod_tile_dims(policy.m_prod_tile_dims) {}
+
+    const typename Policy::point_type m_lower;
+    const typename Policy::point_type m_upper;
+    const typename Policy::tile_type m_tile;
+    const typename Policy::point_type m_tile_end;
+    const typename Policy::index_type m_num_tiles;
+    const typename Policy::index_type m_prod_tile_dims;
+    static constexpr Iterate inner_direction = Policy::inner_direction;
+    static constexpr int rank                = Policy::rank;
+  };
+
+ public:
+  // V - View
+  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 View::memory_space>::accessible) {}
+
+ private:
+  template <typename CombinedFunctorReducerWrapper>
+  sycl::event sycl_direct_launch(
+      const CombinedFunctorReducerWrapper& functor_reducer_wrapper,
+      const sycl::event& memcpy_event) const {
+    // Convenience references
+    Kokkos::Experimental::Impl::SYCLInternal& instance =
+        *m_space.impl_internal_space_instance();
+    sycl::queue& q = m_space.sycl_queue();
+
+    const typename Policy::index_type n_tiles = m_policy.m_num_tiles;
+    const unsigned int value_count =
+        m_functor_reducer.get_reducer().value_count();
+    sycl_device_ptr<value_type> results_ptr;
+    auto host_result_ptr =
+        (m_result_ptr && !m_result_ptr_device_accessible)
+            ? static_cast<sycl_host_ptr<value_type>>(
+                  instance.scratch_host(sizeof(value_type) * value_count))
+            : nullptr;
+
+    sycl::event last_reduction_event;
+
+    desul::ensure_sycl_lock_arrays_on_device(q);
+
+    // If n_tiles==0 we only call init() and final() working with the global
+    // scratch memory but don't copy back to m_result_ptr yet.
+    if (n_tiles == 0) {
+      auto cgh_lambda = [&](sycl::handler& cgh) {
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        cgh.depends_on(memcpy_event);
+#else
+        (void)memcpy_event;
+#endif
+        results_ptr = static_cast<sycl_device_ptr<value_type>>(
+            instance.scratch_space(sizeof(value_type) * value_count));
+        auto device_accessible_result_ptr =
+            m_result_ptr_device_accessible
+                ? static_cast<sycl::global_ptr<value_type>>(m_result_ptr)
+                : static_cast<sycl::global_ptr<value_type>>(host_result_ptr);
+        cgh.single_task([=]() {
+          const CombinedFunctorReducerType& functor_reducer =
+              functor_reducer_wrapper.get_functor();
+          const ReducerType& reducer = functor_reducer.get_reducer();
+          reducer.init(results_ptr);
+          reducer.final(results_ptr);
+          if (device_accessible_result_ptr)
+            reducer.copy(device_accessible_result_ptr.get(), results_ptr.get());
+        });
+      };
+
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+      if constexpr (Policy::is_graph_kernel::value) {
+        sycl_attach_kernel_to_node(*this, cgh_lambda);
+      } else
+#endif
+      {
+        last_reduction_event = q.submit(cgh_lambda);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        q.ext_oneapi_submit_barrier(
+            std::vector<sycl::event>{last_reduction_event});
+#endif
+      }
+    } else {
+      // Otherwise (when n_tiles is not zero), we perform a reduction on the
+      // values in all workgroups separately, write the workgroup results back
+      // to global memory and recurse until only one workgroup does the
+      // reduction and thus gets the final value.
+      const int wgroup_size = Kokkos::bit_ceil(
+          static_cast<unsigned int>(m_policy.m_prod_tile_dims));
+
+      // FIXME_SYCL Find a better way to determine a good limit for the
+      // maximum number of work groups, also see
+      // https://github.com/intel/llvm/blob/756ba2616111235bba073e481b7f1c8004b34ee6/sycl/source/detail/reduction.cpp#L51-L62
+      size_t max_work_groups =
+          2 * q.get_device().get_info<sycl::info::device::max_compute_units>();
+      int values_per_thread = 1;
+      size_t n_wgroups      = n_tiles;
+      while (n_wgroups > max_work_groups) {
+        values_per_thread *= 2;
+        n_wgroups = (n_tiles + values_per_thread - 1) / values_per_thread;
+      }
+
+      results_ptr = static_cast<sycl_device_ptr<value_type>>(
+          instance.scratch_space(sizeof(value_type) * value_count * n_wgroups));
+      auto device_accessible_result_ptr =
+          m_result_ptr_device_accessible
+              ? static_cast<sycl::global_ptr<value_type>>(m_result_ptr)
+              : static_cast<sycl::global_ptr<value_type>>(host_result_ptr);
+      auto scratch_flags = static_cast<sycl_device_ptr<unsigned int>>(
+          instance.scratch_flags(sizeof(unsigned int)));
+
+      auto cgh_lambda = [&](sycl::handler& cgh) {
+        sycl::local_accessor<value_type> local_mem(
+            sycl::range<1>(wgroup_size) * value_count, cgh);
+        sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
+
+        const BarePolicy bare_policy = m_policy;
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        cgh.depends_on(memcpy_event);
+#else
+        (void)memcpy_event;
+#endif
+
+        // REMEMBER swap local x<->y to be conforming with Cuda/HIP
+        // implementation
+        cgh.parallel_for(
+            sycl::nd_range<1>{n_wgroups * wgroup_size, wgroup_size},
+            [=](sycl::nd_item<1> item) {
+              const int 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
+              // results from the previous iteration that are stored in global
+              // memory.
+              using index_type = typename Policy::index_type;
+
+              // SWAPPED here to be conforming with CUDA implementation
+              const index_type local_x    = 0;
+              const index_type local_y    = item.get_local_id(0);
+              const index_type local_z    = 0;
+              const index_type global_y   = 0;
+              const index_type global_z   = 0;
+              const index_type n_global_x = n_tiles;
+              const index_type n_global_y = 1;
+              const index_type n_global_z = 1;
+
+              if constexpr (!SYCLReduction::use_shuffle_based_algorithm<
+                                ReducerType>) {
+                reference_type update =
+                    reducer.init(&local_mem[local_id * value_count]);
+
+                for (index_type global_x = item.get_group(0);
+                     global_x < n_tiles; global_x += item.get_group_range(0))
+                  Kokkos::Impl::Reduce::DeviceIterateTile<
+                      Policy::rank, BarePolicy, FunctorType,
+                      typename Policy::work_tag, reference_type>(
+                      bare_policy, functor, update,
+                      {n_global_x, n_global_y, n_global_z},
+                      {global_x, global_y, global_z},
+                      {local_x, local_y, local_z})
+                      .exec_range();
+                item.barrier(sycl::access::fence_space::local_space);
+
+                SYCLReduction::workgroup_reduction<>(
+                    item, local_mem, results_ptr, device_accessible_result_ptr,
+                    value_count, reducer, false, wgroup_size);
+
+                if (local_id == 0) {
+                  sycl::atomic_ref<unsigned, sycl::memory_order::acq_rel,
+                                   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::local_space);
+                if (num_teams_done[0] == n_wgroups) {
+                  if (local_id == 0) *scratch_flags = 0;
+                  if (local_id >= static_cast<int>(n_wgroups))
+                    reducer.init(&local_mem[local_id * value_count]);
+                  else {
+                    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) {
+                      reducer.join(&local_mem[local_id * value_count],
+                                   &results_ptr[id * value_count]);
+                    }
+                  }
+
+                  SYCLReduction::workgroup_reduction<>(
+                      item, local_mem, results_ptr,
+                      device_accessible_result_ptr, value_count, reducer, true,
+                      std::min<int>(n_wgroups, wgroup_size));
+                }
+              } else {
+                value_type local_value;
+                reference_type update = reducer.init(&local_value);
+
+                for (index_type global_x = item.get_group(0);
+                     global_x < n_tiles; global_x += item.get_group_range(0))
+                  Kokkos::Impl::Reduce::DeviceIterateTile<
+                      Policy::rank, BarePolicy, FunctorType,
+                      typename Policy::work_tag, reference_type>(
+                      bare_policy, functor, update,
+                      {n_global_x, n_global_y, n_global_z},
+                      {global_x, global_y, global_z},
+                      {local_x, local_y, local_z})
+                      .exec_range();
+
+                SYCLReduction::workgroup_reduction<>(
+                    item, local_mem, local_value, results_ptr,
+                    device_accessible_result_ptr, reducer, false, wgroup_size);
+
+                if (local_id == 0) {
+                  sycl::atomic_ref<unsigned, sycl::memory_order::acq_rel,
+                                   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::local_space);
+                if (num_teams_done[0] == n_wgroups) {
+                  if (local_id == 0) *scratch_flags = 0;
+                  if (local_id >= static_cast<int>(n_wgroups))
+                    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) {
+                      reducer.join(&local_value, &results_ptr[id]);
+                    }
+                  }
+
+                  SYCLReduction::workgroup_reduction<>(
+                      item, local_mem, local_value, results_ptr,
+                      device_accessible_result_ptr, reducer, true,
+                      std::min<int>(n_wgroups, wgroup_size));
+                }
+              }
+            });
+      };
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+      if constexpr (Policy::is_graph_kernel::value) {
+        sycl_attach_kernel_to_node(*this, cgh_lambda);
+      } else
+#endif
+      {
+        last_reduction_event = q.submit(cgh_lambda);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        q.ext_oneapi_submit_barrier(
+            std::vector<sycl::event>{last_reduction_event});
+#endif
+      }
+    }
+
+    // At this point, the reduced value is written to the entry in results_ptr
+    // and all that is left is to copy it back to the given result pointer if
+    // necessary.
+    // Using DeepCopy instead of fence+memcpy turned out to be up to 2x slower.
+    if (host_result_ptr) {
+      if constexpr (Policy::is_graph_kernel::value)
+        Kokkos::abort(
+            "parallel_reduce not implemented for graph kernels if result is "
+            "not device-accessible!");
+
+      m_space.fence(
+          "Kokkos::Impl::ParallelReduce<SYCL, MDRangePolicy>::execute: result "
+          "not device-accessible");
+      std::memcpy(m_result_ptr, host_result_ptr,
+                  sizeof(value_type) * value_count);
+    }
+
+    return last_reduction_event;
+  }
+
+ public:
+  template <typename Policy, typename Functor>
+  static int max_tile_size_product(const Policy& policy, const Functor&) {
+    return policy.space().impl_internal_space_instance()->m_maxWorkgroupSize;
+  }
+
+  void execute() const {
+    Kokkos::Experimental::Impl::SYCLInternal& instance =
+        *m_space.impl_internal_space_instance();
+
+    // Only let one instance at a time resize the instance's scratch memory
+    // allocations.
+    std::scoped_lock<std::mutex> scratch_buffers_lock(
+        instance.m_mutexScratchSpace);
+
+    using IndirectKernelMem =
+        Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
+    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(
+        functor_reducer_wrapper, functor_reducer_wrapper.get_copy_event());
+    functor_reducer_wrapper.register_event(event);
+  }
+
+ private:
+  const CombinedFunctorReducerType m_functor_reducer;
+  const BarePolicy m_policy;
+  const Kokkos::Experimental::SYCL& m_space;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+};
+
+#endif /* KOKKOS_SYCL_PARALLEL_REDUCE_MDRANGE_HPP */
diff --git a/core/src/SYCL/Kokkos_SYCL_ParallelReduce_Range.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelReduce_Range.hpp
new file mode 100644
index 0000000000..2d46ffc77d
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelReduce_Range.hpp
@@ -0,0 +1,396 @@
+//@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_PARALLEL_REDUCE_RANGE_HPP
+#define KOKKOS_SYCL_PARALLEL_REDUCE_RANGE_HPP
+
+#include <Kokkos_Macros.hpp>
+
+#include <Kokkos_BitManipulation.hpp>
+#include <Kokkos_Parallel_Reduce.hpp>
+#include <SYCL/Kokkos_SYCL_WorkgroupReduction.hpp>
+#include <vector>
+
+template <class CombinedFunctorReducerType, class... Traits>
+class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
+                                   Kokkos::RangePolicy<Traits...>,
+                                   Kokkos::Experimental::SYCL> {
+ public:
+  using Policy      = Kokkos::RangePolicy<Traits...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+ private:
+  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 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 View::memory_space>::accessible) {}
+
+ private:
+  template <typename PolicyType, typename CombinedFunctorReducerWrapper>
+  sycl::event sycl_direct_launch(
+      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 =
+        *space.impl_internal_space_instance();
+    sycl::queue& q = space.sycl_queue();
+
+    std::size_t size = policy.end() - policy.begin();
+    const unsigned int value_count =
+        m_functor_reducer.get_reducer().value_count();
+    sycl_device_ptr<value_type> results_ptr = nullptr;
+    auto host_result_ptr =
+        (m_result_ptr && !m_result_ptr_device_accessible)
+            ? static_cast<sycl_host_ptr<value_type>>(
+                  instance.scratch_host(sizeof(value_type) * value_count))
+            : nullptr;
+    auto device_accessible_result_ptr =
+        m_result_ptr_device_accessible
+            ? static_cast<sycl::global_ptr<value_type>>(m_result_ptr)
+            : static_cast<sycl::global_ptr<value_type>>(host_result_ptr);
+
+    sycl::event last_reduction_event;
+
+    desul::ensure_sycl_lock_arrays_on_device(q);
+
+    // If size<=1 we only call init(), the functor and possibly final once
+    // working with the global scratch memory but don't copy back to
+    // m_result_ptr yet.
+    if (size <= 1) {
+      results_ptr = static_cast<sycl_device_ptr<value_type>>(
+          instance.scratch_space(sizeof(value_type) * value_count));
+
+      auto cgh_lambda = [&](sycl::handler& cgh) {
+        const auto begin = policy.begin();
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        cgh.depends_on(memcpy_event);
+#else
+        (void)memcpy_event;
+#endif
+        cgh.single_task([=]() {
+          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_v<WorkTag>)
+              functor(begin, update);
+            else
+              functor(WorkTag(), begin, update);
+          }
+          reducer.final(results_ptr);
+          if (device_accessible_result_ptr != nullptr)
+            reducer.copy(device_accessible_result_ptr.get(), results_ptr.get());
+        });
+      };
+
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+      if constexpr (Policy::is_graph_kernel::value) {
+        sycl_attach_kernel_to_node(*this, cgh_lambda);
+      } else
+#endif
+      {
+        last_reduction_event = q.submit(cgh_lambda);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        q.ext_oneapi_submit_barrier(
+            std::vector<sycl::event>{last_reduction_event});
+#endif
+      }
+    } else {
+      // Otherwise (when size > 1), we perform a reduction on the values in all
+      // workgroups separately, write the workgroup results back to global
+      // memory and recurse until only one workgroup does the reduction and thus
+      // gets the final value.
+      auto scratch_flags = static_cast<sycl_device_ptr<unsigned int>>(
+          instance.scratch_flags(sizeof(unsigned int)));
+
+      auto reduction_lambda_factory =
+          [&](sycl::local_accessor<value_type> local_mem,
+              sycl::local_accessor<unsigned int> num_teams_done,
+              sycl_device_ptr<value_type> results_ptr, int values_per_thread) {
+            const auto begin = policy.begin();
+
+            auto lambda = [=](sycl::nd_item<1> item) {
+              const auto n_wgroups   = item.get_group_range()[0];
+              const auto wgroup_size = item.get_local_range()[0];
+
+              const auto local_id = item.get_local_linear_id();
+              const auto global_id =
+                  wgroup_size * item.get_group_linear_id() * values_per_thread +
+                  local_id;
+              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 (!SYCLReduction::use_shuffle_based_algorithm<
+                                ReducerType>) {
+                reference_type update =
+                    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_v<WorkTag>)
+                    functor(id + begin, update);
+                  else
+                    functor(WorkTag(), id + begin, update);
+                }
+                item.barrier(sycl::access::fence_space::local_space);
+
+                SYCLReduction::workgroup_reduction<>(
+                    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::acq_rel,
+                                   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::local_space);
+                if (num_teams_done[0] == n_wgroups) {
+                  if (local_id == 0) *scratch_flags = 0;
+                  if (local_id >= n_wgroups)
+                    reducer.init(&local_mem[local_id * value_count]);
+                  else {
+                    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) {
+                      reducer.join(&local_mem[local_id * value_count],
+                                   &results_ptr[id * value_count]);
+                    }
+                  }
+
+                  SYCLReduction::workgroup_reduction<>(
+                      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 = reducer.init(&local_value);
+                for (index_type id = global_id; id < upper_bound;
+                     id += wgroup_size) {
+                  if constexpr (std::is_void_v<WorkTag>)
+                    functor(id + begin, update);
+                  else
+                    functor(WorkTag(), id + begin, update);
+                }
+
+                SYCLReduction::workgroup_reduction<>(
+                    item, local_mem, local_value, results_ptr,
+                    device_accessible_result_ptr, reducer, false,
+                    std::min(size, wgroup_size));
+
+                if (local_id == 0) {
+                  sycl::atomic_ref<unsigned, sycl::memory_order::acq_rel,
+                                   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::local_space);
+                if (num_teams_done[0] == n_wgroups) {
+                  if (local_id == 0) *scratch_flags = 0;
+                  if (local_id >= n_wgroups)
+                    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) {
+                      reducer.join(&local_value, &results_ptr[id]);
+                    }
+                  }
+
+                  SYCLReduction::workgroup_reduction<>(
+                      item, local_mem, local_value, results_ptr,
+                      device_accessible_result_ptr, reducer, true,
+                      std::min(n_wgroups, wgroup_size));
+                }
+              }
+            };
+            return lambda;
+          };
+
+      auto cgh_lambda = [&](sycl::handler& cgh) {
+        sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
+
+        auto dummy_reduction_lambda =
+            reduction_lambda_factory({1, cgh}, num_teams_done, nullptr, 1);
+
+        static sycl::kernel kernel = [&] {
+          sycl::kernel_id functor_kernel_id =
+              sycl::get_kernel_id<decltype(dummy_reduction_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());
+        // FIXME_SYCL The code below queries the kernel for the maximum subgroup
+        // size but it turns out that this is not accurate and choosing a larger
+        // subgroup size gives better peformance (and is what the oneAPI
+        // reduction algorithm does).
+#ifndef KOKKOS_ARCH_INTEL_GPU
+        auto max =
+            kernel
+                .get_info<sycl::info::kernel_device_specific::work_group_size>(
+                    q.get_device());
+#else
+        auto max =
+            q.get_device().get_info<sycl::info::device::max_work_group_size>();
+#endif
+
+        auto max_local_memory =
+            q.get_device().get_info<sycl::info::device::local_mem_size>();
+        // The workgroup size is computed as the minimum of
+        // - the smallest power of two not less than the total work size
+        // - the largest power of two not exceeding the largest multiple of the
+        //   recommended workgroup size not exceeding the maximum workgroup size
+        // - the largest power of two such that we don't use more than 99% (as a
+        //   safe-guard) of the available local memory.
+        const auto wgroup_size = std::min(
+            {Kokkos::bit_ceil(size),
+             Kokkos::bit_floor(static_cast<size_t>(max / multiple) * multiple),
+             Kokkos::bit_floor(static_cast<size_t>(max_local_memory * .99) /
+                               (sizeof(value_type) * value_count))});
+
+        // FIXME_SYCL Find a better way to determine a good limit for the
+        // maximum number of work groups, also see
+        // https://github.com/intel/llvm/blob/756ba2616111235bba073e481b7f1c8004b34ee6/sycl/source/detail/reduction.cpp#L51-L62
+        size_t max_work_groups =
+            2 *
+            q.get_device().get_info<sycl::info::device::max_compute_units>();
+        int values_per_thread = 1;
+        size_t n_wgroups      = (size + wgroup_size - 1) / wgroup_size;
+        while (n_wgroups > max_work_groups) {
+          values_per_thread *= 2;
+          n_wgroups = ((size + values_per_thread - 1) / values_per_thread +
+                       wgroup_size - 1) /
+                      wgroup_size;
+        }
+
+        results_ptr =
+            static_cast<sycl_device_ptr<value_type>>(instance.scratch_space(
+                sizeof(value_type) * value_count * n_wgroups));
+
+        sycl::local_accessor<value_type> local_mem(
+            sycl::range<1>(wgroup_size) * value_count, cgh);
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        cgh.depends_on(memcpy_event);
+#else
+        (void)memcpy_event;
+#endif
+
+        auto reduction_lambda = reduction_lambda_factory(
+            local_mem, num_teams_done, results_ptr, values_per_thread);
+
+        cgh.parallel_for(
+            sycl::nd_range<1>(n_wgroups * wgroup_size, wgroup_size),
+            reduction_lambda);
+      };
+
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+      if constexpr (Policy::is_graph_kernel::value) {
+        sycl_attach_kernel_to_node(*this, cgh_lambda);
+      } else
+#endif
+      {
+        last_reduction_event = q.submit(cgh_lambda);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        q.ext_oneapi_submit_barrier(
+            std::vector<sycl::event>{last_reduction_event});
+#endif
+      }
+    }
+
+    // At this point, the reduced value is written to the entry in results_ptr
+    // and all that is left is to copy it back to the given result pointer if
+    // necessary.
+    // Using DeepCopy instead of fence+memcpy turned out to be up to 2x slower.
+    if (host_result_ptr) {
+      if constexpr (Policy::is_graph_kernel::value)
+        Kokkos::abort(
+            "parallel_reduce not implemented for graph kernels if result is "
+            "not device-accessible!");
+
+      space.fence(
+          "Kokkos::Impl::ParallelReduce<SYCL, RangePolicy>::execute: result "
+          "not device-accessible");
+      std::memcpy(m_result_ptr, host_result_ptr,
+                  sizeof(*m_result_ptr) * value_count);
+    }
+
+    return last_reduction_event;
+  }
+
+ public:
+  void execute() const {
+    Kokkos::Experimental::Impl::SYCLInternal& instance =
+        *m_policy.space().impl_internal_space_instance();
+
+    // Only let one instance at a time resize the instance's scratch memory
+    // allocations.
+    std::scoped_lock<std::mutex> scratch_buffers_lock(
+        instance.m_mutexScratchSpace);
+
+    using IndirectKernelMem =
+        Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
+    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 CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+};
+
+#endif /* KOKKOS_SYCL_PARALLEL_REDUCE_RANGE_HPP */
diff --git a/core/src/SYCL/Kokkos_SYCL_ParallelReduce_Team.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelReduce_Team.hpp
new file mode 100644
index 0000000000..b443bcbf90
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelReduce_Team.hpp
@@ -0,0 +1,484 @@
+//@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_PARALLEL_REDUCE_TEAM_HPP
+#define KOKKOS_SYCL_PARALLEL_REDUCE_TEAM_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <SYCL/Kokkos_SYCL_Team.hpp>
+#include <SYCL/Kokkos_SYCL_TeamPolicy.hpp>
+#include <SYCL/Kokkos_SYCL_WorkgroupReduction.hpp>
+
+#include <sstream>
+#include <vector>
+
+template <class CombinedFunctorReducerType, class... Properties>
+class Kokkos::Impl::ParallelReduce<CombinedFunctorReducerType,
+                                   Kokkos::TeamPolicy<Properties...>,
+                                   Kokkos::Experimental::SYCL> {
+ public:
+  using Policy      = TeamPolicy<Properties...>;
+  using FunctorType = typename CombinedFunctorReducerType::functor_type;
+  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
+
+ private:
+  using member_type   = typename Policy::member_type;
+  using WorkTag       = typename Policy::work_tag;
+  using launch_bounds = typename Policy::launch_bounds;
+
+  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 CombinedFunctorReducerType m_functor_reducer;
+  const Policy m_policy;
+  const pointer_type m_result_ptr;
+  const bool m_result_ptr_device_accessible;
+  size_type m_shmem_begin;
+  size_type m_shmem_size;
+  size_t m_scratch_size[2];
+  const size_type m_league_size;
+  int m_team_size;
+  const size_type m_vector_size;
+
+  template <typename CombinedFunctorReducerWrapper>
+  sycl::event sycl_direct_launch(
+      const sycl_device_ptr<char> global_scratch_ptr,
+      const CombinedFunctorReducerWrapper& functor_reducer_wrapper,
+      const sycl::event& memcpy_event) const {
+    // 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();
+
+    const unsigned int value_count =
+        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;
+    auto host_result_ptr =
+        (m_result_ptr && !m_result_ptr_device_accessible)
+            ? static_cast<sycl_host_ptr<value_type>>(
+                  instance.scratch_host(sizeof(value_type) * value_count))
+            : nullptr;
+
+    sycl::event last_reduction_event;
+
+    desul::ensure_sycl_lock_arrays_on_device(q);
+
+    // If size<=1 we only call init(), the functor and possibly final once
+    // working with the global scratch memory but don't copy back to
+    // m_result_ptr yet.
+    if (size <= 1) {
+      results_ptr =
+          static_cast<sycl_device_ptr<value_type>>(instance.scratch_space(
+              sizeof(value_type) * std::max(value_count, 1u)));
+      auto device_accessible_result_ptr =
+          m_result_ptr_device_accessible
+              ? static_cast<sycl::global_ptr<value_type>>(m_result_ptr)
+              : static_cast<sycl::global_ptr<value_type>>(host_result_ptr);
+
+      auto cgh_lambda = [&](sycl::handler& cgh) {
+        // FIXME_SYCL accessors seem to need a size greater than zero at least
+        // for host queues
+        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]};
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        cgh.depends_on(memcpy_event);
+#else
+        (void)memcpy_event;
+#endif
+        cgh.parallel_for(
+            sycl::nd_range<2>(sycl::range<2>(1, 1), sycl::range<2>(1, 1)),
+            [=](sycl::nd_item<2> item) {
+              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(
+                    KOKKOS_IMPL_SYCL_GET_MULTI_PTR(team_scratch_memory_L0),
+                    shmem_begin, scratch_size[0], global_scratch_ptr,
+                    scratch_size[1], item, item.get_group_linear_id(),
+                    item.get_group_range(1));
+                if constexpr (std::is_void_v<WorkTag>)
+                  functor(team_member, update);
+                else
+                  functor(WorkTag(), team_member, update);
+              }
+              reducer.final(results_ptr);
+              if (device_accessible_result_ptr)
+                reducer.copy(device_accessible_result_ptr, &results_ptr[0]);
+            });
+      };
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+      if constexpr (Policy::is_graph_kernel::value) {
+        sycl_attach_kernel_to_node(*this, cgh_lambda);
+      } else
+#endif
+      {
+        last_reduction_event = q.submit(cgh_lambda);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        q.ext_oneapi_submit_barrier(
+            std::vector<sycl::event>{last_reduction_event});
+#endif
+      }
+    } else {
+      // Otherwise, (if the total range has more than one element) we perform a
+      // reduction on the values in all workgroups separately, write the
+      // workgroup results back to global memory and recurse until only one
+      // workgroup does the reduction and thus gets the final value.
+      auto cgh_lambda = [&](sycl::handler& cgh) {
+        auto scratch_flags = static_cast<sycl_device_ptr<unsigned int>>(
+            instance.scratch_flags(sizeof(unsigned int)));
+
+        // FIXME_SYCL accessors seem to need a size greater than zero at least
+        // for host queues
+        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 auto league_size       = m_league_size;
+        const size_t scratch_size[2] = {m_scratch_size[0], m_scratch_size[1]};
+        sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
+
+        auto team_reduction_factory =
+            [&](sycl::local_accessor<value_type, 1> local_mem,
+                sycl_device_ptr<value_type> results_ptr) {
+              auto device_accessible_result_ptr =
+                  m_result_ptr_device_accessible
+                      ? static_cast<sycl::global_ptr<value_type>>(m_result_ptr)
+                      : static_cast<sycl::global_ptr<value_type>>(
+                            host_result_ptr);
+              auto lambda = [=](sycl::nd_item<2> item) {
+                auto n_wgroups = item.get_group_range()[1];
+                int wgroup_size =
+                    item.get_local_range()[0] * item.get_local_range()[1];
+                auto group_id = item.get_group_linear_id();
+                auto size     = n_wgroups * wgroup_size;
+
+                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 (!SYCLReduction::use_shuffle_based_algorithm<
+                                  ReducerType>) {
+                  reference_type update =
+                      reducer.init(&local_mem[local_id * value_count]);
+                  for (int league_rank = group_id; league_rank < league_size;
+                       league_rank += n_wgroups) {
+                    const member_type team_member(
+                        KOKKOS_IMPL_SYCL_GET_MULTI_PTR(team_scratch_memory_L0),
+                        shmem_begin, scratch_size[0],
+                        global_scratch_ptr +
+                            item.get_group(1) * scratch_size[1],
+                        scratch_size[1], item, league_rank, league_size);
+                    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, 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]));
+
+                  if (local_id == 0) {
+                    sycl::atomic_ref<unsigned, sycl::memory_order::acq_rel,
+                                     sycl::memory_scope::device,
+                                     sycl::access::address_space::global_space>
+                        scratch_flags_ref(*scratch_flags);
+                    num_teams_done[0] = ++scratch_flags_ref;
+                  }
+                  sycl::group_barrier(item.get_group());
+                  if (num_teams_done[0] == n_wgroups) {
+                    if (local_id == 0) *scratch_flags = 0;
+                    if (local_id >= n_wgroups)
+                      reducer.init(&local_mem[local_id * value_count]);
+                    else {
+                      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) {
+                        reducer.join(&local_mem[local_id * value_count],
+                                     &results_ptr[id * value_count]);
+                      }
+                    }
+
+                    SYCLReduction::workgroup_reduction<>(
+                        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 = reducer.init(&local_value);
+                  for (int league_rank = group_id; league_rank < league_size;
+                       league_rank += n_wgroups) {
+                    const member_type team_member(
+                        KOKKOS_IMPL_SYCL_GET_MULTI_PTR(team_scratch_memory_L0),
+                        shmem_begin, scratch_size[0],
+                        global_scratch_ptr +
+                            item.get_group(1) * scratch_size[1],
+                        scratch_size[1], item, league_rank, league_size);
+                    if constexpr (std::is_void_v<WorkTag>)
+                      functor(team_member, update);
+                    else
+                      functor(WorkTag(), team_member, update);
+                  }
+
+                  SYCLReduction::workgroup_reduction<>(
+                      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]));
+
+                  if (local_id == 0) {
+                    sycl::atomic_ref<unsigned, sycl::memory_order::acq_rel,
+                                     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::local_space);
+                  if (num_teams_done[0] == n_wgroups) {
+                    if (local_id == 0) *scratch_flags = 0;
+                    if (local_id >= n_wgroups)
+                      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) {
+                        reducer.join(&local_value, &results_ptr[id]);
+                      }
+                    }
+
+                    SYCLReduction::workgroup_reduction<>(
+                        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]));
+                  }
+                }
+              };
+              return lambda;
+            };
+
+        auto dummy_reduction_lambda = team_reduction_factory({1, cgh}, nullptr);
+
+        static sycl::kernel kernel = [&] {
+          sycl::kernel_id functor_kernel_id =
+              sycl::get_kernel_id<decltype(dummy_reduction_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 max_sg_size = kernel.get_info<
+            sycl::info::kernel_device_specific::max_sub_group_size>(
+            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);
+
+        auto wgroup_size = m_team_size * final_vector_size;
+        std::size_t size = std::size_t(m_league_size) * wgroup_size;
+        sycl::local_accessor<value_type, 1> local_mem(
+            sycl::range<1>(wgroup_size) * std::max(value_count, 1u), cgh);
+
+        const auto init_size =
+            std::max<std::size_t>((size + wgroup_size - 1) / wgroup_size, 1);
+        results_ptr =
+            static_cast<sycl_device_ptr<value_type>>(instance.scratch_space(
+                sizeof(value_type) * std::max(value_count, 1u) * init_size));
+
+        size_t max_work_groups =
+            2 *
+            q.get_device().get_info<sycl::info::device::max_compute_units>();
+        int values_per_thread = 1;
+        size_t n_wgroups      = m_league_size;
+        while (n_wgroups > max_work_groups) {
+          values_per_thread *= 2;
+          n_wgroups =
+              ((size_t(m_league_size) * wgroup_size + values_per_thread - 1) /
+                   values_per_thread +
+               wgroup_size - 1) /
+              wgroup_size;
+        }
+
+        auto reduction_lambda = team_reduction_factory(local_mem, results_ptr);
+
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        cgh.depends_on(memcpy_event);
+#endif
+
+        cgh.parallel_for(
+            sycl::nd_range<2>(
+                sycl::range<2>(m_team_size, n_wgroups * m_vector_size),
+                sycl::range<2>(m_team_size, m_vector_size)),
+            reduction_lambda);
+      };
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+      if constexpr (Policy::is_graph_kernel::value) {
+        sycl_attach_kernel_to_node(*this, cgh_lambda);
+      } else
+#endif
+      {
+        last_reduction_event = q.submit(cgh_lambda);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+        q.ext_oneapi_submit_barrier(
+            std::vector<sycl::event>{last_reduction_event});
+#endif
+      }
+    }
+
+    // At this point, the reduced value is written to the entry in results_ptr
+    // and all that is left is to copy it back to the given result pointer if
+    // necessary.
+    // Using DeepCopy instead of fence+memcpy turned out to be up to 2x slower.
+    if (host_result_ptr) {
+      if constexpr (Policy::is_graph_kernel::value)
+        Kokkos::abort(
+            "parallel_reduce not implemented for graph kernels if result is "
+            "not device-accessible!");
+
+      space.fence(
+          "Kokkos::Impl::ParallelReduce<SYCL, TeamPolicy>::execute: result not "
+          "device-accessible");
+      std::memcpy(m_result_ptr, host_result_ptr,
+                  sizeof(*m_result_ptr) * value_count);
+    }
+
+    return last_reduction_event;
+  }
+
+ public:
+  inline void execute() {
+    Kokkos::Experimental::Impl::SYCLInternal& instance =
+        *m_policy.space().impl_internal_space_instance();
+
+    // Only let one instance at a time resize the instance's scratch memory
+    // allocations.
+    std::scoped_lock<std::mutex> scratch_buffers_lock(
+        instance.m_mutexScratchSpace);
+    std::scoped_lock<std::mutex> team_scratch_lock(
+        instance.m_team_scratch_mutex);
+
+    // Functor's reduce memory, team scan memory, and team shared memory depend
+    // upon team size.
+    int scratch_pool_id = instance.acquire_team_scratch_space();
+    const sycl_device_ptr<char> global_scratch_ptr =
+        static_cast<sycl_device_ptr<char>>(instance.resize_team_scratch_space(
+            scratch_pool_id,
+            static_cast<ptrdiff_t>(m_scratch_size[1]) * m_league_size));
+
+    using IndirectKernelMem =
+        Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
+    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(global_scratch_ptr, functor_reducer_wrapper,
+                           functor_reducer_wrapper.get_copy_event());
+    functor_reducer_wrapper.register_event(event);
+    instance.register_team_scratch_event(scratch_pool_id, event);
+  }
+
+  template <class ViewType>
+  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_result_ptr(arg_result.data()),
+        m_result_ptr_device_accessible(
+            MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
+                              typename ViewType::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()) {
+    // FIXME_SYCL optimize
+    if (m_team_size < 0)
+      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) {
+      int temp_team_size = 2;
+      while ((temp_team_size << 1) < m_team_size) temp_team_size <<= 1;
+      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_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);
+
+    const Kokkos::Experimental::Impl::SYCLInternal& instance =
+        *m_policy.space().impl_internal_space_instance();
+    if (static_cast<int>(instance.m_maxShmemPerBlock) <
+        m_shmem_size - m_shmem_begin) {
+      std::stringstream out;
+      out << "Kokkos::Impl::ParallelFor<SYCL> insufficient shared memory! "
+             "Requested "
+          << m_shmem_size - m_shmem_begin << " bytes but maximum is "
+          << instance.m_maxShmemPerBlock << '\n';
+      Kokkos::Impl::throw_runtime_exception(out.str());
+    }
+
+    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.");
+  }
+};
+
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp b/core/src/SYCL/Kokkos_SYCL_ParallelScan_Range.hpp
similarity index 61%
rename from core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp
rename to core/src/SYCL/Kokkos_SYCL_ParallelScan_Range.hpp
index f22c8ada02..bdb5b88377 100644
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Scan.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_ParallelScan_Range.hpp
@@ -14,16 +14,15 @@
 //
 //@HEADER
 
-#ifndef KOKKO_SYCL_PARALLEL_SCAN_HPP
-#define KOKKO_SYCL_PARALLEL_SCAN_HPP
+#ifndef KOKKOS_SYCL_PARALLEL_SCAN_RANGE_HPP
+#define KOKKOS_SYCL_PARALLEL_SCAN_RANGE_HPP
 
 #include <Kokkos_Macros.hpp>
+#include <SYCL/Kokkos_SYCL_WorkgroupReduction.hpp>
 #include <memory>
 #include <vector>
-#if defined(KOKKOS_ENABLE_SYCL)
 
-namespace Kokkos {
-namespace Impl {
+namespace Kokkos::Impl {
 
 // Perform a scan over a workgroup.
 // At the end of this function, the subgroup scans are stored in the local array
@@ -37,20 +36,38 @@ void workgroup_scan(sycl::nd_item<dim> item, const FunctorType& final_reducer,
   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);
+  const int local_range = std::min<int>(sg.get_local_range()[0], global_range);
+
+#if defined(KOKKOS_ARCH_INTEL_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  auto shuffle_combine = [&](int stride) {
+    if (stride < local_range) {
+      auto tmp = Kokkos::Impl::SYCLReduction::shift_group_right(sg, local_value,
+                                                                stride);
+      if (id_in_sg >= stride) final_reducer.join(&local_value, &tmp);
+    }
+  };
+  shuffle_combine(1);
+  shuffle_combine(2);
+  shuffle_combine(4);
+  shuffle_combine(8);
+  shuffle_combine(16);
+  KOKKOS_ASSERT(local_range <= 32);
+#else
+  for (int stride = 1; stride < local_range; stride <<= 1) {
+    auto tmp =
+        Kokkos::Impl::SYCLReduction::shift_group_right(sg, local_value, stride);
     if (id_in_sg >= stride) final_reducer.join(&local_value, &tmp);
   }
+#endif
 
   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 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);
+  local_value =
+      Kokkos::Impl::SYCLReduction::shift_group_right(sg, local_value, 1);
   if (id_in_sg == 0) final_reducer.init(&local_value);
   sycl::group_barrier(item.get_group());
 
@@ -63,8 +80,29 @@ void workgroup_scan(sycl::nd_item<dim> item, const FunctorType& final_reducer,
         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];
+#if defined(KOKKOS_ARCH_INTEL_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+        auto shuffle_combine_sg = [&](int stride) {
+          if (stride < upper_bound) {
+            auto tmp = Kokkos::Impl::SYCLReduction::shift_group_right(
+                sg, local_sg_value, stride);
+            if (id_in_sg >= stride) {
+              if (idx < n_active_subgroups)
+                final_reducer.join(&local_sg_value, &tmp);
+              else
+                local_sg_value = tmp;
+            }
+          }
+        };
+        shuffle_combine_sg(1);
+        shuffle_combine_sg(2);
+        shuffle_combine_sg(4);
+        shuffle_combine_sg(8);
+        shuffle_combine_sg(16);
+        KOKKOS_ASSERT(upper_bound <= 32);
+#else
         for (int stride = 1; stride < upper_bound; stride <<= 1) {
-          auto tmp = sg.shuffle_up(local_sg_value, stride);
+          auto tmp = Kokkos::Impl::SYCLReduction::shift_group_right(
+              sg, local_sg_value, stride);
           if (id_in_sg >= stride) {
             if (idx < n_active_subgroups)
               final_reducer.join(&local_sg_value, &tmp);
@@ -72,6 +110,7 @@ void workgroup_scan(sycl::nd_item<dim> item, const FunctorType& final_reducer,
               local_sg_value = tmp;
           }
         }
+#endif
         if (idx < n_active_subgroups) {
           local_mem[idx] = local_sg_value;
           if (round > 0)
@@ -113,14 +152,10 @@ class ParallelScanSYCLBase {
   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;
+  sycl_host_ptr<value_type> m_scratch_host = nullptr;
+  pointer_type m_result_ptr;
   const bool m_result_ptr_device_accessible;
 
-  // Only let one Parallel/Scan modify the shared memory. The
-  // constructor acquires the mutex which is released in the destructor.
-  std::scoped_lock<std::mutex> m_shared_memory_lock;
-
  private:
   template <typename FunctorWrapper>
   sycl::event sycl_direct_launch(const FunctorWrapper& functor_wrapper,
@@ -133,94 +168,95 @@ class ParallelScanSYCLBase {
 
     const auto size = m_policy.end() - m_policy.begin();
 
-    auto scratch_flags = static_cast<sycl::device_ptr<unsigned int>>(
+    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;
-            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);
-            }
+    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;
+        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, reducer, local_mem, local_value,
-                             wgroup_size);
+        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;
+        // Write results to global memory
+        if (global_id < size) global_mem[global_id] = local_value;
 
-            if (local_id == wgroup_size - 1) {
-              group_results[item.get_group_linear_id()] =
-                  local_mem[item.get_sub_group().get_group_range()[0] - 1];
+        if (local_id == wgroup_size - 1) {
+          group_results[item.get_group_linear_id()] =
+              local_mem[item.get_sub_group().get_group_range()[0] - 1];
 
-              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);
-              }
+          sycl::atomic_ref<unsigned, sycl::memory_order::acq_rel,
+                           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) {
+          if (local_id == 0) *scratch_flags = 0;
+          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;
             }
-          };
-          return lambda;
-        };
+            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;
+    sycl_device_ptr<value_type> global_mem;
+    sycl_device_ptr<value_type> group_results;
+
+    desul::ensure_sycl_lock_arrays_on_device(q);
 
     auto perform_work_group_scans = q.submit([&](sycl::handler& cgh) {
       sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
@@ -253,9 +289,10 @@ class ParallelScanSYCLBase {
       // 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(
+          static_cast<sycl_device_ptr<value_type>>(instance.scratch_space(
               n_wgroups * (wgroup_size + 1) * sizeof(value_type)));
-      m_scratch_space = global_mem;
+      m_scratch_host = static_cast<sycl_host_ptr<value_type>>(
+          instance.scratch_host(sizeof(value_type)));
 
       group_results = global_mem + n_wgroups * wgroup_size;
 
@@ -269,7 +306,11 @@ class ParallelScanSYCLBase {
                          min_subgroup_size),
           cgh);
 
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
       cgh.depends_on(memcpy_event);
+#else
+      (void)memcpy_event;
+#endif
 
       auto scan_lambda = scan_lambda_factory(local_mem, num_teams_done,
                                              global_mem, group_results);
@@ -279,17 +320,19 @@ class ParallelScanSYCLBase {
 
     // Write results to global memory
     auto update_global_results = q.submit([&](sycl::handler& cgh) {
-      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;
+      pointer_type result_ptr = m_result_ptr_device_accessible
+                                    ? m_result_ptr
+                                    : static_cast<pointer_type>(m_scratch_host);
 
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
       cgh.depends_on(perform_work_group_scans);
+#endif
 
       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 =
@@ -308,14 +351,14 @@ class ParallelScanSYCLBase {
               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;
+              if (global_id == size - 1) *result_ptr = update;
             }
           });
     });
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
     q.ext_oneapi_submit_barrier(
         std::vector<sycl::event>{update_global_results});
+#endif
     return update_global_results;
   }
 
@@ -326,6 +369,11 @@ class ParallelScanSYCLBase {
 
     auto& instance = *m_policy.space().impl_internal_space_instance();
 
+    // Only let one instance at a time resize the instance's scratch memory
+    // allocations.
+    std::scoped_lock<std::mutex> scratch_buffers_lock(
+        instance.m_mutexScratchSpace);
+
     Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem&
         indirectKernelMem = instance.get_indirect_kernel_mem();
 
@@ -344,15 +392,14 @@ class ParallelScanSYCLBase {
       : 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),
-        m_shared_memory_lock(m_policy.space()
-                                 .impl_internal_space_instance()
-                                 ->m_mutexScratchSpace) {}
+        m_result_ptr_device_accessible(arg_result_ptr_device_accessible) {}
 };
 
+}  // namespace Kokkos::Impl
+
 template <class FunctorType, class... Traits>
-class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
-                   Kokkos::Experimental::SYCL>
+class Kokkos::Impl::ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                                 Kokkos::Experimental::SYCL>
     : private ParallelScanSYCLBase<FunctorType, void, Traits...> {
  public:
   using Base = ParallelScanSYCLBase<FunctorType, void, Traits...>;
@@ -369,8 +416,9 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
 //----------------------------------------------------------------------------
 
 template <class FunctorType, class ReturnType, class... Traits>
-class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
-                            ReturnType, Kokkos::Experimental::SYCL>
+class Kokkos::Impl::ParallelScanWithTotal<
+    FunctorType, Kokkos::RangePolicy<Traits...>, ReturnType,
+    Kokkos::Experimental::SYCL>
     : public ParallelScanSYCLBase<FunctorType, ReturnType, Traits...> {
  public:
   using Base = ParallelScanSYCLBase<FunctorType, ReturnType, Traits...>;
@@ -381,11 +429,13 @@ 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) {
+        // Using DeepCopy instead of fence+memcpy turned out to be up to 2x
+        // slower.
+        m_exec.fence(
+            "Kokkos::Impl::ParallelReduce<SYCL, MDRangePolicy>::execute: "
+            "result not device-accessible");
         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,
-                                             size);
+        std::memcpy(Base::m_result_ptr, Base::m_scratch_host, size);
       }
     });
   }
@@ -400,9 +450,4 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
         m_exec(arg_policy.space()) {}
 };
 
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif
-
 #endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp b/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp
deleted file mode 100644
index a29e8010d8..0000000000
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Reduce.hpp
+++ /dev/null
@@ -1,788 +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_SYCL_PARALLEL_REDUCE_HPP
-#define KOKKOS_SYCL_PARALLEL_REDUCE_HPP
-
-#include <Kokkos_Macros.hpp>
-
-#include <vector>
-#if defined(KOKKOS_ENABLE_SYCL)
-#include <Kokkos_Parallel_Reduce.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-namespace Impl {
-
-template <class ReducerType>
-inline constexpr bool use_shuffle_based_algorithm =
-    std::is_reference_v<typename ReducerType::reference_type>;
-
-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_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,
-    bool final, unsigned int max_size) {
-  const auto local_id = item.get_local_linear_id();
-
-  // Perform the actual workgroup reduction in each subgroup
-  // separately.
-  auto sg             = item.get_sub_group();
-  auto* result        = &local_mem[local_id * value_count];
-  const auto id_in_sg = sg.get_local_id()[0];
-  const auto local_range =
-      std::min<unsigned int>(sg.get_local_range()[0], max_size);
-  const auto upper_stride_bound =
-      std::min(local_range - id_in_sg, max_size - local_id);
-  for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
-    if (stride < upper_stride_bound)
-      final_reducer.join(result, &local_mem[(local_id + stride) * value_count]);
-    sycl::group_barrier(sg);
-  }
-  sycl::group_barrier(item.get_group());
-
-  // Copy the subgroup results into the first positions of the
-  // reduction array.
-  if (id_in_sg == 0)
-    final_reducer.copy(&local_mem[sg.get_group_id()[0] * value_count], result);
-  sycl::group_barrier(item.get_group());
-
-  // Do the final reduction only using the first subgroup.
-  if (sg.get_group_id()[0] == 0) {
-    const auto n_subgroups = sg.get_group_range()[0];
-    auto* result_          = &local_mem[id_in_sg * value_count];
-    // In case the number of subgroups is larger than the range of
-    // the first subgroup, we first combine the items with a higher
-    // index.
-    for (unsigned int offset = local_range; offset < n_subgroups;
-         offset += local_range)
-      if (id_in_sg + offset < n_subgroups)
-        final_reducer.join(result_,
-                           &local_mem[(id_in_sg + offset) * value_count]);
-    sycl::group_barrier(sg);
-
-    // Then, we proceed as before.
-    for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
-      if (id_in_sg + stride < n_subgroups)
-        final_reducer.join(result_,
-                           &local_mem[(id_in_sg + stride) * value_count]);
-      sycl::group_barrier(sg);
-    }
-
-    // Finally, we copy the workgroup results back to global memory
-    // to be used in the next iteration. If this is the last
-    // iteration, i.e., there is only one workgroup also call
-    // final() if necessary.
-    if (id_in_sg == 0) {
-      if (final) {
-        final_reducer.final(&local_mem[0]);
-        if (device_accessible_result_ptr != nullptr)
-          final_reducer.copy(&device_accessible_result_ptr[0], &local_mem[0]);
-        else
-          final_reducer.copy(&results_ptr[0], &local_mem[0]);
-      } else
-        final_reducer.copy(
-            &results_ptr[(item.get_group_linear_id()) * value_count],
-            &local_mem[0]);
-    }
-  }
-}
-
-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_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) {
-  const auto local_id = item.get_local_linear_id();
-
-  // Perform the actual workgroup reduction in each subgroup
-  // separately.
-  auto sg             = item.get_sub_group();
-  const auto id_in_sg = sg.get_local_id()[0];
-  const auto local_range =
-      std::min<unsigned int>(sg.get_local_range()[0], max_size);
-  const auto upper_stride_bound =
-      std::min(local_range - id_in_sg, max_size - local_id);
-  for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
-    auto tmp = sg.shuffle_down(local_value, stride);
-    if (stride < upper_stride_bound) final_reducer.join(&local_value, &tmp);
-  }
-
-  // Copy the subgroup results into the first positions of the
-  // reduction array.
-  const auto max_subgroup_size = sg.get_max_local_range()[0];
-  const auto n_active_subgroups =
-      (max_size + max_subgroup_size - 1) / max_subgroup_size;
-  if (id_in_sg == 0 && sg.get_group_id()[0] <= n_active_subgroups)
-    local_mem[sg.get_group_id()[0]] = local_value;
-  item.barrier(sycl::access::fence_space::local_space);
-
-  // Do the final reduction only using the first subgroup.
-  if (sg.get_group_id()[0] == 0) {
-    auto sg_value = local_mem[id_in_sg < n_active_subgroups ? id_in_sg : 0];
-
-    // In case the number of subgroups is larger than the range of
-    // the first subgroup, we first combine the items with a higher
-    // index.
-    if (n_active_subgroups > local_range) {
-      for (unsigned int offset = local_range; offset < n_active_subgroups;
-           offset += local_range)
-        if (id_in_sg + offset < n_active_subgroups) {
-          final_reducer.join(&sg_value, &local_mem[(id_in_sg + offset)]);
-        }
-      sg.barrier();
-    }
-
-    // Then, we proceed as before.
-    for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
-      auto tmp = sg.shuffle_down(sg_value, stride);
-      if (id_in_sg + stride < n_active_subgroups)
-        final_reducer.join(&sg_value, &tmp);
-    }
-
-    // Finally, we copy the workgroup results back to global memory
-    // to be used in the next iteration. If this is the last
-    // iteration, i.e., there is only one workgroup also call
-    // final() if necessary.
-    if (id_in_sg == 0) {
-      if (final) {
-        final_reducer.final(&sg_value);
-        if (device_accessible_result_ptr != nullptr)
-          device_accessible_result_ptr[0] = sg_value;
-        else
-          results_ptr[0] = sg_value;
-      } else
-        results_ptr[(item.get_group_linear_id())] = sg_value;
-    }
-  }
-}
-
-}  // namespace SYCLReduction
-
-template <class CombinedFunctorReducerType, class... Traits>
-class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
-                     Kokkos::Experimental::SYCL> {
- public:
-  using Policy      = Kokkos::RangePolicy<Traits...>;
-  using FunctorType = typename CombinedFunctorReducerType::functor_type;
-  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
-
- private:
-  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 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 View::memory_space>::accessible),
-        m_shared_memory_lock(
-            p.space().impl_internal_space_instance()->m_mutexScratchSpace) {}
-
- private:
-  template <typename PolicyType, typename CombinedFunctorReducerWrapper>
-  sycl::event sycl_direct_launch(
-      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 =
-        *space.impl_internal_space_instance();
-    sycl::queue& q = space.sycl_queue();
-
-    constexpr size_t values_per_thread = 2;
-    std::size_t size                   = policy.end() - policy.begin();
-    const unsigned int value_count =
-        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;
-
-    sycl::event last_reduction_event;
-
-    // If size<=1 we only call init(), the functor and possibly final once
-    // working with the global scratch memory but don't copy back to
-    // m_result_ptr yet.
-    if (size <= 1) {
-      results_ptr =
-          static_cast<sycl::device_ptr<value_type>>(instance.scratch_space(
-              sizeof(value_type) * std::max(value_count, 1u)));
-
-      auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        const auto begin = policy.begin();
-        cgh.depends_on(memcpy_event);
-        cgh.single_task([=]() {
-          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_v<WorkTag>)
-              functor(begin, update);
-            else
-              functor(WorkTag(), begin, update);
-          }
-          reducer.final(results_ptr);
-          if (device_accessible_result_ptr != nullptr)
-            reducer.copy(device_accessible_result_ptr.get(), results_ptr.get());
-        });
-      });
-      q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{parallel_reduce_event});
-      last_reduction_event = parallel_reduce_event;
-    }
-
-    // Otherwise, we perform a reduction on the values in all workgroups
-    // separately, write the workgroup results back to global memory and recurse
-    // until only one workgroup does the reduction and thus gets the final
-    // value.
-    if (size > 1) {
-      auto scratch_flags = static_cast<sycl::device_ptr<unsigned int>>(
-          instance.scratch_flags(sizeof(unsigned int)));
-
-      auto reduction_lambda_factory =
-          [&](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();
-
-            auto lambda = [=](sycl::nd_item<1> item) {
-              const auto n_wgroups   = item.get_group_range()[0];
-              const auto wgroup_size = item.get_local_range()[0];
-
-              const auto local_id = item.get_local_linear_id();
-              const auto global_id =
-                  wgroup_size * item.get_group_linear_id() * values_per_thread +
-                  local_id;
-              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 (ReducerType::static_value_size() == 0) {
-                reference_type update =
-                    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_v<WorkTag>)
-                    functor(id + begin, update);
-                  else
-                    functor(WorkTag(), id + begin, update);
-                }
-                item.barrier(sycl::access::fence_space::local_space);
-
-                SYCLReduction::workgroup_reduction<>(
-                    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,
-                                   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::local_space);
-                if (num_teams_done[0] == n_wgroups) {
-                  if (local_id >= n_wgroups)
-                    reducer.init(&local_mem[local_id * value_count]);
-                  else {
-                    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) {
-                      reducer.join(&local_mem[local_id * value_count],
-                                   &results_ptr[id * value_count]);
-                    }
-                  }
-
-                  SYCLReduction::workgroup_reduction<>(
-                      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 = reducer.init(&local_value);
-                for (index_type id = global_id; id < upper_bound;
-                     id += wgroup_size) {
-                  if constexpr (std::is_void_v<WorkTag>)
-                    functor(id + begin, update);
-                  else
-                    functor(WorkTag(), id + begin, update);
-                }
-
-                SYCLReduction::workgroup_reduction<>(
-                    item, local_mem, local_value, results_ptr,
-                    device_accessible_result_ptr, reducer, false,
-                    std::min(size, wgroup_size));
-
-                if (local_id == 0) {
-                  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::local_space);
-                if (num_teams_done[0] == n_wgroups) {
-                  if (local_id >= n_wgroups)
-                    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) {
-                      reducer.join(&local_value, &results_ptr[id]);
-                    }
-                  }
-
-                  SYCLReduction::workgroup_reduction<>(
-                      item, local_mem, local_value, results_ptr,
-                      device_accessible_result_ptr, reducer, true,
-                      std::min(n_wgroups, wgroup_size));
-                }
-              }
-            };
-            return lambda;
-          };
-
-      auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        sycl::local_accessor<unsigned int> num_teams_done(1, cgh);
-
-        auto dummy_reduction_lambda =
-            reduction_lambda_factory({1, cgh}, num_teams_done, nullptr);
-
-        static sycl::kernel kernel = [&] {
-          sycl::kernel_id functor_kernel_id =
-              sycl::get_kernel_id<decltype(dummy_reduction_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());
-
-// FIXME_SYCL 1024 seems to be invalid when running on a Volta70.
-#ifndef KOKKOS_ARCH_INTEL_GPU
-        if (max > 512) max = 512;
-#endif
-
-        const size_t wgroup_size =
-            static_cast<size_t>(max / multiple) * multiple;
-
-        const std::size_t init_size =
-            ((size + values_per_thread - 1) / values_per_thread + wgroup_size -
-             1) /
-            wgroup_size;
-        results_ptr =
-            static_cast<sycl::device_ptr<value_type>>(instance.scratch_space(
-                sizeof(value_type) * std::max(value_count, 1u) * init_size));
-
-        auto n_wgroups = ((size + values_per_thread - 1) / values_per_thread +
-                          wgroup_size - 1) /
-                         wgroup_size;
-
-        sycl::local_accessor<value_type> local_mem(
-            sycl::range<1>(wgroup_size) * std::max(value_count, 1u), cgh);
-
-        cgh.depends_on(memcpy_event);
-
-        auto reduction_lambda =
-            reduction_lambda_factory(local_mem, num_teams_done, results_ptr);
-        cgh.parallel_for(
-            sycl::nd_range<1>(n_wgroups * wgroup_size, wgroup_size),
-            reduction_lambda);
-      });
-
-      last_reduction_event = q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{parallel_reduce_event});
-    }
-
-    // At this point, the reduced value is written to the entry in results_ptr
-    // and all that is left is to copy it back to the given result pointer if
-    // necessary.
-    if (m_result_ptr && !m_result_ptr_device_accessible) {
-      Kokkos::Impl::DeepCopy<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                             Kokkos::Experimental::SYCLDeviceUSMSpace>(
-          space, m_result_ptr, results_ptr,
-          sizeof(*m_result_ptr) * value_count);
-    }
-
-    return last_reduction_event;
-  }
-
- public:
-  void execute() const {
-    Kokkos::Experimental::Impl::SYCLInternal& instance =
-        *m_policy.space().impl_internal_space_instance();
-    using IndirectKernelMem =
-        Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
-    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 CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-  const bool m_result_ptr_device_accessible;
-
-  // Only let one Parallel/Scan modify the shared memory. The
-  // constructor acquires the mutex which is released in the destructor.
-  std::scoped_lock<std::mutex> m_shared_memory_lock;
-};
-
-template <class CombinedFunctorReducerType, class... Traits>
-class ParallelReduce<CombinedFunctorReducerType,
-                     Kokkos::MDRangePolicy<Traits...>,
-                     Kokkos::Experimental::SYCL> {
- public:
-  using Policy      = Kokkos::MDRangePolicy<Traits...>;
-  using FunctorType = typename CombinedFunctorReducerType::functor_type;
-  using ReducerType = typename CombinedFunctorReducerType::reducer_type;
-
- private:
-  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;
-
-  // MDRangePolicy is not trivially copyable. Hence, replicate the data we
-  // really need in DeviceIterateTile in a trivially copyable struct.
-  struct BarePolicy {
-    using index_type = typename Policy::index_type;
-
-    BarePolicy(const Policy& policy)
-        : m_lower(policy.m_lower),
-          m_upper(policy.m_upper),
-          m_tile(policy.m_tile),
-          m_tile_end(policy.m_tile_end),
-          m_num_tiles(policy.m_num_tiles),
-          m_prod_tile_dims(policy.m_prod_tile_dims) {}
-
-    const typename Policy::point_type m_lower;
-    const typename Policy::point_type m_upper;
-    const typename Policy::tile_type m_tile;
-    const typename Policy::point_type m_tile_end;
-    const typename Policy::index_type m_num_tiles;
-    const typename Policy::index_type m_prod_tile_dims;
-    static constexpr Iterate inner_direction = Policy::inner_direction;
-    static constexpr int rank                = Policy::rank;
-  };
-
- public:
-  // V - View
-  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 View::memory_space>::accessible),
-        m_shared_memory_lock(
-            m_space.impl_internal_space_instance()->m_mutexScratchSpace) {}
-
- private:
-  template <typename PolicyType, typename CombinedFunctorReducerWrapper>
-  sycl::event sycl_direct_launch(
-      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();
-    sycl::queue& q = m_space.sycl_queue();
-
-    const typename Policy::index_type nwork = m_policy.m_num_tiles;
-    const typename Policy::index_type block_size =
-        std::pow(2, std::ceil(std::log2(m_policy.m_prod_tile_dims)));
-
-    const sycl::range<1> local_range(block_size);
-    // REMEMBER swap local x<->y to be conforming with Cuda/HIP implementation
-    const sycl::range<1> global_range(nwork * block_size);
-    const sycl::nd_range<1> range{global_range, local_range};
-
-    const size_t wgroup_size = range.get_local_range().size();
-    size_t size              = range.get_global_range().size();
-    const auto init_size =
-        std::max<std::size_t>((size + wgroup_size - 1) / wgroup_size, 1);
-    const unsigned int value_count =
-        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));
-    sycl::global_ptr<value_type> device_accessible_result_ptr =
-        m_result_ptr_device_accessible ? m_result_ptr : nullptr;
-    auto scratch_flags = static_cast<sycl::device_ptr<unsigned int>>(
-        instance.scratch_flags(sizeof(unsigned int)));
-
-    sycl::event last_reduction_event;
-
-    // If size<=1 we only call init(), the functor and possibly final once
-    // working with the global scratch memory but don't copy back to
-    // m_result_ptr yet.
-    if (size <= 1) {
-      auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        cgh.depends_on(memcpy_event);
-        cgh.single_task([=]() {
-          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) {
-            Kokkos::Impl::Reduce::DeviceIterateTile<
-                Policy::rank, BarePolicy, FunctorType,
-                typename Policy::work_tag, reference_type>(
-                policy, functor, update, {1, 1, 1}, {0, 0, 0}, {0, 0, 0})
-                .exec_range();
-          }
-          reducer.final(results_ptr);
-          if (device_accessible_result_ptr)
-            reducer.copy(device_accessible_result_ptr.get(), results_ptr.get());
-        });
-      });
-      q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{parallel_reduce_event});
-      last_reduction_event = parallel_reduce_event;
-    }
-
-    // Otherwise, we perform a reduction on the values in all workgroups
-    // separately, write the workgroup results back to global memory and recurse
-    // until only one workgroup does the reduction and thus gets the final
-    // value.
-    if (size > 1) {
-      auto n_wgroups             = (size + wgroup_size - 1) / wgroup_size;
-      auto parallel_reduce_event = q.submit([&](sycl::handler& 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_event);
-
-        cgh.parallel_for(range, [=](sycl::nd_item<1> item) {
-          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
-          // results from the previous iteration that are stored in global
-          // memory.
-          using index_type = typename Policy::index_type;
-
-          // SWAPPED here to be conforming with CUDA implementation
-          const index_type local_x    = 0;
-          const index_type local_y    = item.get_local_id(0);
-          const index_type local_z    = 0;
-          const index_type global_x   = item.get_group(0);
-          const index_type global_y   = 0;
-          const index_type global_z   = 0;
-          const index_type n_global_x = item.get_group_range(0);
-          const index_type n_global_y = 1;
-          const index_type n_global_z = 1;
-
-          if constexpr (ReducerType::static_value_size() == 0) {
-            reference_type update =
-                reducer.init(&local_mem[local_id * value_count]);
-
-            Kokkos::Impl::Reduce::DeviceIterateTile<
-                Policy::rank, BarePolicy, FunctorType,
-                typename Policy::work_tag, reference_type>(
-                bare_policy, functor, update,
-                {n_global_x, n_global_y, n_global_z},
-                {global_x, global_y, global_z}, {local_x, local_y, local_z})
-                .exec_range();
-            item.barrier(sycl::access::fence_space::local_space);
-
-            SYCLReduction::workgroup_reduction<>(
-                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,
-                               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::local_space);
-            if (num_teams_done[0] == n_wgroups) {
-              if (local_id >= n_wgroups)
-                reducer.init(&local_mem[local_id * value_count]);
-              else {
-                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) {
-                  reducer.join(&local_mem[local_id * value_count],
-                               &results_ptr[id * value_count]);
-                }
-              }
-
-              SYCLReduction::workgroup_reduction<>(
-                  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 = reducer.init(&local_value);
-
-            Kokkos::Impl::Reduce::DeviceIterateTile<
-                Policy::rank, BarePolicy, FunctorType,
-                typename Policy::work_tag, reference_type>(
-                bare_policy, functor, update,
-                {n_global_x, n_global_y, n_global_z},
-                {global_x, global_y, global_z}, {local_x, local_y, local_z})
-                .exec_range();
-
-            SYCLReduction::workgroup_reduction<>(
-                item, local_mem, local_value, results_ptr,
-                device_accessible_result_ptr, reducer, false,
-                std::min(size, wgroup_size));
-
-            if (local_id == 0) {
-              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::local_space);
-            if (num_teams_done[0] == n_wgroups) {
-              if (local_id >= n_wgroups)
-                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) {
-                  reducer.join(&local_value, &results_ptr[id]);
-                }
-              }
-
-              SYCLReduction::workgroup_reduction<>(
-                  item, local_mem, local_value, results_ptr,
-                  device_accessible_result_ptr, reducer, true,
-                  std::min(n_wgroups, wgroup_size));
-            }
-          }
-        });
-      });
-      last_reduction_event       = q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{parallel_reduce_event});
-    }
-
-    // At this point, the reduced value is written to the entry in results_ptr
-    // and all that is left is to copy it back to the given result pointer if
-    // necessary.
-    if (m_result_ptr && !m_result_ptr_device_accessible) {
-      Kokkos::Impl::DeepCopy<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                             Kokkos::Experimental::SYCLDeviceUSMSpace>(
-          m_space, m_result_ptr, results_ptr,
-          sizeof(*m_result_ptr) * value_count);
-    }
-
-    return last_reduction_event;
-  }
-
- public:
-  template <typename Policy, typename Functor>
-  static int max_tile_size_product(const Policy& policy, const Functor&) {
-    return policy.space().impl_internal_space_instance()->m_maxWorkgroupSize;
-  }
-
-  void execute() const {
-    Kokkos::Experimental::Impl::SYCLInternal& instance =
-        *m_space.impl_internal_space_instance();
-    using IndirectKernelMem =
-        Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
-    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 CombinedFunctorReducerType m_functor_reducer;
-  const BarePolicy m_policy;
-  const Kokkos::Experimental::SYCL& m_space;
-  const pointer_type m_result_ptr;
-  const bool m_result_ptr_device_accessible;
-
-  // Only let one Parallel/Scan modify the shared memory. The
-  // constructor acquires the mutex which is released in the destructor.
-  std::scoped_lock<std::mutex> m_shared_memory_lock;
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif
-#endif /* KOKKOS_SYCL_PARALLEL_REDUCE_HPP */
diff --git a/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp b/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp
deleted file mode 100644
index e46b00f073..0000000000
--- a/core/src/SYCL/Kokkos_SYCL_Parallel_Team.hpp
+++ /dev/null
@@ -1,914 +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_SYCL_PARALLEL_TEAM_HPP
-#define KOKKOS_SYCL_PARALLEL_TEAM_HPP
-
-#include <Kokkos_Parallel.hpp>
-
-#include <SYCL/Kokkos_SYCL_Parallel_Reduce.hpp>  // workgroup_reduction
-#include <SYCL/Kokkos_SYCL_Team.hpp>
-
-#include <vector>
-
-namespace Kokkos {
-namespace Impl {
-template <typename... Properties>
-class TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>
-    : public PolicyTraits<Properties...> {
- public:
-  using execution_policy = TeamPolicyInternal;
-
-  using traits = PolicyTraits<Properties...>;
-
-  template <typename ExecSpace, typename... OtherProperties>
-  friend class TeamPolicyInternal;
-
- private:
-  typename traits::execution_space m_space;
-  int m_league_size;
-  int m_team_size;
-  int m_vector_length;
-  size_t m_team_scratch_size[2];
-  size_t m_thread_scratch_size[2];
-  int m_chunk_size;
-  bool m_tune_team_size;
-  bool m_tune_vector_length;
-
- public:
-  using execution_space = Kokkos::Experimental::SYCL;
-
-  template <class... OtherProperties>
-  TeamPolicyInternal(TeamPolicyInternal<OtherProperties...> const& p) {
-    m_league_size            = p.m_league_size;
-    m_team_size              = p.m_team_size;
-    m_vector_length          = p.m_vector_length;
-    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
-    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
-    m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
-    m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
-    m_chunk_size             = p.m_chunk_size;
-    m_space                  = p.m_space;
-    m_tune_team_size         = p.m_tune_team_size;
-    m_tune_vector_length     = p.m_tune_vector_length;
-  }
-
-  template <typename FunctorType>
-  int team_size_max(FunctorType const& f, ParallelForTag const&) const {
-    return internal_team_size_max_for(f);
-  }
-
-  template <class FunctorType>
-  inline int team_size_max(const FunctorType& f,
-                           const ParallelReduceTag&) const {
-    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<typename ReducerType::value_type>(f);
-  }
-
-  template <typename FunctorType>
-  int team_size_recommended(FunctorType const& f, ParallelForTag const&) const {
-    return internal_team_size_recommended_for(f);
-  }
-
-  template <typename FunctorType>
-  inline int team_size_recommended(FunctorType const& f,
-                                   ParallelReduceTag const&) const {
-    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<
-        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; }
-  // FIXME_SYCL This is correct in most cases, but not necessarily in case a
-  // custom sycl::queue is used to initialize the execution space.
-  static int vector_length_max() {
-    std::vector<size_t> sub_group_sizes =
-        execution_space{}
-            .impl_internal_space_instance()
-            ->m_queue->get_device()
-            .template get_info<sycl::info::device::sub_group_sizes>();
-    return *std::max_element(sub_group_sizes.begin(), sub_group_sizes.end());
-  }
-
- private:
-  static int verify_requested_vector_length(int requested_vector_length) {
-    int test_vector_length =
-        std::min(requested_vector_length, vector_length_max());
-
-    // Allow only power-of-two vector_length
-    if (!(is_integral_power_of_two(test_vector_length))) {
-      int test_pow2 = 1;
-      while (test_pow2 < test_vector_length) test_pow2 <<= 1;
-      test_vector_length = test_pow2 >> 1;
-    }
-
-    return test_vector_length;
-  }
-
- public:
-  static int scratch_size_max(int level) {
-    return level == 0 ? 1024 * 32
-                      :           // FIXME_SYCL arbitrarily setting this to 32kB
-               20 * 1024 * 1024;  // FIXME_SYCL arbitrarily setting this to 20MB
-  }
-  inline void impl_set_vector_length(size_t size) { m_vector_length = size; }
-  inline void impl_set_team_size(size_t size) { m_team_size = size; }
-  int impl_vector_length() const { return m_vector_length; }
-
-  int team_size() const { return m_team_size; }
-
-  int league_size() const { return m_league_size; }
-
-  size_t scratch_size(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];
-  }
-
-  size_t team_scratch_size(int level) const {
-    return m_team_scratch_size[level];
-  }
-
-  size_t thread_scratch_size(int level) const {
-    return m_thread_scratch_size[level];
-  }
-
-  typename traits::execution_space space() const { return m_space; }
-
-  TeamPolicyInternal()
-      : m_space(typename traits::execution_space()),
-        m_league_size(0),
-        m_team_size(-1),
-        m_vector_length(0),
-        m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(vector_length_max()),
-        m_tune_team_size(false),
-        m_tune_vector_length(false) {}
-
-  /** \brief  Specify league size, request team size */
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     int team_size_request, int vector_length_request = 1)
-      : m_space(space_),
-        m_league_size(league_size_),
-        m_team_size(team_size_request),
-        m_vector_length(
-            (vector_length_request > 0)
-                ? verify_requested_vector_length(vector_length_request)
-                : (verify_requested_vector_length(1))),
-        m_team_scratch_size{0, 0},
-        m_thread_scratch_size{0, 0},
-        m_chunk_size(vector_length_max()),
-        m_tune_team_size(bool(team_size_request <= 0)),
-        m_tune_vector_length(bool(vector_length_request <= 0)) {
-    // FIXME_SYCL Check that league size is permissible,
-    // https://github.com/intel/llvm/pull/4064
-
-    // Make sure total block size is permissible
-    if (m_team_size * m_vector_length >
-        static_cast<int>(
-            m_space.impl_internal_space_instance()->m_maxWorkgroupSize)) {
-      Impl::throw_runtime_exception(
-          std::string("Kokkos::TeamPolicy<SYCL> the team size is too large. "
-                      "Team size x vector length is " +
-                      std::to_string(m_team_size * m_vector_length) +
-                      " but must be smaller than ") +
-          std::to_string(
-              m_space.impl_internal_space_instance()->m_maxWorkgroupSize));
-    }
-  }
-
-  /** \brief  Specify league size, request team size */
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     int vector_length_request = 1)
-      : TeamPolicyInternal(space_, league_size_, -1, vector_length_request) {}
-  // FLAG
-  /** \brief  Specify league size and team size, request vector length*/
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     int team_size_request,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-                     )
-      : TeamPolicyInternal(space_, league_size_, team_size_request, -1)
-
-  {}
-
-  /** \brief  Specify league size, request team size and vector length*/
-  TeamPolicyInternal(const execution_space space_, int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-
-                     )
-      : TeamPolicyInternal(space_, league_size_, -1, -1)
-
-  {}
-
-  TeamPolicyInternal(int league_size_, int team_size_request,
-                     int vector_length_request = 1)
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
-                           team_size_request, vector_length_request) {}
-
-  TeamPolicyInternal(int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     int vector_length_request = 1)
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
-                           vector_length_request) {}
-
-  /** \brief  Specify league size and team size, request vector length*/
-  TeamPolicyInternal(int league_size_, int team_size_request,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-
-                     )
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
-                           team_size_request, -1)
-
-  {}
-
-  /** \brief  Specify league size, request team size and vector length*/
-  TeamPolicyInternal(int league_size_,
-                     const Kokkos::AUTO_t& /* team_size_request */,
-                     const Kokkos::AUTO_t& /* vector_length_request */
-
-                     )
-      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
-                           -1) {}
-
-  int chunk_size() const { return m_chunk_size; }
-
-  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 */
-  TeamPolicyInternal& set_scratch_size(int level,
-                                       PerTeamValue const& 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 */
-  TeamPolicyInternal& set_scratch_size(int level,
-                                       PerThreadValue const& 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 */
-  TeamPolicyInternal& set_scratch_size(int level, PerTeamValue const& per_team,
-                                       PerThreadValue const& per_thread) {
-    m_team_scratch_size[level]   = per_team.value;
-    m_thread_scratch_size[level] = per_thread.value;
-    return *this;
-  }
-
-  using member_type = Kokkos::Impl::SYCLTeamMember;
-
- protected:
-  template <class FunctorType>
-  int internal_team_size_max_for(const FunctorType& /*f*/) const {
-    // nested_reducer_memsize = (sizeof(double) * (m_team_size + 2)
-    // custom: m_team_scratch_size[0] + m_thread_scratch_size[0] * m_team_size
-    // total:
-    // 2*sizeof(double)+m_team_scratch_size[0]
-    // + m_team_size(sizeof(double)+m_thread_scratch_size[0])
-    const int max_threads_for_memory =
-        (space().impl_internal_space_instance()->m_maxShmemPerBlock -
-         2 * sizeof(double) - m_team_scratch_size[0]) /
-        (sizeof(double) + m_thread_scratch_size[0]);
-    return std::min({
-             int(m_space.impl_internal_space_instance()->m_maxWorkgroupSize),
-      // FIXME_SYCL Avoid requesting too many registers on NVIDIA GPUs.
-#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
-                 256,
-#endif
-                 max_threads_for_memory
-           }) /
-           impl_vector_length();
-  }
-
-  template <class ValueType, class FunctorType>
-  int internal_team_size_max_reduce(const FunctorType& f) const {
-    using Analysis =
-        FunctorAnalysis<FunctorPatternInterface::REDUCE, TeamPolicyInternal,
-                        FunctorType, ValueType>;
-    using value_type      = typename Analysis::value_type;
-    const int value_count = Analysis::value_count(f);
-
-    // nested_reducer_memsize = (sizeof(double) * (m_team_size + 2)
-    // reducer_memsize = sizeof(value_type) * m_team_size * value_count
-    // custom: m_team_scratch_size[0] + m_thread_scratch_size[0] * m_team_size
-    // total:
-    // 2*sizeof(double)+m_team_scratch_size[0]
-    // + m_team_size(sizeof(double)+sizeof(value_type)*value_count
-    //               +m_thread_scratch_size[0])
-    const int max_threads_for_memory =
-        (space().impl_internal_space_instance()->m_maxShmemPerBlock -
-         2 * sizeof(double) - m_team_scratch_size[0]) /
-        (sizeof(double) + sizeof(value_type) * value_count +
-         m_thread_scratch_size[0]);
-    return std::min<int>({
-             int(m_space.impl_internal_space_instance()->m_maxWorkgroupSize),
-      // FIXME_SYCL Avoid requesting too many registers on NVIDIA GPUs.
-#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
-                 256,
-#endif
-                 max_threads_for_memory
-           }) /
-           impl_vector_length();
-  }
-
-  template <class FunctorType>
-  int internal_team_size_recommended_for(const FunctorType& f) const {
-    // FIXME_SYCL improve
-    return 1 << Kokkos::Impl::int_log2(internal_team_size_max_for(f));
-  }
-
-  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<ValueType>(f));
-  }
-};
-
-template <typename FunctorType, typename... Properties>
-class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
-                  Kokkos::Experimental::SYCL> {
- public:
-  using Policy = TeamPolicyInternal<Kokkos::Experimental::SYCL, Properties...>;
-  using functor_type = FunctorType;
-  using size_type    = ::Kokkos::Experimental::SYCL::size_type;
-
- private:
-  using member_type   = typename Policy::member_type;
-  using work_tag      = typename Policy::work_tag;
-  using launch_bounds = typename Policy::launch_bounds;
-
-  FunctorType const m_functor;
-  Policy const m_policy;
-  size_type const m_league_size;
-  int m_team_size;
-  size_type const m_vector_size;
-  int m_shmem_begin;
-  int m_shmem_size;
-  sycl::device_ptr<char> m_global_scratch_ptr;
-  size_t m_scratch_size[2];
-  // 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_event) const {
-    // Convenience references
-    const Kokkos::Experimental::SYCL& space = policy.space();
-    sycl::queue& q                          = space.sycl_queue();
-
-    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::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;
-
-      auto lambda = [=](sycl::nd_item<2> item) {
-        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<work_tag>::value)
-          functor_wrapper.get_functor()(team_member);
-        else
-          functor_wrapper.get_functor()(work_tag(), team_member);
-      };
-
-      static sycl::kernel kernel = [&] {
-        sycl::kernel_id functor_kernel_id =
-            sycl::get_kernel_id<decltype(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 max_sg_size =
-          kernel
-              .get_info<sycl::info::kernel_device_specific::max_sub_group_size>(
-                  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_event);
-      cgh.parallel_for(
-          sycl::nd_range<2>(
-              sycl::range<2>(m_team_size, m_league_size * final_vector_size),
-              sycl::range<2>(m_team_size, final_vector_size)),
-          lambda);
-    });
-    q.ext_oneapi_submit_barrier(std::vector<sycl::event>{parallel_for_event});
-    return parallel_for_event;
-  }
-
- public:
-  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 = space.get_indirect_kernel_mem();
-
-    auto functor_wrapper = Experimental::Impl::make_sycl_function_wrapper(
-        m_functor, indirectKernelMem);
-
-    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)
-      : m_functor(arg_functor),
-        m_policy(arg_policy),
-        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) {
-    // FIXME_SYCL optimize
-    if (m_team_size < 0)
-      m_team_size =
-          m_policy.team_size_recommended(arg_functor, ParallelForTag{});
-
-    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_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();
-    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) <
-        m_shmem_size - m_shmem_begin) {
-      std::stringstream out;
-      out << "Kokkos::Impl::ParallelFor<SYCL> insufficient shared memory! "
-             "Requested "
-          << m_shmem_size - m_shmem_begin << " bytes but maximum is "
-          << space.m_maxShmemPerBlock << '\n';
-      Kokkos::Impl::throw_runtime_exception(out.str());
-    }
-
-    const auto max_team_size =
-        m_policy.team_size_max(arg_functor, ParallelForTag{});
-    if (m_team_size > m_policy.team_size_max(arg_functor, ParallelForTag{}))
-      Kokkos::Impl::throw_runtime_exception(
-          "Kokkos::Impl::ParallelFor<SYCL> requested too large team size. The "
-          "maximal team_size is " +
-          std::to_string(max_team_size) + '!');
-  }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-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 member_type   = typename Policy::member_type;
-  using WorkTag       = typename Policy::work_tag;
-  using launch_bounds = typename Policy::launch_bounds;
-
-  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 CombinedFunctorReducerType m_functor_reducer;
-  const Policy m_policy;
-  const pointer_type m_result_ptr;
-  const bool m_result_ptr_device_accessible;
-  size_type m_shmem_begin;
-  size_type m_shmem_size;
-  sycl::device_ptr<char> m_global_scratch_ptr;
-  size_t m_scratch_size[2];
-  const size_type m_league_size;
-  int m_team_size;
-  const size_type m_vector_size;
-  // 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 CombinedFunctorReducerWrapper>
-  sycl::event sycl_direct_launch(
-      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 =
-        *space.impl_internal_space_instance();
-    sycl::queue& q = space.sycl_queue();
-
-    const unsigned int value_count =
-        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;
-
-    sycl::event last_reduction_event;
-
-    // If size<=1 we only call init(), the functor and possibly final once
-    // working with the global scratch memory but don't copy back to
-    // m_result_ptr yet.
-    if (size <= 1) {
-      results_ptr =
-          static_cast<sycl::device_ptr<value_type>>(instance.scratch_space(
-              sizeof(value_type) * std::max(value_count, 1u)));
-      sycl::global_ptr<value_type> device_accessible_result_ptr =
-          m_result_ptr_device_accessible ? m_result_ptr : nullptr;
-
-      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::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_event);
-        cgh.parallel_for(
-            sycl::nd_range<2>(sycl::range<2>(1, 1), sycl::range<2>(1, 1)),
-            [=](sycl::nd_item<2> item) {
-              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_v<WorkTag>)
-                  functor(team_member, update);
-                else
-                  functor(WorkTag(), team_member, update);
-              }
-              reducer.final(results_ptr);
-              if (device_accessible_result_ptr)
-                reducer.copy(device_accessible_result_ptr, &results_ptr[0]);
-            });
-      });
-      q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{parallel_reduce_event});
-      last_reduction_event = parallel_reduce_event;
-    } else {
-      // Otherwise, (if the total range has more than one element) we perform a
-      // reduction on the values in all workgroups separately, write the
-      // workgroup results back to global memory and recurse until only one
-      // workgroup does the reduction and thus gets the final value.
-      auto parallel_reduce_event = q.submit([&](sycl::handler& cgh) {
-        auto scratch_flags = static_cast<sycl::device_ptr<unsigned int>>(
-            instance.scratch_flags(sizeof(unsigned int)));
-
-        // FIXME_SYCL accessors seem to need a size greater than zero at least
-        // for host queues
-        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;
-
-        auto team_reduction_factory =
-            [&](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;
-              auto lambda = [=](sycl::nd_item<2> item) {
-                auto n_wgroups =
-                    item.get_group_range()[0] * item.get_group_range()[1];
-                auto wgroup_size =
-                    item.get_local_range()[0] * item.get_local_range()[1];
-                auto size = n_wgroups * wgroup_size;
-
-                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 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 =
-                      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_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, 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]));
-
-                  if (local_id == 0) {
-                    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 = ++scratch_flags_ref;
-                  }
-                  sycl::group_barrier(item.get_group());
-                  if (num_teams_done == n_wgroups) {
-                    if (local_id >= n_wgroups)
-                      reducer.init(&local_mem[local_id * value_count]);
-                    else {
-                      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) {
-                        reducer.join(&local_mem[local_id * value_count],
-                                     &results_ptr[id * value_count]);
-                      }
-                    }
-
-                    SYCLReduction::workgroup_reduction<>(
-                        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 = 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_v<WorkTag>)
-                    functor(team_member, update);
-                  else
-                    functor(WorkTag(), team_member, update);
-
-                  SYCLReduction::workgroup_reduction<>(
-                      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]));
-
-                  if (local_id == 0) {
-                    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 = ++scratch_flags_ref;
-                  }
-                  item.barrier(sycl::access::fence_space::local_space);
-                  if (num_teams_done == n_wgroups) {
-                    if (local_id >= n_wgroups)
-                      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) {
-                        reducer.join(&local_value, &results_ptr[id]);
-                      }
-                    }
-
-                    SYCLReduction::workgroup_reduction<>(
-                        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]));
-                  }
-                }
-              };
-              return lambda;
-            };
-
-        auto dummy_reduction_lambda = team_reduction_factory({1, cgh}, nullptr);
-
-        static sycl::kernel kernel = [&] {
-          sycl::kernel_id functor_kernel_id =
-              sycl::get_kernel_id<decltype(dummy_reduction_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 max_sg_size = kernel.get_info<
-            sycl::info::kernel_device_specific::max_sub_group_size>(
-            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);
-
-        auto wgroup_size = m_team_size * final_vector_size;
-        std::size_t size = std::size_t(m_league_size) * wgroup_size;
-        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);
-        results_ptr =
-            static_cast<sycl::device_ptr<value_type>>(instance.scratch_space(
-                sizeof(value_type) * std::max(value_count, 1u) * init_size));
-
-        auto reduction_lambda = team_reduction_factory(local_mem, results_ptr);
-
-        cgh.depends_on(memcpy_event);
-
-        cgh.parallel_for(
-            sycl::nd_range<2>(
-                sycl::range<2>(m_team_size, m_league_size * m_vector_size),
-                sycl::range<2>(m_team_size, m_vector_size)),
-            reduction_lambda);
-      });
-      last_reduction_event       = q.ext_oneapi_submit_barrier(
-          std::vector<sycl::event>{parallel_reduce_event});
-    }
-
-    // At this point, the reduced value is written to the entry in results_ptr
-    // and all that is left is to copy it back to the given result pointer if
-    // necessary.
-    if (m_result_ptr && !m_result_ptr_device_accessible) {
-      Kokkos::Impl::DeepCopy<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                             Kokkos::Experimental::SYCLDeviceUSMSpace>(
-          space, m_result_ptr, results_ptr,
-          sizeof(*m_result_ptr) * value_count);
-    }
-
-    return last_reduction_event;
-  }
-
- public:
-  inline void execute() {
-    Kokkos::Experimental::Impl::SYCLInternal& instance =
-        *m_policy.space().impl_internal_space_instance();
-    using IndirectKernelMem =
-        Kokkos::Experimental::Impl::SYCLInternal::IndirectKernelMem;
-    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);
-    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_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) {
-      int temp_team_size = 2;
-      while ((temp_team_size << 1) < m_team_size) temp_team_size <<= 1;
-      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_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();
-    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) <
-        m_shmem_size - m_shmem_begin) {
-      std::stringstream out;
-      out << "Kokkos::Impl::ParallelFor<SYCL> insufficient shared memory! "
-             "Requested "
-          << m_shmem_size - m_shmem_begin << " bytes but maximum is "
-          << space.m_maxShmemPerBlock << '\n';
-      Kokkos::Impl::throw_runtime_exception(out.str());
-    }
-
-    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(CombinedFunctorReducerType const& arg_functor_reducer,
-                 Policy const& arg_policy, ViewType const& arg_result)
-      : m_functor_reducer(arg_functor_reducer),
-        m_policy(arg_policy),
-        m_result_ptr(arg_result.data()),
-        m_result_ptr_device_accessible(
-            MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                              typename ViewType::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
-
-#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Space.cpp b/core/src/SYCL/Kokkos_SYCL_Space.cpp
index 62af720b7c..19fad29150 100644
--- a/core/src/SYCL/Kokkos_SYCL_Space.cpp
+++ b/core/src/SYCL/Kokkos_SYCL_Space.cpp
@@ -25,7 +25,6 @@
 #include <SYCL/Kokkos_SYCL_Space.hpp>
 #include <SYCL/Kokkos_SYCL_DeepCopy.hpp>
 #include <SYCL/Kokkos_SYCL_Instance.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
 #include <impl/Kokkos_Profiling.hpp>
 
 /*--------------------------------------------------------------------------*/
@@ -41,7 +40,9 @@ void DeepCopyAsyncSYCL(const Kokkos::Experimental::SYCL& instance, void* dst,
                        const void* src, size_t n) {
   sycl::queue& q = *instance.impl_internal_space_instance()->m_queue;
   auto event     = q.memcpy(dst, src, n);
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
   q.ext_oneapi_submit_barrier(std::vector<sycl::event>{event});
+#endif
 }
 
 void DeepCopyAsyncSYCL(void* dst, const void* src, size_t n) {
@@ -55,6 +56,23 @@ void DeepCopyAsyncSYCL(void* dst, const void* src, size_t n) {
 
 /*--------------------------------------------------------------------------*/
 /*--------------------------------------------------------------------------*/
+namespace {
+
+std::string_view get_memory_space_name(sycl::usm::alloc allocation_kind) {
+  switch (allocation_kind) {
+    case sycl::usm::alloc::host:
+      return Kokkos::Experimental::SYCLHostUSMSpace::name();
+    case sycl::usm::alloc::device:
+      return Kokkos::Experimental::SYCLDeviceUSMSpace::name();
+    case sycl::usm::alloc::shared:
+      return Kokkos::Experimental::SYCLSharedUSMSpace::name();
+    default:
+      Kokkos::abort("bug: unknown sycl allocation type");
+      return "unreachable";
+  }
+}
+
+}  // namespace
 
 namespace Kokkos {
 namespace Experimental {
@@ -74,17 +92,17 @@ SYCLHostUSMSpace::SYCLHostUSMSpace()
 SYCLHostUSMSpace::SYCLHostUSMSpace(sycl::queue queue)
     : m_queue(std::move(queue)) {}
 
-void* allocate_sycl(
-    const char* arg_label, const size_t arg_alloc_size,
-    const size_t arg_logical_size, const Kokkos::Tools::SpaceHandle arg_handle,
-    const RawMemoryAllocationFailure::AllocationMechanism failure_tag,
-    const sycl::usm::alloc allocation_kind, const sycl::queue& queue) {
+void* allocate_sycl(const char* arg_label, const size_t arg_alloc_size,
+                    const size_t arg_logical_size,
+                    const Kokkos::Tools::SpaceHandle arg_handle,
+                    const sycl::usm::alloc allocation_kind,
+                    const sycl::queue& queue) {
   void* const hostPtr = sycl::malloc(arg_alloc_size, queue, allocation_kind);
 
-  if (hostPtr == nullptr)
-    throw RawMemoryAllocationFailure(
-        arg_alloc_size, 1, RawMemoryAllocationFailure::FailureMode::Unknown,
-        failure_tag);
+  if (hostPtr == nullptr) {
+    Kokkos::Impl::throw_bad_alloc(get_memory_space_name(allocation_kind),
+                                  arg_alloc_size, arg_label);
+  }
 
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     const size_t reported_size =
@@ -105,12 +123,10 @@ void* SYCLDeviceUSMSpace::allocate(const Kokkos::Experimental::SYCL& exec_space,
                                    const char* arg_label,
                                    const size_t arg_alloc_size,
                                    const size_t arg_logical_size) const {
-  return allocate_sycl(
-      arg_label, arg_alloc_size, arg_logical_size,
-      Kokkos::Tools::make_space_handle(name()),
-      RawMemoryAllocationFailure::AllocationMechanism::SYCLMallocDevice,
-      sycl::usm::alloc::device,
-      *exec_space.impl_internal_space_instance()->m_queue);
+  return allocate_sycl(arg_label, arg_alloc_size, arg_logical_size,
+                       Kokkos::Tools::make_space_handle(name()),
+                       sycl::usm::alloc::device,
+                       *exec_space.impl_internal_space_instance()->m_queue);
 }
 
 void* SYCLDeviceUSMSpace::allocate(const size_t arg_alloc_size) const {
@@ -120,11 +136,9 @@ void* SYCLDeviceUSMSpace::allocate(const size_t arg_alloc_size) const {
 void* SYCLDeviceUSMSpace::allocate(const char* arg_label,
                                    const size_t arg_alloc_size,
                                    const size_t arg_logical_size) const {
-  return allocate_sycl(
-      arg_label, arg_alloc_size, arg_logical_size,
-      Kokkos::Tools::make_space_handle(name()),
-      RawMemoryAllocationFailure::AllocationMechanism::SYCLMallocDevice,
-      sycl::usm::alloc::device, m_queue);
+  return allocate_sycl(arg_label, arg_alloc_size, arg_logical_size,
+                       Kokkos::Tools::make_space_handle(name()),
+                       sycl::usm::alloc::device, m_queue);
 }
 
 void* SYCLSharedUSMSpace::allocate(const SYCL& exec_space,
@@ -135,12 +149,10 @@ void* SYCLSharedUSMSpace::allocate(const SYCL& exec_space,
                                    const char* arg_label,
                                    const size_t arg_alloc_size,
                                    const size_t arg_logical_size) const {
-  return allocate_sycl(
-      arg_label, arg_alloc_size, arg_logical_size,
-      Kokkos::Tools::make_space_handle(name()),
-      RawMemoryAllocationFailure::AllocationMechanism::SYCLMallocShared,
-      sycl::usm::alloc::shared,
-      *exec_space.impl_internal_space_instance()->m_queue);
+  return allocate_sycl(arg_label, arg_alloc_size, arg_logical_size,
+                       Kokkos::Tools::make_space_handle(name()),
+                       sycl::usm::alloc::shared,
+                       *exec_space.impl_internal_space_instance()->m_queue);
 }
 
 void* SYCLSharedUSMSpace::allocate(const size_t arg_alloc_size) const {
@@ -149,11 +161,9 @@ void* SYCLSharedUSMSpace::allocate(const size_t arg_alloc_size) const {
 void* SYCLSharedUSMSpace::allocate(const char* arg_label,
                                    const size_t arg_alloc_size,
                                    const size_t arg_logical_size) const {
-  return allocate_sycl(
-      arg_label, arg_alloc_size, arg_logical_size,
-      Kokkos::Tools::make_space_handle(name()),
-      RawMemoryAllocationFailure::AllocationMechanism::SYCLMallocShared,
-      sycl::usm::alloc::shared, m_queue);
+  return allocate_sycl(arg_label, arg_alloc_size, arg_logical_size,
+                       Kokkos::Tools::make_space_handle(name()),
+                       sycl::usm::alloc::shared, m_queue);
 }
 
 void* SYCLHostUSMSpace::allocate(const SYCL& exec_space,
@@ -163,12 +173,10 @@ void* SYCLHostUSMSpace::allocate(const SYCL& exec_space,
 void* SYCLHostUSMSpace::allocate(const SYCL& exec_space, const char* arg_label,
                                  const size_t arg_alloc_size,
                                  const size_t arg_logical_size) const {
-  return allocate_sycl(
-      arg_label, arg_alloc_size, arg_logical_size,
-      Kokkos::Tools::make_space_handle(name()),
-      RawMemoryAllocationFailure::AllocationMechanism::SYCLMallocHost,
-      sycl::usm::alloc::host,
-      *exec_space.impl_internal_space_instance()->m_queue);
+  return allocate_sycl(arg_label, arg_alloc_size, arg_logical_size,
+                       Kokkos::Tools::make_space_handle(name()),
+                       sycl::usm::alloc::host,
+                       *exec_space.impl_internal_space_instance()->m_queue);
 }
 
 void* SYCLHostUSMSpace::allocate(const size_t arg_alloc_size) const {
@@ -177,11 +185,9 @@ void* SYCLHostUSMSpace::allocate(const size_t arg_alloc_size) const {
 void* SYCLHostUSMSpace::allocate(const char* arg_label,
                                  const size_t arg_alloc_size,
                                  const size_t arg_logical_size) const {
-  return allocate_sycl(
-      arg_label, arg_alloc_size, arg_logical_size,
-      Kokkos::Tools::make_space_handle(name()),
-      RawMemoryAllocationFailure::AllocationMechanism::SYCLMallocHost,
-      sycl::usm::alloc::host, m_queue);
+  return allocate_sycl(arg_label, arg_alloc_size, arg_logical_size,
+                       Kokkos::Tools::make_space_handle(name()),
+                       sycl::usm::alloc::host, m_queue);
 }
 
 void sycl_deallocate(const char* arg_label, void* const arg_alloc_ptr,
@@ -241,226 +247,17 @@ void SYCLHostUSMSpace::deallocate(const char* arg_label,
 }  // namespace Experimental
 }  // namespace Kokkos
 
-namespace Kokkos {
-namespace Impl {
-
-#ifdef KOKKOS_ENABLE_DEBUG
-SharedAllocationRecord<void, void> SharedAllocationRecord<
-    Kokkos::Experimental::SYCLDeviceUSMSpace, void>::s_root_record;
-
-SharedAllocationRecord<void, void> SharedAllocationRecord<
-    Kokkos::Experimental::SYCLSharedUSMSpace, void>::s_root_record;
-
-SharedAllocationRecord<void, void> SharedAllocationRecord<
-    Kokkos::Experimental::SYCLHostUSMSpace, void>::s_root_record;
-#endif
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::SYCLDeviceUSMSpace& space,
-        const std::string& label, const size_t size,
-        const SharedAllocationRecord<void, void>::function_type dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                                  void>::s_root_record,
-#endif
-          Kokkos::Impl::checked_allocation_with_header(space, label, size),
-          sizeof(SharedAllocationHeader) + size, dealloc, label),
-      m_space(space) {
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, label);
-
-  // Copy to device memory
-  Kokkos::Experimental::SYCL exec;
-  Kokkos::Impl::DeepCopy<Kokkos::Experimental::SYCLDeviceUSMSpace, HostSpace>(
-      exec, RecordBase::m_alloc_ptr, &header, sizeof(SharedAllocationHeader));
-  exec.fence(
-      "SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace, "
-      "void>::SharedAllocationRecord(): fence after copying header from "
-      "HostSpace");
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::SYCL& arg_exec_space,
-        const Kokkos::Experimental::SYCLDeviceUSMSpace& space,
-        const std::string& label, const size_t size,
-        const SharedAllocationRecord<void, void>::function_type dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                                  void>::s_root_record,
-#endif
-          Kokkos::Impl::checked_allocation_with_header(arg_exec_space, space,
-                                                       label, size),
-          sizeof(SharedAllocationHeader) + size, dealloc, label),
-      m_space(space) {
-  SharedAllocationHeader header;
-
-  this->base_t::_fill_host_accessible_header_info(header, label);
-
-  // Copy to device memory
-  Kokkos::Impl::DeepCopy<Kokkos::Experimental::SYCLDeviceUSMSpace, HostSpace>(
-      arg_exec_space, RecordBase::m_alloc_ptr, &header,
-      sizeof(SharedAllocationHeader));
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLSharedUSMSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::SYCL& exec_space,
-        const Kokkos::Experimental::SYCLSharedUSMSpace& arg_space,
-        const std::string& arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::SYCLSharedUSMSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(exec_space, arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                  arg_label);
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLSharedUSMSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::SYCLSharedUSMSpace& arg_space,
-        const std::string& arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::SYCLSharedUSMSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                  arg_label);
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLHostUSMSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::SYCL& exec_space,
-        const Kokkos::Experimental::SYCLHostUSMSpace& arg_space,
-        const std::string& arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::SYCLHostUSMSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(exec_space, arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                  arg_label);
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLHostUSMSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::SYCLHostUSMSpace& arg_space,
-        const std::string& arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::SYCLHostUSMSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-
-  this->base_t::_fill_host_accessible_header_info(*base_t::m_alloc_ptr,
-                                                  arg_label);
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                       void>::~SharedAllocationRecord() {
-  const auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     alloc_size, alloc_size - sizeof(SharedAllocationHeader));
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLSharedUSMSpace,
-                       void>::~SharedAllocationRecord() {
-  const auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     alloc_size, alloc_size - sizeof(SharedAllocationHeader));
-}
-
-SharedAllocationRecord<Kokkos::Experimental::SYCLHostUSMSpace,
-                       void>::~SharedAllocationRecord() {
-  const auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     alloc_size, alloc_size - sizeof(SharedAllocationHeader));
-}
-
-//----------------------------------------------------------------------------
-
-}  // namespace Impl
-}  // namespace Kokkos
-
 //==============================================================================
 // <editor-fold desc="Explicit instantiations of CRTP Base classes"> {{{1
 
 #include <impl/Kokkos_SharedAlloc_timpl.hpp>
 
-namespace Kokkos {
-namespace Impl {
-
-// To avoid additional compilation cost for something that's (mostly?) not
-// performance sensitive, we explicity instantiate these CRTP base classes here,
-// where we have access to the associated *_timpl.hpp header files.
-template class HostInaccessibleSharedAllocationRecordCommon<
-    Kokkos::Experimental::SYCLDeviceUSMSpace>;
-template class SharedAllocationRecordCommon<
-    Kokkos::Experimental::SYCLDeviceUSMSpace>;
-template class SharedAllocationRecordCommon<
-    Kokkos::Experimental::SYCLSharedUSMSpace>;
-template class SharedAllocationRecordCommon<
-    Kokkos::Experimental::SYCLHostUSMSpace>;
-
-}  // namespace Impl
-}  // namespace Kokkos
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::Experimental::SYCLDeviceUSMSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::Experimental::SYCLSharedUSMSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(
+    Kokkos::Experimental::SYCLHostUSMSpace);
 
 // </editor-fold> end Explicit instantiations of CRTP Base classes }}}1
 //==============================================================================
diff --git a/core/src/SYCL/Kokkos_SYCL_Space.hpp b/core/src/SYCL/Kokkos_SYCL_Space.hpp
index 239c6e3ce0..b86cfca413 100644
--- a/core/src/SYCL/Kokkos_SYCL_Space.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Space.hpp
@@ -66,11 +66,6 @@ class SYCLDeviceUSMSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
- private:
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
-
- public:
   static constexpr const char* name() { return "SYCLDeviceUSM"; };
 
  private:
@@ -87,6 +82,16 @@ class SYCLSharedUSMSpace {
   SYCLSharedUSMSpace();
   explicit SYCLSharedUSMSpace(sycl::queue queue);
 
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const SYCL& exec_space,
                  const std::size_t arg_alloc_size) const;
   void* allocate(const SYCL& exec_space, const char* arg_label,
@@ -102,11 +107,6 @@ class SYCLSharedUSMSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
- private:
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
-
- public:
   static constexpr const char* name() { return "SYCLSharedUSM"; };
 
  private:
@@ -123,6 +123,16 @@ class SYCLHostUSMSpace {
   SYCLHostUSMSpace();
   explicit SYCLHostUSMSpace(sycl::queue queue);
 
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const size_t arg_alloc_size) const {
+    return allocate(arg_alloc_size);
+  }
+  template <typename ExecutionSpace>
+  void* allocate(const ExecutionSpace&, const char* arg_label,
+                 const size_t arg_alloc_size,
+                 const size_t arg_logical_size = 0) const {
+    return allocate(arg_label, arg_alloc_size, arg_logical_size);
+  }
   void* allocate(const SYCL& exec_space,
                  const std::size_t arg_alloc_size) const;
   void* allocate(const SYCL& exec_space, const char* arg_label,
@@ -138,11 +148,6 @@ class SYCLHostUSMSpace {
                   const size_t arg_alloc_size,
                   const size_t arg_logical_size = 0) const;
 
- private:
-  template <class, class, class, class>
-  friend class LogicalMemorySpace;
-
- public:
   static constexpr const char* name() { return "SYCLHostUSM"; };
 
  private:
@@ -166,19 +171,16 @@ struct is_sycl_type_space<Kokkos::Experimental::SYCLHostUSMSpace>
     : public std::true_type {};
 
 static_assert(Kokkos::Impl::MemorySpaceAccess<
-                  Kokkos::Experimental::SYCLDeviceUSMSpace,
-                  Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable,
-              "");
+              Kokkos::Experimental::SYCLDeviceUSMSpace,
+              Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable);
 
 static_assert(Kokkos::Impl::MemorySpaceAccess<
-                  Kokkos::Experimental::SYCLSharedUSMSpace,
-                  Kokkos::Experimental::SYCLSharedUSMSpace>::assignable,
-              "");
+              Kokkos::Experimental::SYCLSharedUSMSpace,
+              Kokkos::Experimental::SYCLSharedUSMSpace>::assignable);
 
 static_assert(Kokkos::Impl::MemorySpaceAccess<
-                  Kokkos::Experimental::SYCLDeviceUSMSpace,
-                  Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable,
-              "");
+              Kokkos::Experimental::SYCLDeviceUSMSpace,
+              Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable);
 
 template <>
 struct MemorySpaceAccess<Kokkos::HostSpace,
@@ -310,151 +312,14 @@ struct MemorySpaceAccess<
 
 }  // namespace Impl
 
-namespace Impl {
-
-template <>
-class SharedAllocationRecord<Kokkos::Experimental::SYCLDeviceUSMSpace, void>
-    : public HostInaccessibleSharedAllocationRecordCommon<
-          Kokkos::Experimental::SYCLDeviceUSMSpace> {
- private:
-  friend class SharedAllocationRecordCommon<
-      Kokkos::Experimental::SYCLDeviceUSMSpace>;
-  friend class HostInaccessibleSharedAllocationRecordCommon<
-      Kokkos::Experimental::SYCLDeviceUSMSpace>;
-  using base_t = HostInaccessibleSharedAllocationRecordCommon<
-      Kokkos::Experimental::SYCLDeviceUSMSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord(SharedAllocationRecord&&)      = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(SharedAllocationRecord&&) = delete;
-
-#ifdef KOKKOS_ENABLE_DEBUG
-  static RecordBase s_root_record;
-#endif
-
-  const Kokkos::Experimental::SYCLDeviceUSMSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      const Kokkos::Experimental::SYCLDeviceUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::SYCL& exec_space,
-      const Kokkos::Experimental::SYCLDeviceUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::SYCLDeviceUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-
-template <>
-class SharedAllocationRecord<Kokkos::Experimental::SYCLSharedUSMSpace, void>
-    : public SharedAllocationRecordCommon<
-          Kokkos::Experimental::SYCLSharedUSMSpace> {
- private:
-  friend class SharedAllocationRecordCommon<
-      Kokkos::Experimental::SYCLSharedUSMSpace>;
-  using base_t =
-      SharedAllocationRecordCommon<Kokkos::Experimental::SYCLSharedUSMSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord(SharedAllocationRecord&&)      = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(SharedAllocationRecord&&) = delete;
-
-  static RecordBase s_root_record;
-
-  const Kokkos::Experimental::SYCLSharedUSMSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      const Kokkos::Experimental::SYCLSharedUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::SYCL& exec_space,
-      const Kokkos::Experimental::SYCLSharedUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::SYCLSharedUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-
-template <>
-class SharedAllocationRecord<Kokkos::Experimental::SYCLHostUSMSpace, void>
-    : public SharedAllocationRecordCommon<
-          Kokkos::Experimental::SYCLHostUSMSpace> {
- private:
-  friend class SharedAllocationRecordCommon<
-      Kokkos::Experimental::SYCLHostUSMSpace>;
-  using base_t =
-      SharedAllocationRecordCommon<Kokkos::Experimental::SYCLHostUSMSpace>;
-  using RecordBase = SharedAllocationRecord<void, void>;
-
-  SharedAllocationRecord(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord(SharedAllocationRecord&&)      = delete;
-  SharedAllocationRecord& operator=(const SharedAllocationRecord&) = delete;
-  SharedAllocationRecord& operator=(SharedAllocationRecord&&) = delete;
-
-  static RecordBase s_root_record;
-
-  const Kokkos::Experimental::SYCLHostUSMSpace m_space;
-
- protected:
-  ~SharedAllocationRecord();
-
-  SharedAllocationRecord() = default;
-
-  template <typename ExecutionSpace>
-  SharedAllocationRecord(
-      const ExecutionSpace& /*exec_space*/,
-      const Kokkos::Experimental::SYCLHostUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate)
-      : SharedAllocationRecord(arg_space, arg_label, arg_alloc_size,
-                               arg_dealloc) {}
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::SYCL& exec_space,
-      const Kokkos::Experimental::SYCLHostUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-
-  SharedAllocationRecord(
-      const Kokkos::Experimental::SYCLHostUSMSpace& arg_space,
-      const std::string& arg_label, const size_t arg_alloc_size,
-      const RecordBase::function_type arg_dealloc = &base_t::deallocate);
-};
-
-}  // namespace Impl
-
 }  // namespace Kokkos
 
+KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::Experimental::SYCLDeviceUSMSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::Experimental::SYCLSharedUSMSpace);
+KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(
+    Kokkos::Experimental::SYCLHostUSMSpace);
+
 #endif
 #endif
diff --git a/core/src/SYCL/Kokkos_SYCL_Team.hpp b/core/src/SYCL/Kokkos_SYCL_Team.hpp
index 797f3c752f..1e42faa5a8 100644
--- a/core/src/SYCL/Kokkos_SYCL_Team.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_Team.hpp
@@ -22,6 +22,7 @@
 #ifdef KOKKOS_ENABLE_SYCL
 
 #include <utility>
+#include <SYCL/Kokkos_SYCL_WorkgroupReduction.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -42,6 +43,8 @@ class SYCLTeamMember {
   scratch_memory_space m_team_shared;
   int m_team_reduce_size;
   sycl::nd_item<2> m_item;
+  int m_league_rank;
+  int m_league_size;
 
  public:
   KOKKOS_INLINE_FUNCTION
@@ -61,12 +64,8 @@ class SYCLTeamMember {
     return m_team_shared.set_team_thread_mode(level, team_size(), team_rank());
   }
 
-  KOKKOS_INLINE_FUNCTION int league_rank() const {
-    return m_item.get_group_linear_id();
-  }
-  KOKKOS_INLINE_FUNCTION int league_size() const {
-    return m_item.get_group_range(1);
-  }
+  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_item.get_local_id(0);
   }
@@ -135,67 +134,71 @@ class SYCLTeamMember {
     const unsigned int team_rank_ = team_rank();
 
     // First combine the values in the same subgroup
+#if defined(KOKKOS_ARCH_INTEL_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+    auto shuffle_combine = [&](int shift) {
+      if (vector_range * shift < sub_group_range) {
+        const value_type tmp = Kokkos::Impl::SYCLReduction::shift_group_left(
+            sg, value, vector_range * shift);
+        if (team_rank_ + shift < team_size_) reducer.join(value, tmp);
+      }
+    };
+    shuffle_combine(1);
+    shuffle_combine(2);
+    shuffle_combine(4);
+    shuffle_combine(8);
+    shuffle_combine(16);
+    KOKKOS_ASSERT(sub_group_range <= 32);
+#else
     for (unsigned int shift = 1; vector_range * shift < sub_group_range;
          shift <<= 1) {
-      const value_type tmp = sg.shuffle_down(value, vector_range * shift);
+      auto tmp = Kokkos::Impl::SYCLReduction::shift_group_left(
+          sg, value, vector_range * shift);
       if (team_rank_ + shift < team_size_) reducer.join(value, tmp);
     }
-    value = sg.shuffle(value, 0);
+#endif
+    value = Kokkos::Impl::SYCLReduction::select_from_group(sg, value, 0);
+
+    const int n_subgroups = sg.get_group_range()[0];
+    if (n_subgroups == 1) {
+      reducer.reference() = value;
+      return;
+    }
 
-    // We need to chunk up the whole reduction because we might not have
-    // allocated enough memory.
-    const auto n_subgroups = sg.get_group_range()[0];
-    const unsigned int maximum_work_range =
-        std::min<int>(m_team_reduce_size / sizeof(value_type), n_subgroups);
+    // It was found experimentally that 16 is a good value for Intel PVC.
+    // Since there is a maximum number of 1024 threads with subgroup size 16,
+    // we have a maximum of 64 subgroups per workgroup which means 64/16=4
+    // rounds for loading values into the reduction_array, and 16 redundant
+    // reduction steps executed by every thread.
+    constexpr int step_width = 16;
+    auto tmp_alloc = sycl::ext::oneapi::group_local_memory_for_overwrite<
+        value_type[step_width]>(m_item.get_group());
+    auto& reduction_array = *tmp_alloc;
 
     const auto id_in_sg = sg.get_local_id()[0];
-    auto reduction_array =
-        static_cast<sycl::local_ptr<value_type>>(m_team_reduce);
 
-    // Load values into the first maximum_work_range values of the reduction
+    // Load values into the first step_width values of the reduction
     // array in chunks. This means that only sub groups with an id in the
     // corresponding chunk load values.
-    const auto group_id = sg.get_group_id()[0];
-    if (id_in_sg == 0 && group_id < maximum_work_range)
+    const int group_id = sg.get_group_id()[0];
+    if (id_in_sg == 0 && group_id < step_width)
       reduction_array[group_id] = value;
     sycl::group_barrier(m_item.get_group());
 
-    for (unsigned int start = maximum_work_range; start < n_subgroups;
-         start += maximum_work_range) {
+    for (int start = step_width; start < n_subgroups; start += step_width) {
       if (id_in_sg == 0 && group_id >= start &&
-          group_id <
-              std::min<unsigned int>(start + maximum_work_range, n_subgroups))
+          group_id < std::min(start + step_width, n_subgroups))
         reducer.join(reduction_array[group_id - start], value);
       sycl::group_barrier(m_item.get_group());
     }
 
-    // Let the first subgroup do the final reduction
-    if (group_id == 0) {
-      const auto local_range = sg.get_local_range()[0];
-      auto result =
-          reduction_array[id_in_sg < maximum_work_range ? id_in_sg : 0];
-      // In case the maximum_work_range is larger than the range of the first
-      // subgroup, we first combine the items with a higher index.
-      for (unsigned int offset = local_range; offset < maximum_work_range;
-           offset += local_range)
-        if (id_in_sg + offset < maximum_work_range)
-          reducer.join(result, reduction_array[id_in_sg + offset]);
-      sycl::group_barrier(sg);
-
-      // Now do the actual subgroup reduction.
-      const auto min_range =
-          std::min<unsigned int>(maximum_work_range, local_range);
-      for (unsigned int stride = 1; stride < min_range; stride <<= 1) {
-        const auto tmp = sg.shuffle_down(result, stride);
-        if (id_in_sg + stride < min_range) reducer.join(result, tmp);
-      }
-      if (id_in_sg == 0) reduction_array[0] = result;
-    }
-    sycl::group_barrier(m_item.get_group());
+    // Do the final reduction for all threads redundantly
+    value = reduction_array[0];
+    for (int i = 1; i < std::min(step_width, n_subgroups); ++i)
+      reducer.join(value, reduction_array[i]);
 
-    reducer.reference() = reduction_array[0];
-    // Make sure that the reduction array hasn't been modified in the meantime.
-    m_item.barrier(sycl::access::fence_space::local_space);
+    reducer.reference() = value;
+    // Make sure that every thread is done using the reduction array.
+    sycl::group_barrier(m_item.get_group());
   }
 
   //--------------------------------------------------------------------------
@@ -220,7 +223,8 @@ class SYCLTeamMember {
     // First combine the values in the same subgroup
     for (unsigned int stride = 1; vector_range * stride < sub_group_range;
          stride <<= 1) {
-      auto tmp = sg.shuffle_up(value, vector_range * stride);
+      auto tmp = Kokkos::Impl::SYCLReduction::shift_group_right(
+          sg, value, vector_range * stride);
       if (id_in_sg >= vector_range * stride) value += tmp;
     }
 
@@ -246,7 +250,8 @@ class SYCLTeamMember {
               sub_group_range, n_active_subgroups - round * sub_group_range);
           auto local_value = base_data[idx];
           for (unsigned int stride = 1; stride < upper_bound; stride <<= 1) {
-            auto tmp = sg.shuffle_up(local_value, stride);
+            auto tmp = Kokkos::Impl::SYCLReduction::shift_group_right(
+                sg, local_value, stride);
             if (id_in_sg >= stride) {
               if (idx < n_active_subgroups)
                 local_value += tmp;
@@ -264,7 +269,8 @@ class SYCLTeamMember {
     }
     auto total = base_data[n_active_subgroups - 1];
 
-    const auto update = sg.shuffle_up(value, vector_range);
+    const auto update =
+        Kokkos::Impl::SYCLReduction::shift_group_right(sg, value, vector_range);
     Type intermediate = (group_id > 0 ? base_data[group_id - 1] : 0) +
                         (id_in_sg >= vector_range ? update : 0);
 
@@ -317,7 +323,7 @@ class SYCLTeamMember {
     typename ReducerType::value_type tmp2 = tmp;
 
     for (int i = grange1; (i >>= 1);) {
-      tmp2 = sg.shuffle_down(tmp, i);
+      tmp2 = Kokkos::Impl::SYCLReduction::shift_group_left(sg, tmp, i);
       if (static_cast<int>(tidx1) < i) {
         reducer.join(tmp, tmp2);
       }
@@ -328,8 +334,9 @@ class SYCLTeamMember {
     // because floating point summation is not associative
     // and thus different threads could have different results.
 
-    tmp2  = sg.shuffle(tmp, (sg.get_local_id() / grange1) * grange1);
-    value = tmp2;
+    tmp2 = Kokkos::Impl::SYCLReduction::select_from_group(
+        sg, tmp, (sg.get_local_id() / grange1) * grange1);
+    value               = tmp2;
     reducer.reference() = tmp2;
   }
 
@@ -339,14 +346,17 @@ class SYCLTeamMember {
   KOKKOS_INLINE_FUNCTION
   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,
+                 sycl_device_ptr<void> scratch_level_1_ptr,
                  const std::size_t scratch_level_1_size,
-                 const sycl::nd_item<2> item)
+                 const sycl::nd_item<2> item, const int arg_league_rank,
+                 const int arg_league_size)
       : 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),
         m_team_reduce_size(shared_begin),
-        m_item(item) {}
+        m_item(item),
+        m_league_rank(arg_league_rank),
+        m_league_size(arg_league_size) {}
 
  public:
   // Declare to avoid unused private member warnings which are trigger
@@ -572,15 +582,17 @@ parallel_reduce(const Impl::TeamThreadRangeBoundariesStruct<
  *  final == true.
  */
 // This is the same code as in CUDA and largely the same as in OpenMPTarget
-template <typename iType, typename FunctorType>
+template <typename iType, typename FunctorType, typename ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::SYCLTeamMember>&
         loop_bounds,
-    const FunctorType& lambda) {
-  // Extract value_type from lambda
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+    const FunctorType& lambda, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using closure_value_type = typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
       void>::value_type;
+  static_assert(std::is_same_v<closure_value_type, ValueType>,
+                "Non-matching value types of closure and return type");
 
   const auto start     = loop_bounds.start;
   const auto end       = loop_bounds.end;
@@ -588,12 +600,12 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   const auto team_size = member.team_size();
   const auto team_rank = member.team_rank();
   const auto nchunk    = (end - start + team_size - 1) / team_size;
-  value_type accum     = 0;
+  ValueType 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;
+    ValueType local_accum = 0;
     // user updates value with prefix value
     if (ii < loop_bounds.end) lambda(ii, local_accum, false);
     // perform team scan
@@ -607,6 +619,21 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     // broadcast last value to rest of the team
     member.team_broadcast(accum, team_size - 1);
   }
+
+  return_val = accum;
+}
+
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<iType, Impl::SYCLTeamMember>&
+        loop_bounds,
+    const FunctorType& lambda) {
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+
+  value_type scan_val;
+  parallel_scan(loop_bounds, lambda, scan_val);
 }
 
 template <typename iType, class Closure>
@@ -807,7 +834,7 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
     // This sets i's val to i-1's contribution to make the latter shfl_up an
     // exclusive scan -- the final accumulation of i's val will be included in
     // the second closure call later.
-    if (i < loop_boundaries.end && tidx1 > 0) closure(i - 1, val, false);
+    if (i - 1 < loop_boundaries.end && tidx1 > 0) closure(i - 1, val, false);
 
     // Bottom up exclusive scan in triangular pattern where each SYCL thread is
     // the root of a reduction tree from the zeroth "lane" to itself.
@@ -816,7 +843,8 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
     //  [t] += [t-4] if t >= 4
     //  ...
     for (int j = 1; j < static_cast<int>(grange1); j <<= 1) {
-      value_type tmp = sg.shuffle_up(val, j);
+      value_type tmp =
+          Kokkos::Impl::SYCLReduction::shift_group_right(sg, val, j);
       if (j <= static_cast<int>(tidx1)) {
         reducer.join(val, tmp);
       }
@@ -827,8 +855,10 @@ parallel_scan(const Impl::ThreadVectorRangeBoundariesStruct<
 
     // Update i's contribution into the val and add it to accum for next round
     if (i < loop_boundaries.end) closure(i, val, true);
-    accum = sg.shuffle(val, mask + vector_offset);
+    accum = Kokkos::Impl::SYCLReduction::select_from_group(
+        sg, val, mask + vector_offset);
   }
+  reducer.reference() = accum;
 }
 
 /** \brief  Intra-thread vector parallel exclusive prefix sum.
@@ -851,6 +881,32 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
   parallel_scan(loop_boundaries, closure, Kokkos::Sum<value_type>{dummy});
 }
 
+/** \brief  Intra-thread vector parallel exclusive prefix sum.
+ *
+ *  Executes closure(iType i, ValueType & val, bool final) for each i=[0..N)
+ *
+ *  The range [0..N) is mapped to all vector lanes in the
+ *  thread and a scan operation is performed.
+ *  The last call to closure has final == true.
+ */
+template <typename iType, class Closure, typename ValueType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<iType, Impl::SYCLTeamMember>&
+        loop_boundaries,
+    const Closure& closure, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using closure_value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
+  static_assert(std::is_same<closure_value_type, ValueType>::value,
+                "Non-matching value types of closure and return type");
+
+  ValueType accum;
+  parallel_scan(loop_boundaries, closure, Kokkos::Sum<ValueType>{accum});
+
+  return_val = accum;
+}
+
 }  // namespace Kokkos
 
 namespace Kokkos {
@@ -877,7 +933,8 @@ KOKKOS_INLINE_FUNCTION void single(
   const auto grange1          = item.get_local_range(1);
   const auto sg               = item.get_sub_group();
   if (item.get_local_id(1) == 0) lambda(val);
-  val = sg.shuffle(val, (sg.get_local_id() / grange1) * grange1);
+  val = Kokkos::Impl::SYCLReduction::select_from_group(
+      sg, val, (sg.get_local_id() / grange1) * grange1);
 }
 
 template <class FunctorType, class ValueType>
diff --git a/core/src/SYCL/Kokkos_SYCL_TeamPolicy.hpp b/core/src/SYCL/Kokkos_SYCL_TeamPolicy.hpp
new file mode 100644
index 0000000000..17ce59058b
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_TeamPolicy.hpp
@@ -0,0 +1,357 @@
+//@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_TEAM_POLICY_HPP
+#define KOKKOS_SYCL_TEAM_POLICY_HPP
+
+#include <SYCL/Kokkos_SYCL_Team.hpp>
+
+#include <vector>
+
+template <typename... Properties>
+class Kokkos::Impl::TeamPolicyInternal<Kokkos::Experimental::SYCL,
+                                       Properties...>
+    : public PolicyTraits<Properties...> {
+ public:
+  using execution_policy = TeamPolicyInternal;
+
+  using traits = PolicyTraits<Properties...>;
+
+  template <typename ExecSpace, typename... OtherProperties>
+  friend class TeamPolicyInternal;
+
+ private:
+  typename traits::execution_space m_space;
+  int m_league_size;
+  int m_team_size;
+  int m_vector_length;
+  size_t m_team_scratch_size[2];
+  size_t m_thread_scratch_size[2];
+  int m_chunk_size;
+  bool m_tune_team_size;
+  bool m_tune_vector_length;
+
+ public:
+  using execution_space = Kokkos::Experimental::SYCL;
+
+  template <class... OtherProperties>
+  TeamPolicyInternal(TeamPolicyInternal<OtherProperties...> const& p) {
+    m_league_size            = p.m_league_size;
+    m_team_size              = p.m_team_size;
+    m_vector_length          = p.m_vector_length;
+    m_team_scratch_size[0]   = p.m_team_scratch_size[0];
+    m_team_scratch_size[1]   = p.m_team_scratch_size[1];
+    m_thread_scratch_size[0] = p.m_thread_scratch_size[0];
+    m_thread_scratch_size[1] = p.m_thread_scratch_size[1];
+    m_chunk_size             = p.m_chunk_size;
+    m_space                  = p.m_space;
+    m_tune_team_size         = p.m_tune_team_size;
+    m_tune_vector_length     = p.m_tune_vector_length;
+  }
+
+  template <typename FunctorType>
+  int team_size_max(FunctorType const& f, ParallelForTag const&) const {
+    return internal_team_size_max_for(f);
+  }
+
+  template <class FunctorType>
+  inline int team_size_max(const FunctorType& f,
+                           const ParallelReduceTag&) const {
+    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<typename ReducerType::value_type>(f);
+  }
+
+  template <typename FunctorType>
+  int team_size_recommended(FunctorType const& f, ParallelForTag const&) const {
+    return internal_team_size_recommended_for(f);
+  }
+
+  template <typename FunctorType>
+  inline int team_size_recommended(FunctorType const& f,
+                                   ParallelReduceTag const&) const {
+    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<
+        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; }
+  // FIXME_SYCL This is correct in most cases, but not necessarily in case a
+  // custom sycl::queue is used to initialize the execution space.
+  static int vector_length_max() {
+    std::vector<size_t> sub_group_sizes =
+        execution_space{}
+            .impl_internal_space_instance()
+            ->m_queue->get_device()
+            .template get_info<sycl::info::device::sub_group_sizes>();
+    return *std::max_element(sub_group_sizes.begin(), sub_group_sizes.end());
+  }
+
+ private:
+  static int verify_requested_vector_length(int requested_vector_length) {
+    int test_vector_length =
+        std::min(requested_vector_length, vector_length_max());
+
+    // Allow only power-of-two vector_length
+    if (!(is_integral_power_of_two(test_vector_length))) {
+      int test_pow2 = 1;
+      while (test_pow2 < test_vector_length) test_pow2 <<= 1;
+      test_vector_length = test_pow2 >> 1;
+    }
+
+    return test_vector_length;
+  }
+
+ public:
+  static int scratch_size_max(int level) {
+    return level == 0 ? 1024 * 32
+                      :           // FIXME_SYCL arbitrarily setting this to 32kB
+               20 * 1024 * 1024;  // FIXME_SYCL arbitrarily setting this to 20MB
+  }
+  inline void impl_set_vector_length(size_t size) { m_vector_length = size; }
+  inline void impl_set_team_size(size_t size) { m_team_size = size; }
+  int impl_vector_length() const { return m_vector_length; }
+
+  int team_size() const { return m_team_size; }
+
+  int league_size() const { return m_league_size; }
+
+  size_t scratch_size(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];
+  }
+
+  size_t team_scratch_size(int level) const {
+    return m_team_scratch_size[level];
+  }
+
+  size_t thread_scratch_size(int level) const {
+    return m_thread_scratch_size[level];
+  }
+
+  typename traits::execution_space space() const { return m_space; }
+
+  TeamPolicyInternal()
+      : m_space(typename traits::execution_space()),
+        m_league_size(0),
+        m_team_size(-1),
+        m_vector_length(0),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(vector_length_max()),
+        m_tune_team_size(false),
+        m_tune_vector_length(false) {}
+
+  /** \brief  Specify league size, request team size */
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     int team_size_request, int vector_length_request = 1)
+      : m_space(space_),
+        m_league_size(league_size_),
+        m_team_size(team_size_request),
+        m_vector_length(
+            (vector_length_request > 0)
+                ? verify_requested_vector_length(vector_length_request)
+                : (verify_requested_vector_length(1))),
+        m_team_scratch_size{0, 0},
+        m_thread_scratch_size{0, 0},
+        m_chunk_size(vector_length_max()),
+        m_tune_team_size(bool(team_size_request <= 0)),
+        m_tune_vector_length(bool(vector_length_request <= 0)) {
+    // FIXME_SYCL Check that league size is permissible,
+    // https://github.com/intel/llvm/pull/4064
+
+    // Make sure total block size is permissible
+    if (m_team_size * m_vector_length >
+        static_cast<int>(
+            m_space.impl_internal_space_instance()->m_maxWorkgroupSize)) {
+      Impl::throw_runtime_exception(
+          std::string("Kokkos::TeamPolicy<SYCL> the team size is too large. "
+                      "Team size x vector length is " +
+                      std::to_string(m_team_size * m_vector_length) +
+                      " but must be smaller than ") +
+          std::to_string(
+              m_space.impl_internal_space_instance()->m_maxWorkgroupSize));
+    }
+  }
+
+  /** \brief  Specify league size, request team size */
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     int vector_length_request = 1)
+      : TeamPolicyInternal(space_, league_size_, -1, vector_length_request) {}
+  // FLAG
+  /** \brief  Specify league size and team size, request vector length*/
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     int team_size_request,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+                     )
+      : TeamPolicyInternal(space_, league_size_, team_size_request, -1)
+
+  {}
+
+  /** \brief  Specify league size, request team size and vector length*/
+  TeamPolicyInternal(const execution_space space_, int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+
+                     )
+      : TeamPolicyInternal(space_, league_size_, -1, -1)
+
+  {}
+
+  TeamPolicyInternal(int league_size_, int team_size_request,
+                     int vector_length_request = 1)
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
+                           team_size_request, vector_length_request) {}
+
+  TeamPolicyInternal(int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     int vector_length_request = 1)
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
+                           vector_length_request) {}
+
+  /** \brief  Specify league size and team size, request vector length*/
+  TeamPolicyInternal(int league_size_, int team_size_request,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+
+                     )
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_,
+                           team_size_request, -1)
+
+  {}
+
+  /** \brief  Specify league size, request team size and vector length*/
+  TeamPolicyInternal(int league_size_,
+                     const Kokkos::AUTO_t& /* team_size_request */,
+                     const Kokkos::AUTO_t& /* vector_length_request */
+
+                     )
+      : TeamPolicyInternal(typename traits::execution_space(), league_size_, -1,
+                           -1) {}
+
+  int chunk_size() const { return m_chunk_size; }
+
+  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 */
+  TeamPolicyInternal& set_scratch_size(int level,
+                                       PerTeamValue const& 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 */
+  TeamPolicyInternal& set_scratch_size(int level,
+                                       PerThreadValue const& 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 */
+  TeamPolicyInternal& set_scratch_size(int level, PerTeamValue const& per_team,
+                                       PerThreadValue const& per_thread) {
+    m_team_scratch_size[level]   = per_team.value;
+    m_thread_scratch_size[level] = per_thread.value;
+    return *this;
+  }
+
+  using member_type = Kokkos::Impl::SYCLTeamMember;
+
+ protected:
+  template <class FunctorType>
+  int internal_team_size_max_for(const FunctorType& /*f*/) const {
+    // nested_reducer_memsize = (sizeof(double) * (m_team_size + 2)
+    // custom: m_team_scratch_size[0] + m_thread_scratch_size[0] * m_team_size
+    // total:
+    // 2*sizeof(double)+m_team_scratch_size[0]
+    // + m_team_size(sizeof(double)+m_thread_scratch_size[0])
+    const int max_threads_for_memory =
+        (space().impl_internal_space_instance()->m_maxShmemPerBlock -
+         2 * sizeof(double) - m_team_scratch_size[0]) /
+        (sizeof(double) + m_thread_scratch_size[0]);
+    return std::min({
+             int(m_space.impl_internal_space_instance()->m_maxWorkgroupSize),
+      // FIXME_SYCL Avoid requesting too many registers on NVIDIA GPUs.
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+                 256,
+#endif
+                 max_threads_for_memory
+           }) /
+           impl_vector_length();
+  }
+
+  template <class ValueType, class FunctorType>
+  int internal_team_size_max_reduce(const FunctorType& f) const {
+    using Analysis =
+        FunctorAnalysis<FunctorPatternInterface::REDUCE, TeamPolicyInternal,
+                        FunctorType, ValueType>;
+    using value_type      = typename Analysis::value_type;
+    const int value_count = Analysis::value_count(f);
+
+    // nested_reducer_memsize = (sizeof(double) * (m_team_size + 2)
+    // reducer_memsize = sizeof(value_type) * m_team_size * value_count
+    // custom: m_team_scratch_size[0] + m_thread_scratch_size[0] * m_team_size
+    // total:
+    // 2*sizeof(double)+m_team_scratch_size[0]
+    // + m_team_size(sizeof(double)+sizeof(value_type)*value_count
+    //               +m_thread_scratch_size[0])
+    const int max_threads_for_memory =
+        (space().impl_internal_space_instance()->m_maxShmemPerBlock -
+         2 * sizeof(double) - m_team_scratch_size[0]) /
+        (sizeof(double) + sizeof(value_type) * value_count +
+         m_thread_scratch_size[0]);
+    return std::min<int>({
+             int(m_space.impl_internal_space_instance()->m_maxWorkgroupSize),
+      // FIXME_SYCL Avoid requesting too many registers on NVIDIA GPUs.
+#if defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+                 256,
+#endif
+                 max_threads_for_memory
+           }) /
+           impl_vector_length();
+  }
+
+  template <class FunctorType>
+  int internal_team_size_recommended_for(const FunctorType& f) const {
+    // FIXME_SYCL improve
+    return 1 << Kokkos::Impl::int_log2(internal_team_size_max_for(f));
+  }
+
+  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<ValueType>(f));
+  }
+};
+
+#endif
diff --git a/core/src/SYCL/Kokkos_SYCL_WorkgroupReduction.hpp b/core/src/SYCL/Kokkos_SYCL_WorkgroupReduction.hpp
new file mode 100644
index 0000000000..abf0bd8f53
--- /dev/null
+++ b/core/src/SYCL/Kokkos_SYCL_WorkgroupReduction.hpp
@@ -0,0 +1,256 @@
+//@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_WORKGROUP_REDUCTION_HPP
+#define KOKKOS_SYCL_WORKGROUP_REDUCTION_HPP
+
+#include <Kokkos_Macros.hpp>
+
+namespace Kokkos::Impl::SYCLReduction {
+
+template <int N>
+struct TrivialWrapper {
+  std::byte array[N];
+};
+
+// shuffle down
+template <typename T>
+T shift_group_left(sycl::sub_group sg, T x,
+                   sycl::sub_group::linear_id_type delta) {
+  if constexpr (std::is_trivially_copyable_v<T>)
+    return sycl::shift_group_left(sg, x, delta);
+  else {
+    auto tmp = sycl::shift_group_left(
+        sg, reinterpret_cast<TrivialWrapper<sizeof(T)>&>(x), delta);
+    return reinterpret_cast<T&>(tmp);
+  }
+}
+
+// shuffle up
+template <typename T>
+T shift_group_right(sycl::sub_group sg, T x,
+                    sycl::sub_group::linear_id_type delta) {
+  if constexpr (std::is_trivially_copyable_v<T>)
+    return sycl::shift_group_right(sg, x, delta);
+  else {
+    auto tmp = sycl::shift_group_right(
+        sg, reinterpret_cast<TrivialWrapper<sizeof(T)>&>(x), delta);
+    return reinterpret_cast<T&>(tmp);
+  }
+}
+
+// shuffle
+template <typename T>
+T select_from_group(sycl::sub_group sg, T x,
+                    sycl::sub_group::id_type remote_local_id) {
+  if constexpr (std::is_trivially_copyable_v<T>)
+    return sycl::select_from_group(sg, x, remote_local_id);
+  else {
+    auto tmp = sycl::select_from_group(
+        sg, reinterpret_cast<TrivialWrapper<sizeof(T)>&>(x), remote_local_id);
+    return reinterpret_cast<T&>(tmp);
+  }
+}
+
+// FIXME_SYCL For some types, shuffle reductions are competitive with local
+// memory reductions but they are significantly slower for the value type used
+// in combined reductions with multiple double arguments.
+template <class ReducerType>
+inline constexpr bool use_shuffle_based_algorithm = false;
+// std::is_reference_v<typename ReducerType::reference_type>;
+
+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_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,
+    bool final, unsigned int max_size) {
+  const unsigned int value_count =
+      std::is_reference_v<typename ReducerType::reference_type> ? 1
+                                                                : value_count_;
+  const int local_id = item.get_local_linear_id();
+
+  // Perform the actual workgroup reduction in each subgroup
+  // separately.
+  auto sg            = item.get_sub_group();
+  auto* result       = &local_mem[local_id * value_count];
+  const int id_in_sg = sg.get_local_id()[0];
+  const auto local_range =
+      std::min<unsigned int>(sg.get_local_range()[0], max_size);
+  const auto upper_stride_bound =
+      std::min<unsigned int>(local_range - id_in_sg, max_size - local_id);
+  for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
+    if (stride < upper_stride_bound)
+      final_reducer.join(result, &local_mem[(local_id + stride) * value_count]);
+    sycl::group_barrier(sg);
+  }
+  sycl::group_barrier(item.get_group());
+
+  // Do the final reduction only using the first subgroup.
+  if (sg.get_group_id()[0] == 0) {
+    const unsigned int n_subgroups = sg.get_group_range()[0];
+    const int max_subgroup_size    = sg.get_max_local_range()[0];
+    auto* result_ = &local_mem[id_in_sg * max_subgroup_size * value_count];
+    // In case the number of subgroups is larger than the range of
+    // the first subgroup, we first combine the items with a higher
+    // index.
+    for (unsigned int offset = local_range; offset < n_subgroups;
+         offset += local_range)
+      if (id_in_sg + offset < n_subgroups)
+        final_reducer.join(
+            result_,
+            &local_mem[(id_in_sg + offset) * max_subgroup_size * value_count]);
+    sycl::group_barrier(sg);
+
+    // Then, we proceed as before.
+    for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
+      if (id_in_sg + stride < n_subgroups)
+        final_reducer.join(
+            result_,
+            &local_mem[(id_in_sg + stride) * max_subgroup_size * value_count]);
+      sycl::group_barrier(sg);
+    }
+
+    // Finally, we copy the workgroup results back to global memory
+    // to be used in the next iteration. If this is the last
+    // iteration, i.e., there is only one workgroup also call
+    // final() if necessary.
+    if (id_in_sg == 0) {
+      if (final) {
+        final_reducer.final(&local_mem[0]);
+        if (device_accessible_result_ptr != nullptr)
+          final_reducer.copy(&device_accessible_result_ptr[0], &local_mem[0]);
+        else
+          final_reducer.copy(&results_ptr[0], &local_mem[0]);
+      } else
+        final_reducer.copy(
+            &results_ptr[(item.get_group_linear_id()) * value_count],
+            &local_mem[0]);
+    }
+  }
+}
+
+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_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) {
+  const auto local_id = item.get_local_linear_id();
+
+  // Perform the actual workgroup reduction in each subgroup
+  // separately.
+  auto sg               = item.get_sub_group();
+  const int id_in_sg    = sg.get_local_id()[0];
+  const int local_range = std::min<int>(sg.get_local_range()[0], max_size);
+
+  const auto upper_stride_bound =
+      std::min<int>(local_range - id_in_sg, max_size - local_id);
+#if defined(KOKKOS_ARCH_INTEL_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  auto shuffle_combine = [&](int stride) {
+    if (stride < local_range) {
+      auto tmp = Kokkos::Impl::SYCLReduction::shift_group_left(sg, local_value,
+                                                               stride);
+      if (stride < upper_stride_bound) final_reducer.join(&local_value, &tmp);
+    }
+  };
+  shuffle_combine(1);
+  shuffle_combine(2);
+  shuffle_combine(4);
+  shuffle_combine(8);
+  shuffle_combine(16);
+  KOKKOS_ASSERT(local_range <= 32);
+#else
+  for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
+    auto tmp =
+        Kokkos::Impl::SYCLReduction::shift_group_left(sg, local_value, stride);
+    if (stride < upper_stride_bound) final_reducer.join(&local_value, &tmp);
+  }
+#endif
+
+  // Copy the subgroup results into the first positions of the
+  // reduction array.
+  const int max_subgroup_size = sg.get_max_local_range()[0];
+  const int n_active_subgroups =
+      (max_size + max_subgroup_size - 1) / max_subgroup_size;
+  const int sg_group_id = sg.get_group_id()[0];
+  if (id_in_sg == 0 && sg_group_id <= n_active_subgroups)
+    local_mem[sg_group_id] = local_value;
+
+  item.barrier(sycl::access::fence_space::local_space);
+
+  // Do the final reduction only using the first subgroup.
+  if (sg.get_group_id()[0] == 0) {
+    auto sg_value = local_mem[id_in_sg < n_active_subgroups ? id_in_sg : 0];
+
+    // In case the number of subgroups is larger than the range of
+    // the first subgroup, we first combine the items with a higher
+    // index.
+    if (n_active_subgroups > local_range) {
+      for (int offset = local_range; offset < n_active_subgroups;
+           offset += local_range)
+        if (id_in_sg + offset < n_active_subgroups) {
+          final_reducer.join(&sg_value, &local_mem[(id_in_sg + offset)]);
+        }
+      sg.barrier();
+    }
+
+    // Then, we proceed as before.
+#if defined(KOKKOS_ARCH_INTEL_GPU) || defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+    auto shuffle_combine_sg = [&](int stride) {
+      if (stride < local_range) {
+        auto tmp =
+            Kokkos::Impl::SYCLReduction::shift_group_left(sg, sg_value, stride);
+        if (id_in_sg + stride < n_active_subgroups)
+          final_reducer.join(&sg_value, &tmp);
+      }
+    };
+    shuffle_combine_sg(1);
+    shuffle_combine_sg(2);
+    shuffle_combine_sg(4);
+    shuffle_combine_sg(8);
+    shuffle_combine_sg(16);
+    KOKKOS_ASSERT(local_range <= 32);
+#else
+    for (unsigned int stride = 1; stride < local_range; stride <<= 1) {
+      auto tmp =
+          Kokkos::Impl::SYCLReduction::shift_group_left(sg, sg_value, stride);
+      if (id_in_sg + stride < n_active_subgroups)
+        final_reducer.join(&sg_value, &tmp);
+    }
+#endif
+
+    // Finally, we copy the workgroup results back to global memory
+    // to be used in the next iteration. If this is the last
+    // iteration, i.e., there is only one workgroup also call
+    // final() if necessary.
+    if (id_in_sg == 0) {
+      if (final) {
+        final_reducer.final(&sg_value);
+        if (device_accessible_result_ptr != nullptr)
+          device_accessible_result_ptr[0] = sg_value;
+        else
+          results_ptr[0] = sg_value;
+      } else
+        results_ptr[(item.get_group_linear_id())] = sg_value;
+    }
+  }
+}
+
+}  // namespace Kokkos::Impl::SYCLReduction
+
+#endif /* KOKKOS_SYCL_WORKGROUP_REDUCTION_HPP */
diff --git a/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp b/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp
index 883c323f2f..61db6b34aa 100644
--- a/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp
+++ b/core/src/SYCL/Kokkos_SYCL_ZeroMemset.hpp
@@ -26,18 +26,13 @@ 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&) {
+             const View<T, P...>& dst) {
     auto event = exec_space.impl_internal_space_instance()->m_queue->memset(
         dst.data(), 0, dst.size() * sizeof(typename View<T, P...>::value_type));
+#ifndef KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
     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));
+#endif
   }
 };
 
diff --git a/core/src/Serial/Kokkos_Serial.cpp b/core/src/Serial/Kokkos_Serial.cpp
index 6d55dffb7c..44d797f1cc 100644
--- a/core/src/Serial/Kokkos_Serial.cpp
+++ b/core/src/Serial/Kokkos_Serial.cpp
@@ -35,6 +35,9 @@
 namespace Kokkos {
 namespace Impl {
 
+std::vector<SerialInternal*> SerialInternal::all_instances;
+std::mutex SerialInternal::all_instances_mutex;
+
 bool SerialInternal::is_initialized() { return m_is_initialized; }
 
 void SerialInternal::initialize() {
@@ -43,6 +46,12 @@ void SerialInternal::initialize() {
   Impl::SharedAllocationRecord<void, void>::tracking_enable();
 
   m_is_initialized = true;
+
+  // guard pushing to all_instances
+  {
+    std::scoped_lock lock(all_instances_mutex);
+    all_instances.push_back(this);
+  }
 }
 
 void SerialInternal::finalize() {
@@ -58,9 +67,18 @@ void SerialInternal::finalize() {
     m_thread_team_data.scratch_assign(nullptr, 0, 0, 0, 0, 0);
   }
 
-  Kokkos::Profiling::finalize();
-
   m_is_initialized = false;
+
+  // guard erasing from all_instances
+  {
+    std::scoped_lock lock(all_instances_mutex);
+    auto it = std::find(all_instances.begin(), all_instances.end(), this);
+    if (it == all_instances.end())
+      Kokkos::abort(
+          "Execution space instance to be removed couldn't be found!");
+    std::swap(*it, all_instances.back());
+    all_instances.pop_back();
+  }
 }
 
 SerialInternal& SerialInternal::singleton() {
@@ -99,9 +117,12 @@ void SerialInternal::resize_thread_team_data(size_t pool_reduce_bytes,
       m_thread_team_data.disband_team();
       m_thread_team_data.disband_pool();
 
-      space.deallocate("Kokkos::Serial::scratch_mem",
-                       m_thread_team_data.scratch_buffer(),
-                       m_thread_team_data.scratch_bytes());
+      // impl_deallocate doesn't fence which we try to avoid here since that
+      // interferes with the using the m_instance_mutex for ensuring proper
+      // kernel enqueuing
+      space.impl_deallocate("Kokkos::Serial::scratch_mem",
+                            m_thread_team_data.scratch_buffer(),
+                            m_thread_team_data.scratch_bytes());
     }
 
     if (pool_reduce_bytes < old_pool_reduce) {
@@ -121,13 +142,7 @@ void SerialInternal::resize_thread_team_data(size_t pool_reduce_bytes,
         HostThreadTeamData::scratch_size(pool_reduce_bytes, team_reduce_bytes,
                                          team_shared_bytes, thread_local_bytes);
 
-    void* ptr = nullptr;
-    try {
-      ptr = space.allocate("Kokkos::Serial::scratch_mem", alloc_bytes);
-    } catch (Kokkos::Experimental::RawMemoryAllocationFailure const& failure) {
-      // For now, just rethrow the error message the existing way
-      Kokkos::Impl::throw_runtime_exception(failure.get_error_message());
-    }
+    void* ptr = space.allocate("Kokkos::Serial::scratch_mem", alloc_bytes);
 
     m_thread_team_data.scratch_assign(static_cast<char*>(ptr), alloc_bytes,
                                       pool_reduce_bytes, team_reduce_bytes,
@@ -145,11 +160,19 @@ Serial::Serial()
     : m_space_instance(&Impl::SerialInternal::singleton(),
                        [](Impl::SerialInternal*) {}) {}
 
+Serial::Serial(NewInstance)
+    : m_space_instance(new Impl::SerialInternal, [](Impl::SerialInternal* ptr) {
+        ptr->finalize();
+        delete ptr;
+      }) {
+  m_space_instance->initialize();
+}
+
 void Serial::print_configuration(std::ostream& os, bool /*verbose*/) const {
   os << "Host Serial Execution Space:\n";
   os << "  KOKKOS_ENABLE_SERIAL: yes\n";
 
-#ifdef KOKKOS_INTERNAL_NOT_PARALLEL
+#ifdef KOKKOS_ENABLE_ATOMICS_BYPASS
   os << "Kokkos atomics disabled\n";
 #endif
 
diff --git a/core/src/Serial/Kokkos_Serial.hpp b/core/src/Serial/Kokkos_Serial.hpp
index 2ade37705e..81d43b31b3 100644
--- a/core/src/Serial/Kokkos_Serial.hpp
+++ b/core/src/Serial/Kokkos_Serial.hpp
@@ -30,6 +30,7 @@ static_assert(false,
 
 #include <cstddef>
 #include <iosfwd>
+#include <iterator>
 #include <mutex>
 #include <thread>
 #include <Kokkos_Core_fwd.hpp>
@@ -59,7 +60,10 @@ class SerialInternal {
 
   static SerialInternal& singleton();
 
-  std::mutex m_thread_team_data_mutex;
+  std::mutex m_instance_mutex;
+
+  static std::vector<SerialInternal*> all_instances;
+  static std::mutex all_instances_mutex;
 
   // Resize thread team data scratch memory
   void resize_thread_team_data(size_t pool_reduce_bytes,
@@ -72,6 +76,10 @@ class SerialInternal {
 };
 }  // namespace Impl
 
+struct NewInstance {
+  explicit NewInstance() = default;
+};
+
 /// \class Serial
 /// \brief Kokkos device for non-parallel execution
 ///
@@ -108,13 +116,26 @@ class Serial {
 
   Serial();
 
+  explicit Serial(NewInstance);
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  template <typename T = void>
+  KOKKOS_DEPRECATED_WITH_COMMENT(
+      "Serial execution space should be constructed explicitly.")
+  Serial(NewInstance)
+      : Serial(NewInstance{}) {}
+#endif
+
   /// \brief True if and only if this method is being called in a
   ///   thread-parallel function.
   ///
   /// For the Serial device, this method <i>always</i> returns false,
   /// because parallel_for or parallel_reduce with the Serial device
   /// always execute sequentially.
-  inline static int in_parallel() { return false; }
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED inline static int in_parallel() { return false; }
+#endif
 
   /// \brief Wait until all dispatched functors complete.
   ///
@@ -127,7 +148,14 @@ class Serial {
         name,
         Kokkos::Tools::Experimental::SpecialSynchronizationCases::
             GlobalDeviceSynchronization,
-        []() {});  // TODO: correct device ID
+        []() {
+          std::lock_guard<std::mutex> lock_all_instances(
+              Impl::SerialInternal::all_instances_mutex);
+          for (auto* instance_ptr : Impl::SerialInternal::all_instances) {
+            std::lock_guard<std::mutex> lock_instance(
+                instance_ptr->m_instance_mutex);
+          }
+        });  // TODO: correct device ID
     Kokkos::memory_fence();
   }
 
@@ -135,7 +163,10 @@ class Serial {
                  "Kokkos::Serial::fence: Unnamed Instance Fence") const {
     Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Serial>(
         name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1},
-        []() {});  // TODO: correct device ID
+        [this]() {
+          auto* internal_instance = this->impl_internal_space_instance();
+          std::lock_guard<std::mutex> lock(internal_instance->m_instance_mutex);
+        });  // TODO: correct device ID
     Kokkos::memory_fence();
   }
 
@@ -218,6 +249,38 @@ struct MemorySpaceAccess<Kokkos::Serial::memory_space,
 }  // namespace Impl
 }  // namespace Kokkos
 
+namespace Kokkos::Experimental {
+
+template <class... Args>
+std::vector<Serial> partition_space(const Serial&, Args...) {
+  static_assert(
+      (... && std::is_arithmetic_v<Args>),
+      "Kokkos Error: partitioning arguments must be integers or floats");
+  std::vector<Serial> instances;
+  instances.reserve(sizeof...(Args));
+  std::generate_n(std::back_inserter(instances), sizeof...(Args),
+                  []() { return Serial{NewInstance{}}; });
+  return instances;
+}
+
+template <class T>
+std::vector<Serial> partition_space(const Serial&,
+                                    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<Serial> instances;
+  instances.reserve(weights.size());
+  std::generate_n(std::back_inserter(instances), weights.size(),
+                  []() { return Serial{NewInstance{}}; });
+  return instances;
+}
+
+}  // namespace Kokkos::Experimental
+
 #include <Serial/Kokkos_Serial_Parallel_Range.hpp>
 #include <Serial/Kokkos_Serial_Parallel_MDRange.hpp>
 #include <Serial/Kokkos_Serial_Parallel_Team.hpp>
diff --git a/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp b/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp
index 69787aa500..34e115eca9 100644
--- a/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp
+++ b/core/src/Serial/Kokkos_Serial_Parallel_MDRange.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef KOKKO_SERIAL_PARALLEL_MDRANGE_HPP
-#define KOKKO_SERIAL_PARALLEL_MDRANGE_HPP
+#ifndef KOKKOS_SERIAL_PARALLEL_MDRANGE_HPP
+#define KOKKOS_SERIAL_PARALLEL_MDRANGE_HPP
 
 #include <Kokkos_Parallel.hpp>
 #include <KokkosExp_MDRangePolicy.hpp>
@@ -43,7 +43,14 @@ class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
   }
 
  public:
-  inline void execute() const { this->exec(); }
+  inline void execute() const {
+    // Make sure kernels are running sequentially even when using multiple
+    // threads
+    auto* internal_instance =
+        m_iter.m_rp.space().impl_internal_space_instance();
+    std::lock_guard<std::mutex> lock(internal_instance->m_instance_mutex);
+    this->exec();
+  }
   template <typename Policy, typename Functor>
   static int max_tile_size_product(const Policy&, const Functor&) {
     /**
@@ -104,9 +111,11 @@ class ParallelReduce<CombinedFunctorReducerType,
 
     auto* internal_instance =
         m_iter.m_rp.space().impl_internal_space_instance();
-    // Need to lock resize_thread_team_data
-    std::lock_guard<std::mutex> lock(
-        internal_instance->m_thread_team_data_mutex);
+
+    // Make sure kernels are running sequentially even when using multiple
+    // threads, lock resize_thread_team_data
+    std::lock_guard<std::mutex> instance_lock(
+        internal_instance->m_instance_mutex);
     internal_instance->resize_thread_team_data(
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
diff --git a/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp b/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp
index 56894716db..80faec9041 100644
--- a/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp
+++ b/core/src/Serial/Kokkos_Serial_Parallel_Range.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef KOKKO_SERIAL_PARALLEL_RANGE_HPP
-#define KOKKO_SERIAL_PARALLEL_RANGE_HPP
+#ifndef KOKKOS_SERIAL_PARALLEL_RANGE_HPP
+#define KOKKOS_SERIAL_PARALLEL_RANGE_HPP
 
 #include <Kokkos_Parallel.hpp>
 
@@ -49,6 +49,10 @@ class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>, Kokkos::Serial> {
 
  public:
   inline void execute() const {
+    // Make sure kernels are running sequentially even when using multiple
+    // threads
+    auto* internal_instance = m_policy.space().impl_internal_space_instance();
+    std::lock_guard<std::mutex> lock(internal_instance->m_instance_mutex);
     this->template exec<typename Policy::work_tag>();
   }
 
@@ -103,9 +107,11 @@ class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
     const size_t thread_local_size = 0;  // Never shrinks
 
     auto* internal_instance = m_policy.space().impl_internal_space_instance();
-    // Need to lock resize_thread_team_data
-    std::lock_guard<std::mutex> lock(
-        internal_instance->m_thread_team_data_mutex);
+
+    // Make sure kernels are running sequentially even when using multiple
+    // threads, lock resize_thread_team_data
+    std::lock_guard<std::mutex> instance_lock(
+        internal_instance->m_instance_mutex);
     internal_instance->resize_thread_team_data(
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
@@ -187,10 +193,12 @@ class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
     const size_t team_shared_size  = 0;  // Never shrinks
     const size_t thread_local_size = 0;  // Never shrinks
 
-    // Need to lock resize_thread_team_data
     auto* internal_instance = m_policy.space().impl_internal_space_instance();
-    std::lock_guard<std::mutex> lock(
-        internal_instance->m_thread_team_data_mutex);
+    // Make sure kernels are running sequentially even when using multiple
+    // threads, lock resize_thread_team_data
+    std::lock_guard<std::mutex> instance_lock(
+        internal_instance->m_instance_mutex);
+
     internal_instance->resize_thread_team_data(
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
@@ -253,10 +261,12 @@ class ParallelScanWithTotal<FunctorType, Kokkos::RangePolicy<Traits...>,
     const size_t team_shared_size  = 0;  // Never shrinks
     const size_t thread_local_size = 0;  // Never shrinks
 
-    // Need to lock resize_thread_team_data
     auto* internal_instance = m_policy.space().impl_internal_space_instance();
-    std::lock_guard<std::mutex> lock(
-        internal_instance->m_thread_team_data_mutex);
+    // Make sure kernels are running sequentially even when using multiple
+    // threads, lock resize_thread_team_data
+    std::lock_guard<std::mutex> instance_lock(
+        internal_instance->m_instance_mutex);
+
     internal_instance->resize_thread_team_data(
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
diff --git a/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp b/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp
index 0876f1af22..a523cc86c9 100644
--- a/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp
+++ b/core/src/Serial/Kokkos_Serial_Parallel_Team.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef KOKKO_SERIAL_PARALLEL_TEAM_HPP
-#define KOKKO_SERIAL_PARALLEL_TEAM_HPP
+#ifndef KOKKOS_SERIAL_PARALLEL_TEAM_HPP
+#define KOKKOS_SERIAL_PARALLEL_TEAM_HPP
 
 #include <Kokkos_Parallel.hpp>
 
@@ -37,6 +37,8 @@ class TeamPolicyInternal<Kokkos::Serial, Properties...>
   int m_league_size;
   int m_chunk_size;
 
+  Kokkos::Serial m_space;
+
  public:
   //! Tag this class as a kokkos execution policy
   using execution_policy = TeamPolicyInternal;
@@ -46,10 +48,7 @@ class TeamPolicyInternal<Kokkos::Serial, Properties...>
   //! Execution space of this execution policy:
   using execution_space = Kokkos::Serial;
 
-  const typename traits::execution_space& space() const {
-    static typename traits::execution_space m_space;
-    return m_space;
-  }
+  const typename traits::execution_space& space() const { return m_space; }
 
   template <class ExecSpace, class... OtherProperties>
   friend class TeamPolicyInternal;
@@ -116,12 +115,13 @@ class TeamPolicyInternal<Kokkos::Serial, Properties...>
     return (level == 0 ? 1024 * 32 : 20 * 1024 * 1024);
   }
   /** \brief  Specify league size, request team size */
-  TeamPolicyInternal(const execution_space&, int league_size_request,
+  TeamPolicyInternal(const execution_space& 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_league_size(league_size_request),
-        m_chunk_size(32) {
+        m_chunk_size(32),
+        m_space(space) {
     if (team_size_request > 1)
       Kokkos::abort("Kokkos::abort: Requested Team Size is too large!");
   }
@@ -247,9 +247,11 @@ class ParallelFor<FunctorType, Kokkos::TeamPolicy<Properties...>,
     const size_t thread_local_size = 0;  // Never shrinks
 
     auto* internal_instance = m_policy.space().impl_internal_space_instance();
-    // Need to lock resize_thread_team_data
-    std::lock_guard<std::mutex> lock(
-        internal_instance->m_thread_team_data_mutex);
+    // Make sure kernels are running sequentially even when using multiple
+    // threads, lock resize_thread_team_data
+    std::lock_guard<std::mutex> instance_lock(
+        internal_instance->m_instance_mutex);
+
     internal_instance->resize_thread_team_data(
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
@@ -319,9 +321,11 @@ class ParallelReduce<CombinedFunctorReducerType,
     const size_t thread_local_size = 0;  // Never shrinks
 
     auto* internal_instance = m_policy.space().impl_internal_space_instance();
-    // Need to lock resize_thread_team_data
-    std::lock_guard<std::mutex> lock(
-        internal_instance->m_thread_team_data_mutex);
+    // Make sure kernels are running sequentially even when using multiple
+    // threads, lock resize_thread_team_data
+    std::lock_guard<std::mutex> instance_lock(
+        internal_instance->m_instance_mutex);
+
     internal_instance->resize_thread_team_data(
         pool_reduce_size, team_reduce_size, team_shared_size,
         thread_local_size);
diff --git a/core/src/Serial/Kokkos_Serial_Task.hpp b/core/src/Serial/Kokkos_Serial_Task.hpp
index f9c86f55ce..5905d6d32e 100644
--- a/core/src/Serial/Kokkos_Serial_Task.hpp
+++ b/core/src/Serial/Kokkos_Serial_Task.hpp
@@ -121,7 +121,7 @@ class TaskQueueSpecializationConstrained<
     using task_base_type = TaskBase;
     using queue_type     = typename scheduler_type::queue_type;
 
-    task_base_type* const end = (task_base_type*)task_base_type::EndTag;
+    auto* const end = reinterpret_cast<task_base_type*>(task_base_type::EndTag);
 
     execution_space serial_execution_space;
     auto& data = serial_execution_space.impl_internal_space_instance()
@@ -157,7 +157,7 @@ class TaskQueueSpecializationConstrained<
     using task_base_type = TaskBase;
     using queue_type     = typename scheduler_type::queue_type;
 
-    task_base_type* const end = (task_base_type*)task_base_type::EndTag;
+    auto* const end = reinterpret_cast<task_base_type*>(task_base_type::EndTag);
 
     execution_space serial_execution_space;
 
diff --git a/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp b/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp
index 3ec2dfbcfa..6ad6aabc5a 100644
--- a/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp
+++ b/core/src/Serial/Kokkos_Serial_ZeroMemset.hpp
@@ -22,6 +22,7 @@
 #include <Serial/Kokkos_Serial.hpp>
 
 #include <type_traits>
+#include <cstring>
 
 namespace Kokkos {
 namespace Impl {
@@ -34,14 +35,11 @@ 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) {}
+    View<T, P...>> {
+  ZeroMemset(const Serial&, const View<T, P...>& dst) {
+    using ValueType = typename View<T, P...>::value_type;
+    std::memset(dst.data(), 0, sizeof(ValueType) * dst.size());
+  }
 };
 
 }  // namespace Impl
diff --git a/core/src/Threads/Kokkos_Threads.hpp b/core/src/Threads/Kokkos_Threads.hpp
index db3b771f2b..31653c46ca 100644
--- a/core/src/Threads/Kokkos_Threads.hpp
+++ b/core/src/Threads/Kokkos_Threads.hpp
@@ -38,15 +38,6 @@ static_assert(false,
 
 /*--------------------------------------------------------------------------*/
 
-namespace Kokkos {
-namespace Impl {
-class ThreadsExec;
-enum class fence_is_static { yes, no };
-}  // namespace Impl
-}  // namespace Kokkos
-
-/*--------------------------------------------------------------------------*/
-
 namespace Kokkos {
 
 /** \brief  Execution space for a pool of C++11 threads on a CPU. */
@@ -73,7 +64,9 @@ class Threads {
 
   /// \brief True if and only if this method is being called in a
   ///   thread-parallel function.
-  static int in_parallel();
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED static int in_parallel();
+#endif
 
   /// \brief Print configuration information to the given output stream.
   void print_configuration(std::ostream& os, bool verbose = false) const;
@@ -169,21 +162,5 @@ struct MemorySpaceAccess<Kokkos::Threads::memory_space,
 }  // namespace Impl
 }  // namespace Kokkos
 
-/*--------------------------------------------------------------------------*/
-
-#include <Kokkos_ExecPolicy.hpp>
-#include <Kokkos_Parallel.hpp>
-#include <Threads/Kokkos_ThreadsExec.hpp>
-#include <Threads/Kokkos_ThreadsTeam.hpp>
-#include <Threads/Kokkos_Threads_Parallel_Range.hpp>
-#include <Threads/Kokkos_Threads_Parallel_MDRange.hpp>
-#include <Threads/Kokkos_Threads_Parallel_Team.hpp>
-#include <Threads/Kokkos_Threads_UniqueToken.hpp>
-
-#include <KokkosExp_MDRangePolicy.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
 #endif /* #if defined( KOKKOS_ENABLE_THREADS ) */
 #endif /* #define KOKKOS_THREADS_HPP */
diff --git a/core/src/Threads/Kokkos_ThreadsExec.cpp b/core/src/Threads/Kokkos_Threads_Instance.cpp
similarity index 56%
rename from core/src/Threads/Kokkos_ThreadsExec.cpp
rename to core/src/Threads/Kokkos_Threads_Instance.cpp
index c754091e87..3842966cd7 100644
--- a/core/src/Threads/Kokkos_ThreadsExec.cpp
+++ b/core/src/Threads/Kokkos_Threads_Instance.cpp
@@ -16,17 +16,15 @@
 
 #ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
 #define KOKKOS_IMPL_PUBLIC_INCLUDE
+#include "Threads/Kokkos_Threads_Instance.hpp"
 #endif
 
 #include <Kokkos_Macros.hpp>
 
-#include <cstdint>
-#include <limits>
 #include <utility>
 #include <iostream>
 #include <sstream>
 #include <thread>
-#include <mutex>
 
 #include <Kokkos_Core.hpp>
 
@@ -41,7 +39,6 @@
 namespace Kokkos {
 namespace Impl {
 namespace {
-std::mutex host_internal_cppthread_mutex;
 
 // std::thread compatible driver.
 // Recovery from an exception would require constant intra-thread health
@@ -49,7 +46,7 @@ std::mutex host_internal_cppthread_mutex;
 // abort the process.
 void internal_cppthread_driver() {
   try {
-    ThreadsExec::driver();
+    ThreadsInternal::driver();
   } catch (const std::exception &x) {
     std::cerr << "Exception thrown from worker thread: " << x.what()
               << std::endl;
@@ -62,32 +59,17 @@ void internal_cppthread_driver() {
   }
 }
 
-ThreadsExec s_threads_process;
-ThreadsExec *s_threads_exec[ThreadsExec::MAX_THREAD_COUNT] = {nullptr};
-std::thread::id s_threads_pid[ThreadsExec::MAX_THREAD_COUNT];
-std::pair<unsigned, unsigned> s_threads_coord[ThreadsExec::MAX_THREAD_COUNT];
+ThreadsInternal s_threads_process;
+ThreadsInternal *s_threads_exec[ThreadsInternal::MAX_THREAD_COUNT] = {nullptr};
+std::thread::id s_threads_pid[ThreadsInternal::MAX_THREAD_COUNT];
+std::pair<unsigned, unsigned>
+    s_threads_coord[ThreadsInternal::MAX_THREAD_COUNT];
 
 int s_thread_pool_size[3] = {0, 0, 0};
 
-unsigned s_current_reduce_size = 0;
-unsigned s_current_shared_size = 0;
-
-void (*volatile s_current_function)(ThreadsExec &, const void *);
+void (*volatile s_current_function)(ThreadsInternal &, const void *);
 const void *volatile s_current_function_arg = nullptr;
 
-struct Sentinel {
-  ~Sentinel() {
-    if (s_thread_pool_size[0] || s_thread_pool_size[1] ||
-        s_thread_pool_size[2] || s_current_reduce_size ||
-        s_current_shared_size || s_current_function || s_current_function_arg ||
-        s_threads_exec[0]) {
-      std::cerr << "ERROR : Process exiting while Kokkos::Threads is still "
-                   "initialized"
-                << std::endl;
-    }
-  }
-};
-
 inline unsigned fan_size(const unsigned rank, const unsigned size) {
   const unsigned rank_rev = size - (rank + 1);
   unsigned count          = 0;
@@ -97,6 +79,12 @@ inline unsigned fan_size(const unsigned rank, const unsigned size) {
   return count;
 }
 
+void wait_yield(volatile ThreadState &flag, const ThreadState value) {
+  while (value == flag) {
+    std::this_thread::yield();
+  }
+}
+
 }  // namespace
 }  // namespace Impl
 }  // namespace Kokkos
@@ -107,66 +95,44 @@ inline unsigned fan_size(const unsigned rank, const unsigned size) {
 namespace Kokkos {
 namespace Impl {
 
-//----------------------------------------------------------------------------
-// Spawn a thread
-
-void ThreadsExec::spawn() {
-  std::thread t(internal_cppthread_driver);
-  t.detach();
-}
-
-//----------------------------------------------------------------------------
-
-bool ThreadsExec::is_process() {
+bool ThreadsInternal::is_process() {
   static const std::thread::id master_pid = std::this_thread::get_id();
 
   return master_pid == std::this_thread::get_id();
 }
 
-void ThreadsExec::global_lock() { host_internal_cppthread_mutex.lock(); }
-
-void ThreadsExec::global_unlock() { host_internal_cppthread_mutex.unlock(); }
-
 //----------------------------------------------------------------------------
 
-void ThreadsExec::wait_yield(volatile int &flag, const int value) {
-  while (value == flag) {
-    std::this_thread::yield();
-  }
-}
-
-void execute_function_noop(ThreadsExec &, const void *) {}
+void execute_function_noop(ThreadsInternal &, const void *) {}
 
-void ThreadsExec::driver() {
+void ThreadsInternal::driver() {
   SharedAllocationRecord<void, void>::tracking_enable();
 
-  ThreadsExec this_thread;
+  ThreadsInternal this_thread;
 
-  while (ThreadsExec::Active == this_thread.m_pool_state) {
+  while (this_thread.m_pool_state == ThreadState::Active) {
     (*s_current_function)(this_thread, s_current_function_arg);
 
     // Deactivate thread and wait for reactivation
-    this_thread.m_pool_state = ThreadsExec::Inactive;
+    this_thread.m_pool_state = ThreadState::Inactive;
 
-    wait_yield(this_thread.m_pool_state, ThreadsExec::Inactive);
+    wait_yield(this_thread.m_pool_state, ThreadState::Inactive);
   }
 }
 
-ThreadsExec::ThreadsExec()
+ThreadsInternal::ThreadsInternal()
     : m_pool_base(nullptr),
       m_scratch(nullptr),
       m_scratch_reduce_end(0),
       m_scratch_thread_end(0),
-      m_numa_rank(0),
-      m_numa_core_rank(0),
       m_pool_rank(0),
       m_pool_size(0),
       m_pool_fan_size(0),
-      m_pool_state(ThreadsExec::Terminating) {
+      m_pool_state(ThreadState::Terminating) {
   if (&s_threads_process != this) {
-    // A spawned thread
-
-    ThreadsExec *const nil = nullptr;
+    // The code in the if is executed by a spawned thread not by the root
+    // thread
+    ThreadsInternal *const nil = nullptr;
 
     // Which entry in 's_threads_exec', possibly determined from hwloc binding
     const int entry = reinterpret_cast<size_t>(s_current_function_arg) <
@@ -178,80 +144,66 @@ ThreadsExec::ThreadsExec()
     // Given a good entry set this thread in the 's_threads_exec' array
     if (entry < s_thread_pool_size[0] &&
         nil == atomic_compare_exchange(s_threads_exec + entry, nil, this)) {
-      const std::pair<unsigned, unsigned> coord =
-          Kokkos::hwloc::get_this_thread_coordinate();
-
-      m_numa_rank      = coord.first;
-      m_numa_core_rank = coord.second;
-      m_pool_base      = s_threads_exec;
-      m_pool_rank      = s_thread_pool_size[0] - (entry + 1);
-      m_pool_rank_rev  = s_thread_pool_size[0] - (pool_rank() + 1);
-      m_pool_size      = s_thread_pool_size[0];
-      m_pool_fan_size  = fan_size(m_pool_rank, m_pool_size);
-      m_pool_state     = ThreadsExec::Active;
+      m_pool_base     = s_threads_exec;
+      m_pool_rank     = s_thread_pool_size[0] - (entry + 1);
+      m_pool_rank_rev = s_thread_pool_size[0] - (pool_rank() + 1);
+      m_pool_size     = s_thread_pool_size[0];
+      m_pool_fan_size = fan_size(m_pool_rank, m_pool_size);
+      m_pool_state    = ThreadState::Active;
 
       s_threads_pid[m_pool_rank] = std::this_thread::get_id();
 
       // Inform spawning process that the threads_exec entry has been set.
-      s_threads_process.m_pool_state = ThreadsExec::Active;
+      s_threads_process.m_pool_state = ThreadState::Active;
     } else {
       // Inform spawning process that the threads_exec entry could not be set.
-      s_threads_process.m_pool_state = ThreadsExec::Terminating;
+      s_threads_process.m_pool_state = ThreadState::Terminating;
     }
   } else {
     // Enables 'parallel_for' to execute on unitialized Threads device
     m_pool_rank  = 0;
     m_pool_size  = 1;
-    m_pool_state = ThreadsExec::Inactive;
+    m_pool_state = ThreadState::Inactive;
 
     s_threads_pid[m_pool_rank] = std::this_thread::get_id();
   }
 }
 
-ThreadsExec::~ThreadsExec() {
+ThreadsInternal::~ThreadsInternal() {
   const unsigned entry = m_pool_size - (m_pool_rank + 1);
 
-  using Record = Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void>;
-
   if (m_scratch) {
-    Record *const r = Record::get_record(m_scratch);
-
+    Kokkos::kokkos_free<Kokkos::HostSpace>(m_scratch);
     m_scratch = nullptr;
-
-    Record::decrement(r);
   }
 
   m_pool_base          = nullptr;
   m_scratch_reduce_end = 0;
   m_scratch_thread_end = 0;
-  m_numa_rank          = 0;
-  m_numa_core_rank     = 0;
   m_pool_rank          = 0;
   m_pool_size          = 0;
   m_pool_fan_size      = 0;
 
-  m_pool_state = ThreadsExec::Terminating;
+  m_pool_state = ThreadState::Terminating;
 
   if (&s_threads_process != this && entry < MAX_THREAD_COUNT) {
-    ThreadsExec *const nil = nullptr;
+    ThreadsInternal *const nil = nullptr;
 
     atomic_compare_exchange(s_threads_exec + entry, this, nil);
 
-    s_threads_process.m_pool_state = ThreadsExec::Terminating;
+    s_threads_process.m_pool_state = ThreadState::Terminating;
   }
 }
 
-int ThreadsExec::get_thread_count() { return s_thread_pool_size[0]; }
-
-ThreadsExec *ThreadsExec::get_thread(const int init_thread_rank) {
-  ThreadsExec *const th =
+ThreadsInternal *ThreadsInternal::get_thread(const int init_thread_rank) {
+  ThreadsInternal *const th =
       init_thread_rank < s_thread_pool_size[0]
           ? s_threads_exec[s_thread_pool_size[0] - (init_thread_rank + 1)]
           : nullptr;
 
   if (nullptr == th || th->m_pool_rank != init_thread_rank) {
     std::ostringstream msg;
-    msg << "Kokkos::Impl::ThreadsExec::get_thread ERROR : "
+    msg << "Kokkos::Impl::ThreadsInternal::get_thread ERROR : "
         << "thread " << init_thread_rank << " of " << s_thread_pool_size[0];
     if (nullptr == th) {
       msg << " does not exist";
@@ -264,24 +216,6 @@ ThreadsExec *ThreadsExec::get_thread(const int init_thread_rank) {
   return th;
 }
 
-//----------------------------------------------------------------------------
-
-void ThreadsExec::execute_sleep(ThreadsExec &exec, const void *) {
-  ThreadsExec::global_lock();
-  ThreadsExec::global_unlock();
-
-  const int n        = exec.m_pool_fan_size;
-  const int rank_rev = exec.m_pool_size - (exec.m_pool_rank + 1);
-
-  for (int i = 0; i < n; ++i) {
-    Impl::spinwait_while_equal<int>(
-        exec.m_pool_base[rank_rev + (1 << i)]->m_pool_state,
-        ThreadsExec::Active);
-  }
-
-  exec.m_pool_state = ThreadsExec::Inactive;
-}
-
 }  // namespace Impl
 }  // namespace Kokkos
 
@@ -290,8 +224,8 @@ void ThreadsExec::execute_sleep(ThreadsExec &exec, const void *) {
 namespace Kokkos {
 namespace Impl {
 
-void ThreadsExec::verify_is_process(const std::string &name,
-                                    const bool initialized) {
+void ThreadsInternal::verify_is_process(const std::string &name,
+                                        const bool initialized) {
   if (!is_process()) {
     std::string msg(name);
     msg.append(
@@ -307,63 +241,48 @@ void ThreadsExec::verify_is_process(const std::string &name,
   }
 }
 
-int ThreadsExec::in_parallel() {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+KOKKOS_DEPRECATED int ThreadsInternal::in_parallel() {
   // A thread function is in execution and
   // the function argument is not the special threads process argument and
   // the master process is a worker or is not the master process.
   return s_current_function && (&s_threads_process != s_current_function_arg) &&
          (s_threads_process.m_pool_base || !is_process());
 }
-void ThreadsExec::fence() { internal_fence(Impl::fence_is_static::yes); }
-void ThreadsExec::fence(const std::string &name) {
-  internal_fence(name, Impl::fence_is_static::yes);
+#endif
+void ThreadsInternal::fence() {
+  fence("Kokkos::ThreadsInternal::fence: Unnamed Instance Fence");
 }
-
-void ThreadsExec::internal_fence(Impl::fence_is_static is_static) {
-  internal_fence((is_static == Impl::fence_is_static::no)
-                     ? "Kokkos::ThreadsExec::fence: Unnamed Instance Fence"
-                     : "Kokkos::ThreadsExec::fence: Unnamed Static Fence",
-                 is_static);
+void ThreadsInternal::fence(const std::string &name) {
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Threads>(
+      name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1},
+      internal_fence);
 }
 
 // Wait for root thread to become inactive
-void ThreadsExec::internal_fence(const std::string &name,
-                                 Impl::fence_is_static is_static) {
-  const auto &fence_lam = [&]() {
-    if (s_thread_pool_size[0]) {
-      // Wait for the root thread to complete:
-      Impl::spinwait_while_equal<int>(s_threads_exec[0]->m_pool_state,
-                                      ThreadsExec::Active);
-    }
+void ThreadsInternal::internal_fence() {
+  if (s_thread_pool_size[0]) {
+    // Wait for the root thread to complete:
+    Impl::spinwait_while_equal(s_threads_exec[0]->m_pool_state,
+                               ThreadState::Active);
+  }
 
-    s_current_function     = nullptr;
-    s_current_function_arg = nullptr;
+  s_current_function     = nullptr;
+  s_current_function_arg = nullptr;
 
-    // Make sure function and arguments are cleared before
-    // potentially re-activating threads with a subsequent launch.
-    memory_fence();
-  };
-  if (is_static == Impl::fence_is_static::yes) {
-    Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Threads>(
-        name,
-        Kokkos::Tools::Experimental::SpecialSynchronizationCases::
-            GlobalDeviceSynchronization,
-        fence_lam);
-  } else {
-    Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Threads>(
-        name, Kokkos::Tools::Experimental::Impl::DirectFenceIDHandle{1},
-        fence_lam);
-  }
+  // Make sure function and arguments are cleared before
+  // potentially re-activating threads with a subsequent launch.
+  memory_fence();
 }
 
 /** \brief  Begin execution of the asynchronous functor */
-void ThreadsExec::start(void (*func)(ThreadsExec &, const void *),
-                        const void *arg) {
-  verify_is_process("ThreadsExec::start", true);
+void ThreadsInternal::start(void (*func)(ThreadsInternal &, const void *),
+                            const void *arg) {
+  verify_is_process("ThreadsInternal::start", true);
 
   if (s_current_function || s_current_function_arg) {
     Kokkos::Impl::throw_runtime_exception(
-        std::string("ThreadsExec::start() FAILED : already executing"));
+        std::string("ThreadsInternal::start() FAILED : already executing"));
   }
 
   s_current_function     = func;
@@ -372,68 +291,29 @@ void ThreadsExec::start(void (*func)(ThreadsExec &, const void *),
   // Make sure function and arguments are written before activating threads.
   memory_fence();
 
-  // Activate threads:
+  // Activate threads. The spawned threads will start working on
+  // s_current_function. The root thread is only set to active, we still need to
+  // call s_current_function.
   for (int i = s_thread_pool_size[0]; 0 < i--;) {
-    s_threads_exec[i]->m_pool_state = ThreadsExec::Active;
+    s_threads_exec[i]->m_pool_state = ThreadState::Active;
   }
 
   if (s_threads_process.m_pool_size) {
     // Master process is the root thread, run it:
     (*func)(s_threads_process, arg);
-    s_threads_process.m_pool_state = ThreadsExec::Inactive;
+    s_threads_process.m_pool_state = ThreadState::Inactive;
   }
 }
 
 //----------------------------------------------------------------------------
 
-bool ThreadsExec::sleep() {
-  verify_is_process("ThreadsExec::sleep", true);
-
-  if (&execute_sleep == s_current_function) return false;
-
-  fence();
-
-  ThreadsExec::global_lock();
-
-  s_current_function = &execute_sleep;
-
-  // Activate threads:
-  for (unsigned i = s_thread_pool_size[0]; 0 < i;) {
-    s_threads_exec[--i]->m_pool_state = ThreadsExec::Active;
-  }
-
-  return true;
-}
-
-bool ThreadsExec::wake() {
-  verify_is_process("ThreadsExec::wake", true);
-
-  if (&execute_sleep != s_current_function) return false;
-
-  ThreadsExec::global_unlock();
-
-  if (s_threads_process.m_pool_base) {
-    execute_sleep(s_threads_process, nullptr);
-    s_threads_process.m_pool_state = ThreadsExec::Inactive;
-  }
-
-  fence();
-
-  return true;
-}
-
-//----------------------------------------------------------------------------
-
-void ThreadsExec::execute_resize_scratch_in_serial() {
+void ThreadsInternal::execute_resize_scratch_in_serial() {
   const unsigned begin = s_threads_process.m_pool_base ? 1 : 0;
 
-  auto deallocate_scratch_memory = [](ThreadsExec &exec) {
+  auto deallocate_scratch_memory = [](ThreadsInternal &exec) {
     if (exec.m_scratch) {
-      using Record =
-          Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void>;
-      Record *const r = Record::get_record(exec.m_scratch);
-      exec.m_scratch  = nullptr;
-      Record::decrement(r);
+      Kokkos::kokkos_free<Kokkos::HostSpace>(exec.m_scratch);
+      exec.m_scratch = nullptr;
     }
   };
   if (s_threads_process.m_pool_base) {
@@ -449,18 +329,18 @@ void ThreadsExec::execute_resize_scratch_in_serial() {
   memory_fence();
 
   for (unsigned i = s_thread_pool_size[0]; begin < i;) {
-    ThreadsExec &th = *s_threads_exec[--i];
+    ThreadsInternal &th = *s_threads_exec[--i];
 
-    th.m_pool_state = ThreadsExec::Active;
+    th.m_pool_state = ThreadState::Active;
 
-    wait_yield(th.m_pool_state, ThreadsExec::Active);
+    wait_yield(th.m_pool_state, ThreadState::Active);
   }
 
   if (s_threads_process.m_pool_base) {
     deallocate_scratch_memory(s_threads_process);
-    s_threads_process.m_pool_state = ThreadsExec::Active;
+    s_threads_process.m_pool_state = ThreadState::Active;
     first_touch_allocate_thread_private_scratch(s_threads_process, nullptr);
-    s_threads_process.m_pool_state = ThreadsExec::Inactive;
+    s_threads_process.m_pool_state = ThreadState::Inactive;
   }
 
   s_current_function_arg = nullptr;
@@ -472,27 +352,20 @@ void ThreadsExec::execute_resize_scratch_in_serial() {
 
 //----------------------------------------------------------------------------
 
-void *ThreadsExec::root_reduce_scratch() {
+void *ThreadsInternal::root_reduce_scratch() {
   return s_threads_process.reduce_memory();
 }
 
-void ThreadsExec::first_touch_allocate_thread_private_scratch(ThreadsExec &exec,
-                                                              const void *) {
+void ThreadsInternal::first_touch_allocate_thread_private_scratch(
+    ThreadsInternal &exec, const void *) {
   exec.m_scratch_reduce_end = s_threads_process.m_scratch_reduce_end;
   exec.m_scratch_thread_end = s_threads_process.m_scratch_thread_end;
 
   if (s_threads_process.m_scratch_thread_end) {
     // Allocate tracked memory:
     {
-      using Record =
-          Kokkos::Impl::SharedAllocationRecord<Kokkos::HostSpace, void>;
-      Record *const r =
-          Record::allocate(Kokkos::HostSpace(), "Kokkos::thread_scratch",
-                           s_threads_process.m_scratch_thread_end);
-
-      Record::increment(r);
-
-      exec.m_scratch = r->data();
+      exec.m_scratch = Kokkos::kokkos_malloc<Kokkos::HostSpace>(
+          "Kokkos::thread_scratch", s_threads_process.m_scratch_thread_end);
     }
 
     unsigned *ptr = reinterpret_cast<unsigned *>(exec.m_scratch);
@@ -505,7 +378,7 @@ void ThreadsExec::first_touch_allocate_thread_private_scratch(ThreadsExec &exec,
   }
 }
 
-void *ThreadsExec::resize_scratch(size_t reduce_size, size_t thread_size) {
+void *ThreadsInternal::resize_scratch(size_t reduce_size, size_t thread_size) {
   enum { ALIGN_MASK = Kokkos::Impl::MEMORY_ALIGNMENT - 1 };
 
   fence();
@@ -522,7 +395,7 @@ void *ThreadsExec::resize_scratch(size_t reduce_size, size_t thread_size) {
   if ((old_reduce_size < reduce_size) || (old_thread_size < thread_size) ||
       ((reduce_size == 0 && thread_size == 0) &&
        (old_reduce_size != 0 || old_thread_size != 0))) {
-    verify_is_process("ThreadsExec::resize_scratch", true);
+    verify_is_process("ThreadsInternal::resize_scratch", true);
 
     s_threads_process.m_scratch_reduce_end = reduce_size;
     s_threads_process.m_scratch_thread_end = reduce_size + thread_size;
@@ -537,27 +410,22 @@ void *ThreadsExec::resize_scratch(size_t reduce_size, size_t thread_size) {
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::print_configuration(std::ostream &s, const bool detail) {
-  verify_is_process("ThreadsExec::print_configuration", false);
+void ThreadsInternal::print_configuration(std::ostream &s, const bool detail) {
+  verify_is_process("ThreadsInternal::print_configuration", false);
 
   fence();
 
-  const unsigned numa_count     = Kokkos::hwloc::get_available_numa_count();
-  const unsigned cores_per_numa = Kokkos::hwloc::get_available_cores_per_numa();
-  const unsigned threads_per_core =
-      Kokkos::hwloc::get_available_threads_per_core();
-
-  // Forestall compiler warnings for unused variables.
-  (void)numa_count;
-  (void)cores_per_numa;
-  (void)threads_per_core;
-
   s << "Kokkos::Threads";
 
 #if defined(KOKKOS_ENABLE_THREADS)
   s << " KOKKOS_ENABLE_THREADS";
 #endif
 #if defined(KOKKOS_ENABLE_HWLOC)
+  const unsigned numa_count     = Kokkos::hwloc::get_available_numa_count();
+  const unsigned cores_per_numa = Kokkos::hwloc::get_available_cores_per_numa();
+  const unsigned threads_per_core =
+      Kokkos::hwloc::get_available_threads_per_core();
+
   s << " hwloc[" << numa_count << "x" << cores_per_numa << "x"
     << threads_per_core << "]";
 #endif
@@ -569,25 +437,21 @@ void ThreadsExec::print_configuration(std::ostream &s, const bool detail) {
     if (nullptr == s_threads_process.m_pool_base) {
       s << " Asynchronous";
     }
-    s << " ReduceScratch[" << s_current_reduce_size << "]"
-      << " SharedScratch[" << s_current_shared_size << "]";
     s << std::endl;
 
     if (detail) {
       for (int i = 0; i < s_thread_pool_size[0]; ++i) {
-        ThreadsExec *const th = s_threads_exec[i];
+        ThreadsInternal *const th = s_threads_exec[i];
 
         if (th) {
           const int rank_rev = th->m_pool_size - (th->m_pool_rank + 1);
 
-          s << " Thread[ " << th->m_pool_rank << " : " << th->m_numa_rank << "."
-            << th->m_numa_core_rank << " ]";
+          s << " Thread[ " << th->m_pool_rank << " ]";
 
           s << " Fan{";
           for (int j = 0; j < th->m_pool_fan_size; ++j) {
-            ThreadsExec *const thfan = th->m_pool_base[rank_rev + (1 << j)];
-            s << " [ " << thfan->m_pool_rank << " : " << thfan->m_numa_rank
-              << "." << thfan->m_numa_core_rank << " ]";
+            ThreadsInternal *const thfan = th->m_pool_base[rank_rev + (1 << j)];
+            s << " [ " << thfan->m_pool_rank << " ]";
           }
           s << " }";
 
@@ -605,29 +469,21 @@ void ThreadsExec::print_configuration(std::ostream &s, const bool detail) {
 
 //----------------------------------------------------------------------------
 
-int ThreadsExec::is_initialized() { return nullptr != s_threads_exec[0]; }
+int ThreadsInternal::is_initialized() { return nullptr != s_threads_exec[0]; }
 
-void ThreadsExec::initialize(int thread_count_arg) {
-  // legacy arguments
-  unsigned thread_count       = thread_count_arg == -1 ? 0 : thread_count_arg;
-  unsigned use_numa_count     = 0;
-  unsigned use_cores_per_numa = 0;
-  bool allow_asynchronous_threadpool = false;
-  // need to provide an initializer for Intel compilers
-  static const Sentinel sentinel = {};
+void ThreadsInternal::initialize(int thread_count_arg) {
+  unsigned thread_count = thread_count_arg == -1 ? 0 : thread_count_arg;
 
   const bool is_initialized = 0 != s_thread_pool_size[0];
 
   unsigned thread_spawn_failed = 0;
 
-  for (int i = 0; i < ThreadsExec::MAX_THREAD_COUNT; i++)
+  for (int i = 0; i < ThreadsInternal::MAX_THREAD_COUNT; i++)
     s_threads_exec[i] = nullptr;
 
   if (!is_initialized) {
-    // If thread_count, use_numa_count, or use_cores_per_numa are zero
-    // then they will be given default values based upon hwloc detection
-    // and allowed asynchronous execution.
-
+    // If thread_count is zero then it will be given default values based upon
+    // hwloc detection.
     const bool hwloc_avail = Kokkos::hwloc::available();
     const bool hwloc_can_bind =
         hwloc_avail && Kokkos::hwloc::can_bind_threads();
@@ -640,17 +496,18 @@ void ThreadsExec::initialize(int thread_count_arg) {
                          : 1;
     }
 
-    const unsigned thread_spawn_begin = hwloc::thread_mapping(
-        "Kokkos::Threads::initialize", allow_asynchronous_threadpool,
-        thread_count, use_numa_count, use_cores_per_numa, s_threads_coord);
+    const bool allow_asynchronous_threadpool = false;
+    unsigned use_numa_count                  = 0;
+    unsigned use_cores_per_numa              = 0;
+    hwloc::thread_mapping("Kokkos::Threads::initialize",
+                          allow_asynchronous_threadpool, thread_count,
+                          use_numa_count, use_cores_per_numa, s_threads_coord);
 
     const std::pair<unsigned, unsigned> proc_coord = s_threads_coord[0];
 
-    if (thread_spawn_begin) {
-      // Synchronous with s_threads_coord[0] as the process core
-      // Claim entry #0 for binding the process core.
-      s_threads_coord[0] = std::pair<unsigned, unsigned>(~0u, ~0u);
-    }
+    // Synchronous with s_threads_coord[0] as the process core
+    // Claim entry #0 for binding the process core.
+    s_threads_coord[0] = std::pair<unsigned, unsigned>(~0u, ~0u);
 
     s_thread_pool_size[0] = thread_count;
     s_thread_pool_size[1] = s_thread_pool_size[0] / use_numa_count;
@@ -658,8 +515,8 @@ void ThreadsExec::initialize(int thread_count_arg) {
     s_current_function =
         &execute_function_noop;  // Initialization work function
 
-    for (unsigned ith = thread_spawn_begin; ith < thread_count; ++ith) {
-      s_threads_process.m_pool_state = ThreadsExec::Inactive;
+    for (unsigned ith = 1; ith < thread_count; ++ith) {
+      s_threads_process.m_pool_state = ThreadState::Inactive;
 
       // If hwloc available then spawned thread will
       // choose its own entry in 's_threads_coord'
@@ -675,18 +532,20 @@ void ThreadsExec::initialize(int thread_count_arg) {
       // Wait until spawned thread has attempted to initialize.
       // If spawning and initialization is successful then
       // an entry in 's_threads_exec' will be assigned.
-      ThreadsExec::spawn();
-      wait_yield(s_threads_process.m_pool_state, ThreadsExec::Inactive);
-      if (s_threads_process.m_pool_state == ThreadsExec::Terminating) break;
+      std::thread t(internal_cppthread_driver);
+      t.detach();
+      wait_yield(s_threads_process.m_pool_state, ThreadState::Inactive);
+      if (s_threads_process.m_pool_state == ThreadState::Terminating) break;
     }
 
     // Wait for all spawned threads to deactivate before zeroing the function.
 
-    for (unsigned ith = thread_spawn_begin; ith < thread_count; ++ith) {
+    for (unsigned ith = 1; ith < thread_count; ++ith) {
       // Try to protect against cache coherency failure by casting to volatile.
-      ThreadsExec *const th = ((ThreadsExec * volatile *)s_threads_exec)[ith];
+      ThreadsInternal *const th =
+          ((ThreadsInternal * volatile *)s_threads_exec)[ith];
       if (th) {
-        wait_yield(th->m_pool_state, ThreadsExec::Active);
+        wait_yield(th->m_pool_state, ThreadState::Active);
       } else {
         ++thread_spawn_failed;
       }
@@ -694,7 +553,7 @@ void ThreadsExec::initialize(int thread_count_arg) {
 
     s_current_function             = nullptr;
     s_current_function_arg         = nullptr;
-    s_threads_process.m_pool_state = ThreadsExec::Inactive;
+    s_threads_process.m_pool_state = ThreadState::Inactive;
 
     memory_fence();
 
@@ -705,30 +564,17 @@ void ThreadsExec::initialize(int thread_count_arg) {
         Kokkos::hwloc::bind_this_thread(proc_coord);
       }
 
-      if (thread_spawn_begin) {  // Include process in pool.
-        const std::pair<unsigned, unsigned> coord =
-            Kokkos::hwloc::get_this_thread_coordinate();
-
-        s_threads_exec[0]                  = &s_threads_process;
-        s_threads_process.m_numa_rank      = coord.first;
-        s_threads_process.m_numa_core_rank = coord.second;
-        s_threads_process.m_pool_base      = s_threads_exec;
-        s_threads_process.m_pool_rank =
-            thread_count - 1;  // Reversed for scan-compatible reductions
-        s_threads_process.m_pool_size     = thread_count;
-        s_threads_process.m_pool_fan_size = fan_size(
-            s_threads_process.m_pool_rank, s_threads_process.m_pool_size);
-        s_threads_pid[s_threads_process.m_pool_rank] =
-            std::this_thread::get_id();
-      } else {
-        s_threads_process.m_pool_base     = nullptr;
-        s_threads_process.m_pool_rank     = 0;
-        s_threads_process.m_pool_size     = 0;
-        s_threads_process.m_pool_fan_size = 0;
-      }
+      s_threads_exec[0]             = &s_threads_process;
+      s_threads_process.m_pool_base = s_threads_exec;
+      s_threads_process.m_pool_rank =
+          thread_count - 1;  // Reversed for scan-compatible reductions
+      s_threads_process.m_pool_size     = thread_count;
+      s_threads_process.m_pool_fan_size = fan_size(
+          s_threads_process.m_pool_rank, s_threads_process.m_pool_size);
+      s_threads_pid[s_threads_process.m_pool_rank] = std::this_thread::get_id();
 
       // Initial allocations:
-      ThreadsExec::resize_scratch(1024, 1024);
+      ThreadsInternal::resize_scratch(1024, 1024);
     } else {
       s_thread_pool_size[0] = 0;
       s_thread_pool_size[1] = 0;
@@ -773,8 +619,8 @@ void ThreadsExec::initialize(int thread_count_arg) {
 
 //----------------------------------------------------------------------------
 
-void ThreadsExec::finalize() {
-  verify_is_process("ThreadsExec::finalize", false);
+void ThreadsInternal::finalize() {
+  verify_is_process("ThreadsInternal::finalize", false);
 
   fence();
 
@@ -784,18 +630,18 @@ void ThreadsExec::finalize() {
 
   for (unsigned i = s_thread_pool_size[0]; begin < i--;) {
     if (s_threads_exec[i]) {
-      s_threads_exec[i]->m_pool_state = ThreadsExec::Terminating;
+      s_threads_exec[i]->m_pool_state = ThreadState::Terminating;
 
-      wait_yield(s_threads_process.m_pool_state, ThreadsExec::Inactive);
+      wait_yield(s_threads_process.m_pool_state, ThreadState::Inactive);
 
-      s_threads_process.m_pool_state = ThreadsExec::Inactive;
+      s_threads_process.m_pool_state = ThreadState::Inactive;
     }
 
     s_threads_pid[i] = std::thread::id();
   }
 
   if (s_threads_process.m_pool_base) {
-    (&s_threads_process)->~ThreadsExec();
+    (&s_threads_process)->~ThreadsInternal();
     s_threads_exec[0] = nullptr;
   }
 
@@ -808,15 +654,11 @@ void ThreadsExec::finalize() {
   s_thread_pool_size[2] = 0;
 
   // Reset master thread to run solo.
-  s_threads_process.m_numa_rank      = 0;
-  s_threads_process.m_numa_core_rank = 0;
-  s_threads_process.m_pool_base      = nullptr;
-  s_threads_process.m_pool_rank      = 0;
-  s_threads_process.m_pool_size      = 1;
-  s_threads_process.m_pool_fan_size  = 0;
-  s_threads_process.m_pool_state     = ThreadsExec::Inactive;
-
-  Kokkos::Profiling::finalize();
+  s_threads_process.m_pool_base     = nullptr;
+  s_threads_process.m_pool_rank     = 0;
+  s_threads_process.m_pool_size     = 1;
+  s_threads_process.m_pool_fan_size = 0;
+  s_threads_process.m_pool_state    = ThreadState::Inactive;
 }
 
 //----------------------------------------------------------------------------
@@ -836,7 +678,7 @@ int Threads::concurrency() const { return impl_thread_pool_size(0); }
 #endif
 
 void Threads::fence(const std::string &name) const {
-  Impl::ThreadsExec::internal_fence(name, Impl::fence_is_static::no);
+  Impl::ThreadsInternal::fence(name);
 }
 
 Threads &Threads::impl_instance(int) {
diff --git a/core/src/Threads/Kokkos_ThreadsExec.hpp b/core/src/Threads/Kokkos_Threads_Instance.hpp
similarity index 76%
rename from core/src/Threads/Kokkos_ThreadsExec.hpp
rename to core/src/Threads/Kokkos_Threads_Instance.hpp
index 8b15928deb..a5eb231cb0 100644
--- a/core/src/Threads/Kokkos_ThreadsExec.hpp
+++ b/core/src/Threads/Kokkos_Threads_Instance.hpp
@@ -14,47 +14,34 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_THREADSEXEC_HPP
-#define KOKKOS_THREADSEXEC_HPP
+#ifndef KOKKOS_THREADS_INSTANCE_HPP
+#define KOKKOS_THREADS_INSTANCE_HPP
 
 #include <Kokkos_Macros.hpp>
 
 #include <cstdio>
-
+#include <ostream>
 #include <utility>
-#include <impl/Kokkos_Spinwait.hpp>
 
 #include <Kokkos_Atomic.hpp>
+#include <Kokkos_Pair.hpp>
 
 #include <impl/Kokkos_ConcurrentBitset.hpp>
+#include <Threads/Kokkos_Threads.hpp>
+#include <Threads/Kokkos_Threads_Spinwait.hpp>
+#include <Threads/Kokkos_Threads_State.hpp>
 
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 namespace Impl {
-class ThreadsExec {
+class ThreadsInternal {
  public:
   // Fan array has log_2(NT) reduction threads plus 2 scan threads
   // Currently limited to 16k threads.
-  enum { MAX_FAN_COUNT = 16 };
-  enum { MAX_THREAD_COUNT = 1 << (MAX_FAN_COUNT - 2) };
-  enum { VECTOR_LENGTH = 8 };
-
-  /** \brief States of a worker thread */
-  enum {
-    Terminating  ///<  Termination in progress
-    ,
-    Inactive  ///<  Exists, waiting for work
-    ,
-    Active  ///<  Exists, performing work
-    ,
-    Rendezvous  ///<  Exists, waiting in a barrier or reduce
-
-    ,
-    ScanCompleted,
-    ScanAvailable,
-    ReductionAvailable
-  };
+  static constexpr int MAX_FAN_COUNT    = 16;
+  static constexpr int MAX_THREAD_COUNT = 1 << (MAX_FAN_COUNT - 2);
+  static constexpr int VECTOR_LENGTH    = 8;
 
  private:
   friend class Kokkos::Threads;
@@ -64,18 +51,16 @@ class ThreadsExec {
   // the threads that need them.
   // For a simple reduction the thread location is arbitrary.
 
-  ThreadsExec *const *m_pool_base;  ///< Base for pool fan-in
+  ThreadsInternal *const *m_pool_base;  ///< Base for pool fan-in
 
   void *m_scratch;
   int m_scratch_reduce_end;
   size_t m_scratch_thread_end;
-  int m_numa_rank;
-  int m_numa_core_rank;
   int m_pool_rank;
   int m_pool_rank_rev;
   int m_pool_size;
   int m_pool_fan_size;
-  int volatile m_pool_state;  ///< State for global synchronizations
+  ThreadState volatile m_pool_state;  ///< State for global synchronizations
 
   // Members for dynamic scheduling
   // Which thread am I stealing from currently
@@ -90,41 +75,36 @@ class ThreadsExec {
 
   static void global_lock();
   static void global_unlock();
-  static void spawn();
 
-  static void first_touch_allocate_thread_private_scratch(ThreadsExec &,
+  static void first_touch_allocate_thread_private_scratch(ThreadsInternal &,
                                                           const void *);
-  static void execute_sleep(ThreadsExec &, const void *);
 
-  ThreadsExec(const ThreadsExec &);
-  ThreadsExec &operator=(const ThreadsExec &);
+  ThreadsInternal(const ThreadsInternal &);
+  ThreadsInternal &operator=(const ThreadsInternal &);
 
   static void execute_resize_scratch_in_serial();
 
  public:
   KOKKOS_INLINE_FUNCTION int pool_size() const { return m_pool_size; }
   KOKKOS_INLINE_FUNCTION int pool_rank() const { return m_pool_rank; }
-  KOKKOS_INLINE_FUNCTION int numa_rank() const { return m_numa_rank; }
-  KOKKOS_INLINE_FUNCTION int numa_core_rank() const { return m_numa_core_rank; }
   inline long team_work_index() const { return m_team_work_index; }
 
-  static int get_thread_count();
-  static ThreadsExec *get_thread(const int init_thread_rank);
+  static ThreadsInternal *get_thread(const int init_thread_rank);
 
   inline void *reduce_memory() const { return m_scratch; }
   KOKKOS_INLINE_FUNCTION void *scratch_memory() const {
     return reinterpret_cast<unsigned char *>(m_scratch) + m_scratch_reduce_end;
   }
 
-  KOKKOS_INLINE_FUNCTION int volatile &state() { return m_pool_state; }
-  KOKKOS_INLINE_FUNCTION ThreadsExec *const *pool_base() const {
+  KOKKOS_INLINE_FUNCTION ThreadState volatile &state() { return m_pool_state; }
+  KOKKOS_INLINE_FUNCTION ThreadsInternal *const *pool_base() const {
     return m_pool_base;
   }
 
   static void driver(void);
 
-  ~ThreadsExec();
-  ThreadsExec();
+  ~ThreadsInternal();
+  ThreadsInternal();
 
   static void *resize_scratch(size_t reduce_size, size_t thread_size);
 
@@ -140,15 +120,8 @@ class ThreadsExec {
 
   static void finalize();
 
-  /* Given a requested team size, return valid team size */
-  static unsigned team_size_valid(unsigned);
-
   static void print_configuration(std::ostream &, const bool detail = false);
 
-  //------------------------------------
-
-  static void wait_yield(volatile int &, const int);
-
   //------------------------------------
   // All-thread functions:
 
@@ -163,14 +136,14 @@ class ThreadsExec {
     // Fan-in reduction with highest ranking thread as the root
     for (int i = 0; i < m_pool_fan_size; ++i) {
       // Wait: Active -> Rendezvous
-      Impl::spinwait_while_equal<int>(
-          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+      spinwait_while_equal(m_pool_base[rev_rank + (1 << i)]->m_pool_state,
+                           ThreadState::Active);
     }
 
     if (rev_rank) {
-      m_pool_state = ThreadsExec::Rendezvous;
+      m_pool_state = ThreadState::Rendezvous;
       // Wait: Rendezvous -> Active
-      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::Rendezvous);
+      spinwait_while_equal(m_pool_state, ThreadState::Rendezvous);
     } else {
       // Root thread does the reduction and broadcast
 
@@ -188,7 +161,7 @@ class ThreadsExec {
       memory_fence();
 
       for (int rank = 0; rank < m_pool_size; ++rank) {
-        get_thread(rank)->m_pool_state = ThreadsExec::Active;
+        get_thread(rank)->m_pool_state = ThreadState::Active;
       }
     }
 
@@ -204,21 +177,21 @@ class ThreadsExec {
     // Fan-in reduction with highest ranking thread as the root
     for (int i = 0; i < m_pool_fan_size; ++i) {
       // Wait: Active -> Rendezvous
-      Impl::spinwait_while_equal<int>(
-          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+      spinwait_while_equal(m_pool_base[rev_rank + (1 << i)]->m_pool_state,
+                           ThreadState::Active);
     }
 
     if (rev_rank) {
-      m_pool_state = ThreadsExec::Rendezvous;
+      m_pool_state = ThreadState::Rendezvous;
       // Wait: Rendezvous -> Active
-      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::Rendezvous);
+      spinwait_while_equal(m_pool_state, ThreadState::Rendezvous);
     } else {
       // Root thread does the reduction and broadcast
 
       memory_fence();
 
       for (int rank = 0; rank < m_pool_size; ++rank) {
-        get_thread(rank)->m_pool_state = ThreadsExec::Active;
+        get_thread(rank)->m_pool_state = ThreadState::Active;
       }
     }
   }
@@ -231,9 +204,9 @@ class ThreadsExec {
     const int rev_rank = m_pool_size - (m_pool_rank + 1);
 
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      ThreadsExec &fan = *m_pool_base[rev_rank + (1 << i)];
+      ThreadsInternal &fan = *m_pool_base[rev_rank + (1 << i)];
 
-      Impl::spinwait_while_equal<int>(fan.m_pool_state, ThreadsExec::Active);
+      spinwait_while_equal(fan.m_pool_state, ThreadState::Active);
 
       f.join(
           reinterpret_cast<typename FunctorType::value_type *>(reduce_memory()),
@@ -262,8 +235,8 @@ class ThreadsExec {
     const int rev_rank = m_pool_size - (m_pool_rank + 1);
 
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      Impl::spinwait_while_equal<int>(
-          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+      spinwait_while_equal(m_pool_base[rev_rank + (1 << i)]->m_pool_state,
+                           ThreadState::Active);
     }
   }
 
@@ -286,10 +259,10 @@ class ThreadsExec {
     //--------------------------------
     // Fan-in reduction with highest ranking thread as the root
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      ThreadsExec &fan = *m_pool_base[rev_rank + (1 << i)];
+      ThreadsInternal &fan = *m_pool_base[rev_rank + (1 << i)];
 
       // Wait: Active -> ReductionAvailable (or ScanAvailable)
-      Impl::spinwait_while_equal<int>(fan.m_pool_state, ThreadsExec::Active);
+      spinwait_while_equal(fan.m_pool_state, ThreadState::Active);
       f.join(work_value, fan.reduce_memory());
     }
 
@@ -300,39 +273,37 @@ class ThreadsExec {
 
     if (rev_rank) {
       // Set: Active -> ReductionAvailable
-      m_pool_state = ThreadsExec::ReductionAvailable;
+      m_pool_state = ThreadState::ReductionAvailable;
 
       // Wait for contributing threads' scan value to be available.
       if ((1 << m_pool_fan_size) < (m_pool_rank + 1)) {
-        ThreadsExec &th = *m_pool_base[rev_rank + (1 << m_pool_fan_size)];
+        ThreadsInternal &th = *m_pool_base[rev_rank + (1 << m_pool_fan_size)];
 
         // Wait: Active             -> ReductionAvailable
         // Wait: ReductionAvailable -> ScanAvailable
-        Impl::spinwait_while_equal<int>(th.m_pool_state, ThreadsExec::Active);
-        Impl::spinwait_while_equal<int>(th.m_pool_state,
-                                        ThreadsExec::ReductionAvailable);
+        spinwait_while_equal(th.m_pool_state, ThreadState::Active);
+        spinwait_while_equal(th.m_pool_state, ThreadState::ReductionAvailable);
 
         f.join(work_value + count, ((scalar_type *)th.reduce_memory()) + count);
       }
 
       // This thread has completed inclusive scan
       // Set: ReductionAvailable -> ScanAvailable
-      m_pool_state = ThreadsExec::ScanAvailable;
+      m_pool_state = ThreadState::ScanAvailable;
 
       // Wait for all threads to complete inclusive scan
       // Wait: ScanAvailable -> Rendezvous
-      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::ScanAvailable);
+      spinwait_while_equal(m_pool_state, ThreadState::ScanAvailable);
     }
 
     //--------------------------------
 
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      ThreadsExec &fan = *m_pool_base[rev_rank + (1 << i)];
+      ThreadsInternal &fan = *m_pool_base[rev_rank + (1 << i)];
       // Wait: ReductionAvailable -> ScanAvailable
-      Impl::spinwait_while_equal<int>(fan.m_pool_state,
-                                      ThreadsExec::ReductionAvailable);
+      spinwait_while_equal(fan.m_pool_state, ThreadState::ReductionAvailable);
       // Set: ScanAvailable -> Rendezvous
-      fan.m_pool_state = ThreadsExec::Rendezvous;
+      fan.m_pool_state = ThreadState::Rendezvous;
     }
 
     // All threads have completed the inclusive scan.
@@ -343,7 +314,7 @@ class ThreadsExec {
     if ((rev_rank + 1) < m_pool_size) {
       // Exclusive scan: copy the previous thread's inclusive scan value
 
-      ThreadsExec &th = *m_pool_base[rev_rank + 1];  // Not the root thread
+      ThreadsInternal &th = *m_pool_base[rev_rank + 1];  // Not the root thread
 
       const scalar_type *const src_value =
           ((scalar_type *)th.reduce_memory()) + count;
@@ -359,19 +330,18 @@ class ThreadsExec {
     // Wait for all threads to copy previous thread's inclusive scan value
     // Wait for all threads: Rendezvous -> ScanCompleted
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      Impl::spinwait_while_equal<int>(
-          m_pool_base[rev_rank + (1 << i)]->m_pool_state,
-          ThreadsExec::Rendezvous);
+      spinwait_while_equal(m_pool_base[rev_rank + (1 << i)]->m_pool_state,
+                           ThreadState::Rendezvous);
     }
     if (rev_rank) {
       // Set: ScanAvailable -> ScanCompleted
-      m_pool_state = ThreadsExec::ScanCompleted;
+      m_pool_state = ThreadState::ScanCompleted;
       // Wait: ScanCompleted -> Active
-      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::ScanCompleted);
+      spinwait_while_equal(m_pool_state, ThreadState::ScanCompleted);
     }
     // Set: ScanCompleted -> Active
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      m_pool_base[rev_rank + (1 << i)]->m_pool_state = ThreadsExec::Active;
+      m_pool_base[rev_rank + (1 << i)]->m_pool_state = ThreadState::Active;
     }
   }
 
@@ -388,8 +358,8 @@ class ThreadsExec {
     // Fan-in reduction with highest ranking thread as the root
     for (int i = 0; i < m_pool_fan_size; ++i) {
       // Wait: Active -> Rendezvous
-      Impl::spinwait_while_equal<int>(
-          m_pool_base[rev_rank + (1 << i)]->m_pool_state, ThreadsExec::Active);
+      spinwait_while_equal(m_pool_base[rev_rank + (1 << i)]->m_pool_state,
+                           ThreadState::Active);
     }
 
     for (unsigned i = 0; i < count; ++i) {
@@ -397,9 +367,9 @@ class ThreadsExec {
     }
 
     if (rev_rank) {
-      m_pool_state = ThreadsExec::Rendezvous;
+      m_pool_state = ThreadState::Rendezvous;
       // Wait: Rendezvous -> Active
-      Impl::spinwait_while_equal<int>(m_pool_state, ThreadsExec::Rendezvous);
+      spinwait_while_equal(m_pool_state, ThreadState::Rendezvous);
     } else {
       // Root thread does the thread-scan before releasing threads
 
@@ -421,7 +391,7 @@ class ThreadsExec {
     }
 
     for (int i = 0; i < m_pool_fan_size; ++i) {
-      m_pool_base[rev_rank + (1 << i)]->m_pool_state = ThreadsExec::Active;
+      m_pool_base[rev_rank + (1 << i)]->m_pool_state = ThreadState::Active;
     }
   }
 
@@ -430,18 +400,14 @@ class ThreadsExec {
    *          complete and release the Threads device.
    *          Acquire the Threads device and start this functor.
    */
-  static void start(void (*)(ThreadsExec &, const void *), const void *);
+  static void start(void (*)(ThreadsInternal &, const void *), const void *);
 
-  static int in_parallel();
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  KOKKOS_DEPRECATED static int in_parallel();
+#endif
   static void fence();
   static void fence(const std::string &);
-  static void internal_fence(
-      Impl::fence_is_static is_static = Impl::fence_is_static::yes);
-  static void internal_fence(
-      const std::string &,
-      Impl::fence_is_static is_static = Impl::fence_is_static::yes);
-  static bool sleep();
-  static bool wake();
+  static void internal_fence();
 
   /* Dynamic Scheduling related functionality */
   // Initialize the work range for this thread
@@ -580,30 +546,38 @@ class ThreadsExec {
 
 namespace Kokkos {
 
-inline int Threads::in_parallel() { return Impl::ThreadsExec::in_parallel(); }
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+KOKKOS_DEPRECATED inline int Threads::in_parallel() {
+  return Impl::ThreadsInternal::in_parallel();
+}
+#endif
 
 inline int Threads::impl_is_initialized() {
-  return Impl::ThreadsExec::is_initialized();
+  return Impl::ThreadsInternal::is_initialized();
 }
 
 inline void Threads::impl_initialize(InitializationSettings const &settings) {
-  Impl::ThreadsExec::initialize(
+  Impl::ThreadsInternal::initialize(
       settings.has_num_threads() ? settings.get_num_threads() : -1);
 }
 
-inline void Threads::impl_finalize() { Impl::ThreadsExec::finalize(); }
+inline void Threads::impl_finalize() { Impl::ThreadsInternal::finalize(); }
 
 inline void Threads::print_configuration(std::ostream &os, bool verbose) const {
   os << "Host Parallel Execution Space:\n";
   os << "  KOKKOS_ENABLE_THREADS: yes\n";
 
   os << "\nThreads Runtime Configuration:\n";
-  Impl::ThreadsExec::print_configuration(os, verbose);
+  Impl::ThreadsInternal::print_configuration(os, verbose);
 }
 
 inline void Threads::impl_static_fence(const std::string &name) {
-  Impl::ThreadsExec::internal_fence(name, Impl::fence_is_static::yes);
+  Kokkos::Tools::Experimental::Impl::profile_fence_event<Kokkos::Threads>(
+      name,
+      Kokkos::Tools::Experimental::SpecialSynchronizationCases::
+          GlobalDeviceSynchronization,
+      Impl::ThreadsInternal::internal_fence);
 }
 } /* namespace Kokkos */
 
-#endif /* #define KOKKOS_THREADSEXEC_HPP */
+#endif
diff --git a/core/src/Threads/Kokkos_Threads_ParallelFor_MDRange.hpp b/core/src/Threads/Kokkos_Threads_ParallelFor_MDRange.hpp
new file mode 100644
index 0000000000..59577609ab
--- /dev/null
+++ b/core/src/Threads/Kokkos_Threads_ParallelFor_MDRange.hpp
@@ -0,0 +1,115 @@
+//@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_THREADS_PARALLEL_FOR_MDRANGE_HPP
+#define KOKKOS_THREADS_PARALLEL_FOR_MDRANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+#include <KokkosExp_MDRangePolicy.hpp>
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
+                  Kokkos::Threads> {
+ 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, typename MDRangePolicy::work_tag, void>;
+
+  const iterate_type m_iter;
+
+  inline void exec_range(const Member ibeg, const Member iend) const {
+    for (Member i = ibeg; i < iend; ++i) {
+      m_iter(i);
+    }
+  }
+
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    exec_schedule<typename Policy::schedule_type::type>(instance, arg);
+  }
+
+  template <class Schedule>
+  static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
+
+    auto const num_tiles = self.m_iter.m_rp.m_num_tiles;
+    WorkRange range(Policy(0, num_tiles).set_chunk_size(1),
+                    instance.pool_rank(), instance.pool_size());
+
+    self.exec_range(range.begin(), range.end());
+
+    instance.fan_in();
+  }
+
+  template <class Schedule>
+  static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
+
+    auto const num_tiles = self.m_iter.m_rp.m_num_tiles;
+    WorkRange range(Policy(0, num_tiles).set_chunk_size(1),
+                    instance.pool_rank(), instance.pool_size());
+
+    instance.set_work_range(range.begin(), range.end(), 1);
+    instance.reset_steal_target();
+    instance.barrier();
+
+    long work_index = instance.get_work_index();
+
+    while (work_index != -1) {
+      const Member begin = static_cast<Member>(work_index);
+      const Member end   = begin + 1 < num_tiles ? begin + 1 : num_tiles;
+
+      self.exec_range(begin, end);
+      work_index = instance.get_work_index();
+    }
+
+    instance.fan_in();
+  }
+
+ public:
+  inline void execute() const {
+    ThreadsInternal::start(&ParallelFor::exec, this);
+    ThreadsInternal::fence();
+  }
+
+  ParallelFor(const FunctorType &arg_functor, const MDRangePolicy &arg_policy)
+      : m_iter(arg_policy, arg_functor) {}
+
+  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
+#endif
diff --git a/core/src/Threads/Kokkos_Threads_ParallelFor_Range.hpp b/core/src/Threads/Kokkos_Threads_ParallelFor_Range.hpp
new file mode 100644
index 0000000000..4a89c4fad8
--- /dev/null
+++ b/core/src/Threads/Kokkos_Threads_ParallelFor_Range.hpp
@@ -0,0 +1,122 @@
+//@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_THREADS_PARALLEL_FOR_RANGE_HPP
+#define KOKKOS_THREADS_PARALLEL_FOR_RANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
+                  Kokkos::Threads> {
+ 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>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member ibeg, const Member iend) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member ibeg, const Member iend) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i);
+    }
+  }
+
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    exec_schedule<typename Policy::schedule_type::type>(instance, arg);
+  }
+
+  template <class Schedule>
+  static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
+
+    WorkRange range(self.m_policy, instance.pool_rank(), instance.pool_size());
+
+    ParallelFor::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                              range.end());
+
+    instance.fan_in();
+  }
+
+  template <class Schedule>
+  static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
+
+    WorkRange range(self.m_policy, instance.pool_rank(), instance.pool_size());
+
+    instance.set_work_range(range.begin() - self.m_policy.begin(),
+                            range.end() - self.m_policy.begin(),
+                            self.m_policy.chunk_size());
+    instance.reset_steal_target();
+    instance.barrier();
+
+    long work_index = instance.get_work_index();
+
+    while (work_index != -1) {
+      const Member begin =
+          static_cast<Member>(work_index) * self.m_policy.chunk_size() +
+          self.m_policy.begin();
+      const Member end =
+          begin + self.m_policy.chunk_size() < self.m_policy.end()
+              ? begin + self.m_policy.chunk_size()
+              : self.m_policy.end();
+      ParallelFor::template exec_range<WorkTag>(self.m_functor, begin, end);
+      work_index = instance.get_work_index();
+    }
+
+    instance.fan_in();
+  }
+
+ public:
+  inline void execute() const {
+    ThreadsInternal::start(&ParallelFor::exec, this);
+    ThreadsInternal::fence();
+  }
+
+  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor), m_policy(arg_policy) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Threads/Kokkos_Threads_ParallelFor_Team.hpp b/core/src/Threads/Kokkos_Threads_ParallelFor_Team.hpp
new file mode 100644
index 0000000000..f927d7c6a6
--- /dev/null
+++ b/core/src/Threads/Kokkos_Threads_ParallelFor_Team.hpp
@@ -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_THREADS_PARALLEL_FOR_TEAM_HPP
+#define KOKKOS_THREADS_PARALLEL_FOR_TEAM_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Properties>
+class ParallelFor<FunctorType, 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;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+  const size_t m_shared;
+
+  template <class TagType, class Schedule>
+  inline static std::enable_if_t<std::is_void<TagType>::value &&
+                                 std::is_same<Schedule, Kokkos::Static>::value>
+  exec_team(const FunctorType &functor, Member member) {
+    for (; member.valid_static(); member.next_static()) {
+      functor(member);
+    }
+  }
+
+  template <class TagType, class Schedule>
+  inline static std::enable_if_t<!std::is_void<TagType>::value &&
+                                 std::is_same<Schedule, Kokkos::Static>::value>
+  exec_team(const FunctorType &functor, Member member) {
+    const TagType t{};
+    for (; member.valid_static(); member.next_static()) {
+      functor(t, member);
+    }
+  }
+
+  template <class TagType, class Schedule>
+  inline static std::enable_if_t<std::is_void<TagType>::value &&
+                                 std::is_same<Schedule, Kokkos::Dynamic>::value>
+  exec_team(const FunctorType &functor, Member member) {
+    for (; member.valid_dynamic(); member.next_dynamic()) {
+      functor(member);
+    }
+  }
+
+  template <class TagType, class Schedule>
+  inline static std::enable_if_t<!std::is_void<TagType>::value &&
+                                 std::is_same<Schedule, Kokkos::Dynamic>::value>
+  exec_team(const FunctorType &functor, Member member) {
+    const TagType t{};
+    for (; member.valid_dynamic(); member.next_dynamic()) {
+      functor(t, member);
+    }
+  }
+
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    const ParallelFor &self = *((const ParallelFor *)arg);
+
+    ParallelFor::exec_team<WorkTag, typename Policy::schedule_type::type>(
+        self.m_functor, Member(&instance, self.m_policy, self.m_shared));
+
+    instance.barrier();
+    instance.fan_in();
+  }
+  template <typename Policy>
+  Policy fix_policy(Policy policy) {
+    if (policy.impl_vector_length() < 0) {
+      policy.impl_set_vector_length(1);
+    }
+    if (policy.team_size() < 0) {
+      policy.impl_set_team_size(
+          policy.team_size_recommended(m_functor, ParallelForTag{}));
+    }
+    return policy;
+  }
+
+ public:
+  inline void execute() const {
+    ThreadsInternal::resize_scratch(
+        0, Policy::member_type::team_reduce_size() + m_shared);
+
+    ThreadsInternal::start(&ParallelFor::exec, this);
+
+    ThreadsInternal::fence();
+  }
+
+  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
+      : m_functor(arg_functor),
+        m_policy(fix_policy(arg_policy)),
+        m_shared(m_policy.scratch_size(0) + m_policy.scratch_size(1) +
+                 FunctorTeamShmemSize<FunctorType>::value(
+                     arg_functor, m_policy.team_size())) {}
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp b/core/src/Threads/Kokkos_Threads_ParallelReduce_MDRange.hpp
similarity index 52%
rename from core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp
rename to core/src/Threads/Kokkos_Threads_ParallelReduce_MDRange.hpp
index 9d06249082..fa63215a9e 100644
--- a/core/src/Threads/Kokkos_Threads_Parallel_MDRange.hpp
+++ b/core/src/Threads/Kokkos_Threads_ParallelReduce_MDRange.hpp
@@ -14,8 +14,8 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_THREADS_PARALLEL_MDRANGE_HPP
-#define KOKKOS_THREADS_PARALLEL_MDRANGE_HPP
+#ifndef KOKKOS_THREADS_PARALLEL_REDUCE_MDRANGE_HPP
+#define KOKKOS_THREADS_PARALLEL_REDUCE_MDRANGE_HPP
 
 #include <Kokkos_Parallel.hpp>
 
@@ -24,93 +24,6 @@
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::MDRangePolicy<Traits...>,
-                  Kokkos::Threads> {
- 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, typename MDRangePolicy::work_tag, void>;
-
-  const iterate_type m_iter;
-
-  inline void exec_range(const Member ibeg, const Member iend) const {
-    for (Member i = ibeg; i < iend; ++i) {
-      m_iter(i);
-    }
-  }
-
-  static void exec(ThreadsExec &exec, const void *arg) {
-    exec_schedule<typename Policy::schedule_type::type>(exec, arg);
-  }
-
-  template <class Schedule>
-  static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
-    const ParallelFor &self = *((const ParallelFor *)arg);
-
-    auto const num_tiles = self.m_iter.m_rp.m_num_tiles;
-    WorkRange range(Policy(0, num_tiles).set_chunk_size(1), exec.pool_rank(),
-                    exec.pool_size());
-
-    self.exec_range(range.begin(), range.end());
-
-    exec.fan_in();
-  }
-
-  template <class Schedule>
-  static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
-    const ParallelFor &self = *((const ParallelFor *)arg);
-
-    auto const num_tiles = self.m_iter.m_rp.m_num_tiles;
-    WorkRange range(Policy(0, num_tiles).set_chunk_size(1), exec.pool_rank(),
-                    exec.pool_size());
-
-    exec.set_work_range(range.begin(), range.end(), 1);
-    exec.reset_steal_target();
-    exec.barrier();
-
-    long work_index = exec.get_work_index();
-
-    while (work_index != -1) {
-      const Member begin = static_cast<Member>(work_index);
-      const Member end   = begin + 1 < num_tiles ? begin + 1 : num_tiles;
-
-      self.exec_range(begin, end);
-      work_index = exec.get_work_index();
-    }
-
-    exec.fan_in();
-  }
-
- public:
-  inline void execute() const {
-    ThreadsExec::start(&ParallelFor::exec, this);
-    ThreadsExec::fence();
-  }
-
-  ParallelFor(const FunctorType &arg_functor, const MDRangePolicy &arg_policy)
-      : m_iter(arg_policy, arg_functor) {}
-
-  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;
-  }
-};
-
 template <class CombinedFunctorReducerType, class... Traits>
 class ParallelReduce<CombinedFunctorReducerType,
                      Kokkos::MDRangePolicy<Traits...>, Kokkos::Threads> {
@@ -141,67 +54,67 @@ class ParallelReduce<CombinedFunctorReducerType,
     }
   }
 
-  static void exec(ThreadsExec &exec, const void *arg) {
-    exec_schedule<typename Policy::schedule_type::type>(exec, arg);
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    exec_schedule<typename Policy::schedule_type::type>(instance, arg);
   }
 
   template <class Schedule>
   static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
     const ParallelReduce &self = *((const ParallelReduce *)arg);
 
     const auto num_tiles = self.m_iter.m_rp.m_num_tiles;
     const WorkRange range(Policy(0, num_tiles).set_chunk_size(1),
-                          exec.pool_rank(), exec.pool_size());
+                          instance.pool_rank(), instance.pool_size());
 
     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())));
+        reducer.init(static_cast<pointer_type>(instance.reduce_memory())));
 
-    exec.fan_in_reduce(reducer);
+    instance.fan_in_reduce(reducer);
   }
 
   template <class Schedule>
   static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
     const ParallelReduce &self = *((const ParallelReduce *)arg);
 
     const auto num_tiles = self.m_iter.m_rp.m_num_tiles;
     const WorkRange range(Policy(0, num_tiles).set_chunk_size(1),
-                          exec.pool_rank(), exec.pool_size());
+                          instance.pool_rank(), instance.pool_size());
 
-    exec.set_work_range(range.begin(), range.end(), 1);
-    exec.reset_steal_target();
-    exec.barrier();
+    instance.set_work_range(range.begin(), range.end(), 1);
+    instance.reset_steal_target();
+    instance.barrier();
 
-    long work_index = exec.get_work_index();
+    long work_index = instance.get_work_index();
 
     const ReducerType &reducer = self.m_iter.m_func.get_reducer();
-    reference_type update =
-        self.m_reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
+    reference_type update      = self.m_reducer.init(
+        static_cast<pointer_type>(instance.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;
       self.exec_range(begin, end, update);
-      work_index = exec.get_work_index();
+      work_index = instance.get_work_index();
     }
 
-    exec.fan_in_reduce(self.m_reducer);
+    instance.fan_in_reduce(self.m_reducer);
   }
 
  public:
   inline void execute() const {
     const ReducerType &reducer = m_iter.m_func.get_reducer();
-    ThreadsExec::resize_scratch(reducer.value_size(), 0);
+    ThreadsInternal::resize_scratch(reducer.value_size(), 0);
 
-    ThreadsExec::start(&ParallelReduce::exec, this);
+    ThreadsInternal::start(&ParallelReduce::exec, this);
 
-    ThreadsExec::fence();
+    ThreadsInternal::fence();
 
     if (m_result_ptr) {
       const pointer_type data =
-          (pointer_type)ThreadsExec::root_reduce_scratch();
+          (pointer_type)ThreadsInternal::root_reduce_scratch();
 
       const unsigned n = reducer.value_count();
       for (unsigned i = 0; i < n; ++i) {
diff --git a/core/src/Threads/Kokkos_Threads_ParallelReduce_Range.hpp b/core/src/Threads/Kokkos_Threads_ParallelReduce_Range.hpp
new file mode 100644
index 0000000000..bf4c2a532a
--- /dev/null
+++ b/core/src/Threads/Kokkos_Threads_ParallelReduce_Range.hpp
@@ -0,0 +1,173 @@
+//@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_THREADS_PARALLEL_REDUCE_RANGE_HPP
+#define KOKKOS_THREADS_PARALLEL_REDUCE_RANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class CombinedFunctorReducerType, class... Traits>
+class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
+                     Kokkos::Threads> {
+ 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 WorkRange = typename Policy::WorkRange;
+  using Member    = typename Policy::member_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;
+
+  template <class TagType>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member &ibeg, const Member &iend,
+      reference_type update) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member &ibeg, const Member &iend,
+      reference_type update) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update);
+    }
+  }
+
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    exec_schedule<typename Policy::schedule_type::type>(instance, arg);
+  }
+
+  template <class Schedule>
+  static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
+    const WorkRange range(self.m_policy, instance.pool_rank(),
+                          instance.pool_size());
+
+    const ReducerType &reducer = self.m_functor_reducer.get_reducer();
+
+    ParallelReduce::template exec_range<WorkTag>(
+        self.m_functor_reducer.get_functor(), range.begin(), range.end(),
+        reducer.init(static_cast<pointer_type>(instance.reduce_memory())));
+
+    instance.fan_in_reduce(reducer);
+  }
+
+  template <class Schedule>
+  static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
+  exec_schedule(ThreadsInternal &instance, const void *arg) {
+    const ParallelReduce &self = *((const ParallelReduce *)arg);
+    const WorkRange range(self.m_policy, instance.pool_rank(),
+                          instance.pool_size());
+
+    instance.set_work_range(range.begin() - self.m_policy.begin(),
+                            range.end() - self.m_policy.begin(),
+                            self.m_policy.chunk_size());
+    instance.reset_steal_target();
+    instance.barrier();
+
+    long work_index            = instance.get_work_index();
+    const ReducerType &reducer = self.m_functor_reducer.get_reducer();
+
+    reference_type update =
+        reducer.init(static_cast<pointer_type>(instance.reduce_memory()));
+    while (work_index != -1) {
+      const Member begin =
+          static_cast<Member>(work_index) * self.m_policy.chunk_size() +
+          self.m_policy.begin();
+      const Member end =
+          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_reducer.get_functor(), begin, end, update);
+      work_index = instance.get_work_index();
+    }
+
+    instance.fan_in_reduce(reducer);
+  }
+
+ public:
+  inline void execute() const {
+    const ReducerType &reducer = m_functor_reducer.get_reducer();
+
+    if (m_policy.end() <= m_policy.begin()) {
+      if (m_result_ptr) {
+        reducer.init(m_result_ptr);
+        reducer.final(m_result_ptr);
+      }
+    } else {
+      ThreadsInternal::resize_scratch(reducer.value_size(), 0);
+
+      ThreadsInternal::start(&ParallelReduce::exec, this);
+
+      ThreadsInternal::fence();
+
+      if (m_result_ptr) {
+        const pointer_type data =
+            (pointer_type)ThreadsInternal::root_reduce_scratch();
+
+        const unsigned n = reducer.value_count();
+        for (unsigned i = 0; i < n; ++i) {
+          m_result_ptr[i] = data[i];
+        }
+      }
+    }
+  }
+
+  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()) {
+    static_assert(Kokkos::is_view<ViewType>::value,
+                  "Kokkos::Threads reduce result must be a View");
+
+    static_assert(
+        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
+                                        Kokkos::HostSpace>::accessible,
+        "Kokkos::Threads reduce result must be a View accessible from "
+        "HostSpace");
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Threads/Kokkos_Threads_Parallel_Team.hpp b/core/src/Threads/Kokkos_Threads_ParallelReduce_Team.hpp
similarity index 53%
rename from core/src/Threads/Kokkos_Threads_Parallel_Team.hpp
rename to core/src/Threads/Kokkos_Threads_ParallelReduce_Team.hpp
index 28efba5ed2..4db310701f 100644
--- a/core/src/Threads/Kokkos_Threads_Parallel_Team.hpp
+++ b/core/src/Threads/Kokkos_Threads_ParallelReduce_Team.hpp
@@ -14,104 +14,14 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_THREADS_PARALLEL_TEAM_HPP
-#define KOKKOS_THREADS_PARALLEL_TEAM_HPP
+#ifndef KOKKOS_THREADS_PARALLEL_REDUCE_TEAM_HPP
+#define KOKKOS_THREADS_PARALLEL_REDUCE_TEAM_HPP
 
 #include <Kokkos_Parallel.hpp>
 
 namespace Kokkos {
 namespace Impl {
 
-template <class FunctorType, class... Properties>
-class ParallelFor<FunctorType, 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;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-  const size_t m_shared;
-
-  template <class TagType, class Schedule>
-  inline static std::enable_if_t<std::is_void<TagType>::value &&
-                                 std::is_same<Schedule, Kokkos::Static>::value>
-  exec_team(const FunctorType &functor, Member member) {
-    for (; member.valid_static(); member.next_static()) {
-      functor(member);
-    }
-  }
-
-  template <class TagType, class Schedule>
-  inline static std::enable_if_t<!std::is_void<TagType>::value &&
-                                 std::is_same<Schedule, Kokkos::Static>::value>
-  exec_team(const FunctorType &functor, Member member) {
-    const TagType t{};
-    for (; member.valid_static(); member.next_static()) {
-      functor(t, member);
-    }
-  }
-
-  template <class TagType, class Schedule>
-  inline static std::enable_if_t<std::is_void<TagType>::value &&
-                                 std::is_same<Schedule, Kokkos::Dynamic>::value>
-  exec_team(const FunctorType &functor, Member member) {
-    for (; member.valid_dynamic(); member.next_dynamic()) {
-      functor(member);
-    }
-  }
-
-  template <class TagType, class Schedule>
-  inline static std::enable_if_t<!std::is_void<TagType>::value &&
-                                 std::is_same<Schedule, Kokkos::Dynamic>::value>
-  exec_team(const FunctorType &functor, Member member) {
-    const TagType t{};
-    for (; member.valid_dynamic(); member.next_dynamic()) {
-      functor(t, member);
-    }
-  }
-
-  static void exec(ThreadsExec &exec, const void *arg) {
-    const ParallelFor &self = *((const ParallelFor *)arg);
-
-    ParallelFor::exec_team<WorkTag, typename Policy::schedule_type::type>(
-        self.m_functor, Member(&exec, self.m_policy, self.m_shared));
-
-    exec.barrier();
-    exec.fan_in();
-  }
-  template <typename Policy>
-  Policy fix_policy(Policy policy) {
-    if (policy.impl_vector_length() < 0) {
-      policy.impl_set_vector_length(1);
-    }
-    if (policy.team_size() < 0) {
-      policy.impl_set_team_size(
-          policy.team_size_recommended(m_functor, ParallelForTag{}));
-    }
-    return policy;
-  }
-
- public:
-  inline void execute() const {
-    ThreadsExec::resize_scratch(
-        0, Policy::member_type::team_reduce_size() + m_shared);
-
-    ThreadsExec::start(&ParallelFor::exec, this);
-
-    ThreadsExec::fence();
-  }
-
-  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
-      : m_functor(arg_functor),
-        m_policy(fix_policy(arg_policy)),
-        m_shared(m_policy.scratch_size(0) + m_policy.scratch_size(1) +
-                 FunctorTeamShmemSize<FunctorType>::value(
-                     arg_functor, m_policy.team_size())) {}
-};
-
 template <class CombinedFunctorReducerType, class... Properties>
 class ParallelReduce<CombinedFunctorReducerType,
                      Kokkos::TeamPolicy<Properties...>, Kokkos::Threads> {
@@ -148,16 +58,16 @@ class ParallelReduce<CombinedFunctorReducerType,
     }
   }
 
-  static void exec(ThreadsExec &exec, const void *arg) {
+  static void exec(ThreadsInternal &instance, const void *arg) {
     const ParallelReduce &self = *((const ParallelReduce *)arg);
 
     ParallelReduce::template exec_team<WorkTag>(
         self.m_functor_reducer.get_functor(),
-        Member(&exec, self.m_policy, self.m_shared),
+        Member(&instance, self.m_policy, self.m_shared),
         self.m_functor_reducer.get_reducer().init(
-            static_cast<pointer_type>(exec.reduce_memory())));
+            static_cast<pointer_type>(instance.reduce_memory())));
 
-    exec.fan_in_reduce(self.m_functor_reducer.get_reducer());
+    instance.fan_in_reduce(self.m_functor_reducer.get_reducer());
   }
 
  public:
@@ -170,17 +80,17 @@ class ParallelReduce<CombinedFunctorReducerType,
         reducer.final(m_result_ptr);
       }
     } else {
-      ThreadsExec::resize_scratch(
+      ThreadsInternal::resize_scratch(
           reducer.value_size(),
           Policy::member_type::team_reduce_size() + m_shared);
 
-      ThreadsExec::start(&ParallelReduce::exec, this);
+      ThreadsInternal::start(&ParallelReduce::exec, this);
 
-      ThreadsExec::fence();
+      ThreadsInternal::fence();
 
       if (m_result_ptr) {
         const pointer_type data =
-            (pointer_type)ThreadsExec::root_reduce_scratch();
+            (pointer_type)ThreadsInternal::root_reduce_scratch();
 
         const unsigned n = reducer.value_count();
         for (unsigned i = 0; i < n; ++i) {
diff --git a/core/src/Threads/Kokkos_Threads_ParallelScan_Range.hpp b/core/src/Threads/Kokkos_Threads_ParallelScan_Range.hpp
new file mode 100644
index 0000000000..62f34d741f
--- /dev/null
+++ b/core/src/Threads/Kokkos_Threads_ParallelScan_Range.hpp
@@ -0,0 +1,198 @@
+//@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_THREADS_PARALLEL_SCAN_RANGE_HPP
+#define KOKKOS_THREADS_PARALLEL_SCAN_RANGE_HPP
+
+#include <Kokkos_Parallel.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+template <class FunctorType, class... Traits>
+class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
+                   Kokkos::Threads> {
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkRange = typename Policy::WorkRange;
+  using WorkTag   = typename Policy::work_tag;
+  using Member    = typename Policy::member_type;
+  using Analysis  = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                                         Policy, FunctorType, void>;
+  using pointer_type   = typename Analysis::pointer_type;
+  using reference_type = typename Analysis::reference_type;
+
+  const FunctorType m_functor;
+  const Policy m_policy;
+
+  template <class TagType>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member &ibeg, const Member &iend,
+      reference_type update, const bool final) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update, final);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member &ibeg, const Member &iend,
+      reference_type update, const bool final) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update, final);
+    }
+  }
+
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    const ParallelScan &self = *((const ParallelScan *)arg);
+
+    const WorkRange range(self.m_policy, instance.pool_rank(),
+                          instance.pool_size());
+
+    typename Analysis::Reducer final_reducer(self.m_functor);
+
+    reference_type update =
+        final_reducer.init(static_cast<pointer_type>(instance.reduce_memory()));
+
+    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                               range.end(), update, false);
+
+    instance.scan_small(final_reducer);
+
+    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
+                                               range.end(), update, true);
+
+    instance.fan_in();
+  }
+
+ public:
+  inline void execute() const {
+    ThreadsInternal::resize_scratch(2 * Analysis::value_size(m_functor), 0);
+    ThreadsInternal::start(&ParallelScan::exec, this);
+    ThreadsInternal::fence();
+  }
+
+  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::Threads> {
+ private:
+  using Policy    = Kokkos::RangePolicy<Traits...>;
+  using WorkRange = typename Policy::WorkRange;
+  using WorkTag   = typename Policy::work_tag;
+  using Member    = typename Policy::member_type;
+
+  using Analysis = Impl::FunctorAnalysis<Impl::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 Policy m_policy;
+  const pointer_type m_result_ptr;
+
+  template <class TagType>
+  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member &ibeg, const Member &iend,
+      reference_type update, const bool final) {
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(i, update, final);
+    }
+  }
+
+  template <class TagType>
+  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
+      const FunctorType &functor, const Member &ibeg, const Member &iend,
+      reference_type update, const bool final) {
+    const TagType t{};
+#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
+    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
+#pragma ivdep
+#endif
+    for (Member i = ibeg; i < iend; ++i) {
+      functor(t, i, update, final);
+    }
+  }
+
+  static void exec(ThreadsInternal &instance, const void *arg) {
+    const ParallelScanWithTotal &self = *((const ParallelScanWithTotal *)arg);
+
+    const WorkRange range(self.m_policy, instance.pool_rank(),
+                          instance.pool_size());
+
+    typename Analysis::Reducer final_reducer(self.m_functor);
+
+    reference_type update =
+        final_reducer.init(static_cast<pointer_type>(instance.reduce_memory()));
+
+    ParallelScanWithTotal::template exec_range<WorkTag>(
+        self.m_functor, range.begin(), range.end(), update, false);
+
+    instance.scan_small(final_reducer);
+
+    ParallelScanWithTotal::template exec_range<WorkTag>(
+        self.m_functor, range.begin(), range.end(), update, true);
+
+    instance.fan_in();
+
+    if (instance.pool_rank() == instance.pool_size() - 1) {
+      *self.m_result_ptr = update;
+    }
+  }
+
+ public:
+  inline void execute() const {
+    ThreadsInternal::resize_scratch(2 * Analysis::value_size(m_functor), 0);
+    ThreadsInternal::start(&ParallelScanWithTotal::exec, this);
+    ThreadsInternal::fence();
+  }
+
+  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::Threads parallel_scan result must be host-accessible!");
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp b/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp
deleted file mode 100644
index f8c2867739..0000000000
--- a/core/src/Threads/Kokkos_Threads_Parallel_Range.hpp
+++ /dev/null
@@ -1,435 +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_THREADS_PARALLEL_RANGE_HPP
-#define KOKKOS_THREADS_PARALLEL_RANGE_HPP
-
-#include <Kokkos_Parallel.hpp>
-
-namespace Kokkos {
-namespace Impl {
-
-template <class FunctorType, class... Traits>
-class ParallelFor<FunctorType, Kokkos::RangePolicy<Traits...>,
-                  Kokkos::Threads> {
- 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>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member ibeg, const Member iend) {
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(i);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member ibeg, const Member iend) {
-    const TagType t{};
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(t, i);
-    }
-  }
-
-  static void exec(ThreadsExec &exec, const void *arg) {
-    exec_schedule<typename Policy::schedule_type::type>(exec, arg);
-  }
-
-  template <class Schedule>
-  static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
-    const ParallelFor &self = *((const ParallelFor *)arg);
-
-    WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
-
-    ParallelFor::template exec_range<WorkTag>(self.m_functor, range.begin(),
-                                              range.end());
-
-    exec.fan_in();
-  }
-
-  template <class Schedule>
-  static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
-    const ParallelFor &self = *((const ParallelFor *)arg);
-
-    WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
-
-    exec.set_work_range(range.begin() - self.m_policy.begin(),
-                        range.end() - self.m_policy.begin(),
-                        self.m_policy.chunk_size());
-    exec.reset_steal_target();
-    exec.barrier();
-
-    long work_index = exec.get_work_index();
-
-    while (work_index != -1) {
-      const Member begin =
-          static_cast<Member>(work_index) * self.m_policy.chunk_size() +
-          self.m_policy.begin();
-      const Member end =
-          begin + self.m_policy.chunk_size() < self.m_policy.end()
-              ? begin + self.m_policy.chunk_size()
-              : self.m_policy.end();
-      ParallelFor::template exec_range<WorkTag>(self.m_functor, begin, end);
-      work_index = exec.get_work_index();
-    }
-
-    exec.fan_in();
-  }
-
- public:
-  inline void execute() const {
-    ThreadsExec::start(&ParallelFor::exec, this);
-    ThreadsExec::fence();
-  }
-
-  ParallelFor(const FunctorType &arg_functor, const Policy &arg_policy)
-      : m_functor(arg_functor), m_policy(arg_policy) {}
-};
-
-template <class CombinedFunctorReducerType, class... Traits>
-class ParallelReduce<CombinedFunctorReducerType, Kokkos::RangePolicy<Traits...>,
-                     Kokkos::Threads> {
- 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 WorkRange = typename Policy::WorkRange;
-  using Member    = typename Policy::member_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;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member &ibeg, const Member &iend,
-      reference_type update) {
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(i, update);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member &ibeg, const Member &iend,
-      reference_type update) {
-    const TagType t{};
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(t, i, update);
-    }
-  }
-
-  static void exec(ThreadsExec &exec, const void *arg) {
-    exec_schedule<typename Policy::schedule_type::type>(exec, arg);
-  }
-
-  template <class Schedule>
-  static std::enable_if_t<std::is_same<Schedule, Kokkos::Static>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
-    const ParallelReduce &self = *((const ParallelReduce *)arg);
-    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
-
-    const ReducerType &reducer = self.m_functor_reducer.get_reducer();
-
-    ParallelReduce::template exec_range<WorkTag>(
-        self.m_functor_reducer.get_functor(), range.begin(), range.end(),
-        reducer.init(static_cast<pointer_type>(exec.reduce_memory())));
-
-    exec.fan_in_reduce(reducer);
-  }
-
-  template <class Schedule>
-  static std::enable_if_t<std::is_same<Schedule, Kokkos::Dynamic>::value>
-  exec_schedule(ThreadsExec &exec, const void *arg) {
-    const ParallelReduce &self = *((const ParallelReduce *)arg);
-    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
-
-    exec.set_work_range(range.begin() - self.m_policy.begin(),
-                        range.end() - self.m_policy.begin(),
-                        self.m_policy.chunk_size());
-    exec.reset_steal_target();
-    exec.barrier();
-
-    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()));
-    while (work_index != -1) {
-      const Member begin =
-          static_cast<Member>(work_index) * self.m_policy.chunk_size() +
-          self.m_policy.begin();
-      const Member end =
-          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_reducer.get_functor(), begin, end, update);
-      work_index = exec.get_work_index();
-    }
-
-    exec.fan_in_reduce(reducer);
-  }
-
- public:
-  inline void execute() const {
-    const ReducerType &reducer = m_functor_reducer.get_reducer();
-
-    if (m_policy.end() <= m_policy.begin()) {
-      if (m_result_ptr) {
-        reducer.init(m_result_ptr);
-        reducer.final(m_result_ptr);
-      }
-    } else {
-      ThreadsExec::resize_scratch(reducer.value_size(), 0);
-
-      ThreadsExec::start(&ParallelReduce::exec, this);
-
-      ThreadsExec::fence();
-
-      if (m_result_ptr) {
-        const pointer_type data =
-            (pointer_type)ThreadsExec::root_reduce_scratch();
-
-        const unsigned n = reducer.value_count();
-        for (unsigned i = 0; i < n; ++i) {
-          m_result_ptr[i] = data[i];
-        }
-      }
-    }
-  }
-
-  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()) {
-    static_assert(Kokkos::is_view<ViewType>::value,
-                  "Kokkos::Threads reduce result must be a View");
-
-    static_assert(
-        Kokkos::Impl::MemorySpaceAccess<typename ViewType::memory_space,
-                                        Kokkos::HostSpace>::accessible,
-        "Kokkos::Threads reduce result must be a View accessible from "
-        "HostSpace");
-  }
-};
-
-template <class FunctorType, class... Traits>
-class ParallelScan<FunctorType, Kokkos::RangePolicy<Traits...>,
-                   Kokkos::Threads> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkRange = typename Policy::WorkRange;
-  using WorkTag   = typename Policy::work_tag;
-  using Member    = typename Policy::member_type;
-  using Analysis  = Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
-                                         Policy, FunctorType, void>;
-  using pointer_type   = typename Analysis::pointer_type;
-  using reference_type = typename Analysis::reference_type;
-
-  const FunctorType m_functor;
-  const Policy m_policy;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member &ibeg, const Member &iend,
-      reference_type update, const bool final) {
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(i, update, final);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member &ibeg, const Member &iend,
-      reference_type update, const bool final) {
-    const TagType t{};
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(t, i, update, final);
-    }
-  }
-
-  static void exec(ThreadsExec &exec, const void *arg) {
-    const ParallelScan &self = *((const ParallelScan *)arg);
-
-    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
-
-    typename Analysis::Reducer final_reducer(self.m_functor);
-
-    reference_type update =
-        final_reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
-
-    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
-                                               range.end(), update, false);
-
-    //  exec.template scan_large( final_reducer );
-    exec.scan_small(final_reducer);
-
-    ParallelScan::template exec_range<WorkTag>(self.m_functor, range.begin(),
-                                               range.end(), update, true);
-
-    exec.fan_in();
-  }
-
- public:
-  inline void execute() const {
-    ThreadsExec::resize_scratch(2 * Analysis::value_size(m_functor), 0);
-    ThreadsExec::start(&ParallelScan::exec, this);
-    ThreadsExec::fence();
-  }
-
-  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::Threads> {
- private:
-  using Policy    = Kokkos::RangePolicy<Traits...>;
-  using WorkRange = typename Policy::WorkRange;
-  using WorkTag   = typename Policy::work_tag;
-  using Member    = typename Policy::member_type;
-
-  using Analysis = Impl::FunctorAnalysis<Impl::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 Policy m_policy;
-  const pointer_type m_result_ptr;
-
-  template <class TagType>
-  inline static std::enable_if_t<std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member &ibeg, const Member &iend,
-      reference_type update, const bool final) {
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(i, update, final);
-    }
-  }
-
-  template <class TagType>
-  inline static std::enable_if_t<!std::is_void<TagType>::value> exec_range(
-      const FunctorType &functor, const Member &ibeg, const Member &iend,
-      reference_type update, const bool final) {
-    const TagType t{};
-#if defined(KOKKOS_ENABLE_AGGRESSIVE_VECTORIZATION) && \
-    defined(KOKKOS_ENABLE_PRAGMA_IVDEP)
-#pragma ivdep
-#endif
-    for (Member i = ibeg; i < iend; ++i) {
-      functor(t, i, update, final);
-    }
-  }
-
-  static void exec(ThreadsExec &exec, const void *arg) {
-    const ParallelScanWithTotal &self = *((const ParallelScanWithTotal *)arg);
-
-    const WorkRange range(self.m_policy, exec.pool_rank(), exec.pool_size());
-
-    typename Analysis::Reducer final_reducer(self.m_functor);
-
-    reference_type update =
-        final_reducer.init(static_cast<pointer_type>(exec.reduce_memory()));
-
-    ParallelScanWithTotal::template exec_range<WorkTag>(
-        self.m_functor, range.begin(), range.end(), update, false);
-
-    //  exec.template scan_large(final_reducer);
-    exec.scan_small(final_reducer);
-
-    ParallelScanWithTotal::template exec_range<WorkTag>(
-        self.m_functor, range.begin(), range.end(), update, true);
-
-    exec.fan_in();
-
-    if (exec.pool_rank() == exec.pool_size() - 1) {
-      *self.m_result_ptr = update;
-    }
-  }
-
- public:
-  inline void execute() const {
-    ThreadsExec::resize_scratch(2 * Analysis::value_size(m_functor), 0);
-    ThreadsExec::start(&ParallelScanWithTotal::exec, this);
-    ThreadsExec::fence();
-  }
-
-  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::Threads parallel_scan result must be host-accessible!");
-  }
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Spinwait.cpp b/core/src/Threads/Kokkos_Threads_Spinwait.cpp
similarity index 90%
rename from core/src/impl/Kokkos_Spinwait.cpp
rename to core/src/Threads/Kokkos_Threads_Spinwait.cpp
index 0a7eda29bc..3df9dc07bf 100644
--- a/core/src/impl/Kokkos_Spinwait.cpp
+++ b/core/src/Threads/Kokkos_Threads_Spinwait.cpp
@@ -21,7 +21,7 @@
 #include <Kokkos_Macros.hpp>
 
 #include <Kokkos_Atomic.hpp>
-#include <impl/Kokkos_Spinwait.hpp>
+#include <Threads/Kokkos_Threads_Spinwait.hpp>
 #include <impl/Kokkos_BitOps.hpp>
 
 #include <thread>
@@ -108,5 +108,15 @@ void host_thread_yield(const uint32_t i, const WaitMode mode) {
 #endif /* defined( KOKKOS_ENABLE_ASM ) */
 }
 
+void spinwait_while_equal(ThreadState const volatile& flag,
+                          ThreadState const value) {
+  Kokkos::store_fence();
+  uint32_t i = 0;
+  while (value == flag) {
+    host_thread_yield(++i, WaitMode::ACTIVE);
+  }
+  Kokkos::load_fence();
+}
+
 }  // namespace Impl
 }  // namespace Kokkos
diff --git a/core/src/Threads/Kokkos_Threads_Spinwait.hpp b/core/src/Threads/Kokkos_Threads_Spinwait.hpp
new file mode 100644
index 0000000000..b98b6dbb73
--- /dev/null
+++ b/core/src/Threads/Kokkos_Threads_Spinwait.hpp
@@ -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
+
+#ifndef KOKKOS_THREADS_SPINWAIT_HPP
+#define KOKKOS_THREADS_SPINWAIT_HPP
+
+#include <Threads/Kokkos_Threads_State.hpp>
+
+#include <cstdint>
+
+namespace Kokkos {
+namespace Impl {
+
+enum class WaitMode : int {
+  ACTIVE  // Used for tight loops to keep threads active longest
+  ,
+  PASSIVE  // Used to quickly yield the thread to quite down the system
+  ,
+  ROOT  // Never sleep or yield the root thread
+};
+
+void host_thread_yield(const uint32_t i, const WaitMode mode);
+
+void spinwait_while_equal(ThreadState const volatile& flag,
+                          ThreadState const value);
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/unit_test/cuda/TestCuda_Graph.cpp b/core/src/Threads/Kokkos_Threads_State.hpp
similarity index 54%
rename from core/unit_test/cuda/TestCuda_Graph.cpp
rename to core/src/Threads/Kokkos_Threads_State.hpp
index 2720363969..148e9aa4e0 100644
--- a/core/unit_test/cuda/TestCuda_Graph.cpp
+++ b/core/src/Threads/Kokkos_Threads_State.hpp
@@ -14,5 +14,26 @@
 //
 //@HEADER
 
-#include <TestCuda_Category.hpp>
-#include <TestGraph.hpp>
+#ifndef KOKKOS_THREADS_STATE_HPP
+#define KOKKOS_THREADS_STATE_HPP
+
+namespace Kokkos {
+namespace Impl {
+/** \brief States of a worker thread */
+enum class ThreadState {
+  Terminating  ///<  Termination in progress
+  ,
+  Inactive  ///<  Exists, waiting for work
+  ,
+  Active  ///<  Exists, performing work
+  ,
+  Rendezvous  ///<  Exists, waiting in a barrier or reduce
+  ,
+  ScanCompleted,
+  ScanAvailable,
+  ReductionAvailable
+};
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/Threads/Kokkos_ThreadsTeam.hpp b/core/src/Threads/Kokkos_Threads_Team.hpp
similarity index 91%
rename from core/src/Threads/Kokkos_ThreadsTeam.hpp
rename to core/src/Threads/Kokkos_Threads_Team.hpp
index 788b6366db..a3501a437d 100644
--- a/core/src/Threads/Kokkos_ThreadsTeam.hpp
+++ b/core/src/Threads/Kokkos_Threads_Team.hpp
@@ -22,10 +22,11 @@
 #include <cstdio>
 
 #include <utility>
-#include <impl/Kokkos_Spinwait.hpp>
 #include <impl/Kokkos_HostThreadTeam.hpp>
 
 #include <Kokkos_Atomic.hpp>
+#include <Threads/Kokkos_Threads_Spinwait.hpp>
+#include <Threads/Kokkos_Threads_State.hpp>
 
 //----------------------------------------------------------------------------
 
@@ -50,8 +51,8 @@ class ThreadsExecTeamMember {
 
  private:
   using space = execution_space::scratch_memory_space;
-  ThreadsExec* const m_exec;
-  ThreadsExec* const* m_team_base;  ///< Base for team fan-in
+  ThreadsInternal* const m_instance;
+  ThreadsInternal* const* m_team_base;  ///< Base for team fan-in
   space m_team_shared;
   size_t m_team_shared_size;
   int m_team_size;
@@ -84,14 +85,13 @@ class ThreadsExecTeamMember {
     for (n = 1;
          (!(m_team_rank_rev & n)) && ((j = m_team_rank_rev + n) < m_team_size);
          n <<= 1) {
-      Impl::spinwait_while_equal<int>(m_team_base[j]->state(),
-                                      ThreadsExec::Active);
+      spinwait_while_equal(m_team_base[j]->state(), ThreadState::Active);
     }
 
     // If not root then wait for release
     if (m_team_rank_rev) {
-      m_exec->state() = ThreadsExec::Rendezvous;
-      Impl::spinwait_while_equal<int>(m_exec->state(), ThreadsExec::Rendezvous);
+      m_instance->state() = ThreadState::Rendezvous;
+      spinwait_while_equal(m_instance->state(), ThreadState::Rendezvous);
     }
 
     return !m_team_rank_rev;
@@ -102,7 +102,7 @@ class ThreadsExecTeamMember {
     for (n = 1;
          (!(m_team_rank_rev & n)) && ((j = m_team_rank_rev + n) < m_team_size);
          n <<= 1) {
-      m_team_base[j]->state() = ThreadsExec::Active;
+      m_team_base[j]->state() = ThreadState::Active;
     }
   }
 
@@ -188,10 +188,8 @@ class ThreadsExecTeamMember {
         using type =
             typename if_c<sizeof(Type) < TEAM_REDUCE_SIZE, Type, void>::type;
 
-        if (nullptr == m_exec) return value;
-
         if (team_rank() != team_size() - 1) *
-            ((volatile type*)m_exec->scratch_memory()) = value;
+            ((volatile type*)m_instance->scratch_memory()) = value;
 
         memory_fence();
 
@@ -229,9 +227,7 @@ class ThreadsExecTeamMember {
         using type = typename if_c<sizeof(value_type) < TEAM_REDUCE_SIZE,
                                    value_type, void>::type;
 
-        if (nullptr == m_exec) return;
-
-        type* const local_value = ((type*)m_exec->scratch_memory());
+        type* const local_value = ((type*)m_instance->scratch_memory());
 
         // Set this thread's contribution
         if (team_rank() != team_size() - 1) { *local_value = contribution; }
@@ -285,9 +281,7 @@ class ThreadsExecTeamMember {
         using type = typename if_c<sizeof(ArgType) < TEAM_REDUCE_SIZE, ArgType,
                                    void>::type;
 
-        if (nullptr == m_exec) return type(0);
-
-        volatile type* const work_value = ((type*)m_exec->scratch_memory());
+        volatile type* const work_value = ((type*)m_instance->scratch_memory());
 
         *work_value = value;
 
@@ -342,10 +336,10 @@ class ThreadsExecTeamMember {
 
   template <class... Properties>
   ThreadsExecTeamMember(
-      Impl::ThreadsExec* exec,
+      Impl::ThreadsInternal* instance,
       const TeamPolicyInternal<Kokkos::Threads, Properties...>& team,
       const size_t shared_size)
-      : m_exec(exec),
+      : m_instance(instance),
         m_team_base(nullptr),
         m_team_shared(nullptr, 0),
         m_team_shared_size(shared_size),
@@ -358,12 +352,15 @@ class ThreadsExecTeamMember {
         m_chunk_size(team.chunk_size()),
         m_league_chunk_end(0),
         m_team_alloc(team.team_alloc()) {
+    KOKKOS_ASSERT(m_instance != nullptr);
     if (team.league_size()) {
       // Execution is using device-team interface:
 
-      const int pool_rank_rev = m_exec->pool_size() - (m_exec->pool_rank() + 1);
+      const int pool_rank_rev =
+          m_instance->pool_size() - (m_instance->pool_rank() + 1);
       const int team_rank_rev = pool_rank_rev % team.team_alloc();
-      const size_t pool_league_size = m_exec->pool_size() / team.team_alloc();
+      const size_t pool_league_size =
+          m_instance->pool_size() / team.team_alloc();
       const size_t pool_league_rank_rev = pool_rank_rev / team.team_alloc();
       if (pool_league_rank_rev >= pool_league_size) {
         m_invalid_thread = 1;
@@ -372,7 +369,7 @@ class ThreadsExecTeamMember {
       const size_t pool_league_rank =
           pool_league_size - (pool_league_rank_rev + 1);
 
-      const int pool_num_teams = m_exec->pool_size() / team.team_alloc();
+      const int pool_num_teams = m_instance->pool_size() / team.team_alloc();
       const int chunk_size =
           team.chunk_size() > 0 ? team.chunk_size() : team.team_iter();
       const int chunks_per_team =
@@ -387,8 +384,8 @@ class ThreadsExecTeamMember {
 
       if ((team.team_alloc() > size_t(m_team_size))
               ? (team_rank_rev >= m_team_size)
-              : (m_exec->pool_size() - pool_num_teams * m_team_size >
-                 m_exec->pool_rank()))
+              : (m_instance->pool_size() - pool_num_teams * m_team_size >
+                 m_instance->pool_rank()))
         m_invalid_thread = 1;
       else
         m_invalid_thread = 0;
@@ -398,7 +395,7 @@ class ThreadsExecTeamMember {
 
       if (team_rank_rev < team.team_size() && !m_invalid_thread) {
         m_team_base =
-            m_exec->pool_base() + team.team_alloc() * pool_league_rank_rev;
+            m_instance->pool_base() + team.team_alloc() * pool_league_rank_rev;
         m_team_size     = team.team_size();
         m_team_rank     = team.team_size() - (team_rank_rev + 1);
         m_team_rank_rev = team_rank_rev;
@@ -413,13 +410,13 @@ class ThreadsExecTeamMember {
       }
 
       if ((m_team_rank_rev == 0) && (m_invalid_thread == 0)) {
-        m_exec->set_work_range(m_league_rank, m_league_end, m_chunk_size);
-        m_exec->reset_steal_target(m_team_size);
+        m_instance->set_work_range(m_league_rank, m_league_end, m_chunk_size);
+        m_instance->reset_steal_target(m_team_size);
       }
       if (std::is_same<typename TeamPolicyInternal<
                            Kokkos::Threads, Properties...>::schedule_type::type,
                        Kokkos::Dynamic>::value) {
-        m_exec->barrier();
+        m_instance->barrier();
       }
     } else {
       m_invalid_thread = 1;
@@ -427,7 +424,7 @@ class ThreadsExecTeamMember {
   }
 
   ThreadsExecTeamMember()
-      : m_exec(nullptr),
+      : m_instance(nullptr),
         m_team_base(nullptr),
         m_team_shared(nullptr, 0),
         m_team_shared_size(0),
@@ -442,8 +439,8 @@ class ThreadsExecTeamMember {
         m_invalid_thread(0),
         m_team_alloc(0) {}
 
-  inline ThreadsExec& threads_exec_team_base() const {
-    return m_team_base ? **m_team_base : *m_exec;
+  inline ThreadsInternal& threads_exec_team_base() const {
+    return m_team_base ? **m_team_base : *m_instance;
   }
 
   bool valid_static() const { return m_league_rank < m_league_end; }
@@ -976,16 +973,19 @@ parallel_reduce(const Impl::ThreadVectorRangeBoundariesStruct<
  * lambda(iType i, ValueType & val, bool final) for each i=0..N-1.
  *
  */
-template <typename iType, class FunctorType>
+template <typename iType, class FunctorType, typename ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::TeamThreadRangeBoundariesStruct<
         iType, Impl::ThreadsExecTeamMember>& loop_bounds,
-    const FunctorType& lambda) {
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+    const FunctorType& lambda, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using closure_value_type = typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
       void>::value_type;
+  static_assert(std::is_same_v<closure_value_type, ValueType>,
+                "Non-matching value types of closure and return type");
 
-  auto scan_val = value_type{};
+  auto scan_val = ValueType{};
 
   // Intra-member scan
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
@@ -996,8 +996,10 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
     lambda(i, scan_val, false);
   }
 
+  auto& team_member = loop_bounds.thread;
+
   // 'scan_val' output is the exclusive prefix sum
-  scan_val = loop_bounds.thread.team_scan(scan_val);
+  scan_val = team_member.team_scan(scan_val);
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
@@ -1006,6 +1008,23 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
        i += loop_bounds.increment) {
     lambda(i, scan_val, true);
   }
+
+  team_member.team_broadcast(scan_val, team_member.team_size() - 1);
+
+  return_val = scan_val;
+}
+
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::TeamThreadRangeBoundariesStruct<
+        iType, Impl::ThreadsExecTeamMember>& loop_bounds,
+    const FunctorType& lambda) {
+  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, FunctorType,
+      void>::value_type;
+
+  value_type scan_val;
+  parallel_scan(loop_bounds, lambda, scan_val);
 }
 
 /** \brief  Intra-thread vector parallel exclusive prefix sum. Executes
@@ -1020,17 +1039,20 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
  * final==true. Scan_val will be set to the final sum value over all vector
  * lanes.
  */
-template <typename iType, class FunctorType>
+template <typename iType, class FunctorType, typename ValueType>
 KOKKOS_INLINE_FUNCTION void parallel_scan(
     const Impl::ThreadVectorRangeBoundariesStruct<
         iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
-    const FunctorType& lambda) {
-  using value_type =
+    const FunctorType& lambda, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using closure_value_type =
       typename Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
                                      TeamPolicy<Threads>, FunctorType,
                                      void>::value_type;
+  static_assert(std::is_same<closure_value_type, ValueType>::value,
+                "Non-matching value types of closure and return type");
 
-  value_type scan_val = value_type();
+  ValueType scan_val = ValueType();
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
@@ -1039,6 +1061,22 @@ KOKKOS_INLINE_FUNCTION void parallel_scan(
        i += loop_boundaries.increment) {
     lambda(i, scan_val, true);
   }
+
+  return_val = scan_val;
+}
+
+template <typename iType, class FunctorType>
+KOKKOS_INLINE_FUNCTION void parallel_scan(
+    const Impl::ThreadVectorRangeBoundariesStruct<
+        iType, Impl::ThreadsExecTeamMember>& loop_boundaries,
+    const FunctorType& lambda) {
+  using value_type =
+      typename Impl::FunctorAnalysis<Impl::FunctorPatternInterface::SCAN,
+                                     TeamPolicy<Threads>, FunctorType,
+                                     void>::value_type;
+
+  value_type scan_val;
+  parallel_scan(loop_boundaries, lambda, scan_val);
 }
 
 /** \brief  Intra-thread vector parallel scan with reducer
diff --git a/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp b/core/src/Threads/Kokkos_Threads_WorkGraphPolicy.hpp
index 797044b117..c88d66db5f 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 <Threads/Kokkos_Threads.hpp>
+#include <Threads/Kokkos_Threads_Instance.hpp>
 
 namespace Kokkos {
 namespace Impl {
@@ -61,16 +61,17 @@ class ParallelFor<FunctorType, Kokkos::WorkGraphPolicy<Traits...>,
     }
   }
 
-  static inline void thread_main(ThreadsExec& exec, const void* arg) noexcept {
+  static inline void thread_main(ThreadsInternal& instance,
+                                 const void* arg) noexcept {
     const Self& self = *(static_cast<const Self*>(arg));
     self.exec_one_thread();
-    exec.fan_in();
+    instance.fan_in();
   }
 
  public:
   inline void execute() {
-    ThreadsExec::start(&Self::thread_main, this);
-    ThreadsExec::fence();
+    ThreadsInternal::start(&Self::thread_main, this);
+    ThreadsInternal::fence();
   }
 
   inline ParallelFor(const FunctorType& arg_functor, const Policy& arg_policy)
diff --git a/core/src/View/Kokkos_ViewAlloc.hpp b/core/src/View/Kokkos_ViewAlloc.hpp
new file mode 100644
index 0000000000..95cb6f619c
--- /dev/null
+++ b/core/src/View/Kokkos_ViewAlloc.hpp
@@ -0,0 +1,318 @@
+//@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_VIEW_ALLOC_HPP
+#define KOKKOS_VIEW_ALLOC_HPP
+
+#include <cstring>
+#include <type_traits>
+#include <string>
+
+#include <impl/Kokkos_Tools.hpp>
+#include <Kokkos_Core_fwd.hpp>
+#include <Kokkos_MemoryTraits.hpp>
+#include <Kokkos_ExecPolicy.hpp>
+#include <impl/Kokkos_ZeroMemset_fwd.hpp>
+
+namespace Kokkos::Impl {
+
+template <typename T>
+bool is_zero_byte(const T& x) {
+  constexpr std::byte all_zeroes[sizeof(T)] = {};
+  return std::memcmp(&x, all_zeroes, sizeof(T)) == 0;
+}
+
+//----------------------------------------------------------------------------
+
+/*
+ *  The construction, assignment to default, and destruction
+ *  are merged into a single functor.
+ *  Primarily to work around an unresolved CUDA back-end bug
+ *  that would lose the destruction cuda device function when
+ *  called from the shared memory tracking destruction.
+ *  Secondarily to have two fewer partial specializations.
+ */
+template <class DeviceType, class ValueType,
+          bool IsScalar = std::is_scalar<ValueType>::value>
+struct ViewValueFunctor;
+
+template <class DeviceType, class ValueType>
+struct ViewValueFunctor<DeviceType, ValueType, false /* is_scalar */> {
+  using ExecSpace = typename DeviceType::execution_space;
+
+  struct DestroyTag {};
+  struct ConstructTag {};
+
+  ExecSpace space;
+  ValueType* ptr;
+  size_t n;
+  std::string name;
+  bool default_exec_space;
+
+  template <class _ValueType = ValueType>
+  KOKKOS_INLINE_FUNCTION
+      std::enable_if_t<std::is_default_constructible<_ValueType>::value>
+      operator()(ConstructTag const&, const size_t i) const {
+    new (ptr + i) ValueType();
+  }
+
+  KOKKOS_INLINE_FUNCTION void operator()(DestroyTag const&,
+                                         const size_t i) const {
+    (ptr + i)->~ValueType();
+  }
+
+  ViewValueFunctor()                        = default;
+  ViewValueFunctor(const ViewValueFunctor&) = default;
+  ViewValueFunctor& operator=(const ViewValueFunctor&) = default;
+
+  ViewValueFunctor(ExecSpace const& arg_space, ValueType* const arg_ptr,
+                   size_t const arg_n, std::string arg_name)
+      : space(arg_space),
+        ptr(arg_ptr),
+        n(arg_n),
+        name(std::move(arg_name)),
+        default_exec_space(false) {
+    functor_instantiate_workaround();
+  }
+
+  ViewValueFunctor(ValueType* const arg_ptr, size_t const arg_n,
+                   std::string arg_name)
+      : space(ExecSpace{}),
+        ptr(arg_ptr),
+        n(arg_n),
+        name(std::move(arg_name)),
+        default_exec_space(true) {
+    functor_instantiate_workaround();
+  }
+
+  template <typename Dummy = ValueType>
+  std::enable_if_t<std::is_trivial<Dummy>::value &&
+                   std::is_trivially_copy_assignable<ValueType>::value>
+  construct_dispatch() {
+    ValueType value{};
+// On A64FX memset seems to do the wrong thing with regards to first touch
+// leading to the significant performance issues
+#ifndef KOKKOS_ARCH_A64FX
+    if (Impl::is_zero_byte(value)) {
+      uint64_t kpID = 0;
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        // We are not really using parallel_for here but using beginParallelFor
+        // instead of begin_parallel_for (and adding "via memset") is the best
+        // we can do to indicate that this is not supposed to be tunable (and
+        // doesn't really execute a parallel_for).
+        Kokkos::Profiling::beginParallelFor(
+            "Kokkos::View::initialization [" + name + "] via memset",
+            Kokkos::Profiling::Experimental::device_id(space), &kpID);
+      }
+      (void)ZeroMemset(
+          space, Kokkos::View<ValueType*, typename DeviceType::memory_space,
+                              Kokkos::MemoryTraits<Kokkos::Unmanaged>>(ptr, n));
+
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        Kokkos::Profiling::endParallelFor(kpID);
+      }
+      if (default_exec_space)
+        space.fence("Kokkos::Impl::ViewValueFunctor: View init/destroy fence");
+    } else {
+#endif
+      parallel_for_implementation<ConstructTag>();
+#ifndef KOKKOS_ARCH_A64FX
+    }
+#endif
+  }
+
+  template <typename Dummy = ValueType>
+  std::enable_if_t<!(std::is_trivial<Dummy>::value &&
+                     std::is_trivially_copy_assignable<ValueType>::value)>
+  construct_dispatch() {
+    parallel_for_implementation<ConstructTag>();
+  }
+
+  template <typename Tag>
+  void parallel_for_implementation() {
+    using PolicyType =
+        Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<int64_t>, Tag>;
+    PolicyType policy(space, 0, n);
+    uint64_t kpID = 0;
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      const std::string functor_name =
+          (std::is_same_v<Tag, DestroyTag>
+               ? "Kokkos::View::destruction [" + name + "]"
+               : "Kokkos::View::initialization [" + name + "]");
+      Kokkos::Profiling::beginParallelFor(
+          functor_name, Kokkos::Profiling::Experimental::device_id(space),
+          &kpID);
+    }
+
+#ifdef KOKKOS_ENABLE_CUDA
+    if (std::is_same<ExecSpace, Kokkos::Cuda>::value) {
+      Kokkos::Impl::cuda_prefetch_pointer(space, ptr, sizeof(ValueType) * n,
+                                          true);
+    }
+#endif
+    const Kokkos::Impl::ParallelFor<ViewValueFunctor, PolicyType> closure(
+        *this, policy);
+    closure.execute();
+    if (default_exec_space || std::is_same_v<Tag, DestroyTag>)
+      space.fence("Kokkos::Impl::ViewValueFunctor: View init/destroy fence");
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endParallelFor(kpID);
+    }
+  }
+
+  void construct_shared_allocation() { construct_dispatch(); }
+
+  void destroy_shared_allocation() {
+#ifdef KOKKOS_ENABLE_IMPL_VIEW_OF_VIEWS_DESTRUCTOR_PRECONDITION_VIOLATION_WORKAROUND
+    if constexpr (std::is_same_v<typename ExecSpace::memory_space,
+                                 Kokkos::HostSpace>)
+      for (size_t i = 0; i < n; ++i) (ptr + i)->~ValueType();
+    else
+#endif
+    {
+      parallel_for_implementation<DestroyTag>();
+    }
+  }
+
+  // This function is to ensure that the functor with DestroyTag is instantiated
+  // This is a workaround to avoid "cudaErrorInvalidDeviceFunction" error later
+  // when the function is queried with cudaFuncGetAttributes
+  void functor_instantiate_workaround() {
+#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) || \
+    defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENMPTARGET)
+    if (false) {
+      parallel_for_implementation<DestroyTag>();
+    }
+#endif
+  }
+};
+
+template <class DeviceType, class ValueType>
+struct ViewValueFunctor<DeviceType, ValueType, true /* is_scalar */> {
+  using ExecSpace  = typename DeviceType::execution_space;
+  using PolicyType = Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<int64_t>>;
+
+  ExecSpace space;
+  ValueType* ptr;
+  size_t n;
+  std::string name;
+  bool default_exec_space;
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(const size_t i) const { ptr[i] = ValueType(); }
+
+  ViewValueFunctor()                        = default;
+  ViewValueFunctor(const ViewValueFunctor&) = default;
+  ViewValueFunctor& operator=(const ViewValueFunctor&) = default;
+
+  ViewValueFunctor(ExecSpace const& arg_space, ValueType* const arg_ptr,
+                   size_t const arg_n, std::string arg_name)
+      : space(arg_space),
+        ptr(arg_ptr),
+        n(arg_n),
+        name(std::move(arg_name)),
+        default_exec_space(false) {}
+
+  ViewValueFunctor(ValueType* const arg_ptr, size_t const arg_n,
+                   std::string arg_name)
+      : space(ExecSpace{}),
+        ptr(arg_ptr),
+        n(arg_n),
+        name(std::move(arg_name)),
+        default_exec_space(true) {}
+
+  template <typename Dummy = ValueType>
+  std::enable_if_t<std::is_trivial<Dummy>::value &&
+                   std::is_trivially_copy_assignable<Dummy>::value>
+  construct_shared_allocation() {
+    // Shortcut for zero initialization
+// On A64FX memset seems to do the wrong thing with regards to first touch
+// leading to the significant performance issues
+#ifndef KOKKOS_ARCH_A64FX
+    ValueType value{};
+    if (Impl::is_zero_byte(value)) {
+      uint64_t kpID = 0;
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        // We are not really using parallel_for here but using beginParallelFor
+        // instead of begin_parallel_for (and adding "via memset") is the best
+        // we can do to indicate that this is not supposed to be tunable (and
+        // doesn't really execute a parallel_for).
+        Kokkos::Profiling::beginParallelFor(
+            "Kokkos::View::initialization [" + name + "] via memset",
+            Kokkos::Profiling::Experimental::device_id(space), &kpID);
+      }
+
+      (void)ZeroMemset(
+          space, Kokkos::View<ValueType*, typename DeviceType::memory_space,
+                              Kokkos::MemoryTraits<Kokkos::Unmanaged>>(ptr, n));
+
+      if (Kokkos::Profiling::profileLibraryLoaded()) {
+        Kokkos::Profiling::endParallelFor(kpID);
+      }
+      if (default_exec_space)
+        space.fence("Kokkos::Impl::ViewValueFunctor: View init/destroy fence");
+    } else {
+#endif
+      parallel_for_implementation();
+#ifndef KOKKOS_ARCH_A64FX
+    }
+#endif
+  }
+
+  template <typename Dummy = ValueType>
+  std::enable_if_t<!(std::is_trivial<Dummy>::value &&
+                     std::is_trivially_copy_assignable<Dummy>::value)>
+  construct_shared_allocation() {
+    parallel_for_implementation();
+  }
+
+  void parallel_for_implementation() {
+    PolicyType policy(space, 0, n);
+    uint64_t kpID = 0;
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::beginParallelFor(
+          "Kokkos::View::initialization [" + name + "]",
+          Kokkos::Profiling::Experimental::device_id(space), &kpID);
+    }
+#ifdef KOKKOS_ENABLE_CUDA
+    if (std::is_same<ExecSpace, Kokkos::Cuda>::value) {
+      Kokkos::Impl::cuda_prefetch_pointer(space, ptr, sizeof(ValueType) * n,
+                                          true);
+    }
+#endif
+    const Kokkos::Impl::ParallelFor<ViewValueFunctor, PolicyType> closure(
+        *this, policy);
+    closure.execute();
+    if (default_exec_space)
+      space.fence(
+          "Kokkos::Impl::ViewValueFunctor: Fence after setting values in "
+          "view");
+    if (Kokkos::Profiling::profileLibraryLoaded()) {
+      Kokkos::Profiling::endParallelFor(kpID);
+    }
+  }
+
+  void destroy_shared_allocation() {}
+};
+}  // namespace Kokkos::Impl
+
+#endif  // KOKKOS_VIEW_ALLOC_HPP
diff --git a/core/src/View/MDSpan/Kokkos_MDSpan_Accessor.hpp b/core/src/View/MDSpan/Kokkos_MDSpan_Accessor.hpp
new file mode 100644
index 0000000000..8814cc015e
--- /dev/null
+++ b/core/src/View/MDSpan/Kokkos_MDSpan_Accessor.hpp
@@ -0,0 +1,220 @@
+//@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
+static_assert(false,
+              "Including non-public Kokkos header files is not allowed.");
+#endif
+
+#ifndef KOKKOS_MDSPAN_ACCESSOR_HPP
+#define KOKKOS_MDSPAN_ACCESSOR_HPP
+
+#include <Kokkos_Macros.hpp>
+#include <Kokkos_Concepts.hpp>
+#include <Kokkos_Core_fwd.hpp>
+#include <desul/atomics.hpp>
+
+namespace Kokkos {
+
+// For now use the accessors in Impl namespace, as an
+// implementation detail for rebasing View on mdspan
+namespace Impl {
+
+template <class MemorySpace, class NestedAccessor>
+struct SpaceAwareAccessor {
+  // Part of Accessor Requirements
+  using element_type     = typename NestedAccessor::element_type;
+  using reference        = typename NestedAccessor::reference;
+  using data_handle_type = typename NestedAccessor::data_handle_type;
+  using offset_policy =
+      SpaceAwareAccessor<MemorySpace, typename NestedAccessor::offset_policy>;
+
+  // Specific to SpaceAwareAccessor
+  using memory_space         = MemorySpace;
+  using nested_accessor_type = NestedAccessor;
+
+  static_assert(is_memory_space_v<memory_space>);
+
+  KOKKOS_DEFAULTED_FUNCTION
+  constexpr SpaceAwareAccessor() = default;
+
+  template <
+      class OtherMemorySpace, class OtherNestedAccessorType,
+      std::enable_if_t<
+          MemorySpaceAccess<MemorySpace, OtherMemorySpace>::assignable &&
+              std::is_constructible_v<NestedAccessor, OtherNestedAccessorType>,
+          int> = 0>
+  KOKKOS_FUNCTION constexpr SpaceAwareAccessor(
+      const SpaceAwareAccessor<OtherMemorySpace, OtherNestedAccessorType>&
+          other) noexcept
+      : nested_acc(other.nested_acc) {}
+
+  KOKKOS_FUNCTION
+  SpaceAwareAccessor(const NestedAccessor& acc) : nested_acc(acc) {}
+
+  KOKKOS_FUNCTION
+  explicit operator NestedAccessor() const { return nested_acc; }
+
+  KOKKOS_FUNCTION
+  constexpr reference access(data_handle_type p, size_t i) const noexcept {
+    Kokkos::Impl::runtime_check_memory_access_violation<memory_space>(
+        "Kokkos::SpaceAwareAccessor ERROR: attempt to access inaccessible "
+        "memory space");
+    return nested_acc.access(p, i);
+  }
+
+  KOKKOS_FUNCTION
+  constexpr typename offset_policy::data_handle_type offset(data_handle_type p,
+                                                            size_t i) const
+      noexcept {
+    return nested_acc.offset(p, i);
+  }
+
+  // Canonical way for accessing nested accessor see ISO C++
+  // [linalg.scaled.scaledaccessor]
+  KOKKOS_FUNCTION
+  constexpr const NestedAccessor& nested_accessor() const noexcept {
+    return nested_acc;
+  }
+
+ private:
+// We either compile with our custom mdspan impl
+// in which case we discover inside it whether no_unique_address
+// works, or we use C++23 in which case it better be available
+#ifdef _MDSPAN_NO_UNIQUE_ADDRESS
+  _MDSPAN_NO_UNIQUE_ADDRESS
+#else
+  [[no_unique_address]]
+#endif
+  NestedAccessor nested_acc;
+  template <class, class>
+  friend struct SpaceAwareAccessor;
+};
+
+template <class NestedAccessor>
+struct SpaceAwareAccessor<AnonymousSpace, NestedAccessor> {
+  // Part of Accessor Requirements
+  using element_type     = typename NestedAccessor::element_type;
+  using reference        = typename NestedAccessor::reference;
+  using data_handle_type = typename NestedAccessor::data_handle_type;
+
+  using offset_policy =
+      SpaceAwareAccessor<AnonymousSpace,
+                         typename NestedAccessor::offset_policy>;
+
+  // Specific to SpaceAwareAccessor
+  using memory_space         = AnonymousSpace;
+  using nested_accessor_type = NestedAccessor;
+
+  KOKKOS_DEFAULTED_FUNCTION
+  constexpr SpaceAwareAccessor() = default;
+
+  template <class OtherMemorySpace, class OtherNestedAccessorType,
+            std::enable_if_t<std::is_constructible_v<NestedAccessor,
+                                                     OtherNestedAccessorType>,
+                             int> = 0>
+  KOKKOS_FUNCTION constexpr SpaceAwareAccessor(
+      const SpaceAwareAccessor<OtherMemorySpace, OtherNestedAccessorType>&
+          other) noexcept
+      : nested_acc(other.nested_acc) {}
+
+  KOKKOS_FUNCTION
+  SpaceAwareAccessor(const NestedAccessor& acc) : nested_acc(acc) {}
+
+  KOKKOS_FUNCTION
+  explicit operator NestedAccessor() const { return nested_acc; }
+
+  KOKKOS_FUNCTION
+  constexpr reference access(data_handle_type p, size_t i) const noexcept {
+    return nested_acc.access(p, i);
+  }
+
+  KOKKOS_FUNCTION
+  constexpr typename offset_policy::data_handle_type offset(data_handle_type p,
+                                                            size_t i) const
+      noexcept {
+    return nested_acc.offset(p, i);
+  }
+
+  // Canonical way for accessing nested accessor see ISO C++
+  // [linalg.scaled.scaledaccessor]
+  KOKKOS_FUNCTION
+  constexpr const NestedAccessor& nested_accessor() const noexcept {
+    return nested_acc;
+  }
+
+ private:
+// We either compile with our custom mdspan impl
+// in which case we discover inside it whether no_unique_address
+// works, or we use C++23 in which case it better be available
+#ifdef _MDSPAN_NO_UNIQUE_ADDRESS
+  _MDSPAN_NO_UNIQUE_ADDRESS
+#else
+  [[no_unique_address]]
+#endif
+  NestedAccessor nested_acc;
+  template <class, class>
+  friend struct SpaceAwareAccessor;
+};
+
+// Like atomic_accessor_relaxed proposed for ISO C++26 but with
+// defaulted memory scope - similar to how desul's AtomicRef has a memory scope
+template <class ElementType, class MemoryScope = desul::MemoryScopeDevice>
+struct AtomicAccessorRelaxed {
+  using element_type = ElementType;
+  using reference =
+      desul::AtomicRef<ElementType, desul::MemoryOrderRelaxed, MemoryScope>;
+  using data_handle_type = ElementType*;
+  using offset_policy    = AtomicAccessorRelaxed;
+
+  KOKKOS_DEFAULTED_FUNCTION
+  AtomicAccessorRelaxed() = default;
+
+  // Conversions from non-const to const element type
+  template <class OtherElementType,
+            std::enable_if_t<std::is_convertible_v<
+                OtherElementType (*)[], element_type (*)[]>>* = nullptr>
+  KOKKOS_FUNCTION constexpr AtomicAccessorRelaxed(
+      Kokkos::default_accessor<OtherElementType>) noexcept {}
+
+  template <class OtherElementType,
+            std::enable_if_t<std::is_convertible_v<
+                OtherElementType (*)[], element_type (*)[]>>* = nullptr>
+  KOKKOS_FUNCTION constexpr AtomicAccessorRelaxed(
+      AtomicAccessorRelaxed<OtherElementType, MemoryScope>) noexcept {}
+
+  template <class OtherElementType,
+            std::enable_if_t<std::is_convertible_v<
+                element_type (*)[], OtherElementType (*)[]>>* = nullptr>
+  KOKKOS_FUNCTION explicit operator default_accessor<OtherElementType>() const {
+    return default_accessor<OtherElementType>{};
+  }
+
+  KOKKOS_FUNCTION
+  reference access(data_handle_type p, size_t i) const noexcept {
+    return reference(p[i]);
+  }
+
+  KOKKOS_FUNCTION
+  data_handle_type offset(data_handle_type p, size_t i) const noexcept {
+    return p + i;
+  }
+};
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif
diff --git a/core/src/View/MDSpan/Kokkos_MDSpan_Extents.hpp b/core/src/View/MDSpan/Kokkos_MDSpan_Extents.hpp
index fb51952543..29d1e00adf 100644
--- a/core/src/View/MDSpan/Kokkos_MDSpan_Extents.hpp
+++ b/core/src/View/MDSpan/Kokkos_MDSpan_Extents.hpp
@@ -37,9 +37,6 @@ struct ViewDimension;
 
 template <class T, class Dim>
 struct ViewDataType;
-}  // namespace Kokkos::Impl
-
-namespace Kokkos::Experimental::Impl {
 
 // A few things to note --
 // - mdspan allows for 0-rank extents similarly to View, so we don't need
@@ -54,7 +51,7 @@ struct ExtentFromDimension {
 // Kokkos uses a dimension of '0' to denote a dynamic dimension.
 template <>
 struct ExtentFromDimension<std::size_t{0}> {
-  static constexpr std::size_t value = std::experimental::dynamic_extent;
+  static constexpr std::size_t value = dynamic_extent;
 };
 
 template <std::size_t N>
@@ -63,7 +60,7 @@ struct DimensionFromExtent {
 };
 
 template <>
-struct DimensionFromExtent<std::experimental::dynamic_extent> {
+struct DimensionFromExtent<dynamic_extent> {
   static constexpr std::size_t value = std::size_t{0};
 };
 
@@ -73,9 +70,9 @@ struct ExtentsFromDimension;
 template <class IndexType, class Dimension, std::size_t... Indices>
 struct ExtentsFromDimension<IndexType, Dimension,
                             std::index_sequence<Indices...>> {
-  using type = std::experimental::extents<
-      IndexType,
-      ExtentFromDimension<Dimension::static_extent(Indices)>::value...>;
+  using type =
+      extents<IndexType,
+              ExtentFromDimension<Dimension::static_extent(Indices)>::value...>;
 };
 
 template <class Extents, class Indices>
@@ -106,6 +103,20 @@ struct DataTypeFromExtents {
   // Will cause a compile error if it is malformed (i.e. dynamic after static)
   using type = typename ::Kokkos::Impl::ViewDataType<T, dimension_type>::type;
 };
-}  // namespace Kokkos::Experimental::Impl
+
+template <class Extents, class VM, std::size_t... Indices>
+constexpr KOKKOS_INLINE_FUNCTION auto extents_from_view_mapping_impl(
+    const VM &view_mapping, std::index_sequence<Indices...>) {
+  return Extents{view_mapping.extent(Indices)...};
+}
+
+template <class Extents, class VM>
+constexpr KOKKOS_INLINE_FUNCTION auto extents_from_view_mapping(
+    const VM &view_mapping) {
+  static_assert(Extents::rank() == VM::Rank);
+  return extents_from_view_mapping_impl<Extents>(
+      view_mapping, std::make_index_sequence<Extents::rank()>{});
+}
+}  // namespace Kokkos::Impl
 
 #endif  // KOKKOS_EXPERIMENTAL_MDSPAN_EXTENTS_HPP
diff --git a/core/src/View/MDSpan/Kokkos_MDSpan_Header.hpp b/core/src/View/MDSpan/Kokkos_MDSpan_Header.hpp
index 495b891cca..f4ae702fc4 100644
--- a/core/src/View/MDSpan/Kokkos_MDSpan_Header.hpp
+++ b/core/src/View/MDSpan/Kokkos_MDSpan_Header.hpp
@@ -23,12 +23,28 @@ static_assert(false,
 #define KOKKOS_EXPERIMENTAL_MDSPAN_HPP
 
 // Look for the right mdspan
-#if __has_include(<mdspan>)
+#if __cplusplus >= 202002L
+#include <version>
+#endif
+
+// Only use standard library mdspan if we are not running Cuda or HIP.
+// Likely these implementations won't be supported on device, so we should use
+// our own device-compatible version for now.
+#if (__cpp_lib_mdspan >= 202207L) && !defined(KOKKOS_ENABLE_CUDA) && \
+    !defined(KOKKOS_ENABLE_HIP)
 #include <mdspan>
-namespace mdspan_ns = std;
+namespace Kokkos {
+using std::default_accessor;
+using std::dextents;
+using std::dynamic_extent;
+using std::extents;
+using std::layout_left;
+using std::layout_right;
+using std::layout_stride;
+using std::mdspan;
+}  // namespace Kokkos
 #else
-#include <experimental/mdspan>
-namespace mdspan_ns = std::experimental;
+#include <mdspan/mdspan.hpp>
 #endif
 
 #endif  // KOKKOS_EXPERIMENTAL_MDSPAN_HPP
diff --git a/core/src/View/MDSpan/Kokkos_MDSpan_Layout.hpp b/core/src/View/MDSpan/Kokkos_MDSpan_Layout.hpp
new file mode 100644
index 0000000000..089628137d
--- /dev/null
+++ b/core/src/View/MDSpan/Kokkos_MDSpan_Layout.hpp
@@ -0,0 +1,156 @@
+//@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
+static_assert(false,
+              "Including non-public Kokkos header files is not allowed.");
+#endif
+
+#ifndef KOKKOS_EXPERIMENTAL_MDSPAN_LAYOUT_HPP
+#define KOKKOS_EXPERIMENTAL_MDSPAN_LAYOUT_HPP
+
+#include "Kokkos_MDSpan_Extents.hpp"
+#include <impl/Kokkos_ViewDataAnalysis.hpp>
+
+namespace Kokkos::Impl {
+
+template <class ArrayLayout>
+struct LayoutFromArrayLayout;
+
+template <>
+struct LayoutFromArrayLayout<Kokkos::LayoutLeft> {
+  using type = Kokkos::Experimental::layout_left_padded<dynamic_extent>;
+};
+
+template <>
+struct LayoutFromArrayLayout<Kokkos::LayoutRight> {
+  using type = Kokkos::Experimental::layout_right_padded<dynamic_extent>;
+};
+
+template <>
+struct LayoutFromArrayLayout<Kokkos::LayoutStride> {
+  using type = layout_stride;
+};
+
+template <class ArrayLayout, class MDSpanType>
+KOKKOS_INLINE_FUNCTION auto array_layout_from_mapping(
+    const typename MDSpanType::mapping_type &mapping) {
+  using mapping_type = typename MDSpanType::mapping_type;
+  using extents_type = typename mapping_type::extents_type;
+
+  constexpr auto rank = extents_type::rank();
+  const auto &ext     = mapping.extents();
+
+  static_assert(rank <= ARRAY_LAYOUT_MAX_RANK,
+                "Unsupported rank for mdspan (must be <= 8)");
+
+  if constexpr (std::is_same_v<ArrayLayout, LayoutStride>) {
+    return Kokkos::LayoutStride{
+        rank > 0 ? ext.extent(0) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 0 ? mapping.stride(0) : 0,
+        rank > 1 ? ext.extent(1) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 1 ? mapping.stride(1) : 0,
+        rank > 2 ? ext.extent(2) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 2 ? mapping.stride(2) : 0,
+        rank > 3 ? ext.extent(3) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 3 ? mapping.stride(3) : 0,
+        rank > 4 ? ext.extent(4) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 4 ? mapping.stride(4) : 0,
+        rank > 5 ? ext.extent(5) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 5 ? mapping.stride(5) : 0,
+        rank > 6 ? ext.extent(6) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 6 ? mapping.stride(6) : 0,
+        rank > 7 ? ext.extent(7) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+        rank > 7 ? mapping.stride(7) : 0,
+    };
+  } else {
+    // FIXME: Kokkos Layouts don't store stride (it's in the mapping)
+    // We could conceivably fix this by adding an extra ViewCtorProp for
+    // an abritrary padding. For now we will check for this.
+    if constexpr (rank > 1 &&
+                  (std::is_same_v<typename mapping_type::layout_type,
+                                  Kokkos::Experimental::layout_left_padded<
+                                      dynamic_extent>> ||
+                   std::is_same_v<typename mapping_type::layout_type,
+                                  Kokkos::Experimental::layout_right_padded<
+                                      dynamic_extent>>)) {
+      [[maybe_unused]] constexpr size_t strided_index =
+          std::is_same_v<
+              typename mapping_type::layout_type,
+              Kokkos::Experimental::layout_left_padded<dynamic_extent>>
+              ? 1
+              : rank - 2;
+      [[maybe_unused]] constexpr size_t extent_index =
+          std::is_same_v<
+              typename mapping_type::layout_type,
+              Kokkos::Experimental::layout_left_padded<dynamic_extent>>
+              ? 0
+              : rank - 1;
+      KOKKOS_ASSERT(mapping.stride(strided_index) == ext.extent(extent_index));
+    }
+
+    return ArrayLayout{rank > 0 ? ext.extent(0) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 1 ? ext.extent(1) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 2 ? ext.extent(2) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 3 ? ext.extent(3) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 4 ? ext.extent(4) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 5 ? ext.extent(5) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 6 ? ext.extent(6) : KOKKOS_IMPL_CTOR_DEFAULT_ARG,
+                       rank > 7 ? ext.extent(7) : KOKKOS_IMPL_CTOR_DEFAULT_ARG};
+  }
+#ifdef KOKKOS_COMPILER_INTEL
+  __builtin_unreachable();
+#endif
+}
+
+template <class MDSpanType, class VM>
+KOKKOS_INLINE_FUNCTION auto mapping_from_view_mapping(const VM &view_mapping) {
+  using mapping_type = typename MDSpanType::mapping_type;
+  using extents_type = typename mapping_type::extents_type;
+
+  // std::span is not available in C++17 (our current requirements),
+  // so we need to use the std::array constructor for layout mappings.
+  // FIXME When C++20 is available, we can use std::span here instead
+  std::size_t strides[VM::Rank];
+  view_mapping.stride_fill(&strides[0]);
+  if constexpr (std::is_same_v<typename mapping_type::layout_type,
+                               Kokkos::layout_stride>) {
+    return mapping_type(Kokkos::mdspan_non_standard,
+                        extents_from_view_mapping<extents_type>(view_mapping),
+                        strides);
+  } else if constexpr (VM::Rank > 1 &&
+                       std::is_same_v<typename mapping_type::layout_type,
+                                      Kokkos::Experimental::layout_left_padded<
+                                          Kokkos::dynamic_extent>>) {
+    return mapping_type(extents_from_view_mapping<extents_type>(view_mapping),
+                        strides[1]);
+  } else if constexpr (VM::Rank > 1 &&
+                       std::is_same_v<typename mapping_type::layout_type,
+                                      Kokkos::Experimental::layout_right_padded<
+                                          Kokkos::dynamic_extent>>) {
+    return mapping_type(extents_from_view_mapping<extents_type>(view_mapping),
+                        strides[VM::Rank - 2]);
+  } else {
+    return mapping_type(extents_from_view_mapping<extents_type>(view_mapping));
+  }
+#ifdef KOKKOS_COMPILER_INTEL
+  __builtin_unreachable();
+#endif
+}
+
+}  // namespace Kokkos::Impl
+
+#endif  // KOKKOS_EXPERIMENTAL_MDSPAN_LAYOUT_HPP
diff --git a/core/src/decl/Kokkos_Declare_HIP.hpp b/core/src/decl/Kokkos_Declare_HIP.hpp
index e115f7051f..cf405e57b8 100644
--- a/core/src/decl/Kokkos_Declare_HIP.hpp
+++ b/core/src/decl/Kokkos_Declare_HIP.hpp
@@ -25,9 +25,13 @@
 #include <HIP/Kokkos_HIP_Half_Conversion.hpp>
 #include <HIP/Kokkos_HIP_Instance.hpp>
 #include <HIP/Kokkos_HIP_MDRangePolicy.hpp>
-#include <HIP/Kokkos_HIP_Parallel_Range.hpp>
-#include <HIP/Kokkos_HIP_Parallel_MDRange.hpp>
-#include <HIP/Kokkos_HIP_Parallel_Team.hpp>
+#include <HIP/Kokkos_HIP_ParallelFor_Range.hpp>
+#include <HIP/Kokkos_HIP_ParallelFor_MDRange.hpp>
+#include <HIP/Kokkos_HIP_ParallelFor_Team.hpp>
+#include <HIP/Kokkos_HIP_ParallelReduce_Range.hpp>
+#include <HIP/Kokkos_HIP_ParallelReduce_MDRange.hpp>
+#include <HIP/Kokkos_HIP_ParallelReduce_Team.hpp>
+#include <HIP/Kokkos_HIP_ParallelScan_Range.hpp>
 #include <HIP/Kokkos_HIP_SharedAllocationRecord.hpp>
 #include <HIP/Kokkos_HIP_UniqueToken.hpp>
 #include <HIP/Kokkos_HIP_ZeroMemset.hpp>
diff --git a/core/src/decl/Kokkos_Declare_OPENMP.hpp b/core/src/decl/Kokkos_Declare_OPENMP.hpp
index ef9d27108e..52aefa25ad 100644
--- a/core/src/decl/Kokkos_Declare_OPENMP.hpp
+++ b/core/src/decl/Kokkos_Declare_OPENMP.hpp
@@ -21,6 +21,9 @@
 #include <OpenMP/Kokkos_OpenMP.hpp>
 #include <OpenMP/Kokkos_OpenMP_MDRangePolicy.hpp>
 #include <OpenMP/Kokkos_OpenMP_UniqueToken.hpp>
+#include <OpenMP/Kokkos_OpenMP_Parallel_For.hpp>
+#include <OpenMP/Kokkos_OpenMP_Parallel_Reduce.hpp>
+#include <OpenMP/Kokkos_OpenMP_Parallel_Scan.hpp>
 #endif
 
 #endif
diff --git a/core/src/decl/Kokkos_Declare_SYCL.hpp b/core/src/decl/Kokkos_Declare_SYCL.hpp
index a810bb0c76..d13c90825c 100644
--- a/core/src/decl/Kokkos_Declare_SYCL.hpp
+++ b/core/src/decl/Kokkos_Declare_SYCL.hpp
@@ -19,14 +19,20 @@
 
 #if defined(KOKKOS_ENABLE_SYCL)
 #include <SYCL/Kokkos_SYCL.hpp>
+#ifdef SYCL_EXT_ONEAPI_GRAPH
+#include <SYCL/Kokkos_SYCL_GraphNodeKernel.hpp>
+#endif
 #include <SYCL/Kokkos_SYCL_Half_Impl_Type.hpp>
 #include <SYCL/Kokkos_SYCL_Half_Conversion.hpp>
 #include <SYCL/Kokkos_SYCL_DeepCopy.hpp>
 #include <SYCL/Kokkos_SYCL_MDRangePolicy.hpp>
-#include <SYCL/Kokkos_SYCL_Parallel_Range.hpp>
-#include <SYCL/Kokkos_SYCL_Parallel_Reduce.hpp>
-#include <SYCL/Kokkos_SYCL_Parallel_Scan.hpp>
-#include <SYCL/Kokkos_SYCL_Parallel_Team.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelFor_Range.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelFor_MDRange.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelFor_Team.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelReduce_Range.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelReduce_MDRange.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelReduce_Team.hpp>
+#include <SYCL/Kokkos_SYCL_ParallelScan_Range.hpp>
 #include <SYCL/Kokkos_SYCL_UniqueToken.hpp>
 #include <SYCL/Kokkos_SYCL_ZeroMemset.hpp>
 #endif
diff --git a/core/src/decl/Kokkos_Declare_THREADS.hpp b/core/src/decl/Kokkos_Declare_THREADS.hpp
index 16f134b6f2..4d7caec6f5 100644
--- a/core/src/decl/Kokkos_Declare_THREADS.hpp
+++ b/core/src/decl/Kokkos_Declare_THREADS.hpp
@@ -19,7 +19,17 @@
 
 #if defined(KOKKOS_ENABLE_THREADS)
 #include <Threads/Kokkos_Threads.hpp>
+#include <Threads/Kokkos_Threads_Instance.hpp>
 #include <Threads/Kokkos_Threads_MDRangePolicy.hpp>
+#include <Threads/Kokkos_Threads_ParallelFor_Range.hpp>
+#include <Threads/Kokkos_Threads_ParallelFor_MDRange.hpp>
+#include <Threads/Kokkos_Threads_ParallelFor_Team.hpp>
+#include <Threads/Kokkos_Threads_ParallelReduce_Range.hpp>
+#include <Threads/Kokkos_Threads_ParallelReduce_MDRange.hpp>
+#include <Threads/Kokkos_Threads_ParallelReduce_Team.hpp>
+#include <Threads/Kokkos_Threads_ParallelScan_Range.hpp>
+#include <Threads/Kokkos_Threads_Team.hpp>
+#include <Threads/Kokkos_Threads_UniqueToken.hpp>
 #endif
 
 #endif
diff --git a/algorithms/src/std_algorithms/Kokkos_Swap.hpp b/core/src/impl/Kokkos_Abort.cpp
similarity index 54%
rename from algorithms/src/std_algorithms/Kokkos_Swap.hpp
rename to core/src/impl/Kokkos_Abort.cpp
index acd2a572c8..23f663e37f 100644
--- a/algorithms/src/std_algorithms/Kokkos_Swap.hpp
+++ b/core/src/impl/Kokkos_Abort.cpp
@@ -14,28 +14,31 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_STD_ALGORITHMS_SWAP_HPP
-#define KOKKOS_STD_ALGORITHMS_SWAP_HPP
+#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
+#define KOKKOS_IMPL_PUBLIC_INCLUDE
+#endif
 
-#include <Kokkos_Core.hpp>
+#include <cstdlib>
+#include <iostream>
+#include <Kokkos_Abort.hpp>
+#include <impl/Kokkos_Stacktrace.hpp>
 
 namespace Kokkos {
-namespace Experimental {
+namespace Impl {
+
+void host_abort(const char *const message) {
+  std::cerr << message;
 
-// swap
-template <class T>
-KOKKOS_INLINE_FUNCTION void swap(T& a, T& b) noexcept {
-  static_assert(
-      std::is_move_assignable<T>::value && std::is_move_constructible<T>::value,
-      "Kokkos::Experimental::swap arguments must be move assignable "
-      "and move constructible");
+#ifdef KOKKOS_IMPL_ENABLE_STACKTRACE
+  std::cerr << "\nBacktrace:\n";
+  save_stacktrace();
+  print_demangled_saved_stacktrace(std::cerr);
+#else
+  std::cerr << "\nTraceback functionality not available\n";
+#endif
 
-  T tmp = std::move(a);
-  a     = std::move(b);
-  b     = std::move(tmp);
+  ::abort();
 }
 
-}  // namespace Experimental
+}  // namespace Impl
 }  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_CheckedIntegerOps.hpp b/core/src/impl/Kokkos_CheckedIntegerOps.hpp
new file mode 100644
index 0000000000..69e616f6fb
--- /dev/null
+++ b/core/src/impl/Kokkos_CheckedIntegerOps.hpp
@@ -0,0 +1,66 @@
+//@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_CHECKED_INTEGER_OPS_HPP
+#define KOKKOS_CHECKED_INTEGER_OPS_HPP
+
+#include <type_traits>
+
+#include <impl/Kokkos_Error.hpp>
+
+namespace Kokkos {
+namespace Impl {
+
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_mul_overflow)
+#define KOKKOS_IMPL_USE_MUL_OVERFLOW_BUILTIN
+#endif
+#endif
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, bool> constexpr multiply_overflow(
+    T a, T b, T& res) {
+  static_assert(std::is_unsigned_v<T>,
+                "Operation not implemented for signed integers.");
+
+#if defined(KOKKOS_IMPL_USE_MUL_OVERFLOW_BUILTIN)
+  return __builtin_mul_overflow(a, b, &res);
+#else
+  auto product = a * b;
+  if ((a == 0) || (b == 0) || (a == product / b)) {
+    res = product;
+    return false;
+  } else {
+    return true;
+  }
+#endif
+}
+
+#undef KOKKOS_IMPL_USE_MUL_OVERFLOW_BUILTIN
+
+template <typename T>
+T multiply_overflow_abort(T a, T b) {
+  T result;
+  if (multiply_overflow(a, b, result))
+    Kokkos::abort("Arithmetic overflow detected.");
+
+  return result;
+}
+
+}  // namespace Impl
+}  // namespace Kokkos
+
+#endif  // KOKKOS_CHECKED_INTEGER_OPS_HPP
diff --git a/core/src/impl/Kokkos_Core.cpp b/core/src/impl/Kokkos_Core.cpp
index 87ad693091..6f862718bc 100644
--- a/core/src/impl/Kokkos_Core.cpp
+++ b/core/src/impl/Kokkos_Core.cpp
@@ -90,9 +90,8 @@ void combine(Kokkos::InitializationSettings& out,
   KOKKOS_IMPL_COMBINE_SETTING(num_threads);
   KOKKOS_IMPL_COMBINE_SETTING(map_device_id_by);
   KOKKOS_IMPL_COMBINE_SETTING(device_id);
-  KOKKOS_IMPL_COMBINE_SETTING(num_devices);
-  KOKKOS_IMPL_COMBINE_SETTING(skip_device);
   KOKKOS_IMPL_COMBINE_SETTING(disable_warnings);
+  KOKKOS_IMPL_COMBINE_SETTING(print_configuration);
   KOKKOS_IMPL_COMBINE_SETTING(tune_internals);
   KOKKOS_IMPL_COMBINE_SETTING(tools_help);
   KOKKOS_IMPL_COMBINE_SETTING(tools_libs);
@@ -131,11 +130,15 @@ void combine(Kokkos::Tools::InitArguments& out,
 
 int get_device_count() {
 #if defined(KOKKOS_ENABLE_CUDA)
-  return Kokkos::Cuda::detect_device_count();
+  int count;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&count));
+  return count;
 #elif defined(KOKKOS_ENABLE_HIP)
-  return Kokkos::HIP::detect_device_count();
+  int count;
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDeviceCount(&count));
+  return count;
 #elif defined(KOKKOS_ENABLE_SYCL)
-  return sycl::device::get_devices(sycl::info::device_type::gpu).size();
+  return Kokkos::Experimental::Impl::get_sycl_devices().size();
 #elif defined(KOKKOS_ENABLE_OPENACC)
   return acc_get_num_devices(
       Kokkos::Experimental::Impl::OpenACC_Traits::dev_type);
@@ -165,20 +168,43 @@ bool is_valid_map_device_id_by(std::string const& x) {
 
 }  // namespace
 
+std::vector<int> const& Kokkos::Impl::get_visible_devices() {
+  static auto devices = get_visible_devices(get_device_count());
+  return devices;
+}
+
 [[nodiscard]] int Kokkos::device_id() noexcept {
 #if defined(KOKKOS_ENABLE_CUDA)
-  return Cuda().cuda_device();
+  int device = Cuda().cuda_device();
 #elif defined(KOKKOS_ENABLE_HIP)
-  return HIP().hip_device();
+  int device = HIP().hip_device();
 #elif defined(KOKKOS_ENABLE_OPENACC)
-  return Experimental::OpenACC().acc_device_number();
+  int device = Experimental::OpenACC().acc_device_number();
 #elif defined(KOKKOS_ENABLE_OPENMPTARGET)
-  return omp_get_default_device();  // FIXME_OPENMPTARGET
+  int device = omp_get_default_device();  // FIXME_OPENMPTARGET
 #elif defined(KOKKOS_ENABLE_SYCL)
-  return Experimental::Impl::SYCLInternal::m_syclDev;
+  int device = Experimental::Impl::SYCLInternal::m_syclDev;
 #else
-  return -1;
+  int device = -1;
+  return device;
 #endif
+  auto const& visible_devices = Impl::get_visible_devices();
+  for (std::size_t i = 0; i < visible_devices.size(); ++i) {
+    if (visible_devices[i] == device) {
+      return i;
+    }
+  }
+  Kokkos::abort("Unexpected error: cannot determine device id");
+  return -1;
+}
+
+[[nodiscard]] int Kokkos::num_devices() noexcept {
+  if constexpr (std::is_same_v<DefaultExecutionSpace,
+                               DefaultHostExecutionSpace>) {
+    return -1;  // no GPU backend enabled
+  } else {
+    return Impl::get_visible_devices().size();
+  }
 }
 
 [[nodiscard]] int Kokkos::num_threads() noexcept {
@@ -313,8 +339,7 @@ int Kokkos::Impl::get_ctest_gpu(int local_rank) {
   return std::stoi(id.c_str());
 }
 
-std::vector<int> Kokkos::Impl::get_visible_devices(
-    Kokkos::InitializationSettings const& settings, int device_count) {
+std::vector<int> Kokkos::Impl::get_visible_devices(int device_count) {
   std::vector<int> visible_devices;
   char* env_visible_devices = std::getenv("KOKKOS_VISIBLE_DEVICES");
   if (env_visible_devices) {
@@ -341,30 +366,9 @@ std::vector<int> Kokkos::Impl::get_visible_devices(
       }
     }
   } else {
-    int num_devices =
-        settings.has_num_devices() ? settings.get_num_devices() : device_count;
-    if (num_devices > device_count) {
-      std::stringstream ss;
-      ss << "Error: Specified number of devices '" << num_devices
-         << "' exceeds the actual number of GPUs available for execution '"
-         << device_count << "'."
-         << " Raised by Kokkos::initialize().\n";
-      Kokkos::abort(ss.str().c_str());
-    }
-    for (int i = 0; i < num_devices; ++i) {
+    for (int i = 0; i < device_count; ++i) {
       visible_devices.push_back(i);
     }
-    if (settings.has_skip_device()) {
-      if (visible_devices.size() == 1 && settings.get_skip_device() == 0) {
-        Kokkos::abort(
-            "Error: skipping the only GPU available for execution.\n"
-            " Raised by Kokkos::initialize().\n");
-      }
-      visible_devices.erase(
-          std::remove(visible_devices.begin(), visible_devices.end(),
-                      settings.get_skip_device()),
-          visible_devices.end());
-    }
   }
   if (visible_devices.empty()) {
     Kokkos::abort(
@@ -374,10 +378,10 @@ std::vector<int> Kokkos::Impl::get_visible_devices(
   return visible_devices;
 }
 
-int Kokkos::Impl::get_gpu(const InitializationSettings& settings) {
-  std::vector<int> visible_devices =
-      get_visible_devices(settings, get_device_count());
-  int const num_devices = visible_devices.size();
+std::optional<int> Kokkos::Impl::get_gpu(
+    const InitializationSettings& settings) {
+  std::vector<int> visible_devices = get_visible_devices(get_device_count());
+  int const num_devices            = visible_devices.size();
   // device_id is provided
   if (settings.has_device_id()) {
     int const id = settings.get_device_id();
@@ -423,14 +427,15 @@ int Kokkos::Impl::get_gpu(const InitializationSettings& settings) {
 
   int const mpi_local_rank = mpi_local_rank_on_node();
 
-  // use first GPU available for execution if unable to detect local MPI rank
+  // if unable to detect local MPI rank return nullopt to delegate device
+  // selection to the backend
   if (mpi_local_rank < 0) {
     if (settings.has_map_device_id_by()) {
       std::cerr << "Warning: unable to detect local MPI rank."
                 << " Falling back to the first GPU available for execution."
                 << " Raised by Kokkos::initialize()." << std::endl;
     }
-    return visible_devices[0];
+    return std::nullopt;
   }
 
   // use device assigned by CTest when resource allocation is activated
@@ -445,13 +450,6 @@ int Kokkos::Impl::get_gpu(const InitializationSettings& settings) {
 namespace {
 
 void initialize_backends(const Kokkos::InitializationSettings& settings) {
-// This is an experimental setting
-// For KNL in Flat mode this variable should be set, so that
-// memkind allocates high bandwidth memory correctly.
-#ifdef KOKKOS_ENABLE_HBWSPACE
-  setenv("MEMKIND_HBW_NODES", "1", 0);
-#endif
-
   Kokkos::Impl::ExecSpaceManager::get_instance().initialize_spaces(settings);
 }
 
@@ -571,19 +569,6 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
                                  "no");
 #endif
 
-#ifdef KOKKOS_ENABLE_HBWSPACE
-  declare_configuration_metadata("memory", "KOKKOS_ENABLE_HBWSPACE", "yes");
-#else
-  declare_configuration_metadata("memory", "KOKKOS_ENABLE_HBWSPACE", "no");
-#endif
-#ifdef KOKKOS_ENABLE_INTEL_MM_ALLOC
-  declare_configuration_metadata("memory", "KOKKOS_ENABLE_INTEL_MM_ALLOC",
-                                 "yes");
-#else
-  declare_configuration_metadata("memory", "KOKKOS_ENABLE_INTEL_MM_ALLOC",
-                                 "no");
-#endif
-
 #ifdef KOKKOS_ENABLE_ASM
   declare_configuration_metadata("options", "KOKKOS_ENABLE_ASM", "yes");
 #else
@@ -604,6 +589,11 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
 #else
   declare_configuration_metadata("options", "KOKKOS_ENABLE_CXX23", "no");
 #endif
+#ifdef KOKKOS_ENABLE_CXX26
+  declare_configuration_metadata("options", "KOKKOS_ENABLE_CXX26", "yes");
+#else
+  declare_configuration_metadata("options", "KOKKOS_ENABLE_CXX26", "no");
+#endif
 #ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
   declare_configuration_metadata("options", "KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK",
                                  "yes");
@@ -616,16 +606,12 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
 #else
   declare_configuration_metadata("options", "KOKKOS_ENABLE_HWLOC", "no");
 #endif
-#ifdef KOKKOS_ENABLE_LIBRT
-  declare_configuration_metadata("options", "KOKKOS_ENABLE_LIBRT", "yes");
-#else
-  declare_configuration_metadata("options", "KOKKOS_ENABLE_LIBRT", "no");
-#endif
 #ifdef KOKKOS_ENABLE_LIBDL
   declare_configuration_metadata("options", "KOKKOS_ENABLE_LIBDL", "yes");
 #else
   declare_configuration_metadata("options", "KOKKOS_ENABLE_LIBDL", "no");
 #endif
+
   declare_configuration_metadata("architecture", "Default Device",
                                  typeid(Kokkos::DefaultExecutionSpace).name());
 
@@ -645,8 +631,6 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
                                  "ARMV8_THUNDERX2");
 #elif defined(KOKKOS_ARCH_BDW)
   declare_configuration_metadata("architecture", "CPU architecture", "BDW");
-#elif defined(KOKKOS_ARCH_BGQ)
-  declare_configuration_metadata("architecture", "CPU architecture", "BGQ");
 #elif defined(KOKKOS_ARCH_HSW)
   declare_configuration_metadata("architecture", "CPU architecture", "HSW");
 #elif defined(KOKKOS_ARCH_ICL)
@@ -659,8 +643,6 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
   declare_configuration_metadata("architecture", "CPU architecture", "KNL");
 #elif defined(KOKKOS_ARCH_NATIVE)
   declare_configuration_metadata("architecture", "CPU architecture", "NATIVE");
-#elif defined(KOKKOS_ARCH_POWER7)
-  declare_configuration_metadata("architecture", "CPU architecture", "POWER7");
 #elif defined(KOKKOS_ARCH_POWER8)
   declare_configuration_metadata("architecture", "CPU architecture", "POWER8");
 #elif defined(KOKKOS_ARCH_POWER9)
@@ -673,8 +655,6 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
   declare_configuration_metadata("architecture", "CPU architecture", "SNB");
 #elif defined(KOKKOS_ARCH_SPR)
   declare_configuration_metadata("architecture", "CPU architecture", "SPR");
-#elif defined(KOKKOS_ARCH_WSM)
-  declare_configuration_metadata("architecture", "CPU architecture", "WSM");
 #elif defined(KOKKOS_ARCH_AMD_ZEN)
   declare_configuration_metadata("architecture", "CPU architecture", "AMD_ZEN");
 #elif defined(KOKKOS_ARCH_AMD_ZEN2)
@@ -683,6 +663,9 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
 #elif defined(KOKKOS_ARCH_AMD_ZEN3)
   declare_configuration_metadata("architecture", "CPU architecture",
                                  "AMD_ZEN3");
+#elif defined(KOKKOS_ARCH_RISCV_SG2042)
+  declare_configuration_metadata("architecture", "CPU architecture",
+                                 "SG2042 (RISC-V)")
 #else
   declare_configuration_metadata("architecture", "CPU architecture", "none");
 #endif
@@ -752,22 +735,23 @@ void pre_initialize_internal(const Kokkos::InitializationSettings& settings) {
 #elif defined(KOKKOS_ARCH_ADA89)
   declare_configuration_metadata("architecture", "GPU architecture", "ADA89");
 #elif defined(KOKKOS_ARCH_HOPPER90)
+      declare_configuration_metadata("architecture", "GPU architecture",
+                                     "HOPPER90");
+#elif defined(KOKKOS_ARCH_AMD_GFX906)
+  declare_configuration_metadata("architecture", "GPU architecture",
+                                 "AMD_GFX906");
+#elif defined(KOKKOS_ARCH_AMD_GFX908)
+  declare_configuration_metadata("architecture", "GPU architecture",
+                                 "AMD_GFX908");
+#elif defined(KOKKOS_ARCH_AMD_GFX90A)
   declare_configuration_metadata("architecture", "GPU architecture",
-                                 "HOPPER90");
-#elif defined(KOKKOS_ARCH_VEGA900)
-  declare_configuration_metadata("architecture", "GPU architecture", "VEGA900");
-#elif defined(KOKKOS_ARCH_VEGA906)
-  declare_configuration_metadata("architecture", "GPU architecture", "VEGA906");
-#elif defined(KOKKOS_ARCH_VEGA908)
-  declare_configuration_metadata("architecture", "GPU architecture", "VEGA908");
-#elif defined(KOKKOS_ARCH_VEGA90A)
-  declare_configuration_metadata("architecture", "GPU architecture", "VEGA90A");
-#elif defined(KOKKOS_ARCH_NAVI1030)
+                                 "AMD_GFX90A");
+#elif defined(KOKKOS_ARCH_AMD_GFX1030)
   declare_configuration_metadata("architecture", "GPU architecture",
-                                 "NAVI1030");
-#elif defined(KOKKOS_ARCH_NAVI1100)
+                                 "AMD_GFX1030");
+#elif defined(KOKKOS_ARCH_AMD_GFX1100)
   declare_configuration_metadata("architecture", "GPU architecture",
-                                 "NAVI1100");
+                                 "AMD_GFX1100");
 
 #else
   declare_configuration_metadata("architecture", "GPU architecture", "none");
@@ -803,34 +787,18 @@ void initialize_internal(const Kokkos::InitializationSettings& settings) {
   post_initialize_internal(settings);
 }
 
-void pre_finalize_internal() {
-  typename decltype(finalize_hooks)::size_type numSuccessfulCalls = 0;
+// declared noexcept such that std::terminate is called if any of the registered
+// function throws
+void call_registered_finalize_hook_functions() noexcept {
   while (!finalize_hooks.empty()) {
-    auto f = finalize_hooks.top();
-    try {
-      f();
-    } catch (...) {
-      std::cerr << "Kokkos::finalize: A finalize hook (set via "
-                   "Kokkos::push_finalize_hook) threw an exception that it did "
-                   "not catch."
-                   "  Per std::atexit rules, this results in std::terminate.  "
-                   "This is "
-                   "finalize hook number "
-                << numSuccessfulCalls
-                << " (1-based indexing) "
-                   "out of "
-                << finalize_hooks.size()
-                << " to call.  Remember that "
-                   "Kokkos::finalize calls finalize hooks in reverse order "
-                   "from how they "
-                   "were pushed."
-                << std::endl;
-      std::terminate();
-    }
+    auto const& func = finalize_hooks.top();
+    func();
     finalize_hooks.pop();
-    ++numSuccessfulCalls;
   }
+}
 
+void pre_finalize_internal() {
+  call_registered_finalize_hook_functions();
   Kokkos::Profiling::finalize();
 }
 
@@ -910,36 +878,18 @@ void Kokkos::Impl::parse_command_line_arguments(
 
   int num_threads;
   int device_id;
-  int num_devices;  // deprecated
-  int skip_device;  // deprecated
   std::string map_device_id_by;
   bool disable_warnings;
   bool print_configuration;
   bool tune_internals;
 
-  auto get_flag = [](std::string s) -> std::string {
-    return s.erase(s.find('='));
-  };
-
   bool help_flag = false;
 
   int iarg = 0;
   while (iarg < argc) {
     bool remove_flag = false;
 
-    if (check_arg(argv[iarg], "--kokkos-numa") ||
-        check_arg(argv[iarg], "--numa")) {
-      warn_deprecated_command_line_argument(get_flag(argv[iarg]));
-      // remove flag if prefixed with '--kokkos-'
-      remove_flag = std::string(argv[iarg]).find("--kokkos-") == 0;
-    } else if (check_arg_int(argv[iarg], "--kokkos-num-threads", num_threads) ||
-               check_arg_int(argv[iarg], "--num-threads", num_threads) ||
-               check_arg_int(argv[iarg], "--kokkos-threads", num_threads) ||
-               check_arg_int(argv[iarg], "--threads", num_threads)) {
-      if (get_flag(argv[iarg]) != "--kokkos-num-threads") {
-        warn_deprecated_command_line_argument(get_flag(argv[iarg]),
-                                              "--kokkos-num-threads");
-      }
+    if (check_arg_int(argv[iarg], "--kokkos-num-threads", num_threads)) {
       if (!is_valid_num_threads(num_threads)) {
         std::stringstream ss;
         ss << "Error: command line argument '" << argv[iarg] << "' is invalid."
@@ -948,15 +898,8 @@ void Kokkos::Impl::parse_command_line_arguments(
         Kokkos::abort(ss.str().c_str());
       }
       settings.set_num_threads(num_threads);
-      remove_flag = std::string(argv[iarg]).find("--kokkos-") == 0;
-    } else if (check_arg_int(argv[iarg], "--kokkos-device-id", device_id) ||
-               check_arg_int(argv[iarg], "--device-id", device_id) ||
-               check_arg_int(argv[iarg], "--kokkos-device", device_id) ||
-               check_arg_int(argv[iarg], "--device", device_id)) {
-      if (get_flag(argv[iarg]) != "--kokkos-device-id") {
-        warn_deprecated_command_line_argument(get_flag(argv[iarg]),
-                                              "--kokkos-device-id");
-      }
+      remove_flag = true;
+    } else if (check_arg_int(argv[iarg], "--kokkos-device-id", device_id)) {
       if (!is_valid_device_id(device_id)) {
         std::stringstream ss;
         ss << "Error: command line argument '" << argv[iarg] << "' is invalid."
@@ -965,70 +908,7 @@ void Kokkos::Impl::parse_command_line_arguments(
         Kokkos::abort(ss.str().c_str());
       }
       settings.set_device_id(device_id);
-      remove_flag = std::string(argv[iarg]).find("--kokkos-") == 0;
-    } else if (check_arg(argv[iarg], "--kokkos-num-devices") ||
-               check_arg(argv[iarg], "--num-devices") ||
-               check_arg(argv[iarg], "--kokkos-ndevices") ||
-               check_arg(argv[iarg], "--ndevices")) {
-      if (check_arg(argv[iarg], "--num-devices")) {
-        warn_deprecated_command_line_argument("--num-devices",
-                                              "--kokkos-num-devices");
-      }
-      if (check_arg(argv[iarg], "--ndevices")) {
-        warn_deprecated_command_line_argument("--ndevices",
-                                              "--kokkos-num-devices");
-      }
-      if (check_arg(argv[iarg], "--kokkos-ndevices")) {
-        warn_deprecated_command_line_argument("--kokkos-ndevices",
-                                              "--kokkos-num-devices");
-      }
-      warn_deprecated_command_line_argument(
-          "--kokkos-num-devices", "--kokkos-map-device-id-by=mpi_rank");
-      // Find the number of device (expecting --device=XX)
-      if (!((strncmp(argv[iarg], "--kokkos-num-devices=", 21) == 0) ||
-            (strncmp(argv[iarg], "--num-devices=", 14) == 0) ||
-            (strncmp(argv[iarg], "--kokkos-ndevices=", 18) == 0) ||
-            (strncmp(argv[iarg], "--ndevices=", 11) == 0)))
-        throw_runtime_exception(
-            "Error: expecting an '=INT[,INT]' after command line argument "
-            "'--kokkos-num-devices'."
-            " Raised by Kokkos::initialize().");
-
-      char* num1      = strchr(argv[iarg], '=') + 1;
-      char* num2      = strpbrk(num1, ",");
-      int num1_len    = num2 == nullptr ? strlen(num1) : num2 - num1;
-      char* num1_only = new char[num1_len + 1];
-      strncpy(num1_only, num1, num1_len);
-      num1_only[num1_len] = '\0';
-
-      if (!is_unsigned_int(num1_only) || (strlen(num1_only) == 0)) {
-        throw_runtime_exception(
-            "Error: expecting an integer number after command line argument "
-            "'--kokkos-num-devices'."
-            " Raised by Kokkos::initialize().");
-      }
-      if (check_arg(argv[iarg], "--kokkos-num-devices") ||
-          check_arg(argv[iarg], "--kokkos-ndevices")) {
-        num_devices = std::stoi(num1_only);
-        settings.set_num_devices(num_devices);
-        settings.set_map_device_id_by("mpi_rank");
-      }
-      delete[] num1_only;
-
-      if (num2 != nullptr) {
-        if ((!is_unsigned_int(num2 + 1)) || (strlen(num2) == 1))
-          throw_runtime_exception(
-              "Error: expecting an integer number after command line argument "
-              "'--kokkos-num-devices=XX,'."
-              " Raised by Kokkos::initialize().");
-
-        if (check_arg(argv[iarg], "--kokkos-num-devices") ||
-            check_arg(argv[iarg], "--kokkos-ndevices")) {
-          skip_device = std::stoi(num2 + 1);
-          settings.set_skip_device(skip_device);
-        }
-      }
-      remove_flag = std::string(argv[iarg]).find("--kokkos-") == 0;
+      remove_flag = true;
     } else if (check_arg_bool(argv[iarg], "--kokkos-disable-warnings",
                               disable_warnings)) {
       settings.set_disable_warnings(disable_warnings);
@@ -1097,9 +977,6 @@ void Kokkos::Impl::parse_environment_variables(
   }
   combine(settings, tools_init_arguments);
 
-  if (std::getenv("KOKKOS_NUMA")) {
-    warn_deprecated_environment_variable("KOKKOS_NUMA");
-  }
   int num_threads;
   if (check_env_int("KOKKOS_NUM_THREADS", num_threads)) {
     if (!is_valid_num_threads(num_threads)) {
@@ -1124,34 +1001,6 @@ void Kokkos::Impl::parse_environment_variables(
     }
     settings.set_device_id(device_id);
   }
-  int num_devices;
-  int rand_devices;
-  bool has_num_devices  = check_env_int("KOKKOS_NUM_DEVICES", num_devices);
-  bool has_rand_devices = check_env_int("KOKKOS_RAND_DEVICES", rand_devices);
-  if (has_rand_devices && has_num_devices) {
-    Impl::throw_runtime_exception(
-        "Error: cannot specify both KOKKOS_NUM_DEVICES and "
-        "KOKKOS_RAND_DEVICES."
-        " Raised by Kokkos::initialize().");
-  }
-  if (has_num_devices) {
-    warn_deprecated_environment_variable("KOKKOS_NUM_DEVICES",
-                                         "KOKKOS_MAP_DEVICE_ID_BY=mpi_rank");
-    settings.set_map_device_id_by("mpi_rank");
-    settings.set_num_devices(num_devices);
-  }
-  if (has_rand_devices) {
-    warn_deprecated_environment_variable("KOKKOS_RAND_DEVICES",
-                                         "KOKKOS_MAP_DEVICE_ID_BY=random");
-    settings.set_map_device_id_by("random");
-    settings.set_num_devices(rand_devices);
-  }
-  if (has_num_devices || has_rand_devices) {
-    int skip_device;
-    if (check_env_int("KOKKOS_SKIP_DEVICE", skip_device)) {
-      settings.set_skip_device(skip_device);
-    }
-  }
   bool disable_warnings;
   if (check_env_bool("KOKKOS_DISABLE_WARNINGS", disable_warnings)) {
     settings.set_disable_warnings(disable_warnings);
diff --git a/core/src/impl/Kokkos_Default_Graph_Impl.hpp b/core/src/impl/Kokkos_Default_Graph_Impl.hpp
index 0b11b251bc..05d4854919 100644
--- a/core/src/impl/Kokkos_Default_Graph_Impl.hpp
+++ b/core/src/impl/Kokkos_Default_Graph_Impl.hpp
@@ -56,7 +56,7 @@ struct GraphImpl : private ExecutionSpaceInstanceStorage<ExecutionSpace> {
   //----------------------------------------------------------------------------
   // <editor-fold desc="Constructors, destructor, and assignment"> {{{2
 
-  // Not moveable or copyable; it spends its whole live as a shared_ptr in the
+  // Not movable or copyable; it spends its whole live as a shared_ptr in the
   // Graph object
   GraphImpl()                 = default;
   GraphImpl(GraphImpl const&) = delete;
@@ -82,10 +82,7 @@ struct GraphImpl : private ExecutionSpaceInstanceStorage<ExecutionSpace> {
   template <class NodeImpl>
   //  requires NodeImplPtr is a shared_ptr to specialization of GraphNodeImpl
   void add_node(std::shared_ptr<NodeImpl> const& arg_node_ptr) {
-    static_assert(
-        NodeImpl::kernel_type::Policy::is_graph_kernel::value,
-        "Something has gone horribly wrong, but it's too complicated to "
-        "explain here.  Buy Daisy a coffee and she'll explain it to you.");
+    static_assert(NodeImpl::kernel_type::Policy::is_graph_kernel::value);
     // Since this is always called before any calls to add_predecessor involving
     // it, we can treat this node as a sink until we discover otherwise.
     arg_node_ptr->node_details_t::set_kernel(arg_node_ptr->get_kernel());
@@ -161,8 +158,6 @@ struct GraphImpl : private ExecutionSpaceInstanceStorage<ExecutionSpace> {
 
 }  // end namespace Kokkos
 
-#include <OpenMP/Kokkos_OpenMP_Parallel.hpp>
-
 #include <impl/Kokkos_Default_GraphNodeKernel.hpp>
 #include <impl/Kokkos_Default_GraphNode_Impl.hpp>
 
diff --git a/core/src/Kokkos_Atomics_Desul_Config.hpp b/core/src/impl/Kokkos_DesulAtomicsConfig.hpp
similarity index 72%
rename from core/src/Kokkos_Atomics_Desul_Config.hpp
rename to core/src/impl/Kokkos_DesulAtomicsConfig.hpp
index 4cf170f5f1..02ab127d5c 100644
--- a/core/src/Kokkos_Atomics_Desul_Config.hpp
+++ b/core/src/impl/Kokkos_DesulAtomicsConfig.hpp
@@ -13,15 +13,9 @@
 // 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_ATOMICS_DESUL_CONFIG_HPP
-#define KOKKOS_ATOMICS_DESUL_CONFIG_HPP
 
-#include <Kokkos_Macros.hpp>
+#ifndef KOKKOS_DESUL_ATOMICS_CONFIG_HPP
+#define KOKKOS_DESUL_ATOMICS_CONFIG_HPP
 
 #if defined(KOKKOS_ARCH_KEPLER) || defined(KOKKOS_ARCH_MAXWELL)
 #define DESUL_CUDA_ARCH_IS_PRE_PASCAL
@@ -32,4 +26,4 @@ static_assert(false,
 #define DESUL_CUDA_ARCH_IS_PRE_VOLTA
 #endif
 
-#endif  // KOKKOS_ATOMICS_DESUL_CONFIG_HPP
+#endif
diff --git a/core/src/impl/Kokkos_DeviceManagement.hpp b/core/src/impl/Kokkos_DeviceManagement.hpp
index bd89c8b19c..70dca5d8fa 100644
--- a/core/src/impl/Kokkos_DeviceManagement.hpp
+++ b/core/src/impl/Kokkos_DeviceManagement.hpp
@@ -17,17 +17,17 @@
 #ifndef KOKKOS_DEVICE_MANAGEMENT_HPP
 #define KOKKOS_DEVICE_MANAGEMENT_HPP
 
+#include <optional>
 #include <vector>
 
 namespace Kokkos {
 class InitializationSettings;
 namespace Impl {
-int get_gpu(const Kokkos::InitializationSettings& settings);
+std::optional<int> get_gpu(const Kokkos::InitializationSettings& settings);
 // This declaration is provided for testing purposes only
 int get_ctest_gpu(int local_rank);
-// ditto
-std::vector<int> get_visible_devices(
-    Kokkos::InitializationSettings const& settings, int device_count);
+std::vector<int> get_visible_devices(int device_count);  // test-only
+std::vector<int> const& get_visible_devices();           // use this instead
 }  // namespace Impl
 }  // namespace Kokkos
 
diff --git a/core/src/impl/Kokkos_Error.cpp b/core/src/impl/Kokkos_Error.cpp
index 5b4e1a7770..0dcd5d523d 100644
--- a/core/src/impl/Kokkos_Error.cpp
+++ b/core/src/impl/Kokkos_Error.cpp
@@ -18,145 +18,54 @@
 #define KOKKOS_IMPL_PUBLIC_INCLUDE
 #endif
 
-#include <cstring>
-#include <cstdlib>
-
 #include <iostream>
-#include <sstream>
 #include <iomanip>
+#include <sstream>
 #include <stdexcept>
+#include <Kokkos_Core.hpp>  // show_warnings
 #include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_Stacktrace.hpp>
-#include <Cuda/Kokkos_Cuda_Error.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
 
-namespace Kokkos {
-namespace Impl {
-void traceback_callstack(std::ostream &msg) {
-#ifdef KOKKOS_IMPL_ENABLE_STACKTRACE
-  msg << "\nBacktrace:\n";
-  save_stacktrace();
-  print_demangled_saved_stacktrace(msg);
-#else
-  msg << "\nTraceback functionality not available\n";
-#endif
+void Kokkos::Impl::throw_runtime_exception(const std::string &msg) {
+  throw std::runtime_error(msg);
 }
 
-void throw_runtime_exception(const std::string &msg) {
-  throw std::runtime_error(msg);
+void Kokkos::Impl::throw_bad_alloc(std::string_view memory_space_name,
+                                   std::size_t size, std::string_view label) {
+  std::stringstream ss;
+  ss << "Kokkos ERROR: " << memory_space_name
+     << " memory space failed to allocate " << human_memory_size(size)
+     << " (label=\"" << label << "\").";
+  throw std::runtime_error(ss.str());
 }
 
-void host_abort(const char *const message) {
-  std::cerr << message;
-  traceback_callstack(std::cerr);
-  ::abort();
+void Kokkos::Impl::log_warning(const std::string &msg) {
+  if (show_warnings()) {
+    std::cerr << msg << std::flush;
+  }
 }
 
-std::string human_memory_size(size_t arg_bytes) {
+std::string Kokkos::Impl::human_memory_size(size_t arg_bytes) {
   double bytes   = arg_bytes;
   const double K = 1024;
   const double M = K * 1024;
   const double G = M * 1024;
+  const double T = G * 1024;
 
   std::ostringstream out;
   if (bytes < K) {
     out << std::setprecision(4) << bytes << " B";
   } else if (bytes < M) {
     bytes /= K;
-    out << std::setprecision(4) << bytes << " K";
+    out << std::setprecision(4) << bytes << " KiB";
   } else if (bytes < G) {
     bytes /= M;
-    out << std::setprecision(4) << bytes << " M";
-  } else {
+    out << std::setprecision(4) << bytes << " MiB";
+  } else if (bytes < T) {
     bytes /= G;
-    out << std::setprecision(4) << bytes << " G";
-  }
-  return out.str();
-}
-
-}  // namespace Impl
-
-void Experimental::RawMemoryAllocationFailure::print_error_message(
-    std::ostream &o) const {
-  o << "Allocation of size " << Impl::human_memory_size(m_attempted_size);
-  o << " failed";
-  switch (m_failure_mode) {
-    case FailureMode::OutOfMemoryError:
-      o << ", likely due to insufficient memory.";
-      break;
-    case FailureMode::AllocationNotAligned:
-      o << " because the allocation was improperly aligned.";
-      break;
-    case FailureMode::InvalidAllocationSize:
-      o << " because the requested allocation size is not a valid size for the"
-           " requested allocation mechanism (it's probably too large).";
-      break;
-    // TODO move this to the subclass for Cuda-related things
-    case FailureMode::MaximumCudaUVMAllocationsExceeded:
-      o << " because the maximum Cuda UVM allocations was exceeded.";
-      break;
-    case FailureMode::Unknown: o << " because of an unknown error."; break;
-  }
-  o << "  (The allocation mechanism was ";
-  switch (m_mechanism) {
-    case AllocationMechanism::StdMalloc: o << "standard malloc()."; break;
-    case AllocationMechanism::PosixMemAlign: o << "posix_memalign()."; break;
-    case AllocationMechanism::PosixMMap: o << "POSIX mmap()."; break;
-    case AllocationMechanism::IntelMMAlloc:
-      o << "the Intel _mm_malloc() intrinsic.";
-      break;
-    case AllocationMechanism::CudaMalloc: o << "cudaMalloc()."; break;
-    case AllocationMechanism::CudaMallocManaged:
-      o << "cudaMallocManaged().";
-      break;
-    case AllocationMechanism::CudaHostAlloc: o << "cudaHostAlloc()."; break;
-    case AllocationMechanism::HIPMalloc: o << "hipMalloc()."; break;
-    case AllocationMechanism::HIPHostMalloc: o << "hipHostMalloc()."; break;
-    case AllocationMechanism::HIPMallocManaged:
-      o << "hipMallocManaged().";
-      break;
-    case AllocationMechanism::SYCLMallocDevice:
-      o << "sycl::malloc_device().";
-      break;
-    case AllocationMechanism::SYCLMallocShared:
-      o << "sycl::malloc_shared().";
-      break;
-    case AllocationMechanism::SYCLMallocHost:
-      o << "sycl::malloc_host().";
-      break;
+    out << std::setprecision(4) << bytes << " GiB";
+  } else {
+    bytes /= T;
+    out << std::setprecision(4) << bytes << " TiB";
   }
-  append_additional_error_information(o);
-  o << ")" << std::endl;
-}
-
-std::string Experimental::RawMemoryAllocationFailure::get_error_message()
-    const {
-  std::ostringstream out;
-  print_error_message(out);
   return out.str();
 }
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-#ifdef KOKKOS_ENABLE_CUDA
-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 \""
-      << cudaGetErrorName(m_error_code) << "\".";
-  }
-}
-
-}  // end namespace Experimental
-#endif
-
-}  // namespace Kokkos
diff --git a/core/src/impl/Kokkos_Error.hpp b/core/src/impl/Kokkos_Error.hpp
index e2054d4ce0..9a80c7b31b 100644
--- a/core/src/impl/Kokkos_Error.hpp
+++ b/core/src/impl/Kokkos_Error.hpp
@@ -18,247 +18,19 @@
 #define KOKKOS_IMPL_ERROR_HPP
 
 #include <string>
-#include <iosfwd>
 #include <Kokkos_Macros.hpp>
-#ifdef KOKKOS_ENABLE_CUDA
-#include <Cuda/Kokkos_Cuda_abort.hpp>
-#endif
-#ifdef KOKKOS_ENABLE_HIP
-#include <HIP/Kokkos_HIP_Abort.hpp>
-#endif
-#ifdef KOKKOS_ENABLE_SYCL
-#include <SYCL/Kokkos_SYCL_Abort.hpp>
-#endif
-
-namespace Kokkos {
-namespace Impl {
-
-[[noreturn]] void host_abort(const char *const);
-
-#if defined(KOKKOS_ENABLE_CUDA) && defined(__CUDA_ARCH__)
-
-#if defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK)
-// required to workaround failures in random number generator unit tests with
-// pre-volta architectures
-#define KOKKOS_IMPL_ABORT_NORETURN
-#else
-// cuda_abort aborts when building for other platforms than macOS
-#define KOKKOS_IMPL_ABORT_NORETURN [[noreturn]]
-#endif
-
-#elif defined(KOKKOS_COMPILER_NVHPC)
-
-#define KOKKOS_IMPL_ABORT_NORETURN
-
-#elif defined(KOKKOS_ENABLE_HIP) && defined(__HIP_DEVICE_COMPILE__)
-// HIP aborts
-#define KOKKOS_IMPL_ABORT_NORETURN [[noreturn]]
-#elif defined(KOKKOS_ENABLE_SYCL) && defined(__SYCL_DEVICE_ONLY__)
-// FIXME_SYCL SYCL doesn't abort
-#define KOKKOS_IMPL_ABORT_NORETURN
-#elif !defined(KOKKOS_ENABLE_OPENMPTARGET) && !defined(KOKKOS_ENABLE_OPENACC)
-// Host aborts
-#define KOKKOS_IMPL_ABORT_NORETURN [[noreturn]]
-#else
-// Everything else does not abort
-#define KOKKOS_IMPL_ABORT_NORETURN
-#endif
-
-// FIXME_SYCL
-// Accomodate host pass for device functions that are not [[noreturn]]
-#if defined(KOKKOS_ENABLE_SYCL) || \
-    (defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK))
-#define KOKKOS_IMPL_ABORT_NORETURN_DEVICE
-#else
-#define KOKKOS_IMPL_ABORT_NORETURN_DEVICE KOKKOS_IMPL_ABORT_NORETURN
-#endif
+#include <Kokkos_Abort.hpp>
+#include <Kokkos_Assert.hpp>
 
-#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) ||          \
-    defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENMPTARGET) || \
-    defined(KOKKOS_ENABLE_OPENACC)
-KOKKOS_IMPL_ABORT_NORETURN_DEVICE inline KOKKOS_IMPL_DEVICE_FUNCTION void
-device_abort(const char *const msg) {
-#if defined(KOKKOS_ENABLE_CUDA)
-  ::Kokkos::Impl::cuda_abort(msg);
-#elif defined(KOKKOS_ENABLE_HIP)
-  ::Kokkos::Impl::hip_abort(msg);
-#elif defined(KOKKOS_ENABLE_SYCL)
-  ::Kokkos::Impl::sycl_abort(msg);
-#elif defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_OPENACC)
-  printf("%s", msg);  // FIXME_OPENMPTARGET FIXME_OPENACC
-#else
-#error faulty logic
-#endif
-}
-#endif
+namespace Kokkos::Impl {
 
 [[noreturn]] void throw_runtime_exception(const std::string &msg);
+[[noreturn]] void throw_bad_alloc(std::string_view memory_space_name,
+                                  std::size_t size, std::string_view label);
+void log_warning(const std::string &msg);
 
-void traceback_callstack(std::ostream &);
-
-std::string human_memory_size(size_t arg_bytes);
-
-}  // namespace Impl
-
-namespace Experimental {
-
-class RawMemoryAllocationFailure : public std::bad_alloc {
- public:
-  enum class FailureMode {
-    OutOfMemoryError,
-    AllocationNotAligned,
-    InvalidAllocationSize,
-    MaximumCudaUVMAllocationsExceeded,
-    Unknown
-  };
-  enum class AllocationMechanism {
-    StdMalloc,
-    PosixMemAlign,
-    PosixMMap,
-    IntelMMAlloc,
-    CudaMalloc,
-    CudaMallocManaged,
-    CudaHostAlloc,
-    HIPMalloc,
-    HIPHostMalloc,
-    HIPMallocManaged,
-    SYCLMallocDevice,
-    SYCLMallocShared,
-    SYCLMallocHost
-  };
-
- private:
-  size_t m_attempted_size;
-  size_t m_attempted_alignment;
-  FailureMode m_failure_mode;
-  AllocationMechanism m_mechanism;
-
- public:
-  RawMemoryAllocationFailure(
-      size_t arg_attempted_size, size_t arg_attempted_alignment,
-      FailureMode arg_failure_mode = FailureMode::OutOfMemoryError,
-      AllocationMechanism arg_mechanism =
-          AllocationMechanism::StdMalloc) noexcept
-      : m_attempted_size(arg_attempted_size),
-        m_attempted_alignment(arg_attempted_alignment),
-        m_failure_mode(arg_failure_mode),
-        m_mechanism(arg_mechanism) {}
+std::string human_memory_size(size_t bytes);
 
-  RawMemoryAllocationFailure() noexcept = delete;
+}  // namespace Kokkos::Impl
 
-  RawMemoryAllocationFailure(RawMemoryAllocationFailure const &) noexcept =
-      default;
-  RawMemoryAllocationFailure(RawMemoryAllocationFailure &&) noexcept = default;
-
-  RawMemoryAllocationFailure &operator             =(
-      RawMemoryAllocationFailure const &) noexcept = default;
-  RawMemoryAllocationFailure &operator             =(
-      RawMemoryAllocationFailure &&) noexcept = default;
-
-  ~RawMemoryAllocationFailure() noexcept override = default;
-
-  [[nodiscard]] const char *what() const noexcept override {
-    if (m_failure_mode == FailureMode::OutOfMemoryError) {
-      return "Memory allocation error: out of memory";
-    } else if (m_failure_mode == FailureMode::AllocationNotAligned) {
-      return "Memory allocation error: allocation result was under-aligned";
-    }
-
-    return nullptr;  // unreachable
-  }
-
-  [[nodiscard]] size_t attempted_size() const noexcept {
-    return m_attempted_size;
-  }
-
-  [[nodiscard]] size_t attempted_alignment() const noexcept {
-    return m_attempted_alignment;
-  }
-
-  [[nodiscard]] AllocationMechanism allocation_mechanism() const noexcept {
-    return m_mechanism;
-  }
-
-  [[nodiscard]] FailureMode failure_mode() const noexcept {
-    return m_failure_mode;
-  }
-
-  void print_error_message(std::ostream &o) const;
-  [[nodiscard]] std::string get_error_message() const;
-
-  virtual void append_additional_error_information(std::ostream &) const {}
-};
-
-}  // end namespace Experimental
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-KOKKOS_IMPL_ABORT_NORETURN KOKKOS_INLINE_FUNCTION void abort(
-    const char *const message) {
-  KOKKOS_IF_ON_HOST(::Kokkos::Impl::host_abort(message);)
-  KOKKOS_IF_ON_DEVICE(::Kokkos::Impl::device_abort(message);)
-}
-
-#undef KOKKOS_IMPL_ABORT_NORETURN
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#if !defined(NDEBUG) || defined(KOKKOS_ENFORCE_CONTRACTS) || \
-    defined(KOKKOS_ENABLE_DEBUG)
-#define KOKKOS_EXPECTS(...)                                                    \
-  {                                                                            \
-    if (!bool(__VA_ARGS__)) {                                                  \
-      ::Kokkos::abort(                                                         \
-          "Kokkos contract violation:\n  "                                     \
-          "  Expected precondition `" #__VA_ARGS__                             \
-          "` evaluated false.\n"                                               \
-          "Error at " KOKKOS_IMPL_TOSTRING(__FILE__) ":" KOKKOS_IMPL_TOSTRING( \
-              __LINE__) " \n");                                                \
-    }                                                                          \
-  }
-#define KOKKOS_ENSURES(...)                                                    \
-  {                                                                            \
-    if (!bool(__VA_ARGS__)) {                                                  \
-      ::Kokkos::abort(                                                         \
-          "Kokkos contract violation:\n  "                                     \
-          "  Ensured postcondition `" #__VA_ARGS__                             \
-          "` evaluated false.\n"                                               \
-          "Error at " KOKKOS_IMPL_TOSTRING(__FILE__) ":" KOKKOS_IMPL_TOSTRING( \
-              __LINE__) " \n");                                                \
-    }                                                                          \
-  }
-// some projects already define this for themselves, so don't mess
-// them up
-#ifndef KOKKOS_ASSERT
-#define KOKKOS_ASSERT(...)                                                     \
-  {                                                                            \
-    if (!bool(__VA_ARGS__)) {                                                  \
-      ::Kokkos::abort(                                                         \
-          "Kokkos contract violation:\n  "                                     \
-          "  Asserted condition `" #__VA_ARGS__                                \
-          "` evaluated false.\n"                                               \
-          "Error at " KOKKOS_IMPL_TOSTRING(__FILE__) ":" KOKKOS_IMPL_TOSTRING( \
-              __LINE__) " \n");                                                \
-    }                                                                          \
-  }
-#endif  // ifndef KOKKOS_ASSERT
-#else   // not debug mode
-#define KOKKOS_EXPECTS(...)
-#define KOKKOS_ENSURES(...)
-#ifndef KOKKOS_ASSERT
-#define KOKKOS_ASSERT(...)
-#endif  // ifndef KOKKOS_ASSERT
-#endif  // end debug mode ifdefs
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_IMPL_ERROR_HPP */
+#endif
diff --git a/core/src/impl/Kokkos_FunctorAnalysis.hpp b/core/src/impl/Kokkos_FunctorAnalysis.hpp
index c635c8bf76..e844a5295e 100644
--- a/core/src/impl/Kokkos_FunctorAnalysis.hpp
+++ b/core/src/impl/Kokkos_FunctorAnalysis.hpp
@@ -631,11 +631,9 @@ struct FunctorAnalysis {
                         detected_volatile_join_no_tag<F>::value)>>
       : public has_volatile_join_no_tag_function<F> {
     enum : bool { value = true };
-#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_3
     static_assert(Impl::dependent_false_v<F>,
                   "Reducer with a join() operator taking "
                   "volatile-qualified parameters is no longer supported");
-#endif
   };
 
   template <class F = Functor, typename = void>
@@ -654,11 +652,9 @@ struct FunctorAnalysis {
                                          detected_volatile_join_tag<F>::value)>>
       : public has_volatile_join_tag_function<F> {
     enum : bool { value = true };
-#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_3
     static_assert(Impl::dependent_false_v<F>,
                   "Reducer with a join() operator taking "
                   "volatile-qualified parameters is no longer supported");
-#endif
   };
 
   //----------------------------------------
diff --git a/core/src/impl/Kokkos_HBWSpace.cpp b/core/src/impl/Kokkos_HBWSpace.cpp
deleted file mode 100644
index cd640b88cb..0000000000
--- a/core/src/impl/Kokkos_HBWSpace.cpp
+++ /dev/null
@@ -1,313 +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 <cstddef>
-#include <cstdlib>
-#include <cstdint>
-#include <cstring>
-
-#include <iostream>
-#include <sstream>
-#include <cstring>
-#include <algorithm>
-
-#include <Kokkos_HBWSpace.hpp>
-#include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
-#include <Kokkos_Atomic.hpp>
-#ifdef KOKKOS_ENABLE_HBWSPACE
-#include <memkind.h>
-#endif
-
-#include <impl/Kokkos_Tools.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-#ifdef KOKKOS_ENABLE_HBWSPACE
-#define MEMKIND_TYPE MEMKIND_HBW  // hbw_get_kind(HBW_PAGESIZE_4KB)
-
-/*--------------------------------------------------------------------------*/
-
-namespace Kokkos {
-namespace Experimental {
-
-/* Default allocation mechanism */
-HBWSpace::HBWSpace() : m_alloc_mech(HBWSpace::STD_MALLOC) {
-  printf("Init\n");
-  setenv("MEMKIND_HBW_NODES", "1", 0);
-}
-
-/* Default allocation mechanism */
-HBWSpace::HBWSpace(const HBWSpace::AllocationMechanism &arg_alloc_mech)
-    : m_alloc_mech(HBWSpace::STD_MALLOC) {
-  printf("Init2\n");
-  setenv("MEMKIND_HBW_NODES", "1", 0);
-  if (arg_alloc_mech == STD_MALLOC) {
-    m_alloc_mech = HBWSpace::STD_MALLOC;
-  }
-}
-
-void *HBWSpace::allocate(const size_t arg_alloc_size) const {
-  return allocate("[unlabeled]", arg_alloc_size);
-}
-void *HBWSpace::allocate(const char *arg_label, const size_t arg_alloc_size,
-                         const size_t arg_logical_size) const {
-  return impl_allocate(arg_label, arg_alloc_size, arg_logical_size);
-}
-void *HBWSpace::impl_allocate(
-    const char *arg_label, const size_t arg_alloc_size,
-    const size_t arg_logical_size,
-    const Kokkos::Tools::SpaceHandle arg_handle) const {
-  static_assert(sizeof(void *) == sizeof(uintptr_t),
-                "Error sizeof(void*) != sizeof(uintptr_t)");
-
-  static_assert(
-      Kokkos::Impl::power_of_two<Kokkos::Impl::MEMORY_ALIGNMENT>::value,
-      "Memory alignment must be power of two");
-
-  constexpr uintptr_t alignment      = Kokkos::Impl::MEMORY_ALIGNMENT;
-  constexpr uintptr_t alignment_mask = alignment - 1;
-
-  void *ptr = nullptr;
-
-  if (arg_alloc_size) {
-    if (m_alloc_mech == STD_MALLOC) {
-      // Over-allocate to and round up to guarantee proper alignment.
-      size_t size_padded = arg_alloc_size + sizeof(void *) + alignment;
-
-      void *alloc_ptr = memkind_malloc(MEMKIND_TYPE, size_padded);
-
-      if (alloc_ptr) {
-        uintptr_t address = reinterpret_cast<uintptr_t>(alloc_ptr);
-
-        // offset enough to record the alloc_ptr
-        address += sizeof(void *);
-        uintptr_t rem    = address % alignment;
-        uintptr_t offset = rem ? (alignment - rem) : 0u;
-        address += offset;
-        ptr = reinterpret_cast<void *>(address);
-        // record the alloc'd pointer
-        address -= sizeof(void *);
-        *reinterpret_cast<void **>(address) = alloc_ptr;
-      }
-    }
-  }
-
-  if ((ptr == nullptr) || (reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0)) ||
-      (reinterpret_cast<uintptr_t>(ptr) & alignment_mask)) {
-    std::ostringstream msg;
-    msg << "Kokkos::Experimental::HBWSpace::allocate[ ";
-    switch (m_alloc_mech) {
-      case STD_MALLOC: msg << "STD_MALLOC"; break;
-      case POSIX_MEMALIGN: msg << "POSIX_MEMALIGN"; break;
-      case POSIX_MMAP: msg << "POSIX_MMAP"; break;
-      case INTEL_MM_ALLOC: msg << "INTEL_MM_ALLOC"; break;
-    }
-    msg << " ]( " << arg_alloc_size << " ) FAILED";
-    if (ptr == nullptr) {
-      msg << " nullptr";
-    } else {
-      msg << " NOT ALIGNED " << ptr;
-    }
-
-    std::cerr << msg.str() << std::endl;
-    std::cerr.flush();
-
-    Kokkos::Impl::throw_runtime_exception(msg.str());
-  }
-  if (Kokkos::Profiling::profileLibraryLoaded()) {
-    const size_t reported_size =
-        (arg_logical_size > 0) ? arg_logical_size : arg_alloc_size;
-    Kokkos::Profiling::allocateData(arg_handle, arg_label, ptr, reported_size);
-  }
-
-  return ptr;
-}
-
-void HBWSpace::deallocate(void *const arg_alloc_ptr,
-                          const size_t arg_alloc_size) const {
-  deallocate("[unlabeled]", arg_alloc_ptr, arg_alloc_size);
-}
-void HBWSpace::deallocate(const char *arg_label, void *const arg_alloc_ptr,
-                          const size_t arg_alloc_size,
-                          const size_t arg_logical_size) const {
-  impl_deallocate(arg_label, arg_alloc_ptr, arg_alloc_size, arg_logical_size);
-}
-void HBWSpace::impl_deallocate(
-    const char *arg_label, void *const arg_alloc_ptr,
-    const size_t arg_alloc_size, const size_t arg_logical_size,
-    const Kokkos::Tools::SpaceHandle arg_handle) const {
-  if (arg_alloc_ptr) {
-    if (Kokkos::Profiling::profileLibraryLoaded()) {
-      const size_t reported_size =
-          (arg_logical_size > 0) ? arg_logical_size : arg_alloc_size;
-      Kokkos::Profiling::deallocateData(arg_handle, arg_label, arg_alloc_ptr,
-                                        reported_size);
-    }
-
-    if (m_alloc_mech == STD_MALLOC) {
-      void *alloc_ptr = *(reinterpret_cast<void **>(arg_alloc_ptr) - 1);
-      memkind_free(MEMKIND_TYPE, alloc_ptr);
-    }
-  }
-}
-
-}  // namespace Experimental
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-#ifdef KOKKOS_ENABLE_DEBUG
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::s_root_record;
-#endif
-
-void SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::deallocate(
-    SharedAllocationRecord<void, void> *arg_rec) {
-  delete static_cast<SharedAllocationRecord *>(arg_rec);
-}
-
-SharedAllocationRecord<Kokkos::Experimental::HBWSpace,
-                       void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     SharedAllocationRecord<void, void>::m_alloc_size,
-                     (SharedAllocationRecord<void, void>::m_alloc_size -
-                      sizeof(SharedAllocationHeader)));
-}
-
-SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
-    SharedAllocationRecord(
-        const Kokkos::Experimental::HBWSpace &arg_space,
-        const std::string &arg_label, const size_t arg_alloc_size,
-        const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : SharedAllocationRecord<void, void>(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::Experimental::HBWSpace,
-                                  void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  // Fill in the Header information
-  RecordBase::m_alloc_ptr->m_record =
-      static_cast<SharedAllocationRecord<void, void> *>(this);
-
-  strncpy(RecordBase::m_alloc_ptr->m_label, arg_label.c_str(),
-          SharedAllocationHeader::maximum_label_length - 1);
-  // Set last element zero, in case c_str is too long
-  RecordBase::m_alloc_ptr
-      ->m_label[SharedAllocationHeader::maximum_label_length - 1] = '\0';
-}
-
-//----------------------------------------------------------------------------
-
-void *
-SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::allocate_tracked(
-    const Kokkos::Experimental::HBWSpace &arg_space,
-    const std::string &arg_alloc_label, const size_t arg_alloc_size) {
-  if (!arg_alloc_size) return nullptr;
-
-  SharedAllocationRecord *const r =
-      allocate(arg_space, arg_alloc_label, arg_alloc_size);
-
-  RecordBase::increment(r);
-
-  return r->data();
-}
-
-void SharedAllocationRecord<Kokkos::Experimental::HBWSpace,
-                            void>::deallocate_tracked(void *const
-                                                          arg_alloc_ptr) {
-  if (arg_alloc_ptr != nullptr) {
-    SharedAllocationRecord *const r = get_record(arg_alloc_ptr);
-
-    RecordBase::decrement(r);
-  }
-}
-
-void *SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
-    reallocate_tracked(void *const arg_alloc_ptr, const size_t arg_alloc_size) {
-  SharedAllocationRecord *const r_old = get_record(arg_alloc_ptr);
-  SharedAllocationRecord *const r_new =
-      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
-
-  Kokkos::Impl::DeepCopy<Kokkos::Experimental::HBWSpace,
-                         Kokkos::Experimental::HBWSpace>(
-      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
-  Kokkos::fence(
-      "SharedAllocationRecord<Kokkos::Experimental::HBWSpace, "
-      "void>::reallocate_tracked(): fence after copying data");
-
-  RecordBase::increment(r_new);
-  RecordBase::decrement(r_old);
-
-  return r_new->data();
-}
-
-SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>
-    *SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::get_record(
-        void *alloc_ptr) {
-  using Header = SharedAllocationHeader;
-  using RecordHost =
-      SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>;
-
-  SharedAllocationHeader const *const head =
-      alloc_ptr ? Header::get_header(alloc_ptr) : nullptr;
-  RecordHost *const record =
-      head ? static_cast<RecordHost *>(head->m_record) : nullptr;
-
-  if (!alloc_ptr || record->m_alloc_ptr != head) {
-    Kokkos::Impl::throw_runtime_exception(std::string(
-        "Kokkos::Impl::SharedAllocationRecord< Kokkos::Experimental::HBWSpace "
-        ", void >::get_record ERROR"));
-  }
-
-  return record;
-}
-
-// Iterate records to print orphaned memory ...
-void SharedAllocationRecord<Kokkos::Experimental::HBWSpace, void>::
-    print_records(std::ostream &s, const Kokkos::Experimental::HBWSpace &space,
-                  bool detail) {
-#ifdef KOKKOS_ENABLE_DEBUG
-  SharedAllocationRecord<void, void>::print_host_accessible_records(
-      s, "HBWSpace", &s_root_record, detail);
-#else
-  throw_runtime_exception(
-      "SharedAllocationRecord<HBWSpace>::print_records"
-      " only works with KOKKOS_ENABLE_DEBUG enabled");
-#endif
-}
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp b/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp
index 7bf315de17..bcce013b00 100644
--- a/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp
+++ b/core/src/impl/Kokkos_Half_FloatingPointWrapper.hpp
@@ -18,11 +18,24 @@
 #define KOKKOS_HALF_FLOATING_POINT_WRAPPER_HPP_
 
 #include <Kokkos_Macros.hpp>
+#include <Kokkos_BitManipulation.hpp>  // bit_cast
 
 #include <type_traits>
 #include <iosfwd>  // istream & ostream for extraction and insertion ops
 #include <string>
 
+namespace Kokkos::Experimental::Impl {
+/// @brief templated struct for determining if half_t is an alias to float.
+/// @tparam T The type to specialize on.
+template <class T>
+struct is_float16 : std::false_type {};
+
+/// @brief templated struct for determining if bhalf_t is an alias to float.
+/// @tparam T The type to specialize on.
+template <class T>
+struct is_bfloat16 : std::false_type {};
+}  // namespace Kokkos::Experimental::Impl
+
 #ifdef KOKKOS_IMPL_HALF_TYPE_DEFINED
 
 // KOKKOS_HALF_IS_FULL_TYPE_ON_ARCH: A macro to select which
@@ -44,6 +57,10 @@ class floating_point_wrapper;
 // Declare half_t (binary16)
 using half_t = Kokkos::Experimental::Impl::floating_point_wrapper<
     Kokkos::Impl::half_impl_t ::type>;
+namespace Impl {
+template <>
+struct is_float16<half_t> : std::true_type {};
+}  // namespace Impl
 KOKKOS_INLINE_FUNCTION
 half_t cast_to_half(float val);
 KOKKOS_INLINE_FUNCTION
@@ -110,7 +127,10 @@ KOKKOS_INLINE_FUNCTION
 #ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
 using bhalf_t = Kokkos::Experimental::Impl::floating_point_wrapper<
     Kokkos::Impl ::bhalf_impl_t ::type>;
-
+namespace Impl {
+template <>
+struct is_bfloat16<bhalf_t> : std::true_type {};
+}  // namespace Impl
 KOKKOS_INLINE_FUNCTION
 bhalf_t cast_to_bhalf(float val);
 KOKKOS_INLINE_FUNCTION
@@ -176,12 +196,12 @@ KOKKOS_INLINE_FUNCTION
 
 template <class T>
 static KOKKOS_INLINE_FUNCTION Kokkos::Experimental::half_t cast_to_wrapper(
-    T x, const volatile Kokkos::Impl::half_impl_t::type&);
+    T x, const 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&);
+    T x, const Kokkos::Impl::bhalf_impl_t::type&);
 #endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
 
 template <class T>
@@ -196,20 +216,73 @@ cast_from_wrapper(const Kokkos::Experimental::bhalf_t& x);
 /************************** END forward declarations **************************/
 
 namespace Impl {
+
+template <typename FloatType>
+struct BitComparisonWrapper {
+  std::uint16_t value;
+
+  template <typename Number>
+  KOKKOS_FUNCTION friend bool operator==(BitComparisonWrapper a, Number b) {
+    return static_cast<FloatType>(a) == b;
+  }
+
+  template <typename Number>
+  KOKKOS_FUNCTION friend bool operator!=(BitComparisonWrapper a, Number b) {
+    return static_cast<FloatType>(a) != b;
+  }
+
+  template <typename Number>
+  KOKKOS_FUNCTION friend bool operator<(BitComparisonWrapper a, Number b) {
+    return static_cast<FloatType>(a) < b;
+  }
+
+  template <typename Number>
+  KOKKOS_FUNCTION friend bool operator<=(BitComparisonWrapper a, Number b) {
+    return static_cast<FloatType>(a) <= b;
+  }
+
+  template <typename Number>
+  KOKKOS_FUNCTION friend bool operator>(BitComparisonWrapper a, Number b) {
+    return static_cast<FloatType>(a) > b;
+  }
+
+  template <typename Number>
+  KOKKOS_FUNCTION friend bool operator>=(BitComparisonWrapper a, Number b) {
+    return static_cast<FloatType>(a) >= b;
+  }
+};
+
+template <typename FloatType>
+inline constexpr BitComparisonWrapper<FloatType> exponent_mask;
+template <typename FloatType>
+inline constexpr BitComparisonWrapper<FloatType> fraction_mask;
+
+#ifdef KOKKOS_IMPL_HALF_TYPE_DEFINED
+template <>
+inline constexpr BitComparisonWrapper<Kokkos::Experimental::half_t>
+    exponent_mask<Kokkos::Experimental::half_t>{0b0'11111'0000000000};
+template <>
+inline constexpr BitComparisonWrapper<Kokkos::Experimental::half_t>
+    fraction_mask<Kokkos::Experimental::half_t>{0b0'00000'1111111111};
+#endif
+
+#ifdef KOKKOS_IMPL_BHALF_TYPE_DEFINED
+template <>
+inline constexpr BitComparisonWrapper<Kokkos::Experimental::bhalf_t>
+    exponent_mask<Kokkos::Experimental::bhalf_t>{0b0'11111111'0000000};
+template <>
+inline constexpr BitComparisonWrapper<Kokkos::Experimental::bhalf_t>
+    fraction_mask<Kokkos::Experimental::bhalf_t>{0b0'00000000'1111111};
+#endif
+
 template <class FloatType>
 class alignas(FloatType) floating_point_wrapper {
  public:
-  using impl_type = FloatType;
+  using impl_type           = FloatType;
+  using bit_comparison_type = BitComparisonWrapper<floating_point_wrapper>;
 
  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
@@ -238,16 +311,9 @@ class alignas(FloatType) floating_point_wrapper {
       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
+  KOKKOS_FUNCTION
+  floating_point_wrapper(bit_comparison_type rhs) {
+    val = Kokkos::bit_cast<impl_type>(rhs);
   }
 
   // Don't support implicit conversion back to impl_type.
@@ -407,15 +473,6 @@ class alignas(FloatType) floating_point_wrapper {
     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) {
@@ -430,15 +487,6 @@ class alignas(FloatType) floating_point_wrapper {
     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<
@@ -475,15 +523,6 @@ class alignas(FloatType) floating_point_wrapper {
     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<
@@ -520,15 +559,6 @@ class alignas(FloatType) floating_point_wrapper {
     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<
@@ -565,15 +595,6 @@ class alignas(FloatType) floating_point_wrapper {
     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<
@@ -799,46 +820,76 @@ class alignas(FloatType) floating_point_wrapper {
 #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;
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator<(floating_point_wrapper lhs, T rhs) {
+    return static_cast<float>(lhs) < 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;
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator<(T lhs, floating_point_wrapper rhs) {
+    return lhs < static_cast<float>(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;
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator>(floating_point_wrapper lhs, T rhs) {
+    return static_cast<float>(lhs) > 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;
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator>(T lhs, floating_point_wrapper rhs) {
+    return lhs > static_cast<float>(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;
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator<=(floating_point_wrapper lhs, T rhs) {
+    return static_cast<float>(lhs) <= 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;
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator<=(T lhs, floating_point_wrapper rhs) {
+    return lhs <= static_cast<float>(rhs);
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator>=(floating_point_wrapper lhs, T rhs) {
+    return static_cast<float>(lhs) >= rhs;
+  }
+
+  template <class T>
+  KOKKOS_FUNCTION friend std::enable_if_t<std::is_convertible_v<T, float> &&
+                                              (std::is_same_v<T, float> ||
+                                               std::is_same_v<T, double>),
+                                          bool>
+  operator>=(T lhs, floating_point_wrapper rhs) {
+    return lhs >= static_cast<float>(rhs);
   }
 
   // Insertion and extraction operators
@@ -861,14 +912,14 @@ class alignas(FloatType) floating_point_wrapper {
 // 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&) {
+    T x, const 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&) {
+    T x, const Kokkos::Impl::bhalf_impl_t::type&) {
   return Kokkos::Experimental::cast_to_bhalf(x);
 }
 #endif  // KOKKOS_IMPL_BHALF_TYPE_DEFINED
diff --git a/core/src/impl/Kokkos_Half_MathematicalFunctions.hpp b/core/src/impl/Kokkos_Half_MathematicalFunctions.hpp
new file mode 100644
index 0000000000..e6a5cadc67
--- /dev/null
+++ b/core/src/impl/Kokkos_Half_MathematicalFunctions.hpp
@@ -0,0 +1,259 @@
+//@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_MATHEMATICAL_FUNCTIONS_HPP_
+#define KOKKOS_HALF_MATHEMATICAL_FUNCTIONS_HPP_
+
+#include <Kokkos_MathematicalFunctions.hpp>  // For the float overloads
+#include <Kokkos_BitManipulation.hpp>        // bit_cast
+
+// clang-format off
+namespace Kokkos {
+// BEGIN macro definitions
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+  #define KOKKOS_IMPL_MATH_H_FUNC_WRAPPER(MACRO, FUNC) \
+    MACRO(FUNC, Kokkos::Experimental::half_t)
+#else
+  #define KOKKOS_IMPL_MATH_H_FUNC_WRAPPER(MACRO, FUNC)
+#endif
+
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+  #define KOKKOS_IMPL_MATH_B_FUNC_WRAPPER(MACRO, FUNC) \
+    MACRO(FUNC, Kokkos::Experimental::bhalf_t)
+#else
+  #define KOKKOS_IMPL_MATH_B_FUNC_WRAPPER(MACRO, FUNC)
+#endif
+
+#define KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(MACRO, FUNC) \
+  KOKKOS_IMPL_MATH_H_FUNC_WRAPPER(MACRO, FUNC)          \
+  KOKKOS_IMPL_MATH_B_FUNC_WRAPPER(MACRO, FUNC)
+
+
+#define KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE(FUNC, HALF_TYPE)      \
+  KOKKOS_INLINE_FUNCTION HALF_TYPE FUNC(HALF_TYPE x) {                  \
+    return static_cast<HALF_TYPE>(Kokkos::FUNC(static_cast<float>(x))); \
+  }
+
+#define KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, MIXED_TYPE) \
+  KOKKOS_INLINE_FUNCTION double FUNC(HALF_TYPE x, MIXED_TYPE y) {  \
+    return Kokkos::FUNC(static_cast<double>(x), static_cast<double>(y)); \
+  } \
+  KOKKOS_INLINE_FUNCTION double FUNC(MIXED_TYPE x, HALF_TYPE y) {  \
+    return Kokkos::FUNC(static_cast<double>(x), static_cast<double>(y)); \
+  }
+
+#define KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF(FUNC, HALF_TYPE)       \
+  KOKKOS_INLINE_FUNCTION HALF_TYPE FUNC(HALF_TYPE x, HALF_TYPE y) {  \
+    return static_cast<HALF_TYPE>(                                   \
+        Kokkos::FUNC(static_cast<float>(x), static_cast<float>(y))); \
+  } \
+  KOKKOS_INLINE_FUNCTION float FUNC(float x, HALF_TYPE y) {  \
+    return Kokkos::FUNC(static_cast<float>(x), static_cast<float>(y)); \
+  } \
+  KOKKOS_INLINE_FUNCTION float FUNC(HALF_TYPE x, float y) {  \
+    return Kokkos::FUNC(static_cast<float>(x), static_cast<float>(y)); \
+  } \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, double) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, short) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, unsigned short) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, int) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, unsigned int) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, long) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, unsigned long) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, long long) \
+  KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF_MIXED(FUNC, HALF_TYPE, unsigned long long)
+
+
+#define KOKKOS_IMPL_MATH_UNARY_PREDICATE_HALF(FUNC, HALF_TYPE) \
+  KOKKOS_INLINE_FUNCTION bool FUNC(HALF_TYPE x) {              \
+    return Kokkos::FUNC(static_cast<float>(x));                \
+  }
+
+// END macros definitions
+
+
+// Basic operations
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, abs)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, fabs)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, fmod)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, remainder)
+// remquo
+// fma
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, fmax)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, fmin)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, fdim)
+// nanq
+// Exponential functions
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, exp)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, exp2)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, expm1)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, log)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, log10)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, log2)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, log1p)
+// Power functions
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, pow)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, sqrt)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, cbrt)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, hypot)
+// Trigonometric functions
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, sin)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, cos)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, tan)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, asin)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, acos)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, atan)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, atan2)
+// Hyperbolic functions
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, sinh)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, cosh)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, tanh)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, asinh)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, acosh)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, atanh)
+// Error and gamma functions
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, erf)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, erfc)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, tgamma)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, lgamma)
+// Nearest integer floating point functions
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, ceil)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, floor)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, trunc)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, round)
+// lround
+// llround
+// FIXME_SYCL not available as of current SYCL 2020 specification (revision 4)
+#ifndef KOKKOS_ENABLE_SYCL // FIXME_SYCL
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, nearbyint)
+#endif
+// rint
+// lrint
+// llrint
+// Floating point manipulation functions
+// frexp
+// ldexp
+// modf
+// scalbn
+// scalbln
+// ilog
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE, logb)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, nextafter)
+// nexttoward
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF, copysign)
+// Classification and comparison functions
+// fpclassify
+
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+KOKKOS_INLINE_FUNCTION bool isfinite(Kokkos::Experimental::half_t x) {
+  using bit_type = Kokkos::Experimental::half_t::bit_comparison_type;
+  constexpr bit_type exponent_mask = Kokkos::Experimental::Impl::exponent_mask<Kokkos::Experimental::half_t>;
+  const bit_type bit_pattern_x = bit_cast<bit_type>(
+      static_cast<Kokkos::Experimental::half_t::impl_type>(x));
+  return (bit_pattern_x.value & exponent_mask.value) != exponent_mask.value;
+}
+#endif
+
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+KOKKOS_INLINE_FUNCTION bool isfinite(Kokkos::Experimental::bhalf_t x) {
+  using bit_type = Kokkos::Experimental::bhalf_t::bit_comparison_type;
+  constexpr bit_type exponent_mask = Kokkos::Experimental::Impl::exponent_mask<Kokkos::Experimental::bhalf_t>;
+  const bit_type bit_pattern_x = bit_cast<bit_type>(
+      static_cast<Kokkos::Experimental::bhalf_t::impl_type>(x));
+  return (bit_pattern_x.value & exponent_mask.value) != exponent_mask.value;
+}
+#endif
+
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+KOKKOS_INLINE_FUNCTION bool isinf(Kokkos::Experimental::half_t x) {
+  using bit_type = Kokkos::Experimental::half_t::bit_comparison_type;
+  constexpr bit_type exponent_mask = Kokkos::Experimental::Impl::exponent_mask<Kokkos::Experimental::half_t>;
+  constexpr bit_type fraction_mask = Kokkos::Experimental::Impl::fraction_mask<Kokkos::Experimental::half_t>;
+  const bit_type bit_pattern_x = bit_cast<bit_type>(
+      static_cast<Kokkos::Experimental::half_t::impl_type>(x));
+  return (
+      ((bit_pattern_x.value & exponent_mask.value) == exponent_mask.value) &&
+      ((bit_pattern_x.value & fraction_mask.value) == 0));
+}
+#endif
+
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+KOKKOS_INLINE_FUNCTION bool isinf(Kokkos::Experimental::bhalf_t x) {
+  using bit_type = Kokkos::Experimental::bhalf_t::bit_comparison_type;
+  constexpr bit_type exponent_mask = Kokkos::Experimental::Impl::exponent_mask<Kokkos::Experimental::bhalf_t>;
+  constexpr bit_type fraction_mask = Kokkos::Experimental::Impl::fraction_mask<Kokkos::Experimental::bhalf_t>;
+  const bit_type bit_pattern_x = bit_cast<bit_type>(
+      static_cast<Kokkos::Experimental::bhalf_t::impl_type>(x));
+  return (
+      ((bit_pattern_x.value & exponent_mask.value) == exponent_mask.value) &&
+      ((bit_pattern_x.value & fraction_mask.value) == 0));
+}
+#endif
+
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+KOKKOS_INLINE_FUNCTION bool isnan(Kokkos::Experimental::half_t x) {
+  using bit_type = Kokkos::Experimental::half_t::bit_comparison_type;
+  constexpr bit_type exponent_mask = Kokkos::Experimental::Impl::exponent_mask<Kokkos::Experimental::half_t>;
+  constexpr bit_type fraction_mask = Kokkos::Experimental::Impl::fraction_mask<Kokkos::Experimental::half_t>;
+  const bit_type bit_pattern_x = bit_cast<bit_type>(
+      static_cast<Kokkos::Experimental::half_t::impl_type>(x));
+  return (
+      ((bit_pattern_x.value & exponent_mask.value) == exponent_mask.value) &&
+      ((bit_pattern_x.value & fraction_mask.value) != 0));
+}
+#endif
+
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+KOKKOS_INLINE_FUNCTION bool isnan(Kokkos::Experimental::bhalf_t x) {
+  using bit_type = Kokkos::Experimental::bhalf_t::bit_comparison_type;
+  constexpr bit_type exponent_mask = Kokkos::Experimental::Impl::exponent_mask<Kokkos::Experimental::bhalf_t>;
+  constexpr bit_type fraction_mask = Kokkos::Experimental::Impl::fraction_mask<Kokkos::Experimental::bhalf_t>;
+  const bit_type bit_pattern_x = bit_cast<bit_type>(
+      static_cast<Kokkos::Experimental::bhalf_t::impl_type>(x));
+  return (
+      ((bit_pattern_x.value & exponent_mask.value) == exponent_mask.value) &&
+      ((bit_pattern_x.value & fraction_mask.value) != 0));
+}
+#endif
+// isnormal
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_UNARY_PREDICATE_HALF, signbit)
+// isgreater
+// isgreaterequal
+// isless
+// islessequal
+// islessgreater
+// isunordered
+// Complex number functions
+#define KOKKOS_IMPL_MATH_COMPLEX_REAL_HALF(FUNC, HALF_TYPE) \
+  KOKKOS_INLINE_FUNCTION HALF_TYPE FUNC(HALF_TYPE x) { return x; }
+
+#define KOKKOS_IMPL_MATH_COMPLEX_IMAG_HALF(FUNC, HALF_TYPE) \
+  KOKKOS_INLINE_FUNCTION HALF_TYPE FUNC(HALF_TYPE) { return 0; }
+
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_COMPLEX_REAL_HALF, real)
+KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER(KOKKOS_IMPL_MATH_COMPLEX_IMAG_HALF, imag)
+
+#undef KOKKOS_IMPL_MATH_COMPLEX_REAL_HALF
+#undef KOKKOS_IMPL_MATH_COMPLEX_IMAG_HALF
+#undef KOKKOS_IMPL_MATH_UNARY_PREDICATE_HALF
+#undef KOKKOS_IMPL_MATH_BINARY_FUNCTION_HALF
+#undef KOKKOS_IMPL_MATH_UNARY_FUNCTION_HALF_TYPE
+#undef KOKKOS_IMPL_MATH_HALF_FUNC_WRAPPER
+#undef KOKKOS_IMPL_MATH_B_FUNC_WRAPPER
+#undef KOKKOS_IMPL_MATH_H_FUNC_WRAPPER
+}  // namespace Kokkos
+// clang-format on
+#endif  // KOKKOS_HALF_MATHEMATICAL_FUNCTIONS_HPP_
diff --git a/core/src/impl/Kokkos_Half_NumericTraits.hpp b/core/src/impl/Kokkos_Half_NumericTraits.hpp
index b5cbf22194..4779c2a6e1 100644
--- a/core/src/impl/Kokkos_Half_NumericTraits.hpp
+++ b/core/src/impl/Kokkos_Half_NumericTraits.hpp
@@ -70,7 +70,7 @@
 ///
 template <>
 struct Kokkos::Experimental::Impl::infinity_helper<Kokkos::Experimental::half_t> {
-  static constexpr int value = 0x7C00;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'11111'0000000000};
 };
 
 /// \brief: Minimum normalized number
@@ -87,7 +87,7 @@ struct Kokkos::Experimental::Impl::infinity_helper<Kokkos::Experimental::half_t>
 template <>
 struct Kokkos::Experimental::Impl::finite_min_helper<
     Kokkos::Experimental::half_t> {
-  static constexpr float value = -65504.0F;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b1'11110'1111111111}; // -65504
 };
 
 /// \brief: Maximum normalized number
@@ -104,7 +104,7 @@ struct Kokkos::Experimental::Impl::finite_min_helper<
 template <>
 struct Kokkos::Experimental::Impl::finite_max_helper<
     Kokkos::Experimental::half_t> {
-  static constexpr float value = 65504.0F;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'11110'1111111111}; // +65504
 };
 
 /// \brief: This is the difference between 1 and the smallest floating point
@@ -123,7 +123,7 @@ struct Kokkos::Experimental::Impl::finite_max_helper<
 template <>
 struct Kokkos::Experimental::Impl::epsilon_helper<
     Kokkos::Experimental::half_t> {
-  static constexpr float value = 0.0009765625F;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'00101'0000000000}; // 0.0009765625
 };
 
 /// @brief: The largest possible rounding error in ULPs
@@ -134,7 +134,7 @@ struct Kokkos::Experimental::Impl::epsilon_helper<
 template <>
 struct Kokkos::Experimental::Impl::round_error_helper<
     Kokkos::Experimental::half_t> {
-  static constexpr float value = 0.5F;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'01110'0000000000}; // 0.5
 };
 
 /// \brief: Minimum normalized positive half precision number
@@ -152,35 +152,35 @@ struct Kokkos::Experimental::Impl::round_error_helper<
 template <>
 struct Kokkos::Experimental::Impl::norm_min_helper<
     Kokkos::Experimental::half_t> {
-  static constexpr float value = 0.00006103515625F;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'00001'0000000000}; // 0.00006103515625
 };
 
 /// \brief: Quiet not a half precision number
 ///
-/// IEEE 754 defines this as all exponent bits high.
+/// 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  0 0 0 0 0 0 0 0 0 0]
+///             [0  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::quiet_NaN_helper<
     Kokkos::Experimental::half_t> {
-  static constexpr float value = 0xfc000;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'11111'1000000000};
 };
 
 /// \brief: Signaling not a half precision number
 ///
-/// IEEE 754 defines this as all exponent bits and the first fraction bit high.
+/// IEEE 754 defines this as all exponent bits and the second 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]
+///             [0  1  1  1  1  1  0 1 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;
+  static constexpr Kokkos::Experimental::half_t::bit_comparison_type value{0b0'11111'0100000000};
 };
 
 /// \brief: Number of digits in the matissa that can be represented
@@ -267,49 +267,49 @@ struct Kokkos::Experimental::Impl::max_exponent_helper<
 ///
 template <>
 struct Kokkos::Experimental::Impl::infinity_helper<Kokkos::Experimental::bhalf_t> {
-  static constexpr int value = 0x7F80;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'11111111'0000000};
 };
 
 // Minimum normalized number
 template <>
 struct Kokkos::Experimental::Impl::finite_min_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = -3.38953139e38;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b1'11111110'1111111}; // -3.38953139e38
 };
 // Maximum normalized number
 template <>
 struct Kokkos::Experimental::Impl::finite_max_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = 3.38953139e38;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'11111110'1111111}; // +3.38953139e3
 };
 // 1/2^7
 template <>
 struct Kokkos::Experimental::Impl::epsilon_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = 0.0078125F;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'01111000'0000000}; // 0.0078125
 };
 template <>
 struct Kokkos::Experimental::Impl::round_error_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = 0.5F;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'01111110'0000000}; // 0.5
 };
 // Minimum normalized positive bhalf number
 template <>
 struct Kokkos::Experimental::Impl::norm_min_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = 1.1754494351e-38;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'00000001'0000000}; // 1.175494351e-38
 };
 // Quiet not a bhalf number
 template <>
 struct Kokkos::Experimental::Impl::quiet_NaN_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = 0x7fc000;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'11111111'1000000};
 };
 // Signaling not a bhalf number
 template <>
 struct Kokkos::Experimental::Impl::signaling_NaN_helper<
     Kokkos::Experimental::bhalf_t> {
-  static constexpr float value = 0x7fe000;
+  static constexpr Kokkos::Experimental::bhalf_t::bit_comparison_type value{0b0'11111111'0100000};
 };
 // Number of digits in the matissa that can be represented
 // without losing precision.
diff --git a/core/src/impl/Kokkos_HostSpace.cpp b/core/src/impl/Kokkos_HostSpace.cpp
index 88dfaadb08..1c1fb67ff0 100644
--- a/core/src/impl/Kokkos_HostSpace.cpp
+++ b/core/src/impl/Kokkos_HostSpace.cpp
@@ -20,23 +20,11 @@
 
 #include <Kokkos_Macros.hpp>
 
+#include <Kokkos_Atomic.hpp>
+#include <Kokkos_HostSpace.hpp>
 #include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_MemorySpace.hpp>
 #include <impl/Kokkos_Tools.hpp>
 
-/*--------------------------------------------------------------------------*/
-
-#if (defined(KOKKOS_COMPILER_INTEL) || defined(KOKKOS_COMPILER_INTEL_LLVM)) && \
-    !defined(KOKKOS_ENABLE_CUDA)
-
-// Intel specialized allocator does not interoperate with CUDA memory allocation
-
-#define KOKKOS_ENABLE_INTEL_MM_ALLOC
-
-#endif
-
-/*--------------------------------------------------------------------------*/
-
 #include <cstddef>
 #include <cstdlib>
 #include <cstdint>
@@ -46,50 +34,19 @@
 #include <sstream>
 #include <cstring>
 
-#include <Kokkos_HostSpace.hpp>
-#include <impl/Kokkos_Error.hpp>
-#include <Kokkos_Atomic.hpp>
+#ifdef KOKKOS_COMPILER_INTEL
+#include <aligned_new>
+#endif
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
 
 namespace Kokkos {
 
-/* Default allocation mechanism */
-HostSpace::HostSpace()
-    : m_alloc_mech(
-#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
-          HostSpace::INTEL_MM_ALLOC
-#else
-          HostSpace::STD_MALLOC
-#endif
-      ) {
-}
-
-/* Default allocation mechanism */
-HostSpace::HostSpace(const HostSpace::AllocationMechanism &arg_alloc_mech)
-    : m_alloc_mech(HostSpace::STD_MALLOC) {
-  if (arg_alloc_mech == STD_MALLOC) {
-    m_alloc_mech = HostSpace::STD_MALLOC;
-  }
-#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
-  else if (arg_alloc_mech == HostSpace::INTEL_MM_ALLOC) {
-    m_alloc_mech = HostSpace::INTEL_MM_ALLOC;
-  }
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+KOKKOS_DEPRECATED HostSpace::HostSpace(const HostSpace::AllocationMechanism &)
+    : HostSpace() {}
 #endif
-  else {
-    const char *const mech =
-        (arg_alloc_mech == HostSpace::INTEL_MM_ALLOC)
-            ? "INTEL_MM_ALLOC"
-            : ((arg_alloc_mech == HostSpace::POSIX_MMAP) ? "POSIX_MMAP" : "");
-
-    std::string msg;
-    msg.append("Kokkos::HostSpace ");
-    msg.append(mech);
-    msg.append(" is not available");
-    Kokkos::Impl::throw_runtime_exception(msg);
-  }
-}
 
 void *HostSpace::allocate(const size_t arg_alloc_size) const {
   return allocate("[unlabeled]", arg_alloc_size);
@@ -118,65 +75,13 @@ void *HostSpace::impl_allocate(
 
   void *ptr = nullptr;
 
-  if (arg_alloc_size) {
-    if (m_alloc_mech == STD_MALLOC) {
-      // Over-allocate to and round up to guarantee proper alignment.
-      size_t size_padded = arg_alloc_size + sizeof(void *) + alignment;
-
-      void *alloc_ptr = malloc(size_padded);
-
-      if (alloc_ptr) {
-        auto address = reinterpret_cast<uintptr_t>(alloc_ptr);
+  if (arg_alloc_size)
+    ptr = operator new (arg_alloc_size, std::align_val_t(alignment),
+                        std::nothrow_t{});
 
-        // offset enough to record the alloc_ptr
-        address += sizeof(void *);
-        uintptr_t rem    = address % alignment;
-        uintptr_t offset = rem ? (alignment - rem) : 0u;
-        address += offset;
-        ptr = reinterpret_cast<void *>(address);
-        // record the alloc'd pointer
-        address -= sizeof(void *);
-        *reinterpret_cast<void **>(address) = alloc_ptr;
-      }
-    }
-#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
-    else if (m_alloc_mech == INTEL_MM_ALLOC) {
-      ptr = _mm_malloc(arg_alloc_size, alignment);
-    }
-#endif
-  }
-
-  if ((ptr == nullptr) || (reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0)) ||
+  if (!ptr || (reinterpret_cast<uintptr_t>(ptr) == ~uintptr_t(0)) ||
       (reinterpret_cast<uintptr_t>(ptr) & alignment_mask)) {
-    Experimental::RawMemoryAllocationFailure::FailureMode failure_mode =
-        Experimental::RawMemoryAllocationFailure::FailureMode::
-            AllocationNotAligned;
-    if (ptr == nullptr) {
-      failure_mode = Experimental::RawMemoryAllocationFailure::FailureMode::
-          OutOfMemoryError;
-    }
-
-    Experimental::RawMemoryAllocationFailure::AllocationMechanism alloc_mec =
-        Experimental::RawMemoryAllocationFailure::AllocationMechanism::
-            StdMalloc;
-    switch (m_alloc_mech) {
-      case STD_MALLOC: break;  // default
-      case POSIX_MEMALIGN:
-        alloc_mec = Experimental::RawMemoryAllocationFailure::
-            AllocationMechanism::PosixMemAlign;
-        break;
-      case POSIX_MMAP:
-        alloc_mec = Experimental::RawMemoryAllocationFailure::
-            AllocationMechanism::PosixMMap;
-        break;
-      case INTEL_MM_ALLOC:
-        alloc_mec = Experimental::RawMemoryAllocationFailure::
-            AllocationMechanism::IntelMMAlloc;
-        break;
-    }
-
-    throw Kokkos::Experimental::RawMemoryAllocationFailure(
-        arg_alloc_size, alignment, failure_mode, alloc_mec);
+    Impl::throw_bad_alloc(name(), arg_alloc_size, arg_label);
   }
   if (Kokkos::Profiling::profileLibraryLoaded()) {
     Kokkos::Profiling::allocateData(arg_handle, arg_label, ptr, reported_size);
@@ -191,9 +96,8 @@ void HostSpace::deallocate(void *const arg_alloc_ptr,
 
 void HostSpace::deallocate(const char *arg_label, void *const arg_alloc_ptr,
                            const size_t arg_alloc_size,
-                           const size_t
-
-                               arg_logical_size) const {
+                           const size_t arg_logical_size) const {
+  if (arg_alloc_ptr) Kokkos::fence("HostSpace::impl_deallocate before free");
   impl_deallocate(arg_label, arg_alloc_ptr, arg_alloc_size, arg_logical_size);
 }
 void HostSpace::impl_deallocate(
@@ -201,105 +105,20 @@ void HostSpace::impl_deallocate(
     const size_t arg_alloc_size, const size_t arg_logical_size,
     const Kokkos::Tools::SpaceHandle arg_handle) const {
   if (arg_alloc_ptr) {
-    Kokkos::fence("HostSpace::impl_deallocate before free");
     size_t reported_size =
         (arg_logical_size > 0) ? arg_logical_size : arg_alloc_size;
     if (Kokkos::Profiling::profileLibraryLoaded()) {
       Kokkos::Profiling::deallocateData(arg_handle, arg_label, arg_alloc_ptr,
                                         reported_size);
     }
-    if (m_alloc_mech == STD_MALLOC) {
-      void *alloc_ptr = *(reinterpret_cast<void **>(arg_alloc_ptr) - 1);
-      free(alloc_ptr);
-    }
-#if defined(KOKKOS_ENABLE_INTEL_MM_ALLOC)
-    else if (m_alloc_mech == INTEL_MM_ALLOC) {
-      _mm_free(arg_alloc_ptr);
-    }
-#endif
-  }
-}
-
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-#ifdef KOKKOS_ENABLE_DEBUG
-SharedAllocationRecord<void, void>
-    SharedAllocationRecord<Kokkos::HostSpace, void>::s_root_record;
-#endif
-
-SharedAllocationRecord<Kokkos::HostSpace, void>::~SharedAllocationRecord() {
-  m_space.deallocate(m_label.c_str(),
-                     SharedAllocationRecord<void, void>::m_alloc_ptr,
-                     SharedAllocationRecord<void, void>::m_alloc_size,
-                     (SharedAllocationRecord<void, void>::m_alloc_size -
-                      sizeof(SharedAllocationHeader)));
-}
-
-SharedAllocationHeader *_do_allocation(Kokkos::HostSpace const &space,
-                                       std::string const &label,
-                                       size_t alloc_size) {
-  try {
-    return reinterpret_cast<SharedAllocationHeader *>(
-        space.allocate(alloc_size));
-  } catch (Experimental::RawMemoryAllocationFailure const &failure) {
-    if (failure.failure_mode() == Experimental::RawMemoryAllocationFailure::
-                                      FailureMode::AllocationNotAligned) {
-      // TODO: delete the misaligned memory
-    }
-
-    std::cerr << "Kokkos failed to allocate memory for label \"" << label
-              << "\".  Allocation using MemorySpace named \"" << space.name()
-              << " failed with the following error:  ";
-    failure.print_error_message(std::cerr);
-    std::cerr.flush();
-    Kokkos::Impl::throw_runtime_exception("Memory allocation failure");
+    constexpr uintptr_t alignment = Kokkos::Impl::MEMORY_ALIGNMENT;
+    operator delete (arg_alloc_ptr, std::align_val_t(alignment),
+                     std::nothrow_t{});
   }
-  return nullptr;  // unreachable
 }
 
-SharedAllocationRecord<Kokkos::HostSpace, void>::SharedAllocationRecord(
-    const Kokkos::HostSpace &arg_space, const std::string &arg_label,
-    const size_t arg_alloc_size,
-    const SharedAllocationRecord<void, void>::function_type arg_dealloc)
-    // Pass through allocated [ SharedAllocationHeader , user_memory ]
-    // Pass through deallocation function
-    : base_t(
-#ifdef KOKKOS_ENABLE_DEBUG
-          &SharedAllocationRecord<Kokkos::HostSpace, void>::s_root_record,
-#endif
-          Impl::checked_allocation_with_header(arg_space, arg_label,
-                                               arg_alloc_size),
-          sizeof(SharedAllocationHeader) + arg_alloc_size, arg_dealloc,
-          arg_label),
-      m_space(arg_space) {
-  this->base_t::_fill_host_accessible_header_info(*RecordBase::m_alloc_ptr,
-                                                  arg_label);
-}
-
-}  // namespace Impl
 }  // namespace Kokkos
 
-//==============================================================================
-// <editor-fold desc="Explicit instantiations of CRTP Base classes"> {{{1
-
 #include <impl/Kokkos_SharedAlloc_timpl.hpp>
 
-namespace Kokkos {
-namespace Impl {
-
-// To avoid additional compilation cost for something that's (mostly?) not
-// performance sensitive, we explicity instantiate these CRTP base classes here,
-// where we have access to the associated *_timpl.hpp header files.
-template class SharedAllocationRecordCommon<Kokkos::HostSpace>;
-
-}  // end namespace Impl
-}  // end namespace Kokkos
-
-// </editor-fold> end Explicit instantiations of CRTP Base classes }}}1
-//==============================================================================
+KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION(Kokkos::HostSpace);
diff --git a/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp b/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp
index b373167127..3072e2ce82 100644
--- a/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp
+++ b/core/src/impl/Kokkos_HostSpace_ZeroMemset.hpp
@@ -21,15 +21,12 @@
 #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&) {
+  ZeroMemset(const HostSpace::execution_space& exec, const View<T, P...>& dst) {
     // 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
@@ -38,12 +35,6 @@ struct ZeroMemset<HostSpace::execution_space, View<T, P...>> {
     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
diff --git a/core/src/impl/Kokkos_HostSpace_deepcopy.cpp b/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
index 0ce5fe34b6..84f525061e 100644
--- a/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
+++ b/core/src/impl/Kokkos_HostSpace_deepcopy.cpp
@@ -57,7 +57,7 @@ void hostspace_parallel_deepcopy_async(const DefaultHostExecutionSpace& exec,
   constexpr int host_deep_copy_serial_limit = 10 * 8192;
   if ((n < host_deep_copy_serial_limit) ||
       (DefaultHostExecutionSpace().concurrency() == 1)) {
-    std::memcpy(dst, src, n);
+    if (0 < n) std::memcpy(dst, src, n);
     return;
   }
 
diff --git a/core/src/impl/Kokkos_HostThreadTeam.cpp b/core/src/impl/Kokkos_HostThreadTeam.cpp
index bfe5902bf7..11bf701b57 100644
--- a/core/src/impl/Kokkos_HostThreadTeam.cpp
+++ b/core/src/impl/Kokkos_HostThreadTeam.cpp
@@ -22,7 +22,6 @@
 #include <Kokkos_Macros.hpp>
 #include <impl/Kokkos_HostThreadTeam.hpp>
 #include <impl/Kokkos_Error.hpp>
-#include <impl/Kokkos_Spinwait.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/core/src/impl/Kokkos_HostThreadTeam.hpp b/core/src/impl/Kokkos_HostThreadTeam.hpp
index 94db1f49bb..3dc68a187b 100644
--- a/core/src/impl/Kokkos_HostThreadTeam.hpp
+++ b/core/src/impl/Kokkos_HostThreadTeam.hpp
@@ -106,7 +106,11 @@ class HostThreadTeamData {
 
  public:
   inline bool team_rendezvous() const noexcept {
-    int* ptr = reinterpret_cast<int*>(m_team_scratch + m_team_rendezvous);
+    // FIXME_OPENMP The tasking framework creates an instance with
+    // m_team_scratch == nullptr and m_team_rendezvous != 0:
+    int* ptr = m_team_scratch == nullptr
+                   ? nullptr
+                   : reinterpret_cast<int*>(m_team_scratch + m_team_rendezvous);
     HostBarrier::split_arrive(ptr, m_team_size, m_team_rendezvous_step);
     if (m_team_rank != 0) {
       HostBarrier::wait(ptr, m_team_size, m_team_rendezvous_step);
@@ -130,9 +134,13 @@ class HostThreadTeamData {
   }
 
   inline void team_rendezvous_release() const noexcept {
+    // FIXME_OPENMP The tasking framework creates an instance with
+    // m_team_scratch == nullptr and m_team_rendezvous != 0:
     HostBarrier::split_release(
-        reinterpret_cast<int*>(m_team_scratch + m_team_rendezvous), m_team_size,
-        m_team_rendezvous_step);
+        (m_team_scratch == nullptr)
+            ? nullptr
+            : reinterpret_cast<int*>(m_team_scratch + m_team_rendezvous),
+        m_team_size, m_team_rendezvous_step);
   }
 
   inline int pool_rendezvous() const noexcept {
@@ -155,8 +163,7 @@ class HostThreadTeamData {
 
   //----------------------------------------
 
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC bug in NVHPC regarding constexpr
-                               // constructors used in device code
+#if !defined(KOKKOS_COMPILER_NVHPC) || (KOKKOS_COMPILER_NVHPC >= 230700)
   constexpr
 #endif
       HostThreadTeamData() noexcept
@@ -272,6 +279,9 @@ class HostThreadTeamData {
   }
 
   int64_t* team_shared() const noexcept {
+    // FIXME_OPENMP The tasking framework creates an instance with
+    // m_team_scratch == nullptr and m_team_shared != 0
+    if (m_team_scratch == nullptr) return nullptr;
     return m_team_scratch + m_team_shared;
   }
 
@@ -401,8 +411,12 @@ class HostThreadTeamMember {
   int const m_league_size;
 
  public:
+  // FIXME_OPENMP The tasking framework creates an instance with
+  // m_team_scratch == nullptr and m_team_shared != 0:
   constexpr HostThreadTeamMember(HostThreadTeamData& arg_data) noexcept
-      : m_scratch(arg_data.team_shared(), arg_data.team_shared_bytes()),
+      : m_scratch(arg_data.team_shared(), (arg_data.team_shared() == nullptr)
+                                              ? 0
+                                              : arg_data.team_shared_bytes()),
         m_data(arg_data),
         m_league_rank(arg_data.m_league_rank),
         m_league_size(arg_data.m_league_size) {}
@@ -864,19 +878,21 @@ KOKKOS_INLINE_FUNCTION
 
 //----------------------------------------------------------------------------
 
-template <typename iType, class Closure, class Member>
+template <typename iType, class Closure, class Member, typename ValueType>
 KOKKOS_INLINE_FUNCTION
-    std::enable_if_t<Impl::is_host_thread_team_member<Member>::value>
+    std::enable_if_t<!Kokkos::is_reducer<ValueType>::value &&
+                     Impl::is_host_thread_team_member<Member>::value>
     parallel_scan(Impl::TeamThreadRangeBoundariesStruct<iType, Member> const&
                       loop_boundaries,
-                  Closure const& closure) {
-  // Extract ValueType from the closure
-
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
+                  Closure const& closure, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using ClosureValueType = typename Kokkos::Impl::FunctorAnalysis<
       Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
       void>::value_type;
+  static_assert(std::is_same<ClosureValueType, ValueType>::value,
+                "Non-matching value types of closure and return type");
 
-  value_type accum = 0;
+  ValueType accum = ValueType();
 
   // Intra-member scan
   for (iType i = loop_boundaries.start; i < loop_boundaries.end;
@@ -884,25 +900,51 @@ KOKKOS_INLINE_FUNCTION
     closure(i, accum, false);
   }
 
+  auto& team_member = loop_boundaries.thread;
+
   // 'accum' output is the exclusive prefix sum
-  accum = loop_boundaries.thread.team_scan(accum);
+  accum = team_member.team_scan(accum);
 
   for (iType i = loop_boundaries.start; i < loop_boundaries.end;
        i += loop_boundaries.increment) {
     closure(i, accum, true);
   }
+
+  team_member.team_broadcast(accum, team_member.team_size() - 1);
+
+  return_val = accum;
 }
 
-template <typename iType, class ClosureType, class Member>
+template <typename iType, class Closure, class Member>
 KOKKOS_INLINE_FUNCTION
     std::enable_if_t<Impl::is_host_thread_team_member<Member>::value>
+    parallel_scan(Impl::TeamThreadRangeBoundariesStruct<iType, Member> const&
+                      loop_boundaries,
+                  Closure const& closure) {
+  // Extract ValueType from the closure
+  using ValueType = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, Closure,
+      void>::value_type;
+
+  ValueType scan_val;
+  parallel_scan(loop_boundaries, closure, scan_val);
+}
+
+template <typename iType, class ClosureType, class Member, typename ValueType>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<!Kokkos::is_reducer<ValueType>::value &&
+                     Impl::is_host_thread_team_member<Member>::value>
     parallel_scan(Impl::ThreadVectorRangeBoundariesStruct<iType, Member> const&
                       loop_boundaries,
-                  ClosureType const& closure) {
-  using value_type = typename Kokkos::Impl::FunctorAnalysis<
-      Impl::FunctorPatternInterface::SCAN, void, ClosureType, void>::value_type;
+                  ClosureType const& closure, ValueType& return_val) {
+  // Extract ValueType from the Closure
+  using ClosureValueType = typename Kokkos::Impl::FunctorAnalysis<
+      Kokkos::Impl::FunctorPatternInterface::SCAN, void, ClosureType,
+      void>::value_type;
+  static_assert(std::is_same<ClosureValueType, ValueType>::value,
+                "Non-matching value types of closure and return type");
 
-  value_type scan_val = value_type();
+  ValueType scan_val = ValueType();
 
 #ifdef KOKKOS_ENABLE_PRAGMA_IVDEP
 #pragma ivdep
@@ -911,6 +953,22 @@ KOKKOS_INLINE_FUNCTION
        i += loop_boundaries.increment) {
     closure(i, scan_val, true);
   }
+
+  return_val = scan_val;
+}
+
+template <typename iType, class ClosureType, class Member>
+KOKKOS_INLINE_FUNCTION
+    std::enable_if_t<Impl::is_host_thread_team_member<Member>::value>
+    parallel_scan(Impl::ThreadVectorRangeBoundariesStruct<iType, Member> const&
+                      loop_boundaries,
+                  ClosureType const& closure) {
+  // Extract ValueType from the closure
+  using ValueType = typename Kokkos::Impl::FunctorAnalysis<
+      Impl::FunctorPatternInterface::SCAN, void, ClosureType, void>::value_type;
+
+  ValueType scan_val;
+  parallel_scan(loop_boundaries, closure, scan_val);
 }
 
 template <typename iType, class Lambda, typename ReducerType, typename Member>
diff --git a/core/src/impl/Kokkos_InitializationSettings.hpp b/core/src/impl/Kokkos_InitializationSettings.hpp
index ab4350f3a7..11a93c6bb5 100644
--- a/core/src/impl/Kokkos_InitializationSettings.hpp
+++ b/core/src/impl/Kokkos_InitializationSettings.hpp
@@ -24,32 +24,6 @@
 
 namespace Kokkos {
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-struct InitArguments {
-  int num_threads;
-  int num_numa;
-  int device_id;
-  int ndevices;
-  int skip_device;
-  bool disable_warnings;
-  bool tune_internals;
-  bool tool_help        = false;
-  std::string tool_lib  = {};
-  std::string tool_args = {};
-
-  KOKKOS_DEPRECATED_WITH_COMMENT("Use InitializationSettings instead!")
-  InitArguments(int nt = -1, int nn = -1, int dv = -1, bool dw = false,
-                bool ti = false)
-      : num_threads{nt},
-        num_numa{nn},
-        device_id{dv},
-        ndevices{-1},
-        skip_device{9999},
-        disable_warnings{dw},
-        tune_internals{ti} {}
-};
-#endif
-
 class InitializationSettings {
 #define KOKKOS_IMPL_DECLARE(TYPE, NAME)                                    \
  private:                                                                  \
@@ -64,12 +38,32 @@ class InitializationSettings {
   TYPE get_##NAME() const noexcept { return *m_##NAME; }                   \
   static_assert(true, "no-op to require trailing semicolon")
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+#define KOKKOS_IMPL_DECLARE_DEPRECATED(TYPE, NAME)                         \
+ private:                                                                  \
+  std::optional<TYPE> m_##NAME;                                            \
+                                                                           \
+ public:                                                                   \
+  KOKKOS_DEPRECATED InitializationSettings& set_##NAME(TYPE NAME) {        \
+    m_##NAME = NAME;                                                       \
+    return *this;                                                          \
+  }                                                                        \
+  KOKKOS_DEPRECATED bool has_##NAME() const noexcept {                     \
+    return static_cast<bool>(m_##NAME);                                    \
+  }                                                                        \
+  KOKKOS_DEPRECATED TYPE get_##NAME() const noexcept { return *m_##NAME; } \
+  static_assert(true, "no-op to require trailing semicolon")
+#else
+#define KOKKOS_IMPL_DECLARE_DEPRECATED(TYPE, NAME) \
+  static_assert(true, "no-op to require trailing semicolon")
+#endif
+
  public:
   KOKKOS_IMPL_DECLARE(int, num_threads);
   KOKKOS_IMPL_DECLARE(int, device_id);
   KOKKOS_IMPL_DECLARE(std::string, map_device_id_by);
-  KOKKOS_IMPL_DECLARE(int, num_devices);  // deprecated
-  KOKKOS_IMPL_DECLARE(int, skip_device);  // deprecated
+  KOKKOS_IMPL_DECLARE_DEPRECATED(int, num_devices);
+  KOKKOS_IMPL_DECLARE_DEPRECATED(int, skip_device);
   KOKKOS_IMPL_DECLARE(bool, disable_warnings);
   KOKKOS_IMPL_DECLARE(bool, print_configuration);
   KOKKOS_IMPL_DECLARE(bool, tune_internals);
@@ -80,41 +74,6 @@ class InitializationSettings {
 #undef KOKKOS_IMPL_INIT_ARGS_DATA_MEMBER_TYPE
 #undef KOKKOS_IMPL_INIT_ARGS_DATA_MEMBER
 #undef KOKKOS_IMPL_DECLARE
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
- public:
-  InitializationSettings() = default;
-
-  InitializationSettings(InitArguments const& old) {
-    if (old.num_threads != -1) {
-      set_num_threads(old.num_threads);
-    }
-    if (old.device_id != -1) {
-      set_device_id(old.device_id);
-    }
-    if (old.ndevices != -1) {
-      set_num_devices(old.ndevices);
-    }
-    if (old.skip_device != 9999) {
-      set_skip_device(old.skip_device);
-    }
-    if (old.disable_warnings) {
-      set_disable_warnings(true);
-    }
-    if (old.tune_internals) {
-      set_tune_internals(true);
-    }
-    if (old.tool_help) {
-      set_tools_help(true);
-    }
-    if (!old.tool_lib.empty()) {
-      set_tools_libs(old.tool_lib);
-    }
-    if (!old.tool_args.empty()) {
-      set_tools_args(old.tool_args);
-    }
-  }
-#endif
 };
 
 }  // namespace Kokkos
diff --git a/core/src/impl/Kokkos_MemorySpace.cpp b/core/src/impl/Kokkos_MemorySpace.cpp
deleted file mode 100644
index 2f0e01c5b2..0000000000
--- a/core/src/impl/Kokkos_MemorySpace.cpp
+++ /dev/null
@@ -1,72 +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
-
-/** @file Kokkos_MemorySpace.cpp
- *
- *  Operations common to memory space instances, or at least default
- *  implementations thereof.
- */
-
-#ifndef KOKKOS_IMPL_PUBLIC_INCLUDE
-#define KOKKOS_IMPL_PUBLIC_INCLUDE
-#endif
-
-#include <impl/Kokkos_MemorySpace.hpp>
-
-#include <iostream>
-#include <string>
-#include <sstream>
-
-namespace Kokkos {
-namespace Impl {
-
-void safe_throw_allocation_with_header_failure(
-    std::string const& space_name, std::string const& label,
-    Kokkos::Experimental::RawMemoryAllocationFailure const& failure) {
-  auto generate_failure_message = [&](std::ostream& o) {
-    o << "Kokkos failed to allocate memory for label \"" << label
-      << "\".  Allocation using MemorySpace named \"" << space_name
-      << "\" failed with the following error:  ";
-    failure.print_error_message(o);
-    if (failure.failure_mode() ==
-        Kokkos::Experimental::RawMemoryAllocationFailure::FailureMode::
-            AllocationNotAligned) {
-      // TODO: delete the misaligned memory?
-      o << "Warning: Allocation failed due to misalignment; memory may "
-           "be leaked.\n";
-    }
-    o.flush();
-  };
-  try {
-    std::ostringstream sstr;
-    generate_failure_message(sstr);
-    Kokkos::Impl::throw_runtime_exception(sstr.str());
-  } catch (std::bad_alloc const&) {
-    // Probably failed to allocate the string because we're so close to out
-    // of memory. Try printing to std::cerr instead
-    try {
-      generate_failure_message(std::cerr);
-    } catch (std::bad_alloc const&) {
-      // oh well, we tried...
-    }
-    Kokkos::Impl::throw_runtime_exception(
-        "Kokkos encountered an allocation failure, then another allocation "
-        "failure while trying to create the error message.");
-  }
-}
-
-}  // end namespace Impl
-}  // end namespace Kokkos
diff --git a/core/src/impl/Kokkos_MemorySpace.hpp b/core/src/impl/Kokkos_MemorySpace.hpp
deleted file mode 100644
index 44956dd7c5..0000000000
--- a/core/src/impl/Kokkos_MemorySpace.hpp
+++ /dev/null
@@ -1,71 +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
-
-/** @file Kokkos_MemorySpace.hpp
- *
- *  Operations common to memory space instances, or at least default
- *  implementations thereof.
- */
-
-#ifndef KOKKOS_IMPL_MEMORYSPACE_HPP
-#define KOKKOS_IMPL_MEMORYSPACE_HPP
-
-#include <Kokkos_Macros.hpp>
-#include <impl/Kokkos_SharedAlloc.hpp>
-#include <impl/Kokkos_Error.hpp>
-
-#include <string>
-
-namespace Kokkos {
-namespace Impl {
-
-// Defined in implementation file to avoid having to include iostream
-void safe_throw_allocation_with_header_failure(
-    std::string const &space_name, std::string const &label,
-    Kokkos::Experimental::RawMemoryAllocationFailure const &failure);
-
-template <class MemorySpace>
-SharedAllocationHeader *checked_allocation_with_header(MemorySpace const &space,
-                                                       std::string const &label,
-                                                       size_t alloc_size) {
-  try {
-    return reinterpret_cast<SharedAllocationHeader *>(space.allocate(
-        label.c_str(), alloc_size + sizeof(SharedAllocationHeader),
-        alloc_size));
-  } catch (Kokkos::Experimental::RawMemoryAllocationFailure const &failure) {
-    safe_throw_allocation_with_header_failure(space.name(), label, failure);
-  }
-  return nullptr;  // unreachable
-}
-
-template <class ExecutionSpace, class MemorySpace>
-SharedAllocationHeader *checked_allocation_with_header(
-    ExecutionSpace const &exec_space, MemorySpace const &space,
-    std::string const &label, size_t alloc_size) {
-  try {
-    return reinterpret_cast<SharedAllocationHeader *>(space.allocate(
-        exec_space, label.c_str(), alloc_size + sizeof(SharedAllocationHeader),
-        alloc_size));
-  } catch (Kokkos::Experimental::RawMemoryAllocationFailure const &failure) {
-    safe_throw_allocation_with_header_failure(space.name(), label, failure);
-  }
-  return nullptr;  // unreachable
-}
-
-}  // end namespace Impl
-}  // end namespace Kokkos
-
-#endif  // KOKKOS_IMPL_MEMORYSPACE_HPP
diff --git a/core/src/impl/Kokkos_Memory_Fence.hpp b/core/src/impl/Kokkos_Memory_Fence.hpp
deleted file mode 100644
index 42a53b04fb..0000000000
--- a/core/src/impl/Kokkos_Memory_Fence.hpp
+++ /dev/null
@@ -1,54 +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_MEMORY_FENCE_HPP)
-#define KOKKOS_MEMORY_FENCE_HPP
-namespace Kokkos {
-
-//////////////////////////////////////////////////////
-// store_fence()
-//
-// If possible use a store fence on the architecture, if not run a full memory
-// fence
-
-KOKKOS_FORCEINLINE_FUNCTION
-void store_fence() {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-  asm volatile("sfence" ::: "memory");
-#else
-  memory_fence();
-#endif
-}
-
-//////////////////////////////////////////////////////
-// load_fence()
-//
-// If possible use a load fence on the architecture, if not run a full memory
-// fence
-
-KOKKOS_FORCEINLINE_FUNCTION
-void load_fence() {
-#if defined(KOKKOS_ENABLE_ASM) && defined(KOKKOS_ENABLE_ISA_X86_64)
-  asm volatile("lfence" ::: "memory");
-#else
-  memory_fence();
-#endif
-}
-
-}  // namespace Kokkos
-
-#endif
diff --git a/core/src/impl/Kokkos_Profiling.cpp b/core/src/impl/Kokkos_Profiling.cpp
index 47780caab5..0b34653017 100644
--- a/core/src/impl/Kokkos_Profiling.cpp
+++ b/core/src/impl/Kokkos_Profiling.cpp
@@ -626,17 +626,11 @@ void initialize(const std::string& profileLibrary) {
     return;
   }
 
-  char* envProfileLibrary = const_cast<char*>(profileLibrary.c_str());
-
-  const size_t envProfileLen = strlen(envProfileLibrary) + 1;
-  const auto envProfileCopy  = std::make_unique<char[]>(envProfileLen);
-  snprintf(envProfileCopy.get(), envProfileLen, "%s", envProfileLibrary);
-
-  char* profileLibraryName = strtok(envProfileCopy.get(), ";");
-
-  if ((profileLibraryName != nullptr) &&
-      (strcmp(profileLibraryName, "") != 0)) {
-    firstProfileLibrary = dlopen(profileLibraryName, RTLD_NOW | RTLD_GLOBAL);
+  if (auto end_first_library = profileLibrary.find(';');
+      end_first_library != 0) {
+    auto profileLibraryName = profileLibrary.substr(0, end_first_library);
+    firstProfileLibrary =
+        dlopen(profileLibraryName.c_str(), RTLD_NOW | RTLD_GLOBAL);
 
     if (firstProfileLibrary == nullptr) {
       std::cerr << "Error: Unable to load KokkosP library: "
@@ -977,84 +971,6 @@ void set_callbacks(Kokkos::Tools::Experimental::EventSet new_events) {
 }  // namespace Experimental
 }  // namespace Tools
 
-namespace Profiling {
-bool profileLibraryLoaded() { return Kokkos::Tools::profileLibraryLoaded(); }
-
-void beginParallelFor(const std::string& kernelPrefix, const uint32_t devID,
-                      uint64_t* kernelID) {
-  Kokkos::Tools::beginParallelFor(kernelPrefix, devID, kernelID);
-}
-void beginParallelReduce(const std::string& kernelPrefix, const uint32_t devID,
-                         uint64_t* kernelID) {
-  Kokkos::Tools::beginParallelReduce(kernelPrefix, devID, kernelID);
-}
-void beginParallelScan(const std::string& kernelPrefix, const uint32_t devID,
-                       uint64_t* kernelID) {
-  Kokkos::Tools::beginParallelScan(kernelPrefix, devID, kernelID);
-}
-void endParallelFor(const uint64_t kernelID) {
-  Kokkos::Tools::endParallelFor(kernelID);
-}
-void endParallelReduce(const uint64_t kernelID) {
-  Kokkos::Tools::endParallelReduce(kernelID);
-}
-void endParallelScan(const uint64_t kernelID) {
-  Kokkos::Tools::endParallelScan(kernelID);
-}
-
-void pushRegion(const std::string& kName) { Kokkos::Tools::pushRegion(kName); }
-void popRegion() { Kokkos::Tools::popRegion(); }
-
-void createProfileSection(const std::string& sectionName, uint32_t* secID) {
-  Kokkos::Tools::createProfileSection(sectionName, secID);
-}
-void destroyProfileSection(const uint32_t secID) {
-  Kokkos::Tools::destroyProfileSection(secID);
-}
-
-void startSection(const uint32_t secID) { Kokkos::Tools::startSection(secID); }
-
-void stopSection(const uint32_t secID) { Kokkos::Tools::stopSection(secID); }
-
-void markEvent(const std::string& eventName) {
-  Kokkos::Tools::markEvent(eventName);
-}
-void allocateData(const SpaceHandle handle, const std::string name,
-                  const void* data, const uint64_t size) {
-  Kokkos::Tools::allocateData(handle, name, data, size);
-}
-void deallocateData(const SpaceHandle space, const std::string label,
-                    const void* ptr, const uint64_t size) {
-  Kokkos::Tools::deallocateData(space, label, ptr, size);
-}
-
-void beginDeepCopy(const SpaceHandle dst_space, const std::string dst_label,
-                   const void* dst_ptr, const SpaceHandle src_space,
-                   const std::string src_label, const void* src_ptr,
-                   const uint64_t size) {
-  Kokkos::Tools::beginDeepCopy(dst_space, dst_label, dst_ptr, src_space,
-                               src_label, src_ptr, size);
-}
-void endDeepCopy() { Kokkos::Tools::endDeepCopy(); }
-
-void finalize() { Kokkos::Tools::finalize(); }
-void initialize(const std::string& profileLibrary) {
-  Kokkos::Tools::initialize(profileLibrary);
-}
-
-bool printHelp(const std::string& args) {
-  return Kokkos::Tools::printHelp(args);
-}
-void parseArgs(const std::string& args) { Kokkos::Tools::parseArgs(args); }
-void parseArgs(int _argc, char** _argv) {
-  Kokkos::Tools::parseArgs(_argc, _argv);
-}
-
-SpaceHandle make_space_handle(const char* space_name) {
-  return Kokkos::Tools::make_space_handle(space_name);
-}
-}  // namespace Profiling
-
 // Tuning
 
 namespace Tools {
diff --git a/core/src/impl/Kokkos_Profiling.hpp b/core/src/impl/Kokkos_Profiling.hpp
index 025d8d3d18..01a41d0c3f 100644
--- a/core/src/impl/Kokkos_Profiling.hpp
+++ b/core/src/impl/Kokkos_Profiling.hpp
@@ -263,40 +263,41 @@ size_t get_current_context_id();
 }  // namespace Tools
 namespace Profiling {
 
-bool profileLibraryLoaded();
+// don't let ClangFormat reorder the using-declarations below
+// clang-format off
+using Kokkos::Tools::profileLibraryLoaded;
 
-void beginParallelFor(const std::string& kernelPrefix, const uint32_t devID,
-                      uint64_t* kernelID);
-void beginParallelReduce(const std::string& kernelPrefix, const uint32_t devID,
-                         uint64_t* kernelID);
-void beginParallelScan(const std::string& kernelPrefix, const uint32_t devID,
-                       uint64_t* kernelID);
-void endParallelFor(const uint64_t kernelID);
-void endParallelReduce(const uint64_t kernelID);
-void endParallelScan(const uint64_t kernelID);
-void pushRegion(const std::string& kName);
-void popRegion();
+using Kokkos::Tools::printHelp;
+using Kokkos::Tools::parseArgs;
 
-void createProfileSection(const std::string& sectionName, uint32_t* secID);
-void destroyProfileSection(const uint32_t secID);
-void startSection(const uint32_t secID);
+using Kokkos::Tools::initialize;
+using Kokkos::Tools::finalize;
 
-void stopSection(const uint32_t secID);
+using Kokkos::Tools::beginParallelFor;
+using Kokkos::Tools::beginParallelReduce;
+using Kokkos::Tools::beginParallelScan;
+using Kokkos::Tools::endParallelFor;
+using Kokkos::Tools::endParallelReduce;
+using Kokkos::Tools::endParallelScan;
 
-void markEvent(const std::string& eventName);
-void allocateData(const SpaceHandle handle, const std::string name,
-                  const void* data, const uint64_t size);
-void deallocateData(const SpaceHandle space, const std::string label,
-                    const void* ptr, const uint64_t size);
-void beginDeepCopy(const SpaceHandle dst_space, const std::string dst_label,
-                   const void* dst_ptr, const SpaceHandle src_space,
-                   const std::string src_label, const void* src_ptr,
-                   const uint64_t size);
-void endDeepCopy();
-void finalize();
-void initialize(const std::string& = {});
+using Kokkos::Tools::allocateData;
+using Kokkos::Tools::deallocateData;
+
+using Kokkos::Tools::beginDeepCopy;
+using Kokkos::Tools::endDeepCopy;
+
+using Kokkos::Tools::pushRegion;
+using Kokkos::Tools::popRegion;
+
+using Kokkos::Tools::createProfileSection;
+using Kokkos::Tools::destroyProfileSection;
+using Kokkos::Tools::startSection;
+using Kokkos::Tools::stopSection;
+
+using Kokkos::Tools::markEvent;
 
-SpaceHandle make_space_handle(const char* space_name);
+using Kokkos::Tools::make_space_handle;
+// clang-format on
 
 namespace Experimental {
 using Kokkos::Tools::Experimental::set_allocate_data_callback;
diff --git a/core/src/impl/Kokkos_Profiling_C_Interface.h b/core/src/impl/Kokkos_Profiling_C_Interface.h
index 731a11e917..8c3194e43b 100644
--- a/core/src/impl/Kokkos_Profiling_C_Interface.h
+++ b/core/src/impl/Kokkos_Profiling_C_Interface.h
@@ -32,6 +32,10 @@
 
 // Profiling
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 struct Kokkos_Profiling_KokkosPDeviceInfo {
   size_t deviceID;
 };
@@ -154,7 +158,7 @@ enum Kokkos_Tools_OptimizationType {
   Kokkos_Tools_Maximize
 };
 
-struct Kokkos_Tools_OptimzationGoal {
+struct Kokkos_Tools_OptimizationGoal {
   size_t type_id;
   enum Kokkos_Tools_OptimizationType goal;
 };
@@ -220,7 +224,7 @@ typedef void (*Kokkos_Tools_contextBeginFunction)(const size_t);
 typedef void (*Kokkos_Tools_contextEndFunction)(
     const size_t, struct Kokkos_Tools_VariableValue);
 typedef void (*Kokkos_Tools_optimizationGoalDeclarationFunction)(
-    const size_t, const struct Kokkos_Tools_OptimzationGoal goal);
+    const size_t, const struct Kokkos_Tools_OptimizationGoal goal);
 
 struct Kokkos_Profiling_EventSet {
   Kokkos_Profiling_initFunction init;
@@ -267,4 +271,8 @@ struct Kokkos_Profiling_EventSet {
                                                     // changing struct layout
 };
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif  // KOKKOS_PROFILING_C_INTERFACE_HPP
diff --git a/core/src/impl/Kokkos_Profiling_Interface.hpp b/core/src/impl/Kokkos_Profiling_Interface.hpp
index af71932e47..b66886d9f7 100644
--- a/core/src/impl/Kokkos_Profiling_Interface.hpp
+++ b/core/src/impl/Kokkos_Profiling_Interface.hpp
@@ -226,7 +226,7 @@ using ValueType           = Kokkos_Tools_VariableInfo_ValueType;
 using CandidateValueType  = Kokkos_Tools_VariableInfo_CandidateValueType;
 using SetOrRange          = Kokkos_Tools_VariableInfo_SetOrRange;
 using VariableInfo        = Kokkos_Tools_VariableInfo;
-using OptimizationGoal    = Kokkos_Tools_OptimzationGoal;
+using OptimizationGoal    = Kokkos_Tools_OptimizationGoal;
 using TuningString        = Kokkos_Tools_Tuning_String;
 using VariableValue       = Kokkos_Tools_VariableValue;
 
diff --git a/core/src/impl/Kokkos_SharedAlloc.cpp b/core/src/impl/Kokkos_SharedAlloc.cpp
index ccc5b60f5f..ccf3c47a1e 100644
--- a/core/src/impl/Kokkos_SharedAlloc.cpp
+++ b/core/src/impl/Kokkos_SharedAlloc.cpp
@@ -19,6 +19,9 @@
 #endif
 
 #include <Kokkos_Core.hpp>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
 
 namespace Kokkos {
 namespace Impl {
@@ -285,51 +288,30 @@ void SharedAllocationRecord<void, void>::print_host_accessible_records(
   // allocation.
   const SharedAllocationRecord<void, void>* r = root->m_next;
 
-  char buffer[256];
-
+  std::ios_base::fmtflags saved_flags = s.flags();
+#define KOKKOS_PAD_HEX(ptr)                              \
+  "0x" << std::hex << std::setw(12) << std::setfill('0') \
+       << reinterpret_cast<uintptr_t>(ptr)
   if (detail) {
     while (r != root) {
-      // Formatting dependent on sizeof(uintptr_t)
-      const char* format_string;
-
-      if (sizeof(uintptr_t) == sizeof(unsigned long)) {
-        format_string =
-            "%s addr( 0x%.12lx ) list( 0x%.12lx 0x%.12lx ) extent[ 0x%.12lx + "
-            "%.8ld ] count(%d) dealloc(0x%.12lx) %s\n";
-      } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
-        format_string =
-            "%s addr( 0x%.12llx ) list( 0x%.12llx 0x%.12llx ) extent[ "
-            "0x%.12llx + %.8ld ] count(%d) dealloc(0x%.12llx) %s\n";
-      }
+      s << space_name << " addr( " << KOKKOS_PAD_HEX(r) << " ) list ( "
+        << KOKKOS_PAD_HEX(r->m_prev) << ' ' << KOKKOS_PAD_HEX(r->m_next)
+        << " ) extent[ " << KOKKOS_PAD_HEX(r->m_alloc_ptr) << " + " << std::dec
+        << std::setw(8) << r->m_alloc_size << " ] count(" << r->use_count()
+        << ") dealloc(" << KOKKOS_PAD_HEX(r->m_dealloc) << ") "
+        << r->m_alloc_ptr->m_label << '\n';
 
-      snprintf(buffer, 256, format_string, space_name,
-               reinterpret_cast<uintptr_t>(r),
-               reinterpret_cast<uintptr_t>(r->m_prev),
-               reinterpret_cast<uintptr_t>(r->m_next),
-               reinterpret_cast<uintptr_t>(r->m_alloc_ptr), r->m_alloc_size,
-               r->use_count(), reinterpret_cast<uintptr_t>(r->m_dealloc),
-               r->m_alloc_ptr->m_label);
-      s << buffer;
       r = r->m_next;
     }
   } else {
     while (r != root) {
-      // Formatting dependent on sizeof(uintptr_t)
-      const char* format_string;
-
-      if (sizeof(uintptr_t) == sizeof(unsigned long)) {
-        format_string = "%s [ 0x%.12lx + %ld ] %s\n";
-      } else if (sizeof(uintptr_t) == sizeof(unsigned long long)) {
-        format_string = "%s [ 0x%.12llx + %ld ] %s\n";
-      }
-
-      snprintf(buffer, 256, format_string, space_name,
-               reinterpret_cast<uintptr_t>(r->data()), r->size(),
-               r->m_alloc_ptr->m_label);
-      s << buffer;
+      s << space_name << " [ " << KOKKOS_PAD_HEX(r->data()) << " + " << std::dec
+        << r->size() << " ] " << r->m_alloc_ptr->m_label << '\n';
       r = r->m_next;
     }
   }
+#undef KOKKOS_PAD_HEX
+  s.flags(saved_flags);
 }
 #else
 void SharedAllocationRecord<void, void>::print_host_accessible_records(
@@ -341,5 +323,18 @@ void SharedAllocationRecord<void, void>::print_host_accessible_records(
 }
 #endif
 
+void fill_host_accessible_header_info(
+    SharedAllocationRecord<void, void>* arg_record,
+    SharedAllocationHeader& arg_header, std::string const& arg_label) {
+  // Fill in the Header information, directly accessible on the host
+
+  arg_header.m_record = arg_record;
+
+  strncpy(arg_header.m_label, arg_label.c_str(),
+          SharedAllocationHeader::maximum_label_length);
+  // Set last element zero, in case c_str is too long
+  arg_header.m_label[SharedAllocationHeader::maximum_label_length - 1] = '\0';
+}
+
 } /* namespace Impl */
 } /* namespace Kokkos */
diff --git a/core/src/impl/Kokkos_SharedAlloc.hpp b/core/src/impl/Kokkos_SharedAlloc.hpp
index 6bb87ca84b..da03cc4983 100644
--- a/core/src/impl/Kokkos_SharedAlloc.hpp
+++ b/core/src/impl/Kokkos_SharedAlloc.hpp
@@ -37,7 +37,7 @@ class SharedAllocationHeader {
  private:
   using Record = SharedAllocationRecord<void, void>;
 
-#if defined(KOKKOS_ARCH_VEGA) || defined(KOKKOS_ARCH_NAVI)
+#if defined(KOKKOS_ARCH_AMD_GPU)
   static constexpr unsigned maximum_label_length =
       (1u << 8 /* 256 */) - sizeof(Record*);
 #else
@@ -51,6 +51,9 @@ class SharedAllocationHeader {
   friend class SharedAllocationRecordCommon;
   template <class>
   friend class HostInaccessibleSharedAllocationRecordCommon;
+  friend void fill_host_accessible_header_info(
+      SharedAllocationRecord<void, void>*, SharedAllocationHeader&,
+      std::string const&);
 
   Record* m_record;
   char m_label[maximum_label_length];
@@ -70,7 +73,7 @@ class SharedAllocationHeader {
 template <>
 class SharedAllocationRecord<void, void> {
  protected:
-#if defined(KOKKOS_ARCH_VEGA) || defined(KOKKOS_ARCH_NAVI)
+#if defined(KOKKOS_ARCH_AMD_GPU)
   static_assert(sizeof(SharedAllocationHeader) == (1u << 8 /* 256 */),
                 "sizeof(SharedAllocationHeader) != 256");
 #else
@@ -145,25 +148,23 @@ class SharedAllocationRecord<void, void> {
   SharedAllocationRecord()
       : m_alloc_ptr(nullptr),
         m_alloc_size(0),
-        m_dealloc(nullptr)
+        m_dealloc(nullptr),
 #ifdef KOKKOS_ENABLE_DEBUG
-        ,
         m_root(this),
         m_prev(this),
-        m_next(this)
+        m_next(this),
 #endif
-        ,
         m_count(0) {
   }
 
   static constexpr unsigned maximum_label_length =
       SharedAllocationHeader::maximum_label_length;
 
-  KOKKOS_INLINE_FUNCTION
+  KOKKOS_FUNCTION
   const SharedAllocationHeader* head() const { return m_alloc_ptr; }
 
   /* User's memory begins at the end of the header */
-  KOKKOS_INLINE_FUNCTION
+  KOKKOS_FUNCTION
   void* data() const { return static_cast<void*>(m_alloc_ptr + 1); }
 
   /* User's memory begins at the end of the header */
@@ -195,23 +196,64 @@ class SharedAllocationRecord<void, void> {
       const SharedAllocationRecord* const root, const bool detail);
 };
 
+template <class MemorySpace>
+SharedAllocationHeader* checked_allocation_with_header(MemorySpace const& space,
+                                                       std::string const& label,
+                                                       size_t alloc_size) {
+  return reinterpret_cast<SharedAllocationHeader*>(space.allocate(
+      label.c_str(), alloc_size + sizeof(SharedAllocationHeader), alloc_size));
+}
+
+template <class ExecutionSpace, class MemorySpace>
+SharedAllocationHeader* checked_allocation_with_header(
+    ExecutionSpace const& exec_space, MemorySpace const& space,
+    std::string const& label, size_t alloc_size) {
+  return reinterpret_cast<SharedAllocationHeader*>(
+      space.allocate(exec_space, label.c_str(),
+                     alloc_size + sizeof(SharedAllocationHeader), alloc_size));
+}
+
+void fill_host_accessible_header_info(SharedAllocationHeader& arg_header,
+                                      std::string const& arg_label);
+
 template <class MemorySpace>
 class SharedAllocationRecordCommon : public SharedAllocationRecord<void, void> {
  private:
   using derived_t     = SharedAllocationRecord<MemorySpace, void>;
   using record_base_t = SharedAllocationRecord<void, void>;
-  derived_t& self() { return *static_cast<derived_t*>(this); }
-  derived_t const& self() const { return *static_cast<derived_t const*>(this); }
 
  protected:
   using record_base_t::record_base_t;
 
-  void _fill_host_accessible_header_info(SharedAllocationHeader& arg_header,
-                                         std::string const& arg_label);
+  MemorySpace m_space;
+
+#ifdef KOKKOS_ENABLE_DEBUG
+  static record_base_t s_root_record;
+#endif
 
   static void deallocate(record_base_t* arg_rec);
 
  public:
+  ~SharedAllocationRecordCommon();
+  template <class ExecutionSpace>
+  SharedAllocationRecordCommon(
+      ExecutionSpace const& exec, MemorySpace const& space,
+      std::string const& label, std::size_t alloc_size,
+      record_base_t::function_type dealloc = &deallocate)
+      : SharedAllocationRecord<void, void>(
+#ifdef KOKKOS_ENABLE_DEBUG
+            &s_root_record,
+#endif
+            checked_allocation_with_header(exec, space, label, alloc_size),
+            sizeof(SharedAllocationHeader) + alloc_size, dealloc, label),
+        m_space(space) {
+    auto& header = *SharedAllocationRecord<void, void>::m_alloc_ptr;
+    fill_host_accessible_header_info(this, header, label);
+  }
+  SharedAllocationRecordCommon(
+      MemorySpace const& space, std::string const& label, std::size_t size,
+      record_base_t::function_type dealloc = &deallocate);
+
   static auto allocate(MemorySpace const& arg_space,
                        std::string const& arg_label, size_t arg_alloc_size)
       -> derived_t*;
@@ -231,27 +273,106 @@ class SharedAllocationRecordCommon : public SharedAllocationRecord<void, void> {
 
 template <class MemorySpace>
 class HostInaccessibleSharedAllocationRecordCommon
-    : public SharedAllocationRecordCommon<MemorySpace> {
+    : public SharedAllocationRecord<void, void> {
  private:
-  using base_t        = SharedAllocationRecordCommon<MemorySpace>;
   using derived_t     = SharedAllocationRecord<MemorySpace, void>;
   using record_base_t = SharedAllocationRecord<void, void>;
 
  protected:
-  using base_t::base_t;
+  using record_base_t::record_base_t;
+
+  MemorySpace m_space;
+
+#ifdef KOKKOS_ENABLE_DEBUG
+  static record_base_t s_root_record;
+#endif
+
+  static void deallocate(record_base_t* arg_rec);
 
  public:
+  ~HostInaccessibleSharedAllocationRecordCommon();
+  template <class ExecutionSpace>
+  HostInaccessibleSharedAllocationRecordCommon(
+      ExecutionSpace const& exec, MemorySpace const& space,
+      std::string const& label, std::size_t alloc_size,
+      record_base_t::function_type dealloc = &deallocate)
+      : SharedAllocationRecord<void, void>(
+#ifdef KOKKOS_ENABLE_DEBUG
+            &s_root_record,
+#endif
+            checked_allocation_with_header(exec, space, label, alloc_size),
+            sizeof(SharedAllocationHeader) + alloc_size, dealloc, label),
+        m_space(space) {
+    SharedAllocationHeader header;
+
+    fill_host_accessible_header_info(this, header, label);
+
+    Kokkos::Impl::DeepCopy<MemorySpace, HostSpace>(
+        exec, SharedAllocationRecord<void, void>::m_alloc_ptr, &header,
+        sizeof(SharedAllocationHeader));
+  }
+  HostInaccessibleSharedAllocationRecordCommon(
+      MemorySpace const& space, std::string const& label, std::size_t size,
+      record_base_t::function_type dealloc = &deallocate);
+
+  static auto allocate(MemorySpace const& arg_space,
+                       std::string const& arg_label, size_t arg_alloc_size)
+      -> derived_t*;
+  /**\brief  Allocate tracked memory in the space */
+  static void* allocate_tracked(MemorySpace const& arg_space,
+                                std::string const& arg_alloc_label,
+                                size_t arg_alloc_size);
+  /**\brief  Reallocate tracked memory in the space */
+  static void deallocate_tracked(void* arg_alloc_ptr);
+  /**\brief  Deallocate tracked memory in the space */
+  static void* reallocate_tracked(void* arg_alloc_ptr, size_t arg_alloc_size);
+
   static void print_records(std::ostream& s, MemorySpace const&,
                             bool detail = false);
   static auto get_record(void* alloc_ptr) -> derived_t*;
   std::string get_label() const;
 };
 
-namespace {
+#ifdef KOKKOS_ENABLE_DEBUG
+template <class MemorySpace>
+SharedAllocationRecord<void, void>
+    SharedAllocationRecordCommon<MemorySpace>::s_root_record;
+
+template <class MemorySpace>
+SharedAllocationRecord<void, void>
+    HostInaccessibleSharedAllocationRecordCommon<MemorySpace>::s_root_record;
+#endif
+
+#define KOKKOS_IMPL_SHARED_ALLOCATION_SPECIALIZATION(MEMORY_SPACE)        \
+  template <>                                                             \
+  class Kokkos::Impl::SharedAllocationRecord<MEMORY_SPACE, void>          \
+      : public Kokkos::Impl::SharedAllocationRecordCommon<MEMORY_SPACE> { \
+    using SharedAllocationRecordCommon<                                   \
+        MEMORY_SPACE>::SharedAllocationRecordCommon;                      \
+  }
+
+#define KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_SPECIALIZATION(    \
+    MEMORY_SPACE)                                                          \
+  template <>                                                              \
+  class Kokkos::Impl::SharedAllocationRecord<MEMORY_SPACE, void>           \
+      : public Kokkos::Impl::HostInaccessibleSharedAllocationRecordCommon< \
+            MEMORY_SPACE> {                                                \
+    using HostInaccessibleSharedAllocationRecordCommon<                    \
+        MEMORY_SPACE>::HostInaccessibleSharedAllocationRecordCommon;       \
+  }
+
+#define KOKKOS_IMPL_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION( \
+    MEMORY_SPACE)                                                    \
+  template class Kokkos::Impl::SharedAllocationRecordCommon<MEMORY_SPACE>
+
+#define KOKKOS_IMPL_HOST_INACCESSIBLE_SHARED_ALLOCATION_RECORD_EXPLICIT_INSTANTIATION( \
+    MEMORY_SPACE)                                                                      \
+  template class Kokkos::Impl::HostInaccessibleSharedAllocationRecordCommon<           \
+      MEMORY_SPACE>
 
 /* Taking the address of this function so make sure it is unique */
 template <class MemorySpace, class DestroyFunctor>
-void deallocate(SharedAllocationRecord<void, void>* record_ptr) {
+inline void deallocate(SharedAllocationRecord<void, void>* record_ptr) {
   using base_type = SharedAllocationRecord<MemorySpace, void>;
   using this_type = SharedAllocationRecord<MemorySpace, DestroyFunctor>;
 
@@ -263,8 +384,6 @@ void deallocate(SharedAllocationRecord<void, void>* record_ptr) {
   delete ptr;
 }
 
-}  // namespace
-
 /*
  *  Memory space specialization of SharedAllocationRecord< Space , void >
  * requires :
@@ -349,15 +468,21 @@ union SharedAllocationTracker {
   // pressure on compiler optimization by reducing
   // number of symbols and inline functions.
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT          \
-  KOKKOS_IF_ON_HOST((if (!(m_record_bits & DO_NOT_DEREF_FLAG)) { \
-    Record::increment(m_record);                                 \
-  }))
+#ifdef KOKKOS_ENABLE_IMPL_REF_COUNT_BRANCH_UNLIKELY
+#define KOKKOS_IMPL_BRANCH_PROB KOKKOS_IMPL_ATTRIBUTE_UNLIKELY
+#else
+#define KOKKOS_IMPL_BRANCH_PROB
+#endif
+
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT \
+  KOKKOS_IF_ON_HOST(                                    \
+      (if (!(m_record_bits & DO_NOT_DEREF_FLAG))        \
+           KOKKOS_IMPL_BRANCH_PROB { Record::increment(m_record); }))
 
-#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT          \
-  KOKKOS_IF_ON_HOST((if (!(m_record_bits & DO_NOT_DEREF_FLAG)) { \
-    Record::decrement(m_record);                                 \
-  }))
+#define KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT \
+  KOKKOS_IF_ON_HOST(                                    \
+      (if (!(m_record_bits & DO_NOT_DEREF_FLAG))        \
+           KOKKOS_IMPL_BRANCH_PROB { Record::decrement(m_record); }))
 
 #define KOKKOS_IMPL_SHARED_ALLOCATION_CARRY_RECORD_BITS(rhs,               \
                                                         override_tracking) \
@@ -504,8 +629,41 @@ union SharedAllocationTracker {
 
 #undef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_INCREMENT
 #undef KOKKOS_IMPL_SHARED_ALLOCATION_TRACKER_DECREMENT
+#undef KOKKOS_IMPL_BRANCH_PROB
 };
 
+struct SharedAllocationDisableTrackingGuard {
+  SharedAllocationDisableTrackingGuard() {
+    KOKKOS_ASSERT(
+        (Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_enabled()));
+    Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_disable();
+  }
+
+  SharedAllocationDisableTrackingGuard(
+      const SharedAllocationDisableTrackingGuard&) = delete;
+  SharedAllocationDisableTrackingGuard(SharedAllocationDisableTrackingGuard&&) =
+      delete;
+
+  ~SharedAllocationDisableTrackingGuard() {
+    KOKKOS_ASSERT((
+        !Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_enabled()));
+    Kokkos::Impl::SharedAllocationRecord<void, void>::tracking_enable();
+  }
+  // clang-format off
+  // The old version of clang format we use is particularly egregious here
+  SharedAllocationDisableTrackingGuard& operator=(
+      const SharedAllocationDisableTrackingGuard&) = delete;
+  SharedAllocationDisableTrackingGuard& operator=(
+      SharedAllocationDisableTrackingGuard&&) = delete;
+  // clang-format on
+};
+
+template <class FunctorType, class... Args>
+inline FunctorType construct_with_shared_allocation_tracking_disabled(
+    Args&&... args) {
+  [[maybe_unused]] auto guard = SharedAllocationDisableTrackingGuard{};
+  return {std::forward<Args>(args)...};
+}
 } /* namespace Impl */
 } /* namespace Kokkos */
 #endif
diff --git a/core/src/impl/Kokkos_SharedAlloc_timpl.hpp b/core/src/impl/Kokkos_SharedAlloc_timpl.hpp
index 9aa96e27d1..41036ab067 100644
--- a/core/src/impl/Kokkos_SharedAlloc_timpl.hpp
+++ b/core/src/impl/Kokkos_SharedAlloc_timpl.hpp
@@ -24,13 +24,73 @@
 
 #include <Kokkos_HostSpace.hpp>  // used with HostInaccessible specializations
 
-#include <string>    // std::string
-#include <cstring>   // strncpy
-#include <iostream>  // ostream
+#include <cstring>
+#include <ostream>
+#include <string>
 
 namespace Kokkos {
 namespace Impl {
 
+template <class MemorySpace>
+SharedAllocationRecordCommon<MemorySpace>::~SharedAllocationRecordCommon() {
+  auto alloc_ptr  = SharedAllocationRecord<void, void>::m_alloc_ptr;
+  auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
+  auto label      = SharedAllocationRecord<void, void>::m_label;
+  m_space.deallocate(label.c_str(), alloc_ptr, alloc_size,
+                     alloc_size - sizeof(SharedAllocationHeader));
+}
+template <class MemorySpace>
+HostInaccessibleSharedAllocationRecordCommon<
+    MemorySpace>::~HostInaccessibleSharedAllocationRecordCommon() {
+  auto alloc_ptr  = SharedAllocationRecord<void, void>::m_alloc_ptr;
+  auto alloc_size = SharedAllocationRecord<void, void>::m_alloc_size;
+  auto label      = SharedAllocationRecord<void, void>::m_label;
+  m_space.deallocate(label.c_str(), alloc_ptr, alloc_size,
+                     alloc_size - sizeof(SharedAllocationHeader));
+}
+
+template <class MemorySpace>
+SharedAllocationRecordCommon<MemorySpace>::SharedAllocationRecordCommon(
+    MemorySpace const& space, std::string const& label, std::size_t alloc_size,
+    SharedAllocationRecord<void, void>::function_type dealloc)
+    : SharedAllocationRecord<void, void>(
+#ifdef KOKKOS_ENABLE_DEBUG
+          &s_root_record,
+#endif
+          checked_allocation_with_header(space, label, alloc_size),
+          sizeof(SharedAllocationHeader) + alloc_size, dealloc, label),
+      m_space(space) {
+  auto& header = *SharedAllocationRecord<void, void>::m_alloc_ptr;
+  fill_host_accessible_header_info(this, header, label);
+}
+
+template <class MemorySpace>
+HostInaccessibleSharedAllocationRecordCommon<MemorySpace>::
+    HostInaccessibleSharedAllocationRecordCommon(
+        MemorySpace const& space, std::string const& label,
+        std::size_t alloc_size,
+        SharedAllocationRecord<void, void>::function_type dealloc)
+    : SharedAllocationRecord<void, void>(
+#ifdef KOKKOS_ENABLE_DEBUG
+          &s_root_record,
+#endif
+          checked_allocation_with_header(space, label, alloc_size),
+          sizeof(SharedAllocationHeader) + alloc_size, dealloc, label),
+      m_space(space) {
+  SharedAllocationHeader header;
+
+  fill_host_accessible_header_info(this, header, label);
+
+  typename MemorySpace::execution_space exec;
+  Kokkos::Impl::DeepCopy<MemorySpace, HostSpace>(
+      exec, SharedAllocationRecord<void, void>::m_alloc_ptr, &header,
+      sizeof(SharedAllocationHeader));
+  exec.fence(std::string("SharedAllocationRecord<Kokkos::") +
+             MemorySpace::name() +
+             "Space, void>::SharedAllocationRecord(): "
+             "fence after copying header from HostSpace");
+}
+
 template <class MemorySpace>
 auto SharedAllocationRecordCommon<MemorySpace>::allocate(
     MemorySpace const& arg_space, std::string const& arg_label,
@@ -76,9 +136,64 @@ void* SharedAllocationRecordCommon<MemorySpace>::reallocate_tracked(
 
   Kokkos::Impl::DeepCopy<MemorySpace, MemorySpace>(
       r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
-  Kokkos::fence(
-      "SharedAllocationRecord<Kokkos::Experimental::HBWSpace, "
-      "void>::reallocate_tracked(): fence after copying data");
+  Kokkos::fence(std::string("SharedAllocationRecord<") + MemorySpace::name() +
+                ", void>::reallocate_tracked(): fence after copying data");
+
+  record_base_t::increment(r_new);
+  record_base_t::decrement(r_old);
+
+  return r_new->data();
+}
+
+template <class MemorySpace>
+auto HostInaccessibleSharedAllocationRecordCommon<MemorySpace>::allocate(
+    MemorySpace const& arg_space, std::string const& arg_label,
+    size_t arg_alloc_size) -> derived_t* {
+  return new derived_t(arg_space, arg_label, arg_alloc_size);
+}
+
+template <class MemorySpace>
+void* HostInaccessibleSharedAllocationRecordCommon<
+    MemorySpace>::allocate_tracked(const MemorySpace& arg_space,
+                                   const std::string& arg_alloc_label,
+                                   size_t arg_alloc_size) {
+  if (!arg_alloc_size) return nullptr;
+
+  SharedAllocationRecord* const r =
+      allocate(arg_space, arg_alloc_label, arg_alloc_size);
+
+  record_base_t::increment(r);
+
+  return r->data();
+}
+
+template <class MemorySpace>
+void HostInaccessibleSharedAllocationRecordCommon<MemorySpace>::deallocate(
+    HostInaccessibleSharedAllocationRecordCommon::record_base_t* arg_rec) {
+  delete static_cast<derived_t*>(arg_rec);
+}
+
+template <class MemorySpace>
+void HostInaccessibleSharedAllocationRecordCommon<
+    MemorySpace>::deallocate_tracked(void* arg_alloc_ptr) {
+  if (arg_alloc_ptr != nullptr) {
+    SharedAllocationRecord* const r = derived_t::get_record(arg_alloc_ptr);
+    record_base_t::decrement(r);
+  }
+}
+
+template <class MemorySpace>
+void* HostInaccessibleSharedAllocationRecordCommon<
+    MemorySpace>::reallocate_tracked(void* arg_alloc_ptr,
+                                     size_t arg_alloc_size) {
+  derived_t* const r_old = derived_t::get_record(arg_alloc_ptr);
+  derived_t* const r_new =
+      allocate(r_old->m_space, r_old->get_label(), arg_alloc_size);
+
+  Kokkos::Impl::DeepCopy<MemorySpace, MemorySpace>(
+      r_new->data(), r_old->data(), std::min(r_old->size(), r_new->size()));
+  Kokkos::fence(std::string("SharedAllocationRecord<") + MemorySpace::name() +
+                ", void>::reallocate_tracked(): fence after copying data");
 
   record_base_t::increment(r_new);
   record_base_t::decrement(r_old);
@@ -108,20 +223,6 @@ std::string SharedAllocationRecordCommon<MemorySpace>::get_label() const {
   return record_base_t::m_label;
 }
 
-template <class MemorySpace>
-void SharedAllocationRecordCommon<MemorySpace>::
-    _fill_host_accessible_header_info(SharedAllocationHeader& arg_header,
-                                      std::string const& arg_label) {
-  // Fill in the Header information, directly accessible on the host
-
-  arg_header.m_record = &self();
-
-  strncpy(arg_header.m_label, arg_label.c_str(),
-          SharedAllocationHeader::maximum_label_length);
-  // Set last element zero, in case c_str is too long
-  arg_header.m_label[SharedAllocationHeader::maximum_label_length - 1] = '\0';
-}
-
 template <class MemorySpace>
 void SharedAllocationRecordCommon<MemorySpace>::print_records(
     std::ostream& s, const MemorySpace&, bool detail) {
diff --git a/core/src/impl/Kokkos_Spinwait.hpp b/core/src/impl/Kokkos_Spinwait.hpp
deleted file mode 100644
index c57b17d646..0000000000
--- a/core/src/impl/Kokkos_Spinwait.hpp
+++ /dev/null
@@ -1,109 +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_SPINWAIT_HPP
-#define KOKKOS_SPINWAIT_HPP
-
-#include <Kokkos_Macros.hpp>
-#include <Kokkos_Atomic.hpp>
-
-#include <cstdint>
-
-#include <type_traits>
-
-namespace Kokkos {
-namespace Impl {
-
-enum class WaitMode : int {
-  ACTIVE  // Used for tight loops to keep threads active longest
-  ,
-  PASSIVE  // Used to quickly yield the thread to quite down the system
-  ,
-  ROOT  // Never sleep or yield the root thread
-};
-
-void host_thread_yield(const uint32_t i, const WaitMode mode);
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, void> root_spinwait_while_equal(
-    T const volatile& flag, const T value) {
-  Kokkos::store_fence();
-  uint32_t i = 0;
-  while (value == flag) {
-    host_thread_yield(++i, WaitMode::ROOT);
-  }
-  Kokkos::load_fence();
-}
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, void> root_spinwait_until_equal(
-    T const volatile& flag, const T value) {
-  Kokkos::store_fence();
-  uint32_t i = 0;
-  while (value != flag) {
-    host_thread_yield(++i, WaitMode::ROOT);
-  }
-  Kokkos::load_fence();
-}
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, void> spinwait_while_equal(
-    T const volatile& flag, const T value) {
-  Kokkos::store_fence();
-  uint32_t i = 0;
-  while (value == flag) {
-    host_thread_yield(++i, WaitMode::ACTIVE);
-  }
-  Kokkos::load_fence();
-}
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, void> yield_while_equal(
-    T const volatile& flag, const T value) {
-  Kokkos::store_fence();
-  uint32_t i = 0;
-  while (value == flag) {
-    host_thread_yield(++i, WaitMode::PASSIVE);
-  }
-  Kokkos::load_fence();
-}
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, void> spinwait_until_equal(
-    T const volatile& flag, const T value) {
-  Kokkos::store_fence();
-  uint32_t i = 0;
-  while (value != flag) {
-    host_thread_yield(++i, WaitMode::ACTIVE);
-  }
-  Kokkos::load_fence();
-}
-
-template <typename T>
-std::enable_if_t<std::is_integral<T>::value, void> yield_until_equal(
-    T const volatile& flag, const T value) {
-  Kokkos::store_fence();
-  uint32_t i = 0;
-  while (value != flag) {
-    host_thread_yield(++i, WaitMode::PASSIVE);
-  }
-  Kokkos::load_fence();
-}
-
-} /* namespace Impl */
-} /* namespace Kokkos */
-
-#endif /* #ifndef KOKKOS_SPINWAIT_HPP */
diff --git a/core/src/impl/Kokkos_TaskQueueCommon.hpp b/core/src/impl/Kokkos_TaskQueueCommon.hpp
index 4ff9c6b700..3709d6e720 100644
--- a/core/src/impl/Kokkos_TaskQueueCommon.hpp
+++ b/core/src/impl/Kokkos_TaskQueueCommon.hpp
@@ -143,14 +143,14 @@ class TaskQueueCommonMixin {
  public:
   KOKKOS_INLINE_FUNCTION
   bool is_done() const noexcept {
-    // TODO @tasking @memory_order DSH Memory order, instead of volatile
-    return (*(volatile int*)(&m_ready_count)) == 0;
+    return desul::atomic_load(&m_ready_count, desul::MemoryOrderAcquire(),
+                              desul::MemoryScopeDevice()) == 0;
   }
 
   KOKKOS_INLINE_FUNCTION
   int32_t ready_count() const noexcept {
-    // TODO @tasking @memory_order DSH Memory order, instead of volatile
-    return (*(volatile int*)(&m_ready_count));
+    return desul::atomic_load(&m_ready_count, desul::MemoryOrderAcquire(),
+                              desul::MemoryScopeDevice());
   }
 
   template <class TaskQueueTraits, class TeamSchedulerInfo>
diff --git a/core/src/impl/Kokkos_TaskQueueMultiple.hpp b/core/src/impl/Kokkos_TaskQueueMultiple.hpp
index 39d70f331d..4ed057a689 100644
--- a/core/src/impl/Kokkos_TaskQueueMultiple.hpp
+++ b/core/src/impl/Kokkos_TaskQueueMultiple.hpp
@@ -119,7 +119,9 @@ class TaskQueueMultiple : public TaskQueue<ExecSpace, MemorySpace> {
         for (int iteam = 0; iteam < m_other_queues->size(); ++iteam) {
           if (iteam == m_league_rank) continue;
           auto& steal_from = get_team_queue(iteam);
-          if (*((volatile int*)&steal_from.m_ready_count) > 0) {
+          if (desul::atomic_load(&steal_from.m_ready_count,
+                                 desul::MemoryOrderAcquire(),
+                                 desul::MemoryScopeDevice()) > 0) {
             // we've found at least one queue that's not done, so even if we
             // can't pop something off of it we shouldn't return a nullptr
             // indicating completion.  rv will be end_tag when the pop fails
diff --git a/core/src/impl/Kokkos_Utilities.hpp b/core/src/impl/Kokkos_Utilities.hpp
index 67021c134c..cadeed1a6d 100644
--- a/core/src/impl/Kokkos_Utilities.hpp
+++ b/core/src/impl/Kokkos_Utilities.hpp
@@ -49,6 +49,11 @@ struct integral_constant {
 template <typename... Is>
 struct always_true : std::true_type {};
 
+// type-dependent expression that is always false intended for use in
+// static_assert to check "we should never get there"
+template <typename... Deps>
+struct always_false : std::false_type {};
+
 //==============================================================================
 
 #if defined(__cpp_lib_type_identity)
@@ -79,6 +84,33 @@ template <class T>
 using remove_cvref_t = typename remove_cvref<T>::type;
 #endif
 
+// same as C++23 std::to_underlying but with __host__ __device__ annotations
+template <typename E>
+KOKKOS_FUNCTION constexpr std::underlying_type_t<E> to_underlying(
+    E e) noexcept {
+  return static_cast<std::underlying_type_t<E>>(e);
+}
+
+#if defined(__cpp_lib_is_scoped_enum)
+// since C++23
+using std::is_scoped_enum;
+using std::is_scoped_enum_v;
+#else
+template <typename E, bool = std::is_enum_v<E>>
+struct is_scoped_enum_impl : std::false_type {};
+
+template <typename E>
+struct is_scoped_enum_impl<E, true>
+    : std::bool_constant<!std::is_convertible_v<E, std::underlying_type_t<E>>> {
+};
+
+template <typename E>
+struct is_scoped_enum : is_scoped_enum_impl<E>::type {};
+
+template <typename E>
+inline constexpr bool is_scoped_enum_v = is_scoped_enum<E>::value;
+#endif
+
 //==============================================================================
 // <editor-fold desc="is_specialization_of"> {{{1
 
diff --git a/core/src/impl/Kokkos_ViewArray.hpp b/core/src/impl/Kokkos_ViewArray.hpp
deleted file mode 100644
index 725ba5de09..0000000000
--- a/core/src/impl/Kokkos_ViewArray.hpp
+++ /dev/null
@@ -1,617 +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_EXPERIMENTAL_VIEW_ARRAY_MAPPING_HPP
-#define KOKKOS_EXPERIMENTAL_VIEW_ARRAY_MAPPING_HPP
-
-#include <Kokkos_Array.hpp>
-
-namespace Kokkos {
-namespace Impl {
-
-template <class DataType, class ArrayLayout, class V, size_t N, class P>
-struct ViewDataAnalysis<DataType, ArrayLayout, Kokkos::Array<V, N, P>> {
- private:
-  using array_analysis = ViewArrayAnalysis<DataType>;
-
-  static_assert(std::is_void<P>::value, "");
-  static_assert(std::is_same<typename array_analysis::non_const_value_type,
-                             Kokkos::Array<V, N, P>>::value,
-                "");
-  static_assert(std::is_scalar<V>::value,
-                "View of Array type must be of a scalar type");
-
- public:
-  using specialize = Kokkos::Array<>;
-
-  using dimension = typename array_analysis::dimension;
-
- private:
-  enum {
-    is_const = std::is_same<typename array_analysis::value_type,
-                            typename array_analysis::const_value_type>::value
-  };
-
-  using array_scalar_dimension = typename dimension::template append<N>::type;
-
-  using scalar_type           = std::conditional_t<is_const, const V, V>;
-  using non_const_scalar_type = V;
-  using const_scalar_type     = const V;
-
- public:
-  using value_type           = typename array_analysis::value_type;
-  using const_value_type     = typename array_analysis::const_value_type;
-  using non_const_value_type = typename array_analysis::non_const_value_type;
-
-  using type       = typename ViewDataType<value_type, dimension>::type;
-  using const_type = typename ViewDataType<const_value_type, dimension>::type;
-  using non_const_type =
-      typename ViewDataType<non_const_value_type, dimension>::type;
-
-  using scalar_array_type =
-      typename ViewDataType<scalar_type, array_scalar_dimension>::type;
-  using const_scalar_array_type =
-      typename ViewDataType<const_scalar_type, array_scalar_dimension>::type;
-  using non_const_scalar_array_type =
-      typename ViewDataType<non_const_scalar_type,
-                            array_scalar_dimension>::type;
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-/** \brief  View mapping for non-specialized data type and standard layout */
-template <class Traits>
-class ViewMapping<Traits, Kokkos::Array<>> {
- private:
-  template <class, class...>
-  friend class ViewMapping;
-  template <class, class...>
-  friend class Kokkos::View;
-
-  using offset_type = ViewOffset<typename Traits::dimension,
-                                 typename Traits::array_layout, void>;
-
-  using handle_type = typename Traits::value_type::pointer;
-
-  handle_type m_impl_handle;
-  offset_type m_impl_offset;
-  size_t m_stride = 0;
-
-  using scalar_type = typename Traits::value_type::value_type;
-
-  using contiguous_reference = Kokkos::Array<scalar_type, (~std::size_t(0)),
-                                             Kokkos::Array<>::contiguous>;
-  using strided_reference =
-      Kokkos::Array<scalar_type, (~std::size_t(0)), Kokkos::Array<>::strided>;
-
-  enum {
-    is_contiguous_reference =
-        (Traits::rank == 0) || (std::is_same<typename Traits::array_layout,
-                                             Kokkos::LayoutRight>::value)
-  };
-
-  enum { Array_N = Traits::value_type::size() };
-  enum { Array_S = is_contiguous_reference ? Array_N : 1 };
-
-  KOKKOS_INLINE_FUNCTION
-  ViewMapping(const handle_type &arg_handle, const offset_type &arg_offset)
-      : m_impl_handle(arg_handle),
-        m_impl_offset(arg_offset),
-        m_stride(is_contiguous_reference ? 0 : arg_offset.span()) {}
-
- public:
-  //----------------------------------------
-  // Domain dimensions
-
-  static constexpr unsigned Rank = Traits::dimension::rank;
-
-  template <typename iType>
-  KOKKOS_INLINE_FUNCTION constexpr size_t extent(const iType &r) const {
-    return m_impl_offset.m_dim.extent(r);
-  }
-
-  KOKKOS_INLINE_FUNCTION constexpr typename Traits::array_layout layout()
-      const {
-    return m_impl_offset.layout();
-  }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_0() const {
-    return m_impl_offset.dimension_0();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_1() const {
-    return m_impl_offset.dimension_1();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_2() const {
-    return m_impl_offset.dimension_2();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_3() const {
-    return m_impl_offset.dimension_3();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_4() const {
-    return m_impl_offset.dimension_4();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_5() const {
-    return m_impl_offset.dimension_5();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_6() const {
-    return m_impl_offset.dimension_6();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t dimension_7() const {
-    return m_impl_offset.dimension_7();
-  }
-
-  // Is a regular layout with uniform striding for each index.
-  using is_regular = typename offset_type::is_regular;
-
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_0() const {
-    return m_impl_offset.stride_0();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_1() const {
-    return m_impl_offset.stride_1();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_2() const {
-    return m_impl_offset.stride_2();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_3() const {
-    return m_impl_offset.stride_3();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_4() const {
-    return m_impl_offset.stride_4();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_5() const {
-    return m_impl_offset.stride_5();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_6() const {
-    return m_impl_offset.stride_6();
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_t stride_7() const {
-    return m_impl_offset.stride_7();
-  }
-
-  //----------------------------------------
-  // Range span
-
-  /** \brief  Span of the mapped range */
-  KOKKOS_INLINE_FUNCTION constexpr size_t span() const {
-    return m_impl_offset.span() * Array_N;
-  }
-
-  /** \brief  Is the mapped range span contiguous */
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
-    return m_impl_offset.span_is_contiguous();
-  }
-
-  using reference_type =
-      std::conditional_t<is_contiguous_reference, contiguous_reference,
-                         strided_reference>;
-
-  using pointer_type = handle_type;
-
-  /** \brief  If data references are lvalue_reference than can query pointer to
-   * memory */
-  KOKKOS_INLINE_FUNCTION constexpr pointer_type data() const {
-    return m_impl_handle;
-  }
-
-  //----------------------------------------
-  // The View class performs all rank and bounds checking before
-  // calling these element reference methods.
-
-  KOKKOS_FORCEINLINE_FUNCTION
-  reference_type reference() const {
-    return reference_type(m_impl_handle + 0, Array_N, 0);
-  }
-
-  template <typename I0>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0) const {
-    return reference_type(m_impl_handle + m_impl_offset(i0) * Array_S, Array_N,
-                          m_stride);
-  }
-
-  template <typename I0, typename I1>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0,
-                                                       const I1 &i1) const {
-    return reference_type(m_impl_handle + m_impl_offset(i0, i1) * Array_S,
-                          Array_N, m_stride);
-  }
-
-  template <typename I0, typename I1, typename I2>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0,
-                                                       const I1 &i1,
-                                                       const I2 &i2) const {
-    return reference_type(m_impl_handle + m_impl_offset(i0, i1, i2) * Array_S,
-                          Array_N, m_stride);
-  }
-
-  template <typename I0, typename I1, typename I2, typename I3>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type
-  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3) const {
-    return reference_type(
-        m_impl_handle + m_impl_offset(i0, i1, i2, i3) * Array_S, Array_N,
-        m_stride);
-  }
-
-  template <typename I0, typename I1, typename I2, typename I3, typename I4>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type reference(const I0 &i0,
-                                                       const I1 &i1,
-                                                       const I2 &i2,
-                                                       const I3 &i3,
-                                                       const I4 &i4) const {
-    return reference_type(
-        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4) * Array_S, Array_N,
-        m_stride);
-  }
-
-  template <typename I0, typename I1, typename I2, typename I3, typename I4,
-            typename I5>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type
-  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3,
-            const I4 &i4, const I5 &i5) const {
-    return reference_type(
-        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4, i5) * Array_S,
-        Array_N, m_stride);
-  }
-
-  template <typename I0, typename I1, typename I2, typename I3, typename I4,
-            typename I5, typename I6>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type
-  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3,
-            const I4 &i4, const I5 &i5, const I6 &i6) const {
-    return reference_type(
-        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4, i5, i6) * Array_S,
-        Array_N, m_stride);
-  }
-
-  template <typename I0, typename I1, typename I2, typename I3, typename I4,
-            typename I5, typename I6, typename I7>
-  KOKKOS_FORCEINLINE_FUNCTION reference_type
-  reference(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3,
-            const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7) const {
-    return reference_type(
-        m_impl_handle + m_impl_offset(i0, i1, i2, i3, i4, i5, i6, i7) * Array_S,
-        Array_N, m_stride);
-  }
-
-  //----------------------------------------
-
- private:
-  enum { MemorySpanMask = 8 - 1 /* Force alignment on 8 byte boundary */ };
-  enum { MemorySpanSize = sizeof(scalar_type) };
-
- public:
-  /** \brief  Span, in bytes, of the referenced memory */
-  KOKKOS_INLINE_FUNCTION constexpr size_t memory_span() const {
-    return (m_impl_offset.span() * Array_N * MemorySpanSize + MemorySpanMask) &
-           ~size_t(MemorySpanMask);
-  }
-
-  //----------------------------------------
-
-  KOKKOS_DEFAULTED_FUNCTION ViewMapping() = default;
-
-  //----------------------------------------
-
-  template <class... Args>
-  KOKKOS_INLINE_FUNCTION ViewMapping(pointer_type ptr, Args... args)
-      : m_impl_handle(ptr),
-        m_impl_offset(std::integral_constant<unsigned, 0>(), args...),
-        m_stride(m_impl_offset.span()) {}
-
-  //----------------------------------------
-
-  template <class... P>
-  Kokkos::Impl::SharedAllocationRecord<> *allocate_shared(
-      Kokkos::Impl::ViewCtorProp<P...> const &arg_prop,
-      typename Traits::array_layout const &arg_layout,
-      bool execution_space_specified) {
-    using alloc_prop = Kokkos::Impl::ViewCtorProp<P...>;
-
-    using execution_space = typename alloc_prop::execution_space;
-    using memory_space    = typename Traits::memory_space;
-    static_assert(
-        SpaceAccessibility<execution_space, memory_space>::accessible);
-    using functor_type =
-        ViewValueFunctor<typename Traits::device_type, scalar_type>;
-    using record_type =
-        Kokkos::Impl::SharedAllocationRecord<memory_space, functor_type>;
-
-    // Query the mapping for byte-size of allocation.
-    using padding = std::integral_constant<
-        unsigned int, alloc_prop::allow_padding ? sizeof(scalar_type) : 0>;
-
-    m_impl_offset = offset_type(padding(), arg_layout);
-
-    const size_t alloc_size =
-        (m_impl_offset.span() * Array_N * MemorySpanSize + MemorySpanMask) &
-        ~size_t(MemorySpanMask);
-    const auto &alloc_name = Impl::get_property<Impl::LabelTag>(arg_prop);
-    const execution_space &exec_space =
-        Impl::get_property<Impl::ExecutionSpaceTag>(arg_prop);
-    const memory_space &mem_space =
-        Impl::get_property<Impl::MemorySpaceTag>(arg_prop);
-
-    // Allocate memory from the memory space and create tracking record.
-    record_type *const record =
-        execution_space_specified
-            ? record_type::allocate(exec_space, mem_space, alloc_name,
-                                    alloc_size)
-            : record_type::allocate(mem_space, alloc_name, alloc_size);
-
-    m_impl_handle = handle_type(reinterpret_cast<pointer_type>(record->data()));
-
-    functor_type functor =
-        execution_space_specified
-            ? functor_type(exec_space, (pointer_type)m_impl_handle,
-                           m_impl_offset.span() * Array_N, alloc_name)
-            : functor_type((pointer_type)m_impl_handle,
-                           m_impl_offset.span() * Array_N, alloc_name);
-
-#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) || \
-    defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENMPTARGET)
-    if (false) {
-      // Make sure the destroy functor gets instantiated.
-      // This avoids "cudaErrorInvalidDeviceFunction"-type errors.
-      functor.destroy_shared_allocation();
-    }
-#endif
-
-    //  Only initialize if the allocation is non-zero.
-    //  May be zero if one of the dimensions is zero.
-    if constexpr (alloc_prop::initialize)
-      if (alloc_size) {
-        // Assume destruction is only required when construction is requested.
-        // The ViewValueFunctor has both value construction and destruction
-        // operators.
-        record->m_destroy = std::move(functor);
-
-        // Construct values
-        record->m_destroy.construct_shared_allocation();
-      }
-
-    return record;
-  }
-};
-
-/** \brief Assign Array to non-Array */
-
-template <class DstTraits, class SrcTraits>
-class ViewMapping<
-    DstTraits, SrcTraits,
-    std::enable_if_t<(
-        std::is_same<typename DstTraits::memory_space,
-                     typename SrcTraits::memory_space>::value &&
-        std::is_void<typename DstTraits::specialize>::value &&
-        (std::is_same<typename DstTraits::array_layout,
-                      Kokkos::LayoutLeft>::value ||
-         std::is_same<typename DstTraits::array_layout,
-                      Kokkos::LayoutRight>::value ||
-         std::is_same<typename DstTraits::array_layout,
-                      Kokkos::LayoutStride>::value) &&
-        std::is_same<typename SrcTraits::specialize, Kokkos::Array<>>::value &&
-        (std::is_same<typename SrcTraits::array_layout,
-                      Kokkos::LayoutLeft>::value ||
-         std::is_same<typename SrcTraits::array_layout,
-                      Kokkos::LayoutRight>::value ||
-         std::is_same<typename SrcTraits::array_layout,
-                      Kokkos::LayoutStride>::value))>> {
- public:
-  // Can only convert to View::array_type
-
-  enum {
-    is_assignable_data_type =
-        std::is_same<typename DstTraits::data_type,
-                     typename SrcTraits::scalar_array_type>::value &&
-        (DstTraits::rank == SrcTraits::rank + 1)
-  };
-  enum {
-    is_assignable =
-        std::is_same<typename DstTraits::data_type,
-                     typename SrcTraits::scalar_array_type>::value &&
-        std::is_same<typename DstTraits::array_layout,
-                     typename SrcTraits::array_layout>::value
-  };
-
-  using TrackType = Kokkos::Impl::SharedAllocationTracker;
-  using DstType   = ViewMapping<DstTraits, void>;
-  using SrcType   = ViewMapping<SrcTraits, Kokkos::Array<>>;
-
-  KOKKOS_INLINE_FUNCTION
-  static void assign(DstType &dst, const SrcType &src,
-                     const TrackType & /*src_track*/) {
-    static_assert(is_assignable, "Can only convert to array_type");
-
-    using dst_offset_type = typename DstType::offset_type;
-
-    // Array dimension becomes the last dimension.
-    // Arguments beyond the destination rank are ignored.
-    if (src.span_is_contiguous()) {  // not padded
-      dst.m_impl_offset = dst_offset_type(
-          std::integral_constant<unsigned, 0>(),
-          typename DstTraits::array_layout(
-              (0 < SrcType::Rank ? src.dimension_0()
-                                 : SrcTraits::value_type::size()),
-              (1 < SrcType::Rank ? src.dimension_1()
-                                 : SrcTraits::value_type::size()),
-              (2 < SrcType::Rank ? src.dimension_2()
-                                 : SrcTraits::value_type::size()),
-              (3 < SrcType::Rank ? src.dimension_3()
-                                 : SrcTraits::value_type::size()),
-              (4 < SrcType::Rank ? src.dimension_4()
-                                 : SrcTraits::value_type::size()),
-              (5 < SrcType::Rank ? src.dimension_5()
-                                 : SrcTraits::value_type::size()),
-              (6 < SrcType::Rank ? src.dimension_6()
-                                 : SrcTraits::value_type::size()),
-              (7 < SrcType::Rank ? src.dimension_7()
-                                 : SrcTraits::value_type::size())));
-    } else {  // is padded
-      using padded = std::integral_constant<
-          unsigned int, sizeof(typename SrcTraits::value_type::value_type)>;
-
-      dst.m_impl_offset = dst_offset_type(
-          padded(), typename DstTraits::array_layout(
-                        (0 < SrcType::Rank ? src.dimension_0()
-                                           : SrcTraits::value_type::size()),
-                        (1 < SrcType::Rank ? src.dimension_1()
-                                           : SrcTraits::value_type::size()),
-                        (2 < SrcType::Rank ? src.dimension_2()
-                                           : SrcTraits::value_type::size()),
-                        (3 < SrcType::Rank ? src.dimension_3()
-                                           : SrcTraits::value_type::size()),
-                        (4 < SrcType::Rank ? src.dimension_4()
-                                           : SrcTraits::value_type::size()),
-                        (5 < SrcType::Rank ? src.dimension_5()
-                                           : SrcTraits::value_type::size()),
-                        (6 < SrcType::Rank ? src.dimension_6()
-                                           : SrcTraits::value_type::size()),
-                        (7 < SrcType::Rank ? src.dimension_7()
-                                           : SrcTraits::value_type::size())));
-    }
-
-    dst.m_impl_handle = src.m_impl_handle;
-  }
-};
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-template <class SrcTraits, class... Args>
-class ViewMapping<
-    std::enable_if_t<(
-        std::is_same<typename SrcTraits::specialize, Kokkos::Array<>>::value &&
-        (std::is_same<typename SrcTraits::array_layout,
-                      Kokkos::LayoutLeft>::value ||
-         std::is_same<typename SrcTraits::array_layout,
-                      Kokkos::LayoutRight>::value ||
-         std::is_same<typename SrcTraits::array_layout,
-                      Kokkos::LayoutStride>::value))>,
-    SrcTraits, Args...> {
- private:
-  static_assert(SrcTraits::rank == sizeof...(Args), "");
-
-  enum : bool {
-    R0 = is_integral_extent<0, Args...>::value,
-    R1 = is_integral_extent<1, Args...>::value,
-    R2 = is_integral_extent<2, Args...>::value,
-    R3 = is_integral_extent<3, Args...>::value,
-    R4 = is_integral_extent<4, Args...>::value,
-    R5 = is_integral_extent<5, Args...>::value,
-    R6 = is_integral_extent<6, Args...>::value,
-    R7 = is_integral_extent<7, Args...>::value
-  };
-
-  enum {
-    rank = unsigned(R0) + unsigned(R1) + unsigned(R2) + unsigned(R3) +
-           unsigned(R4) + unsigned(R5) + unsigned(R6) + unsigned(R7)
-  };
-
-  // Whether right-most rank is a range.
-  enum {
-    R0_rev =
-        0 == SrcTraits::rank
-            ? false
-            : (1 == SrcTraits::rank
-                   ? R0
-                   : (2 == SrcTraits::rank
-                          ? R1
-                          : (3 == SrcTraits::rank
-                                 ? R2
-                                 : (4 == SrcTraits::rank
-                                        ? R3
-                                        : (5 == SrcTraits::rank
-                                               ? R4
-                                               : (6 == SrcTraits::rank
-                                                      ? R5
-                                                      : (7 == SrcTraits::rank
-                                                             ? R6
-                                                             : R7)))))))
-  };
-
-  // Subview's layout
-  using array_layout =
-      std::conditional_t<((rank == 0) ||
-                          (rank <= 2 && R0 &&
-                           std::is_same<typename SrcTraits::array_layout,
-                                        Kokkos::LayoutLeft>::value) ||
-                          (rank <= 2 && R0_rev &&
-                           std::is_same<typename SrcTraits::array_layout,
-                                        Kokkos::LayoutRight>::value)),
-                         typename SrcTraits::array_layout,
-                         Kokkos::LayoutStride>;
-
-  using value_type = typename SrcTraits::value_type;
-
-  using data_type = std::conditional_t<
-      rank == 0, value_type,
-      std::conditional_t<
-          rank == 1, value_type *,
-          std::conditional_t<
-              rank == 2, value_type **,
-              std::conditional_t<
-                  rank == 3, value_type ***,
-                  std::conditional_t<
-                      rank == 4, value_type ****,
-                      std::conditional_t<
-                          rank == 5, value_type *****,
-                          std::conditional_t<
-                              rank == 6, value_type ******,
-                              std::conditional_t<rank == 7, value_type *******,
-                                                 value_type ********>>>>>>>>;
-
- public:
-  using traits_type = Kokkos::ViewTraits<data_type, array_layout,
-                                         typename SrcTraits::device_type,
-                                         typename SrcTraits::memory_traits>;
-
-  using type =
-      Kokkos::View<data_type, array_layout, typename SrcTraits::device_type,
-                   typename SrcTraits::memory_traits>;
-
-  KOKKOS_INLINE_FUNCTION
-  static void assign(ViewMapping<traits_type, void> &dst,
-                     ViewMapping<SrcTraits, void> const &src, Args... args) {
-    using DstType = ViewMapping<traits_type, void>;
-
-    using dst_offset_type = typename DstType::offset_type;
-    using dst_handle_type = typename DstType::handle_type;
-
-    const SubviewExtents<SrcTraits::rank, rank> extents(src.m_impl_offset.m_dim,
-                                                        args...);
-
-    dst.m_impl_offset = dst_offset_type(src.m_impl_offset, extents);
-    dst.m_impl_handle = dst_handle_type(
-        src.m_impl_handle +
-        src.m_impl_offset(extents.domain_offset(0), extents.domain_offset(1),
-                          extents.domain_offset(2), extents.domain_offset(3),
-                          extents.domain_offset(4), extents.domain_offset(5),
-                          extents.domain_offset(6), extents.domain_offset(7)));
-  }
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_EXPERIMENTAL_VIEW_ARRAY_MAPPING_HPP */
diff --git a/core/src/impl/Kokkos_ViewDataAnalysis.hpp b/core/src/impl/Kokkos_ViewDataAnalysis.hpp
new file mode 100644
index 0000000000..04c0c9aeed
--- /dev/null
+++ b/core/src/impl/Kokkos_ViewDataAnalysis.hpp
@@ -0,0 +1,402 @@
+//@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
+static_assert(false,
+              "Including non-public Kokkos header files is not allowed.");
+#endif
+
+#ifndef KOKKOS_VIEW_DATA_ANALYSIS_HPP
+#define KOKKOS_VIEW_DATA_ANALYSIS_HPP
+
+#include <Kokkos_Macros.hpp>
+
+namespace Kokkos::Impl {
+
+template <unsigned I, size_t... Args>
+struct variadic_size_t {
+  enum : size_t { value = KOKKOS_INVALID_INDEX };
+};
+
+template <size_t Val, size_t... Args>
+struct variadic_size_t<0, Val, Args...> {
+  enum : size_t { value = Val };
+};
+
+template <unsigned I, size_t Val, size_t... Args>
+struct variadic_size_t<I, Val, Args...> {
+  enum : size_t { value = variadic_size_t<I - 1, Args...>::value };
+};
+
+template <size_t... Args>
+struct rank_dynamic;
+
+template <>
+struct rank_dynamic<> {
+  enum : unsigned { value = 0 };
+};
+
+template <size_t Val, size_t... Args>
+struct rank_dynamic<Val, Args...> {
+  enum : unsigned { value = (Val == 0 ? 1 : 0) + rank_dynamic<Args...>::value };
+};
+
+#define KOKKOS_IMPL_VIEW_DIMENSION(R)                                       \
+  template <size_t V, unsigned>                                             \
+  struct ViewDimension##R {                                                 \
+    static constexpr size_t ArgN##R = (V != KOKKOS_INVALID_INDEX ? V : 1);  \
+    static constexpr size_t N##R    = (V != KOKKOS_INVALID_INDEX ? V : 1);  \
+    KOKKOS_INLINE_FUNCTION explicit ViewDimension##R(size_t) {}             \
+    ViewDimension##R()                        = default;                    \
+    ViewDimension##R(const ViewDimension##R&) = default;                    \
+    ViewDimension##R& operator=(const ViewDimension##R&) = default;         \
+  };                                                                        \
+  template <size_t V, unsigned RD>                                          \
+  constexpr size_t ViewDimension##R<V, RD>::ArgN##R;                        \
+  template <size_t V, unsigned RD>                                          \
+  constexpr size_t ViewDimension##R<V, RD>::N##R;                           \
+  template <unsigned RD>                                                    \
+  struct ViewDimension##R<0u, RD> {                                         \
+    static constexpr size_t ArgN##R = 0;                                    \
+    std::conditional_t<(RD < 3), size_t, unsigned> N##R;                    \
+    ViewDimension##R()                        = default;                    \
+    ViewDimension##R(const ViewDimension##R&) = default;                    \
+    ViewDimension##R& operator=(const ViewDimension##R&) = default;         \
+    KOKKOS_INLINE_FUNCTION explicit ViewDimension##R(size_t V) : N##R(V) {} \
+  };                                                                        \
+  template <unsigned RD>                                                    \
+  constexpr size_t ViewDimension##R<0u, RD>::ArgN##R;
+
+KOKKOS_IMPL_VIEW_DIMENSION(0)
+KOKKOS_IMPL_VIEW_DIMENSION(1)
+KOKKOS_IMPL_VIEW_DIMENSION(2)
+KOKKOS_IMPL_VIEW_DIMENSION(3)
+KOKKOS_IMPL_VIEW_DIMENSION(4)
+KOKKOS_IMPL_VIEW_DIMENSION(5)
+KOKKOS_IMPL_VIEW_DIMENSION(6)
+KOKKOS_IMPL_VIEW_DIMENSION(7)
+
+#undef KOKKOS_IMPL_VIEW_DIMENSION
+
+// MSVC does not do empty base class optimization by default.
+// Per standard it is required for standard layout types
+template <size_t... Vals>
+struct KOKKOS_IMPL_ENFORCE_EMPTY_BASE_OPTIMIZATION ViewDimension
+    : public ViewDimension0<variadic_size_t<0u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension1<variadic_size_t<1u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension2<variadic_size_t<2u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension3<variadic_size_t<3u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension4<variadic_size_t<4u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension5<variadic_size_t<5u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension6<variadic_size_t<6u, Vals...>::value,
+                            rank_dynamic<Vals...>::value>,
+      public ViewDimension7<variadic_size_t<7u, Vals...>::value,
+                            rank_dynamic<Vals...>::value> {
+  using D0 = ViewDimension0<variadic_size_t<0U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D1 = ViewDimension1<variadic_size_t<1U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D2 = ViewDimension2<variadic_size_t<2U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D3 = ViewDimension3<variadic_size_t<3U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D4 = ViewDimension4<variadic_size_t<4U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D5 = ViewDimension5<variadic_size_t<5U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D6 = ViewDimension6<variadic_size_t<6U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+  using D7 = ViewDimension7<variadic_size_t<7U, Vals...>::value,
+                            rank_dynamic<Vals...>::value>;
+
+  using D0::ArgN0;
+  using D1::ArgN1;
+  using D2::ArgN2;
+  using D3::ArgN3;
+  using D4::ArgN4;
+  using D5::ArgN5;
+  using D6::ArgN6;
+  using D7::ArgN7;
+
+  using D0::N0;
+  using D1::N1;
+  using D2::N2;
+  using D3::N3;
+  using D4::N4;
+  using D5::N5;
+  using D6::N6;
+  using D7::N7;
+
+  static constexpr unsigned rank         = sizeof...(Vals);
+  static constexpr unsigned rank_dynamic = Impl::rank_dynamic<Vals...>::value;
+
+  ViewDimension()                     = default;
+  ViewDimension(const ViewDimension&) = default;
+  ViewDimension& operator=(const ViewDimension&) = default;
+
+  KOKKOS_INLINE_FUNCTION
+  constexpr ViewDimension(size_t n0, size_t n1, size_t n2, size_t n3, size_t n4,
+                          size_t n5, size_t n6, size_t n7)
+      : D0(n0 == KOKKOS_INVALID_INDEX ? 1 : n0),
+        D1(n1 == KOKKOS_INVALID_INDEX ? 1 : n1),
+        D2(n2 == KOKKOS_INVALID_INDEX ? 1 : n2),
+        D3(n3 == KOKKOS_INVALID_INDEX ? 1 : n3),
+        D4(n4 == KOKKOS_INVALID_INDEX ? 1 : n4),
+        D5(n5 == KOKKOS_INVALID_INDEX ? 1 : n5),
+        D6(n6 == KOKKOS_INVALID_INDEX ? 1 : n6),
+        D7(n7 == KOKKOS_INVALID_INDEX ? 1 : n7) {}
+
+  KOKKOS_INLINE_FUNCTION
+  constexpr size_t extent(const unsigned r) const noexcept {
+    return r == 0
+               ? N0
+               : (r == 1
+                      ? N1
+                      : (r == 2
+                             ? N2
+                             : (r == 3
+                                    ? N3
+                                    : (r == 4
+                                           ? N4
+                                           : (r == 5
+                                                  ? N5
+                                                  : (r == 6
+                                                         ? N6
+                                                         : (r == 7 ? N7
+                                                                   : 0)))))));
+  }
+
+  static KOKKOS_INLINE_FUNCTION constexpr size_t static_extent(
+      const unsigned r) noexcept {
+    return r == 0
+               ? ArgN0
+               : (r == 1
+                      ? ArgN1
+                      : (r == 2
+                             ? ArgN2
+                             : (r == 3
+                                    ? ArgN3
+                                    : (r == 4
+                                           ? ArgN4
+                                           : (r == 5
+                                                  ? ArgN5
+                                                  : (r == 6
+                                                         ? ArgN6
+                                                         : (r == 7 ? ArgN7
+                                                                   : 0)))))));
+  }
+
+  template <size_t N>
+  struct prepend {
+    using type = ViewDimension<N, Vals...>;
+  };
+
+  template <size_t N>
+  struct append {
+    using type = ViewDimension<Vals..., N>;
+  };
+};
+
+template <class A, class B>
+struct ViewDimensionJoin;
+
+template <size_t... A, size_t... B>
+struct ViewDimensionJoin<ViewDimension<A...>, ViewDimension<B...>> {
+  using type = ViewDimension<A..., B...>;
+};
+
+//----------------------------------------------------------------------------
+
+template <class DstDim, class SrcDim>
+struct ViewDimensionAssignable;
+
+template <size_t... DstArgs, size_t... SrcArgs>
+struct ViewDimensionAssignable<ViewDimension<DstArgs...>,
+                               ViewDimension<SrcArgs...>> {
+  using dst = ViewDimension<DstArgs...>;
+  using src = ViewDimension<SrcArgs...>;
+
+  enum {
+    value = unsigned(dst::rank) == unsigned(src::rank) &&
+            (
+                // Compile time check that potential static dimensions match
+                ((1 > dst::rank_dynamic && 1 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN0) == size_t(src::ArgN0))
+                     : true) &&
+                ((2 > dst::rank_dynamic && 2 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN1) == size_t(src::ArgN1))
+                     : true) &&
+                ((3 > dst::rank_dynamic && 3 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN2) == size_t(src::ArgN2))
+                     : true) &&
+                ((4 > dst::rank_dynamic && 4 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN3) == size_t(src::ArgN3))
+                     : true) &&
+                ((5 > dst::rank_dynamic && 5 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN4) == size_t(src::ArgN4))
+                     : true) &&
+                ((6 > dst::rank_dynamic && 6 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN5) == size_t(src::ArgN5))
+                     : true) &&
+                ((7 > dst::rank_dynamic && 7 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN6) == size_t(src::ArgN6))
+                     : true) &&
+                ((8 > dst::rank_dynamic && 8 > src::rank_dynamic)
+                     ? (size_t(dst::ArgN7) == size_t(src::ArgN7))
+                     : true))
+  };
+};
+
+/** \brief  Given a value type and dimension generate the View data type */
+template <class T, class Dim>
+struct ViewDataType;
+
+template <class T>
+struct ViewDataType<T, ViewDimension<>> {
+  using type = T;
+};
+
+template <class T, size_t... Args>
+struct ViewDataType<T, ViewDimension<0, Args...>> {
+  using type = typename ViewDataType<T*, ViewDimension<Args...>>::type;
+};
+
+template <class T, size_t N, size_t... Args>
+struct ViewDataType<T, ViewDimension<N, Args...>> {
+  using type = typename ViewDataType<T, ViewDimension<Args...>>::type[N];
+};
+
+/**\brief  Analysis of View data type.
+ *
+ *  Data type conforms to one of the following patterns :
+ *    {const} value_type [][#][#][#]
+ *    {const} value_type ***[#][#][#]
+ *  Where the sum of counts of '*' and '[#]' is at most ten.
+ *
+ *  Provide alias for ViewDimension<...> and value_type.
+ */
+template <class T>
+struct ViewArrayAnalysis {
+  using value_type           = T;
+  using const_value_type     = std::add_const_t<T>;
+  using non_const_value_type = std::remove_const_t<T>;
+  using static_dimension     = ViewDimension<>;
+  using dynamic_dimension    = ViewDimension<>;
+  using dimension            = ViewDimension<>;
+};
+
+template <class T, size_t N>
+struct ViewArrayAnalysis<T[N]> {
+ private:
+  using nested = ViewArrayAnalysis<T>;
+
+ public:
+  using value_type           = typename nested::value_type;
+  using const_value_type     = typename nested::const_value_type;
+  using non_const_value_type = typename nested::non_const_value_type;
+
+  using static_dimension =
+      typename nested::static_dimension::template prepend<N>::type;
+
+  using dynamic_dimension = typename nested::dynamic_dimension;
+
+  using dimension =
+      typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type;
+};
+
+template <class T>
+struct ViewArrayAnalysis<T[]> {
+ private:
+  using nested           = ViewArrayAnalysis<T>;
+  using nested_dimension = typename nested::dimension;
+
+ public:
+  using value_type           = typename nested::value_type;
+  using const_value_type     = typename nested::const_value_type;
+  using non_const_value_type = typename nested::non_const_value_type;
+
+  using dynamic_dimension =
+      typename nested::dynamic_dimension::template prepend<0>::type;
+
+  using static_dimension = typename nested::static_dimension;
+
+  using dimension =
+      typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type;
+};
+
+template <class T>
+struct ViewArrayAnalysis<T*> {
+ private:
+  using nested = ViewArrayAnalysis<T>;
+
+ public:
+  using value_type           = typename nested::value_type;
+  using const_value_type     = typename nested::const_value_type;
+  using non_const_value_type = typename nested::non_const_value_type;
+
+  using dynamic_dimension =
+      typename nested::dynamic_dimension::template prepend<0>::type;
+
+  using static_dimension = typename nested::static_dimension;
+
+  using dimension =
+      typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type;
+};
+
+template <class DataType, class ArrayLayout, class ValueType>
+struct ViewDataAnalysis {
+ private:
+  using array_analysis = ViewArrayAnalysis<DataType>;
+
+  // ValueType is opportunity for partial specialization.
+  // Must match array analysis when this default template is used.
+  static_assert(
+      std::is_same<ValueType,
+                   typename array_analysis::non_const_value_type>::value);
+
+ public:
+  using specialize = void;  // No specialization
+
+  using dimension            = typename array_analysis::dimension;
+  using value_type           = typename array_analysis::value_type;
+  using const_value_type     = typename array_analysis::const_value_type;
+  using non_const_value_type = typename array_analysis::non_const_value_type;
+
+  // Generate analogous multidimensional array specification type.
+  using type       = typename ViewDataType<value_type, dimension>::type;
+  using const_type = typename ViewDataType<const_value_type, dimension>::type;
+  using non_const_type =
+      typename ViewDataType<non_const_value_type, dimension>::type;
+
+  // Generate "flattened" multidimensional array specification type.
+  using scalar_array_type           = type;
+  using const_scalar_array_type     = const_type;
+  using non_const_scalar_array_type = non_const_type;
+};
+
+template <class Dimension, class Layout, class Enable = void>
+struct ViewOffset {
+  using is_mapping_plugin = std::false_type;
+};
+}  // namespace Kokkos::Impl
+
+#endif  // KOKKOS_VIEW_DATA_ANALYSIS_HPP
diff --git a/core/src/impl/Kokkos_ViewLayoutTiled.hpp b/core/src/impl/Kokkos_ViewLayoutTiled.hpp
deleted file mode 100644
index 957717f973..0000000000
--- a/core/src/impl/Kokkos_ViewLayoutTiled.hpp
+++ /dev/null
@@ -1,1425 +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_EXPERIMENTAL_VIEWLAYOUTTILE_HPP
-#define KOKKOS_EXPERIMENTAL_VIEWLAYOUTTILE_HPP
-
-#include <Kokkos_Layout.hpp>
-#include <Kokkos_View.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-
-// View offset and mapping for tiled view's
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1>
-struct is_array_layout<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, 0, 0, 0, 0, 0, 0, true>>
-    : public std::true_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2>
-struct is_array_layout<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, ArgN2, 0, 0, 0, 0, 0, true>>
-    : public std::true_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3>
-struct is_array_layout<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, 0, 0, 0, 0, true>>
-    : public std::true_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4>
-struct is_array_layout<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, 0, 0, 0, true>>
-    : public std::true_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
-          unsigned ArgN5>
-struct is_array_layout<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, 0, 0, true>>
-    : public std::true_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
-          unsigned ArgN5, unsigned ArgN6>
-struct is_array_layout<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, 0, true>>
-    : public std::true_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
-          unsigned ArgN5, unsigned ArgN6, unsigned ArgN7>
-struct is_array_layout<
-    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, ArgN0, ArgN1, ArgN2,
-                                      ArgN3, ArgN4, ArgN5, ArgN6, ArgN7, true>>
-    : public std::true_type {};
-
-template <class L>
-struct is_array_layout_tiled : public std::false_type {};
-
-template <Kokkos::Iterate OuterP, Kokkos::Iterate InnerP, unsigned ArgN0,
-          unsigned ArgN1, unsigned ArgN2, unsigned ArgN3, unsigned ArgN4,
-          unsigned ArgN5, unsigned ArgN6, unsigned ArgN7, bool IsPowerTwo>
-struct is_array_layout_tiled<Kokkos::Experimental::LayoutTiled<
-    OuterP, InnerP, ArgN0, ArgN1, ArgN2, ArgN3, ArgN4, ArgN5, ArgN6, ArgN7,
-    IsPowerTwo>> : public std::true_type {
-};  // Last template parameter "true" meaning this currently only supports
-    // powers-of-two
-
-namespace Impl {
-
-template <class Dimension, class Layout>
-struct ViewOffset<
-    Dimension, Layout,
-    std::enable_if_t<((Dimension::rank <= 8) && (Dimension::rank >= 2) &&
-                      is_array_layout<Layout>::value &&
-                      is_array_layout_tiled<Layout>::value)>> {
- public:
-  static constexpr Kokkos::Iterate outer_pattern = Layout::outer_pattern;
-  static constexpr Kokkos::Iterate inner_pattern = Layout::inner_pattern;
-
-  static constexpr int VORank = Dimension::rank;
-
-  static constexpr unsigned SHIFT_0 =
-      Kokkos::Impl::integral_power_of_two(Layout::N0);
-  static constexpr unsigned SHIFT_1 =
-      Kokkos::Impl::integral_power_of_two(Layout::N1);
-  static constexpr unsigned SHIFT_2 =
-      Kokkos::Impl::integral_power_of_two(Layout::N2);
-  static constexpr unsigned SHIFT_3 =
-      Kokkos::Impl::integral_power_of_two(Layout::N3);
-  static constexpr unsigned SHIFT_4 =
-      Kokkos::Impl::integral_power_of_two(Layout::N4);
-  static constexpr unsigned SHIFT_5 =
-      Kokkos::Impl::integral_power_of_two(Layout::N5);
-  static constexpr unsigned SHIFT_6 =
-      Kokkos::Impl::integral_power_of_two(Layout::N6);
-  static constexpr unsigned SHIFT_7 =
-      Kokkos::Impl::integral_power_of_two(Layout::N7);
-  static constexpr int MASK_0 = Layout::N0 - 1;
-  static constexpr int MASK_1 = Layout::N1 - 1;
-  static constexpr int MASK_2 = Layout::N2 - 1;
-  static constexpr int MASK_3 = Layout::N3 - 1;
-  static constexpr int MASK_4 = Layout::N4 - 1;
-  static constexpr int MASK_5 = Layout::N5 - 1;
-  static constexpr int MASK_6 = Layout::N6 - 1;
-  static constexpr int MASK_7 = Layout::N7 - 1;
-
-  static constexpr unsigned SHIFT_2T = SHIFT_0 + SHIFT_1;
-  static constexpr unsigned SHIFT_3T = SHIFT_0 + SHIFT_1 + SHIFT_2;
-  static constexpr unsigned SHIFT_4T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3;
-  static constexpr unsigned SHIFT_5T =
-      SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4;
-  static constexpr unsigned SHIFT_6T =
-      SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5;
-  static constexpr unsigned SHIFT_7T =
-      SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5 + SHIFT_6;
-  static constexpr unsigned SHIFT_8T = SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 +
-                                       SHIFT_4 + SHIFT_5 + SHIFT_6 + SHIFT_7;
-
-  // Is an irregular layout that does not have uniform striding for each index.
-  using is_mapping_plugin = std::true_type;
-  using is_regular        = std::false_type;
-
-  using size_type      = size_t;
-  using dimension_type = Dimension;
-  using array_layout   = Layout;
-
-  dimension_type m_dim;
-  size_type m_tile_N0;  // Num tiles dim 0
-  size_type m_tile_N1;
-  size_type m_tile_N2;
-  size_type m_tile_N3;
-  size_type m_tile_N4;
-  size_type m_tile_N5;
-  size_type m_tile_N6;
-  size_type m_tile_N7;
-
-  //----------------------------------------
-
-#define KOKKOS_IMPL_DEBUG_OUTPUT_CHECK 0
-
-  // Rank 2
-  template <typename I0, typename I1>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0,
-                                              I1 const& i1) const {
-    auto tile_offset =
-        (outer_pattern == (Kokkos::Iterate::Left))
-            ? (((i0 >> SHIFT_0) + m_tile_N0 * ((i1 >> SHIFT_1))) << SHIFT_2T)
-            : (((m_tile_N1 * (i0 >> SHIFT_0) + (i1 >> SHIFT_1))) << SHIFT_2T);
-    //                     ( num_tiles[1] * ti0     +  ti1 ) * FTD
-
-    auto local_offset = (inner_pattern == (Kokkos::Iterate::Left))
-                            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0))
-                            : (((i0 & MASK_0) << SHIFT_1) + (i1 & MASK_1));
-    //                     ( tile_dim[1] * li0         +  li1 )
-
-#if KOKKOS_IMPL_DEBUG_OUTPUT_CHECK
-    std::cout << "Am I Outer Left? "
-              << (outer_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "Am I Inner Left? "
-              << (inner_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "i0 = " << i0 << " i1 = " << i1
-              << "\ntilei0 = " << (i0 >> SHIFT_0)
-              << " tilei1 = " << (i1 >> SHIFT_1)
-              << "locali0 = " << (i0 & MASK_0)
-              << "\nlocali1 = " << (i1 & MASK_1) << std::endl;
-#endif
-
-    return tile_offset + local_offset;
-  }
-
-  // Rank 3
-  template <typename I0, typename I1, typename I2>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
-                                              I2 const& i2) const {
-    auto tile_offset =
-        (outer_pattern == Kokkos::Iterate::Left)
-            ? (((i0 >> SHIFT_0) +
-                m_tile_N0 * ((i1 >> SHIFT_1) + m_tile_N1 * (i2 >> SHIFT_2)))
-               << SHIFT_3T)
-            : ((m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) + (i1 >> SHIFT_1)) +
-                (i2 >> SHIFT_2))
-               << SHIFT_3T);
-
-    auto local_offset = (inner_pattern == Kokkos::Iterate::Left)
-                            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
-                               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)))
-                            : (((i0 & MASK_0) << (SHIFT_2 + SHIFT_1)) +
-                               ((i1 & MASK_1) << (SHIFT_2)) + (i2 & MASK_2));
-
-#if KOKKOS_IMPL_DEBUG_OUTPUT_CHECK
-    std::cout << "Am I Outer Left? "
-              << (outer_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "Am I Inner Left? "
-              << (inner_pattern == (Kokkos::Iterate::Left)) << std::endl;
-    std::cout << "i0 = " << i0 << " i1 = " << i1 << " i2 = " << i2
-              << "\ntilei0 = " << (i0 >> SHIFT_0)
-              << " tilei1 = " << (i1 >> SHIFT_1)
-              << " tilei2 = " << (i2 >> SHIFT_2)
-              << "\nlocali0 = " << (i0 & MASK_0)
-              << "locali1 = " << (i1 & MASK_1) << "locali2 = " << (i2 & MASK_2)
-              << std::endl;
-#endif
-
-    return tile_offset + local_offset;
-  }
-
-  // Rank 4
-  template <typename I0, typename I1, typename I2, typename I3>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
-                                              I2 const& i2,
-                                              I3 const& i3) const {
-    auto tile_offset =
-        (outer_pattern == Kokkos::Iterate::Left)
-            ? (((i0 >> SHIFT_0) +
-                m_tile_N0 * ((i1 >> SHIFT_1) +
-                             m_tile_N1 * ((i2 >> SHIFT_2) +
-                                          m_tile_N2 * (i3 >> SHIFT_3))))
-               << SHIFT_4T)
-            : ((m_tile_N3 * (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
-                                          (i1 >> SHIFT_1)) +
-                             (i2 >> SHIFT_2)) +
-                (i3 >> SHIFT_3))
-               << SHIFT_4T);
-
-    auto local_offset =
-        (inner_pattern == Kokkos::Iterate::Left)
-            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
-               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
-               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)))
-            : (((i0 & MASK_0) << (SHIFT_3 + SHIFT_2 + SHIFT_1)) +
-               ((i1 & MASK_1) << (SHIFT_3 + SHIFT_2)) +
-               ((i2 & MASK_2) << (SHIFT_3)) + (i3 & MASK_3));
-
-    return tile_offset + local_offset;
-  }
-
-  // Rank 5
-  template <typename I0, typename I1, typename I2, typename I3, typename I4>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
-                                              I2 const& i2, I3 const& i3,
-                                              I4 const& i4) const {
-    auto tile_offset =
-        (outer_pattern == Kokkos::Iterate::Left)
-            ? (((i0 >> SHIFT_0) +
-                m_tile_N0 *
-                    ((i1 >> SHIFT_1) +
-                     m_tile_N1 * ((i2 >> SHIFT_2) +
-                                  m_tile_N2 * ((i3 >> SHIFT_3) +
-                                               m_tile_N3 * (i4 >> SHIFT_4)))))
-               << SHIFT_5T)
-            : ((m_tile_N4 *
-                    (m_tile_N3 * (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
-                                               (i1 >> SHIFT_1)) +
-                                  (i2 >> SHIFT_2)) +
-                     (i3 >> SHIFT_3)) +
-                (i4 >> SHIFT_4))
-               << SHIFT_5T);
-
-    auto local_offset =
-        (inner_pattern == Kokkos::Iterate::Left)
-            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
-               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
-               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
-               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)))
-            : (((i0 & MASK_0) << (SHIFT_4 + SHIFT_3 + SHIFT_2 + SHIFT_1)) +
-               ((i1 & MASK_1) << (SHIFT_4 + SHIFT_3 + SHIFT_2)) +
-               ((i2 & MASK_2) << (SHIFT_4 + SHIFT_3)) +
-               ((i3 & MASK_3) << (SHIFT_4)) + (i4 & MASK_4));
-
-    return tile_offset + local_offset;
-  }
-
-  // Rank 6
-  template <typename I0, typename I1, typename I2, typename I3, typename I4,
-            typename I5>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
-                                              I2 const& i2, I3 const& i3,
-                                              I4 const& i4,
-                                              I5 const& i5) const {
-    auto tile_offset =
-        (outer_pattern == Kokkos::Iterate::Left)
-            ? (((i0 >> SHIFT_0) +
-                m_tile_N0 *
-                    ((i1 >> SHIFT_1) +
-                     m_tile_N1 *
-                         ((i2 >> SHIFT_2) +
-                          m_tile_N2 *
-                              ((i3 >> SHIFT_3) +
-                               m_tile_N3 * ((i4 >> SHIFT_4) +
-                                            m_tile_N4 * (i5 >> SHIFT_5))))))
-               << SHIFT_6T)
-            : ((m_tile_N5 *
-                    (m_tile_N4 *
-                         (m_tile_N3 *
-                              (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
-                                            (i1 >> SHIFT_1)) +
-                               (i2 >> SHIFT_2)) +
-                          (i3 >> SHIFT_3)) +
-                     (i4 >> SHIFT_4)) +
-                (i5 >> SHIFT_5))
-               << SHIFT_6T);
-
-    auto local_offset =
-        (inner_pattern == Kokkos::Iterate::Left)
-            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
-               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
-               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
-               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)) +
-               ((i5 & MASK_5)
-                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4)))
-            : (((i0 & MASK_0)
-                << (SHIFT_5 + SHIFT_4 + SHIFT_3 + SHIFT_2 + SHIFT_1)) +
-               ((i1 & MASK_1) << (SHIFT_5 + SHIFT_4 + SHIFT_3 + SHIFT_2)) +
-               ((i2 & MASK_2) << (SHIFT_5 + SHIFT_4 + SHIFT_3)) +
-               ((i3 & MASK_3) << (SHIFT_5 + SHIFT_4)) +
-               ((i4 & MASK_4) << (SHIFT_5)) + (i5 & MASK_5));
-
-    return tile_offset + local_offset;
-  }
-
-  // Rank 7
-  template <typename I0, typename I1, typename I2, typename I3, typename I4,
-            typename I5, typename I6>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
-                                              I2 const& i2, I3 const& i3,
-                                              I4 const& i4, I5 const& i5,
-                                              I6 const& i6) const {
-    auto tile_offset =
-        (outer_pattern == Kokkos::Iterate::Left)
-            ? (((i0 >> SHIFT_0) +
-                m_tile_N0 *
-                    ((i1 >> SHIFT_1) +
-                     m_tile_N1 *
-                         ((i2 >> SHIFT_2) +
-                          m_tile_N2 *
-                              ((i3 >> SHIFT_3) +
-                               m_tile_N3 *
-                                   ((i4 >> SHIFT_4) +
-                                    m_tile_N4 *
-                                        ((i5 >> SHIFT_5) +
-                                         m_tile_N5 * (i6 >> SHIFT_6)))))))
-               << SHIFT_7T)
-            : ((m_tile_N6 *
-                    (m_tile_N5 *
-                         (m_tile_N4 *
-                              (m_tile_N3 *
-                                   (m_tile_N2 * (m_tile_N1 * (i0 >> SHIFT_0) +
-                                                 (i1 >> SHIFT_1)) +
-                                    (i2 >> SHIFT_2)) +
-                               (i3 >> SHIFT_3)) +
-                          (i4 >> SHIFT_4)) +
-                     (i5 >> SHIFT_5)) +
-                (i6 >> SHIFT_6))
-               << SHIFT_7T);
-
-    auto local_offset =
-        (inner_pattern == Kokkos::Iterate::Left)
-            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
-               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
-               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
-               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)) +
-               ((i5 & MASK_5)
-                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4)) +
-               ((i6 & MASK_6)
-                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4 + SHIFT_5)))
-            : (((i0 & MASK_0) << (SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3 +
-                                  SHIFT_2 + SHIFT_1)) +
-               ((i1 & MASK_1)
-                << (SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3 + SHIFT_2)) +
-               ((i2 & MASK_2) << (SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3)) +
-               ((i3 & MASK_3) << (SHIFT_6 + SHIFT_5 + SHIFT_4)) +
-               ((i4 & MASK_4) << (SHIFT_6 + SHIFT_5)) +
-               ((i5 & MASK_5) << (SHIFT_6)) + (i6 & MASK_6));
-
-    return tile_offset + local_offset;
-  }
-
-  // Rank 8
-  template <typename I0, typename I1, typename I2, typename I3, typename I4,
-            typename I5, typename I6, typename I7>
-  KOKKOS_INLINE_FUNCTION size_type operator()(I0 const& i0, I1 const& i1,
-                                              I2 const& i2, I3 const& i3,
-                                              I4 const& i4, I5 const& i5,
-                                              I6 const& i6,
-                                              I7 const& i7) const {
-    auto tile_offset =
-        (outer_pattern == Kokkos::Iterate::Left)
-            ? (((i0 >> SHIFT_0) +
-                m_tile_N0 *
-                    ((i1 >> SHIFT_1) +
-                     m_tile_N1 *
-                         ((i2 >> SHIFT_2) +
-                          m_tile_N2 *
-                              ((i3 >> SHIFT_3) +
-                               m_tile_N3 *
-                                   ((i4 >> SHIFT_4) +
-                                    m_tile_N4 *
-                                        ((i5 >> SHIFT_5) +
-                                         m_tile_N5 *
-                                             ((i6 >> SHIFT_6) +
-                                              m_tile_N6 * (i7 >> SHIFT_7))))))))
-               << SHIFT_8T)
-            : ((m_tile_N7 *
-                    (m_tile_N6 *
-                         (m_tile_N5 *
-                              (m_tile_N4 *
-                                   (m_tile_N3 *
-                                        (m_tile_N2 *
-                                             (m_tile_N1 * (i0 >> SHIFT_0) +
-                                              (i1 >> SHIFT_1)) +
-                                         (i2 >> SHIFT_2)) +
-                                    (i3 >> SHIFT_3)) +
-                               (i4 >> SHIFT_4)) +
-                          (i5 >> SHIFT_5)) +
-                     (i6 >> SHIFT_6)) +
-                (i7 >> SHIFT_7))
-               << SHIFT_8T);
-
-    auto local_offset =
-        (inner_pattern == Kokkos::Iterate::Left)
-            ? ((i0 & MASK_0) + ((i1 & MASK_1) << SHIFT_0) +
-               ((i2 & MASK_2) << (SHIFT_0 + SHIFT_1)) +
-               ((i3 & MASK_3) << (SHIFT_0 + SHIFT_1 + SHIFT_2)) +
-               ((i4 & MASK_4) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3)) +
-               ((i5 & MASK_5)
-                << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 + SHIFT_4)) +
-               ((i6 & MASK_6) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 +
-                                  SHIFT_4 + SHIFT_5)) +
-               ((i7 & MASK_7) << (SHIFT_0 + SHIFT_1 + SHIFT_2 + SHIFT_3 +
-                                  SHIFT_4 + SHIFT_5 + SHIFT_6)))
-            : (((i0 & MASK_0) << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4 +
-                                  SHIFT_3 + SHIFT_2 + SHIFT_1)) +
-               ((i1 & MASK_1) << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4 +
-                                  SHIFT_3 + SHIFT_2)) +
-               ((i2 & MASK_2)
-                << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4 + SHIFT_3)) +
-               ((i3 & MASK_3) << (SHIFT_7 + SHIFT_6 + SHIFT_5 + SHIFT_4)) +
-               ((i4 & MASK_4) << (SHIFT_7 + SHIFT_6 + SHIFT_5)) +
-               ((i5 & MASK_5) << (SHIFT_7 + SHIFT_6)) +
-               ((i6 & MASK_6) << (SHIFT_7)) + (i7 & MASK_7));
-
-    return tile_offset + local_offset;
-  }
-
-  //----------------------------------------
-
-  KOKKOS_INLINE_FUNCTION constexpr array_layout layout() const {
-    return array_layout((VORank > 0 ? m_dim.N0 : KOKKOS_INVALID_INDEX),
-                        (VORank > 1 ? m_dim.N1 : KOKKOS_INVALID_INDEX),
-                        (VORank > 2 ? m_dim.N2 : KOKKOS_INVALID_INDEX),
-                        (VORank > 3 ? m_dim.N3 : KOKKOS_INVALID_INDEX),
-                        (VORank > 4 ? m_dim.N4 : KOKKOS_INVALID_INDEX),
-                        (VORank > 5 ? m_dim.N5 : KOKKOS_INVALID_INDEX),
-                        (VORank > 6 ? m_dim.N6 : KOKKOS_INVALID_INDEX),
-                        (VORank > 7 ? m_dim.N7 : KOKKOS_INVALID_INDEX));
-  }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_0() const {
-    return m_dim.N0;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_1() const {
-    return m_dim.N1;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_2() const {
-    return m_dim.N2;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_3() const {
-    return m_dim.N3;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_4() const {
-    return m_dim.N4;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_5() const {
-    return m_dim.N5;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_6() const {
-    return m_dim.N6;
-  }
-  KOKKOS_INLINE_FUNCTION constexpr size_type dimension_7() const {
-    return m_dim.N7;
-  }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type size() const {
-    return m_dim.N0 * m_dim.N1 * m_dim.N2 * m_dim.N3 * m_dim.N4 * m_dim.N5 *
-           m_dim.N6 * m_dim.N7;
-  }
-
-  // Strides are meaningless due to irregularity
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_0() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_1() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_2() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_3() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_4() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_5() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_6() const { return 0; }
-  KOKKOS_INLINE_FUNCTION constexpr size_type stride_7() const { return 0; }
-
-  // Stride with [ rank ] value is the total length
-  template <typename iType>
-  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
-    s[0] = 0;
-    if (0 < dimension_type::rank) {
-      s[1] = 0;
-    }
-    if (1 < dimension_type::rank) {
-      s[2] = 0;
-    }
-    if (2 < dimension_type::rank) {
-      s[3] = 0;
-    }
-    if (3 < dimension_type::rank) {
-      s[4] = 0;
-    }
-    if (4 < dimension_type::rank) {
-      s[5] = 0;
-    }
-    if (5 < dimension_type::rank) {
-      s[6] = 0;
-    }
-    if (6 < dimension_type::rank) {
-      s[7] = 0;
-    }
-    if (7 < dimension_type::rank) {
-      s[8] = 0;
-    }
-  }
-
-  KOKKOS_INLINE_FUNCTION constexpr size_type span() const {
-    // Rank2: ( NumTile0 * ( NumTile1 ) ) * TileSize, etc
-    return (VORank == 2)
-               ? (m_tile_N0 * m_tile_N1) << SHIFT_2T
-               : (VORank == 3)
-                     ? (m_tile_N0 * m_tile_N1 * m_tile_N2) << SHIFT_3T
-                     : (VORank == 4)
-                           ? (m_tile_N0 * m_tile_N1 * m_tile_N2 * m_tile_N3)
-                                 << SHIFT_4T
-                           : (VORank == 5)
-                                 ? (m_tile_N0 * m_tile_N1 * m_tile_N2 *
-                                    m_tile_N3 * m_tile_N4)
-                                       << SHIFT_5T
-                                 : (VORank == 6)
-                                       ? (m_tile_N0 * m_tile_N1 * m_tile_N2 *
-                                          m_tile_N3 * m_tile_N4 * m_tile_N5)
-                                             << SHIFT_6T
-                                       : (VORank == 7)
-                                             ? (m_tile_N0 * m_tile_N1 *
-                                                m_tile_N2 * m_tile_N3 *
-                                                m_tile_N4 * m_tile_N5 *
-                                                m_tile_N6)
-                                                   << SHIFT_7T
-                                             : (m_tile_N0 * m_tile_N1 *
-                                                m_tile_N2 * m_tile_N3 *
-                                                m_tile_N4 * m_tile_N5 *
-                                                m_tile_N6 * m_tile_N7)
-                                                   << SHIFT_8T;
-  }
-
-  KOKKOS_INLINE_FUNCTION constexpr bool span_is_contiguous() const {
-    return true;
-  }
-
-  //----------------------------------------
-#ifdef KOKKOS_IMPL_WINDOWS_CUDA
-  KOKKOS_FUNCTION ViewOffset() {}
-  KOKKOS_FUNCTION ViewOffset(const ViewOffset& src) {
-    m_dim     = src.m_dim;
-    m_tile_N0 = src.m_tile_N0;
-    m_tile_N1 = src.m_tile_N1;
-    m_tile_N2 = src.m_tile_N2;
-    m_tile_N3 = src.m_tile_N3;
-    m_tile_N4 = src.m_tile_N4;
-    m_tile_N5 = src.m_tile_N5;
-    m_tile_N6 = src.m_tile_N6;
-    m_tile_N7 = src.m_tile_N7;
-  }
-  KOKKOS_FUNCTION ViewOffset& operator=(const ViewOffset& src) {
-    m_dim     = src.m_dim;
-    m_tile_N0 = src.m_tile_N0;
-    m_tile_N1 = src.m_tile_N1;
-    m_tile_N2 = src.m_tile_N2;
-    m_tile_N3 = src.m_tile_N3;
-    m_tile_N4 = src.m_tile_N4;
-    m_tile_N5 = src.m_tile_N5;
-    m_tile_N6 = src.m_tile_N6;
-    m_tile_N7 = src.m_tile_N7;
-    return *this;
-  }
-#else
-  KOKKOS_DEFAULTED_FUNCTION ~ViewOffset()                 = default;
-  KOKKOS_DEFAULTED_FUNCTION ViewOffset()                  = default;
-  KOKKOS_DEFAULTED_FUNCTION ViewOffset(const ViewOffset&) = default;
-  KOKKOS_DEFAULTED_FUNCTION ViewOffset& operator=(const ViewOffset&) = default;
-#endif
-
-  template <unsigned TrivialScalarSize>
-  KOKKOS_INLINE_FUNCTION constexpr ViewOffset(
-      std::integral_constant<unsigned, TrivialScalarSize> const&,
-      array_layout const arg_layout)
-      : m_dim(arg_layout.dimension[0], arg_layout.dimension[1],
-              arg_layout.dimension[2], arg_layout.dimension[3],
-              arg_layout.dimension[4], arg_layout.dimension[5],
-              arg_layout.dimension[6], arg_layout.dimension[7]),
-        m_tile_N0((arg_layout.dimension[0] + MASK_0) >>
-                  SHIFT_0 /* number of tiles in first dimension */),
-        m_tile_N1((arg_layout.dimension[1] + MASK_1) >> SHIFT_1),
-        m_tile_N2((VORank > 2) ? (arg_layout.dimension[2] + MASK_2) >> SHIFT_2
-                               : 0),
-        m_tile_N3((VORank > 3) ? (arg_layout.dimension[3] + MASK_3) >> SHIFT_3
-                               : 0),
-        m_tile_N4((VORank > 4) ? (arg_layout.dimension[4] + MASK_4) >> SHIFT_4
-                               : 0),
-        m_tile_N5((VORank > 5) ? (arg_layout.dimension[5] + MASK_5) >> SHIFT_5
-                               : 0),
-        m_tile_N6((VORank > 6) ? (arg_layout.dimension[6] + MASK_6) >> SHIFT_6
-                               : 0),
-        m_tile_N7((VORank > 7) ? (arg_layout.dimension[7] + MASK_7) >> SHIFT_7
-                               : 0) {}
-};
-
-// FIXME Remove the out-of-class definitions when we require C++17
-#define KOKKOS_ITERATE_VIEW_OFFSET_ENABLE                               \
-  std::enable_if_t<((Dimension::rank <= 8) && (Dimension::rank >= 2) && \
-                    is_array_layout<Layout>::value &&                   \
-                    is_array_layout_tiled<Layout>::value)>
-template <class Dimension, class Layout>
-constexpr Kokkos::Iterate ViewOffset<
-    Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::outer_pattern;
-template <class Dimension, class Layout>
-constexpr Kokkos::Iterate ViewOffset<
-    Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::inner_pattern;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::VORank;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_0;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_1;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_2;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_3;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_4;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_5;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_6;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_7;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_0;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_1;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_2;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_3;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_4;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_5;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_6;
-template <class Dimension, class Layout>
-constexpr int
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::MASK_7;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_2T;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_3T;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_4T;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_5T;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_6T;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_7T;
-template <class Dimension, class Layout>
-constexpr unsigned
-    ViewOffset<Dimension, Layout, KOKKOS_ITERATE_VIEW_OFFSET_ENABLE>::SHIFT_8T;
-#undef KOKKOS_ITERATE_VIEW_OFFSET_ENABLE
-
-//----------------------------------------
-
-// ViewMapping assign method needed in order to return a 'subview' tile as a
-// proper View The outer iteration pattern determines the mapping of the pointer
-// offset to the beginning of requested tile The inner iteration pattern is
-// needed for the layout of the tile's View to be returned Rank 2
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1>
-class ViewMapping<std::enable_if_t<(N2 == 0 && N3 == 0 && N4 == 0 && N5 == 0 &&
-                                    N6 == 0 && N7 == 0)>  // void
-                  ,
-                  Kokkos::ViewTraits<
-                      T**,
-                      Kokkos::Experimental::LayoutTiled<
-                          OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                      P...>,
-                  Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
-                                                    N3, N4, N5, N6, N7, true>,
-                  iType0, iType1> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T**, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits       = Kokkos::ViewTraits<T[N0][N1], array_layout, P...>;
-  using type         = Kokkos::View<T[N0][N1], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left ? ((i_tile0 + src.m_impl_offset.m_tile_N0 * i_tile1)
-                              << src_offset_type::SHIFT_2T)
-                           : ((src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1)
-                              << src_offset_type::SHIFT_2T))  // offset to start
-                                                              // of the tile
-            ),
-        dst_offset_type());
-  }
-};
-
-// Rank 3
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1, typename iType2>
-class ViewMapping<std::enable_if_t<(N3 == 0 && N4 == 0 && N5 == 0 && N6 == 0 &&
-                                    N7 == 0)>  // void
-                  ,
-                  Kokkos::ViewTraits<
-                      T***,
-                      Kokkos::Experimental::LayoutTiled<
-                          OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                      P...>,
-                  Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
-                                                    N3, N4, N5, N6, N7, true>,
-                  iType0, iType1, iType2> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T***, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits       = Kokkos::ViewTraits<T[N0][N1][N2], array_layout, P...>;
-  using type         = Kokkos::View<T[N0][N1][N2], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
-      const iType2 i_tile2) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left
-                 ? ((i_tile0 +
-                     src.m_impl_offset.m_tile_N0 *
-                         (i_tile1 + src.m_impl_offset.m_tile_N1 * i_tile2))
-                    << src_offset_type::SHIFT_3T)
-                 : ((src.m_impl_offset.m_tile_N2 *
-                         (src.m_impl_offset.m_tile_N1 * i_tile0 + i_tile1) +
-                     i_tile2)
-                    << src_offset_type::SHIFT_3T)))  // offset to start of the
-                                                     // tile
-        ,
-        dst_offset_type());
-  }
-};
-
-// Rank 4
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1, typename iType2, typename iType3>
-class ViewMapping<
-    std::enable_if_t<(N4 == 0 && N5 == 0 && N6 == 0 && N7 == 0)>  // void
-    ,
-    Kokkos::ViewTraits<
-        T****,
-        Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
-                                          N5, N6, N7, true>,
-        P...>,
-    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                      N6, N7, true>,
-    iType0, iType1, iType2, iType3> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T****, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits = Kokkos::ViewTraits<T[N0][N1][N2][N3], array_layout, P...>;
-  using type   = Kokkos::View<T[N0][N1][N2][N3], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
-      const iType2 i_tile2, const iType3 i_tile3) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left
-                 ? ((i_tile0 +
-                     src.m_impl_offset.m_tile_N0 *
-                         (i_tile1 + src.m_impl_offset.m_tile_N1 *
-                                        (i_tile2 + src.m_impl_offset.m_tile_N2 *
-                                                       i_tile3)))
-                    << src_offset_type::SHIFT_4T)
-                 : ((src.m_impl_offset.m_tile_N3 *
-                         (src.m_impl_offset.m_tile_N2 *
-                              (src.m_impl_offset.m_tile_N1 * i_tile0 +
-                               i_tile1) +
-                          i_tile2) +
-                     i_tile3)
-                    << src_offset_type::SHIFT_4T)))  // offset to start of the
-                                                     // tile
-        ,
-        dst_offset_type());
-  }
-};
-
-// Rank 5
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1, typename iType2, typename iType3, typename iType4>
-class ViewMapping<std::enable_if_t<(N5 == 0 && N6 == 0 && N7 == 0)>  // void
-                  ,
-                  Kokkos::ViewTraits<
-                      T*****,
-                      Kokkos::Experimental::LayoutTiled<
-                          OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                      P...>,
-                  Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
-                                                    N3, N4, N5, N6, N7, true>,
-                  iType0, iType1, iType2, iType3, iType4> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T*****, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits = Kokkos::ViewTraits<T[N0][N1][N2][N3][N4], array_layout, P...>;
-  using type   = Kokkos::View<T[N0][N1][N2][N3][N4], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
-      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left
-                 ? ((i_tile0 +
-                     src.m_impl_offset.m_tile_N0 *
-                         (i_tile1 +
-                          src.m_impl_offset.m_tile_N1 *
-                              (i_tile2 +
-                               src.m_impl_offset.m_tile_N2 *
-                                   (i_tile3 +
-                                    src.m_impl_offset.m_tile_N3 * i_tile4))))
-                    << src_offset_type::SHIFT_5T)
-                 : ((src.m_impl_offset.m_tile_N4 *
-                         (src.m_impl_offset.m_tile_N3 *
-                              (src.m_impl_offset.m_tile_N2 *
-                                   (src.m_impl_offset.m_tile_N1 * i_tile0 +
-                                    i_tile1) +
-                               i_tile2) +
-                          i_tile3) +
-                     i_tile4)
-                    << src_offset_type::SHIFT_5T)))  // offset to start of the
-                                                     // tile
-        ,
-        dst_offset_type());
-  }
-};
-
-// Rank 6
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1, typename iType2, typename iType3, typename iType4,
-          typename iType5>
-class ViewMapping<std::enable_if_t<(N6 == 0 && N7 == 0)>  // void
-                  ,
-                  Kokkos::ViewTraits<
-                      T******,
-                      Kokkos::Experimental::LayoutTiled<
-                          OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                      P...>,
-                  Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
-                                                    N3, N4, N5, N6, N7, true>,
-                  iType0, iType1, iType2, iType3, iType4, iType5> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T******, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits =
-      Kokkos::ViewTraits<T[N0][N1][N2][N3][N4][N5], array_layout, P...>;
-  using type = Kokkos::View<T[N0][N1][N2][N3][N4][N5], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
-      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4,
-      const iType5 i_tile5) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left
-                 ? ((i_tile0 +
-                     src.m_impl_offset.m_tile_N0 *
-                         (i_tile1 +
-                          src.m_impl_offset.m_tile_N1 *
-                              (i_tile2 +
-                               src.m_impl_offset.m_tile_N2 *
-                                   (i_tile3 +
-                                    src.m_impl_offset.m_tile_N3 *
-                                        (i_tile4 + src.m_impl_offset.m_tile_N4 *
-                                                       i_tile5)))))
-                    << src_offset_type::SHIFT_6T)
-                 : ((src.m_impl_offset.m_tile_N5 *
-                         (src.m_impl_offset.m_tile_N4 *
-                              (src.m_impl_offset.m_tile_N3 *
-                                   (src.m_impl_offset.m_tile_N2 *
-                                        (src.m_impl_offset.m_tile_N1 * i_tile0 +
-                                         i_tile1) +
-                                    i_tile2) +
-                               i_tile3) +
-                          i_tile4) +
-                     i_tile5)
-                    << src_offset_type::SHIFT_6T)))  // offset to start of the
-                                                     // tile
-        ,
-        dst_offset_type());
-  }
-};
-
-// Rank 7
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1, typename iType2, typename iType3, typename iType4,
-          typename iType5, typename iType6>
-class ViewMapping<std::enable_if_t<(N7 == 0)>  // void
-                  ,
-                  Kokkos::ViewTraits<
-                      T*******,
-                      Kokkos::Experimental::LayoutTiled<
-                          OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                      P...>,
-                  Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2,
-                                                    N3, N4, N5, N6, N7, true>,
-                  iType0, iType1, iType2, iType3, iType4, iType5, iType6> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T*******, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits =
-      Kokkos::ViewTraits<T[N0][N1][N2][N3][N4][N5][N6], array_layout, P...>;
-  using type = Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
-      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4,
-      const iType5 i_tile5, const iType6 i_tile6) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left
-                 ? ((i_tile0 +
-                     src.m_impl_offset.m_tile_N0 *
-                         (i_tile1 +
-                          src.m_impl_offset.m_tile_N1 *
-                              (i_tile2 +
-                               src.m_impl_offset.m_tile_N2 *
-                                   (i_tile3 +
-                                    src.m_impl_offset.m_tile_N3 *
-                                        (i_tile4 +
-                                         src.m_impl_offset.m_tile_N4 *
-                                             (i_tile5 +
-                                              src.m_impl_offset.m_tile_N5 *
-                                                  i_tile6))))))
-                    << src_offset_type::SHIFT_7T)
-                 : ((src.m_impl_offset.m_tile_N6 *
-                         (src.m_impl_offset.m_tile_N5 *
-                              (src.m_impl_offset.m_tile_N4 *
-                                   (src.m_impl_offset.m_tile_N3 *
-                                        (src.m_impl_offset.m_tile_N2 *
-                                             (src.m_impl_offset.m_tile_N1 *
-                                                  i_tile0 +
-                                              i_tile1) +
-                                         i_tile2) +
-                                    i_tile3) +
-                               i_tile4) +
-                          i_tile5) +
-                     i_tile6)
-                    << src_offset_type::SHIFT_7T)))  // offset to start of the
-                                                     // tile
-        ,
-        dst_offset_type());
-  }
-};
-
-// Rank 8
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P, typename iType0,
-          typename iType1, typename iType2, typename iType3, typename iType4,
-          typename iType5, typename iType6, typename iType7>
-class ViewMapping<
-    std::enable_if_t<(N0 != 0 && N1 != 0 && N2 != 0 && N3 != 0 && N4 != 0 &&
-                      N5 != 0 && N6 != 0 && N7 != 0)>  // void
-    ,
-    Kokkos::ViewTraits<
-        T********,
-        Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4,
-                                          N5, N6, N7, true>,
-        P...>,
-    Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                      N6, N7, true>,
-    iType0, iType1, iType2, iType3, iType4, iType5, iType6, iType7> {
- public:
-  using src_layout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-  using src_traits = Kokkos::ViewTraits<T********, src_layout, P...>;
-
-  static constexpr bool is_outer_left = (OuterP == Kokkos::Iterate::Left);
-  static constexpr bool is_inner_left = (InnerP == Kokkos::Iterate::Left);
-  using array_layout = std::conditional_t<is_inner_left, Kokkos::LayoutLeft,
-                                          Kokkos::LayoutRight>;
-  using traits =
-      Kokkos::ViewTraits<T[N0][N1][N2][N3][N4][N5][N6][N7], array_layout, P...>;
-  using type =
-      Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6][N7], array_layout, P...>;
-
-  KOKKOS_INLINE_FUNCTION static void assign(
-      ViewMapping<traits, void>& dst, const ViewMapping<src_traits, void>& src,
-      const src_layout&, const iType0 i_tile0, const iType1 i_tile1,
-      const iType2 i_tile2, const iType3 i_tile3, const iType4 i_tile4,
-      const iType5 i_tile5, const iType6 i_tile6, const iType7 i_tile7) {
-    using dst_map_type    = ViewMapping<traits, void>;
-    using src_map_type    = ViewMapping<src_traits, void>;
-    using dst_handle_type = typename dst_map_type::handle_type;
-    using dst_offset_type = typename dst_map_type::offset_type;
-    using src_offset_type = typename src_map_type::offset_type;
-
-    dst = dst_map_type(
-        dst_handle_type(
-            src.m_impl_handle +
-            (is_outer_left
-                 ? ((i_tile0 +
-                     src.m_impl_offset.m_tile_N0 *
-                         (i_tile1 +
-                          src.m_impl_offset.m_tile_N1 *
-                              (i_tile2 +
-                               src.m_impl_offset.m_tile_N2 *
-                                   (i_tile3 +
-                                    src.m_impl_offset.m_tile_N3 *
-                                        (i_tile4 +
-                                         src.m_impl_offset.m_tile_N4 *
-                                             (i_tile5 +
-                                              src.m_impl_offset.m_tile_N5 *
-                                                  (i_tile6 +
-                                                   src.m_impl_offset.m_tile_N6 *
-                                                       i_tile7)))))))
-                    << src_offset_type::SHIFT_8T)
-                 : ((src.m_impl_offset.m_tile_N7 *
-                         (src.m_impl_offset.m_tile_N6 *
-                              (src.m_impl_offset.m_tile_N5 *
-                                   (src.m_impl_offset.m_tile_N4 *
-                                        (src.m_impl_offset.m_tile_N3 *
-                                             (src.m_impl_offset.m_tile_N2 *
-                                                  (src.m_impl_offset.m_tile_N1 *
-                                                       i_tile0 +
-                                                   i_tile1) +
-                                              i_tile2) +
-                                         i_tile3) +
-                                    i_tile4) +
-                               i_tile5) +
-                          i_tile6) +
-                     i_tile7)
-                    << src_offset_type::SHIFT_8T)))  // offset to start of the
-                                                     // tile
-        ,
-        dst_offset_type());
-  }
-};
-
-} /* namespace Impl */
-} /* namespace Kokkos */
-
-//----------------------------------------
-
-namespace Kokkos {
-
-// Rank 2
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T**,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1], array_layout, P...>(src, SrcLayout(), i_tile0,
-                                                     i_tile1);
-}
-
-// Rank 3
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1][N2],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T***,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1,
-                 const size_t i_tile2) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1][N2], array_layout, P...>(
-      src, SrcLayout(), i_tile0, i_tile1, i_tile2);
-}
-
-// Rank 4
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1][N2][N3],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T****,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1,
-                 const size_t i_tile2, const size_t i_tile3) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1][N2][N3], array_layout, P...>(
-      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3);
-}
-
-// Rank 5
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1][N2][N3][N4],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T*****,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1,
-                 const size_t i_tile2, const size_t i_tile3,
-                 const size_t i_tile4) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1][N2][N3][N4], array_layout, P...>(
-      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4);
-}
-
-// Rank 6
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1][N2][N3][N4][N5],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T******,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1,
-                 const size_t i_tile2, const size_t i_tile3,
-                 const size_t i_tile4, const size_t i_tile5) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1][N2][N3][N4][N5], array_layout, P...>(
-      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4, i_tile5);
-}
-
-// Rank 7
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T*******,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1,
-                 const size_t i_tile2, const size_t i_tile3,
-                 const size_t i_tile4, const size_t i_tile5,
-                 const size_t i_tile6) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6], array_layout, P...>(
-      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4, i_tile5,
-      i_tile6);
-}
-
-// Rank 8
-template <typename T, Kokkos::Iterate OuterP, Kokkos::Iterate InnerP,
-          unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4,
-          unsigned N5, unsigned N6, unsigned N7, class... P>
-KOKKOS_INLINE_FUNCTION
-    Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6][N7],
-                 std::conditional_t<(InnerP == Kokkos::Iterate::Left),
-                                    Kokkos::LayoutLeft, Kokkos::LayoutRight>,
-                 P...>
-    tile_subview(const Kokkos::View<
-                     T********,
-                     Kokkos::Experimental::LayoutTiled<
-                         OuterP, InnerP, N0, N1, N2, N3, N4, N5, N6, N7, true>,
-                     P...>& src,
-                 const size_t i_tile0, const size_t i_tile1,
-                 const size_t i_tile2, const size_t i_tile3,
-                 const size_t i_tile4, const size_t i_tile5,
-                 const size_t i_tile6, const size_t i_tile7) {
-  // Force the specialized ViewMapping for extracting a tile
-  // by using the first subview argument as the layout.
-  using array_layout =
-      std::conditional_t<(InnerP == Kokkos::Iterate::Left), Kokkos::LayoutLeft,
-                         Kokkos::LayoutRight>;
-  using SrcLayout =
-      Kokkos::Experimental::LayoutTiled<OuterP, InnerP, N0, N1, N2, N3, N4, N5,
-                                        N6, N7, true>;
-
-  return Kokkos::View<T[N0][N1][N2][N3][N4][N5][N6][N7], array_layout, P...>(
-      src, SrcLayout(), i_tile0, i_tile1, i_tile2, i_tile3, i_tile4, i_tile5,
-      i_tile6, i_tile7);
-}
-
-} /* namespace Kokkos */
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-#endif /* #ifndef KOKKOS_EXPERIENTAL_VIEWLAYOUTTILE_HPP */
diff --git a/core/src/impl/Kokkos_ViewMapping.hpp b/core/src/impl/Kokkos_ViewMapping.hpp
index 877004ae4c..8919dccdb7 100644
--- a/core/src/impl/Kokkos_ViewMapping.hpp
+++ b/core/src/impl/Kokkos_ViewMapping.hpp
@@ -17,6 +17,7 @@
 #ifndef KOKKOS_EXPERIMENTAL_VIEW_MAPPING_HPP
 #define KOKKOS_EXPERIMENTAL_VIEW_MAPPING_HPP
 
+#include <cstring>
 #include <type_traits>
 #include <initializer_list>
 
@@ -33,255 +34,8 @@
 #include <impl/Kokkos_Tools.hpp>
 #include <impl/Kokkos_StringManipulation.hpp>
 #include <impl/Kokkos_ZeroMemset_fwd.hpp>
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template <unsigned I, size_t... Args>
-struct variadic_size_t {
-  enum : size_t { value = KOKKOS_INVALID_INDEX };
-};
-
-template <size_t Val, size_t... Args>
-struct variadic_size_t<0, Val, Args...> {
-  enum : size_t { value = Val };
-};
-
-template <unsigned I, size_t Val, size_t... Args>
-struct variadic_size_t<I, Val, Args...> {
-  enum : size_t { value = variadic_size_t<I - 1, Args...>::value };
-};
-
-template <size_t... Args>
-struct rank_dynamic;
-
-template <>
-struct rank_dynamic<> {
-  enum : unsigned { value = 0 };
-};
-
-template <size_t Val, size_t... Args>
-struct rank_dynamic<Val, Args...> {
-  enum : unsigned { value = (Val == 0 ? 1 : 0) + rank_dynamic<Args...>::value };
-};
-
-#define KOKKOS_IMPL_VIEW_DIMENSION(R)                                       \
-  template <size_t V, unsigned>                                             \
-  struct ViewDimension##R {                                                 \
-    static constexpr size_t ArgN##R = (V != KOKKOS_INVALID_INDEX ? V : 1);  \
-    static constexpr size_t N##R    = (V != KOKKOS_INVALID_INDEX ? V : 1);  \
-    KOKKOS_INLINE_FUNCTION explicit ViewDimension##R(size_t) {}             \
-    ViewDimension##R()                        = default;                    \
-    ViewDimension##R(const ViewDimension##R&) = default;                    \
-    ViewDimension##R& operator=(const ViewDimension##R&) = default;         \
-  };                                                                        \
-  template <size_t V, unsigned RD>                                          \
-  constexpr size_t ViewDimension##R<V, RD>::ArgN##R;                        \
-  template <size_t V, unsigned RD>                                          \
-  constexpr size_t ViewDimension##R<V, RD>::N##R;                           \
-  template <unsigned RD>                                                    \
-  struct ViewDimension##R<0u, RD> {                                         \
-    static constexpr size_t ArgN##R = 0;                                    \
-    std::conditional_t<(RD < 3), size_t, unsigned> N##R;                    \
-    ViewDimension##R()                        = default;                    \
-    ViewDimension##R(const ViewDimension##R&) = default;                    \
-    ViewDimension##R& operator=(const ViewDimension##R&) = default;         \
-    KOKKOS_INLINE_FUNCTION explicit ViewDimension##R(size_t V) : N##R(V) {} \
-  };                                                                        \
-  template <unsigned RD>                                                    \
-  constexpr size_t ViewDimension##R<0u, RD>::ArgN##R;
-
-KOKKOS_IMPL_VIEW_DIMENSION(0)
-KOKKOS_IMPL_VIEW_DIMENSION(1)
-KOKKOS_IMPL_VIEW_DIMENSION(2)
-KOKKOS_IMPL_VIEW_DIMENSION(3)
-KOKKOS_IMPL_VIEW_DIMENSION(4)
-KOKKOS_IMPL_VIEW_DIMENSION(5)
-KOKKOS_IMPL_VIEW_DIMENSION(6)
-KOKKOS_IMPL_VIEW_DIMENSION(7)
-
-#undef KOKKOS_IMPL_VIEW_DIMENSION
-
-// MSVC does not do empty base class optimization by default.
-// Per standard it is required for standard layout types
-template <size_t... Vals>
-struct KOKKOS_IMPL_ENFORCE_EMPTY_BASE_OPTIMIZATION ViewDimension
-    : public ViewDimension0<variadic_size_t<0u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension1<variadic_size_t<1u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension2<variadic_size_t<2u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension3<variadic_size_t<3u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension4<variadic_size_t<4u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension5<variadic_size_t<5u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension6<variadic_size_t<6u, Vals...>::value,
-                            rank_dynamic<Vals...>::value>,
-      public ViewDimension7<variadic_size_t<7u, Vals...>::value,
-                            rank_dynamic<Vals...>::value> {
-  using D0 = ViewDimension0<variadic_size_t<0U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D1 = ViewDimension1<variadic_size_t<1U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D2 = ViewDimension2<variadic_size_t<2U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D3 = ViewDimension3<variadic_size_t<3U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D4 = ViewDimension4<variadic_size_t<4U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D5 = ViewDimension5<variadic_size_t<5U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D6 = ViewDimension6<variadic_size_t<6U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-  using D7 = ViewDimension7<variadic_size_t<7U, Vals...>::value,
-                            rank_dynamic<Vals...>::value>;
-
-  using D0::ArgN0;
-  using D1::ArgN1;
-  using D2::ArgN2;
-  using D3::ArgN3;
-  using D4::ArgN4;
-  using D5::ArgN5;
-  using D6::ArgN6;
-  using D7::ArgN7;
-
-  using D0::N0;
-  using D1::N1;
-  using D2::N2;
-  using D3::N3;
-  using D4::N4;
-  using D5::N5;
-  using D6::N6;
-  using D7::N7;
-
-  static constexpr unsigned rank         = sizeof...(Vals);
-  static constexpr unsigned rank_dynamic = Impl::rank_dynamic<Vals...>::value;
-
-  ViewDimension()                     = default;
-  ViewDimension(const ViewDimension&) = default;
-  ViewDimension& operator=(const ViewDimension&) = default;
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr ViewDimension(size_t n0, size_t n1, size_t n2, size_t n3, size_t n4,
-                          size_t n5, size_t n6, size_t n7)
-      : D0(n0 == KOKKOS_INVALID_INDEX ? 1 : n0),
-        D1(n1 == KOKKOS_INVALID_INDEX ? 1 : n1),
-        D2(n2 == KOKKOS_INVALID_INDEX ? 1 : n2),
-        D3(n3 == KOKKOS_INVALID_INDEX ? 1 : n3),
-        D4(n4 == KOKKOS_INVALID_INDEX ? 1 : n4),
-        D5(n5 == KOKKOS_INVALID_INDEX ? 1 : n5),
-        D6(n6 == KOKKOS_INVALID_INDEX ? 1 : n6),
-        D7(n7 == KOKKOS_INVALID_INDEX ? 1 : n7) {}
-
-  KOKKOS_INLINE_FUNCTION
-  constexpr size_t extent(const unsigned r) const noexcept {
-    return r == 0
-               ? N0
-               : (r == 1
-                      ? N1
-                      : (r == 2
-                             ? N2
-                             : (r == 3
-                                    ? N3
-                                    : (r == 4
-                                           ? N4
-                                           : (r == 5
-                                                  ? N5
-                                                  : (r == 6
-                                                         ? N6
-                                                         : (r == 7 ? N7
-                                                                   : 0)))))));
-  }
-
-  static KOKKOS_INLINE_FUNCTION constexpr size_t static_extent(
-      const unsigned r) noexcept {
-    return r == 0
-               ? ArgN0
-               : (r == 1
-                      ? ArgN1
-                      : (r == 2
-                             ? ArgN2
-                             : (r == 3
-                                    ? ArgN3
-                                    : (r == 4
-                                           ? ArgN4
-                                           : (r == 5
-                                                  ? ArgN5
-                                                  : (r == 6
-                                                         ? ArgN6
-                                                         : (r == 7 ? ArgN7
-                                                                   : 0)))))));
-  }
-
-  template <size_t N>
-  struct prepend {
-    using type = ViewDimension<N, Vals...>;
-  };
-
-  template <size_t N>
-  struct append {
-    using type = ViewDimension<Vals..., N>;
-  };
-};
-
-template <class A, class B>
-struct ViewDimensionJoin;
-
-template <size_t... A, size_t... B>
-struct ViewDimensionJoin<ViewDimension<A...>, ViewDimension<B...>> {
-  using type = ViewDimension<A..., B...>;
-};
-
-//----------------------------------------------------------------------------
-
-template <class DstDim, class SrcDim>
-struct ViewDimensionAssignable;
-
-template <size_t... DstArgs, size_t... SrcArgs>
-struct ViewDimensionAssignable<ViewDimension<DstArgs...>,
-                               ViewDimension<SrcArgs...>> {
-  using dst = ViewDimension<DstArgs...>;
-  using src = ViewDimension<SrcArgs...>;
-
-  enum {
-    value = unsigned(dst::rank) == unsigned(src::rank) &&
-            (
-                // Compile time check that potential static dimensions match
-                ((1 > dst::rank_dynamic && 1 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN0) == size_t(src::ArgN0))
-                     : true) &&
-                ((2 > dst::rank_dynamic && 2 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN1) == size_t(src::ArgN1))
-                     : true) &&
-                ((3 > dst::rank_dynamic && 3 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN2) == size_t(src::ArgN2))
-                     : true) &&
-                ((4 > dst::rank_dynamic && 4 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN3) == size_t(src::ArgN3))
-                     : true) &&
-                ((5 > dst::rank_dynamic && 5 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN4) == size_t(src::ArgN4))
-                     : true) &&
-                ((6 > dst::rank_dynamic && 6 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN5) == size_t(src::ArgN5))
-                     : true) &&
-                ((7 > dst::rank_dynamic && 7 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN6) == size_t(src::ArgN6))
-                     : true) &&
-                ((8 > dst::rank_dynamic && 8 > src::rank_dynamic)
-                     ? (size_t(dst::ArgN7) == size_t(src::ArgN7))
-                     : true))
-  };
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
+#include <impl/Kokkos_ViewDataAnalysis.hpp>
+#include <View/Kokkos_ViewAlloc.hpp>
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
@@ -657,21 +411,20 @@ struct SubviewExtents {
   template <size_t... DimArgs, class... Args>
   KOKKOS_INLINE_FUNCTION SubviewExtents(const ViewDimension<DimArgs...>& dim,
                                         Args... args) {
-    static_assert(DomainRank == sizeof...(DimArgs), "");
-    static_assert(DomainRank == sizeof...(Args), "");
+    static_assert(DomainRank == sizeof...(DimArgs));
+    static_assert(DomainRank == sizeof...(Args));
 
     // Verifies that all arguments, up to 8, are integral types,
     // integral extents, or don't exist.
-    static_assert(
-        RangeRank == unsigned(is_integral_extent<0, Args...>::value) +
-                         unsigned(is_integral_extent<1, Args...>::value) +
-                         unsigned(is_integral_extent<2, Args...>::value) +
-                         unsigned(is_integral_extent<3, Args...>::value) +
-                         unsigned(is_integral_extent<4, Args...>::value) +
-                         unsigned(is_integral_extent<5, Args...>::value) +
-                         unsigned(is_integral_extent<6, Args...>::value) +
-                         unsigned(is_integral_extent<7, Args...>::value),
-        "");
+    static_assert(RangeRank ==
+                  unsigned(is_integral_extent<0, Args...>::value) +
+                      unsigned(is_integral_extent<1, Args...>::value) +
+                      unsigned(is_integral_extent<2, Args...>::value) +
+                      unsigned(is_integral_extent<3, Args...>::value) +
+                      unsigned(is_integral_extent<4, Args...>::value) +
+                      unsigned(is_integral_extent<5, Args...>::value) +
+                      unsigned(is_integral_extent<6, Args...>::value) +
+                      unsigned(is_integral_extent<7, Args...>::value));
 
     if (RangeRank == 0) {
       m_length[0] = 0;
@@ -708,149 +461,6 @@ struct SubviewExtents {
 
 namespace Kokkos {
 namespace Impl {
-
-/** \brief  Given a value type and dimension generate the View data type */
-template <class T, class Dim>
-struct ViewDataType;
-
-template <class T>
-struct ViewDataType<T, ViewDimension<>> {
-  using type = T;
-};
-
-template <class T, size_t... Args>
-struct ViewDataType<T, ViewDimension<0, Args...>> {
-  using type = typename ViewDataType<T*, ViewDimension<Args...>>::type;
-};
-
-template <class T, size_t N, size_t... Args>
-struct ViewDataType<T, ViewDimension<N, Args...>> {
-  using type = typename ViewDataType<T, ViewDimension<Args...>>::type[N];
-};
-
-/**\brief  Analysis of View data type.
- *
- *  Data type conforms to one of the following patterns :
- *    {const} value_type [][#][#][#]
- *    {const} value_type ***[#][#][#]
- *  Where the sum of counts of '*' and '[#]' is at most ten.
- *
- *  Provide alias for ViewDimension<...> and value_type.
- */
-template <class T>
-struct ViewArrayAnalysis {
-  using value_type           = T;
-  using const_value_type     = std::add_const_t<T>;
-  using non_const_value_type = std::remove_const_t<T>;
-  using static_dimension     = ViewDimension<>;
-  using dynamic_dimension    = ViewDimension<>;
-  using dimension            = ViewDimension<>;
-};
-
-template <class T, size_t N>
-struct ViewArrayAnalysis<T[N]> {
- private:
-  using nested = ViewArrayAnalysis<T>;
-
- public:
-  using value_type           = typename nested::value_type;
-  using const_value_type     = typename nested::const_value_type;
-  using non_const_value_type = typename nested::non_const_value_type;
-
-  using static_dimension =
-      typename nested::static_dimension::template prepend<N>::type;
-
-  using dynamic_dimension = typename nested::dynamic_dimension;
-
-  using dimension =
-      typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type;
-};
-
-template <class T>
-struct ViewArrayAnalysis<T[]> {
- private:
-  using nested           = ViewArrayAnalysis<T>;
-  using nested_dimension = typename nested::dimension;
-
- public:
-  using value_type           = typename nested::value_type;
-  using const_value_type     = typename nested::const_value_type;
-  using non_const_value_type = typename nested::non_const_value_type;
-
-  using dynamic_dimension =
-      typename nested::dynamic_dimension::template prepend<0>::type;
-
-  using static_dimension = typename nested::static_dimension;
-
-  using dimension =
-      typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type;
-};
-
-template <class T>
-struct ViewArrayAnalysis<T*> {
- private:
-  using nested = ViewArrayAnalysis<T>;
-
- public:
-  using value_type           = typename nested::value_type;
-  using const_value_type     = typename nested::const_value_type;
-  using non_const_value_type = typename nested::non_const_value_type;
-
-  using dynamic_dimension =
-      typename nested::dynamic_dimension::template prepend<0>::type;
-
-  using static_dimension = typename nested::static_dimension;
-
-  using dimension =
-      typename ViewDimensionJoin<dynamic_dimension, static_dimension>::type;
-};
-
-template <class DataType, class ArrayLayout, class ValueType>
-struct ViewDataAnalysis {
- private:
-  using array_analysis = ViewArrayAnalysis<DataType>;
-
-  // ValueType is opportunity for partial specialization.
-  // Must match array analysis when this default template is used.
-  static_assert(
-      std::is_same<ValueType,
-                   typename array_analysis::non_const_value_type>::value,
-      "");
-
- public:
-  using specialize = void;  // No specialization
-
-  using dimension            = typename array_analysis::dimension;
-  using value_type           = typename array_analysis::value_type;
-  using const_value_type     = typename array_analysis::const_value_type;
-  using non_const_value_type = typename array_analysis::non_const_value_type;
-
-  // Generate analogous multidimensional array specification type.
-  using type       = typename ViewDataType<value_type, dimension>::type;
-  using const_type = typename ViewDataType<const_value_type, dimension>::type;
-  using non_const_type =
-      typename ViewDataType<non_const_value_type, dimension>::type;
-
-  // Generate "flattened" multidimensional array specification type.
-  using scalar_array_type           = type;
-  using const_scalar_array_type     = const_type;
-  using non_const_scalar_array_type = non_const_type;
-};
-
-}  // namespace Impl
-}  // namespace Kokkos
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-
-namespace Kokkos {
-namespace Impl {
-
-template <class Dimension, class Layout, class Enable = void>
-struct ViewOffset {
-  using is_mapping_plugin = std::false_type;
-};
-
 //----------------------------------------------------------------------------
 // LayoutLeft AND ( 1 >= rank OR 0 == rank_dynamic ) : no padding / striding
 template <class Dimension>
@@ -1039,34 +649,60 @@ struct ViewOffset<
            m_dim.N5 * m_dim.N6;
   }
 
-  // Stride with [ rank ] value is the total length
+  // Fill the target unbounded array s with the stride.
+  // This method differs from stride() in that it does not write the total
+  // length to the last index of the array. Preconditions: s must be an array of
+  // dimension_type::rank elements
+  // FIXME: The version of clang-format in CI fails from maybe_unused
+  // clang-format off
   template <typename iType>
-  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
-    s[0] = 1;
-    if (0 < dimension_type::rank) {
-      s[1] = m_dim.N0;
+  KOKKOS_INLINE_FUNCTION iType
+  stride_fill([[maybe_unused]] iType* const s) const {
+    iType n = 1;
+    if constexpr (0 < dimension_type::rank) {
+      s[0] = n;
+      n *= m_dim.N0;
     }
-    if (1 < dimension_type::rank) {
-      s[2] = s[1] * m_dim.N1;
+    if constexpr (1 < dimension_type::rank) {
+      s[1] = n;
+      n *= m_dim.N1;
     }
-    if (2 < dimension_type::rank) {
-      s[3] = s[2] * m_dim.N2;
+    if constexpr (2 < dimension_type::rank) {
+      s[2] = n;
+      n *= m_dim.N2;
     }
-    if (3 < dimension_type::rank) {
-      s[4] = s[3] * m_dim.N3;
+    if constexpr (3 < dimension_type::rank) {
+      s[3] = n;
+      n *= m_dim.N3;
     }
-    if (4 < dimension_type::rank) {
-      s[5] = s[4] * m_dim.N4;
+    if constexpr (4 < dimension_type::rank) {
+      s[4] = n;
+      n *= m_dim.N4;
     }
-    if (5 < dimension_type::rank) {
-      s[6] = s[5] * m_dim.N5;
+    if constexpr (5 < dimension_type::rank) {
+      s[5] = n;
+      n *= m_dim.N5;
     }
-    if (6 < dimension_type::rank) {
-      s[7] = s[6] * m_dim.N6;
+    if constexpr (6 < dimension_type::rank) {
+      s[6] = n;
+      n *= m_dim.N6;
     }
-    if (7 < dimension_type::rank) {
-      s[8] = s[7] * m_dim.N7;
+    if constexpr (7 < dimension_type::rank) {
+      s[7] = n;
+      n *= m_dim.N7;
     }
+    return n;
+  }
+  // clang-format on
+
+  // Fill the target unbounded array s with the stride and the total spanned
+  // size. This method differs from stride_fill() in that it writes the total
+  // spanned size to the last index of the array. Preconditions: s must be an
+  // array of dimension_type::rank + 1 elements Stride with [ rank ] value is
+  // the total length
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[dimension_type::rank] = stride_fill(s);
   }
 
   //----------------------------------------
@@ -1327,34 +963,59 @@ struct ViewOffset<
            m_dim.N6;
   }
 
-  // Stride with [ rank ] value is the total length
+  // Fill the target unbounded array s with the stride.
+  // This method differs from stride() in that it does not write the total
+  // length to the last index of the array. Preconditions: s must be an array of
+  // dimension_type::rank elements
+  // The version of clang-format in CI fails from maybe_unused
+  // clang-format off
   template <typename iType>
-  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
-    s[0] = 1;
-    if (0 < dimension_type::rank) {
-      s[1] = m_stride;
+  KOKKOS_INLINE_FUNCTION iType
+  stride_fill([[maybe_unused]] iType* const s) const {
+    iType n = 1;
+    if constexpr (0 < dimension_type::rank) {
+      s[0] = n;
+      n *= m_stride;
     }
-    if (1 < dimension_type::rank) {
-      s[2] = s[1] * m_dim.N1;
+    if constexpr (1 < dimension_type::rank) {
+      s[1] = n;
+      n *= m_dim.N1;
     }
-    if (2 < dimension_type::rank) {
-      s[3] = s[2] * m_dim.N2;
+    if constexpr (2 < dimension_type::rank) {
+      s[2] = n;
+      n *= m_dim.N2;
     }
-    if (3 < dimension_type::rank) {
-      s[4] = s[3] * m_dim.N3;
+    if constexpr (3 < dimension_type::rank) {
+      s[3] = n;
+      n *= m_dim.N3;
     }
-    if (4 < dimension_type::rank) {
-      s[5] = s[4] * m_dim.N4;
+    if constexpr (4 < dimension_type::rank) {
+      s[4] = n;
+      n *= m_dim.N4;
     }
-    if (5 < dimension_type::rank) {
-      s[6] = s[5] * m_dim.N5;
+    if constexpr (5 < dimension_type::rank) {
+      s[5] = n;
+      n *= m_dim.N5;
     }
-    if (6 < dimension_type::rank) {
-      s[7] = s[6] * m_dim.N6;
+    if constexpr (6 < dimension_type::rank) {
+      s[6] = n;
+      n *= m_dim.N6;
     }
-    if (7 < dimension_type::rank) {
-      s[8] = s[7] * m_dim.N7;
+    if constexpr (7 < dimension_type::rank) {
+      s[7] = n;
+      n *= m_dim.N7;
     }
+    return n;
+  }
+  // clang-format on
+
+  // Fill the target unbounded array s with the stride and the total spanned
+  // size. This method differs from stride_fill() in that it writes the total
+  // spanned size to the last index of the array. Preconditions: s must be an
+  // array of dimension_type::rank + 1 elements
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[dimension_type::rank] = stride_fill(s);
   }
 
   //----------------------------------------
@@ -1678,42 +1339,58 @@ struct ViewOffset<
            m_dim.N1;
   }
 
-  // Stride with [ rank ] value is the total length
+  // Fill the target unbounded array s with the stride.
+  // This method differs from stride() in that it does not write the total
+  // length to the last index of the array. Preconditions: s must be an array of
+  // dimension_type::rank elements
+  // The version of clang-format in CI fails from maybe_unused
+  // clang-format off
   template <typename iType>
-  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+  KOKKOS_INLINE_FUNCTION iType
+  stride_fill([[maybe_unused]] iType* const s) const {
     size_type n = 1;
-    if (7 < dimension_type::rank) {
+    if constexpr (7 < dimension_type::rank) {
       s[7] = n;
       n *= m_dim.N7;
     }
-    if (6 < dimension_type::rank) {
+    if constexpr (6 < dimension_type::rank) {
       s[6] = n;
       n *= m_dim.N6;
     }
-    if (5 < dimension_type::rank) {
+    if constexpr (5 < dimension_type::rank) {
       s[5] = n;
       n *= m_dim.N5;
     }
-    if (4 < dimension_type::rank) {
+    if constexpr (4 < dimension_type::rank) {
       s[4] = n;
       n *= m_dim.N4;
     }
-    if (3 < dimension_type::rank) {
+    if constexpr (3 < dimension_type::rank) {
       s[3] = n;
       n *= m_dim.N3;
     }
-    if (2 < dimension_type::rank) {
+    if constexpr (2 < dimension_type::rank) {
       s[2] = n;
       n *= m_dim.N2;
     }
-    if (1 < dimension_type::rank) {
+    if constexpr (1 < dimension_type::rank) {
       s[1] = n;
       n *= m_dim.N1;
     }
-    if (0 < dimension_type::rank) {
+    if constexpr (0 < dimension_type::rank) {
       s[0] = n;
     }
-    s[dimension_type::rank] = n * m_dim.N0;
+    return n * m_dim.N0;
+  }
+  // clang-format on
+
+  // Fill the target unbounded array s with the stride and the total spanned
+  // size. This method differs from stride_fill() in that it writes the total
+  // spanned size to the last index of the array. Preconditions: s must be an
+  // array of dimension_type::rank + 1 elements
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[dimension_type::rank] = stride_fill(s);
   }
 
   //----------------------------------------
@@ -1965,41 +1642,57 @@ struct ViewOffset<
     return m_stride;
   }
 
-  // Stride with [ rank ] value is the total length
+  // Fill the target unbounded array s with the stride.
+  // This method differs from stride() in that it does not write the total
+  // length to the last index of the array. Preconditions: s must be an array of
+  // dimension_type::rank elements
+  // The version of clang-format in CI fails from maybe_unused
+  // clang-format off
   template <typename iType>
-  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+  KOKKOS_INLINE_FUNCTION iType
+  stride_fill([[maybe_unused]] iType* const s) const {
     size_type n = 1;
-    if (7 < dimension_type::rank) {
+    if constexpr (7 < dimension_type::rank) {
       s[7] = n;
       n *= m_dim.N7;
     }
-    if (6 < dimension_type::rank) {
+    if constexpr (6 < dimension_type::rank) {
       s[6] = n;
       n *= m_dim.N6;
     }
-    if (5 < dimension_type::rank) {
+    if constexpr (5 < dimension_type::rank) {
       s[5] = n;
       n *= m_dim.N5;
     }
-    if (4 < dimension_type::rank) {
+    if constexpr (4 < dimension_type::rank) {
       s[4] = n;
       n *= m_dim.N4;
     }
-    if (3 < dimension_type::rank) {
+    if constexpr (3 < dimension_type::rank) {
       s[3] = n;
       n *= m_dim.N3;
     }
-    if (2 < dimension_type::rank) {
+    if constexpr (2 < dimension_type::rank) {
       s[2] = n;
       n *= m_dim.N2;
     }
-    if (1 < dimension_type::rank) {
+    if constexpr (1 < dimension_type::rank) {
       s[1] = n;
     }
-    if (0 < dimension_type::rank) {
+    if constexpr (0 < dimension_type::rank) {
       s[0] = m_stride;
     }
-    s[dimension_type::rank] = m_stride * m_dim.N0;
+    return m_stride * m_dim.N0;
+  }
+  // clang-format on
+
+  // Fill the target unbounded array s with the stride and the total spanned
+  // size. This method differs from stride_fill() in that it writes the total
+  // spanned size to the last index of the array. Preconditions: s must be an
+  // array of dimension_type::rank + 1 elements
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[dimension_type::rank] = stride_fill(s);
   }
 
   //----------------------------------------
@@ -2525,34 +2218,50 @@ struct ViewOffset<Dimension, Kokkos::LayoutStride, void> {
     return m_stride.S7;
   }
 
-  // Stride with [ rank ] value is the total length
+  // Fill the target unbounded array s with the stride.
+  // This method differs from stride() in that it does not write the total
+  // length to the last index of the array. Preconditions: s must be an array of
+  // dimension_type::rank elements
+  // The version of clang-format in CI fails from maybe_unused
+  // clang-format off
   template <typename iType>
-  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
-    if (0 < dimension_type::rank) {
+  KOKKOS_INLINE_FUNCTION iType
+  stride_fill([[maybe_unused]] iType* const s) const {
+    if constexpr (0 < dimension_type::rank) {
       s[0] = m_stride.S0;
     }
-    if (1 < dimension_type::rank) {
+    if constexpr (1 < dimension_type::rank) {
       s[1] = m_stride.S1;
     }
-    if (2 < dimension_type::rank) {
+    if constexpr (2 < dimension_type::rank) {
       s[2] = m_stride.S2;
     }
-    if (3 < dimension_type::rank) {
+    if constexpr (3 < dimension_type::rank) {
       s[3] = m_stride.S3;
     }
-    if (4 < dimension_type::rank) {
+    if constexpr (4 < dimension_type::rank) {
       s[4] = m_stride.S4;
     }
-    if (5 < dimension_type::rank) {
+    if constexpr (5 < dimension_type::rank) {
       s[5] = m_stride.S5;
     }
-    if (6 < dimension_type::rank) {
+    if constexpr (6 < dimension_type::rank) {
       s[6] = m_stride.S6;
     }
-    if (7 < dimension_type::rank) {
+    if constexpr (7 < dimension_type::rank) {
       s[7] = m_stride.S7;
     }
-    s[dimension_type::rank] = span();
+    return span();
+  }
+  // clang-format on
+
+  // Fill the target unbounded array s with the stride and the total spanned
+  // size. This method differs from stride_fill() in that it writes the total
+  // spanned size to the last index of the array. Preconditions: s must be an
+  // array of dimension_type::rank + 1 elements
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
+    s[dimension_type::rank] = stride_fill(s);
   }
 
   //----------------------------------------
@@ -2820,304 +2529,6 @@ struct ViewDataHandle<
 
 namespace Kokkos {
 namespace Impl {
-
-template <typename T>
-inline bool is_zero_byte(const T& t) {
-  using comparison_type = std::conditional_t<
-      sizeof(T) % sizeof(long long int) == 0, long long int,
-      std::conditional_t<
-          sizeof(T) % sizeof(long int) == 0, long int,
-          std::conditional_t<
-              sizeof(T) % sizeof(int) == 0, int,
-              std::conditional_t<sizeof(T) % sizeof(short int) == 0, short int,
-                                 char>>>>;
-  const auto* const ptr = reinterpret_cast<const comparison_type*>(&t);
-  for (std::size_t i = 0; i < sizeof(T) / sizeof(comparison_type); ++i)
-    if (ptr[i] != 0) return false;
-  return true;
-}
-
-//----------------------------------------------------------------------------
-
-/*
- *  The construction, assignment to default, and destruction
- *  are merged into a single functor.
- *  Primarily to work around an unresolved CUDA back-end bug
- *  that would lose the destruction cuda device function when
- *  called from the shared memory tracking destruction.
- *  Secondarily to have two fewer partial specializations.
- */
-template <class DeviceType, class ValueType,
-          bool IsScalar = std::is_scalar<ValueType>::value>
-struct ViewValueFunctor;
-
-template <class DeviceType, class ValueType>
-struct ViewValueFunctor<DeviceType, ValueType, false /* is_scalar */> {
-  using ExecSpace = typename DeviceType::execution_space;
-
-  struct DestroyTag {};
-  struct ConstructTag {};
-
-  ExecSpace space;
-  ValueType* ptr;
-  size_t n;
-  std::string name;
-  bool default_exec_space;
-
-  template <class _ValueType = ValueType>
-  KOKKOS_INLINE_FUNCTION
-      std::enable_if_t<std::is_default_constructible<_ValueType>::value>
-      operator()(ConstructTag const&, const size_t i) const {
-    new (ptr + i) ValueType();
-  }
-
-  KOKKOS_INLINE_FUNCTION void operator()(DestroyTag const&,
-                                         const size_t i) const {
-    (ptr + i)->~ValueType();
-  }
-
-  ViewValueFunctor()                        = default;
-  ViewValueFunctor(const ViewValueFunctor&) = default;
-  ViewValueFunctor& operator=(const ViewValueFunctor&) = default;
-
-  ViewValueFunctor(ExecSpace const& arg_space, ValueType* const arg_ptr,
-                   size_t const arg_n, std::string arg_name)
-      : space(arg_space),
-        ptr(arg_ptr),
-        n(arg_n),
-        name(std::move(arg_name)),
-        default_exec_space(false) {
-    functor_instantiate_workaround();
-  }
-
-  ViewValueFunctor(ValueType* const arg_ptr, size_t const arg_n,
-                   std::string arg_name)
-      : space(ExecSpace{}),
-        ptr(arg_ptr),
-        n(arg_n),
-        name(std::move(arg_name)),
-        default_exec_space(true) {
-    functor_instantiate_workaround();
-  }
-
-  template <typename Dummy = ValueType>
-  std::enable_if_t<std::is_trivial<Dummy>::value &&
-                   std::is_trivially_copy_assignable<ValueType>::value>
-  construct_dispatch() {
-    ValueType value{};
-// On A64FX memset seems to do the wrong thing with regards to first touch
-// leading to the significant performance issues
-#ifndef KOKKOS_ARCH_A64FX
-    if (Impl::is_zero_byte(value)) {
-      uint64_t kpID = 0;
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        // We are not really using parallel_for here but using beginParallelFor
-        // instead of begin_parallel_for (and adding "via memset") is the best
-        // we can do to indicate that this is not supposed to be tunable (and
-        // doesn't really execute a parallel_for).
-        Kokkos::Profiling::beginParallelFor(
-            "Kokkos::View::initialization [" + name + "] via memset",
-            Kokkos::Profiling::Experimental::device_id(space), &kpID);
-      }
-      (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),
-          value);
-
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        Kokkos::Profiling::endParallelFor(kpID);
-      }
-      if (default_exec_space)
-        space.fence("Kokkos::Impl::ViewValueFunctor: View init/destroy fence");
-    } else {
-#endif
-      parallel_for_implementation<ConstructTag>();
-#ifndef KOKKOS_ARCH_A64FX
-    }
-#endif
-  }
-
-  template <typename Dummy = ValueType>
-  std::enable_if_t<!(std::is_trivial<Dummy>::value &&
-                     std::is_trivially_copy_assignable<ValueType>::value)>
-  construct_dispatch() {
-    parallel_for_implementation<ConstructTag>();
-  }
-
-  template <typename Tag>
-  void parallel_for_implementation() {
-    if (!space.in_parallel()) {
-      using PolicyType =
-          Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<int64_t>, Tag>;
-      PolicyType policy(space, 0, n);
-      uint64_t kpID = 0;
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        const std::string functor_name =
-            (std::is_same_v<Tag, DestroyTag>
-                 ? "Kokkos::View::destruction [" + name + "]"
-                 : "Kokkos::View::initialization [" + name + "]");
-        Kokkos::Profiling::beginParallelFor(
-            functor_name, Kokkos::Profiling::Experimental::device_id(space),
-            &kpID);
-      }
-
-#ifdef KOKKOS_ENABLE_CUDA
-      if (std::is_same<ExecSpace, Kokkos::Cuda>::value) {
-        Kokkos::Impl::cuda_prefetch_pointer(space, ptr, sizeof(ValueType) * n,
-                                            true);
-      }
-#endif
-      const Kokkos::Impl::ParallelFor<ViewValueFunctor, PolicyType> closure(
-          *this, policy);
-      closure.execute();
-      if (default_exec_space || std::is_same_v<Tag, DestroyTag>)
-        space.fence("Kokkos::Impl::ViewValueFunctor: View init/destroy fence");
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        Kokkos::Profiling::endParallelFor(kpID);
-      }
-    } else {
-      for (size_t i = 0; i < n; ++i) operator()(Tag{}, i);
-    }
-  }
-
-  void construct_shared_allocation() { construct_dispatch(); }
-
-  void destroy_shared_allocation() {
-    parallel_for_implementation<DestroyTag>();
-  }
-
-  // This function is to ensure that the functor with DestroyTag is instantiated
-  // This is a workaround to avoid "cudaErrorInvalidDeviceFunction" error later
-  // when the function is queried with cudaFuncGetAttributes
-  void functor_instantiate_workaround() {
-#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) || \
-    defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENMPTARGET)
-    if (false) {
-      parallel_for_implementation<DestroyTag>();
-    }
-#endif
-  }
-};
-
-template <class DeviceType, class ValueType>
-struct ViewValueFunctor<DeviceType, ValueType, true /* is_scalar */> {
-  using ExecSpace  = typename DeviceType::execution_space;
-  using PolicyType = Kokkos::RangePolicy<ExecSpace, Kokkos::IndexType<int64_t>>;
-
-  ExecSpace space;
-  ValueType* ptr;
-  size_t n;
-  std::string name;
-  bool default_exec_space;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const size_t i) const { ptr[i] = ValueType(); }
-
-  ViewValueFunctor()                        = default;
-  ViewValueFunctor(const ViewValueFunctor&) = default;
-  ViewValueFunctor& operator=(const ViewValueFunctor&) = default;
-
-  ViewValueFunctor(ExecSpace const& arg_space, ValueType* const arg_ptr,
-                   size_t const arg_n, std::string arg_name)
-      : space(arg_space),
-        ptr(arg_ptr),
-        n(arg_n),
-        name(std::move(arg_name)),
-        default_exec_space(false) {}
-
-  ViewValueFunctor(ValueType* const arg_ptr, size_t const arg_n,
-                   std::string arg_name)
-      : space(ExecSpace{}),
-        ptr(arg_ptr),
-        n(arg_n),
-        name(std::move(arg_name)),
-        default_exec_space(true) {}
-
-  template <typename Dummy = ValueType>
-  std::enable_if_t<std::is_trivial<Dummy>::value &&
-                   std::is_trivially_copy_assignable<Dummy>::value>
-  construct_shared_allocation() {
-    // Shortcut for zero initialization
-// On A64FX memset seems to do the wrong thing with regards to first touch
-// leading to the significant performance issues
-#ifndef KOKKOS_ARCH_A64FX
-    ValueType value{};
-    if (Impl::is_zero_byte(value)) {
-      uint64_t kpID = 0;
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        // We are not really using parallel_for here but using beginParallelFor
-        // instead of begin_parallel_for (and adding "via memset") is the best
-        // we can do to indicate that this is not supposed to be tunable (and
-        // doesn't really execute a parallel_for).
-        Kokkos::Profiling::beginParallelFor(
-            "Kokkos::View::initialization [" + name + "] via memset",
-            Kokkos::Profiling::Experimental::device_id(space), &kpID);
-      }
-
-      (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),
-          value);
-
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        Kokkos::Profiling::endParallelFor(kpID);
-      }
-      if (default_exec_space)
-        space.fence("Kokkos::Impl::ViewValueFunctor: View init/destroy fence");
-    } else {
-#endif
-      parallel_for_implementation();
-#ifndef KOKKOS_ARCH_A64FX
-    }
-#endif
-  }
-
-  template <typename Dummy = ValueType>
-  std::enable_if_t<!(std::is_trivial<Dummy>::value &&
-                     std::is_trivially_copy_assignable<Dummy>::value)>
-  construct_shared_allocation() {
-    parallel_for_implementation();
-  }
-
-  void parallel_for_implementation() {
-    if (!space.in_parallel()) {
-      PolicyType policy(0, n);
-      uint64_t kpID = 0;
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        Kokkos::Profiling::beginParallelFor(
-            "Kokkos::View::initialization [" + name + "]",
-            Kokkos::Profiling::Experimental::device_id(space), &kpID);
-      }
-#ifdef KOKKOS_ENABLE_CUDA
-      if (std::is_same<ExecSpace, Kokkos::Cuda>::value) {
-        Kokkos::Impl::cuda_prefetch_pointer(space, ptr, sizeof(ValueType) * n,
-                                            true);
-      }
-#endif
-      const Kokkos::Impl::ParallelFor<ViewValueFunctor, PolicyType> closure(
-          *this, PolicyType(0, n));
-      closure.execute();
-      if (default_exec_space)
-        space.fence(
-            "Kokkos::Impl::ViewValueFunctor: Fence after setting values in "
-            "view");
-      if (Kokkos::Profiling::profileLibraryLoaded()) {
-        Kokkos::Profiling::endParallelFor(kpID);
-      }
-    } else {
-      for (size_t i = 0; i < n; ++i) operator()(i);
-    }
-  }
-
-  void destroy_shared_allocation() {}
-};
-
 //----------------------------------------------------------------------------
 /** \brief  View mapping for non-specialized data type and standard layout */
 template <class Traits>
@@ -3222,11 +2633,24 @@ class ViewMapping<
     return m_impl_offset.stride_7();
   }
 
+  // Fill the target unbounded array s with the stride and the total spanned
+  // size. This method differs from stride_fill() in that it writes the total
+  // spanned size to the last index of the array. Preconditions: s must be an
+  // array of dimension_type::rank + 1 elements
   template <typename iType>
   KOKKOS_INLINE_FUNCTION void stride(iType* const s) const {
     m_impl_offset.stride(s);
   }
 
+  // Fill the target unbounded array s with the stride.
+  // This method differs from stride() in that it does not write the total
+  // length to the last index of the array. Preconditions: s must be an array of
+  // dimension_type::rank elements
+  template <typename iType>
+  KOKKOS_INLINE_FUNCTION iType stride_fill(iType* const s) const {
+    return m_impl_offset.stride_fill(s);
+  }
+
   //----------------------------------------
   // Range span
 
@@ -3667,7 +3091,7 @@ class ViewMapping<
     size_t exp_stride = 1;
     if (std::is_same<typename DstTraits::array_layout,
                      Kokkos::LayoutLeft>::value) {
-      for (unsigned int i = 0; i < src.Rank; i++) {
+      for (int i = 0; i < (int)src.Rank; i++) {
         if (i > 0) exp_stride *= src.extent(i - 1);
         if (strides[i] != exp_stride) {
           assignable = false;
@@ -3676,7 +3100,7 @@ class ViewMapping<
       }
     } else if (std::is_same<typename DstTraits::array_layout,
                             Kokkos::LayoutRight>::value) {
-      for (unsigned int i = 0; i < src.Rank; i++) {
+      for (int i = 0; i < (int)src.Rank; i++) {
         if (i > 0) exp_stride *= src.extent(src.Rank - i);
         if (strides[src.Rank - 1 - i] != exp_stride) {
           assignable = false;
@@ -3768,7 +3192,7 @@ struct SubViewDataTypeImpl<void, ValueType, Kokkos::Experimental::Extents<>> {
 };
 
 /* for integral args, subview doesn't have that dimension */
-template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class Integral,
+template <class ValueType, size_t Ext, size_t... Exts, class Integral,
           class... Args>
 struct SubViewDataTypeImpl<
     std::enable_if_t<std::is_integral<std::decay_t<Integral>>::value>,
@@ -3777,7 +3201,7 @@ struct SubViewDataTypeImpl<
                           Kokkos::Experimental::Extents<Exts...>, Args...> {};
 
 /* for ALL slice, subview has the same dimension */
-template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class... Args>
+template <class ValueType, size_t Ext, size_t... Exts, class... Args>
 struct SubViewDataTypeImpl<void, ValueType,
                            Kokkos::Experimental::Extents<Ext, Exts...>,
                            Kokkos::ALL_t, Args...>
@@ -3788,7 +3212,7 @@ struct SubViewDataTypeImpl<void, ValueType,
  * static sizes */
 /* Since we don't allow interleaving of dynamic and static extents, make all of
  * the dimensions to the left dynamic  */
-template <class ValueType, ptrdiff_t Ext, ptrdiff_t... Exts, class PairLike,
+template <class ValueType, size_t Ext, size_t... Exts, class PairLike,
           class... Args>
 struct SubViewDataTypeImpl<
     std::enable_if_t<is_pair_like<PairLike>::value>, ValueType,
@@ -3896,7 +3320,7 @@ class ViewMapping<
 
   template <class MemoryTraits>
   struct apply {
-    static_assert(Kokkos::is_memory_traits<MemoryTraits>::value, "");
+    static_assert(Kokkos::is_memory_traits<MemoryTraits>::value);
 
     using traits_type =
         Kokkos::ViewTraits<data_type, array_layout,
@@ -3945,110 +3369,86 @@ class ViewMapping<
 namespace Kokkos {
 namespace Impl {
 
-template <unsigned, class MapType>
-KOKKOS_INLINE_FUNCTION bool view_verify_operator_bounds(const MapType&) {
-  return true;
+template <class Map, class... Indices, std::size_t... Enumerate>
+KOKKOS_FUNCTION bool within_range(Map const& map,
+                                  std::index_sequence<Enumerate...>,
+                                  Indices... indices) {
+  return (((std::size_t)indices < map.extent(Enumerate)) && ...);
 }
 
-template <unsigned R, class MapType, class iType, class... Args>
-KOKKOS_INLINE_FUNCTION bool view_verify_operator_bounds(const MapType& map,
-                                                        const iType& i,
-                                                        Args... args) {
-  return (size_t(i) < map.extent(R)) &&
-         view_verify_operator_bounds<R + 1>(map, args...);
+template <class... Indices>
+KOKKOS_FUNCTION constexpr char* append_formatted_multidimensional_index(
+    char* dest, Indices... indices) {
+  char* d = dest;
+  strcat(d, "[");
+  (
+      [&] {
+        d += strlen(d);
+        to_chars_i(d,
+                   d + 20,  // 20 digits ought to be enough
+                   indices);
+        strcat(d, ",");
+      }(),
+      ...);
+  d[strlen(d) - 1] = ']';  // overwrite trailing comma
+  return dest;
 }
 
-template <unsigned, class MapType>
-inline void view_error_operator_bounds(char*, int, const MapType&) {}
-
-template <unsigned R, class MapType, class iType, class... Args>
-inline void view_error_operator_bounds(char* buf, int len, const MapType& map,
-                                       const iType& i, Args... args) {
-  const int n = snprintf(
-      buf, len, " %ld < %ld %c", static_cast<unsigned long>(i),
-      static_cast<unsigned long>(map.extent(R)), (sizeof...(Args) ? ',' : ')'));
-  view_error_operator_bounds<R + 1>(buf + n, len - n, map, args...);
+template <class Map, class... Indices, std::size_t... Enumerate>
+KOKKOS_FUNCTION void print_extents(char* dest, Map const& map,
+                                   std::index_sequence<Enumerate...>) {
+  append_formatted_multidimensional_index(dest, map.extent(Enumerate)...);
 }
 
-/* Check #3: is the View managed as determined by the MemoryTraits? */
-template <class MapType, bool is_managed = (MapType::is_managed != 0)>
-struct OperatorBoundsErrorOnDevice;
-
-template <class MapType>
-struct OperatorBoundsErrorOnDevice<MapType, false> {
-  KOKKOS_INLINE_FUNCTION
-  static void run(MapType const&) { Kokkos::abort("View bounds error"); }
-};
-
-template <class MapType>
-struct OperatorBoundsErrorOnDevice<MapType, true> {
-  KOKKOS_INLINE_FUNCTION
-  static void run(MapType const& map) {
-    SharedAllocationHeader const* const header =
-        SharedAllocationHeader::get_header(
-            static_cast<void const*>(map.data()));
-    char const* const label = header->label();
-    enum { LEN = 128 };
-    char msg[LEN];
-    char const* const first_part = "View bounds error of view ";
-    char* p                      = msg;
-    char* const end              = msg + LEN - 1;
-    for (char const* p2 = first_part; (*p2 != '\0') && (p < end); ++p, ++p2) {
-      *p = *p2;
-    }
-    for (char const* p2 = label; (*p2 != '\0') && (p < end); ++p, ++p2) {
-      *p = *p2;
-    }
-    *p = '\0';
-    Kokkos::abort(msg);
-  }
-};
-
-/* Check #2: does the ViewMapping have the printable_label_typedef defined?
-   See above that only the non-specialized standard-layout ViewMapping has
-   this defined by default.
-   The existence of this alias indicates the existence of MapType::is_managed
- */
 template <class T>
 using printable_label_typedef_t = typename T::printable_label_typedef;
 
-template <class Map>
-KOKKOS_FUNCTION
-    std::enable_if_t<!is_detected<printable_label_typedef_t, Map>::value>
-    operator_bounds_error_on_device(Map const&) {
-  Kokkos::abort("View bounds error");
-}
-
-template <class Map>
-KOKKOS_FUNCTION
-    std::enable_if_t<is_detected<printable_label_typedef_t, Map>::value>
-    operator_bounds_error_on_device(Map const& map) {
-  OperatorBoundsErrorOnDevice<Map>::run(map);
-}
-
 template <class MemorySpace, class ViewType, class MapType, class... Args>
 KOKKOS_INLINE_FUNCTION void view_verify_operator_bounds(
     Kokkos::Impl::ViewTracker<ViewType> const& tracker, const MapType& map,
     Args... args) {
-  if (!view_verify_operator_bounds<0>(map, args...)) {
+  if (!within_range(map, std::make_index_sequence<sizeof...(Args)>(),
+                    args...)) {
+    char err[256] = "";
+    strcat(err, "Kokkos::View ERROR: out of bounds access");
+    strcat(err, " label=(\"");
     KOKKOS_IF_ON_HOST(
-        (enum {LEN = 1024}; char buffer[LEN];
-         const std::string label =
-             tracker.m_tracker.template get_label<MemorySpace>();
-         int n = snprintf(buffer, LEN, "View bounds error of view %s (",
-                          label.c_str());
-         view_error_operator_bounds<0>(buffer + n, LEN - n, map, args...);
-         Kokkos::Impl::throw_runtime_exception(std::string(buffer));))
-
-    KOKKOS_IF_ON_DEVICE((
-        /* Check #1: is there a SharedAllocationRecord?
-           (we won't use it, but if its not there then there isn't
-            a corresponding SharedAllocationHeader containing a label).
-           This check should cover the case of Views that don't
-           have the Unmanaged trait but were initialized by pointer. */
         if (tracker.m_tracker.has_record()) {
-          operator_bounds_error_on_device(map);
-        } else { Kokkos::abort("View bounds error"); }))
+          strncat(err, tracker.m_tracker.template get_label<void>().c_str(),
+                  128);
+        } else { strcat(err, "**UNMANAGED**"); })
+    KOKKOS_IF_ON_DEVICE([&] {
+      // Check #1: is there a SharedAllocationRecord?  (we won't use it, but
+      // if its not there then there isn't a corresponding
+      // SharedAllocationHeader containing a label).  This check should cover
+      // the case of Views that don't have the Unmanaged trait but were
+      // initialized by pointer.
+      if (!tracker.m_tracker.has_record()) {
+        strcat(err, "**UNMANAGED**");
+        return;
+      }
+      // Check #2: does the ViewMapping have the printable_label_typedef
+      // defined? See above that only the non-specialized standard-layout
+      // ViewMapping has this defined by default. The existence of this
+      // alias indicates the existence of MapType::is_managed
+      if constexpr (is_detected_v<printable_label_typedef_t, MapType>) {
+        // Check #3: is the View managed as determined by the MemoryTraits?
+        if constexpr (MapType::is_managed != 0) {
+          SharedAllocationHeader const* const header =
+              SharedAllocationHeader::get_header(
+                  static_cast<void const*>(map.data()));
+          char const* const label = header->label();
+          strcat(err, label);
+          return;
+        }
+        strcat(err, "**UNAVAILABLE**");
+      }
+    }();)
+    strcat(err, "\") with indices ");
+    append_formatted_multidimensional_index(err, args...);
+    strcat(err, " but extents ");
+    print_extents(err, map, std::make_index_sequence<sizeof...(Args)>());
+    Kokkos::abort(err);
   }
 }
 
diff --git a/core/src/setup/Kokkos_Setup_Cuda.hpp b/core/src/setup/Kokkos_Setup_Cuda.hpp
index 1130485e84..b2faccc527 100644
--- a/core/src/setup/Kokkos_Setup_Cuda.hpp
+++ b/core/src/setup/Kokkos_Setup_Cuda.hpp
@@ -56,6 +56,8 @@
 #define KOKKOS_LAMBDA [=] __host__ __device__
 #define KOKKOS_CLASS_LAMBDA [ =, *this ] __host__ __device__
 
+#define KOKKOS_DEDUCTION_GUIDE __host__ __device__
+
 #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/src/setup/Kokkos_Setup_HIP.hpp b/core/src/setup/Kokkos_Setup_HIP.hpp
index 7b01866107..a3c5000b33 100644
--- a/core/src/setup/Kokkos_Setup_HIP.hpp
+++ b/core/src/setup/Kokkos_Setup_HIP.hpp
@@ -27,6 +27,8 @@
 #define KOKKOS_LAMBDA [=] __host__ __device__
 #define KOKKOS_CLASS_LAMBDA [ =, *this ] __host__ __device__
 
+#define KOKKOS_DEDUCTION_GUIDE __host__ __device__
+
 #define KOKKOS_IMPL_FORCEINLINE_FUNCTION __device__ __host__ __forceinline__
 #define KOKKOS_IMPL_INLINE_FUNCTION __device__ __host__ inline
 #define KOKKOS_IMPL_FUNCTION __device__ __host__
diff --git a/core/src/setup/Kokkos_Setup_SYCL.hpp b/core/src/setup/Kokkos_Setup_SYCL.hpp
index 417f80f7f4..b117d75acb 100644
--- a/core/src/setup/Kokkos_Setup_SYCL.hpp
+++ b/core/src/setup/Kokkos_Setup_SYCL.hpp
@@ -17,6 +17,11 @@
 #ifndef KOKKOS_SETUP_SYCL_HPP_
 #define KOKKOS_SETUP_SYCL_HPP_
 
+// FIXME_SYCL Using in-order queues currently gives better performance on Intel
+// GPUs and we run into correctness issues with out-of-order queues on NVIDIA
+// GPUs.
+#define KOKKOS_IMPL_SYCL_USE_IN_ORDER_QUEUES
+
 // FIXME_SYCL the fallback assert is temporarily disabled by default in the
 // compiler so we need to force it
 #ifndef SYCL_ENABLE_FALLBACK_ASSERT
@@ -33,12 +38,28 @@
 #include <CL/sycl.hpp>
 #endif
 
-#ifdef __SYCL_DEVICE_ONLY__
-#define KOKKOS_IMPL_DO_NOT_USE_PRINTF(format, ...)                \
-  do {                                                            \
-    const __attribute__((opencl_constant)) char fmt[] = (format); \
-    sycl::ext::oneapi::experimental::printf(fmt, ##__VA_ARGS__);  \
-  } while (0)
+#if defined(__INTEL_LLVM_COMPILER) && __INTEL_LLVM_COMPILER >= 20230200
+#define KOKKOS_IMPL_SYCL_GET_MULTI_PTR(accessor) \
+  accessor.get_multi_ptr<sycl::access::decorated::yes>()
+#else
+#define KOKKOS_IMPL_SYCL_GET_MULTI_PTR(accessor) accessor.get_pointer()
+#endif
+
+// FIXME_SYCL Use type directly once it has stabilized in SYCL.
+namespace Kokkos::Impl {
+#ifndef SYCL_EXT_INTEL_USM_ADDRESS_SPACES
+#error SYCL_EXT_INTEL_USM_ADDRESS_SPACES undefined!
+#elif SYCL_EXT_INTEL_USM_ADDRESS_SPACES >= 2
+template <typename T>
+using sycl_device_ptr = sycl::ext::intel::device_ptr<T>;
+template <typename T>
+using sycl_host_ptr = sycl::ext::intel::host_ptr<T>;
+#else
+template <typename T>
+using sycl_device_ptr = sycl::device_ptr<T>;
+template <typename T>
+using sycl_host_ptr = sycl::host_ptr<T>;
 #endif
+}  // namespace Kokkos::Impl
 
 #endif
diff --git a/core/src/traits/Kokkos_IndexTypeTrait.hpp b/core/src/traits/Kokkos_IndexTypeTrait.hpp
index 91820fbcca..e43535451c 100644
--- a/core/src/traits/Kokkos_IndexTypeTrait.hpp
+++ b/core/src/traits/Kokkos_IndexTypeTrait.hpp
@@ -83,7 +83,7 @@ struct IndexTypePolicyMixin : AnalyzeNextTrait {
                 "Kokkos Error: More than one index type given. Search "
                 "compiler output for 'show_extra_index_type' to see the "
                 "type of the errant tag.");
-  static_assert(std::is_integral<IntegralIndexType>::value, "");
+  static_assert(std::is_integral<IntegralIndexType>::value);
   static constexpr bool index_type_is_defaulted = false;
   using index_type = Kokkos::IndexType<IntegralIndexType>;
 };
diff --git a/core/src/traits/Kokkos_OccupancyControlTrait.hpp b/core/src/traits/Kokkos_OccupancyControlTrait.hpp
index dadf582c37..c2ca5a341f 100644
--- a/core/src/traits/Kokkos_OccupancyControlTrait.hpp
+++ b/core/src/traits/Kokkos_OccupancyControlTrait.hpp
@@ -163,7 +163,7 @@ auto prefer(Policy const& p, DesiredOccupancy occ) {
 
 template <typename Policy>
 constexpr auto prefer(Policy const& p, MaximizeOccupancy) {
-  static_assert(Kokkos::is_execution_policy<Policy>::value, "");
+  static_assert(Kokkos::is_execution_policy<Policy>::value);
   using new_policy_t =
       Kokkos::Impl::OccupancyControlTrait::policy_with_trait<Policy,
                                                              MaximizeOccupancy>;
diff --git a/core/src/traits/Kokkos_PolicyTraitAdaptor.hpp b/core/src/traits/Kokkos_PolicyTraitAdaptor.hpp
index 578e9e762a..98ad1d7ebb 100644
--- a/core/src/traits/Kokkos_PolicyTraitAdaptor.hpp
+++ b/core/src/traits/Kokkos_PolicyTraitAdaptor.hpp
@@ -68,7 +68,7 @@ struct PolicyTraitAdaptorImpl<
     TraitSpec, PolicyTemplate, type_list<ProcessedTraits...>,
     type_list<MatchingTrait, ToProcessTraits...>, NewTrait,
     std::enable_if_t<PolicyTraitMatcher<TraitSpec, MatchingTrait>::value>> {
-  static_assert(PolicyTraitMatcher<TraitSpec, NewTrait>::value, "");
+  static_assert(PolicyTraitMatcher<TraitSpec, NewTrait>::value);
   using type = PolicyTemplate<ProcessedTraits..., NewTrait, ToProcessTraits...>;
 };
 
@@ -92,7 +92,7 @@ template <class TraitSpec, template <class...> class PolicyTemplate,
 struct PolicyTraitAdaptorImpl<TraitSpec, PolicyTemplate,
                               type_list<ProcessedTraits...>, type_list<>,
                               NewTrait> {
-  static_assert(PolicyTraitMatcher<TraitSpec, NewTrait>::value, "");
+  static_assert(PolicyTraitMatcher<TraitSpec, NewTrait>::value);
   using type = PolicyTemplate<ProcessedTraits..., NewTrait>;
 };
 
diff --git a/core/src/traits/Kokkos_ScheduleTrait.hpp b/core/src/traits/Kokkos_ScheduleTrait.hpp
index 8613002553..4e91d89f0f 100644
--- a/core/src/traits/Kokkos_ScheduleTrait.hpp
+++ b/core/src/traits/Kokkos_ScheduleTrait.hpp
@@ -78,7 +78,7 @@ namespace Experimental {
 
 template <class Policy, class ScheduleType>
 constexpr auto require(Policy const& p, Kokkos::Schedule<ScheduleType>) {
-  static_assert(Kokkos::is_execution_policy<Policy>::value, "");
+  static_assert(Kokkos::is_execution_policy<Policy>::value);
   using new_policy_t = Kokkos::Impl::ScheduleTrait::policy_with_trait<
       Policy, Kokkos::Schedule<ScheduleType>>;
   return new_policy_t{p};
diff --git a/core/src/traits/Kokkos_WorkItemPropertyTrait.hpp b/core/src/traits/Kokkos_WorkItemPropertyTrait.hpp
index 8f95385c85..ae7aa6e534 100644
--- a/core/src/traits/Kokkos_WorkItemPropertyTrait.hpp
+++ b/core/src/traits/Kokkos_WorkItemPropertyTrait.hpp
@@ -57,7 +57,7 @@ namespace Experimental {
 template <class Policy, unsigned long Property>
 constexpr auto require(const Policy p,
                        WorkItemProperty::ImplWorkItemProperty<Property>) {
-  static_assert(Kokkos::is_execution_policy<Policy>::value, "");
+  static_assert(Kokkos::is_execution_policy<Policy>::value);
   using new_policy_t = Kokkos::Impl::WorkItemPropertyTrait::policy_with_trait<
       Policy, WorkItemProperty::ImplWorkItemProperty<Property>>;
   return new_policy_t{p};
diff --git a/core/unit_test/CMakeLists.txt b/core/unit_test/CMakeLists.txt
index f5a979a313..f821581872 100644
--- a/core/unit_test/CMakeLists.txt
+++ b/core/unit_test/CMakeLists.txt
@@ -45,8 +45,11 @@ SET(KOKKOS_OPENMP_FEATURE_LEVEL 999)
 SET(KOKKOS_OPENMP_NAME OpenMP)
 
 # FIXME_OPENMPTARGET - The NVIDIA HPC compiler nvc++ only compiles the first 8 incremental tests for the OpenMPTarget backend.
+# FIXME_OPENMPTARGET - Clang version 17 fails to compile incremental tests past 12 with verion 17. There is PR for this in upstream already. So it should be fixed by version 18.
 IF(KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
   SET(KOKKOS_OPENMPTARGET_FEATURE_LEVEL 10)
+ELSEIF(KOKKOS_CXX_COMPILER_ID STREQUAL "Clang" AND KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 17.0.0)
+  SET(KOKKOS_OPENMPTARGET_FEATURE_LEVEL 12)
 ELSE()
   SET(KOKKOS_OPENMPTARGET_FEATURE_LEVEL 14)
 ENDIF()
@@ -58,7 +61,13 @@ 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 16)
+# FIXME_OPENACC - The Clang compiler only compiles the first 9 incremental tests for the OpenACC backend.
+IF(KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+  SET(KOKKOS_OPENACC_FEATURE_LEVEL 9)
+ELSE()
+  SET(KOKKOS_OPENACC_FEATURE_LEVEL 17)
+ENDIF()
+
 SET(KOKKOS_OPENACC_NAME Experimental::OpenACC)
 
 
@@ -77,11 +86,16 @@ SET(COMPILE_ONLY_SOURCES
   TestDetectionIdiom.cpp
   TestBitManipulation.cpp
   TestInterOp.cpp
+  TestRangePolicyCTAD.cpp
   TestStringManipulation.cpp
   TestVersionMacros.cpp
   TestViewRank.cpp
   TestViewTypeTraits.cpp
   TestTypeList.cpp
+  TestMDRangePolicyCTAD.cpp
+  TestTeamPolicyCTAD.cpp
+  TestTeamMDRangePolicyCTAD.cpp
+  TestNestedReducerCTAD.cpp
   view/TestExtentsDatatypeConversion.cpp
 )
 
@@ -94,6 +108,9 @@ endif()
 IF(KOKKOS_HAS_TRILINOS)
   LIST(REMOVE_ITEM COMPILE_ONLY_SOURCES TestInterOp.cpp)
 ENDIF()
+if(Kokkos_ENABLE_OPENMPTARGET)
+  list(REMOVE_ITEM COMPILE_ONLY_SOURCES TestNestedReducerCTAD.cpp)
+endif()
 KOKKOS_ADD_EXECUTABLE(
   CoreTestCompileOnly
   SOURCES
@@ -114,6 +131,7 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
     set(${Tag}_SOURCES1A)
     foreach(Name
         Abort
+        ArrayOps
         AtomicOperations_complexdouble
         AtomicOperations_complexfloat
         AtomicOperations_double
@@ -128,6 +146,7 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
         AtomicViews
         BitManipulationBuiltins
         BlockSizeDeduction
+        CheckedIntegerOps
         CommonPolicyConstructors
         CommonPolicyInterface
         Complex
@@ -135,8 +154,10 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
         Crs
         DeepCopyAlignment
         ExecSpacePartitioning
+        ExecSpaceThreadSafety
         ExecutionSpace
         FunctorAnalysis
+        Graph
         HostSharedPtr
         HostSharedPtrAccessOnDevice
         Init
@@ -160,7 +181,7 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
     endforeach()
 
     set(${Tag}_SOURCES1B)
-    foreach(Name
+    set(${Tag}_TESTNAMES1B
         MDRange_a
         MDRange_b
         MDRange_c
@@ -171,10 +192,14 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
         MDRangePolicyConstructors
         MDRangeReduce
         MDSpan
+        MDSpanAtomicAccessor
+        MDSpanConversion
         MinMaxClamp
         NumericTraits
+        OccupancyControlTrait
         Other
         ParallelScanRangePolicy
+        Printf
         QuadPrecisionMath
         RangePolicy
         RangePolicyConstructors
@@ -188,7 +213,19 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
         Reductions
         Reductions_DeviceView
         SharedAlloc
+        SpaceAwareAccessorAccessViolation
+        SpaceAwareAccessor
+        Swap
         )
+    IF (NOT Kokkos_ENABLE_IMPL_MDSPAN)
+      LIST(REMOVE_ITEM ${Tag}_TESTNAMES1B
+         MDSpanAtomicAccessor
+         MDSpanConversion
+         SpaceAwareAccessorAccessViolation
+         SpaceAwareAccessor
+      )
+    ENDIF()
+    foreach(Name IN LISTS ${Tag}_TESTNAMES1B)
       set(file ${dir}/Test${Tag}_${Name}.cpp)
       # Write to a temporary intermediate file and call configure_file to avoid
       # updating timestamps triggering unnecessary rebuilds on subsequent cmake runs.
@@ -201,7 +238,7 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
     endforeach()
 
     SET(${Tag}_SOURCES2A)
-    foreach(Name
+    SET(${TAG}_TESTNAMES2A
       TeamBasic
       TeamCombinedReducers
       TeamMDRange
@@ -218,9 +255,12 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
       ViewAPI_c
       ViewAPI_d
       ViewAPI_e
+      ViewBadAlloc
       ViewCopy_a
       ViewCopy_b
+      ViewCopy_c
       ViewCtorDimMatch
+      ViewEmptyRuntimeUnmanaged
       ViewHooks
       ViewLayoutStrideAssignment
       ViewMapping_a
@@ -228,10 +268,21 @@ foreach(Tag Threads;Serial;OpenMP;Cuda;HPX;OpenMPTarget;OpenACC;HIP;SYCL)
       ViewMapping_subview
       ViewMemoryAccessViolation
       ViewOfClass
+      ViewOfViews
+      ViewOutOfBoundsAccess
       ViewResize
       WorkGraph
       WithoutInitializing
       )
+    # Workaround to internal compiler error with intel classic compilers
+    # when using -no-ip flag in ViewCopy_c
+    # See issue: https://github.com/kokkos/kokkos/issues/7084
+    IF(KOKKOS_CXX_COMPILER_ID STREQUAL Intel)
+      LIST(REMOVE_ITEM ${Tag}_TESTNAMES2A
+        ViewCopy_c
+      )
+    endif()
+    foreach(Name IN LISTS ${Tag}_TESTNAMES2A)
       set(file ${dir}/Test${Tag}_${Name}.cpp)
       # Write to a temporary intermediate file and call configure_file to avoid
       # updating timestamps triggering unnecessary rebuilds on subsequent cmake runs.
@@ -335,6 +386,7 @@ foreach(PairDeviceSpace HIP-HostPinned;HIP-Managed;Cuda-HostPinned;Cuda-UVM;SYCL
       ViewAPI_e
       ViewCopy_a
       ViewCopy_b
+      ViewCopy_c
       ViewMapping_a
       ViewMapping_b
       ViewMapping_subview
@@ -353,13 +405,29 @@ foreach(PairDeviceSpace HIP-HostPinned;HIP-Managed;Cuda-HostPinned;Cuda-UVM;SYCL
   endif()
 endforeach()
 
-
+# Disable non-compiling tests based on clang version.
 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
+    IF (KOKKOS_CXX_COMPILER_ID STREQUAL "Clang" AND KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0.0)
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_AtomicOperations_shared.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_MinMaxClamp.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_LocalDeepCopy.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_d.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamVectorRange.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_ViewAPI_e.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamScan.cpp
+        ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_TeamBasic.cpp
+        IF (KOKKOS_CXX_COMPILER_VERSION VERSION_LESS 17.0.3)
+            ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c01.cpp
+            ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c02.cpp
+            ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_SubView_c03.cpp
+            ${CMAKE_CURRENT_BINARY_DIR}/openmptarget/TestOpenMPTarget_Reducers_d.cpp
+        endif()
+    endif()
     # 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)
@@ -370,6 +438,21 @@ if(Kokkos_ENABLE_OPENMPTARGET)
     )
 endif()
 
+# FIXME_OPENMPTARGET - MinMaxClamp fails even with the host backend when OpenMPTarget backend is enabled.
+# FIXME_OPENMPTARGET - Unsure of the reason as of now.
+IF (KOKKOS_CXX_COMPILER_ID STREQUAL "Clang" AND KOKKOS_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0.0)
+    IF(Kokkos_ENABLE_OPENMPTARGET AND Kokkos_ENABLE_OPENMP)
+      list(REMOVE_ITEM OpenMP_SOURCES
+          ${CMAKE_CURRENT_BINARY_DIR}/openmp/TestOpenMP_MinMaxClamp.cpp
+            )
+    ENDIF()
+    IF(Kokkos_ENABLE_OPENMPTARGET AND Kokkos_ENABLE_SERIAL)
+        list(REMOVE_ITEM Serial_SOURCES1
+            ${CMAKE_CURRENT_BINARY_DIR}/serial/TestSerial_MinMaxClamp.cpp
+            )
+    ENDIF()
+ENDIF()
+
 if(Kokkos_ENABLE_OPENACC)
   list(REMOVE_ITEM OpenACC_SOURCES
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicOperations_complexdouble.cpp
@@ -391,7 +474,7 @@ if(Kokkos_ENABLE_OPENACC)
 endif()
 
 # FIXME_OPENMPTARGET - Comment non-passing tests with amdclang++
-# FIXME_OPENMPTARGET - Need to check on NAVI architecture
+# FIXME_OPENMPTARGET - Need to check on GFX1030 and GFX1100 architectures
 IF(KOKKOS_ARCH_VEGA)
   SET(KOKKOS_AMDGPU_ARCH TRUE)
 ENDIF()
@@ -480,7 +563,36 @@ IF(KOKKOS_ENABLE_OPENACC AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
   list(REMOVE_ITEM OpenACC_SOURCES
     ${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_shared.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_BlockSizeDeduction.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_DeepCopyAlignment.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_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_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_ViewResize.cpp
+    )
+endif()
+
+# FIXME_OPENACC - Comment non-passing tests with the Clang compiler
+IF(KOKKOS_ENABLE_OPENACC AND KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
+  list(REMOVE_ITEM OpenACC_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_a1.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/default/TestDefaultDeviceType_b1.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
@@ -493,33 +605,67 @@ IF(KOKKOS_ENABLE_OPENACC AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_AtomicViews.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_BlockSizeDeduction.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_DeepCopyAlignment.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_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_a.cpp
     ${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_c02.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c03.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c05.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c08.cpp
-    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_SubView_c11.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
+    # This test is not removed above for OpenACC+NVHPC but all its TEST
+    # functions are not compiled for the case of KOKKOS_COMPILER_NVHPC.
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewCtorDimMatch.cpp
+    # These tests are not removed above for OpenACC+NVHPC.
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Abort.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Complex.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ExecutionSpace.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ExecSpacePartitioning.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_Init.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalConstants.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalSpecialFunctions.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MinMaxClamp.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewLayoutStrideAssignment.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewMapping_a.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewMemoryAccessViolation.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_WithoutInitializing.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_d.cpp
+    )
+  # When tested on a systme with AMD MI60 GPU and ROCm V5.4.0, these cause
+  # clang-linker-wrapper to hang for a long time while building the unit tests.
+  # In some cases, including them caused the build not to complete after an hour,
+  # but excluding them permitted the build to finish in 1.5 mins or less.
+  IF(KOKKOS_AMDGPU_ARCH)
+    list(REMOVE_ITEM OpenACC_SOURCES
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_BitManipulationBuiltins.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_MathematicalFunctions3.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ParallelScanRangePolicy.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_ViewAPI_b.cpp
+    ${CMAKE_CURRENT_BINARY_DIR}/openacc/TestOpenACC_ViewAPI_c.cpp
     )
+  endif()
+  # Fails serial.atomics_tpetra_max_abs when we test with Clacc.
+  list(REMOVE_ITEM Serial_SOURCES1
+    ${CMAKE_CURRENT_BINARY_DIR}/serial/TestSerial_Atomics.cpp)
 endif()
 
 if(Kokkos_ENABLE_SERIAL)
@@ -536,12 +682,6 @@ if(Kokkos_ENABLE_SERIAL)
     UnitTestMainInit.cpp
     ${Serial_SOURCES2}
   )
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    CoreUnitTest_SerialGraph
-    SOURCES
-    UnitTestMainInit.cpp
-    serial/TestSerial_Graph.cpp
-  )
 endif()
 
 if(Kokkos_ENABLE_THREADS)
@@ -555,7 +695,6 @@ endif()
 if (Kokkos_ENABLE_OPENMP)
   set(OpenMP_EXTRA_SOURCES
     openmp/TestOpenMP_Task.cpp
-    openmp/TestOpenMP_PartitionMaster.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
     CoreUnitTest_OpenMP
@@ -570,12 +709,6 @@ if (Kokkos_ENABLE_OPENMP)
       UnitTestMain.cpp
       openmp/TestOpenMP_InterOp.cpp
   )
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    CoreUnitTest_OpenMPGraph
-    SOURCES
-      UnitTestMainInit.cpp
-      openmp/TestOpenMP_Graph.cpp
-  )
 endif()
 
 if(Kokkos_ENABLE_HPX)
@@ -602,12 +735,14 @@ if(Kokkos_ENABLE_HPX)
       hpx/TestHPX_IndependentInstancesRefCounting.cpp
       hpx/TestHPX_IndependentInstancesSynchronization.cpp
   )
+if(Kokkos_ENABLE_DEPRECATED_CODE_4)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
     CoreUnitTest_HPX_InParallel
     SOURCES
       UnitTestMainInit.cpp
       hpx/TestHPX_InParallel.cpp
   )
+  endif()
 endif()
 
 if(Kokkos_ENABLE_OPENMPTARGET)
@@ -676,10 +811,10 @@ if(Kokkos_ENABLE_CUDA)
       cuda/TestCuda_InterOp_Streams.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    CoreUnitTest_CudaGraph
+    CoreUnitTest_CudaInterOpStreamsMultiGPU
     SOURCES
       UnitTestMainInit.cpp
-      cuda/TestCuda_Graph.cpp
+      cuda/TestCuda_InterOp_StreamsMultiGPU.cpp
   )
 endif()
 
@@ -708,12 +843,6 @@ if(Kokkos_ENABLE_HIP)
       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)
@@ -783,15 +912,21 @@ if(Kokkos_ENABLE_SYCL)
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
     CoreUnitTest_SYCLInterOpInit_Context
     SOURCES
-    UnitTestMainInit.cpp
+      UnitTestMainInit.cpp
       sycl/TestSYCL_InterOp_Init_Context.cpp
   )
   KOKKOS_ADD_EXECUTABLE_AND_TEST(
     CoreUnitTest_SYCLInterOpStreams
     SOURCES
-      UnitTestMain.cpp
+     UnitTestMain.cpp
      sycl/TestSYCL_InterOp_Streams.cpp
   )
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+      CoreUnitTest_SYCLInterOpStreamsMultiGPU
+    SOURCES
+      UnitTestMainInit.cpp
+      sycl/TestSYCL_InterOp_StreamsMultiGPU.cpp
+  )
 endif()
 
 SET(DEFAULT_DEVICE_SOURCES
@@ -827,11 +962,32 @@ endif()
 
 # FIXME_OPENMPTARGET, FIXME_OPENACC - Comment non-passing tests with the NVIDIA HPC compiler nvc++
 if ((KOKKOS_ENABLE_OPENMPTARGET OR KOKKOS_ENABLE_OPENACC) AND KOKKOS_CXX_COMPILER_ID STREQUAL NVHPC)
+  LIST(REMOVE_ITEM DEFAULT_DEVICE_SOURCES
+    default/TestDefaultDeviceType_a1.cpp
+    default/TestDefaultDeviceType_b1.cpp
+    default/TestDefaultDeviceType_c1.cpp
+    default/TestDefaultDeviceType_a2.cpp
+    default/TestDefaultDeviceType_b2.cpp
+    default/TestDefaultDeviceType_c2.cpp
+    default/TestDefaultDeviceType_a3.cpp
+    default/TestDefaultDeviceType_b3.cpp
+    default/TestDefaultDeviceType_c3.cpp
+    default/TestDefaultDeviceType_d.cpp
+    default/TestDefaultDeviceTypeResize.cpp
+    default/TestDefaultDeviceTypeViewAPI.cpp
+  )
+endif()
+
+# FIXME_OPENACC - Comment non-passing tests with the Clang compiler
+if (KOKKOS_ENABLE_OPENACC AND KOKKOS_CXX_COMPILER_ID STREQUAL Clang)
   SET(DEFAULT_DEVICE_SOURCES
+    TestCompilerMacros.cpp
     UnitTestMainInit.cpp
     TestInitializationSettings.cpp
     TestParseCmdLineArgsAndEnvVars.cpp
-    default/TestDefaultDeviceType.cpp
+    default/TestDefaultDeviceType_d.cpp
+    default/TestDefaultDeviceTypeResize.cpp
+    default/TestDefaultDeviceTypeViewAPI.cpp
   )
 endif()
 
@@ -853,6 +1009,13 @@ KOKKOS_ADD_EXECUTABLE_AND_TEST(
     UnitTest_PushFinalizeHook.cpp
 )
 
+KOKKOS_ADD_EXECUTABLE_AND_TEST(
+  CoreUnitTest_ScopeGuard
+  SOURCES
+    UnitTestMain.cpp
+    UnitTest_ScopeGuard.cpp
+)
+
 # This test is intended for development and debugging by putting code
 # into TestDefaultDeviceDevelop.cpp. By default its empty.
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
@@ -862,23 +1025,35 @@ KOKKOS_ADD_EXECUTABLE_AND_TEST(
     default/TestDefaultDeviceDevelop.cpp
 )
 
-# This test is special, because it passes exactly when it prints the
-# message "PASSED: I am the custom std::terminate handler.", AND calls
-# std::terminate.  This means that we can't use
-# KOKKOS_ADD_EXECUTABLE_AND_TEST.  See GitHub issue #2147.
-
-KOKKOS_ADD_TEST_EXECUTABLE( push_finalize_hook_terminate
-  SOURCES UnitTest_PushFinalizeHook_terminate.cpp
-)
+# With MSVC, the terminate handler is called and prints the message but the
+# program does not seem to exit and we get a timeout with ctest.
+if (NOT WIN32)
+  # This test is special, because it passes exactly when it prints the
+  # message "PASSED: I am the custom std::terminate handler.", AND calls
+  # std::terminate.  This means that we can't use
+  # KOKKOS_ADD_EXECUTABLE_AND_TEST.  See GitHub issue #2147.
+  KOKKOS_ADD_TEST_EXECUTABLE(
+    CoreUnitTest_PushFinalizeHookTerminate
+    SOURCES UnitTest_PushFinalizeHook_terminate.cpp
+  )
+  add_test(
+    NAME Kokkos_CoreUnitTest_PushFinalizeHookTerminateRegex
+    COMMAND ${CMAKE_COMMAND} -E env $<TARGET_FILE:Kokkos_CoreUnitTest_PushFinalizeHookTerminate>
+  )
+  set_property(
+    TEST Kokkos_CoreUnitTest_PushFinalizeHookTerminateRegex
+    PROPERTY PASS_REGULAR_EXPRESSION "PASSED: I am the custom std::terminate handler."
+  )
+  add_test(
+    NAME Kokkos_CoreUnitTest_PushFinalizeHookTerminateFails
+    COMMAND ${CMAKE_COMMAND} -E env $<TARGET_FILE:Kokkos_CoreUnitTest_PushFinalizeHookTerminate>
+  )
+  set_property(
+    TEST Kokkos_CoreUnitTest_PushFinalizeHookTerminateFails
+    PROPERTY WILL_FAIL TRUE
+  )
+endif()
 
-KOKKOS_ADD_ADVANCED_TEST( CoreUnitTest_PushFinalizeHook_terminate
-  TEST_0
-    EXEC push_finalize_hook_terminate
-    NUM_MPI_PROCS 1
-    PASS_REGULAR_EXPRESSION
-      "PASSED: I am the custom std::terminate handler."
-    ALWAYS_FAIL_ON_ZERO_RETURN
-)
   if(KOKKOS_ENABLE_TUNING)
     KOKKOS_ADD_EXECUTABLE_AND_TEST(
       CoreUnitTest_TuningBuiltins
@@ -896,13 +1071,7 @@ KOKKOS_ADD_ADVANCED_TEST( CoreUnitTest_PushFinalizeHook_terminate
       tools/TestCategoricalTuner.cpp
     )
   endif()
-  if((NOT Kokkos_ENABLE_OPENMPTARGET) AND (NOT Kokkos_ENABLE_OPENACC))
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    CoreUnitTest_LogicalSpaces
-    SOURCES
-      tools/TestLogicalSpaces.cpp
-  )
-  endif()
+
   SET(KOKKOSP_SOURCES
     UnitTestMainInit.cpp
     tools/TestEventCorrectness.cpp
@@ -1024,15 +1193,6 @@ KOKKOS_ADD_TEST( NAME CoreUnitTest_StackTraceTest
                )
 endif()
 
-if(Kokkos_ENABLE_DEPRECATED_CODE_3)
-  foreach(INITTESTS_NUM RANGE 1 18)
-  KOKKOS_ADD_EXECUTABLE_AND_TEST(
-    CoreUnitTest_DefaultInit_${INITTESTS_NUM}
-    SOURCES UnitTestMain.cpp default/TestDefaultDeviceTypeInit_${INITTESTS_NUM}.cpp
-  )
-  endforeach(INITTESTS_NUM)
-endif()
-
 if (KOKKOS_ENABLE_HWLOC)
 KOKKOS_ADD_EXECUTABLE_AND_TEST(
   CoreUnitTest_HWLOC
@@ -1116,12 +1276,10 @@ if (NOT KOKKOS_HAS_TRILINOS)
       INPUT TestDeviceAndThreads.py
       ${USE_SOURCE_PERMISSIONS_WHEN_SUPPORTED}
     )
-    if(NOT Kokkos_ENABLE_OPENMPTARGET)  # FIXME_OPENMPTARGET does not select the right device
-      add_test(
-        NAME Kokkos_CoreUnitTest_DeviceAndThreads
-        COMMAND ${Python3_EXECUTABLE} -m unittest -v $<TARGET_FILE_DIR:Kokkos_CoreUnitTest_DeviceAndThreads>/TestDeviceAndThreads.py
-      )
-    endif()
+    add_test(
+      NAME Kokkos_CoreUnitTest_DeviceAndThreads
+      COMMAND ${Python3_EXECUTABLE} $<TARGET_FILE_DIR:Kokkos_CoreUnitTest_DeviceAndThreads>/TestDeviceAndThreads.py -v
+    )
   endif()
 endif()
 
diff --git a/core/unit_test/Makefile b/core/unit_test/Makefile
index 33a84b61f9..a4d65687e5 100644
--- a/core/unit_test/Makefile
+++ b/core/unit_test/Makefile
@@ -62,18 +62,18 @@ 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 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
+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 ViewCopy_c ViewLayoutStrideAssignment ViewMapping_a ViewMapping_b ViewMapping_subview ViewOfClass WorkGraph View_64bit ViewResize
 
 tmp := $(foreach device, $(KOKKOS_DEVICELIST), \
   tmp2 := $(foreach test, $(TESTS), \
     $(if $(filter Test$(device)_$(test).cpp, $(shell ls Test$(device)_$(test).cpp 2>/dev/null)),,\
-      $(shell echo "\#include <Test"$(device)"_Category.hpp>" > Test$(device)_$(test).cpp); \
-      $(shell echo "\#include <Test"$(test)".hpp>" >> Test$(device)_$(test).cpp); \
+      $(shell echo "$(H)include <Test"$(device)"_Category.hpp>" > Test$(device)_$(test).cpp); \
+      $(shell echo "$(H)include <Test"$(test)".hpp>" >> Test$(device)_$(test).cpp); \
      ) \
   ) \
 )
 
-GPU_SPACE_TESTS = SharedAlloc ViewAPI_a ViewAPI_b ViewAPI_c ViewAPI_d ViewAPI_e ViewCopy_a ViewCopy_b ViewMapping_a ViewMapping_b ViewMapping_subview
+GPU_SPACE_TESTS = SharedAlloc ViewAPI_a ViewAPI_b ViewAPI_c ViewAPI_d ViewAPI_e ViewCopy_a ViewCopy_b ViewCopy_c ViewMapping_a ViewMapping_b ViewMapping_subview
 
 SUBVIEW_TESTS = SubView_a SubView_b SubView_c01 SubView_c02 SubView_c03 SubView_c04 SubView_c05 SubView_c06 SubView_c07 SubView_c08 SubView_c09 SubView_c10 SubView_c11 SubView_c12 SubView_c13
 
@@ -82,8 +82,8 @@ KOKKOS_SUBVIEW_DEVICELIST := $(filter-out Cuda, $(KOKKOS_DEVICELIST))
 tmp := $(foreach device, $(KOKKOS_SUBVIEW_DEVICELIST), \
   tmp2 := $(foreach test, $(SUBVIEW_TESTS), \
     $(if $(filter Test$(device)_$(test).cpp, $(shell ls Test$(device)_$(test).cpp 2>/dev/null)),, \
-      $(shell echo "\#include <Test"$(device)"_Category.hpp>" > Test$(device)_$(test).cpp); \
-      $(shell echo "\#include <Test"$(test)".hpp>" >> Test$(device)_$(test).cpp); \
+      $(shell echo "$(H)include <Test"$(device)"_Category.hpp>" > Test$(device)_$(test).cpp); \
+      $(shell echo "$(H)include <Test"$(test)".hpp>" >> Test$(device)_$(test).cpp); \
      ) \
   )\
 )
@@ -91,8 +91,8 @@ tmp := $(foreach device, $(KOKKOS_SUBVIEW_DEVICELIST), \
 ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     tmp2 := $(foreach test, $(SUBVIEW_TESTS), \
       $(if $(filter TestCuda_$(test).cpp, $(shell ls TestCuda_$(test).cpp 2>/dev/null)),,\
-        $(shell echo "\#include <TestCudaUVM_Category.hpp>" > TestCuda_$(test).cpp); \
-        $(shell echo "\#include <Test"$(test)".hpp>" >> TestCuda_$(test).cpp); \
+        $(shell echo "$(H)include <TestCudaUVM_Category.hpp>" > TestCuda_$(test).cpp); \
+        $(shell echo "$(H)include <Test"$(test)".hpp>" >> TestCuda_$(test).cpp); \
       )\
     )
 
@@ -100,8 +100,8 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     tmp := $(foreach space, $(GPU_SPACES), \
       tmp2 := $(foreach test, $(GPU_SPACE_TESTS), \
         $(if $(filter Test$(space)_$(test).cpp, $(shell ls Test$(space)_$(test).cpp 2>/dev/null)),,\
-          $(shell echo "\#include <Test$(space)_Category.hpp>" > Test$(space)_$(test).cpp); \
-          $(shell echo "\#include <Test"$(test)".hpp>" >> Test$(space)_$(test).cpp); \
+          $(shell echo "$(H)include <Test$(space)_Category.hpp>" > Test$(space)_$(test).cpp); \
+          $(shell echo "$(H)include <Test"$(test)".hpp>" >> Test$(space)_$(test).cpp); \
         )\
       )\
     )
@@ -110,14 +110,14 @@ ifeq ($(KOKKOS_INTERNAL_USE_CUDA), 1)
     OBJ_CUDA += TestCuda_Init.o
     OBJ_CUDA += TestCuda_SharedAlloc.o TestCudaUVM_SharedAlloc.o TestCudaHostPinned_SharedAlloc.o
     OBJ_CUDA += TestCuda_RangePolicy.o TestCuda_RangePolicyRequire.o
-    OBJ_CUDA += TestCuda_ViewAPI_a.o TestCuda_ViewAPI_b.o TestCuda_ViewAPI_c.o TestCuda_ViewAPI_d.o TestCuda_ViewAPI_e.o TestCuda_ViewCopy_a.o TestCuda_ViewCopy_b.o
+    OBJ_CUDA += TestCuda_ViewAPI_a.o TestCuda_ViewAPI_b.o TestCuda_ViewAPI_c.o TestCuda_ViewAPI_d.o TestCuda_ViewAPI_e.o TestCuda_ViewCopy_a.o TestCuda_ViewCopy_b.o TestCuda_ViewCopy_c.o
     OBJ_CUDA += TestCuda_DeepCopyAlignment.o
     OBJ_CUDA += TestCuda_ViewMapping_a.o TestCuda_ViewMapping_b.o TestCuda_ViewMapping_subview.o TestCuda_ViewResize.o TestCuda_ViewLayoutStrideAssignment.o
     OBJ_CUDA += TestCudaUVM_ViewAPI_a.o TestCudaUVM_ViewAPI_b.o TestCudaUVM_ViewAPI_c.o TestCudaUVM_ViewAPI_d.o TestCudaUVM_ViewAPI_e.o
-    OBJ_CUDA += TestCudaUVM_ViewCopy_a.o TestCudaUVM_ViewCopy_b.o
+    OBJ_CUDA += TestCudaUVM_ViewCopy_a.o TestCudaUVM_ViewCopy_b.o TestCudaUVM_ViewCopy_c.o
     OBJ_CUDA += TestCudaUVM_ViewMapping_a.o TestCudaUVM_ViewMapping_b.o TestCudaUVM_ViewMapping_subview.o
     OBJ_CUDA += TestCudaHostPinned_ViewAPI_a.o TestCudaHostPinned_ViewAPI_b.o TestCudaHostPinned_ViewAPI_c.o TestCudaHostPinned_ViewAPI_d.o TestCudaHostPinned_ViewAPI_e.o
-    OBJ_CUDA += TestCudaHostPinned_ViewCopy_a.o TestCudaHostPinned_ViewCopy_b.o
+    OBJ_CUDA += TestCudaHostPinned_ViewCopy_a.o TestCudaHostPinned_ViewCopy_b.o TestCudaHostPinned_ViewCopy_c.o
     OBJ_CUDA += TestCudaHostPinned_ViewMapping_a.o TestCudaHostPinned_ViewMapping_b.o TestCudaHostPinned_ViewMapping_subview.o
     OBJ_CUDA += TestCuda_View_64bit.o
     OBJ_CUDA += TestCuda_ViewOfClass.o
@@ -162,7 +162,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_THREADS), 1)
     OBJ_THREADS += TestThreads_RangePolicy.o TestThreads_RangePolicyRequire.o
     OBJ_THREADS += TestThreads_View_64bit.o
     OBJ_THREADS += TestThreads_ViewAPI_a.o TestThreads_ViewAPI_b.o TestThreads_ViewAPI_c.o TestThreads_ViewAPI_d.o TestThreads_ViewAPI_e.o
-    OBJ_THREADS += TestThreads_ViewCopy_a.o TestThreads_ViewCopy_b.o
+    OBJ_THREADS += TestThreads_ViewCopy_a.o TestThreads_ViewCopy_b.o TestThreads_ViewCopy_c.o
     OBJ_THREADS += TestThreads_DeepCopyAlignment.o
     OBJ_THREADS += TestThreads_ViewMapping_a.o TestThreads_ViewMapping_b.o TestThreads_ViewMapping_subview.o TestThreads_ViewResize.o TestThreads_ViewLayoutStrideAssignment.o
     OBJ_THREADS += TestThreads_ViewOfClass.o
@@ -198,7 +198,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMP), 1)
     OBJ_OPENMP += TestOpenMP_RangePolicy.o TestOpenMP_RangePolicyRequire.o
     OBJ_OPENMP += TestOpenMP_View_64bit.o
     OBJ_OPENMP += TestOpenMP_ViewAPI_a.o TestOpenMP_ViewAPI_b.o TestOpenMP_ViewAPI_c.o TestOpenMP_ViewAPI_d.o TestOpenMP_ViewAPI_e.o
-    OBJ_OPENMP += TestOpenMP_DeepCopyAlignment.o TestOpenMP_ViewCopy_a.o TestOpenMP_ViewCopy_b.o
+    OBJ_OPENMP += TestOpenMP_DeepCopyAlignment.o TestOpenMP_ViewCopy_a.o TestOpenMP_ViewCopy_b.o TestOpenMP_ViewCopy_c.o
     OBJ_OPENMP += TestOpenMP_ViewMapping_a.o TestOpenMP_ViewMapping_b.o TestOpenMP_ViewMapping_subview.o TestOpenMP_ViewResize.o TestOpenMP_ViewLayoutStrideAssignment.o
     OBJ_OPENMP += TestOpenMP_ViewOfClass.o
     OBJ_OPENMP += TestOpenMP_SubView_a.o TestOpenMP_SubView_b.o
@@ -237,7 +237,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_OPENMPTARGET), 1)
     #OBJ_OPENMPTARGET += TestOpenMPTarget_SharedAlloc.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_RangePolicy.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_ViewAPI_a.o TestOpenMPTarget_ViewAPI_b.o TestOpenMPTarget_ViewAPI_c.o TestOpenMPTarget_ViewAPI_d.o  #Some commented out code
-    #OBJ_OPENMPTARGET += TestOpenMPTarget_ViewAPI_e.o TestOpenMPTarget_ViewCopy_a.o TestOpenMPTarget_ViewCopy_b.o
+    #OBJ_OPENMPTARGET += TestOpenMPTarget_ViewAPI_e.o TestOpenMPTarget_ViewCopy_a.o TestOpenMPTarget_ViewCopy_b.o TestOpenMPTarget_ViewCopy_c.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_DeepCopyAlignment.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_ViewMapping_a.o
     OBJ_OPENMPTARGET += TestOpenMPTarget_ViewMapping_b.o
@@ -277,8 +277,8 @@ ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
 	tmp := $(foreach space, $(GPU_SPACES), \
 	  tmp2 := $(foreach test, $(GPU_SPACE_TESTS), \
 	    $(if $(filter Test$(space)_$(test).cpp, $(shell ls Test$(space)_$(test).cpp 2>/dev/null)),,\
-	      $(shell echo "\#include <Test$(space)_Category.hpp>" > Test$(space)_$(test).cpp); \
-	      $(shell echo "\#include <Test"$(test)".hpp>" >> Test$(space)_$(test).cpp); \
+	      $(shell echo "$(H)include <Test$(space)_Category.hpp>" > Test$(space)_$(test).cpp); \
+	      $(shell echo "$(H)include <Test"$(test)".hpp>" >> Test$(space)_$(test).cpp); \
 	    )\
 	  )\
 	)
@@ -292,7 +292,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_HIP), 1)
 	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_ViewCopy_a.o TestHIPHostPinned_ViewCopy_b.o TestHIPHostPinned_ViewCopy_c.o
 	OBJ_HIP += TestHIPHostPinned_ViewMapping_a.o TestHIPHostPinned_ViewMapping_b.o TestHIPHostPinned_ViewMapping_subview.o
 
 	TARGETS += KokkosCore_UnitTest_HIP
@@ -307,7 +307,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_HPX), 1)
 	OBJ_HPX += TestHPX_RangePolicy.o TestHPX_RangePolicyRequire.o
 	OBJ_HPX += TestHPX_View_64bit.o
 	OBJ_HPX += TestHPX_ViewAPI_a.o TestHPX_ViewAPI_b.o TestHPX_ViewAPI_c.o TestHPX_ViewAPI_d.o TestHPX_ViewAPI_e.o
-	OBJ_HPX += TestHPX_ViewCopy_a.o TestHPX_ViewCopy_b.o
+	OBJ_HPX += TestHPX_ViewCopy_a.o TestHPX_ViewCopy_b.o TestHPX_ViewCopy_c.o
 	OBJ_HPX += TestHPX_ViewMapping_a.o TestHPX_ViewMapping_b.o TestHPX_ViewMapping_subview.o TestHPX_ViewResize.o
 	OBJ_HPX += TestHPX_ViewOfClass.o
 	OBJ_HPX += TestHPX_SubView_a.o TestHPX_SubView_b.o
@@ -347,7 +347,7 @@ ifeq ($(KOKKOS_INTERNAL_USE_SERIAL), 1)
     OBJ_SERIAL += TestSerial_RangePolicy.o TestSerial_RangePolicyRequire.o
     OBJ_SERIAL += TestSerial_View_64bit.o
     OBJ_SERIAL += TestSerial_ViewAPI_a.o TestSerial_ViewAPI_b.o TestSerial_ViewAPI_c.o TestSerial_ViewAPI_d.o TestSerial_ViewAPI_e.o
-    OBJ_SERIAL += TestSerial_DeepCopyAlignment.o TestSerial_ViewCopy_a.o TestSerial_ViewCopy_b.o
+    OBJ_SERIAL += TestSerial_DeepCopyAlignment.o TestSerial_ViewCopy_a.o TestSerial_ViewCopy_b.o TestSerial_ViewCopy_c.o
     OBJ_SERIAL += TestSerial_ViewMapping_a.o TestSerial_ViewMapping_b.o TestSerial_ViewMapping_subview.o TestSerial_ViewResize.o TestSerial_ViewLayoutStrideAssignment.o
     OBJ_SERIAL += TestSerial_ViewOfClass.o
     OBJ_SERIAL += TestSerial_SubView_a.o TestSerial_SubView_b.o
diff --git a/core/unit_test/TestAbort.hpp b/core/unit_test/TestAbort.hpp
index 63e9bdc6e2..6e51ef6ee7 100644
--- a/core/unit_test/TestAbort.hpp
+++ b/core/unit_test/TestAbort.hpp
@@ -19,7 +19,6 @@
 #include <regex>
 #include <Kokkos_Core.hpp>
 
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
 TEST(TEST_CATEGORY_DEATH, abort_from_host) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
@@ -81,7 +80,13 @@ void test_abort_from_device() {
   } else {
     TestAbortCausingAbnormalProgramTerminationAndPrinting<ExecutionSpace>();
   }
-#elif defined(KOKKOS_ENABLE_SYCL)  // FIXME_SYCL
+#elif defined(KOKKOS_ENABLE_OPENACC)  // FIXME_OPENACC
+  if (std::is_same<ExecutionSpace, Kokkos::Experimental::OpenACC>::value) {
+    TestAbortPrintingToStdout<ExecutionSpace>();
+  } else {
+    TestAbortCausingAbnormalProgramTerminationAndPrinting<ExecutionSpace>();
+  }
+#elif defined(KOKKOS_ENABLE_SYCL)     // FIXME_SYCL
   if (std::is_same<ExecutionSpace, Kokkos::Experimental::SYCL>::value) {
 #ifdef NDEBUG
     TestAbortPrintingToStdout<ExecutionSpace>();
@@ -100,4 +105,3 @@ TEST(TEST_CATEGORY_DEATH, abort_from_device) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
   test_abort_from_device<TEST_EXECSPACE>();
 }
-#endif
diff --git a/core/unit_test/TestAggregate.hpp b/core/unit_test/TestAggregate.hpp
deleted file mode 100644
index 4f67b2eddc..0000000000
--- a/core/unit_test/TestAggregate.hpp
+++ /dev/null
@@ -1,112 +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 TEST_AGGREGATE_HPP
-#define TEST_AGGREGATE_HPP
-
-#include <Kokkos_Core.hpp>
-
-namespace Test {
-
-template <class DeviceType>
-void TestViewAggregate() {
-  using value_type = Kokkos::Array<double, 32>;
-  using analysis_1d =
-      Kokkos::Impl::ViewDataAnalysis<value_type *, Kokkos::LayoutLeft,
-                                     value_type>;
-
-  static_assert(
-      std::is_same<typename analysis_1d::specialize, Kokkos::Array<> >::value,
-      "");
-
-  using a32_traits = Kokkos::ViewTraits<value_type **, DeviceType>;
-  using flat_traits =
-      Kokkos::ViewTraits<typename a32_traits::scalar_array_type, DeviceType>;
-
-  static_assert(
-      std::is_same<typename a32_traits::specialize, Kokkos::Array<> >::value,
-      "");
-  static_assert(
-      std::is_same<typename a32_traits::value_type, value_type>::value, "");
-  static_assert(a32_traits::rank == 2, "");
-  static_assert(a32_traits::rank_dynamic == 2, "");
-
-  static_assert(std::is_void<typename flat_traits::specialize>::value, "");
-  static_assert(flat_traits::rank == 3, "");
-  static_assert(flat_traits::rank_dynamic == 2, "");
-  static_assert(flat_traits::dimension::N2 == 32, "");
-
-  using a32_type      = Kokkos::View<Kokkos::Array<double, 32> **, DeviceType>;
-  using a32_flat_type = typename a32_type::array_type;
-
-  static_assert(std::is_same<typename a32_type::value_type, value_type>::value,
-                "");
-  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, "");
-
-  a32_type x("test", 4, 5);
-  a32_flat_type y(x);
-
-  ASSERT_EQ(x.extent(0), 4u);
-  ASSERT_EQ(x.extent(1), 5u);
-  ASSERT_EQ(y.extent(0), 4u);
-  ASSERT_EQ(y.extent(1), 5u);
-  ASSERT_EQ(y.extent(2), 32u);
-
-  // Initialize arrays from brace-init-list as for std::array.
-  //
-  // Comment: Clang will issue the following warning if we don't use double
-  //          braces here (one for initializing the Kokkos::Array and one for
-  //          initializing the sub-aggreagate C-array data member),
-  //
-  //            warning: suggest braces around initialization of subobject
-  //
-  //          but single brace syntax would be valid as well.
-  Kokkos::Array<float, 2> aggregate_initialization_syntax_1 = {{1.41, 3.14}};
-  ASSERT_FLOAT_EQ(aggregate_initialization_syntax_1[0], 1.41);
-  ASSERT_FLOAT_EQ(aggregate_initialization_syntax_1[1], 3.14);
-
-  Kokkos::Array<int, 3> aggregate_initialization_syntax_2{
-      {0, 1, 2}};  // since C++11
-  for (int i = 0; i < 3; ++i) {
-    ASSERT_EQ(aggregate_initialization_syntax_2[i], i);
-  }
-
-  // Note that this is a valid initialization.
-  Kokkos::Array<double, 3> initialized_with_one_argument_missing = {{255, 255}};
-  for (int i = 0; i < 2; ++i) {
-    ASSERT_DOUBLE_EQ(initialized_with_one_argument_missing[i], 255);
-  }
-  // But the following line would not compile
-  //  Kokkos::Array< double, 3 > initialized_with_too_many{ { 1, 2, 3, 4 } };
-
-  // The code below must compile for zero-sized arrays.
-  using T = float;
-
-  constexpr int N = 0;
-  Kokkos::Array<T, N> a;
-  for (int i = 0; i < N; ++i) {
-    a[i] = T();
-  }
-}
-
-TEST(TEST_CATEGORY, view_aggregate) { TestViewAggregate<TEST_EXECSPACE>(); }
-
-}  // namespace Test
-
-#endif /* #ifndef TEST_AGGREGATE_HPP */
diff --git a/core/unit_test/TestArray.cpp b/core/unit_test/TestArray.cpp
index d3bdc4f93f..cb713a1782 100644
--- a/core/unit_test/TestArray.cpp
+++ b/core/unit_test/TestArray.cpp
@@ -15,9 +15,19 @@
 //@HEADER
 
 #include <Kokkos_Array.hpp>
+#include <Kokkos_DetectionIdiom.hpp>
 
 namespace {
 
+// nvcc errors on variables only used in static_asserts
+// Passing those variables to this function should eliminate the warning
+template <typename... Ts>
+KOKKOS_FUNCTION constexpr void maybe_unused(Ts&&...) {}
+
+template <typename T, typename U = T>
+using equality_comparable =
+    decltype(std::declval<T const&>() == std::declval<U const&>());
+
 KOKKOS_FUNCTION constexpr bool test_array() {
   constexpr Kokkos::Array<int, 3> a{{1, 2}};
 
@@ -49,4 +59,187 @@ KOKKOS_FUNCTION constexpr bool test_array_structured_binding_support() {
 
 static_assert(test_array_structured_binding_support());
 
+// Disable ctad test for intel versions < 2021, see issue #6702
+#if !defined(KOKKOS_COMPILER_INTEL) || KOKKOS_COMPILER_INTEL >= 2021
+KOKKOS_FUNCTION constexpr bool test_array_ctad() {
+  constexpr int x = 10;
+  constexpr Kokkos::Array a{1, 2, 3, 5, x};
+  constexpr Kokkos::Array<int, 5> b{1, 2, 3, 5, x};
+
+  return std::is_same_v<decltype(a), decltype(b)> && a == b;
+}
+
+static_assert(test_array_ctad());
+#endif
+
+KOKKOS_FUNCTION constexpr bool test_array_aggregate_initialization() {
+  // Initialize arrays from brace-init-list as for std::array.
+
+  Kokkos::Array<float, 2> aggregate_initialization_syntax_1 = {1.41f, 3.14f};
+  if ((aggregate_initialization_syntax_1[0] != 1.41f) ||
+      (aggregate_initialization_syntax_1[1] != 3.14f))
+    return false;
+
+  Kokkos::Array<int, 3> aggregate_initialization_syntax_2{
+      {0, 1, 2}};  // since C++11
+  if ((aggregate_initialization_syntax_2[0] != 0) ||
+      (aggregate_initialization_syntax_2[1] != 1) ||
+      (aggregate_initialization_syntax_2[2] != 2))
+    return false;
+
+  // Note that this is a valid initialization.
+  Kokkos::Array<double, 3> initialized_with_one_argument_missing = {{255, 255}};
+  if ((initialized_with_one_argument_missing[0] != 255) ||
+      (initialized_with_one_argument_missing[1] != 255) ||
+      (initialized_with_one_argument_missing[2] != 0))
+    return false;
+
+  // But the following line would not compile
+  //  Kokkos::Array< double, 3 > initialized_with_too_many{ { 1, 2, 3, 4 } };
+
+  return true;
+}
+
+static_assert(test_array_aggregate_initialization());
+
+// A few compilers, such as GCC 8.4, were erroring out when the function below
+// appeared in a constant expression because
+// Kokkos::Array<T, 0, Proxy>::operator[] is non-constexpr.  The issue
+// disappears with GCC 9.1 (https://godbolt.org/z/TG4TEef1b).  As a workaround,
+// the static_assert was dropped and the [[maybe_unused]] is used as an attempt
+// to silent warnings that the function is never used.
+[[maybe_unused]] KOKKOS_FUNCTION void test_array_zero_sized() {
+  using T = float;
+
+  // The code below must compile for zero-sized arrays.
+  constexpr int N = 0;
+  Kokkos::Array<T, N> a;
+  for (int i = 0; i < N; ++i) {
+    a[i] = T();
+  }
+}
+
+constexpr bool test_array_const_qualified_element_type() {
+  Kokkos::Array<int const, 1> a{255};
+  return a[0] == 255;
+}
+
+static_assert(test_array_const_qualified_element_type());
+
+// User-defined type providing a sepcialization of kokkos_swap
+struct MyInt {
+  int i;
+
+ private:
+  friend constexpr KOKKOS_FUNCTION void kokkos_swap(MyInt& lhs,
+                                                    MyInt& rhs) noexcept {
+    lhs.i = 255;
+    rhs.i = 127;
+  }
+};
+
+constexpr bool test_array_specialization_kokkos_swap() {
+  Kokkos::Array<MyInt, 2> a{MyInt{1}, MyInt{2}};
+  Kokkos::Array<MyInt, 2> b{MyInt{11}, MyInt{22}};
+
+  // sanity check
+  if (a[0].i != 1 || a[1].i != 2 || b[0].i != 11 || b[1].i != 22) {
+    return false;
+  }
+
+  using Kokkos::kokkos_swap;
+  kokkos_swap(a, b);
+
+  // check that the user-definied kokkos_swap(MyInt) overload was called
+  if (a[0].i != 255 || a[1].i != 255 || b[0].i != 127 || b[1].i != 127) {
+    return false;
+  }
+
+  return true;
+}
+
+static_assert(test_array_specialization_kokkos_swap());
+
+constexpr bool test_to_array() {
+  // copies a string literal
+  [[maybe_unused]] auto a1 = Kokkos::to_array("foo");
+  static_assert(a1.size() == 4);
+  maybe_unused(a1);
+
+  // deduces both element type and length
+  [[maybe_unused]] auto a2 = Kokkos::to_array({0, 2, 1, 3});
+  static_assert(std::is_same_v<decltype(a2), Kokkos::Array<int, 4>>);
+  maybe_unused(a2);
+
+// gcc8, icc, and nvcc 11.3 do not support the implicit conversion
+#if !(defined(KOKKOS_COMPILER_GNU) && (KOKKOS_COMPILER_GNU < 910)) &&      \
+    !(defined(KOKKOS_COMPILER_INTEL) && (KOKKOS_COMPILER_INTEL < 2021)) && \
+    !(defined(KOKKOS_COMPILER_NVCC) && (KOKKOS_COMPILER_NVCC < 1140))
+  // deduces length with element type specified
+  // implicit conversion happens
+  [[maybe_unused]] auto a3 = Kokkos::to_array<long>({0, 1, 3});
+  static_assert(std::is_same_v<decltype(a3), Kokkos::Array<long, 3>>);
+  maybe_unused(a3);
+#endif
+
+  return true;
+}
+
+static_assert(test_to_array());
+
+constexpr bool test_array_equality_comparable() {
+  using C0 = Kokkos::Array<char, 0>;
+  using C2 = Kokkos::Array<char, 2>;
+  using C3 = Kokkos::Array<char, 3>;
+  using I0 = Kokkos::Array<int, 0>;
+  using I2 = Kokkos::Array<int, 2>;
+  using I3 = Kokkos::Array<int, 3>;
+
+  static_assert(Kokkos::is_detected_v<equality_comparable, C0, C0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C0, C2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C0, C3>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C0, I0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C0, I2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C0, I3>);
+
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C2, C0>);
+  static_assert(Kokkos::is_detected_v<equality_comparable, C2, C2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C2, C3>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C2, I0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C2, I2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C2, I3>);
+
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C3, C0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C3, C2>);
+  static_assert(Kokkos::is_detected_v<equality_comparable, C3, C3>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C3, I0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C3, I2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, C3, I3>);
+
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I0, C0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I0, C2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I0, C3>);
+  static_assert(Kokkos::is_detected_v<equality_comparable, I0, I0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I0, I2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I0, I3>);
+
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I2, C0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I2, C2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I2, C3>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I2, I0>);
+  static_assert(Kokkos::is_detected_v<equality_comparable, I2, I2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I2, I3>);
+
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I3, C0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I3, C2>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I3, C3>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I3, I0>);
+  static_assert(!Kokkos::is_detected_v<equality_comparable, I3, I2>);
+  static_assert(Kokkos::is_detected_v<equality_comparable, I3, I3>);
+
+  return true;
+}
+
+static_assert(test_array_equality_comparable());
+
 }  // namespace
diff --git a/core/unit_test/TestArrayOps.hpp b/core/unit_test/TestArrayOps.hpp
new file mode 100644
index 0000000000..29a452b660
--- /dev/null
+++ b/core/unit_test/TestArrayOps.hpp
@@ -0,0 +1,422 @@
+//@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 <numeric>
+
+namespace {
+
+TEST(TEST_CATEGORY, array_capacity) {
+  using A = Kokkos::Array<int, 2>;
+  A a{{3, 5}};
+
+  ASSERT_FALSE(a.empty());
+  ASSERT_EQ(a.size(), 2u);
+  ASSERT_EQ(a.max_size(), 2u);
+}
+
+enum Enum { EZero, EOne };
+enum EnumShort : short { ESZero, ESOne };
+
+TEST(TEST_CATEGORY, array_element_access) {
+  using A = Kokkos::Array<int, 2>;
+  A a{{3, 5}};
+  A const& ca = a;
+
+  size_t index = 1;
+  ASSERT_EQ(a[index], 5);
+
+  auto sc = static_cast<signed char>(index);
+  ASSERT_EQ(a[sc], a[index]);
+  ASSERT_EQ(ca[sc], a[index]);
+
+  auto uc = static_cast<unsigned char>(index);
+  ASSERT_EQ(a[uc], a[index]);
+  ASSERT_EQ(ca[uc], a[index]);
+
+  auto s = static_cast<short>(index);
+  ASSERT_EQ(a[s], a[index]);
+  ASSERT_EQ(ca[s], a[index]);
+
+  auto us = static_cast<unsigned short>(index);
+  ASSERT_EQ(a[us], a[index]);
+  ASSERT_EQ(ca[us], a[index]);
+
+  auto i = static_cast<int>(index);
+  ASSERT_EQ(a[i], a[index]);
+  ASSERT_EQ(ca[i], a[index]);
+
+  auto ui = static_cast<unsigned int>(index);
+  ASSERT_EQ(a[ui], a[index]);
+  ASSERT_EQ(ca[ui], a[index]);
+
+  auto l = static_cast<long>(index);
+  ASSERT_EQ(a[l], a[index]);
+  ASSERT_EQ(ca[l], a[index]);
+
+  auto ul = static_cast<unsigned long>(index);
+  ASSERT_EQ(a[ul], a[index]);
+  ASSERT_EQ(ca[ul], a[index]);
+
+  auto ll = static_cast<long long>(index);
+  ASSERT_EQ(a[ll], a[index]);
+  ASSERT_EQ(ca[ll], a[index]);
+
+  auto ull = static_cast<unsigned long long>(index);
+  ASSERT_EQ(a[ull], a[index]);
+  ASSERT_EQ(ca[ull], a[index]);
+
+  auto e = static_cast<Enum>(index);
+  ASSERT_EQ(a[e], a[index]);
+  ASSERT_EQ(ca[e], a[index]);
+
+  auto es = static_cast<EnumShort>(index);
+  ASSERT_EQ(a[es], a[index]);
+  ASSERT_EQ(ca[es], a[index]);
+
+  ASSERT_EQ(a.data()[index], a[index]);
+  ASSERT_EQ(ca.data()[index], a[index]);
+}
+
+TEST(TEST_CATEGORY, array_operator_equal) {
+  using A = Kokkos::Array<int, 2>;
+  constexpr A a{{3, 5}};
+  constexpr A b{{3, 5}};
+  constexpr A c{{5, 3}};
+
+  static_assert(a == b);
+  static_assert(!(a == c));
+  static_assert(a != c);
+
+  ASSERT_TRUE(a == b);
+  ASSERT_FALSE(a == c);
+  ASSERT_TRUE(a != c);
+
+  using E = Kokkos::Array<int, 0>;
+  constexpr E e;
+  constexpr E f;
+
+  static_assert(e == f);
+  static_assert(!(e != f));
+
+  ASSERT_TRUE(e == f);
+  ASSERT_FALSE(e != f);
+}
+
+TEST(TEST_CATEGORY, array_zero_capacity) {
+  using A = Kokkos::Array<int, 0>;
+  A e;
+
+  ASSERT_TRUE(e.empty());
+  ASSERT_EQ(e.size(), 0u);
+  ASSERT_EQ(e.max_size(), 0u);
+}
+
+TEST(TEST_CATEGORY, array_zero_data_nullptr) {
+  using A = Kokkos::Array<int, 0>;
+
+  A e;
+  ASSERT_EQ(e.data(), nullptr);
+
+  const A& ce = e;
+  ASSERT_EQ(ce.data(), nullptr);
+}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
+TEST(TEST_CATEGORY, array_contiguous_capacity) {
+  using A =
+      Kokkos::Array<int, KOKKOS_INVALID_INDEX, Kokkos::Array<>::contiguous>;
+
+  A e(nullptr, 0);
+
+  ASSERT_TRUE(e.empty());
+  ASSERT_EQ(e.size(), 0u);
+  ASSERT_EQ(e.max_size(), 0u);
+
+  int aa[] = {3, 5};
+  A a(aa, std::size(aa));
+
+  ASSERT_EQ(a.empty(), 0 == std::size(aa));
+  ASSERT_EQ(a.size(), std::size(aa));
+  ASSERT_EQ(a.max_size(), std::size(aa));
+}
+
+TEST(TEST_CATEGORY, array_contiguous_element_access) {
+  int aa[] = {3, 5};
+  using A =
+      Kokkos::Array<int, KOKKOS_INVALID_INDEX, Kokkos::Array<>::contiguous>;
+  A a(aa, std::size(aa));
+  A const& ca = a;
+
+  size_t index = 1;
+  ASSERT_EQ(std::addressof(a[index]), std::addressof(aa[index]));
+
+  auto sc = static_cast<signed char>(index);
+  ASSERT_EQ(a[sc], aa[index]);
+  ASSERT_EQ(ca[sc], aa[index]);
+
+  auto uc = static_cast<unsigned char>(index);
+  ASSERT_EQ(a[uc], aa[index]);
+  ASSERT_EQ(ca[uc], aa[index]);
+
+  auto s = static_cast<short>(index);
+  ASSERT_EQ(a[s], aa[index]);
+  ASSERT_EQ(ca[s], aa[index]);
+
+  auto us = static_cast<unsigned short>(index);
+  ASSERT_EQ(a[us], aa[index]);
+  ASSERT_EQ(ca[us], aa[index]);
+
+  auto i = static_cast<int>(index);
+  ASSERT_EQ(a[i], aa[index]);
+  ASSERT_EQ(ca[i], aa[index]);
+
+  auto ui = static_cast<unsigned int>(index);
+  ASSERT_EQ(a[ui], aa[index]);
+  ASSERT_EQ(ca[ui], aa[index]);
+
+  auto l = static_cast<long>(index);
+  ASSERT_EQ(a[l], aa[index]);
+  ASSERT_EQ(ca[l], aa[index]);
+
+  auto ul = static_cast<unsigned long>(index);
+  ASSERT_EQ(a[ul], aa[index]);
+  ASSERT_EQ(ca[ul], aa[index]);
+
+  auto ll = static_cast<long long>(index);
+  ASSERT_EQ(a[ll], aa[index]);
+  ASSERT_EQ(ca[ll], aa[index]);
+
+  auto ull = static_cast<unsigned long long>(index);
+  ASSERT_EQ(a[ull], aa[index]);
+  ASSERT_EQ(ca[ull], aa[index]);
+
+  auto e = static_cast<Enum>(index);
+  ASSERT_EQ(a[e], aa[index]);
+  ASSERT_EQ(ca[e], aa[index]);
+
+  auto es = static_cast<EnumShort>(index);
+  ASSERT_EQ(a[es], aa[index]);
+  ASSERT_EQ(ca[es], aa[index]);
+
+  ASSERT_EQ(a.data(), aa);
+  ASSERT_EQ(ca.data(), aa);
+}
+
+TEST(TEST_CATEGORY, array_contiguous_assignment) {
+  using A =
+      Kokkos::Array<int, KOKKOS_INVALID_INDEX, Kokkos::Array<>::contiguous>;
+
+  int aa[] = {3, 5};
+  A a(aa, std::size(aa));
+
+  // operator=(Array<T, N, P> const&) semantics when lhs size a > rhs size b
+  using B = Kokkos::Array<int, 1>;
+  static_assert(std::size(aa) > B::size());
+  B b{{7}};
+
+  ASSERT_GT(std::size(a), std::size(b));
+  a = b;
+  ASSERT_GT(std::size(a), std::size(b));
+
+  ASSERT_EQ(a.size(), std::size(aa));
+  ASSERT_EQ(a.max_size(), std::size(aa));
+  ASSERT_EQ(a[0], 7);
+  ASSERT_EQ(a[1], 5);
+
+  // operator=(Array<T, N, P> const&) semantics when lhs size a < rhs size d
+  using D = Kokkos::Array<int, 4>;
+  static_assert(std::size(aa) < D::size());
+  D d{{11, 13, 17, 19}};
+
+  ASSERT_LT(std::size(a), std::size(d));
+  a = d;
+  ASSERT_LT(std::size(a), std::size(d));
+
+  ASSERT_EQ(a.size(), std::size(aa));
+  ASSERT_EQ(a.max_size(), std::size(aa));
+  ASSERT_EQ(a[0], 11);
+  ASSERT_EQ(a[1], 13);
+
+  // Copy assignment operator semantics when lhs size a > rhs size e
+  int ee[] = {23};
+  A e(ee, std::size(ee));
+
+  ASSERT_GT(a.size(), e.size());
+  a = e;
+  ASSERT_GT(a.size(), e.size());
+
+  ASSERT_EQ(a.size(), std::size(aa));
+  ASSERT_EQ(a.max_size(), std::size(aa));
+  ASSERT_EQ(a[0], 23);
+  ASSERT_EQ(a[1], 13);
+
+  // Copy assignment operator semantics when lhs size e < rhs size a
+  ASSERT_LT(e.size(), a.size());
+  e[0] = 29;  // To check that e[0] is overwritten by e = a
+  e    = a;
+  ASSERT_LT(e.size(), a.size());
+
+  ASSERT_EQ(e.size(), std::size(ee));
+  ASSERT_EQ(e.max_size(), std::size(ee));
+  ASSERT_EQ(e[0], 23);
+}
+
+TEST(TEST_CATEGORY, array_strided_capacity) {
+  using A = Kokkos::Array<int, KOKKOS_INVALID_INDEX, Kokkos::Array<>::strided>;
+
+  A e(nullptr, 0, 0);
+
+  ASSERT_TRUE(e.empty());
+  ASSERT_EQ(e.size(), 0u);
+  ASSERT_EQ(e.max_size(), 0u);
+
+  int aa[]                 = {5, 7, 11, 13, 17, 19};
+  constexpr size_t aStride = 2;
+  A a(aa, std::size(aa) / aStride, aStride);
+
+  ASSERT_EQ(a.empty(), 0 == std::size(aa) / aStride);
+  ASSERT_EQ(a.size(), std::size(aa) / aStride);
+  ASSERT_EQ(a.max_size(), std::size(aa) / aStride);
+}
+
+TEST(TEST_CATEGORY, array_strided_element_access) {
+  using A = Kokkos::Array<int, KOKKOS_INVALID_INDEX, Kokkos::Array<>::strided>;
+
+  int aa[]                 = {5, 7, 11, 13, 17, 19};
+  constexpr size_t aStride = 2;
+
+  A a(aa, std::size(aa) / aStride, aStride);
+  A const& ca = a;
+
+  size_t index = 1;
+  ASSERT_EQ(std::addressof(a[index]), std::addressof(aa[index * aStride]));
+
+  auto sc = static_cast<signed char>(index);
+  ASSERT_EQ(a[sc], aa[index * aStride]);
+  ASSERT_EQ(ca[sc], aa[index * aStride]);
+
+  auto uc = static_cast<unsigned char>(index);
+  ASSERT_EQ(a[uc], aa[index * aStride]);
+  ASSERT_EQ(ca[uc], aa[index * aStride]);
+
+  auto s = static_cast<short>(index);
+  ASSERT_EQ(a[s], aa[index * aStride]);
+  ASSERT_EQ(ca[s], aa[index * aStride]);
+
+  auto us = static_cast<unsigned short>(index);
+  ASSERT_EQ(a[us], aa[index * aStride]);
+  ASSERT_EQ(ca[us], aa[index * aStride]);
+
+  auto i = static_cast<int>(index);
+  ASSERT_EQ(a[i], aa[index * aStride]);
+  ASSERT_EQ(ca[i], aa[index * aStride]);
+
+  auto ui = static_cast<unsigned int>(index);
+  ASSERT_EQ(a[ui], aa[index * aStride]);
+  ASSERT_EQ(ca[ui], aa[index * aStride]);
+
+  auto l = static_cast<long>(index);
+  ASSERT_EQ(a[l], aa[index * aStride]);
+  ASSERT_EQ(ca[l], aa[index * aStride]);
+
+  auto ul = static_cast<unsigned long>(index);
+  ASSERT_EQ(a[ul], aa[index * aStride]);
+  ASSERT_EQ(ca[ul], aa[index * aStride]);
+
+  auto ll = static_cast<long long>(index);
+  ASSERT_EQ(a[ll], aa[index * aStride]);
+  ASSERT_EQ(ca[ll], aa[index * aStride]);
+
+  auto ull = static_cast<unsigned long long>(index);
+  ASSERT_EQ(a[ull], aa[index * aStride]);
+  ASSERT_EQ(ca[ull], aa[index * aStride]);
+
+  auto e = static_cast<Enum>(index);
+  ASSERT_EQ(a[e], aa[index * aStride]);
+  ASSERT_EQ(ca[e], aa[index * aStride]);
+
+  auto es = static_cast<EnumShort>(index);
+  ASSERT_EQ(a[es], aa[index * aStride]);
+  ASSERT_EQ(ca[es], aa[index * aStride]);
+
+  ASSERT_EQ(a.data(), aa);
+  ASSERT_EQ(ca.data(), aa);
+}
+
+TEST(TEST_CATEGORY, array_strided_assignment) {
+  using A  = Kokkos::Array<int, KOKKOS_INVALID_INDEX, Kokkos::Array<>::strided>;
+  int aa[] = {5, 7, 11, 13, 17, 19};
+  constexpr size_t aStride = 2;
+  A a(aa, std::size(aa) / aStride, aStride);
+
+  // operator=(Array<T, N, P> const&) semantics when lhs size a > rhs size b
+  using B = Kokkos::Array<int, 1>;
+  static_assert(std::size(aa) / aStride > B::size());
+  B b{{23}};
+
+  ASSERT_GT(std::size(a), std::size(b));
+  a = b;
+  ASSERT_GT(std::size(a), std::size(b));
+
+  ASSERT_EQ(a.size(), std::size(aa) / aStride);
+  ASSERT_EQ(a.max_size(), std::size(aa) / aStride);
+  ASSERT_EQ(a[0], b[0]);
+  ASSERT_EQ(a[1], aa[1 * aStride]);
+
+  // operator=(Array<T, N, P> const&) semantics when lhs size a < rhs size d
+  using D = Kokkos::Array<int, 7>;
+  static_assert(std::size(aa) / aStride < D::size());
+  D d{{29, 31, 37, 41, 43, 47, 53}};
+
+  ASSERT_LT(std::size(a), std::size(d));
+  a = d;
+  ASSERT_LT(std::size(a), std::size(d));
+
+  ASSERT_EQ(a.size(), std::size(aa) / aStride);
+  ASSERT_EQ(a.max_size(), std::size(aa) / aStride);
+  ASSERT_EQ(a[0], d[0]);
+  ASSERT_EQ(a[1], d[1]);
+
+  // Copy assignment operator semantics when lhs size a > rhs size e
+  int ee[]                 = {59, 61, 67, 71, 73, 79};
+  constexpr size_t eStride = 3;
+  A e(ee, std::size(ee) / eStride, eStride);
+
+  ASSERT_GT(a.size(), e.size());
+  a = e;
+  ASSERT_GT(a.size(), e.size());
+
+  ASSERT_EQ(a.size(), std::size(aa) / aStride);
+  ASSERT_EQ(a.max_size(), std::size(aa) / aStride);
+  ASSERT_EQ(a[0], ee[0 * eStride]);
+  ASSERT_EQ(a[1], ee[1 * eStride]);
+
+  // Copy assignment operator semantics when lhs size e < rhs size a
+  e[0] = 83;  // To check that e[0] is overwritten by e = a
+  ASSERT_LT(e.size(), a.size());
+  e = a;
+  ASSERT_LT(e.size(), a.size());
+  ASSERT_EQ(e.size(), std::size(ee) / eStride);
+  ASSERT_EQ(e.max_size(), std::size(ee) / eStride);
+  ASSERT_EQ(e[0], ee[0]);
+}
+KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP()
+#endif
+
+}  // namespace
diff --git a/core/unit_test/TestAtomicOperations.hpp b/core/unit_test/TestAtomicOperations.hpp
index 9965041e52..957ba9a7aa 100644
--- a/core/unit_test/TestAtomicOperations.hpp
+++ b/core/unit_test/TestAtomicOperations.hpp
@@ -15,1146 +15,515 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
+#include <Kokkos_Pair.hpp>
 
 namespace TestAtomicOperations {
 
-//-----------------------------------------------
-//--------------zero_functor---------------------
-//-----------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct ZeroFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = typename Kokkos::View<T, execution_space>;
-  using h_type          = typename Kokkos::View<T, execution_space>::HostMirror;
-
-  type data;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { data() = 0; }
+struct AddAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_add(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_add(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_add_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
+  }
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old + update;
+  }
+  static const char* name() { return "add"; }
 };
 
-//-----------------------------------------------
-//--------------init_functor---------------------
-//-----------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct InitFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = typename Kokkos::View<T, execution_space>;
-  using h_type          = typename Kokkos::View<T, execution_space>::HostMirror;
-
-  type data;
-  T init_value;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { data() = init_value; }
-
-  InitFunctor(T _init_value) : init_value(_init_value) {}
+struct SubAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_sub(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_sub(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_sub_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
+  }
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old - update;
+  }
+  static const char* name() { return "sub"; }
 };
 
-//---------------------------------------------------
-//--------------atomic_load/store/assign---------------------
-//---------------------------------------------------
-template <class T, class DEVICE_TYPE>
-struct LoadStoreFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    T old = Kokkos::atomic_load(&data());
-    if (old != i0)
-      Kokkos::abort("Kokkos Atomic Load didn't get the right value");
-    Kokkos::atomic_store(&data(), i1);
-    Kokkos::atomic_assign(&data(), old);
+struct IncAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T) {
+    Kokkos::atomic_inc(ptr_op);
+    T old_val = Kokkos::atomic_fetch_inc(ptr_fetch_op);
+    T new_val = Kokkos::atomic_inc_fetch(ptr_op_fetch);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-  LoadStoreFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T) {
+    return old + 1;
+  }
+  static const char* name() { return "inc"; }
 };
 
-template <class T, class DeviceType>
-bool LoadStoreAtomicTest(T i0, T i1) {
-  using execution_space = typename DeviceType::execution_space;
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct LoadStoreFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-
-  Kokkos::deep_copy(h_data, data);
-
-  return h_data() == i0;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_max---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct MaxFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    // Kokkos::atomic_fetch_max( &data(), (T) 1 );
-    Kokkos::atomic_fetch_max(&data(), (T)i1);
+struct DecAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T) {
+    Kokkos::atomic_dec(ptr_op);
+    T old_val = Kokkos::atomic_fetch_dec(ptr_fetch_op);
+    T new_val = Kokkos::atomic_dec_fetch(ptr_op_fetch);
+    return Kokkos::pair<T, T>(old_val, new_val);
+  }
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T) {
+    return old - 1;
   }
-  MaxFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  static const char* name() { return "dec"; }
 };
 
-template <class T, class execution_space>
-T MaxAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct MaxFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T MaxAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = (i0 > i1 ? i0 : i1);
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool MaxAtomicTest(T i0, T i1) {
-  T res       = MaxAtomic<T, DeviceType>(i0, i1);
-  T resSerial = MaxAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = MaxAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct MaxAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_max(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_max(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_max_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_min---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct MinFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_min(&data(), (T)i1); }
-
-  MinFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return update > old ? update : old;
+  }
+  static const char* name() { return "max"; }
 };
 
-template <class T, class execution_space>
-T MinAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct MinFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T MinAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = (i0 < i1 ? i0 : i1);
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool MinAtomicTest(T i0, T i1) {
-  T res       = MinAtomic<T, DeviceType>(i0, i1);
-  T resSerial = MinAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = MinAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct MinAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_min(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_min(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_min_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_increment---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct IncFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_increment(&data()); }
-
-  IncFunctor(T _i0) : i0(_i0) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return update < old ? update : old;
+  }
+  static const char* name() { return "min"; }
 };
 
-template <class T, class execution_space>
-T IncAtomic(T i0) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct IncFunctor<T, execution_space> f(i0);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T IncAtomicCheck(T i0) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 + 1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool IncAtomicTest(T i0) {
-  T res       = IncAtomic<T, DeviceType>(i0);
-  T resSerial = IncAtomicCheck<T>(i0);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = IncAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct MulAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_mul(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_mul(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_mul_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//-------------atomic_wrapping_increment-------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct WrappingIncFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    desul::atomic_fetch_inc_mod(&data(), (T)i1, desul::MemoryOrderRelaxed(),
-                                desul::MemoryScopeDevice());
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old * update;
   }
-
-  WrappingIncFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  static const char* name() { return "mul"; }
 };
 
-template <class T, class execution_space>
-T WrappingIncAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct WrappingIncFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T WrappingIncAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  // Wraps to 0 when i0 >= i1
-  *data = ((i0 >= i1) ? (T)0 : i0 + (T)1);
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool WrappingIncAtomicTest(T i0, T i1) {
-  T res       = WrappingIncAtomic<T, DeviceType>(i0, i1);
-  T resSerial = WrappingIncAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name()
-              << ">( test = WrappingIncAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct DivAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_div(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_div(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_div_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_decrement---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct DecFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_decrement(&data()); }
-
-  DecFunctor(T _i0) : i0(_i0) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old / update;
+  }
+  static const char* name() { return "div"; }
 };
 
-template <class T, class execution_space>
-T DecAtomic(T i0) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct DecFunctor<T, execution_space> f(i0);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T DecAtomicCheck(T i0) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 - 1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool DecAtomicTest(T i0) {
-  T res       = DecAtomic<T, DeviceType>(i0);
-  T resSerial = DecAtomicCheck<T>(i0);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = DecAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct ModAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    // Kokkos::atomic_mod(ptr_op, update);
+    (void)Kokkos::atomic_fetch_mod(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_mod(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_mod_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//-------------atomic_wrapping_decrement-------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct WrappingDecFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    desul::atomic_fetch_dec_mod(&data(), (T)i1, desul::MemoryOrderRelaxed(),
-                                desul::MemoryScopeDevice());
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old % update;
   }
-
-  WrappingDecFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  static const char* name() { return "mod"; }
 };
 
-template <class T, class execution_space>
-T WrappingDecAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct WrappingDecFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T WrappingDecAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  // Wraps to i1 when i0 <= 0
-  // i0 should never be negative
-  *data = ((i0 <= (T)0) ? i1 : i0 - (T)1);
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool WrappingDecAtomicTest(T i0, T i1) {
-  T res       = WrappingDecAtomic<T, DeviceType>(i0, i1);
-  T resSerial = WrappingDecAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name()
-              << ">( test = WrappingDecAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct AndAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_and(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_and(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_and_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_mul---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct MulFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_mul(&data(), (T)i1); }
-
-  MulFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old & update;
+  }
+  static const char* name() { return "and"; }
 };
 
-template <class T, class execution_space>
-T MulAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct MulFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T MulAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 * i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool MulAtomicTest(T i0, T i1) {
-  T res       = MulAtomic<T, DeviceType>(i0, i1);
-  T resSerial = MulAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = MulAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct OrAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    Kokkos::atomic_or(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_or(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_or_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_div---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct DivFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_div(&data(), (T)i1); }
-
-  DivFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old | update;
+  }
+  static const char* name() { return "or"; }
 };
 
-template <class T, class execution_space>
-T DivAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct DivFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T DivAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 / i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool DivAtomicTest(T i0, T i1) {
-  T res       = DivAtomic<T, DeviceType>(i0, i1);
-  T resSerial = DivAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  using Kokkos::abs;
-  if (abs((resSerial - res) * 1.) > 1e-5) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = DivAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct XorAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    // Kokkos::atomic_xor(ptr_op, update);
+    (void)Kokkos::atomic_fetch_xor(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_xor(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_xor_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_mod---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct ModFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_mod(&data(), (T)i1); }
-
-  ModFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old ^ update;
+  }
+  static const char* name() { return "xor"; }
 };
 
-template <class T, class execution_space>
-T ModAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct ModFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T ModAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 % i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool ModAtomicTest(T i0, T i1) {
-  T res       = ModAtomic<T, DeviceType>(i0, i1);
-  T resSerial = ModAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = ModAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct NandAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    // Kokkos::atomic_nand(ptr_op, update);
+    (void)Kokkos::atomic_fetch_nand(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_nand(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_nand_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_and---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct AndFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    T result = Kokkos::atomic_fetch_and(&data(), (T)i1);
-    Kokkos::atomic_and(&data(), result);
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return ~(old & update);
   }
-
-  AndFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  static const char* name() { return "nand"; }
 };
 
-template <class T, class execution_space>
-T AndAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct AndFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T AndAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 & i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool AndAtomicTest(T i0, T i1) {
-  T res       = AndAtomic<T, DeviceType>(i0, i1);
-  T resSerial = AndAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = AndAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct LShiftAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    // Kokkos::atomic_lshift(ptr_op, update);
+    (void)Kokkos::atomic_fetch_lshift(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_lshift(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_lshift_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_or----------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct OrFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const {
-    T result = Kokkos::atomic_fetch_or(&data(), (T)i1);
-    Kokkos::atomic_or(&data(), result);
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old << update;
   }
-
-  OrFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  static const char* name() { return "lshift"; }
 };
 
-template <class T, class execution_space>
-T OrAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct OrFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T OrAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 | i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool OrAtomicTest(T i0, T i1) {
-  T res       = OrAtomic<T, DeviceType>(i0, i1);
-  T resSerial = OrAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = OrAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct RShiftAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    // Kokkos::atomic_rshift(ptr_op, update); not implemented
+    (void)Kokkos::atomic_fetch_rshift(ptr_op, update);
+    T old_val = Kokkos::atomic_fetch_rshift(ptr_fetch_op, update);
+    T new_val = Kokkos::atomic_rshift_fetch(ptr_op_fetch, update);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_xor---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct XorFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_xor(&data(), (T)i1); }
-
-  XorFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T update) {
+    return old >> update;
+  }
+  static const char* name() { return "rshift"; }
 };
 
-template <class T, class execution_space>
-T XorAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct XorFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T XorAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 ^ i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool XorAtomicTest(T i0, T i1) {
-  T res       = XorAtomic<T, DeviceType>(i0, i1);
-  T resSerial = XorAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = XorAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct LoadStoreAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T update) {
+    T old_val = Kokkos::atomic_load(ptr_op);
+    Kokkos::atomic_store(ptr_op, update);
+    Kokkos::atomic_store(ptr_op_fetch, update);
+    Kokkos::atomic_store(ptr_fetch_op, update);
+    return Kokkos::pair<T, T>(old_val, update);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_lshift---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct LShiftFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_lshift(&data(), (T)i1); }
-
-  LShiftFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T, T update) {
+    return update;
+  }
+  static const char* name() { return "load/store"; }
 };
 
-template <class T, class execution_space>
-T LShiftAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct LShiftFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
-
-  return val;
-}
-
-template <class T>
-T LShiftAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 << i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool LShiftAtomicTest(T i0, T i1) {
-  T res       = LShiftAtomic<T, DeviceType>(i0, i1);
-  T resSerial = LShiftAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = LShiftAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
+struct IncModAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T wrap_value) {
+    // no atomic_inc_mod in desul
+    (void)desul::atomic_fetch_inc_mod(ptr_op, wrap_value,
+                                      desul::MemoryOrderRelaxed(),
+                                      desul::MemoryScopeDevice());
+    T old_val = desul::atomic_fetch_inc_mod(ptr_fetch_op, wrap_value,
+                                            desul::MemoryOrderRelaxed(),
+                                            desul::MemoryScopeDevice());
+    // no atomic_inc_mod_fetch in desul
+    (void)desul::atomic_fetch_inc_mod(ptr_op_fetch, wrap_value,
+                                      desul::MemoryOrderRelaxed(),
+                                      desul::MemoryScopeDevice());
+    T new_val = op(old_val, wrap_value);
+    return Kokkos::pair<T, T>(old_val, new_val);
   }
-
-  return passed;
-}
-
-//---------------------------------------------------
-//--------------atomic_fetch_rshift---------------------
-//---------------------------------------------------
-
-template <class T, class DEVICE_TYPE>
-struct RShiftFunctor {
-  using execution_space = DEVICE_TYPE;
-  using type            = Kokkos::View<T, execution_space>;
-
-  type data;
-  T i0;
-  T i1;
-
-  KOKKOS_INLINE_FUNCTION
-  void operator()(int) const { Kokkos::atomic_fetch_rshift(&data(), (T)i1); }
-
-  RShiftFunctor(T _i0, T _i1) : i0(_i0), i1(_i1) {}
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T wrap_value) {
+    return old + 1 > wrap_value ? 0 : old + 1;
+  }
+  static const char* name() { return "inc_mod"; }
 };
 
-template <class T, class execution_space>
-T RShiftAtomic(T i0, T i1) {
-  struct InitFunctor<T, execution_space> f_init(i0);
-  typename InitFunctor<T, execution_space>::type data("Data");
-  typename InitFunctor<T, execution_space>::h_type h_data("HData");
-
-  f_init.data = data;
-  Kokkos::parallel_for(1, f_init);
-  execution_space().fence();
-
-  struct RShiftFunctor<T, execution_space> f(i0, i1);
-
-  f.data = data;
-  Kokkos::parallel_for(1, f);
-  execution_space().fence();
-
-  Kokkos::deep_copy(h_data, data);
-  T val = h_data();
+struct DecModAtomicTest {
+  template <class T>
+  KOKKOS_FUNCTION static auto atomic_op(T* ptr_op, T* ptr_fetch_op,
+                                        T* ptr_op_fetch, T wrap_value) {
+    // no atomic_dec_mod in desul
+    (void)desul::atomic_fetch_dec_mod(ptr_op, wrap_value,
+                                      desul::MemoryOrderRelaxed(),
+                                      desul::MemoryScopeDevice());
+    T old_val = desul::atomic_fetch_dec_mod(ptr_fetch_op, wrap_value,
+                                            desul::MemoryOrderRelaxed(),
+                                            desul::MemoryScopeDevice());
+    // no atomic_dec_mod_fetch in desul
+    (void)desul::atomic_fetch_dec_mod(ptr_op_fetch, wrap_value,
+                                      desul::MemoryOrderRelaxed(),
+                                      desul::MemoryScopeDevice());
+    T new_val = op(old_val, wrap_value);
+    return Kokkos::pair<T, T>(old_val, new_val);
+  }
+  template <class T>
+  KOKKOS_FUNCTION static T op(T old, T wrap_value) {
+    return ((old == 0) || (old > wrap_value)) ? wrap_value : old - 1;
+  }
+  static const char* name() { return "dec_mod"; }
+};
 
-  return val;
+template <class Op, class T, class ExecSpace>
+bool atomic_op_test(T old_val, T update) {
+  Kokkos::View<T[3], ExecSpace> op_data("op_data");
+  Kokkos::deep_copy(op_data, old_val);
+  int result = 0;
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecSpace>(0, 1),
+      KOKKOS_LAMBDA(int, int& local_result) {
+        auto fetch_result =
+            Op::atomic_op(&op_data(0), &op_data(1), &op_data(2), update);
+        T expected_val = Op::op(old_val, update);
+        Kokkos::memory_fence();
+        if (op_data(0) != expected_val) local_result += 1;
+        if (op_data(1) != expected_val) local_result += 2;
+        if (op_data(2) != expected_val) local_result += 4;
+        if (fetch_result.first != old_val) local_result += 8;
+        if (fetch_result.second != expected_val) local_result += 16;
+      },
+      result);
+  if ((result & 1) != 0)
+    printf("atomic_%s failed with type %s\n", Op::name(), typeid(T).name());
+  if ((result & 2) != 0)
+    printf("atomic_fetch_%s failed with type %s\n", Op::name(),
+           typeid(T).name());
+  if ((result & 4) != 0)
+    printf("atomic_%s_fetch failed with type %s\n", Op::name(),
+           typeid(T).name());
+  if ((result & 8) != 0)
+    printf("atomic_fetch_%s did not return old value with type %s\n",
+           Op::name(), typeid(T).name());
+  if ((result & 16) != 0)
+    printf("atomic_%s_fetch did not return updated value with type %s\n",
+           Op::name(), typeid(T).name());
+
+  return result == 0;
 }
 
 template <class T>
-T RShiftAtomicCheck(T i0, T i1) {
-  T* data = new T[1];
-  data[0] = 0;
-
-  *data = i0 >> i1;
-
-  T val = *data;
-  delete[] data;
-
-  return val;
-}
-
-template <class T, class DeviceType>
-bool RShiftAtomicTest(T i0, T i1) {
-  T res       = RShiftAtomic<T, DeviceType>(i0, i1);
-  T resSerial = RShiftAtomicCheck<T>(i0, i1);
-
-  bool passed = true;
-
-  if (resSerial != res) {
-    passed = false;
-
-    std::cout << "Loop<" << typeid(T).name() << ">( test = RShiftAtomicTest"
-              << " FAILED : " << resSerial << " != " << res << std::endl;
-  }
-
-  return passed;
+constexpr T relative_error_threshold = T(1.0e-15);
+
+template <class Op, class T, class ExecSpace>
+bool atomic_op_test_rel(T old_val, T update) {
+  Kokkos::View<T[3], ExecSpace> op_data("op_data");
+  Kokkos::deep_copy(op_data, old_val);
+  int result = 0;
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecSpace>(0, 1),
+      KOKKOS_LAMBDA(int, int& local_result) {
+        auto fetch_result =
+            Op::atomic_op(&op_data(0), &op_data(1), &op_data(2), update);
+        T expected_val = Op::op(old_val, update);
+        Kokkos::memory_fence();
+        if (expected_val == T(0)) {
+          if (fabs(op_data(0)) > relative_error_threshold<T>) local_result += 1;
+          if (fabs(op_data(1)) > relative_error_threshold<T>) local_result += 2;
+          if (fabs(op_data(2)) > relative_error_threshold<T>) local_result += 4;
+          if (fetch_result.first != old_val) local_result += 8;
+          if (fabs(fetch_result.second) > relative_error_threshold<T>)
+            local_result += 16;
+        } else {
+          if (fabs((op_data(0) - expected_val) / expected_val) >
+              relative_error_threshold<T>)
+            local_result += 1;
+          if (fabs((op_data(1) - expected_val) / expected_val) >
+              relative_error_threshold<T>)
+            local_result += 2;
+          if (fabs((op_data(2) - expected_val) / expected_val) >
+              relative_error_threshold<T>)
+            local_result += 4;
+          if (fetch_result.first != old_val) local_result += 8;
+          if (fabs((fetch_result.second - expected_val) / expected_val) >
+              relative_error_threshold<T>)
+            local_result += 16;
+        }
+      },
+      result);
+  if ((result & 1) != 0)
+    printf("atomic_%s failed with type %s\n", Op::name(), typeid(T).name());
+  if ((result & 2) != 0)
+    printf("atomic_fetch_%s failed with type %s\n", Op::name(),
+           typeid(T).name());
+  if ((result & 4) != 0)
+    printf("atomic_%s_fetch failed with type %s\n", Op::name(),
+           typeid(T).name());
+  if ((result & 8) != 0)
+    printf("atomic_fetch_%s did not return old value with type %s\n",
+           Op::name(), typeid(T).name());
+  if ((result & 16) != 0)
+    printf("atomic_%s_fetch did not return updated value with type %s\n",
+           Op::name(), typeid(T).name());
+
+  return result == 0;
 }
 
 //---------------------------------------------------
 //--------------atomic_test_control------------------
 //---------------------------------------------------
 
-template <class T, class DeviceType>
-bool AtomicOperationsTestIntegralType(int i0, int i1, int test) {
+template <class T, class ExecSpace>
+bool AtomicOperationsTestIntegralType(int old_val_in, int update_in, int test) {
+  T old_val = static_cast<T>(old_val_in);
+  T update  = static_cast<T>(update_in);
   switch (test) {
-    case 1: return MaxAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 2: return MinAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 3: return MulAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 4: return DivAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 5: return ModAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 6: return AndAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 7: return OrAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 8: return XorAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 9: return LShiftAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 10: return RShiftAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 11: return IncAtomicTest<T, DeviceType>((T)i0);
-    case 12: return DecAtomicTest<T, DeviceType>((T)i0);
-    case 13: return LoadStoreAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 0: return atomic_op_test<AddAtomicTest, T, ExecSpace>(old_val, update);
+    case 1: return atomic_op_test<SubAtomicTest, T, ExecSpace>(old_val, update);
+    case 2: return atomic_op_test<MaxAtomicTest, T, ExecSpace>(old_val, update);
+    case 3: return atomic_op_test<MinAtomicTest, T, ExecSpace>(old_val, update);
+    case 4: return atomic_op_test<MulAtomicTest, T, ExecSpace>(old_val, update);
+    case 5:
+      return update != 0
+                 ? atomic_op_test<DivAtomicTest, T, ExecSpace>(old_val, update)
+                 : true;
+    case 6:
+      return update != 0
+                 ? atomic_op_test<ModAtomicTest, T, ExecSpace>(old_val, update)
+                 : true;
+    case 7: return atomic_op_test<AndAtomicTest, T, ExecSpace>(old_val, update);
+    case 8: return atomic_op_test<OrAtomicTest, T, ExecSpace>(old_val, update);
+    case 9: return atomic_op_test<XorAtomicTest, T, ExecSpace>(old_val, update);
+    case 10:
+      return atomic_op_test<NandAtomicTest, T, ExecSpace>(old_val, update);
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+    // FIXME_NVHPC: atomic-fetch-shift operation fails due to NVHPC OpenACC
+    // compiler bugs, which are reported to NVIDIA.
+    case 11: return true;
+    case 12: return true;
+#else
+    case 11:
+      return (std::make_signed_t<T>(update_in) >= 0 &&
+              std::make_signed_t<T>(old_val) >= 0)
+                 ? atomic_op_test<LShiftAtomicTest, T, ExecSpace>(old_val,
+                                                                  update)
+                 : true;
+    case 12:
+      return update_in >= 0 ? atomic_op_test<RShiftAtomicTest, T, ExecSpace>(
+                                  old_val, update)
+                            : true;
+#endif
+    case 13:
+      return atomic_op_test<IncAtomicTest, T, ExecSpace>(old_val, update);
+    case 14:
+      return atomic_op_test<DecAtomicTest, T, ExecSpace>(old_val, update);
+    case 15:
+      return atomic_op_test<LoadStoreAtomicTest, T, ExecSpace>(old_val, update);
   }
 
-  return 0;
+  return true;
 }
 
-template <class T, class DeviceType>
-bool AtomicOperationsTestUnsignedIntegralType(int i0, int i1, int test) {
+template <class T, class ExecSpace>
+bool AtomicOperationsTestUnsignedIntegralType(int old_val_in, int update_in,
+                                              int test) {
+  T old_val = static_cast<T>(old_val_in);
+  T update  = static_cast<T>(update_in);
   switch (test) {
-    case 1: return WrappingIncAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 2: return WrappingDecAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 1:
+      return atomic_op_test<IncModAtomicTest, T, ExecSpace>(old_val, update);
+    case 2:
+      return atomic_op_test<DecModAtomicTest, T, ExecSpace>(old_val, update);
   }
 
-  return 0;
+  return true;
 }
 
-template <class T, class DeviceType>
-bool AtomicOperationsTestNonIntegralType(int i0, int i1, int test) {
+template <class T, class ExecSpace>
+bool AtomicOperationsTestNonIntegralType(int old_val_in, int update_in,
+                                         int test) {
+  T old_val = static_cast<T>(old_val_in);
+  T update  = static_cast<T>(update_in);
   switch (test) {
-    case 1: return MaxAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 2: return MinAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 3: return MulAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 4: return DivAtomicTest<T, DeviceType>((T)i0, (T)i1);
-    case 5: return LoadStoreAtomicTest<T, DeviceType>((T)i0, (T)i1);
+    case 0: return atomic_op_test<AddAtomicTest, T, ExecSpace>(old_val, update);
+    case 1: return atomic_op_test<SubAtomicTest, T, ExecSpace>(old_val, update);
+    case 2: return atomic_op_test<MaxAtomicTest, T, ExecSpace>(old_val, update);
+    case 3: return atomic_op_test<MinAtomicTest, T, ExecSpace>(old_val, update);
+    case 4: return atomic_op_test<MulAtomicTest, T, ExecSpace>(old_val, update);
+#if defined(KOKKOS_ENABLE_OPENACC) && defined(KOKKOS_COMPILER_NVHPC)
+    // NVHPC may use different internal precisions for the device and host
+    // atomic operations. Therefore, relative errors are used to compare the
+    // host results and device results.
+    case 5:
+      return update != 0 ? atomic_op_test_rel<DivAtomicTest, T, ExecSpace>(
+                               old_val, update)
+                         : true;
+#else
+    case 5:
+      return update != 0
+                 ? atomic_op_test<DivAtomicTest, T, ExecSpace>(old_val, update)
+                 : true;
+#endif
+    case 6:
+      return atomic_op_test<LoadStoreAtomicTest, T, ExecSpace>(old_val, update);
   }
 
-  return 0;
+  return true;
 }
-
 }  // namespace TestAtomicOperations
diff --git a/core/unit_test/TestAtomicOperations_complexdouble.hpp b/core/unit_test/TestAtomicOperations_complexdouble.hpp
index 852fade58b..5708fd2ebf 100644
--- a/core/unit_test/TestAtomicOperations_complexdouble.hpp
+++ b/core/unit_test/TestAtomicOperations_complexdouble.hpp
@@ -16,6 +16,8 @@
 
 #include <TestAtomicOperations.hpp>
 
+using namespace TestAtomicOperations;
+
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_complexdouble) {
 #if defined(KOKKOS_ENABLE_SYCL) && \
@@ -23,15 +25,29 @@ TEST(TEST_CATEGORY, atomic_operations_complexdouble) {
   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 start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
+    using T   = Kokkos::complex<double>;
+    T old_val = static_cast<T>(i);
+    T update  = static_cast<T>(end - i - start);
+    ASSERT_TRUE(
+        (atomic_op_test<AddAtomicTest, T, TEST_EXECSPACE>(old_val, update)));
     ASSERT_TRUE(
-        (TestAtomicOperations::MulAtomicTest<Kokkos::complex<double>,
-                                             TEST_EXECSPACE>(start, end - i)));
+        (atomic_op_test<SubAtomicTest, T, TEST_EXECSPACE>(old_val, update)));
     ASSERT_TRUE(
-        (TestAtomicOperations::DivAtomicTest<Kokkos::complex<double>,
-                                             TEST_EXECSPACE>(start, end - i)));
+        (atomic_op_test<MulAtomicTest, T, TEST_EXECSPACE>(old_val, update)));
+
+    // FIXME_32BIT disable division test for 32bit where we have accuracy issues
+    // with division atomics still compile it though
+    if (sizeof(void*) == 8) {
+      ASSERT_TRUE((update != 0
+                       ? atomic_op_test<DivAtomicTest, T, TEST_EXECSPACE>(
+                             old_val, update)
+                       : true));
+    }
+    ASSERT_TRUE((atomic_op_test<LoadStoreAtomicTest, T, TEST_EXECSPACE>(
+        old_val, update)));
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_complexfloat.hpp b/core/unit_test/TestAtomicOperations_complexfloat.hpp
index b23e55a339..97bfeea6ad 100644
--- a/core/unit_test/TestAtomicOperations_complexfloat.hpp
+++ b/core/unit_test/TestAtomicOperations_complexfloat.hpp
@@ -16,17 +16,33 @@
 
 #include <TestAtomicOperations.hpp>
 
+using namespace TestAtomicOperations;
+
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_complexfloat) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
+    using T   = Kokkos::complex<float>;
+    T old_val = static_cast<T>(i);
+    T update  = static_cast<T>(end - i - start);
+    ASSERT_TRUE(
+        (atomic_op_test<AddAtomicTest, T, TEST_EXECSPACE>(old_val, update)));
     ASSERT_TRUE(
-        (TestAtomicOperations::MulAtomicTest<Kokkos::complex<float>,
-                                             TEST_EXECSPACE>(start, end - i)));
+        (atomic_op_test<SubAtomicTest, T, TEST_EXECSPACE>(old_val, update)));
     ASSERT_TRUE(
-        (TestAtomicOperations::DivAtomicTest<Kokkos::complex<float>,
-                                             TEST_EXECSPACE>(start, end - i)));
+        (atomic_op_test<MulAtomicTest, T, TEST_EXECSPACE>(old_val, update)));
+
+    // FIXME_32BIT disable division test for 32bit where we have accuracy issues
+    // with division atomics still compile it though
+    if (sizeof(void*) == 8) {
+      ASSERT_TRUE((update != 0
+                       ? atomic_op_test<DivAtomicTest, T, TEST_EXECSPACE>(
+                             old_val, update)
+                       : true));
+    }
+    ASSERT_TRUE((atomic_op_test<LoadStoreAtomicTest, T, TEST_EXECSPACE>(
+        old_val, update)));
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_double.hpp b/core/unit_test/TestAtomicOperations_double.hpp
index 0dea91f416..30f7e5e3bd 100644
--- a/core/unit_test/TestAtomicOperations_double.hpp
+++ b/core/unit_test/TestAtomicOperations_double.hpp
@@ -18,19 +18,16 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_double) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 double, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 double, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 double, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 double, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 double, TEST_EXECSPACE>(start, end - i, 5)));
+    for (int t = 0; t < 8; t++)
+      // FIXME_32BIT disable division test for 32bit where we have accuracy
+      // issues with division atomics still compile it though
+      if (t != 5 || sizeof(void*) == 8) {
+        ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                     double, TEST_EXECSPACE>(i, end - i + start, t)));
+      }
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_float.hpp b/core/unit_test/TestAtomicOperations_float.hpp
index 23348f20ec..73ea439808 100644
--- a/core/unit_test/TestAtomicOperations_float.hpp
+++ b/core/unit_test/TestAtomicOperations_float.hpp
@@ -18,19 +18,16 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_float) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 float, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 float, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 float, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 float, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
-                 float, TEST_EXECSPACE>(start, end - i, 5)));
+    for (int t = 0; t < 8; t++)
+      // FIXME_32BIT disable division test for 32bit where we have accuracy
+      // issues with division atomics still compile it though
+      if (t != 5 || sizeof(void*) == 8) {
+        ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestNonIntegralType<
+                     double, TEST_EXECSPACE>(i, end - i + start, t)));
+      }
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_int.hpp b/core/unit_test/TestAtomicOperations_int.hpp
index 31cddf20ba..5aeaecd7af 100644
--- a/core/unit_test/TestAtomicOperations_int.hpp
+++ b/core/unit_test/TestAtomicOperations_int.hpp
@@ -18,33 +18,12 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_int) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 5)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 6)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 7)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 8)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 9)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 11)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 12)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 int, TEST_EXECSPACE>(start, end - i, 13)));
+    for (int t = 0; t < 16; t++)
+      ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                   int, TEST_EXECSPACE>(i, end - i + start, t)));
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_longint.hpp b/core/unit_test/TestAtomicOperations_longint.hpp
index 3171e61018..b181171dd5 100644
--- a/core/unit_test/TestAtomicOperations_longint.hpp
+++ b/core/unit_test/TestAtomicOperations_longint.hpp
@@ -18,33 +18,12 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_long) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 5)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 6)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 7)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 8)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 9)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 11)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 12)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long int, TEST_EXECSPACE>(start, end - i, 13)));
+    for (int t = 0; t < 16; t++)
+      ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                   long int, TEST_EXECSPACE>(i, end - i + start, t)));
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_longlongint.hpp b/core/unit_test/TestAtomicOperations_longlongint.hpp
index f7bef416d6..aa21722f47 100644
--- a/core/unit_test/TestAtomicOperations_longlongint.hpp
+++ b/core/unit_test/TestAtomicOperations_longlongint.hpp
@@ -18,33 +18,12 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_longlong) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = -5;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 5)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 6)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 7)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 8)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 9)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 11)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 12)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 long long int, TEST_EXECSPACE>(start, end - i, 13)));
+    for (int t = 0; t < 16; t++)
+      ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                   long long int, TEST_EXECSPACE>(i, end - i + start, t)));
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_unsignedint.hpp b/core/unit_test/TestAtomicOperations_unsignedint.hpp
index f844c9062d..96acb94bb1 100644
--- a/core/unit_test/TestAtomicOperations_unsignedint.hpp
+++ b/core/unit_test/TestAtomicOperations_unsignedint.hpp
@@ -18,39 +18,18 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_unsigned) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = 0;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 5)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 6)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 7)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 8)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 9)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 11)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 12)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned int, TEST_EXECSPACE>(start, end - i, 13)));
+    for (int t = 0; t < 16; t++)
+      ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                   unsigned int, TEST_EXECSPACE>(i, end - i + start, t)));
     ASSERT_TRUE(
         (TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
-            unsigned int, TEST_EXECSPACE>(start, end - i, 1)));  // Wrapping Inc
+            unsigned int, TEST_EXECSPACE>(i, end - i, 1)));  // Wrapping Inc
     ASSERT_TRUE(
         (TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
-            unsigned int, TEST_EXECSPACE>(start, end - i, 2)));  // Wrapping Dec
+            unsigned int, TEST_EXECSPACE>(i, end - i, 2)));  // Wrapping Dec
   }
 }
 }  // namespace Test
diff --git a/core/unit_test/TestAtomicOperations_unsignedlongint.hpp b/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
index 8b6ca64e99..3482f6fe1e 100644
--- a/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
+++ b/core/unit_test/TestAtomicOperations_unsignedlongint.hpp
@@ -18,38 +18,17 @@
 
 namespace Test {
 TEST(TEST_CATEGORY, atomic_operations_unsignedlong) {
-  const int start = 1;  // Avoid zero for division.
+  const int start = 0;
   const int end   = 11;
   for (int i = start; i < end; ++i) {
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 1)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 2)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 3)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 4)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 5)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 6)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 7)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 8)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 9)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 11)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 12)));
-    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i, 13)));
+    for (int t = 0; t < 16; t++)
+      ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestIntegralType<
+                   unsigned long int, TEST_EXECSPACE>(i, end - i + start, t)));
     ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i,
+                 unsigned long int, TEST_EXECSPACE>(i, end - i,
                                                     1)));  // Wrapping Inc
     ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
-                 unsigned long int, TEST_EXECSPACE>(start, end - i,
+                 unsigned long int, TEST_EXECSPACE>(i, end - i,
                                                     2)));  // Wrapping Dec
   }
 }
diff --git a/core/unit_test/TestAtomicOperations_unsignedlonglongint.hpp b/core/unit_test/TestAtomicOperations_unsignedlonglongint.hpp
new file mode 100644
index 0000000000..cf41dedccb
--- /dev/null
+++ b/core/unit_test/TestAtomicOperations_unsignedlonglongint.hpp
@@ -0,0 +1,36 @@
+//@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 <TestAtomicOperations.hpp>
+
+namespace Test {
+TEST(TEST_CATEGORY, atomic_operations_unsignedlonglong) {
+  const int start = 0;
+  const int end   = 11;
+  for (int i = start; i < end; ++i) {
+    for (int t = 0; t < 16; t++)
+      ASSERT_TRUE(
+          (TestAtomicOperations::AtomicOperationsTestIntegralType<
+              unsigned long long int, TEST_EXECSPACE>(i, end - i + start, t)));
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
+                 unsigned long long int, TEST_EXECSPACE>(i, end - i,
+                                                         1)));  // Wrapping Inc
+    ASSERT_TRUE((TestAtomicOperations::AtomicOperationsTestUnsignedIntegralType<
+                 unsigned long long int, TEST_EXECSPACE>(i, end - i,
+                                                         2)));  // Wrapping Dec
+  }
+}
+}  // namespace Test
diff --git a/core/unit_test/TestAtomics.hpp b/core/unit_test/TestAtomics.hpp
index fd3b8facfc..5f48e8c974 100644
--- a/core/unit_test/TestAtomics.hpp
+++ b/core/unit_test/TestAtomics.hpp
@@ -498,7 +498,9 @@ TEST(TEST_CATEGORY, atomics) {
   ASSERT_TRUE((TestAtomic::Loop<float, TEST_EXECSPACE>(100, 2)));
   ASSERT_TRUE((TestAtomic::Loop<float, TEST_EXECSPACE>(100, 3)));
 
-#ifndef KOKKOS_ENABLE_OPENMPTARGET
+  // FIXME_OPENMPTARGET
+  // FIXME_OPENACC: atomic operations on composite types are not supported.
+#if !defined(KOKKOS_ENABLE_OPENMPTARGET) && !defined(KOKKOS_ENABLE_OPENACC)
   ASSERT_TRUE((TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(1, 1)));
   ASSERT_TRUE((TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(1, 2)));
   ASSERT_TRUE((TestAtomic::Loop<Kokkos::complex<float>, TEST_EXECSPACE>(1, 3)));
@@ -563,7 +565,7 @@ struct TpetraUseCase {
   };
 
   using T = int;
-  Kokkos::View<T> d_{"lbl"};
+  Kokkos::View<T, TEST_EXECSPACE> d_{"lbl"};
   KOKKOS_FUNCTION void operator()(int i) const {
     // 0, -1, 2, -3, ...
     auto v_i = static_cast<T>(i);
@@ -572,7 +574,9 @@ struct TpetraUseCase {
                        AbsMaxHelper<T>{v_i});
   }
 
-  TpetraUseCase() { Kokkos::parallel_for(10, *this); }
+  TpetraUseCase() {
+    Kokkos::parallel_for(Kokkos::RangePolicy<TEST_EXECSPACE>(0, 10), *this);
+  }
 
   void check() {
     T v;
@@ -581,12 +585,6 @@ struct TpetraUseCase {
   }
 };
 
-TEST(TEST_CATEGORY, atomics_tpetra_max_abs) {
-#ifdef KOKKOS_COMPILER_NVHPC
-  GTEST_SKIP() << "FIXME_NVHPC (?)";
-#endif
-
-  TpetraUseCase().check();
-}
+TEST(TEST_CATEGORY, atomics_tpetra_max_abs) { TpetraUseCase().check(); }
 
 }  // namespace Test
diff --git a/core/unit_test/TestBitManipulation.cpp b/core/unit_test/TestBitManipulation.cpp
index dccabed3db..50d2b3067f 100644
--- a/core/unit_test/TestBitManipulation.cpp
+++ b/core/unit_test/TestBitManipulation.cpp
@@ -500,8 +500,8 @@ constexpr X test_bit_cast(...) {
   return {};
 }
 
-// FIXME_SYCL The SYCL implementation is unconstrained
-#ifndef KOKKOS_ENABLE_SYCL
+#if !defined(KOKKOS_ENABLE_SYCL) || \
+    (defined(__INTEL_LLVM_COMPILER) && __INTEL_LLVM_COMPILER >= 20240000)
 namespace TypesNotTheSameSize {
 struct To {
   char a;
diff --git a/core/unit_test/TestBitManipulationBuiltins.hpp b/core/unit_test/TestBitManipulationBuiltins.hpp
index 9e353de9e7..fe015404f1 100644
--- a/core/unit_test/TestBitManipulationBuiltins.hpp
+++ b/core/unit_test/TestBitManipulationBuiltins.hpp
@@ -77,9 +77,9 @@ struct TestBitManipFunction {
   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]));
+      Kokkos::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]));
     }
   }
 };
@@ -549,7 +549,7 @@ struct TestBitRotateFunction {
     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(
+      Kokkos::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),
@@ -726,11 +726,10 @@ struct TestByteswapFunction {
     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);
+      Kokkos::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);
     }
   }
 };
@@ -805,35 +804,29 @@ struct TestBitCastFunction {
     using Kokkos::bit_cast;
     if (bit_cast<int>(123) != 123) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #1\n");
+      Kokkos::printf("failed check #1\n");
     }
     if (bit_cast<int>(123u) != 123) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #2\n");
+      Kokkos::printf("failed check #2\n");
     }
     if (bit_cast<int>(~0u) != ~0) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #3\n");
+      Kokkos::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");
+        Kokkos::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");
+        Kokkos::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;
 
@@ -849,11 +842,11 @@ struct TestBitCastFunction {
     }
     if (!(bit_cast<S>(arr) == arr)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #6\n");
+      Kokkos::printf("failed check #6\n");
     }
     if (!(bit_cast<S>(arr2) == arr2)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed check #7\n");
+      Kokkos::printf("failed check #7\n");
     }
   }
 };
diff --git a/core/unit_test/TestCheckedIntegerOps.hpp b/core/unit_test/TestCheckedIntegerOps.hpp
new file mode 100644
index 0000000000..2940a14711
--- /dev/null
+++ b/core/unit_test/TestCheckedIntegerOps.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
+
+#include <gtest/gtest.h>
+#include <impl/Kokkos_CheckedIntegerOps.hpp>
+#include <limits>
+
+namespace {
+
+TEST(TEST_CATEGORY, checked_integer_operations_multiply_overflow) {
+  {
+    auto result      = 1u;
+    auto is_overflow = Kokkos::Impl::multiply_overflow(1u, 2u, result);
+    EXPECT_EQ(result, 2u);
+    EXPECT_FALSE(is_overflow);
+  }
+  {
+    auto result      = 1u;
+    auto is_overflow = Kokkos::Impl::multiply_overflow(
+        std::numeric_limits<unsigned>::max(), 2u, result);
+    EXPECT_TRUE(is_overflow);
+  }
+}
+
+TEST(TEST_CATEGORY_DEATH, checked_integer_operations_multiply_overflow_abort) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  {
+    auto result = Kokkos::Impl::multiply_overflow_abort(1u, 2u);
+    EXPECT_EQ(result, 2u);
+  }
+  {
+    ASSERT_DEATH(Kokkos::Impl::multiply_overflow_abort(
+                     std::numeric_limits<unsigned>::max(), 2u),
+                 "Arithmetic overflow detected.");
+  }
+}
+
+}  // namespace
diff --git a/core/unit_test/TestComplex.hpp b/core/unit_test/TestComplex.hpp
index bcae2e1d81..ef6a21cd37 100644
--- a/core/unit_test/TestComplex.hpp
+++ b/core/unit_test/TestComplex.hpp
@@ -15,9 +15,26 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <cstdio>
 #include <sstream>
 
+// Suppress "'long double' is treated as 'double' in device code"
+#ifdef KOKKOS_COMPILER_NVCC
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diagnostic push
+#pragma nv_diag_suppress 20208
+#else
+#ifdef __CUDA_ARCH__
+#pragma diagnostic push
+#pragma diag_suppress 20208
+#endif
+#endif
+#endif
+
+namespace {
+template <typename... Ts>
+KOKKOS_FUNCTION constexpr void maybe_unused(Ts &&...) noexcept {}
+}  // namespace
+
 namespace Test {
 
 // Test construction and assignment
@@ -451,17 +468,15 @@ TEST(TEST_CATEGORY, complex_issue_3867) {
   ASSERT_FLOAT_EQ(x.real(), y.real());
   ASSERT_FLOAT_EQ(x.imag(), y.imag());
 
-#define CHECK_POW_COMPLEX_PROMOTION(ARGTYPE1, ARGTYPE2, RETURNTYPE)         \
-  static_assert(                                                            \
-      std::is_same<RETURNTYPE,                                              \
-                   decltype(Kokkos::pow(std::declval<ARGTYPE1>(),           \
-                                        std::declval<ARGTYPE2>()))>::value, \
-      "");                                                                  \
-  static_assert(                                                            \
-      std::is_same<RETURNTYPE,                                              \
-                   decltype(Kokkos::pow(std::declval<ARGTYPE2>(),           \
-                                        std::declval<ARGTYPE1>()))>::value, \
-      "");
+#define CHECK_POW_COMPLEX_PROMOTION(ARGTYPE1, ARGTYPE2, RETURNTYPE)          \
+  static_assert(                                                             \
+      std::is_same<RETURNTYPE,                                               \
+                   decltype(Kokkos::pow(std::declval<ARGTYPE1>(),            \
+                                        std::declval<ARGTYPE2>()))>::value); \
+  static_assert(                                                             \
+      std::is_same<RETURNTYPE,                                               \
+                   decltype(Kokkos::pow(std::declval<ARGTYPE2>(),            \
+                                        std::declval<ARGTYPE1>()))>::value);
 
   CHECK_POW_COMPLEX_PROMOTION(Kokkos::complex<long double>, long double,
                               Kokkos::complex<long double>);
@@ -534,4 +549,151 @@ TEST(TEST_CATEGORY, complex_operations_arithmetic_types_overloads) {
                               Kokkos::complex<long double>>::value));
 }
 
+template <class ExecSpace>
+struct TestComplexStructuredBindings {
+  using exec_space       = ExecSpace;
+  using value_type       = double;
+  using complex_type     = Kokkos::complex<double>;
+  using device_view_type = Kokkos::View<complex_type *, exec_space>;
+  using host_view_type   = typename device_view_type::HostMirror;
+
+  device_view_type d_results;
+  host_view_type h_results;
+
+  // tuple_size
+  static_assert(std::is_same_v<std::tuple_size<complex_type>::type,
+                               std::integral_constant<size_t, 2>>);
+
+  // tuple_element
+  static_assert(
+      std::is_same_v<std::tuple_element_t<0, complex_type>, value_type>);
+  static_assert(
+      std::is_same_v<std::tuple_element_t<1, complex_type>, value_type>);
+
+  static void testgetreturnreferencetypes() {
+    complex_type m;
+    const complex_type c;
+
+    // get lvalue
+    complex_type &ml = m;
+    static_assert(std::is_same_v<decltype(Kokkos::get<0>(ml)), value_type &>);
+    static_assert(std::is_same_v<decltype(Kokkos::get<1>(ml)), value_type &>);
+
+    // get rvalue
+    complex_type &&mr = std::move(m);
+    static_assert(
+        std::is_same_v<decltype(Kokkos::get<0>(std::move(mr))), value_type &&>);
+    static_assert(
+        std::is_same_v<decltype(Kokkos::get<1>(std::move(mr))), value_type &&>);
+
+    // get const lvalue
+    const complex_type &cl = c;
+    static_assert(
+        std::is_same_v<decltype(Kokkos::get<0>(cl)), value_type const &>);
+    static_assert(
+        std::is_same_v<decltype(Kokkos::get<1>(cl)), value_type const &>);
+
+    // get const rvalue
+    complex_type const &&cr = std::move(c);
+    static_assert(std::is_same_v<decltype(Kokkos::get<0>(std::move(cr))),
+                                 value_type const &&>);
+    static_assert(std::is_same_v<decltype(Kokkos::get<1>(std::move(cr))),
+                                 value_type const &&>);
+
+    maybe_unused(m, c, ml, mr, cl, cr);
+  }
+
+  void testit() {
+    testgetreturnreferencetypes();
+
+    d_results = device_view_type("TestComplexStructuredBindings", 6);
+    h_results = Kokkos::create_mirror_view(d_results);
+
+    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0, 1), *this);
+    Kokkos::fence();
+    Kokkos::deep_copy(h_results, d_results);
+
+    // get lvalue
+    ASSERT_FLOAT_EQ(h_results[0].real(), 2.);
+    ASSERT_FLOAT_EQ(h_results[0].imag(), 3.);
+
+    // get rvalue
+    ASSERT_FLOAT_EQ(h_results[1].real(), 2.);
+    ASSERT_FLOAT_EQ(h_results[1].imag(), 3.);
+
+    // get const lvalue
+    ASSERT_FLOAT_EQ(h_results[2].real(), 5.);
+    ASSERT_FLOAT_EQ(h_results[2].imag(), 7.);
+
+    // get const rvalue
+    ASSERT_FLOAT_EQ(h_results[3].real(), 5.);
+    ASSERT_FLOAT_EQ(h_results[3].imag(), 7.);
+
+    // swap real and imaginary
+    ASSERT_FLOAT_EQ(h_results[4].real(), 11.);
+    ASSERT_FLOAT_EQ(h_results[4].imag(), 13.);
+    ASSERT_FLOAT_EQ(h_results[5].real(), 13.);
+    ASSERT_FLOAT_EQ(h_results[5].imag(), 11.);
+  }
+
+  KOKKOS_FUNCTION
+  void operator()(int) const {
+    complex_type m(2., 3.);
+    const complex_type c(5., 7.);
+
+    // get lvalue
+    {
+      complex_type &ml = m;
+      auto &[mlr, mli] = ml;
+      d_results[0]     = complex_type(mlr, mli);
+    }
+
+    // get rvalue
+    {
+      complex_type &&mr = std::move(m);
+      auto &&[mrr, mri] = std::move(mr);
+      d_results[1]      = complex_type(mrr, mri);
+    }
+
+    // get const lvalue
+    {
+      const complex_type &cl = c;
+      auto &[clr, cli]       = cl;
+      d_results[2]           = complex_type(clr, cli);
+    }
+
+    // get const rvalue
+    {
+      complex_type const &&cr = std::move(c);
+      auto &&[crr, cri]       = std::move(cr);
+      d_results[3]            = complex_type(crr, cri);
+    }
+
+    // swap real and imaginary
+    {
+      complex_type z(11., 13.);
+      d_results[4] = z;
+
+      auto &[zr, zi] = z;
+      Kokkos::kokkos_swap(zr, zi);
+      d_results[5] = z;
+    }
+  }
+};
+
+TEST(TEST_CATEGORY, complex_structured_bindings) {
+  TestComplexStructuredBindings<TEST_EXECSPACE> test;
+  test.testit();
+}
+
 }  // namespace Test
+
+#ifdef KOKKOS_COMPILER_NVCC
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diagnostic pop
+#else
+#ifdef __CUDA_ARCH__
+#pragma diagnostic pop
+#endif
+#endif
+#endif
diff --git a/core/unit_test/TestConcepts.hpp b/core/unit_test/TestConcepts.hpp
index 476a884832..b85867bf63 100644
--- a/core/unit_test/TestConcepts.hpp
+++ b/core/unit_test/TestConcepts.hpp
@@ -22,42 +22,42 @@ using ExecutionSpace = TEST_EXECSPACE;
 using MemorySpace    = typename ExecutionSpace::memory_space;
 using DeviceType     = typename ExecutionSpace::device_type;
 
-static_assert(Kokkos::is_execution_space<ExecutionSpace>{}, "");
-static_assert(Kokkos::is_execution_space<ExecutionSpace const>{}, "");
-static_assert(!Kokkos::is_execution_space<ExecutionSpace &>{}, "");
-static_assert(!Kokkos::is_execution_space<ExecutionSpace const &>{}, "");
-
-static_assert(Kokkos::is_memory_space<MemorySpace>{}, "");
-static_assert(Kokkos::is_memory_space<MemorySpace const>{}, "");
-static_assert(!Kokkos::is_memory_space<MemorySpace &>{}, "");
-static_assert(!Kokkos::is_memory_space<MemorySpace const &>{}, "");
-
-static_assert(Kokkos::is_device<DeviceType>{}, "");
-static_assert(Kokkos::is_device<DeviceType const>{}, "");
-static_assert(!Kokkos::is_device<DeviceType &>{}, "");
-static_assert(!Kokkos::is_device<DeviceType const &>{}, "");
-
-static_assert(!Kokkos::is_device<ExecutionSpace>{}, "");
-static_assert(!Kokkos::is_device<MemorySpace>{}, "");
-
-static_assert(Kokkos::is_space<ExecutionSpace>{}, "");
-static_assert(Kokkos::is_space<MemorySpace>{}, "");
-static_assert(Kokkos::is_space<DeviceType>{}, "");
-static_assert(Kokkos::is_space<ExecutionSpace const>{}, "");
-static_assert(Kokkos::is_space<MemorySpace const>{}, "");
-static_assert(Kokkos::is_space<DeviceType const>{}, "");
-static_assert(!Kokkos::is_space<ExecutionSpace &>{}, "");
-static_assert(!Kokkos::is_space<MemorySpace &>{}, "");
-static_assert(!Kokkos::is_space<DeviceType &>{}, "");
-
-static_assert(Kokkos::is_execution_space_v<ExecutionSpace>, "");
-static_assert(!Kokkos::is_execution_space_v<ExecutionSpace &>, "");
+static_assert(Kokkos::is_execution_space<ExecutionSpace>{});
+static_assert(Kokkos::is_execution_space<ExecutionSpace const>{});
+static_assert(!Kokkos::is_execution_space<ExecutionSpace &>{});
+static_assert(!Kokkos::is_execution_space<ExecutionSpace const &>{});
+
+static_assert(Kokkos::is_memory_space<MemorySpace>{});
+static_assert(Kokkos::is_memory_space<MemorySpace const>{});
+static_assert(!Kokkos::is_memory_space<MemorySpace &>{});
+static_assert(!Kokkos::is_memory_space<MemorySpace const &>{});
+
+static_assert(Kokkos::is_device<DeviceType>{});
+static_assert(Kokkos::is_device<DeviceType const>{});
+static_assert(!Kokkos::is_device<DeviceType &>{});
+static_assert(!Kokkos::is_device<DeviceType const &>{});
+
+static_assert(!Kokkos::is_device<ExecutionSpace>{});
+static_assert(!Kokkos::is_device<MemorySpace>{});
+
+static_assert(Kokkos::is_space<ExecutionSpace>{});
+static_assert(Kokkos::is_space<MemorySpace>{});
+static_assert(Kokkos::is_space<DeviceType>{});
+static_assert(Kokkos::is_space<ExecutionSpace const>{});
+static_assert(Kokkos::is_space<MemorySpace const>{});
+static_assert(Kokkos::is_space<DeviceType const>{});
+static_assert(!Kokkos::is_space<ExecutionSpace &>{});
+static_assert(!Kokkos::is_space<MemorySpace &>{});
+static_assert(!Kokkos::is_space<DeviceType &>{});
+
+static_assert(Kokkos::is_execution_space_v<ExecutionSpace>);
+static_assert(!Kokkos::is_execution_space_v<ExecutionSpace &>);
 
 static_assert(
-    std::is_same<float, Kokkos::Impl::remove_cvref_t<float const &>>{}, "");
-static_assert(std::is_same<int, Kokkos::Impl::remove_cvref_t<int &>>{}, "");
-static_assert(std::is_same<int, Kokkos::Impl::remove_cvref_t<int const>>{}, "");
-static_assert(std::is_same<float, Kokkos::Impl::remove_cvref_t<float>>{}, "");
+    std::is_same<float, Kokkos::Impl::remove_cvref_t<float const &>>{});
+static_assert(std::is_same<int, Kokkos::Impl::remove_cvref_t<int &>>{});
+static_assert(std::is_same<int, Kokkos::Impl::remove_cvref_t<int const>>{});
+static_assert(std::is_same<float, Kokkos::Impl::remove_cvref_t<float>>{});
 
 /*-------------------------------------------------
   begin test for team_handle concept
diff --git a/core/unit_test/TestDefaultDeviceTypeInit.hpp b/core/unit_test/TestDefaultDeviceTypeInit.hpp
deleted file mode 100644
index 929c91db4e..0000000000
--- a/core/unit_test/TestDefaultDeviceTypeInit.hpp
+++ /dev/null
@@ -1,491 +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 <gtest/gtest.h>
-
-#include <Kokkos_Core.hpp>
-
-#ifdef KOKKOS_ENABLE_OPENMP
-#include <omp.h>
-#endif
-#include <set>
-#if !defined(KOKKOS_ENABLE_CUDA) || defined(__CUDACC__)
-
-namespace Test {
-
-namespace Impl {
-
-std::set<char*> delete_these;
-void cleanup_memory() {
-  for (auto x : delete_these) {
-    delete[] x;
-  }
-}
-
-char** init_kokkos_args(bool do_threads, bool do_numa, bool do_device,
-                        bool do_other, bool do_tune, int& nargs,
-                        Kokkos::InitArguments& init_args) {
-  nargs = (do_threads ? 1 : 0) + (do_numa ? 1 : 0) + (do_device ? 1 : 0) +
-          (do_other ? 4 : 0) + (do_tune ? 1 : 0);
-
-  char** args_kokkos      = new char*[nargs];
-  const int max_args_size = 45;
-  for (int i = 0; i < nargs; i++) {
-    args_kokkos[i] = new char[max_args_size];
-    delete_these.insert(args_kokkos[i]);
-  }
-
-  int threads_idx = do_other ? 1 : 0;
-  int numa_idx    = (do_other ? 3 : 0) + (do_threads ? 1 : 0);
-  int device_idx =
-      (do_other ? 3 : 0) + (do_threads ? 1 : 0) + (do_numa ? 1 : 0);
-  int tune_idx = (do_other ? 4 : 0) + (do_threads ? 1 : 0) + (do_numa ? 1 : 0) +
-                 (do_device ? 1 : 0);
-
-  if (do_threads) {
-    int nthreads = 3;
-
-#ifdef KOKKOS_ENABLE_OPENMP
-    if (omp_get_max_threads() < nthreads) {
-      nthreads = omp_get_max_threads();
-    }
-#elif defined(KOKKOS_ENABLE_HPX)
-    const int concurrency = std::thread::hardware_concurrency();
-    if (concurrency < nthreads) {
-      nthreads = concurrency;
-    }
-#endif
-
-    if (Kokkos::hwloc::available()) {
-      if (Kokkos::hwloc::get_available_threads_per_core() <
-          static_cast<unsigned>(nthreads))
-        nthreads = Kokkos::hwloc::get_available_threads_per_core() *
-                   Kokkos::hwloc::get_available_numa_count();
-    }
-
-#ifdef KOKKOS_ENABLE_SERIAL
-    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
-        std::is_same<Kokkos::Serial,
-                     Kokkos::DefaultHostExecutionSpace>::value) {
-      nthreads = 1;
-    }
-#endif
-
-    init_args.num_threads = nthreads;
-    snprintf(args_kokkos[threads_idx], max_args_size, "--threads=%i", nthreads);
-  }
-
-  if (do_numa) {
-    int numa = 1;
-    if (Kokkos::hwloc::available()) {
-      numa = Kokkos::hwloc::get_available_numa_count();
-    }
-
-#ifdef KOKKOS_ENABLE_SERIAL
-    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
-        std::is_same<Kokkos::Serial,
-                     Kokkos::DefaultHostExecutionSpace>::value) {
-      numa = 1;
-    }
-#endif
-
-    init_args.num_numa = numa;
-    snprintf(args_kokkos[numa_idx], max_args_size, "--numa=%i", numa);
-  }
-
-  if (do_device) {
-    init_args.device_id = 0;
-    snprintf(args_kokkos[device_idx], max_args_size, "--device-id=%i", 0);
-  }
-
-  if (do_other) {
-    snprintf(args_kokkos[0], max_args_size, "--dummyarg=1");
-    snprintf(args_kokkos[threads_idx + (do_threads ? 1 : 0)], max_args_size,
-             "--dummy2arg");
-    snprintf(args_kokkos[threads_idx + (do_threads ? 1 : 0) + 1], max_args_size,
-             "dummy3arg");
-    snprintf(args_kokkos[device_idx + (do_device ? 1 : 0)], max_args_size,
-             "dummy4arg=1");
-  }
-
-  if (do_tune) {
-    init_args.tune_internals = true;
-    snprintf(args_kokkos[tune_idx], max_args_size, "--kokkos-tune-internals");
-  }
-
-  return args_kokkos;
-}
-
-Kokkos::InitArguments init_initstruct(bool do_threads, bool do_numa,
-                                      bool do_device, bool do_tune) {
-  Kokkos::InitArguments args;
-
-  if (do_threads) {
-    int nthreads = 3;
-
-#ifdef KOKKOS_ENABLE_OPENMP
-    if (omp_get_max_threads() < nthreads) {
-      nthreads = omp_get_max_threads();
-    }
-#elif defined(KOKKOS_ENABLE_HPX)
-    const int concurrency = std::thread::hardware_concurrency();
-    if (concurrency < nthreads) {
-      nthreads = concurrency;
-    }
-#endif
-
-    if (Kokkos::hwloc::available()) {
-      if (Kokkos::hwloc::get_available_threads_per_core() <
-          static_cast<unsigned>(nthreads)) {
-        nthreads = Kokkos::hwloc::get_available_threads_per_core() *
-                   Kokkos::hwloc::get_available_numa_count();
-      }
-    }
-
-#ifdef KOKKOS_ENABLE_SERIAL
-    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
-        std::is_same<Kokkos::Serial,
-                     Kokkos::DefaultHostExecutionSpace>::value) {
-      nthreads = 1;
-    }
-#endif
-
-    args.num_threads = nthreads;
-  }
-
-  if (do_numa) {
-    int numa = 1;
-    if (Kokkos::hwloc::available()) {
-      numa = Kokkos::hwloc::get_available_numa_count();
-    }
-
-#ifdef KOKKOS_ENABLE_SERIAL
-    if (std::is_same<Kokkos::Serial, Kokkos::DefaultExecutionSpace>::value ||
-        std::is_same<Kokkos::Serial,
-                     Kokkos::DefaultHostExecutionSpace>::value) {
-      numa = 1;
-    }
-#endif
-
-    args.num_numa = numa;
-  }
-
-  if (do_device) {
-    args.device_id = 0;
-  }
-
-  if (do_tune) {
-    args.tune_internals = true;
-  }
-
-  return args;
-}
-
-void check_correct_initialization(const Kokkos::InitArguments& argstruct) {
-  ASSERT_EQ(Kokkos::DefaultExecutionSpace::impl_is_initialized(), 1);
-  ASSERT_EQ(Kokkos::HostSpace::execution_space::impl_is_initialized(), 1);
-
-  // Figure out the number of threads the HostSpace ExecutionSpace should have
-  // initialized to.
-  int expected_nthreads = argstruct.num_threads;
-
-#ifdef KOKKOS_ENABLE_OPENMP
-  if (std::is_same<Kokkos::HostSpace::execution_space, Kokkos::OpenMP>::value) {
-    // use openmp default num threads
-    if (expected_nthreads < 0 ||
-        (expected_nthreads == 0 && !Kokkos::hwloc::available())) {
-      expected_nthreads = omp_get_max_threads();
-    }
-    // use hwloc if available
-    else if (expected_nthreads == 0 && Kokkos::hwloc::available()) {
-      expected_nthreads = Kokkos::hwloc::get_available_numa_count() *
-                          Kokkos::hwloc::get_available_cores_per_numa() *
-                          Kokkos::hwloc::get_available_threads_per_core();
-    }
-  }
-#endif
-
-  if (expected_nthreads < 1) {
-    if (Kokkos::hwloc::available()) {
-      expected_nthreads = Kokkos::hwloc::get_available_numa_count() *
-                          Kokkos::hwloc::get_available_cores_per_numa() *
-                          Kokkos::hwloc::get_available_threads_per_core();
-    } else {
-      expected_nthreads = 1;
-    }
-
-#ifdef KOKKOS_ENABLE_SERIAL
-    if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Serial>::value ||
-        std::is_same<Kokkos::DefaultHostExecutionSpace,
-                     Kokkos::Serial>::value) {
-      expected_nthreads = 1;
-    }
-#endif
-
-#ifdef KOKKOS_ENABLE_HPX
-    // HPX uses all cores on machine by default. Skip this test.
-    if (std::is_same<Kokkos::DefaultExecutionSpace,
-                     Kokkos::Experimental::HPX>::value ||
-        std::is_same<Kokkos::DefaultHostExecutionSpace,
-                     Kokkos::Experimental::HPX>::value) {
-      return;
-    }
-#endif
-  }
-
-  int expected_numa = argstruct.num_numa;
-
-  if (expected_numa < 1) {
-    if (Kokkos::hwloc::available()) {
-      expected_numa = Kokkos::hwloc::get_available_numa_count();
-    } else {
-      expected_numa = 1;
-    }
-
-#ifdef KOKKOS_ENABLE_SERIAL
-    if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Serial>::value ||
-        std::is_same<Kokkos::DefaultHostExecutionSpace, Kokkos::Serial>::value)
-      expected_numa = 1;
-#endif
-  }
-
-  ASSERT_EQ(Kokkos::HostSpace::execution_space().impl_thread_pool_size(),
-            expected_nthreads);
-
-#ifdef KOKKOS_ENABLE_CUDA
-  if (std::is_same<Kokkos::DefaultExecutionSpace, Kokkos::Cuda>::value) {
-    int device;
-    cudaGetDevice(&device);
-
-    int expected_device = argstruct.device_id;
-    if (argstruct.device_id < 0) {
-      expected_device = Kokkos::Cuda().cuda_device();
-    }
-
-    ASSERT_EQ(expected_device, device);
-  }
-#endif
-  ASSERT_EQ(argstruct.tune_internals, Kokkos::tune_internals());
-}
-
-// TODO: Add check whether correct number of threads are actually started.
-void test_no_arguments() {
-  Kokkos::initialize();
-  check_correct_initialization(Kokkos::InitArguments());
-  Kokkos::finalize();
-}
-
-void test_commandline_args(int nargs, char** args,
-                           const Kokkos::InitArguments& argstruct) {
-  Kokkos::initialize(nargs, args);
-  check_correct_initialization(argstruct);
-  Kokkos::finalize();
-}
-
-void test_initstruct_args(const Kokkos::InitArguments& args) {
-  Kokkos::initialize(args);
-  check_correct_initialization(args);
-  Kokkos::finalize();
-}
-
-}  // namespace Impl
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_01
-TEST(defaultdevicetypeinit, no_args) { Impl::test_no_arguments(); }
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_02
-TEST(defaultdevicetypeinit, commandline_args_empty) {
-  Kokkos::InitArguments argstruct;
-  int nargs   = 0;
-  char** args = Impl::init_kokkos_args(false, false, false, false, false, nargs,
-                                       argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_03
-TEST(defaultdevicetypeinit, commandline_args_other) {
-  Kokkos::InitArguments argstruct;
-  int nargs   = 0;
-  char** args = Impl::init_kokkos_args(false, false, false, true, false, nargs,
-                                       argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_04
-TEST(defaultdevicetypeinit, commandline_args_nthreads) {
-  Kokkos::InitArguments argstruct;
-  int nargs   = 0;
-  char** args = Impl::init_kokkos_args(true, false, false, false, false, nargs,
-                                       argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_05
-TEST(defaultdevicetypeinit, commandline_args_nthreads_numa) {
-  Kokkos::InitArguments argstruct;
-  int nargs = 0;
-  char** args =
-      Impl::init_kokkos_args(true, true, false, false, false, nargs, argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_06
-TEST(defaultdevicetypeinit, commandline_args_nthreads_numa_device) {
-  Kokkos::InitArguments argstruct;
-  int nargs = 0;
-  char** args =
-      Impl::init_kokkos_args(true, true, true, false, false, nargs, argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_07
-TEST(defaultdevicetypeinit, commandline_args_nthreads_device) {
-  Kokkos::InitArguments argstruct;
-  int nargs = 0;
-  char** args =
-      Impl::init_kokkos_args(true, false, true, false, false, nargs, argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_08
-TEST(defaultdevicetypeinit, commandline_args_numa_device) {
-  Kokkos::InitArguments argstruct;
-  int nargs = 0;
-  char** args =
-      Impl::init_kokkos_args(false, true, true, false, false, nargs, argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_09
-TEST(defaultdevicetypeinit, commandline_args_device) {
-  Kokkos::InitArguments argstruct;
-  int nargs   = 0;
-  char** args = Impl::init_kokkos_args(false, false, true, false, false, nargs,
-                                       argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_10
-TEST(defaultdevicetypeinit, commandline_args_nthreads_numa_device_other) {
-  Kokkos::InitArguments argstruct;
-  int nargs = 0;
-  char** args =
-      Impl::init_kokkos_args(true, true, true, true, false, nargs, argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_11
-TEST(defaultdevicetypeinit, commandline_args_nthreads_numa_device_other_tune) {
-  Kokkos::InitArguments argstruct;
-  int nargs = 0;
-  char** args =
-      Impl::init_kokkos_args(true, true, true, true, true, nargs, argstruct);
-  Impl::test_commandline_args(nargs, args, argstruct);
-  Impl::cleanup_memory();
-  delete[] args;
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_12
-TEST(defaultdevicetypeinit, initstruct_default) {
-  Kokkos::InitArguments args;
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_13
-TEST(defaultdevicetypeinit, initstruct_nthreads) {
-  Kokkos::InitArguments args = Impl::init_initstruct(true, false, false, false);
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_14
-TEST(defaultdevicetypeinit, initstruct_nthreads_numa) {
-  Kokkos::InitArguments args = Impl::init_initstruct(true, true, false, false);
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_15
-TEST(defaultdevicetypeinit, initstruct_device) {
-  Kokkos::InitArguments args = Impl::init_initstruct(false, false, true, false);
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_16
-TEST(defaultdevicetypeinit, initstruct_nthreads_device) {
-  Kokkos::InitArguments args = Impl::init_initstruct(true, false, true, false);
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_17
-TEST(defaultdevicetypeinit, initstruct_nthreads_numa_device) {
-  Kokkos::InitArguments args = Impl::init_initstruct(true, true, true, false);
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-#ifdef KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_18
-TEST(defaultdevicetypeinit, initstruct_nthreads_numa_device_tune) {
-  Kokkos::InitArguments args = Impl::init_initstruct(true, true, true, true);
-  Impl::test_initstruct_args(args);
-}
-#endif
-
-}  // namespace Test
-
-#endif
diff --git a/core/unit_test/TestDeviceAndThreads.py b/core/unit_test/TestDeviceAndThreads.py
index 1d3ff8eea7..63d26ad41a 100644
--- a/core/unit_test/TestDeviceAndThreads.py
+++ b/core/unit_test/TestDeviceAndThreads.py
@@ -17,6 +17,8 @@
 
 import unittest
 import subprocess
+import platform
+import os
 
 PREFIX = "$<TARGET_FILE_DIR:Kokkos_CoreUnitTest_DeviceAndThreads>"
 EXECUTABLE = "$<TARGET_FILE_NAME:Kokkos_CoreUnitTest_DeviceAndThreads>"
@@ -30,7 +32,22 @@ def GetFlag(flag, *extra_args):
     return int(p.stdout)
 
 def GetNumThreads(max_threads):
-    for x in [1, 2, 3, 5, 7]:
+    args = []
+    name = platform.system()
+    if name == 'Darwin':
+        args = ['sysctl', '-n', 'hw.physicalcpu_max']
+    elif name == 'Linux':
+        args = ['nproc', '--all']
+    else:
+        args = ['wmic', 'cpu', 'get', 'NumberOfCores']
+
+    result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    output = result.stdout.decode('utf-8')
+    phys_cores_count = int(output)
+    looplist = [1] + [i*phys_cores_count for i in [1,2,3,4,5,6,7]] \
+        if GetFlag("hwloc_enabled") else [1,2,3,4,5]
+
+    for x in looplist:
         if x >= max_threads:
             break
         yield x
@@ -48,13 +65,25 @@ def test_num_threads(self):
                     "num_threads",
                     "--kokkos-num-threads={}".format(num_threads)))
 
+    def test_num_devices(self):
+        if "KOKKOS_VISIBLE_DEVICES" in os.environ:
+            self.skipTest("KOKKOS_VISIBLE_DEVICES environment variable is set")
+        num_devices = GetFlag("num_devices")
+        self.assertNotEqual(num_devices, 0)
+        if num_devices == -1:
+            self.skipTest("no device backend enabled")
+        self.assertGreaterEqual(num_devices, 1)
+
     def test_device_id(self):
-        device_count = GetFlag("device_count")
-        if device_count == 0:
-            self.skipTest("no device detected")
+        if "KOKKOS_VISIBLE_DEVICES" in os.environ:
+            self.skipTest("KOKKOS_VISIBLE_DEVICES environment variable is set")
+        num_devices = GetFlag("num_devices")
+        if num_devices == -1:
+            self.assertEqual(-1, GetFlag("device_id"))
+            self.skipTest("no device backend enabled")
         # by default use the first GPU available for execution
         self.assertEqual(0, GetFlag("device_id"))
-        for device_id in range(device_count):
+        for device_id in range(num_devices):
             self.assertEqual(
                 device_id,
                 GetFlag(
diff --git a/core/unit_test/TestExecSpacePartitioning.hpp b/core/unit_test/TestExecSpacePartitioning.hpp
index 1a70b7b267..f8b570ab64 100644
--- a/core/unit_test/TestExecSpacePartitioning.hpp
+++ b/core/unit_test/TestExecSpacePartitioning.hpp
@@ -29,30 +29,46 @@ struct SumFunctor {
 };
 
 template <class ExecSpace>
-void check_distinctive(ExecSpace, ExecSpace) {}
+void check_space_member_for_policies(const ExecSpace& exec) {
+  Kokkos::RangePolicy<ExecSpace> range_policy(exec, 0, 1);
+  ASSERT_EQ(range_policy.space(), exec);
+  Kokkos::MDRangePolicy<ExecSpace, Kokkos::Rank<2>> mdrange_policy(exec, {0, 0},
+                                                                   {1, 1});
+  ASSERT_EQ(mdrange_policy.space(), exec);
+  Kokkos::TeamPolicy<ExecSpace> team_policy(exec, 1, Kokkos::AUTO);
+  ASSERT_EQ(team_policy.space(), exec);
+}
 
+template <class ExecSpace>
+void check_distinctive([[maybe_unused]] ExecSpace exec1,
+                       [[maybe_unused]] ExecSpace exec2) {
+#ifdef KOKKOS_ENABLE_SERIAL
+  if constexpr (std::is_same_v<ExecSpace, Kokkos::Serial>) {
+    ASSERT_NE(exec1, exec2);
+  }
+#endif
+#ifdef KOKKOS_ENABLE_OPENMP
+  if constexpr (std::is_same_v<ExecSpace, Kokkos::OpenMP>) {
+    ASSERT_NE(exec1, exec2);
+  }
+#endif
 #ifdef KOKKOS_ENABLE_CUDA
-void check_distinctive(Kokkos::Cuda exec1, Kokkos::Cuda exec2) {
-  ASSERT_NE(exec1.cuda_stream(), exec2.cuda_stream());
-}
+  if constexpr (std::is_same_v<ExecSpace, Kokkos::Cuda>) {
+    ASSERT_NE(exec1.cuda_stream(), exec2.cuda_stream());
+  }
 #endif
 #ifdef KOKKOS_ENABLE_HIP
-void check_distinctive(Kokkos::HIP exec1, Kokkos::HIP exec2) {
-  ASSERT_NE(exec1.hip_stream(), exec2.hip_stream());
-}
+  if constexpr (std::is_same_v<ExecSpace, Kokkos::HIP>) {
+    ASSERT_NE(exec1.hip_stream(), exec2.hip_stream());
+  }
 #endif
 #ifdef KOKKOS_ENABLE_SYCL
-void check_distinctive(Kokkos::Experimental::SYCL exec1,
-                       Kokkos::Experimental::SYCL exec2) {
-  ASSERT_NE(*exec1.impl_internal_space_instance()->m_queue,
-            *exec2.impl_internal_space_instance()->m_queue);
-}
+  if constexpr (std::is_same_v<ExecSpace, Kokkos::Experimental::SYCL>) {
+    ASSERT_NE(*exec1.impl_internal_space_instance()->m_queue,
+              *exec2.impl_internal_space_instance()->m_queue);
+  }
 #endif
-#ifdef KOKKOS_ENABLE_OPENMP
-void check_distinctive(Kokkos::OpenMP exec1, Kokkos::OpenMP exec2) {
-  ASSERT_NE(exec1, exec2);
 }
-#endif
 }  // namespace
 
 #ifdef KOKKOS_ENABLE_OPENMP
@@ -84,6 +100,9 @@ void run_threaded_test(const Lambda1 l1, const Lambda2 l2) {
 
 void test_partitioning(std::vector<TEST_EXECSPACE>& instances) {
   check_distinctive(instances[0], instances[1]);
+  check_space_member_for_policies(instances[0]);
+  check_space_member_for_policies(instances[1]);
+
   int sum1, sum2;
   int N = 3910;
   run_threaded_test(
@@ -99,28 +118,6 @@ void test_partitioning(std::vector<TEST_EXECSPACE>& instances) {
       });
   ASSERT_EQ(sum1, sum2);
   ASSERT_EQ(sum1, N * (N - 1) / 2);
-
-#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP) || \
-    defined(KOKKOS_ENABLE_SYCL) || defined(KOKKOS_ENABLE_OPENMP)
-  // Eliminate unused function warning
-  // (i.e. when compiling for Serial and CUDA, during Serial compilation the
-  // Cuda overload is unused ...)
-  if (sum1 != sum2) {
-#ifdef KOKKOS_ENABLE_CUDA
-    check_distinctive(Kokkos::Cuda(), Kokkos::Cuda());
-#endif
-#ifdef KOKKOS_ENABLE_HIP
-    check_distinctive(Kokkos::HIP(), Kokkos::HIP());
-#endif
-#ifdef KOKKOS_ENABLE_SYCL
-    check_distinctive(Kokkos::Experimental::SYCL(),
-                      Kokkos::Experimental::SYCL());
-#endif
-#ifdef KOKKOS_ENABLE_OPENMP
-    check_distinctive(Kokkos::OpenMP(), Kokkos::OpenMP());
-#endif
-  }
-#endif
 }
 
 TEST(TEST_CATEGORY, partitioning_by_args) {
diff --git a/core/unit_test/TestExecSpaceThreadSafety.hpp b/core/unit_test/TestExecSpaceThreadSafety.hpp
new file mode 100644
index 0000000000..a83355c51f
--- /dev/null
+++ b/core/unit_test/TestExecSpaceThreadSafety.hpp
@@ -0,0 +1,327 @@
+//@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 <thread>
+
+namespace {
+
+#ifdef KOKKOS_ENABLE_OPENMP
+template <class Lambda1, class Lambda2>
+void run_threaded_test(const Lambda1 l1, const Lambda2 l2) {
+#pragma omp parallel num_threads(2)
+  {
+    if (omp_get_thread_num() == 0) l1();
+    if (omp_get_thread_num() == 1) l2();
+  }
+}
+// We cannot run the multithreaded test when threads or HPX is enabled because
+// we cannot launch a thread from inside another thread
+#elif !defined(KOKKOS_ENABLE_THREADS) && !defined(KOKKOS_ENABLE_HPX)
+template <class Lambda1, class Lambda2>
+void run_threaded_test(const Lambda1 l1, const Lambda2 l2) {
+  std::thread t1(l1);
+  std::thread t2(l2);
+  t1.join();
+  t2.join();
+}
+#else
+template <class Lambda1, class Lambda2>
+void run_threaded_test(const Lambda1 l1, const Lambda2 l2) {
+  l1();
+  l2();
+}
+#endif
+
+// The idea for all of these tests is to access a View from kernels submitted by
+// two different threads to the same execution space instance. If the kernels
+// are executed concurrently, we expect to count too many increments.
+void run_exec_space_thread_safety_range() {
+  constexpr int N = 10000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(exec, 0, 1), KOKKOS_LAMBDA(int) {
+            Kokkos::atomic_store(view.data(), 0);
+            for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+            if (Kokkos::atomic_load(view.data()) != N)
+              Kokkos::atomic_store(error.data(), 1);
+          });
+    }
+  };
+
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_range) {
+#ifdef KOKKOS_ENABLE_OPENACC  // FIXME_OPENACC
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenACC>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenACC";
+#endif
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail for OpenMPTarget";
+#endif
+  run_exec_space_thread_safety_range();
+}
+
+void run_exec_space_thread_safety_mdrange() {
+  constexpr int N = 1000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_for(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(exec, {0, 0},
+                                                                 {1, 1}),
+          KOKKOS_LAMBDA(int, int) {
+            Kokkos::atomic_store(view.data(), 0);
+            for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+            if (Kokkos::atomic_load(view.data()) != N)
+              Kokkos::atomic_store(error.data(), 1);
+          });
+    }
+  };
+
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_mdrange) {
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail for OpenMPTarget";
+#endif
+  run_exec_space_thread_safety_mdrange();
+}
+
+void run_exec_space_thread_safety_team_policy() {
+  constexpr int N = 1000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_for(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(exec, 1, 1, 1),
+          KOKKOS_LAMBDA(const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type
+                            &team_member) {
+            Kokkos::single(Kokkos::PerTeam(team_member), [=]() {
+              Kokkos::atomic_store(view.data(), 0);
+              for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+              if (Kokkos::atomic_load(view.data()) != N)
+                Kokkos::atomic_store(error.data(), 1);
+            });
+          });
+    }
+  };
+
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_team_policy) {
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping for OpenMPTarget since the test is designed to "
+                    "run with vector_length=1";
+#endif
+  run_exec_space_thread_safety_team_policy();
+}
+
+void run_exec_space_thread_safety_range_reduce() {
+  constexpr int N = 1000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_reduce(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(exec, 0, 1),
+          KOKKOS_LAMBDA(int, int &update) {
+            Kokkos::atomic_store(view.data(), 0);
+            for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+            if (Kokkos::atomic_load(view.data()) != N) ++update;
+          },
+          error);
+    }
+    exec.fence();
+  };
+
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_range_reduce) {
+  run_exec_space_thread_safety_range_reduce();
+}
+
+void run_exec_space_thread_safety_mdrange_reduce() {
+  constexpr int N = 1000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_reduce(
+          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(exec, {0, 0},
+                                                                 {1, 1}),
+          KOKKOS_LAMBDA(int, int, int &update) {
+            Kokkos::atomic_store(view.data(), 0);
+            for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+            if (Kokkos::atomic_load(view.data()) != N) ++update;
+          },
+          error);
+    }
+    exec.fence();
+  };
+
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_mdrange_reduce) {
+// FIXME_INTEL
+#if defined(KOKKOS_COMPILER_INTEL) && defined(KOKKOS_ENABLE_OPENMP)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::OpenMP>)
+    GTEST_SKIP() << "skipping since test is known to fail for OpenMP using the "
+                    "legacy Intel compiler";
+#endif
+  run_exec_space_thread_safety_mdrange_reduce();
+}
+
+void run_exec_space_thread_safety_team_policy_reduce() {
+  constexpr int N = 1000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_reduce(
+          Kokkos::TeamPolicy<TEST_EXECSPACE>(exec, 1, 1, 1),
+          KOKKOS_LAMBDA(const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type
+                            &team_member,
+                        int &update) {
+            Kokkos::single(Kokkos::PerTeam(team_member), [=, &update]() {
+              Kokkos::atomic_store(view.data(), 0);
+              for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+              if (Kokkos::atomic_load(view.data()) != N) ++update;
+            });
+          },
+          error);
+    }
+  };
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_team_policy_reduce) {
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping for OpenMPTarget since the test is designed to "
+                    "run with vector_length=1";
+#endif
+    // FIXME_SYCL
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_IMPL_ARCH_NVIDIA_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+    GTEST_SKIP() << "skipping since test is know to fail with SYCL+Cuda";
+#endif
+  run_exec_space_thread_safety_team_policy_reduce();
+}
+
+void run_exec_space_thread_safety_range_scan() {
+  constexpr int N = 1000000;
+  constexpr int M = 10;
+
+  Kokkos::View<int, TEST_EXECSPACE> view("view");
+  Kokkos::View<int, TEST_EXECSPACE> error("error");
+
+  auto lambda = [=]() {
+    TEST_EXECSPACE exec;
+    for (int j = 0; j < M; ++j) {
+      Kokkos::parallel_scan(
+          Kokkos::RangePolicy<TEST_EXECSPACE>(exec, 0, 1),
+          KOKKOS_LAMBDA(int, int &, const bool final) {
+            if (final) {
+              Kokkos::atomic_store(view.data(), 0);
+              for (int i = 0; i < N; ++i) Kokkos::atomic_inc(view.data());
+              if (Kokkos::atomic_load(view.data()) != N)
+                Kokkos::atomic_store(error.data(), 1);
+            }
+          });
+    }
+    exec.fence();
+  };
+
+  run_threaded_test(lambda, lambda);
+
+  auto host_error =
+      Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace{}, error);
+  ASSERT_EQ(host_error(), 0);
+}
+
+TEST(TEST_CATEGORY, exec_space_thread_safety_range_scan) {
+#ifdef KOKKOS_ENABLE_OPENACC  // FIXME_OPENACC
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenACC>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenACC";
+#endif
+  run_exec_space_thread_safety_range_scan();
+}
+
+}  // namespace
diff --git a/core/unit_test/TestExecutionSpace.hpp b/core/unit_test/TestExecutionSpace.hpp
index 6f0f159c17..d4142dee18 100644
--- a/core/unit_test/TestExecutionSpace.hpp
+++ b/core/unit_test/TestExecutionSpace.hpp
@@ -25,13 +25,7 @@ struct CheckClassWithExecutionSpaceAsDataMemberIsCopyable {
   Kokkos::DefaultExecutionSpace device;
   Kokkos::DefaultHostExecutionSpace host;
 
-  KOKKOS_FUNCTION void operator()(int, int& e) const {
-    // not actually doing anything useful, mostly checking that
-    // ExecutionSpace::in_parallel() is callable
-    if (static_cast<int>(device.in_parallel()) < 0) {
-      ++e;
-    }
-  }
+  KOKKOS_FUNCTION void operator()(int i, int& e) const { e += i; }
 
   CheckClassWithExecutionSpaceAsDataMemberIsCopyable() {
     int errors;
@@ -50,4 +44,60 @@ TEST(TEST_CATEGORY, execution_space_as_class_data_member) {
 }
 #endif
 
+constexpr bool test_execspace_explicit_construction() {
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+#ifdef KOKKOS_ENABLE_SERIAL
+  static_assert(std::is_convertible_v<Kokkos::NewInstance, Kokkos::Serial>);
+#endif
+#ifdef KOKKOS_ENABLE_OPENMP
+  static_assert(std::is_convertible_v<int, Kokkos::OpenMP>);
+#endif
+#ifdef KOKKOS_ENABLE_CUDA
+  static_assert(std::is_convertible_v<cudaStream_t, Kokkos::Cuda>);
+#endif
+#ifdef KOKKOS_ENABLE_HIP
+  static_assert(std::is_convertible_v<hipStream_t, Kokkos::HIP>);
+#endif
+#ifdef KOKKOS_ENABLE_HPX
+  static_assert(std::is_convertible_v<Kokkos::Experimental::HPX::instance_mode,
+                                      Kokkos::Experimental::HPX>);
+  static_assert(
+      std::is_convertible_v<hpx::execution::experimental::unique_any_sender<>&&,
+                            Kokkos::Experimental::HPX>);
+#endif
+#else
+#ifdef KOKKOS_ENABLE_SERIAL
+  static_assert(!std::is_convertible_v<Kokkos::NewInstance, Kokkos::Serial>);
+#endif
+#ifdef KOKKOS_ENABLE_OPENMP
+  static_assert(!std::is_convertible_v<int, Kokkos::OpenMP>);
+#endif
+#ifdef KOKKOS_ENABLE_CUDA
+  static_assert(!std::is_convertible_v<cudaStream_t, Kokkos::Cuda>);
+#endif
+#ifdef KOKKOS_ENABLE_HIP
+  static_assert(!std::is_convertible_v<hipStream_t, Kokkos::HIP>);
+#endif
+#ifdef KOKKOS_ENABLE_HPX
+  static_assert(!std::is_convertible_v<Kokkos::Experimental::HPX::instance_mode,
+                                       Kokkos::Experimental::HPX>);
+  static_assert(!std::is_convertible_v<
+                hpx::execution::experimental::unique_any_sender<>&&,
+                Kokkos::Experimental::HPX>);
+#endif
+#endif
+
+#ifdef KOKKOS_ENABLE_OPENACC
+  static_assert(!std::is_convertible_v<int, Kokkos::Experimental::OpenACC>);
+#endif
+#ifdef KOKKOS_ENABLE_SYCL
+  static_assert(
+      !std::is_convertible_v<sycl::queue, Kokkos::Experimental::SYCL>);
+#endif
+
+  return true;
+}
+
+static_assert(test_execspace_explicit_construction());
+
 }  // namespace
diff --git a/core/unit_test/TestFunctorAnalysis.hpp b/core/unit_test/TestFunctorAnalysis.hpp
index c024526111..e58324144e 100644
--- a/core/unit_test/TestFunctorAnalysis.hpp
+++ b/core/unit_test/TestFunctorAnalysis.hpp
@@ -59,16 +59,15 @@ void test_functor_analysis() {
 
   using R01 = typename A01::Reducer;
 
-  static_assert(std::is_void<typename A01::value_type>::value, "");
-  static_assert(std::is_void<typename A01::pointer_type>::value, "");
-  static_assert(std::is_void<typename A01::reference_type>::value, "");
-  static_assert(std::is_same<typename R01::functor_type, decltype(c01)>::value,
-                "");
-
-  static_assert(!A01::has_join_member_function, "");
-  static_assert(!A01::has_init_member_function, "");
-  static_assert(!A01::has_final_member_function, "");
-  static_assert(A01::StaticValueSize == 0, "");
+  static_assert(std::is_void<typename A01::value_type>::value);
+  static_assert(std::is_void<typename A01::pointer_type>::value);
+  static_assert(std::is_void<typename A01::reference_type>::value);
+  static_assert(std::is_same<typename R01::functor_type, decltype(c01)>::value);
+
+  static_assert(!A01::has_join_member_function);
+  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);
 
   //------------------------------
@@ -78,16 +77,15 @@ void test_functor_analysis() {
       Kokkos::RangePolicy<ExecSpace>, decltype(c02), void>;
   using R02 = typename A02::Reducer;
 
-  static_assert(std::is_same<typename A02::value_type, double>::value, "");
-  static_assert(std::is_same<typename A02::pointer_type, double*>::value, "");
-  static_assert(std::is_same<typename A02::reference_type, double&>::value, "");
-  static_assert(std::is_same<typename R02::functor_type, decltype(c02)>::value,
-                "");
+  static_assert(std::is_same<typename A02::value_type, double>::value);
+  static_assert(std::is_same<typename A02::pointer_type, double*>::value);
+  static_assert(std::is_same<typename A02::reference_type, double&>::value);
+  static_assert(std::is_same<typename R02::functor_type, decltype(c02)>::value);
 
-  static_assert(!A02::has_join_member_function, "");
-  static_assert(!A02::has_init_member_function, "");
-  static_assert(!A02::has_final_member_function, "");
-  static_assert(A02::StaticValueSize == sizeof(double), "");
+  static_assert(!A02::has_join_member_function);
+  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);
 
   //------------------------------
@@ -99,23 +97,19 @@ void test_functor_analysis() {
   using R03 = typename A03::Reducer;
 
   static_assert(std::is_same<typename A03::value_type,
-                             TestFunctorAnalysis_03::value_type>::value,
-                "");
+                             TestFunctorAnalysis_03::value_type>::value);
   static_assert(std::is_same<typename A03::pointer_type,
-                             TestFunctorAnalysis_03::value_type*>::value,
-                "");
+                             TestFunctorAnalysis_03::value_type*>::value);
   static_assert(std::is_same<typename A03::reference_type,
-                             TestFunctorAnalysis_03::value_type&>::value,
-                "");
+                             TestFunctorAnalysis_03::value_type&>::value);
   static_assert(
-      std::is_same<typename R03::functor_type, TestFunctorAnalysis_03>::value,
-      "");
+      std::is_same<typename R03::functor_type, TestFunctorAnalysis_03>::value);
 
-  static_assert(A03::has_join_member_function, "");
-  static_assert(A03::has_init_member_function, "");
-  static_assert(!A03::has_final_member_function, "");
-  static_assert(
-      A03::StaticValueSize == sizeof(TestFunctorAnalysis_03::value_type), "");
+  static_assert(A03::has_join_member_function);
+  static_assert(A03::has_init_member_function);
+  static_assert(!A03::has_final_member_function);
+  static_assert(A03::StaticValueSize ==
+                sizeof(TestFunctorAnalysis_03::value_type));
   ASSERT_EQ(R03(c03).length(), 1);
 
   //------------------------------
diff --git a/core/unit_test/TestGraph.hpp b/core/unit_test/TestGraph.hpp
index 9a36d08f44..f9dc63d30c 100644
--- a/core/unit_test/TestGraph.hpp
+++ b/core/unit_test/TestGraph.hpp
@@ -21,6 +21,21 @@
 
 namespace Test {
 
+template <class ExecSpace, class ValueType>
+struct NoOpReduceFunctor {
+  KOKKOS_FUNCTION void operator()(int, ValueType&) const {
+    Kokkos::abort("Should never be called!");
+  }
+  KOKKOS_FUNCTION void operator()(int, int, ValueType&) const {
+    Kokkos::abort("Should never be called!");
+  }
+  KOKKOS_FUNCTION void operator()(
+      const typename Kokkos::TeamPolicy<ExecSpace>::member_type&,
+      ValueType&) const {
+    Kokkos::abort("Should never be called!");
+  }
+};
+
 template <class ExecSpace>
 struct CountTestFunctor {
   using value_type = int;
@@ -66,7 +81,7 @@ struct SetResultToViewFunctor {
   }
 };
 
-struct TEST_CATEGORY_FIXTURE(count_bugs) : public ::testing::Test {
+struct TEST_CATEGORY_FIXTURE(graph) : public ::testing::Test {
  public:
   using count_functor      = CountTestFunctor<TEST_EXECSPACE>;
   using set_functor        = SetViewToValueFunctor<TEST_EXECSPACE, int>;
@@ -88,7 +103,7 @@ struct TEST_CATEGORY_FIXTURE(count_bugs) : public ::testing::Test {
   }
 };
 
-TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), launch_one) {
+TEST_F(TEST_CATEGORY_FIXTURE(graph), launch_one) {
   auto graph =
       Kokkos::Experimental::create_graph<TEST_EXECSPACE>([&](auto root) {
         root.then_parallel_for(1, count_functor{count, bugs, 0, 0});
@@ -101,7 +116,7 @@ TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), launch_one) {
   ASSERT_EQ(0, bugs_host());
 }
 
-TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), launch_one_rvalue) {
+TEST_F(TEST_CATEGORY_FIXTURE(graph), launch_one_rvalue) {
   Kokkos::Experimental::create_graph(ex, [&](auto root) {
     root.then_parallel_for(1, count_functor{count, bugs, 0, 0});
   }).submit();
@@ -112,7 +127,17 @@ TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), launch_one_rvalue) {
   ASSERT_EQ(0, bugs_host());
 }
 
-TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), launch_six) {
+TEST_F(TEST_CATEGORY_FIXTURE(graph), launch_six) {
+#ifdef KOKKOS_ENABLE_OPENMPTARGET  // FIXME_OPENMPTARGET team_size incompatible
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since OpenMPTarget can't use team_size 1";
+#endif
+#if defined(KOKKOS_ENABLE_SYCL) && \
+    !defined(SYCL_EXT_ONEAPI_GRAPH)  // FIXME_SYCL
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+    GTEST_SKIP() << "skipping since test case is known to fail with SYCL";
+#endif
+
   auto graph = Kokkos::Experimental::create_graph(ex, [&](auto root) {
     auto f_setup_count = root.then_parallel_for(1, set_functor{count, 0});
     auto f_setup_bugs  = root.then_parallel_for(1, set_functor{bugs, 0});
@@ -145,7 +170,7 @@ TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), launch_six) {
   ASSERT_EQ(0, bugs_host());
 }
 
-TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), when_all_cycle) {
+TEST_F(TEST_CATEGORY_FIXTURE(graph), when_all_cycle) {
   view_type reduction_out{"reduction_out"};
   view_host reduction_host{"reduction_host"};
   Kokkos::Experimental::create_graph(ex, [&](auto root) {
@@ -172,7 +197,7 @@ TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), when_all_cycle) {
 
 // This test is disabled because we don't currently support copying to host,
 // even asynchronously. We _may_ want to do that eventually?
-TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), DISABLED_repeat_chain) {
+TEST_F(TEST_CATEGORY_FIXTURE(graph), DISABLED_repeat_chain) {
   auto graph = Kokkos::Experimental::create_graph(
       ex, [&, count_host = count_host](auto root) {
         //----------------------------------------
@@ -198,10 +223,27 @@ TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), DISABLED_repeat_chain) {
   //----------------------------------------
 }
 
-TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), zero_work_reduce) {
-  auto graph = Kokkos::Experimental::create_graph(ex, [&](auto root) {
-    root.then_parallel_reduce(0, set_result_functor{bugs}, count);
-  });
+TEST_F(TEST_CATEGORY_FIXTURE(graph), zero_work_reduce) {
+  auto graph = Kokkos::Experimental::create_graph(
+      ex, [&](Kokkos::Experimental::GraphNodeRef<TEST_EXECSPACE> root) {
+        NoOpReduceFunctor<TEST_EXECSPACE, int> no_op_functor;
+        root.then_parallel_reduce(Kokkos::RangePolicy<TEST_EXECSPACE>(0, 0),
+                                  no_op_functor, count)
+#if !defined(KOKKOS_ENABLE_SYCL) || \
+    defined(SYCL_EXT_ONEAPI_GRAPH)  // FIXME_SYCL
+#if !defined(KOKKOS_ENABLE_CUDA) && \
+    !defined(KOKKOS_ENABLE_HIP)  // FIXME_CUDA FIXME_HIP
+            .then_parallel_reduce(
+                Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>{{0, 0},
+                                                                       {0, 0}},
+                no_op_functor, count)
+#endif
+            .then_parallel_reduce(
+                Kokkos::TeamPolicy<TEST_EXECSPACE>{0, Kokkos::AUTO},
+                no_op_functor, count)
+#endif
+            ;
+      });
 // These fences are only necessary because of the weirdness of how CUDA
 // UVM works on pre pascal cards.
 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_CUDA_UVM) && \
@@ -214,12 +256,15 @@ TEST_F(TEST_CATEGORY_FIXTURE(count_bugs), zero_work_reduce) {
 // UVM works on pre pascal cards.
 #if defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_ENABLE_CUDA_UVM) && \
     (defined(KOKKOS_ARCH_KEPLER) || defined(KOKKOS_ARCH_MAXWELL))
-  Kokkos::fence();
+  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Cuda>) Kokkos::fence();
+#endif
+#ifdef KOKKOS_ENABLE_HPX  // FIXME_HPX graph.submit() isn't properly enqueued
+  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::HPX>)
+    Kokkos::fence();
 #endif
-  graph.submit();  // should reset to 0, but doesn't
+  graph.submit();
   Kokkos::deep_copy(ex, count_host, count);
   ex.fence();
   ASSERT_EQ(count_host(), 0);
 }
-
 }  // end namespace Test
diff --git a/core/unit_test/TestHalfOperators.hpp b/core/unit_test/TestHalfOperators.hpp
index 29844a3c6a..c69cdd5703 100644
--- a/core/unit_test/TestHalfOperators.hpp
+++ b/core/unit_test/TestHalfOperators.hpp
@@ -241,106 +241,33 @@ enum OP_TESTS {
   OR,
   EQ,
   NEQ,
-  LT,
-  GT,
-  LE,
-  GE,  // TODO: TW,
+  LT_H_H,
+  LT_H_S,
+  LT_S_H,
+  LT_H_D,
+  LT_D_H,
+  GT_H_H,
+  GT_H_S,
+  GT_S_H,
+  GT_H_D,
+  GT_D_H,
+  LE_H_H,
+  LE_H_S,
+  LE_S_H,
+  LE_H_D,
+  LE_D_H,
+  GE_H_H,
+  GE_H_S,
+  GE_S_H,
+  GE_H_D,
+  GE_D_H,
+  // TODO: TW,
   PASS_BY_REF,
   AO_IMPL_HALF,
   AO_HALF_T,
   N_OP_TESTS
 };
 
-// volatile-qualified parameter type 'volatile half_type' is deprecated
-#if !defined(KOKKOS_ENABLE_CXX20) && !defined(KOKKOS_ENABLE_CXX23)
-template <class view_type, class half_type>
-struct Functor_TestHalfVolatileOperators {
-  volatile half_type h_lhs, h_rhs;
-  view_type actual_lhs, expected_lhs;
-  double d_lhs, d_rhs;
-  Functor_TestHalfVolatileOperators(volatile half_type lhs = half_type(0),
-                                    volatile half_type rhs = half_type(0))
-      : h_lhs(lhs), h_rhs(rhs) {
-    actual_lhs   = view_type("actual_lhs", N_OP_TESTS);
-    expected_lhs = view_type("expected_lhs", N_OP_TESTS);
-    half_type nv_tmp;
-    nv_tmp = h_lhs;
-    d_lhs  = static_cast<double>(nv_tmp);
-    nv_tmp = h_rhs;
-    d_rhs  = static_cast<double>(nv_tmp);
-    if (std::is_same<view_type, ViewTypeHost>::value) {
-      auto run_on_host = *this;
-      run_on_host(0);
-    } else {
-      Kokkos::parallel_for("Test::Functor_TestHalfVolatileOperators",
-                           Kokkos::RangePolicy<ExecutionSpace>(0, 1), *this);
-    }
-  }
-
-  KOKKOS_FUNCTION
-  void operator()(int) const {
-    volatile half_type tmp_lhs;
-    half_type nv_tmp;
-
-    // Initialze output views to catch missing test invocations
-    for (int i = 0; i < N_OP_TESTS; ++i) {
-      actual_lhs(i)   = 1;
-      expected_lhs(i) = -1;
-    }
-
-    nv_tmp               = h_lhs;
-    actual_lhs(ASSIGN)   = static_cast<double>(nv_tmp);
-    expected_lhs(ASSIGN) = d_lhs;
-
-    actual_lhs(LT)   = h_lhs < h_rhs;
-    expected_lhs(LT) = d_lhs < d_rhs;
-
-    actual_lhs(LE)   = h_lhs <= h_rhs;
-    expected_lhs(LE) = d_lhs <= d_rhs;
-
-    actual_lhs(NEQ)   = h_lhs != h_rhs;
-    expected_lhs(NEQ) = d_lhs != d_rhs;
-
-    actual_lhs(GT)   = h_lhs > h_rhs;
-    expected_lhs(GT) = d_lhs > d_rhs;
-
-    actual_lhs(GE)   = h_lhs >= h_rhs;
-    expected_lhs(GE) = d_lhs >= d_rhs;
-
-    actual_lhs(EQ)   = h_lhs == h_rhs;
-    expected_lhs(EQ) = d_lhs == d_rhs;
-
-    tmp_lhs = h_lhs;
-    tmp_lhs += h_rhs;
-    nv_tmp                 = tmp_lhs;
-    actual_lhs(CADD_H_H)   = static_cast<double>(nv_tmp);
-    expected_lhs(CADD_H_H) = d_lhs;
-    expected_lhs(CADD_H_H) += d_rhs;
-
-    tmp_lhs = h_lhs;
-    tmp_lhs -= h_rhs;
-    nv_tmp                 = tmp_lhs;
-    actual_lhs(CSUB_H_H)   = static_cast<double>(nv_tmp);
-    expected_lhs(CSUB_H_H) = d_lhs;
-    expected_lhs(CSUB_H_H) -= d_rhs;
-
-    tmp_lhs = h_lhs;
-    tmp_lhs *= h_rhs;
-    nv_tmp                 = tmp_lhs;
-    actual_lhs(CMUL_H_H)   = static_cast<double>(nv_tmp);
-    expected_lhs(CMUL_H_H) = d_lhs;
-    expected_lhs(CMUL_H_H) *= d_rhs;
-
-    tmp_lhs = h_lhs;
-    tmp_lhs /= h_rhs;
-    nv_tmp                 = tmp_lhs;
-    actual_lhs(CDIV_H_H)   = static_cast<double>(nv_tmp);
-    expected_lhs(CDIV_H_H) = d_lhs;
-    expected_lhs(CDIV_H_H) /= d_rhs;
-  }
-};
-#endif
-
 template <class view_type, class half_type>
 struct Functor_TestHalfOperators {
   half_type h_lhs, h_rhs;
@@ -879,17 +806,49 @@ struct Functor_TestHalfOperators {
     actual_lhs(NEQ)   = h_lhs != h_rhs;
     expected_lhs(NEQ) = d_lhs != d_rhs;
 
-    actual_lhs(LT)   = h_lhs < h_rhs;
-    expected_lhs(LT) = d_lhs < d_rhs;
-
-    actual_lhs(GT)   = h_lhs > h_rhs;
-    expected_lhs(GT) = d_lhs > d_rhs;
-
-    actual_lhs(LE)   = h_lhs <= h_rhs;
-    expected_lhs(LE) = d_lhs <= d_rhs;
-
-    actual_lhs(GE)   = h_lhs >= h_rhs;
-    expected_lhs(GE) = d_lhs >= d_rhs;
+    actual_lhs(LT_H_H)   = h_lhs < h_rhs;
+    expected_lhs(LT_H_H) = d_lhs < d_rhs;
+    actual_lhs(LT_H_S)   = h_lhs < static_cast<float>(h_rhs);
+    expected_lhs(LT_H_S) = d_lhs < d_rhs;
+    actual_lhs(LT_S_H)   = static_cast<float>(h_lhs) < h_rhs;
+    expected_lhs(LT_S_H) = d_lhs < d_rhs;
+    actual_lhs(LT_H_D)   = h_lhs < static_cast<double>(h_rhs);
+    expected_lhs(LT_H_D) = d_lhs < d_rhs;
+    actual_lhs(LT_D_H)   = static_cast<double>(h_lhs) < h_rhs;
+    expected_lhs(LT_D_H) = d_lhs < d_rhs;
+
+    actual_lhs(GT_H_H)   = h_lhs > h_rhs;
+    expected_lhs(GT_H_H) = d_lhs > d_rhs;
+    actual_lhs(GT_H_S)   = h_lhs > static_cast<float>(h_rhs);
+    expected_lhs(GT_H_S) = d_lhs > d_rhs;
+    actual_lhs(GT_S_H)   = static_cast<float>(h_lhs) > h_rhs;
+    expected_lhs(GT_S_H) = d_lhs > d_rhs;
+    actual_lhs(GT_H_D)   = h_lhs > static_cast<double>(h_rhs);
+    expected_lhs(GT_H_D) = d_lhs > d_rhs;
+    actual_lhs(GT_D_H)   = static_cast<double>(h_lhs) > h_rhs;
+    expected_lhs(GT_D_H) = d_lhs > d_rhs;
+
+    actual_lhs(LE_H_H)   = h_lhs <= h_rhs;
+    expected_lhs(LE_H_H) = d_lhs <= d_rhs;
+    actual_lhs(LE_H_S)   = h_lhs <= static_cast<float>(h_rhs);
+    expected_lhs(LE_H_S) = d_lhs <= d_rhs;
+    actual_lhs(LE_S_H)   = static_cast<float>(h_lhs) <= h_rhs;
+    expected_lhs(LE_S_H) = d_lhs <= d_rhs;
+    actual_lhs(LE_H_D)   = h_lhs <= static_cast<double>(h_rhs);
+    expected_lhs(LE_H_D) = d_lhs <= d_rhs;
+    actual_lhs(LE_D_H)   = static_cast<double>(h_lhs) <= h_rhs;
+    expected_lhs(LE_D_H) = d_lhs <= d_rhs;
+
+    actual_lhs(GE_H_H)   = h_lhs >= h_rhs;
+    expected_lhs(GE_H_H) = d_lhs >= d_rhs;
+    actual_lhs(GE_H_S)   = h_lhs >= static_cast<float>(h_rhs);
+    expected_lhs(GE_H_S) = d_lhs >= d_rhs;
+    actual_lhs(GE_S_H)   = static_cast<float>(h_lhs) >= h_rhs;
+    expected_lhs(GE_S_H) = d_lhs >= d_rhs;
+    actual_lhs(GE_H_D)   = h_lhs >= static_cast<double>(h_rhs);
+    expected_lhs(GE_H_D) = d_lhs >= d_rhs;
+    actual_lhs(GE_D_H)   = static_cast<double>(h_lhs) >= h_rhs;
+    expected_lhs(GE_D_H) = d_lhs >= d_rhs;
 
     // actual_lhs(TW)   = h_lhs <=> h_rhs;  // Need C++20?
     // expected_lhs(TW) = d_lhs <=> d_rhs;  // Need C++20?
@@ -926,7 +885,7 @@ struct Functor_TestHalfOperators {
 
 template <class half_type>
 void __test_half_operators(half_type h_lhs, half_type h_rhs) {
-  double epsilon = Kokkos::Experimental::epsilon<half_type>::value;
+  half_type 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);
@@ -941,37 +900,10 @@ void __test_half_operators(half_type h_lhs, half_type h_rhs) {
   for (int op_test = 0; op_test < N_OP_TESTS; op_test++) {
     // printf("op_test = %d\n", op_test);
     ASSERT_NEAR(f_device_actual_lhs(op_test), f_device_expected_lhs(op_test),
-                epsilon);
+                static_cast<double>(epsilon));
     ASSERT_NEAR(f_host.actual_lhs(op_test), f_host.expected_lhs(op_test),
-                epsilon);
-  }
-
-// volatile-qualified parameter type 'volatile half_type' is deprecated
-#if !defined(KOKKOS_ENABLE_CXX20) && !defined(KOKKOS_ENABLE_CXX23)
-  // Test partial volatile support
-  volatile half_type _h_lhs = h_lhs;
-  volatile half_type _h_rhs = h_rhs;
-  Functor_TestHalfVolatileOperators<ViewType, half_type> f_volatile_device(
-      _h_lhs, _h_rhs);
-  Functor_TestHalfVolatileOperators<ViewTypeHost, half_type> f_volatile_host(
-      _h_lhs, _h_rhs);
-
-  ExecutionSpace().fence();
-  Kokkos::deep_copy(f_device_actual_lhs, f_device.actual_lhs);
-  Kokkos::deep_copy(f_device_expected_lhs, f_device.expected_lhs);
-  for (int op_test = 0; op_test < N_OP_TESTS; op_test++) {
-    // printf("op_test = %d\n", op_test);
-    if (op_test == ASSIGN || op_test == LT || op_test == LE || op_test == NEQ ||
-        op_test == EQ || op_test == GT || op_test == GE ||
-        op_test == CADD_H_H || op_test == CSUB_H_H || op_test == CMUL_H_H ||
-        op_test == CDIV_H_H) {
-      ASSERT_NEAR(f_device_actual_lhs(op_test), f_device_expected_lhs(op_test),
-                  epsilon);
-      ASSERT_NEAR(f_host.actual_lhs(op_test), f_host.expected_lhs(op_test),
-                  epsilon);
-    }
+                static_cast<double>(epsilon));
   }
-#endif
 
   // is_trivially_copyable is false with the addition of explicit
   // copy constructors that are required for supporting reductions
diff --git a/core/unit_test/TestHostSharedPtrAccessOnDevice.hpp b/core/unit_test/TestHostSharedPtrAccessOnDevice.hpp
index 8cf25cef84..467b9ad157 100644
--- a/core/unit_test/TestHostSharedPtrAccessOnDevice.hpp
+++ b/core/unit_test/TestHostSharedPtrAccessOnDevice.hpp
@@ -37,7 +37,7 @@ template <class SmartPtr>
 struct CheckAccessStoredPointerAndDereferenceOnDevice {
   SmartPtr m_device_ptr;
   using ElementType = typename SmartPtr::element_type;
-  static_assert(std::is_same<ElementType, Data>::value, "");
+  static_assert(std::is_same<ElementType, Data>::value);
 
   CheckAccessStoredPointerAndDereferenceOnDevice(SmartPtr device_ptr)
       : m_device_ptr(device_ptr) {
@@ -108,12 +108,6 @@ TEST(TEST_CATEGORY, host_shared_ptr_dereference_on_device) {
       static_cast<T*>(Kokkos::kokkos_malloc<MemorySpace>(sizeof(T))),
       [](T* p) { Kokkos::kokkos_free<MemorySpace>(p); });
 
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Cuda>) {
-    GTEST_SKIP() << "FIXME wrong result";
-  }
-#endif
   check_access_stored_pointer_and_dereference_on_device(device_ptr);
 }
 
diff --git a/core/unit_test/TestInitializationSettings.cpp b/core/unit_test/TestInitializationSettings.cpp
index f5be0e47aa..40dc3f11df 100644
--- a/core/unit_test/TestInitializationSettings.cpp
+++ b/core/unit_test/TestInitializationSettings.cpp
@@ -20,30 +20,6 @@
 
 namespace {
 
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-void take_initialization_settings(Kokkos::InitializationSettings const&) {}
-
-TEST(defaultdevicetype,
-     init_arguments_implicit_conversion_to_initialization_settings) {
-  Kokkos::InitArguments arguments;
-  take_initialization_settings(arguments);  // check that conversion is implicit
-  arguments.device_id      = 1;
-  arguments.tune_internals = true;
-  Kokkos::InitializationSettings settings{arguments};
-  EXPECT_FALSE(settings.has_num_threads());
-  EXPECT_TRUE(settings.has_device_id());
-  EXPECT_EQ(settings.get_device_id(), 1);
-  EXPECT_FALSE(settings.has_num_devices());
-  EXPECT_FALSE(settings.has_skip_device());
-  EXPECT_FALSE(settings.has_disable_warnings());
-  EXPECT_TRUE(settings.has_tune_internals());
-  EXPECT_TRUE(settings.get_tune_internals());
-  EXPECT_FALSE(settings.has_tools_help());
-  EXPECT_FALSE(settings.has_tools_libs());
-  EXPECT_FALSE(settings.has_tools_args());
-}
-#endif
-
 TEST(defaultdevicetype, initialization_settings) {
   auto const settings = Kokkos::InitializationSettings()
                             .set_num_threads(255)
@@ -52,8 +28,6 @@ TEST(defaultdevicetype, initialization_settings) {
   EXPECT_TRUE(settings.has_num_threads());
   EXPECT_EQ(settings.get_num_threads(), 255);
   EXPECT_FALSE(settings.has_device_id());
-  EXPECT_FALSE(settings.has_num_devices());
-  EXPECT_FALSE(settings.has_skip_device());
   EXPECT_TRUE(settings.has_disable_warnings());
   EXPECT_FALSE(settings.get_disable_warnings());
   EXPECT_FALSE(settings.has_tune_internals());
@@ -75,8 +49,6 @@ constexpr bool test_initialization_settings_getter() {
                 TYPE>::value);
   CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(num_threads, int);
   CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(device_id, int);
-  CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(num_devices, int);
-  CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(skip_device, int);
   CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(disable_warnings, bool);
   CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(tune_internals, bool);
   CHECK_INITIALIZATION_SETTINGS_GETTER_RETURN_TYPE(tools_help, bool);
diff --git a/core/unit_test/TestJoinBackwardCompatibility.hpp b/core/unit_test/TestJoinBackwardCompatibility.hpp
index 3ca4421270..efe4a2307a 100644
--- a/core/unit_test/TestJoinBackwardCompatibility.hpp
+++ b/core/unit_test/TestJoinBackwardCompatibility.hpp
@@ -21,10 +21,6 @@
                                // 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,
@@ -39,21 +35,9 @@ 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,
-              "");
-static_assert((error_join_volatile | error_operator_plus_equal) == 0b101, "");
+              error_operator_plus_equal_volatile);
+static_assert((error_join_volatile | error_operator_plus_equal) == 0b101);
 
 struct MyJoinBackCompatValueType {
   MyErrorCode err = no_error;
@@ -111,7 +95,7 @@ struct ReducerWithJoinThatTakesVolatileQualifiedArgs {
 
 void test_join_backward_compatibility() {
   MyJoinBackCompatValueType result;
-  Kokkos::RangePolicy<> policy(0, 1);
+  Kokkos::RangePolicy<TEST_EXECSPACE> policy(0, 1);
 
   Kokkos::parallel_reduce(
       policy, ReducerWithJoinThatTakesBothVolatileAndNonVolatileQualifiedArgs{},
@@ -134,21 +118,9 @@ void test_join_backward_compatibility() {
   ReducerWithJoinThatTakesVolatileQualifiedArgs my_red;
   my_red.join(vol_result, result2);
   ASSERT_EQ(vol_result.err, expected_join_volatile);
-
-#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_3)
-  MyJoinBackCompatValueType result3;
-  Kokkos::parallel_reduce(
-      policy, ReducerWithJoinThatTakesVolatileQualifiedArgs{}, result3);
-  ASSERT_EQ(result3.err, expected_join_volatile);
-#endif
 }
 
 TEST(TEST_CATEGORY, join_backward_compatibility) {
-#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/TestLocalDeepCopy.hpp b/core/unit_test/TestLocalDeepCopy.hpp
index 60cb02b7f0..c6ee687cf9 100644
--- a/core/unit_test/TestLocalDeepCopy.hpp
+++ b/core/unit_test/TestLocalDeepCopy.hpp
@@ -988,6 +988,7 @@ TEST(TEST_CATEGORY, local_deepcopy_teampolicy_layoutright) {
 //-------------------------------------------------------------------------------------------------------------
 TEST(TEST_CATEGORY, local_deepcopy_rangepolicy_layoutright) {
   using ExecSpace = TEST_EXECSPACE;
+
   using ViewType = Kokkos::View<double********, Kokkos::LayoutRight, ExecSpace>;
 
   {  // Rank-1
diff --git a/core/unit_test/TestMDRangePolicyCTAD.cpp b/core/unit_test/TestMDRangePolicyCTAD.cpp
new file mode 100644
index 0000000000..b2c3d021c3
--- /dev/null
+++ b/core/unit_test/TestMDRangePolicyCTAD.cpp
@@ -0,0 +1,138 @@
+//@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 {
+
+struct TestMDRangePolicyCTAD {
+  template <typename... Ts>
+  static void maybe_unused(Ts&&...) {}
+
+  struct SomeExecutionSpace {
+    using execution_space = SomeExecutionSpace;
+    using size_type       = size_t;
+  };
+  static_assert(Kokkos::is_execution_space_v<SomeExecutionSpace>);
+
+  struct ImplicitlyConvertibleToDefaultExecutionSpace {
+    [[maybe_unused]] operator Kokkos::DefaultExecutionSpace() const {
+      return Kokkos::DefaultExecutionSpace();
+    }
+  };
+  static_assert(!Kokkos::is_execution_space_v<
+                ImplicitlyConvertibleToDefaultExecutionSpace>);
+
+  [[maybe_unused]] static inline Kokkos::DefaultExecutionSpace des;
+  [[maybe_unused]] static inline ImplicitlyConvertibleToDefaultExecutionSpace
+      notEs;
+  [[maybe_unused]] static inline SomeExecutionSpace ses;
+
+  [[maybe_unused]] static inline int t[5];
+  [[maybe_unused]] static inline int64_t tt[5];
+  [[maybe_unused]] static inline Kokkos::Array<int64_t, 3> a;
+  [[maybe_unused]] static inline Kokkos::Array<int64_t, 2> aa;
+  [[maybe_unused]] static inline int64_t i64;
+
+  // Workaround for nvc++ (CUDA-11.7-NVHPC) ignoring [[maybe_unused]] on
+  // ImplicitlyConvertibleToDefaultExecutionSpace::operator
+  // Kokkos::DefaultExecutionSpace() const
+  [[maybe_unused]] static inline Kokkos::DefaultExecutionSpace notEsToDes =
+      notEs;
+
+  // Workaround for HIP-ROCm-5.2 "declared but never referenced"
+  TestMDRangePolicyCTAD() {
+    maybe_unused(des, notEs, ses, t, tt, a, aa, notEsToDes, i64);
+  }
+
+  // MDRangePolicy with C array parameters
+
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(t)>>,
+                     decltype(Kokkos::MDRangePolicy(t, t))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(t)>>,
+                     decltype(Kokkos::MDRangePolicy(t, t, tt))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(t)>>,
+                     decltype(Kokkos::MDRangePolicy(des, t, tt))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(t)>>,
+                     decltype(Kokkos::MDRangePolicy(notEs, t, t))>);
+
+  static_assert(
+      std::is_same_v<
+          Kokkos::MDRangePolicy<SomeExecutionSpace, Kokkos::Rank<std::size(t)>>,
+          decltype(Kokkos::MDRangePolicy(ses, t, t))>);
+
+  // MDRangePolicy with Kokkos::initializer_list parameters
+
+  static_assert(std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<6>>,
+                               decltype(Kokkos::MDRangePolicy(
+                                   {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6}))>);
+
+  static_assert(std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<6>>,
+                               decltype(Kokkos::MDRangePolicy(
+                                   {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6},
+                                   {i64, i64, i64, i64, i64, i64}))>);
+
+  static_assert(std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<6>>,
+                               decltype(Kokkos::MDRangePolicy(
+                                   des, {1, 2, 3, 4, 5, 6},
+                                   {i64, i64, i64, i64, i64, i64}))>);
+
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<6>>,
+                     decltype(Kokkos::MDRangePolicy(notEs, {1, 2, 3, 4, 5, 6},
+                                                    {1, 2, 3, 4, 5, 6}))>);
+
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<SomeExecutionSpace, Kokkos::Rank<6>>,
+                     decltype(Kokkos::MDRangePolicy(ses, {1, 2, 3, 4, 5, 6},
+                                                    {1, 2, 3, 4, 5, 6}))>);
+
+  // MDRangePolicy with Kokkos::Array parameters
+
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(a)>>,
+                     decltype(Kokkos::MDRangePolicy(a, a))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(a)>>,
+                     decltype(Kokkos::MDRangePolicy(a, a, aa))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(a)>>,
+                     decltype(Kokkos::MDRangePolicy(des, a, a))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(a)>>,
+                     decltype(Kokkos::MDRangePolicy(notEs, a, a))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(a)>>,
+                     decltype(Kokkos::MDRangePolicy(des, a, a, aa))>);
+  static_assert(
+      std::is_same_v<Kokkos::MDRangePolicy<Kokkos::Rank<std::size(a)>>,
+                     decltype(Kokkos::MDRangePolicy(notEs, a, a, aa))>);
+
+  static_assert(
+      std::is_same_v<
+          Kokkos::MDRangePolicy<SomeExecutionSpace, Kokkos::Rank<std::size(a)>>,
+          decltype(Kokkos::MDRangePolicy(ses, a, a))>);
+  static_assert(
+      std::is_same_v<
+          Kokkos::MDRangePolicy<SomeExecutionSpace, Kokkos::Rank<std::size(a)>>,
+          decltype(Kokkos::MDRangePolicy(ses, a, a, aa))>);
+};
+
+}  // namespace
diff --git a/core/unit_test/TestMDRangePolicyConstructors.hpp b/core/unit_test/TestMDRangePolicyConstructors.hpp
index 9eeaba9fd4..6f241b45d4 100644
--- a/core/unit_test/TestMDRangePolicyConstructors.hpp
+++ b/core/unit_test/TestMDRangePolicyConstructors.hpp
@@ -18,6 +18,8 @@
 
 #include <Kokkos_Core.hpp>
 
+#include <regex>
+
 namespace {
 
 template <class IndexType>
@@ -81,20 +83,62 @@ TEST(TEST_CATEGORY, md_range_policy_construction_from_arrays) {
   construct_mdrange_policy_variable_type<std::int64_t>();
 }
 
-#ifndef KOKKOS_COMPILER_NVHPC       // FIXME_NVHPC
 #ifndef KOKKOS_ENABLE_OPENMPTARGET  // FIXME_OPENMPTARGET
 TEST(TEST_CATEGORY_DEATH, policy_bounds_unsafe_narrowing_conversions) {
   using Policy = Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>,
                                        Kokkos::IndexType<unsigned>>;
 
+  std::string msg =
+      "Kokkos::MDRangePolicy bound type error: an unsafe implicit conversion "
+      "is "
+      "performed on a bound (-1) in dimension (0), which may not preserve its "
+      "original value.\n";
+  std::string expected = std::regex_replace(msg, std::regex("\\(|\\)"), "\\$&");
+
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
-  ASSERT_DEATH(
-      {
-        (void)Policy({-1, 0}, {2, 3});
-      },
-      "unsafe narrowing conversion");
+  ASSERT_DEATH({ (void)Policy({-1, 0}, {2, 3}); }, expected);
 }
+
+TEST(TEST_CATEGORY_DEATH, policy_invalid_bounds) {
+  using Policy = Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>;
+
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  auto [dim0, dim1] = (Policy::inner_direction == Kokkos::Iterate::Right)
+                          ? std::make_pair(1, 0)
+                          : std::make_pair(0, 1);
+  std::string msg1 =
+      "Kokkos::MDRangePolicy bounds error: The lower bound (100) is greater "
+      "than its upper bound (90) in dimension " +
+      std::to_string(dim0) + ".\n";
+
+  std::string msg2 =
+      "Kokkos::MDRangePolicy bounds error: The lower bound (100) is greater "
+      "than its upper bound (90) in dimension " +
+      std::to_string(dim1) + ".\n";
+
+#if !defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+  // escape the parentheses in the regex to match the error message
+  msg1 = std::regex_replace(msg1, std::regex("\\(|\\)"), "\\$&");
+  (void)msg2;
+  ASSERT_DEATH({ (void)Policy({100, 100}, {90, 90}); }, msg1);
+#else
+  if (!Kokkos::show_warnings()) {
+    GTEST_SKIP() << "Kokkos warning messages are disabled";
+  }
+
+  ::testing::internal::CaptureStderr();
+  (void)Policy({100, 100}, {90, 90});
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+  ASSERT_EQ(::testing::internal::GetCapturedStderr(), msg1 + msg2);
+#else
+  ASSERT_TRUE(::testing::internal::GetCapturedStderr().empty());
+  (void)msg1;
+  (void)msg2;
 #endif
+
+#endif
+}
 #endif
 
 }  // namespace
diff --git a/core/unit_test/TestMDSpan.hpp b/core/unit_test/TestMDSpan.hpp
index 6359bd447d..fa88b547a5 100644
--- a/core/unit_test/TestMDSpan.hpp
+++ b/core/unit_test/TestMDSpan.hpp
@@ -30,18 +30,24 @@ void test_mdspan_minimal_functional() {
       "FillSequence", Kokkos::RangePolicy<TEST_EXECSPACE>(0, N),
       KOKKOS_LAMBDA(int i) { a(i) = i; });
 
-  mdspan_ns::mdspan<int, mdspan_ns::dextents<int, 1>> a_mds(a.data(), N);
+  Kokkos::mdspan<int, Kokkos::dextents<int, 1>> a_mds(a.data(), N);
   int errors;
   Kokkos::parallel_reduce(
       "CheckMinimalMDSpan", Kokkos::RangePolicy<TEST_EXECSPACE>(0, N),
       KOKKOS_LAMBDA(int i, int& err) {
-        mdspan_ns::mdspan<int, mdspan_ns::dextents<int, 1>> b_mds(a.data(), N);
-#ifdef KOKKOS_ENABLE_CXX23
+#if !defined(KOKKOS_ENABLE_OPENACC)
+        Kokkos::mdspan<int, Kokkos::dextents<int, 1>> b_mds(a.data(), N);
+#endif
+#if !defined(KOKKOS_ENABLE_CXX17) && !defined(KOKKOS_ENABLE_CXX20)
         if (a_mds[i] != i) err++;
+#if !defined(KOKKOS_ENABLE_OPENACC)
         if (b_mds[i] != i) err++;
+#endif
 #else
         if (a_mds(i) != i) err++;
+#if !defined(KOKKOS_ENABLE_OPENACC)
         if (b_mds(i) != i) err++;
+#endif
 #endif
       },
       errors);
diff --git a/core/unit_test/TestMDSpanAtomicAccessor.hpp b/core/unit_test/TestMDSpanAtomicAccessor.hpp
new file mode 100644
index 0000000000..04460e6419
--- /dev/null
+++ b/core/unit_test/TestMDSpanAtomicAccessor.hpp
@@ -0,0 +1,112 @@
+//@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 <type_traits>
+
+#include <gtest/gtest.h>
+#ifndef KOKKOS_ENABLE_CXX17
+#include <concepts>
+#endif
+
+template <class T, class ExecutionSpace>
+void test_atomic_accessor() {
+  using value_type = std::remove_const_t<T>;
+  Kokkos::View<value_type*, ExecutionSpace> v("V", 100);
+
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecutionSpace>(0, v.extent(0)),
+      KOKKOS_LAMBDA(int i) { v(i) = i; });
+
+  int errors;
+  using acc_t = Kokkos::Impl::AtomicAccessorRelaxed<T>;
+  acc_t acc{};
+  typename acc_t::data_handle_type ptr = v.data();
+
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecutionSpace>(0, v.extent(0)),
+      KOKKOS_LAMBDA(int i, int& error) {
+        if (acc.access(ptr, i) != ptr[i]) error++;
+        if (acc.offset(ptr, i) != ptr + i) error++;
+        static_assert(std::is_same_v<typename acc_t::element_type, T>);
+        static_assert(
+            std::is_same_v<typename acc_t::reference,
+                           desul::AtomicRef<T, desul::MemoryOrderRelaxed,
+                                            desul::MemoryScopeDevice>>);
+        static_assert(std::is_same_v<typename acc_t::data_handle_type, T*>);
+        static_assert(std::is_same_v<typename acc_t::offset_policy, acc_t>);
+        static_assert(std::is_same_v<decltype(acc.access(ptr, i)),
+                                     typename acc_t::reference>);
+        static_assert(std::is_same_v<decltype(acc.offset(ptr, i)), T*>);
+        static_assert(std::is_nothrow_move_constructible_v<acc_t>);
+        static_assert(std::is_nothrow_move_assignable_v<acc_t>);
+        static_assert(std::is_nothrow_swappable_v<acc_t>);
+        static_assert(std::is_trivially_copyable_v<acc_t>);
+        static_assert(std::is_trivially_default_constructible_v<acc_t>);
+        static_assert(std::is_trivially_constructible_v<acc_t>);
+        static_assert(std::is_trivially_move_constructible_v<acc_t>);
+        static_assert(std::is_trivially_assignable_v<acc_t, acc_t>);
+        static_assert(std::is_trivially_move_assignable_v<acc_t>);
+#ifndef KOKKOS_ENABLE_CXX17
+        static_assert(std::copyable<acc_t>);
+        static_assert(std::is_empty_v<acc_t>);
+#endif
+      },
+      errors);
+  ASSERT_EQ(errors, 0);
+}
+
+void test_atomic_accessor_conversion() {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using T              = float;
+  using acc_t          = Kokkos::Impl::AtomicAccessorRelaxed<T>;
+  using const_acc_t    = Kokkos::Impl::AtomicAccessorRelaxed<const T>;
+  using int_acc_t      = Kokkos::Impl::AtomicAccessorRelaxed<int>;
+  using defacc_t       = Kokkos::default_accessor<T>;
+  using const_defacc_t = Kokkos::default_accessor<const T>;
+  using int_defacc_t   = Kokkos::default_accessor<int>;
+
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecutionSpace>(0, 1), KOKKOS_LAMBDA(int) {
+        static_assert(std::is_constructible_v<const_acc_t, acc_t>);
+        static_assert(std::is_convertible_v<acc_t, const_acc_t>);
+        static_assert(!std::is_constructible_v<acc_t, const_acc_t>);
+        static_assert(!std::is_constructible_v<acc_t, int_acc_t>);
+        static_assert(std::is_constructible_v<defacc_t, acc_t>);
+        static_assert(std::is_constructible_v<acc_t, defacc_t>);
+        static_assert(!std::is_constructible_v<int_defacc_t, acc_t>);
+        static_assert(!std::is_constructible_v<int_acc_t, defacc_t>);
+        static_assert(std::is_constructible_v<const_defacc_t, const_acc_t>);
+        static_assert(std::is_constructible_v<const_acc_t, const_defacc_t>);
+        static_assert(std::is_constructible_v<const_defacc_t, acc_t>);
+        static_assert(std::is_constructible_v<const_acc_t, defacc_t>);
+        static_assert(!std::is_constructible_v<defacc_t, const_acc_t>);
+        static_assert(!std::is_constructible_v<acc_t, const_defacc_t>);
+        static_assert(std::is_convertible_v<acc_t, const_acc_t>);
+        static_assert(std::is_convertible_v<defacc_t, acc_t>);
+        static_assert(std::is_convertible_v<defacc_t, const_acc_t>);
+        static_assert(std::is_convertible_v<const_defacc_t, const_acc_t>);
+        static_assert(!std::is_convertible_v<acc_t, defacc_t>);
+        static_assert(!std::is_convertible_v<acc_t, const_defacc_t>);
+        static_assert(!std::is_convertible_v<const_acc_t, const_defacc_t>);
+      });
+}
+
+TEST(TEST_CATEGORY, mdspan_atomic_accessor) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  test_atomic_accessor<int, ExecutionSpace>();
+  test_atomic_accessor<double, ExecutionSpace>();
+}
diff --git a/core/unit_test/TestMDSpanConversion.hpp b/core/unit_test/TestMDSpanConversion.hpp
new file mode 100644
index 0000000000..10123901c4
--- /dev/null
+++ b/core/unit_test/TestMDSpanConversion.hpp
@@ -0,0 +1,507 @@
+//@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 <type_traits>
+
+#include <Kokkos_Core.hpp>
+#include "experimental/__p0009_bits/layout_stride.hpp"
+
+namespace {
+
+template <class T, class ExecutionSpace>
+struct TestViewMDSpanConversion {
+  using value_type = T;
+
+  template <std::size_t Padding>
+  using layout_left_padded = Kokkos::Experimental::layout_left_padded<Padding>;
+
+  template <std::size_t Padding>
+  using layout_right_padded =
+      Kokkos::Experimental::layout_right_padded<Padding>;
+
+  struct TestAccessor {
+    using offset_policy    = TestAccessor;
+    using element_type     = value_type;
+    using reference        = element_type &;
+    using data_handle_type = element_type *;
+
+    constexpr TestAccessor() noexcept = default;
+    constexpr reference access(data_handle_type p, std::size_t i) noexcept {
+      return p[i];
+    }
+    constexpr data_handle_type offset(data_handle_type p,
+                                      std::size_t i) noexcept {
+      return p + i;
+    }
+  };
+
+  template <class KokkosLayout, class DataType, class MDSpanLayoutMapping,
+            class... RefViewProps>
+  static void test_conversion_from_mdspan(
+      Kokkos::View<DataType, RefViewProps...> ref,
+      const MDSpanLayoutMapping &mapping) {
+    using unmanaged_view_type =
+        Kokkos::View<DataType, KokkosLayout, ExecutionSpace,
+                     Kokkos::MemoryTraits<Kokkos::Unmanaged>>;
+    using natural_mdspan_type = typename Kokkos::Impl::MDSpanViewTraits<
+        typename unmanaged_view_type::traits>::mdspan_type;
+    using mapping_type       = MDSpanLayoutMapping;
+    using mdspan_layout_type = typename MDSpanLayoutMapping::layout_type;
+    using extents_type       = typename mapping_type::extents_type;
+    using mdspan_type =
+        Kokkos::mdspan<value_type, extents_type, mdspan_layout_type>;
+
+    static_assert(std::is_constructible_v<natural_mdspan_type, mdspan_type>);
+    static_assert(std::is_convertible_v<mdspan_type, natural_mdspan_type> ==
+                  std::is_convertible_v<mdspan_type, unmanaged_view_type>);
+    // Manually create an mdspan from ref so we have a valid pointer to play
+    // with
+    const auto &exts = mapping.extents();
+    auto mds         = mdspan_type{ref.data(), mapping};
+
+    auto test_view = unmanaged_view_type(mds);
+
+    ASSERT_EQ(test_view.data(), ref.data());
+    ASSERT_EQ(test_view.data(), mds.data_handle());
+    ASSERT_EQ(test_view.layout(), ref.layout());
+    for (std::size_t r = 0; r < mdspan_type::rank(); ++r) {
+      ASSERT_EQ(test_view.extent(r), ref.extent(r));
+      ASSERT_EQ(test_view.extent(r), exts.extent(r));
+    }
+  }
+
+  template <class MDSpanLayoutMapping, class ViewType>
+  static void test_conversion_to_mdspan(
+      const MDSpanLayoutMapping &ref_layout_mapping, ViewType v) {
+    using view_type           = ViewType;
+    using natural_mdspan_type = typename Kokkos::Impl::MDSpanViewTraits<
+        typename view_type::traits>::mdspan_type;
+
+    static_assert(natural_mdspan_type::rank() == view_type::rank);
+    static_assert(std::is_same_v<typename natural_mdspan_type::value_type,
+                                 typename view_type::value_type>);
+    constexpr bool is_strided_layout =
+        std::is_same_v<typename MDSpanLayoutMapping::layout_type,
+                       Kokkos::layout_stride>;
+    if constexpr (!is_strided_layout) {
+      static_assert(natural_mdspan_type::mapping_type::padding_value ==
+                    Kokkos::dynamic_extent);
+    }
+    // test conversion operator to natural mdspan
+    {
+      natural_mdspan_type cvt = v;
+      ASSERT_EQ(cvt.data_handle(), v.data());
+      ASSERT_EQ(cvt.mapping(), ref_layout_mapping);
+
+      if constexpr (!is_strided_layout && natural_mdspan_type::rank() > 1) {
+        ASSERT_EQ(cvt.mapping().stride(1), ref_layout_mapping.stride(1));
+      }
+    }
+    // test to_mdspan() returning natural mdspan
+    {
+      auto cvt = v.to_mdspan();
+      static_assert(std::is_same_v<natural_mdspan_type, decltype(cvt)>);
+      ASSERT_EQ(cvt.data_handle(), v.data());
+      ASSERT_EQ(cvt.mapping(), ref_layout_mapping);
+    }
+    // test conversion operator to different mdspan type
+    {
+      using element_type   = const typename natural_mdspan_type::element_type;
+      using const_acc_type = Kokkos::Impl::SpaceAwareAccessor<
+          typename ViewType::memory_space,
+          Kokkos::default_accessor<element_type>>;
+      using mdspan_type = Kokkos::mdspan<
+          element_type,
+          Kokkos::dextents<typename natural_mdspan_type::index_type,
+                           natural_mdspan_type::rank()>,
+          typename natural_mdspan_type::layout_type, const_acc_type>;
+      mdspan_type cvt = v;
+      ASSERT_EQ(cvt.data_handle(), v.data());
+      ASSERT_EQ(cvt.mapping(), ref_layout_mapping);
+    }
+  }
+
+  template <class MDSpanLayoutMapping, class ViewType, class AccessorType>
+  static void test_conversion_to_mdspan_with_accessor(
+      const MDSpanLayoutMapping &ref_layout_mapping, ViewType v,
+      const AccessorType &a) {
+    auto cvt = v.to_mdspan(a);
+    static_assert(decltype(cvt)::rank() == ViewType::rank);
+    static_assert(std::is_same_v<typename decltype(cvt)::value_type,
+                                 typename ViewType::value_type>);
+    ASSERT_EQ(cvt.data_handle(), v.data());
+    ASSERT_EQ(cvt.mapping(), ref_layout_mapping);
+  }
+
+  template <typename ViewType>
+  using natural_mdspan_type_for_view = typename Kokkos::Impl::MDSpanViewTraits<
+      typename ViewType::traits>::mdspan_type;
+
+  static void run_test() {
+    // Verify we can only convert to compatible mdspans
+    static_assert(std::is_convertible_v<
+                  Kokkos::View<value_type *>,
+                  natural_mdspan_type_for_view<Kokkos::View<value_type *>>>);
+    static_assert(
+        std::is_convertible_v<
+            Kokkos::View<value_type *>,
+            natural_mdspan_type_for_view<Kokkos::View<const value_type *>>>);
+
+    // Do not cast const away
+    static_assert(!std::is_convertible_v<
+                  Kokkos::View<const value_type *>,
+                  natural_mdspan_type_for_view<Kokkos::View<value_type *>>>);
+
+    // Mismatched dim
+    static_assert(!std::is_convertible_v<
+                  Kokkos::View<value_type *>,
+                  natural_mdspan_type_for_view<Kokkos::View<value_type **>>>);
+
+    // Mismatched layouts
+    static_assert(
+        !std::is_convertible_v<Kokkos::View<value_type **, Kokkos::LayoutLeft>,
+                               natural_mdspan_type_for_view<Kokkos::View<
+                                   value_type **, Kokkos::LayoutRight>>>);
+    static_assert(
+        !std::is_convertible_v<Kokkos::View<value_type **, Kokkos::LayoutRight>,
+                               natural_mdspan_type_for_view<Kokkos::View<
+                                   value_type **, Kokkos::LayoutLeft>>>);
+    // nvcc doesn't do CTAD properly here, making this way more verbose..
+    // LayoutLeft
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type *, Kokkos::LayoutLeft, ExecutionSpace>("ref",
+                                                                       7),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 1>>{
+            Kokkos::dextents<std::size_t, 1>(7)});
+
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type[7], Kokkos::LayoutLeft, ExecutionSpace>("ref"),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 7>>{
+            Kokkos::extents<std::size_t, 7>()});
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type[7], Kokkos::LayoutLeft, ExecutionSpace>("ref"),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 1>>{
+            Kokkos::dextents<std::size_t, 1>(7)});
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type *, Kokkos::LayoutLeft, ExecutionSpace>("ref",
+                                                                       7),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 7>>{
+            Kokkos::extents<std::size_t, 7>()});
+
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type **, Kokkos::LayoutLeft, ExecutionSpace>("ref",
+                                                                        7, 3),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 2>>{
+            Kokkos::dextents<std::size_t, 2>(7, 3)});
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type[7][3], Kokkos::LayoutLeft, ExecutionSpace>(
+            "ref"),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 7, 3>>{
+            Kokkos::extents<std::size_t, 7, 3>()});
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type[7][3], Kokkos::LayoutLeft, ExecutionSpace>(
+            "ref"),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 2>>{
+            Kokkos::dextents<std::size_t, 2>(7, 3)});
+    test_conversion_from_mdspan<Kokkos::LayoutLeft>(
+        Kokkos::View<value_type **, Kokkos::LayoutLeft, ExecutionSpace>("ref",
+                                                                        7, 3),
+        typename layout_left_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 7, 3>>{
+            Kokkos::extents<std::size_t, 7, 3>()});
+
+    // LayoutRight
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type *, Kokkos::LayoutRight, ExecutionSpace>("ref",
+                                                                        7),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 1>>{
+            Kokkos::dextents<std::size_t, 1>(7)});
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type[7], Kokkos::LayoutRight, ExecutionSpace>("ref"),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 7>>{
+            Kokkos::extents<std::size_t, 7>()});
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type[7], Kokkos::LayoutRight, ExecutionSpace>("ref"),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 1>>{
+            Kokkos::dextents<std::size_t, 1>(7)});
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type *, Kokkos::LayoutRight, ExecutionSpace>("ref",
+                                                                        7),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 7>>{
+            Kokkos::extents<std::size_t, 7>()});
+
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type **, Kokkos::LayoutRight, ExecutionSpace>("ref",
+                                                                         3, 7),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 2>>{
+            Kokkos::dextents<std::size_t, 2>(3, 7)});
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type[3][7], Kokkos::LayoutRight, ExecutionSpace>(
+            "ref"),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 3, 7>>{
+            Kokkos::extents<std::size_t, 3, 7>()});
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type[3][7], Kokkos::LayoutRight, ExecutionSpace>(
+            "ref"),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::dextents<std::size_t, 2>>{
+            Kokkos::dextents<std::size_t, 2>(3, 7)});
+    test_conversion_from_mdspan<Kokkos::LayoutRight>(
+        Kokkos::View<value_type **, Kokkos::LayoutRight, ExecutionSpace>("ref",
+                                                                         3, 7),
+        typename layout_right_padded<7>::template mapping<
+            Kokkos::extents<std::size_t, 3, 7>>{
+            Kokkos::extents<std::size_t, 3, 7>()});
+
+    // LayoutStride
+    {
+      const size_t strides[] = {2};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type *, Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2}),
+          Kokkos::layout_stride::mapping<Kokkos::dextents<std::size_t, 1>>{
+              Kokkos::mdspan_non_standard, Kokkos::dextents<std::size_t, 1>{7},
+              strides});
+    }
+    {
+      const size_t strides[] = {2};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type[7], Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2}),
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 7>>{
+              Kokkos::mdspan_non_standard, {}, strides});
+    }
+    {
+      const size_t strides[] = {2};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type[7], Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2}),
+          Kokkos::layout_stride::mapping<Kokkos::dextents<std::size_t, 1>>{
+              Kokkos::mdspan_non_standard, Kokkos::dextents<std::size_t, 1>{7},
+              strides});
+    }
+    {
+      const size_t strides[] = {2};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type *, Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2}),
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 7>>{
+              Kokkos::mdspan_non_standard, Kokkos::extents<std::size_t, 7>(),
+              strides});
+    }
+
+    {
+      const size_t strides[] = {2, 4};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type **, Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2, 3, 4}),
+          Kokkos::layout_stride::mapping<Kokkos::dextents<std::size_t, 2>>{
+              Kokkos::mdspan_non_standard,
+              Kokkos::dextents<std::size_t, 2>(7, 3), strides});
+    }
+    {
+      const size_t strides[] = {2, 4};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type[7][3], Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2, 3, 4}),
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 7, 3>>{
+              Kokkos::mdspan_non_standard, Kokkos::extents<std::size_t, 7, 3>(),
+              strides});
+    }
+    {
+      const size_t strides[] = {2, 4};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type[7][3], Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2, 3, 4}),
+          Kokkos::layout_stride::mapping<Kokkos::dextents<std::size_t, 2>>{
+              Kokkos::mdspan_non_standard,
+              Kokkos::dextents<std::size_t, 2>(7, 3), strides});
+    }
+    {
+      const size_t strides[] = {2, 4};
+      test_conversion_from_mdspan<Kokkos::LayoutStride>(
+          Kokkos::View<value_type **, Kokkos::LayoutStride, ExecutionSpace>(
+              "ref", Kokkos::LayoutStride{7, 2, 3, 4}),
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 7, 3>>{
+              Kokkos::mdspan_non_standard, Kokkos::extents<std::size_t, 7, 3>(),
+              strides});
+    }
+
+    // Conversion to mdspan
+    test_conversion_to_mdspan(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4>>({}, 4),
+        Kokkos::View<value_type *, Kokkos::LayoutLeft, ExecutionSpace>("v", 4));
+    test_conversion_to_mdspan(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4, 7>>({}, 4),
+        Kokkos::View<value_type **, Kokkos::LayoutLeft, ExecutionSpace>("v", 4,
+                                                                        7));
+
+    test_conversion_to_mdspan(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4>>({}, 4),
+        Kokkos::View<value_type *, Kokkos::LayoutRight, ExecutionSpace>("v",
+                                                                        4));
+    test_conversion_to_mdspan(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4, 7>>({}, 7),
+        Kokkos::View<value_type **, Kokkos::LayoutRight, ExecutionSpace>("v", 4,
+                                                                         7));
+
+    {
+      const size_t strides[] = {5};
+      test_conversion_to_mdspan(
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 4>>(
+              Kokkos::mdspan_non_standard, {}, strides),
+          Kokkos::View<value_type *, Kokkos::LayoutStride, ExecutionSpace>(
+              "v", Kokkos::LayoutStride{4, 5}));
+    }
+    {
+      const size_t strides[] = {5, 9};
+      test_conversion_to_mdspan(
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 4, 7>>(
+              Kokkos::mdspan_non_standard, {}, strides),
+          Kokkos::View<value_type **, Kokkos::LayoutStride, ExecutionSpace>(
+              "v", Kokkos::LayoutStride{4, 5, 7, 9}));
+    }
+
+    // Aligned types (for padded layouts)
+    test_conversion_to_mdspan(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 127, 7>>({}, 128),
+        Kokkos::View<value_type **, Kokkos::LayoutLeft, ExecutionSpace>(
+            Kokkos::view_alloc("v", Kokkos::AllowPadding), 127, 7));
+
+    test_conversion_to_mdspan(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 7, 127>>({}, 128),
+        Kokkos::View<value_type **, Kokkos::LayoutRight, ExecutionSpace>(
+            Kokkos::view_alloc("v", Kokkos::AllowPadding), 7, 127));
+
+    // Conversion with standard default_accessor
+
+    test_conversion_to_mdspan_with_accessor(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4>>({}, 4),
+        Kokkos::View<value_type *, Kokkos::LayoutLeft, ExecutionSpace>("v", 4),
+        Kokkos::default_accessor<value_type>{});
+    test_conversion_to_mdspan_with_accessor(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4, 7>>({}, 4),
+        Kokkos::View<value_type **, Kokkos::LayoutLeft, ExecutionSpace>("v", 4,
+                                                                        7),
+        Kokkos::default_accessor<value_type>{});
+
+    test_conversion_to_mdspan_with_accessor(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4>>({}, 4),
+        Kokkos::View<value_type *, Kokkos::LayoutRight, ExecutionSpace>("v", 4),
+        Kokkos::default_accessor<value_type>{});
+    test_conversion_to_mdspan_with_accessor(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4, 7>>({}, 7),
+        Kokkos::View<value_type **, Kokkos::LayoutRight, ExecutionSpace>("v", 4,
+                                                                         7),
+        Kokkos::default_accessor<value_type>{});
+
+    {
+      const size_t strides[] = {5};
+      test_conversion_to_mdspan_with_accessor(
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 4>>(
+              Kokkos::mdspan_non_standard, {}, strides),
+          Kokkos::View<value_type *, Kokkos::LayoutStride, ExecutionSpace>(
+              "v", Kokkos::LayoutStride{4, 5}),
+          Kokkos::default_accessor<value_type>{});
+    }
+    {
+      const size_t strides[] = {5, 9};
+      test_conversion_to_mdspan_with_accessor(
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 4, 7>>(
+              Kokkos::mdspan_non_standard, {}, strides),
+          Kokkos::View<value_type **, Kokkos::LayoutStride, ExecutionSpace>(
+              "v", Kokkos::LayoutStride{4, 5, 7, 9}),
+          Kokkos::default_accessor<value_type>{});
+    }
+
+    // Conversion with a test accessor
+
+    test_conversion_to_mdspan_with_accessor(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4>>({}, 4),
+        Kokkos::View<value_type *, Kokkos::LayoutLeft, ExecutionSpace>("v", 4),
+        TestAccessor{});
+    test_conversion_to_mdspan_with_accessor(
+        layout_left_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4, 7>>({}, 4),
+        Kokkos::View<value_type **, Kokkos::LayoutLeft, ExecutionSpace>("v", 4,
+                                                                        7),
+        TestAccessor{});
+
+    test_conversion_to_mdspan_with_accessor(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4>>({}, 4),
+        Kokkos::View<value_type *, Kokkos::LayoutRight, ExecutionSpace>("v", 4),
+        TestAccessor{});
+    test_conversion_to_mdspan_with_accessor(
+        layout_right_padded<Kokkos::dynamic_extent>::mapping<
+            Kokkos::extents<std::size_t, 4, 7>>({}, 7),
+        Kokkos::View<value_type **, Kokkos::LayoutRight, ExecutionSpace>("v", 4,
+                                                                         7),
+        TestAccessor{});
+
+    {
+      const size_t strides[] = {5};
+      test_conversion_to_mdspan_with_accessor(
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 4>>(
+              Kokkos::mdspan_non_standard, {}, strides),
+          Kokkos::View<value_type *, Kokkos::LayoutStride, ExecutionSpace>(
+              "v", Kokkos::LayoutStride{4, 5}),
+          TestAccessor{});
+    }
+    {
+      const size_t strides[] = {5, 9};
+      test_conversion_to_mdspan_with_accessor(
+          Kokkos::layout_stride::mapping<Kokkos::extents<std::size_t, 4, 7>>(
+              Kokkos::mdspan_non_standard, {}, strides),
+          Kokkos::View<value_type **, Kokkos::LayoutStride, ExecutionSpace>(
+              "v", Kokkos::LayoutStride{4, 5, 7, 9}),
+          TestAccessor{});
+    }
+  }
+};
+
+TEST(TEST_CATEGORY, view_mdspan_conversion) {
+  TestViewMDSpanConversion<double, TEST_EXECSPACE>::run_test();
+  TestViewMDSpanConversion<float, TEST_EXECSPACE>::run_test();
+  TestViewMDSpanConversion<int, TEST_EXECSPACE>::run_test();
+}
+
+}  // namespace
diff --git a/core/unit_test/TestMathematicalConstants.hpp b/core/unit_test/TestMathematicalConstants.hpp
index b9b350c9b7..f52bfeaff7 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_COMPILER_NVHPC)
+    defined(KOKKOS_ENABLE_OPENACC)
     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 fe7074d5a1..f996c61a52 100644
--- a/core/unit_test/TestMathematicalFunctions.hpp
+++ b/core/unit_test/TestMathematicalFunctions.hpp
@@ -30,10 +30,26 @@
 #define MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
 #endif
 
+#if defined KOKKOS_COMPILER_INTEL ||                                  \
+    (defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC >= 1130 && \
+     !defined(KOKKOS_COMPILER_MSVC))
+#define MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE __builtin_unreachable();
+#else
+#define MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE
+#endif
+
+namespace KE = Kokkos::Experimental;
+
 // clang-format off
 template <class>
 struct math_unary_function_return_type;
 // Floating-point types
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+template <> struct math_unary_function_return_type<KE::half_t> { using type = KE::half_t; };
+#endif // defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+template <> struct math_unary_function_return_type<KE::bhalf_t> { using type = KE::bhalf_t; };
+#endif // defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
 template <> struct math_unary_function_return_type<      float> { using type =       float; };
 template <> struct math_unary_function_return_type<     double> { using type =      double; };
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -53,6 +69,29 @@ template <class T>
 using math_unary_function_return_type_t = typename math_unary_function_return_type<T>::type;
 template <class, class>
 struct math_binary_function_return_type;
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+template <> struct math_binary_function_return_type<KE::half_t, KE::half_t> { using type = KE::half_t; };
+template <> struct math_binary_function_return_type<short, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned short, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<int, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned int, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<long, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned long, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<long long, KE::half_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned long long, KE::half_t> { using type = double; };
+#endif // defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+template <> struct math_binary_function_return_type<KE::bhalf_t, KE::bhalf_t> { using type = KE::bhalf_t; };
+template <> struct math_binary_function_return_type<KE::half_t, KE::bhalf_t> { using type = KE::half_t; };
+template <> struct math_binary_function_return_type<short, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned short, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<int, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned int, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<long, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned long, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<long long, KE::bhalf_t> { using type = double; };
+template <> struct math_binary_function_return_type<unsigned long long, KE::bhalf_t> { using type = double; };
+#endif // defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
 template <> struct math_binary_function_return_type<             float,              float> { using type =       float; };
 template <> struct math_binary_function_return_type<             float,             double> { using type =      double; };
 template <> struct math_binary_function_return_type<             float,               bool> { using type =      double; };
@@ -200,11 +239,39 @@ struct FloatingPointComparison {
   KOKKOS_FUNCTION double eps(T) const {
     return DBL_EPSILON;
   }
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+  KOKKOS_FUNCTION
+  KE::half_t eps(KE::half_t) const {
+// FIXME_NVHPC compile-time error
+#ifdef KOKKOS_COMPILER_NVHPC
+    return 0.0009765625F;
+#else
+    return KE::epsilon<KE::half_t>::value;
+#endif
+  }
+#endif
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+  KOKKOS_FUNCTION
+  KE::bhalf_t eps(KE::bhalf_t) const {
+// FIXME_NVHPC compile-time error
+#ifdef KOKKOS_COMPILER_NVHPC
+    return 0.0078125;
+#else
+    return KE::epsilon<KE::bhalf_t>::value;
+#endif
+  }
+#endif
   KOKKOS_FUNCTION
   double eps(float) const { return FLT_EPSILON; }
+// POWER9 gives unexpected values with LDBL_EPSILON issues
+// https://stackoverflow.com/questions/68960416/ppc64-long-doubles-machine-epsilon-calculation
+#if defined(KOKKOS_ARCH_POWER9) || defined(KOKKOS_ARCH_POWER8)
+  KOKKOS_FUNCTION
+  double eps(long double) const { return DBL_EPSILON; }
+#else
   KOKKOS_FUNCTION
   double eps(long double) const { return LDBL_EPSILON; }
-
+#endif
   // Using absolute here instead of abs, since we actually test abs ...
   template <class T>
   KOKKOS_FUNCTION std::enable_if_t<std::is_signed<T>::value, T> absolute(
@@ -220,22 +287,20 @@ struct FloatingPointComparison {
 
  public:
   template <class FPT>
-  KOKKOS_FUNCTION bool compare_near_zero(FPT const& fpv, double ulp) const {
+  KOKKOS_FUNCTION bool compare_near_zero(FPT const& fpv, int ulp) const {
     auto abs_tol = eps(fpv) * ulp;
 
     bool ar = absolute(fpv) < abs_tol;
     if (!ar) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "absolute value exceeds tolerance [|%e| > %e]\n", (double)fpv,
-          abs_tol);
+      Kokkos::printf("absolute value exceeds tolerance [|%e| > %e]\n",
+                     (double)fpv, (double)abs_tol);
     }
 
     return ar;
   }
 
   template <class Lhs, class Rhs>
-  KOKKOS_FUNCTION bool compare(Lhs const& lhs, Rhs const& rhs,
-                               double ulp) const {
+  KOKKOS_FUNCTION bool compare(Lhs const& lhs, Rhs const& rhs, int ulp) const {
     if (lhs == 0) {
       return compare_near_zero(rhs, ulp);
     } else if (rhs == 0) {
@@ -248,9 +313,8 @@ struct FloatingPointComparison {
       double rel_diff = abs_diff / min_denom;
       bool ar         = abs_diff == 0 || rel_diff < rel_tol;
       if (!ar) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-            "relative difference exceeds tolerance [%e > %e]\n",
-            (double)rel_diff, rel_tol);
+        Kokkos::printf("relative difference exceeds tolerance [%e > %e]\n",
+                       (double)rel_diff, (double)rel_tol);
       }
 
       return ar;
@@ -261,29 +325,35 @@ struct FloatingPointComparison {
 template <class>
 struct math_function_name;
 
-#define DEFINE_UNARY_FUNCTION_EVAL(FUNC, ULP_FACTOR)                  \
-  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(std::FUNC((T)0)),                     \
-                       math_unary_function_return_type_t<T>>::value); \
-      return std::FUNC(x);                                            \
-    }                                                                 \
-    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;                             \
-  };                                                                  \
+#define DEFINE_UNARY_FUNCTION_EVAL(FUNC, ULP_FACTOR)                    \
+  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) {                                         \
+      if constexpr (std::is_same<T, KE::half_t>::value ||               \
+                    std::is_same<T, KE::bhalf_t>::value) {              \
+        return std::FUNC(static_cast<float>(x));                        \
+      } else {                                                          \
+        static_assert(                                                  \
+            std::is_same<decltype(std::FUNC((T)0)),                     \
+                         math_unary_function_return_type_t<T>>::value); \
+        return std::FUNC(x);                                            \
+      }                                                                 \
+      MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE                           \
+    }                                                                   \
+    static KOKKOS_FUNCTION int 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[]
 
 #define DEFINE_UNARY_FUNCTION_EVAL_CUSTOM(FUNC, ULP_FACTOR, REF_FUNC) \
@@ -302,7 +372,7 @@ struct math_function_name;
                        math_unary_function_return_type_t<T>>::value); \
       return REF_FUNC;                                                \
     }                                                                 \
-    static KOKKOS_FUNCTION double ulp_factor() { return ULP_FACTOR; } \
+    static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; }    \
   };                                                                  \
   using kk_##FUNC = MathUnaryFunction_##FUNC;                         \
   template <>                                                         \
@@ -316,12 +386,7 @@ struct math_function_name;
 // https://www.gnu.org/software/libc/manual/html_node/Errors-in-Math-Functions.html
 // For now 1s largely seem to work ...
 DEFINE_UNARY_FUNCTION_EVAL(exp, 2);
-#ifdef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC exp2 not device callable,
-                              // workaround computes it via exp
-DEFINE_UNARY_FUNCTION_EVAL(exp2, 30);
-#else
 DEFINE_UNARY_FUNCTION_EVAL(exp2, 2);
-#endif
 DEFINE_UNARY_FUNCTION_EVAL(expm1, 2);
 DEFINE_UNARY_FUNCTION_EVAL(log, 2);
 DEFINE_UNARY_FUNCTION_EVAL(log10, 2);
@@ -329,10 +394,12 @@ DEFINE_UNARY_FUNCTION_EVAL(log2, 2);
 DEFINE_UNARY_FUNCTION_EVAL(log1p, 2);
 #endif
 
-#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
 DEFINE_UNARY_FUNCTION_EVAL(sqrt, 2);
 DEFINE_UNARY_FUNCTION_EVAL(cbrt, 2);
+#endif
 
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
 DEFINE_UNARY_FUNCTION_EVAL(sin, 2);
 DEFINE_UNARY_FUNCTION_EVAL(cos, 2);
 DEFINE_UNARY_FUNCTION_EVAL(tan, 2);
@@ -380,36 +447,47 @@ DEFINE_UNARY_FUNCTION_EVAL(logb, 2);
 
 #undef DEFINE_UNARY_FUNCTION_EVAL
 
-#define DEFINE_BINARY_FUNCTION_EVAL(FUNC, ULP_FACTOR)                     \
-  struct MathBinaryFunction_##FUNC {                                      \
-    template <typename T, typename U>                                     \
-    static KOKKOS_FUNCTION auto eval(T x, U y) {                          \
-      static_assert(                                                      \
-          std::is_same<decltype(Kokkos::FUNC((T)0, (U)0)),                \
-                       math_binary_function_return_type_t<T, U>>::value); \
-      return Kokkos::FUNC(x, y);                                          \
-    }                                                                     \
-    template <typename T, typename U>                                     \
-    static auto eval_std(T x, U y) {                                      \
-      static_assert(                                                      \
-          std::is_same<decltype(std::FUNC((T)0, (U)0)),                   \
-                       math_binary_function_return_type_t<T, U>>::value); \
-      return std::FUNC(x, y);                                             \
-    }                                                                     \
-    static KOKKOS_FUNCTION double ulp_factor() { return ULP_FACTOR; }     \
-  };                                                                      \
-  using kk_##FUNC = MathBinaryFunction_##FUNC;                            \
-  template <>                                                             \
-  struct math_function_name<MathBinaryFunction_##FUNC> {                  \
-    static constexpr char name[] = #FUNC;                                 \
-  };                                                                      \
+#define DEFINE_BINARY_FUNCTION_EVAL(FUNC, ULP_FACTOR)                          \
+  struct MathBinaryFunction_##FUNC {                                           \
+    template <typename T, typename U>                                          \
+    static KOKKOS_FUNCTION auto eval(T x, U y) {                               \
+      static_assert(                                                           \
+          std::is_same<decltype(Kokkos::FUNC((T)0, (U)0)),                     \
+                       math_binary_function_return_type_t<T, U>>::value);      \
+      return Kokkos::FUNC(x, y);                                               \
+    }                                                                          \
+    template <typename T, typename U>                                          \
+    static auto eval_std(T x, U y) {                                           \
+      constexpr bool const x_is_half =                                         \
+          (KE::Impl::is_float16<T>::value || KE::Impl::is_bfloat16<T>::value); \
+      constexpr bool const y_is_half =                                         \
+          (KE::Impl::is_float16<U>::value || KE::Impl::is_bfloat16<U>::value); \
+      if constexpr (x_is_half && y_is_half)                                    \
+        return std::FUNC(static_cast<float>(x), static_cast<float>(y));        \
+      else if constexpr (x_is_half)                                            \
+        return std::FUNC(static_cast<float>(x), y);                            \
+      else if constexpr (y_is_half)                                            \
+        return std::FUNC(x, static_cast<float>(y));                            \
+      else {                                                                   \
+        static_assert(                                                         \
+            std::is_same<decltype(std::FUNC((T)0, (U)0)),                      \
+                         math_binary_function_return_type_t<T, U>>::value);    \
+        return std::FUNC(x, y);                                                \
+      }                                                                        \
+      MATHEMATICAL_FUNCTIONS_TEST_UNREACHABLE                                  \
+    }                                                                          \
+    static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; }             \
+  };                                                                           \
+  using kk_##FUNC = MathBinaryFunction_##FUNC;                                 \
+  template <>                                                                  \
+  struct math_function_name<MathBinaryFunction_##FUNC> {                       \
+    static constexpr char name[] = #FUNC;                                      \
+  };                                                                           \
   constexpr char math_function_name<MathBinaryFunction_##FUNC>::name[]
 
-#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
 DEFINE_BINARY_FUNCTION_EVAL(pow, 2);
 DEFINE_BINARY_FUNCTION_EVAL(hypot, 2);
-#endif
-#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
 DEFINE_BINARY_FUNCTION_EVAL(nextafter, 1);
 DEFINE_BINARY_FUNCTION_EVAL(copysign, 1);
 #endif
@@ -432,7 +510,7 @@ DEFINE_BINARY_FUNCTION_EVAL(copysign, 1);
                        math_ternary_function_return_type_t<T, U, V>>::value); \
       return std::FUNC(x, y, z);                                              \
     }                                                                         \
-    static KOKKOS_FUNCTION double ulp_factor() { return ULP_FACTOR; }         \
+    static KOKKOS_FUNCTION int ulp_factor() { return ULP_FACTOR; }            \
   };                                                                          \
   using kk3_##FUNC = MathTernaryFunction_##FUNC;                              \
   template <>                                                                 \
@@ -441,7 +519,7 @@ DEFINE_BINARY_FUNCTION_EVAL(copysign, 1);
   };                                                                          \
   constexpr char math_function_name<MathTernaryFunction_##FUNC>::name[]
 
-#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_1
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
 DEFINE_TERNARY_FUNCTION_EVAL(hypot, 2);
 DEFINE_TERNARY_FUNCTION_EVAL(fma, 2);
 #endif
@@ -460,6 +538,12 @@ DEFINE_TYPE_NAME(long long)
 DEFINE_TYPE_NAME(unsigned int)
 DEFINE_TYPE_NAME(unsigned long)
 DEFINE_TYPE_NAME(unsigned long long)
+#if defined(KOKKOS_HALF_T_IS_FLOAT) && !KOKKOS_HALF_T_IS_FLOAT
+DEFINE_TYPE_NAME(KE::half_t)
+#endif
+#if defined(KOKKOS_BHALF_T_IS_FLOAT) && !KOKKOS_BHALF_T_IS_FLOAT
+DEFINE_TYPE_NAME(KE::bhalf_t)
+#endif
 DEFINE_TYPE_NAME(float)
 DEFINE_TYPE_NAME(double)
 DEFINE_TYPE_NAME(long double)
@@ -488,9 +572,9 @@ struct TestMathUnaryFunction : FloatingPointComparison {
     bool ar = compare(Func::eval(val_[i]), res_[i], Func::ulp_factor());
     if (!ar) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "value at %f which is %f was expected to be %f\n", (double)val_[i],
-          (double)Func::eval(val_[i]), (double)res_[i]);
+      Kokkos::printf("value at %f which is %f was expected to be %f\n",
+                     (double)val_[i], (double)Func::eval(val_[i]),
+                     (double)res_[i]);
     }
   }
 };
@@ -511,6 +595,24 @@ void do_test_math_unary_function(const Arg (&x)[N]) {
 #define TEST_MATH_FUNCTION(FUNC) \
   do_test_math_unary_function<TEST_EXECSPACE, MathUnaryFunction_##FUNC>
 
+template <class Half, class Space, class... Func, class Arg, std::size_t N>
+void do_test_half_math_unary_function(const Arg (&x)[N]) {
+  Half y[N];
+  std::copy(x, x + N, y);  // cast to array of half type
+  (void)std::initializer_list<int>{
+      (TestMathUnaryFunction<Space, Func, Half, N>(y), 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, Half, N>(
+            y),
+        0)...};
+}
+
+#define TEST_HALF_MATH_FUNCTION(FUNC, T) \
+  do_test_half_math_unary_function<T, TEST_EXECSPACE, MathUnaryFunction_##FUNC>
+
 template <class Space, class Func, class Arg1, class Arg2,
           class Ret = math_binary_function_return_type_t<Arg1, Arg2>>
 struct TestMathBinaryFunction : FloatingPointComparison {
@@ -533,9 +635,9 @@ struct TestMathBinaryFunction : FloatingPointComparison {
     bool ar = compare(Func::eval(val1_, val2_), res_, Func::ulp_factor());
     if (!ar) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "value at %f, %f which is %f was expected to be %f\n", (double)val1_,
-          (double)val2_, (double)Func::eval(val1_, val2_), (double)res_);
+      Kokkos::printf("value at %f, %f which is %f was expected to be %f\n",
+                     (double)val1_, (double)val2_,
+                     (double)Func::eval(val1_, val2_), (double)res_);
     }
   }
 };
@@ -574,10 +676,9 @@ struct TestMathTernaryFunction : FloatingPointComparison {
         compare(Func::eval(val1_, val2_, val3_), res_, Func::ulp_factor());
     if (!ar) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "value at %f, %f, %f which is %f was expected to be %f\n",
-          (double)val1_, (double)val2_, (double)val3_,
-          (double)Func::eval(val1_, val2_, val3_), (double)res_);
+      Kokkos::printf("value at %f, %f, %f which is %f was expected to be %f\n",
+                     (double)val1_, (double)val2_, (double)val3_,
+                     (double)Func::eval(val1_, val2_, val3_), (double)res_);
     }
   }
 };
@@ -599,6 +700,8 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
   TEST_MATH_FUNCTION(sin)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(sin)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(sin)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(sin, KE::half_t)({.1f, .2f, .3f});
+  TEST_HALF_MATH_FUNCTION(sin, KE::bhalf_t)({.1f, .2f, .3f});
   TEST_MATH_FUNCTION(sin)({.1f, .2f, .3f});
   TEST_MATH_FUNCTION(sin)({.4, .5, .6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -612,6 +715,8 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
   TEST_MATH_FUNCTION(cos)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(cos)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(cos)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(cos, KE::half_t)({.1f, .2f, .3f});
+  TEST_HALF_MATH_FUNCTION(cos, KE::bhalf_t)({.1f, .2f, .3f});
   TEST_MATH_FUNCTION(cos)({.1f, .2f, .3f});
   TEST_MATH_FUNCTION(cos)({.4, .5, .6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -625,6 +730,8 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
   TEST_MATH_FUNCTION(tan)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(tan)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(tan)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(tan, KE::half_t)({.1f, .2f, .3f});
+  TEST_HALF_MATH_FUNCTION(tan, KE::bhalf_t)({.1f, .2f, .3f});
   TEST_MATH_FUNCTION(tan)({.1f, .2f, .3f});
   TEST_MATH_FUNCTION(tan)({.4, .5, .6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -638,6 +745,8 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
   TEST_MATH_FUNCTION(asin)({0u, 1u});
   TEST_MATH_FUNCTION(asin)({0ul, 1ul});
   TEST_MATH_FUNCTION(asin)({0ull, 1ull});
+  TEST_HALF_MATH_FUNCTION(asin, KE::half_t)({-1.f, .9f, -.8f, .7f, -.6f});
+  TEST_HALF_MATH_FUNCTION(asin, KE::bhalf_t)({-1.f, .9f, -.8f, .7f, -.6f});
   TEST_MATH_FUNCTION(asin)({-1.f, .9f, -.8f, .7f, -.6f});
   TEST_MATH_FUNCTION(asin)({-.5, .4, -.3, .2, -.1, 0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -651,6 +760,8 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
   TEST_MATH_FUNCTION(acos)({0u, 1u});
   TEST_MATH_FUNCTION(acos)({0ul, 1ul});
   TEST_MATH_FUNCTION(acos)({0ull, 1ull});
+  TEST_HALF_MATH_FUNCTION(acos, KE::half_t)({-1.f, .9f, -.8f, .7f, -.6f});
+  TEST_HALF_MATH_FUNCTION(acos, KE::bhalf_t)({-1.f, .9f, -.8f, .7f, -.6f});
   TEST_MATH_FUNCTION(acos)({-1.f, .9f, -.8f, .7f, -.6f});
   TEST_MATH_FUNCTION(acos)({-.5, .4, -.3, .2, -.1, 0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -664,6 +775,10 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
   TEST_MATH_FUNCTION(atan)({0u, 1u});
   TEST_MATH_FUNCTION(atan)({0ul, 1ul});
   TEST_MATH_FUNCTION(atan)({0ull, 1ull});
+  TEST_HALF_MATH_FUNCTION(atan, KE::half_t)
+  ({-1.5f, 1.3f, -1.1f, .9f, -.7f, .5f});
+  TEST_HALF_MATH_FUNCTION(atan, KE::bhalf_t)
+  ({-1.5f, 1.3f, -1.1f, .9f, -.7f, .5f});
   TEST_MATH_FUNCTION(atan)({-1.5f, 1.3f, -1.1f, .9f, -.7f, .5f});
   TEST_MATH_FUNCTION(atan)({1.4, -1.2, 1., -.8, .6, -.4, .2, -0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -672,7 +787,9 @@ TEST(TEST_CATEGORY, mathematical_functions_trigonometric_functions) {
 
   // TODO atan2
 }
+#endif
 
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
 TEST(TEST_CATEGORY, mathematical_functions_power_functions) {
   TEST_MATH_FUNCTION(sqrt)({0, 1, 2, 3, 5, 7, 11});
   TEST_MATH_FUNCTION(sqrt)({0l, 1l, 2l, 3l, 5l, 7l, 11l});
@@ -680,6 +797,8 @@ TEST(TEST_CATEGORY, mathematical_functions_power_functions) {
   TEST_MATH_FUNCTION(sqrt)({0u, 1u, 2u, 3u, 5u, 7u});
   TEST_MATH_FUNCTION(sqrt)({0ul, 1ul, 2ul, 3ul, 5ul, 7ul});
   TEST_MATH_FUNCTION(sqrt)({0ull, 1ull, 2ull, 3ull, 5ull, 7ull});
+  TEST_HALF_MATH_FUNCTION(sqrt, KE::half_t)({10.f, 20.f, 30.f, 40.f});
+  TEST_HALF_MATH_FUNCTION(sqrt, KE::bhalf_t)({10.f, 20.f, 30.f, 40.f});
   TEST_MATH_FUNCTION(sqrt)({10.f, 20.f, 30.f, 40.f});
   TEST_MATH_FUNCTION(sqrt)({11.1, 22.2, 33.3, 44.4});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -692,18 +811,29 @@ TEST(TEST_CATEGORY, mathematical_functions_power_functions) {
   TEST_MATH_FUNCTION(cbrt)({0u, 1u, 2u, 3u, 4u, 5u});
   TEST_MATH_FUNCTION(cbrt)({0ul, 1ul, 2ul, 3ul, 4ul, 5ul});
   TEST_MATH_FUNCTION(cbrt)({0ull, 1ull, 2ull, 3ull, 4ull, 5ull});
+  TEST_HALF_MATH_FUNCTION(cbrt, KE::half_t)({-1.f, .2f, -3.f, .4f, -5.f});
+  TEST_HALF_MATH_FUNCTION(cbrt, KE::bhalf_t)({-1.f, .2f, -3.f, .4f, -5.f});
   TEST_MATH_FUNCTION(cbrt)({-1.f, .2f, -3.f, .4f, -5.f});
   TEST_MATH_FUNCTION(cbrt)({11.1, -2.2, 33.3, -4.4, 55.5});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
   TEST_MATH_FUNCTION(cbrt)({-10.l, 20.l, -30.l, 40.l, -50.l});
 #endif
 
+  do_test_math_binary_function<TEST_EXECSPACE, kk_pow>(
+      static_cast<KE::half_t>(2.f), static_cast<KE::half_t>(3.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_pow>(
+      static_cast<KE::bhalf_t>(2.f), static_cast<KE::bhalf_t>(3.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_pow>(2.f, 3.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_pow>(2.f, 3.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_pow>(2., 3.);
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
   do_test_math_binary_function<TEST_EXECSPACE, kk_pow>(2.l, 3.l);
 #endif
 
+  do_test_math_binary_function<TEST_EXECSPACE, kk_hypot>(
+      static_cast<KE::half_t>(2.f), static_cast<KE::half_t>(3.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_hypot>(
+      static_cast<KE::bhalf_t>(2.f), static_cast<KE::bhalf_t>(3.f));
   do_test_math_binary_function<TEST_EXECSPACE, kk_hypot>(2.f, 3.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_hypot>(2., 3.);
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -741,6 +871,10 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(exp)({0u, 1u, 2u, 3u, 4u, 5u});
   TEST_MATH_FUNCTION(exp)({0ul, 1ul, 2ul, 3ul, 4ul, 5ul});
   TEST_MATH_FUNCTION(exp)({0ull, 1ull, 2ull, 3ull, 4ull, 5ull});
+  TEST_HALF_MATH_FUNCTION(exp, KE::half_t)
+  ({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
+  TEST_HALF_MATH_FUNCTION(exp, KE::bhalf_t)
+  ({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
   TEST_MATH_FUNCTION(exp)({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
   TEST_MATH_FUNCTION(exp)({-98., -7.6, -.54, 3.2, 1., -0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -753,6 +887,10 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(exp2)({0u, 1u, 2u, 3u, 4u, 5u});
   TEST_MATH_FUNCTION(exp2)({0ul, 1ul, 2ul, 3ul, 4ul, 5ul});
   TEST_MATH_FUNCTION(exp2)({0ull, 1ull, 2ull, 3ull, 4ull, 5ull});
+  TEST_HALF_MATH_FUNCTION(exp2, KE::half_t)
+  ({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
+  TEST_HALF_MATH_FUNCTION(exp2, KE::bhalf_t)
+  ({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
   TEST_MATH_FUNCTION(exp2)({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
   TEST_MATH_FUNCTION(exp2)({-98., -7.6, -.54, 3.2, 1., -0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -765,6 +903,10 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(expm1)({0u, 1u, 2u, 3u, 4u, 5u});
   TEST_MATH_FUNCTION(expm1)({0ul, 1ul, 2ul, 3ul, 4ul, 5ul});
   TEST_MATH_FUNCTION(expm1)({0ull, 1ull, 2ull, 3ull, 4ull, 5ull});
+  TEST_HALF_MATH_FUNCTION(expm1, KE::half_t)
+  ({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
+  TEST_HALF_MATH_FUNCTION(expm1, KE::bhalf_t)
+  ({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
   TEST_MATH_FUNCTION(expm1)({-98.f, -7.6f, -.54f, 3.2f, 1.f, -0.f});
   TEST_MATH_FUNCTION(expm1)({-98., -7.6, -.54, 3.2, 1., -0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -777,6 +919,8 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(log)({1u, 23u, 456u, 7890u});
   TEST_MATH_FUNCTION(log)({1ul, 23ul, 456ul, 7890ul});
   TEST_MATH_FUNCTION(log)({1ull, 23ull, 456ull, 7890ull});
+  TEST_HALF_MATH_FUNCTION(log, KE::half_t)({1234.f, 567.f, 89.f, .1f});
+  TEST_HALF_MATH_FUNCTION(log, KE::bhalf_t)({1234.f, 567.f, 89.f, .1f});
   TEST_MATH_FUNCTION(log)({1234.f, 567.f, 89.f, .1f});
   TEST_MATH_FUNCTION(log)({1234., 567., 89., .02});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -789,6 +933,8 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(log10)({1u, 23u, 456u, 7890u});
   TEST_MATH_FUNCTION(log10)({1ul, 23ul, 456ul, 7890ul});
   TEST_MATH_FUNCTION(log10)({1ull, 23ull, 456ull, 7890ull});
+  TEST_HALF_MATH_FUNCTION(log10, KE::half_t)({1234.f, 567.f, 89.f, .1f});
+  TEST_HALF_MATH_FUNCTION(log10, KE::bhalf_t)({1234.f, 567.f, 89.f, .1f});
   TEST_MATH_FUNCTION(log10)({1234.f, 567.f, 89.f, .1f});
   TEST_MATH_FUNCTION(log10)({1234., 567., 89., .02});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -796,9 +942,9 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
 #endif
 
 // FIXME_OPENMPTARGET FIXME_AMD
-#if defined(KOKKOS_ENABLE_OPENMPTARGET) &&                           \
-    (defined(KOKKOS_ARCH_VEGA906) || defined(KOKKOS_ARCH_VEGA908) || \
-     defined(KOKKOS_ARCH_VEGA90A))
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) &&                                 \
+    (defined(KOKKOS_ARCH_AMD_GFX906) || defined(KOKKOS_ARCH_AMD_GFX908) || \
+     defined(KOKKOS_ARCH_AMD_GFX90A) || defined(KOKKOS_ARCH_AMD_GFX942))
 
   TEST_MATH_FUNCTION(log2)({1, 23, 456, 7890});
 #endif
@@ -807,6 +953,8 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(log2)({1u, 23u, 456u, 7890u});
   TEST_MATH_FUNCTION(log2)({1ul, 23ul, 456ul, 7890ul});
   TEST_MATH_FUNCTION(log2)({1ull, 23ull, 456ull, 7890ull});
+  TEST_HALF_MATH_FUNCTION(log2, KE::half_t)({1234.f, 567.f, 89.f, .1f});
+  TEST_HALF_MATH_FUNCTION(log2, KE::bhalf_t)({1234.f, 567.f, 89.f, .1f});
   TEST_MATH_FUNCTION(log2)({1234.f, 567.f, 89.f, .1f});
   TEST_MATH_FUNCTION(log2)({1234., 567., 89., .02});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -819,6 +967,8 @@ TEST(TEST_CATEGORY, mathematical_functions_exponential_functions) {
   TEST_MATH_FUNCTION(log1p)({1u, 23u, 456u, 7890u, 0u});
   TEST_MATH_FUNCTION(log1p)({1ul, 23ul, 456ul, 7890ul, 0ul});
   TEST_MATH_FUNCTION(log1p)({1ull, 23ull, 456ull, 7890ull, 0ull});
+  TEST_HALF_MATH_FUNCTION(log1p, KE::half_t)({1234.f, 567.f, 89.f, -.9f});
+  TEST_HALF_MATH_FUNCTION(log1p, KE::bhalf_t)({1234.f, 567.f, 89.f, -.9f});
   TEST_MATH_FUNCTION(log1p)({1234.f, 567.f, 89.f, -.9f});
   TEST_MATH_FUNCTION(log1p)({1234., 567., 89., -.08});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -835,6 +985,8 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(sinh)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(sinh)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(sinh)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(sinh, KE::half_t)({.1f, -2.f, 3.f});
+  TEST_HALF_MATH_FUNCTION(sinh, KE::bhalf_t)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(sinh)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(sinh)({-4., .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -847,6 +999,8 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(cosh)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(cosh)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(cosh)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(cosh, KE::half_t)({.1f, -2.f, 3.f});
+  TEST_HALF_MATH_FUNCTION(cosh, KE::bhalf_t)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(cosh)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(cosh)({-4., .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -859,6 +1013,8 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(tanh)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(tanh)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(tanh)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(tanh, KE::half_t)({.1f, -2.f, 3.f});
+  TEST_HALF_MATH_FUNCTION(tanh, KE::bhalf_t)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(tanh)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(tanh)({-4., .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -871,6 +1027,8 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(asinh)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(asinh)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(asinh)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(asinh, KE::half_t)({.1f, -2.f, 3.f});
+  TEST_HALF_MATH_FUNCTION(asinh, KE::bhalf_t)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(asinh)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(asinh)({-4., .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -883,6 +1041,8 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(acosh)({1u, 2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(acosh)({1ul, 2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(acosh)({1ull, 2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(acosh, KE::half_t)({1.2f, 34.f, 56.f, 789.f});
+  TEST_HALF_MATH_FUNCTION(acosh, KE::bhalf_t)({1.2f, 34.f, 56.f, 789.f});
   TEST_MATH_FUNCTION(acosh)({1.2f, 34.f, 56.f, 789.f});
   TEST_MATH_FUNCTION(acosh)({1.2, 34., 56., 789.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -895,6 +1055,10 @@ TEST(TEST_CATEGORY, mathematical_functions_hyperbolic_functions) {
   TEST_MATH_FUNCTION(atanh)({0u});
   TEST_MATH_FUNCTION(atanh)({0ul});
   TEST_MATH_FUNCTION(atanh)({0ull});
+  TEST_HALF_MATH_FUNCTION(atanh, KE::half_t)
+  ({-.97f, .86f, -.53f, .42f, -.1f, 0.f});
+  TEST_HALF_MATH_FUNCTION(atanh, KE::bhalf_t)
+  ({-.97f, .86f, -.53f, .42f, -.1f, 0.f});
   TEST_MATH_FUNCTION(atanh)({-.97f, .86f, -.53f, .42f, -.1f, 0.f});
   TEST_MATH_FUNCTION(atanh)({-.97, .86, -.53, .42, -.1, 0.});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -926,6 +1090,8 @@ TEST(TEST_CATEGORY, mathematical_functions_error_and_gamma_functions) {
   TEST_MATH_FUNCTION(erf)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(erf)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(erf)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(erf, KE::half_t)({.1f, -2.f, 3.f});
+  TEST_HALF_MATH_FUNCTION(erf, KE::bhalf_t)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(erf)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(erf)({-4., .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -938,6 +1104,8 @@ TEST(TEST_CATEGORY, mathematical_functions_error_and_gamma_functions) {
   TEST_MATH_FUNCTION(erfc)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(erfc)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(erfc)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(erfc, KE::half_t)({.1f, -2.f, 3.f});
+  TEST_HALF_MATH_FUNCTION(erfc, KE::bhalf_t)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(erfc)({.1f, -2.f, 3.f});
   TEST_MATH_FUNCTION(erfc)({-4., .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -950,6 +1118,8 @@ TEST(TEST_CATEGORY, mathematical_functions_error_and_gamma_functions) {
   TEST_MATH_FUNCTION(tgamma)({1u, 2u, 3u, 4u, 56u, 78u});
   TEST_MATH_FUNCTION(tgamma)({1ul, 2ul, 3ul, 4ul, 56ul, 78ul});
   TEST_MATH_FUNCTION(tgamma)({1ull, 2ull, 3ull, 4ull, 56ull, 78ull});
+  TEST_HALF_MATH_FUNCTION(tgamma, KE::half_t)({.1f, -2.2f, 3.f});
+  TEST_HALF_MATH_FUNCTION(tgamma, KE::bhalf_t)({.1f, -2.2f, 3.f});
   TEST_MATH_FUNCTION(tgamma)({.1f, -2.2f, 3.f});
   TEST_MATH_FUNCTION(tgamma)({-4.4, .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -962,6 +1132,8 @@ TEST(TEST_CATEGORY, mathematical_functions_error_and_gamma_functions) {
   TEST_MATH_FUNCTION(lgamma)({1u, 2u, 3u, 4u, 56u, 78u});
   TEST_MATH_FUNCTION(lgamma)({1ul, 2ul, 3ul, 4ul, 56ul, 78ul});
   TEST_MATH_FUNCTION(lgamma)({1ull, 2ull, 3ull, 4ull, 56ull, 78ull});
+  TEST_HALF_MATH_FUNCTION(lgamma, KE::half_t)({.1f, -2.2f, 3.f});
+  TEST_HALF_MATH_FUNCTION(lgamma, KE::bhalf_t)({.1f, -2.2f, 3.f});
   TEST_MATH_FUNCTION(lgamma)({.1f, -2.2f, 3.f});
   TEST_MATH_FUNCTION(lgamma)({-4.4, .5, -.6});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -977,6 +1149,8 @@ TEST(TEST_CATEGORY,
   TEST_MATH_FUNCTION(ceil)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(ceil)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(ceil)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(ceil, KE::half_t)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
+  TEST_HALF_MATH_FUNCTION(ceil, KE::bhalf_t)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(ceil)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(ceil)({-6.6, 7.7, -8.8, 9.9});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -989,6 +1163,9 @@ TEST(TEST_CATEGORY,
   TEST_MATH_FUNCTION(floor)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(floor)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(floor)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(floor, KE::half_t)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
+  TEST_HALF_MATH_FUNCTION(floor, KE::bhalf_t)
+  ({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(floor)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(floor)({-6.6, 7.7, -8.8, 9.9});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -1001,6 +1178,9 @@ TEST(TEST_CATEGORY,
   TEST_MATH_FUNCTION(trunc)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(trunc)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(trunc)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(trunc, KE::half_t)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
+  TEST_HALF_MATH_FUNCTION(trunc, KE::bhalf_t)
+  ({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(trunc)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(trunc)({-6.6, 7.7, -8.8, 9.9});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -1013,6 +1193,10 @@ TEST(TEST_CATEGORY,
   TEST_MATH_FUNCTION(round)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(round)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(round)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(round, KE::half_t)
+  ({2.3f, 2.5f, 2.7f, -2.3f, -2.5f, -2.7f, -0.0f});
+  TEST_HALF_MATH_FUNCTION(round, KE::bhalf_t)
+  ({2.3f, 2.5f, 2.7f, -2.3f, -2.5f, -2.7f, -0.0f});
   TEST_MATH_FUNCTION(round)({2.3f, 2.5f, 2.7f, -2.3f, -2.5f, -2.7f, -0.0f});
   TEST_MATH_FUNCTION(round)({2.3, 2.5, 2.7, -2.3, -2.5, -2.7, -0.0});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -1026,6 +1210,10 @@ TEST(TEST_CATEGORY,
   TEST_MATH_FUNCTION(nearbyint)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(nearbyint)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(nearbyint)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(nearbyint, KE::half_t)
+  ({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
+  TEST_HALF_MATH_FUNCTION(nearbyint, KE::bhalf_t)
+  ({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(nearbyint)({-1.1f, 2.2f, -3.3f, 4.4f, -5.5f});
   TEST_MATH_FUNCTION(nearbyint)({-6.6, 7.7, -8.8, 9.9});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
@@ -1042,12 +1230,22 @@ TEST(TEST_CATEGORY,
   TEST_MATH_FUNCTION(logb)({2u, 3u, 4u, 5u, 6u});
   TEST_MATH_FUNCTION(logb)({2ul, 3ul, 4ul, 5ul, 6ul});
   TEST_MATH_FUNCTION(logb)({2ull, 3ull, 4ull, 5ull, 6ull});
+  TEST_HALF_MATH_FUNCTION(logb, KE::half_t)({123.45f, 6789.0f});
+  TEST_HALF_MATH_FUNCTION(logb, KE::bhalf_t)({123.45f, 6789.0f});
   TEST_MATH_FUNCTION(logb)({123.45f, 6789.0f});
   TEST_MATH_FUNCTION(logb)({123.45, 6789.0});
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
   TEST_MATH_FUNCTION(logb)({123.45l, 6789.0l});
 #endif
 
+  do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(
+      0, static_cast<KE::half_t>(1.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(
+      1, static_cast<KE::half_t>(2.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(
+      0, static_cast<KE::bhalf_t>(1.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(
+      1, static_cast<KE::bhalf_t>(2.f));
   do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(0, 1.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(1, 2.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(0.1, 0);
@@ -1056,6 +1254,14 @@ TEST(TEST_CATEGORY,
   do_test_math_binary_function<TEST_EXECSPACE, kk_nextafter>(1.l, 2.l);
 #endif
 
+  do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(
+      0, static_cast<KE::half_t>(1.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(
+      1, static_cast<KE::half_t>(2.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(
+      0, static_cast<KE::bhalf_t>(1.f));
+  do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(
+      1, static_cast<KE::bhalf_t>(2.f));
   do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(0, 1.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(1, 2.f);
   do_test_math_binary_function<TEST_EXECSPACE, kk_copysign>(0.1, 0);
@@ -1083,28 +1289,38 @@ struct TestAbsoluteValueFunction {
     using Kokkos::abs;
     if (abs(1) != 1 || abs(-1) != 1) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed abs(int)\n");
+      Kokkos::printf("failed abs(int)\n");
     }
     if (abs(2l) != 2l || abs(-2l) != 2l) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed abs(long int)\n");
+      Kokkos::printf("failed abs(long int)\n");
     }
     if (abs(3ll) != 3ll || abs(-3ll) != 3ll) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed abs(long long int)\n");
+      Kokkos::printf("failed abs(long long int)\n");
     }
     if (abs(4.f) != 4.f || abs(-4.f) != 4.f) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed abs(float)\n");
+      Kokkos::printf("failed abs(float)\n");
+    }
+    if (abs(static_cast<KE::half_t>(4.f)) != static_cast<KE::half_t>(4.f) ||
+        abs(static_cast<KE::half_t>(-4.f)) != static_cast<KE::half_t>(4.f)) {
+      ++e;
+      Kokkos::printf("failed abs(KE::half_t)\n");
+    }
+    if (abs(static_cast<KE::bhalf_t>(4.f)) != static_cast<KE::bhalf_t>(4.f) ||
+        abs(static_cast<KE::bhalf_t>(-4.f)) != static_cast<KE::bhalf_t>(4.f)) {
+      ++e;
+      Kokkos::printf("failed abs(KE::bhalf_t)\n");
     }
     if (abs(5.) != 5. || abs(-5.) != 5.) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed abs(double)\n");
+      Kokkos::printf("failed abs(double)\n");
     }
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
     if (abs(6.l) != 6.l || abs(-6.l) != 6.l) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed abs(long double)\n");
+      Kokkos::printf("failed abs(long double)\n");
     }
 #endif
     // special values
@@ -1112,17 +1328,20 @@ struct TestAbsoluteValueFunction {
     using Kokkos::isnan;
     if (abs(-0.) != 0. || !isinf(abs(-INFINITY)) || !isnan(abs(-NAN))) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "failed abs(floating_point) special values\n");
+      Kokkos::printf("failed abs(floating_point) special values\n");
     }
 
-    static_assert(std::is_same<decltype(abs(1)), int>::value, "");
-    static_assert(std::is_same<decltype(abs(2l)), long>::value, "");
-    static_assert(std::is_same<decltype(abs(3ll)), long long>::value, "");
-    static_assert(std::is_same<decltype(abs(4.f)), float>::value, "");
-    static_assert(std::is_same<decltype(abs(5.)), double>::value, "");
+    static_assert(std::is_same<decltype(abs(1)), int>::value);
+    static_assert(std::is_same<decltype(abs(2l)), long>::value);
+    static_assert(std::is_same<decltype(abs(3ll)), long long>::value);
+    static_assert(std::is_same<decltype(abs(static_cast<KE::half_t>(4.f))),
+                               KE::half_t>::value);
+    static_assert(std::is_same<decltype(abs(static_cast<KE::bhalf_t>(4.f))),
+                               KE::bhalf_t>::value);
+    static_assert(std::is_same<decltype(abs(4.f)), float>::value);
+    static_assert(std::is_same<decltype(abs(5.)), double>::value);
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
-    static_assert(std::is_same<decltype(abs(6.l)), long double>::value, "");
+    static_assert(std::is_same<decltype(abs(6.l)), long double>::value);
 #endif
   }
 };
@@ -1131,6 +1350,360 @@ TEST(TEST_CATEGORY, mathematical_functions_absolute_value) {
   TestAbsoluteValueFunction<TEST_EXECSPACE>();
 }
 
+template <class Space>
+struct TestFloatingPointAbsoluteValueFunction {
+  TestFloatingPointAbsoluteValueFunction() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0);
+  }
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using Kokkos::fabs;
+    if (fabs(4.f) != 4.f || fabs(-4.f) != 4.f) {
+      ++e;
+      Kokkos::printf("failed fabs(float)\n");
+    }
+    if (fabs(static_cast<KE::half_t>(4.f)) != static_cast<KE::half_t>(4.f) ||
+        fabs(static_cast<KE::half_t>(-4.f)) != static_cast<KE::half_t>(4.f)) {
+      ++e;
+      Kokkos::printf("failed fabs(KE::half_t)\n");
+    }
+    if (fabs(static_cast<KE::bhalf_t>(4.f)) != static_cast<KE::bhalf_t>(4.f) ||
+        fabs(static_cast<KE::bhalf_t>(-4.f)) != static_cast<KE::bhalf_t>(4.f)) {
+      ++e;
+      Kokkos::printf("failed fabs(KE::bhalf_t)\n");
+    }
+    if (fabs(5.) != 5. || fabs(-5.) != 5.) {
+      ++e;
+      Kokkos::printf("failed fabs(double)\n");
+    }
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    if (fabs(6.l) != 6.l || fabs(-6.l) != 6.l) {
+      ++e;
+      Kokkos::printf("failed fabs(long double)\n");
+    }
+#endif
+    // special values
+    using Kokkos::isinf;
+    using Kokkos::isnan;
+    if (fabs(-0.) != 0. || !isinf(fabs(-INFINITY)) || !isnan(fabs(-NAN))) {
+      ++e;
+      Kokkos::printf("failed fabs(floating_point) special values\n");
+    }
+
+    static_assert(std::is_same<decltype(fabs(static_cast<KE::half_t>(4.f))),
+                               KE::half_t>::value);
+    static_assert(std::is_same<decltype(fabs(static_cast<KE::bhalf_t>(4.f))),
+                               KE::bhalf_t>::value);
+    static_assert(std::is_same<decltype(fabs(4.f)), float>::value);
+    static_assert(std::is_same<decltype(fabs(5.)), double>::value);
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    static_assert(std::is_same<decltype(fabs(6.l)), long double>::value);
+#endif
+  }
+};
+
+TEST(TEST_CATEGORY, mathematical_functions_floating_point_absolute_value) {
+  TestFloatingPointAbsoluteValueFunction<TEST_EXECSPACE>();
+}
+
+template <class Space>
+struct TestFloatingPointRemainderFunction : FloatingPointComparison {
+  TestFloatingPointRemainderFunction() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0);
+  }
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using Kokkos::fmod;
+    if (!compare(fmod(6.2f, 4.f), 2.2f, 1) &&
+        !compare(fmod(-6.2f, 4.f), -2.2f, 1)) {
+      ++e;
+      Kokkos::printf("failed fmod(float)\n");
+    }
+    if (!compare(
+            fmod(static_cast<KE::half_t>(6.2f), static_cast<KE::half_t>(4.f)),
+            static_cast<KE::half_t>(2.2f), 1) &&
+        !compare(
+            fmod(static_cast<KE::half_t>(-6.2f), static_cast<KE::half_t>(4.f)),
+            -static_cast<KE::half_t>(2.2f), 1)) {
+      ++e;
+      Kokkos::printf("failed fmod(KE::half_t)\n");
+    }
+    if (!compare(
+            fmod(static_cast<KE::bhalf_t>(6.2f), static_cast<KE::bhalf_t>(4.f)),
+            static_cast<KE::bhalf_t>(2.2f), 1) &&
+        !compare(fmod(static_cast<KE::bhalf_t>(-6.2f),
+                      static_cast<KE::bhalf_t>(4.f)),
+                 -static_cast<KE::bhalf_t>(2.2f), 1)) {
+      ++e;
+      Kokkos::printf("failed fmod(KE::bhalf_t)\n");
+    }
+    if (!compare(fmod(6.2, 4.), 2.2, 1) && !compare(fmod(-6.2, 4.), -2.2, 1)) {
+      ++e;
+      Kokkos::printf("failed fmod(double)\n");
+    }
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    if (!compare(fmod(6.2l, 4.l), 2.2l, 1) &&
+        !compare(fmod(-6.2l, 4.l), -2.2l, 1)) {
+      ++e;
+      Kokkos::printf("failed fmod(long double)\n");
+    }
+#endif
+    // special values
+    using Kokkos::isinf;
+    using Kokkos::isnan;
+    if (!isinf(fmod(-KE::infinity<float>::value, 1.f)) &&
+        !isnan(fmod(-KE::quiet_NaN<float>::value, 1.f))) {
+      ++e;
+      Kokkos::printf("failed fmod(floating_point) special values\n");
+    }
+
+    static_assert(std::is_same<decltype(fmod(static_cast<KE::half_t>(4.f),
+                                             static_cast<KE::half_t>(4.f))),
+                               KE::half_t>::value);
+    static_assert(std::is_same<decltype(fmod(static_cast<KE::bhalf_t>(4.f),
+                                             static_cast<KE::bhalf_t>(4.f))),
+                               KE::bhalf_t>::value);
+    static_assert(std::is_same<decltype(fmod(4.f, 4.f)), float>::value);
+    static_assert(std::is_same<decltype(fmod(5., 5.)), double>::value);
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    static_assert(std::is_same<decltype(fmod(6.l, 6.l)), long double>::value);
+#endif
+  }
+};
+
+TEST(TEST_CATEGORY, mathematical_functions_remainder_function) {
+  TestFloatingPointRemainderFunction<TEST_EXECSPACE>();
+}
+
+#if 0
+// TODO: Adjust expected values, see https://github.com/kokkos/kokkos/issues/6275
+template <class Space>
+struct TestIEEEFloatingPointRemainderFunction : FloatingPointComparison {
+  TestIEEEFloatingPointRemainderFunction() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0);
+  }
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using Kokkos::remainder;
+    if (!compare(remainder(6.2f, 4.f), 2.2f, 2) &&
+        !compare(remainder(-6.2f, 4.f), 2.2f, 1)) {
+      ++e;
+      Kokkos::printf("failed remainder(float)\n");
+    }
+    if (!compare(remainder(static_cast<KE::half_t>(6.2f),
+                           static_cast<KE::half_t>(4.f)),
+                 static_cast<KE::half_t>(2.2f), 1) &&
+        !compare(remainder(static_cast<KE::half_t>(-6.2f),
+                           static_cast<KE::half_t>(4.f)),
+                 -static_cast<KE::half_t>(2.2f), 1)) {
+      ++e;
+      Kokkos::printf("failed remainder(KE::half_t)\n");
+    }
+    if (!compare(remainder(static_cast<KE::bhalf_t>(6.2f),
+                           static_cast<KE::bhalf_t>(4.f)),
+                 static_cast<KE::bhalf_t>(2.2f), 1) &&
+        !compare(remainder(static_cast<KE::bhalf_t>(-6.2f),
+                           static_cast<KE::bhalf_t>(4.f)),
+                 -static_cast<KE::bhalf_t>(2.2f), 1)) {
+      ++e;
+      Kokkos::printf("failed remainder(KE::bhalf_t)\n");
+    }
+    if (!compare(remainder(6.2, 4.), 2.2, 2) &&
+        !compare(remainder(-6.2, 4.), 2.2, 1)) {
+      ++e;
+      Kokkos::printf("failed remainder(double)\n");
+    }
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    if (!compare(remainder(6.2l, 4.l), 2.2l, 1) &&
+        !compare(remainder(-6.2l, 4.l), -2.2l, 1)) {
+      ++e;
+      Kokkos::printf("failed remainder(long double)\n");
+    }
+#endif
+    // special values
+    using Kokkos::isinf;
+    using Kokkos::isnan;
+    if (!isinf(remainder(-KE::infinity<float>::value, 1.f)) &&
+        !isnan(remainder(-KE::quiet_NaN<float>::value, 1.f))) {
+      ++e;
+      Kokkos::printf(
+          "failed remainder(floating_point) special values\n");
+    }
+
+    static_assert(
+        std::is_same<decltype(remainder(static_cast<KE::half_t>(4.f),
+                                        static_cast<KE::half_t>(4.f))),
+                     KE::half_t>::value);
+    static_assert(
+        std::is_same<decltype(remainder(static_cast<KE::bhalf_t>(4.f),
+                                        static_cast<KE::bhalf_t>(4.f))),
+                     KE::bhalf_t>::value);
+    static_assert(std::is_same<decltype(remainder(4.f, 4.f)), float>::value);
+    static_assert(std::is_same<decltype(remainder(5., 5.)), double>::value);
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    static_assert(
+        std::is_same<decltype(remainder(6.l, 6.l)), long double>::value);
+#endif
+  }
+};
+
+TEST(TEST_CATEGORY, mathematical_functions_ieee_remainder_function) {
+  TestIEEEFloatingPointRemainderFunction<TEST_EXECSPACE>();
+}
+#endif
+
+// TODO: TestFpClassify, see https://github.com/kokkos/kokkos/issues/6279
+
+#ifndef KOKKOS_MATHEMATICAL_FUNCTIONS_SKIP_2
+template <class Space>
+struct TestIsFinite {
+  TestIsFinite() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0);
+  }
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using KE::infinity;
+    using KE::quiet_NaN;
+    using KE::signaling_NaN;
+    using Kokkos::isfinite;
+    if (!isfinite(1) || !isfinite(INT_MAX)) {
+      ++e;
+      Kokkos::printf("failed isfinite(integral)\n");
+    }
+    if (!isfinite(2.f) || isfinite(quiet_NaN<float>::value) ||
+        isfinite(signaling_NaN<float>::value) ||
+        isfinite(infinity<float>::value)) {
+      ++e;
+      Kokkos::printf("failed isfinite(float)\n");
+    }
+#if !(defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_MSVC))
+    if (!isfinite(static_cast<KE::half_t>(2.f)) ||
+        isfinite(quiet_NaN<KE::half_t>::value) ||
+        isfinite(signaling_NaN<KE::half_t>::value) ||
+        isfinite(infinity<KE::half_t>::value)) {
+      ++e;
+      Kokkos::printf("failed isfinite(KE::half_t)\n");
+    }
+    if (!isfinite(static_cast<KE::bhalf_t>(2.f)) ||
+        isfinite(quiet_NaN<KE::bhalf_t>::value) ||
+        isfinite(signaling_NaN<KE::bhalf_t>::value) ||
+        isfinite(infinity<KE::bhalf_t>::value)) {
+      ++e;
+      Kokkos::printf("failed isfinite(KE::bhalf_t)\n");
+    }
+#endif
+    if (!isfinite(3.) || isfinite(quiet_NaN<double>::value) ||
+        isfinite(signaling_NaN<double>::value) ||
+        isfinite(infinity<double>::value)) {
+      ++e;
+      Kokkos::printf("failed isfinite(double)\n");
+    }
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    if (!isfinite(4.l) || isfinite(quiet_NaN<long double>::value) ||
+        isfinite(signaling_NaN<long double>::value) ||
+        isfinite(infinity<long double>::value)) {
+      ++e;
+      Kokkos::printf("failed isfinite(long double)\n");
+    }
+#endif
+    // special values
+    if (isfinite(INFINITY) || isfinite(NAN)) {
+      ++e;
+      Kokkos::printf("failed isfinite(floating_point) special values\n");
+    }
+
+    static_assert(std::is_same<decltype(isfinite(1)), bool>::value);
+    static_assert(std::is_same<decltype(isfinite(2.f)), bool>::value);
+    static_assert(std::is_same<decltype(isfinite(3.)), bool>::value);
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    static_assert(std::is_same<decltype(isfinite(4.l)), bool>::value);
+#endif
+  }
+};
+
+TEST(TEST_CATEGORY, mathematical_functions_isfinite) {
+  TestIsFinite<TEST_EXECSPACE>();
+}
+
+template <class Space>
+struct TestIsInf {
+  TestIsInf() { run(); }
+  void run() const {
+    int errors = 0;
+    Kokkos::parallel_reduce(Kokkos::RangePolicy<Space>(0, 1), *this, errors);
+    ASSERT_EQ(errors, 0);
+  }
+  KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using KE::infinity;
+    using KE::quiet_NaN;
+    using KE::signaling_NaN;
+    using Kokkos::isinf;
+    if (isinf(1) || isinf(INT_MAX)) {
+      ++e;
+      Kokkos::printf("failed isinf(integral)\n");
+    }
+    if (isinf(2.f) || isinf(quiet_NaN<float>::value) ||
+        isinf(signaling_NaN<float>::value) || !isinf(infinity<float>::value)) {
+      ++e;
+      Kokkos::printf("failed isinf(float)\n");
+    }
+#if !(defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_MSVC))
+    if (isinf(static_cast<KE::half_t>(2.f)) ||
+        isinf(quiet_NaN<KE::half_t>::value) ||
+        isinf(signaling_NaN<KE::half_t>::value) ||
+        !isinf(infinity<KE::half_t>::value)) {
+      ++e;
+      Kokkos::printf("failed isinf(KE::half_t)\n");
+    }
+    if (isinf(static_cast<KE::bhalf_t>(2.f)) ||
+        isinf(quiet_NaN<KE::bhalf_t>::value) ||
+        isinf(signaling_NaN<KE::bhalf_t>::value) ||
+        !isinf(infinity<KE::bhalf_t>::value)) {
+      ++e;
+      Kokkos::printf("failed isinf(KE::bhalf_t)\n");
+    }
+#endif
+    if (isinf(3.) || isinf(quiet_NaN<double>::value) ||
+        isinf(signaling_NaN<double>::value) ||
+        !isinf(infinity<double>::value)) {
+      ++e;
+      Kokkos::printf("failed isinf(double)\n");
+    }
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    if (isinf(4.l) || isinf(quiet_NaN<long double>::value) ||
+        isinf(signaling_NaN<long double>::value) ||
+        !isinf(infinity<long double>::value)) {
+      ++e;
+      Kokkos::printf("failed isinf(long double)\n");
+    }
+#endif
+    // special values
+    if (!isinf(INFINITY) || isinf(NAN)) {
+      ++e;
+      Kokkos::printf("failed isinf(floating_point) special values\n");
+    }
+
+    static_assert(std::is_same<decltype(isinf(1)), bool>::value);
+    static_assert(std::is_same<decltype(isinf(2.f)), bool>::value);
+    static_assert(std::is_same<decltype(isinf(3.)), bool>::value);
+#ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
+    static_assert(std::is_same<decltype(isinf(4.l)), bool>::value);
+#endif
+  }
+};
+
+TEST(TEST_CATEGORY, mathematical_functions_isinf) {
+  TestIsInf<TEST_EXECSPACE>();
+}
+
 template <class Space>
 struct TestIsNaN {
   TestIsNaN() { run(); }
@@ -1140,48 +1713,60 @@ struct TestIsNaN {
     ASSERT_EQ(errors, 0);
   }
   KOKKOS_FUNCTION void operator()(int, int& e) const {
+    using KE::infinity;
+    using KE::quiet_NaN;
+    using KE::signaling_NaN;
     using Kokkos::isnan;
-    using Kokkos::Experimental::quiet_NaN;
-    using Kokkos::Experimental::signaling_NaN;
     if (isnan(1) || isnan(INT_MAX)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(integral)\n");
+      Kokkos::printf("failed isnan(integral)\n");
     }
     if (isnan(2.f) || !isnan(quiet_NaN<float>::value) ||
-        !isnan(signaling_NaN<float>::value)
-
-    ) {
+        !isnan(signaling_NaN<float>::value) || isnan(infinity<float>::value)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(float)\n");
+      Kokkos::printf("failed isnan(float)\n");
     }
-    if (isnan(3.)
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
-        || !isnan(quiet_NaN<double>::value) ||
-        !isnan(signaling_NaN<double>::value)
-#endif
-    ) {
+#if !(defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_MSVC))
+    if (isnan(static_cast<KE::half_t>(2.f)) ||
+        !isnan(quiet_NaN<KE::half_t>::value) ||
+        !isnan(signaling_NaN<KE::half_t>::value) ||
+        isnan(infinity<KE::half_t>::value)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(double)\n");
+      Kokkos::printf("failed isnan(KE::half_t)\n");
     }
+    if (isnan(static_cast<KE::bhalf_t>(2.f)) ||
+        !isnan(quiet_NaN<KE::bhalf_t>::value) ||
+        !isnan(signaling_NaN<KE::bhalf_t>::value) ||
+        isnan(infinity<KE::bhalf_t>::value)) {
+      ++e;
+      Kokkos::printf("failed isnan(KE::bhalf_t)\n");
+    }
+    if (isnan(3.) || !isnan(quiet_NaN<double>::value) ||
+        !isnan(signaling_NaN<double>::value) ||
+        isnan(infinity<double>::value)) {
+      ++e;
+      Kokkos::printf("failed isnan(double)\n");
+    }
+#endif
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
     if (isnan(4.l) || !isnan(quiet_NaN<long double>::value) ||
-        !isnan(signaling_NaN<long double>::value)) {
+        !isnan(signaling_NaN<long double>::value) ||
+        isnan(infinity<long double>::value)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("failed isnan(long double)\n");
+      Kokkos::printf("failed isnan(long double)\n");
     }
 #endif
     // special values
     if (isnan(INFINITY) || !isnan(NAN)) {
       ++e;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "failed isnan(floating_point) special values\n");
+      Kokkos::printf("failed isnan(floating_point) special values\n");
     }
 
-    static_assert(std::is_same<decltype(isnan(1)), bool>::value, "");
-    static_assert(std::is_same<decltype(isnan(2.f)), bool>::value, "");
-    static_assert(std::is_same<decltype(isnan(3.)), bool>::value, "");
+    static_assert(std::is_same<decltype(isnan(1)), bool>::value);
+    static_assert(std::is_same<decltype(isnan(2.f)), bool>::value);
+    static_assert(std::is_same<decltype(isnan(3.)), bool>::value);
 #ifdef MATHEMATICAL_FUNCTIONS_HAVE_LONG_DOUBLE_OVERLOADS
-    static_assert(std::is_same<decltype(isnan(4.l)), bool>::value, "");
+    static_assert(std::is_same<decltype(isnan(4.l)), bool>::value);
 #endif
   }
 };
@@ -1190,3 +1775,6 @@ TEST(TEST_CATEGORY, mathematical_functions_isnan) {
   TestIsNaN<TEST_EXECSPACE>();
 }
 #endif
+
+// TODO: TestSignBit, see https://github.com/kokkos/kokkos/issues/6279
+#endif
diff --git a/core/unit_test/TestMathematicalSpecialFunctions.hpp b/core/unit_test/TestMathematicalSpecialFunctions.hpp
index 7ae2027705..7969dc8686 100644
--- a/core/unit_test/TestMathematicalSpecialFunctions.hpp
+++ b/core/unit_test/TestMathematicalSpecialFunctions.hpp
@@ -911,11 +911,14 @@ struct TestComplexBesselJ1Y1Function {
                 Kokkos::abs(h_ref_cbj1(i)) * 1e-13);
     }
 
+// FIXME_SYCL Failing for Intel GPUs
+#if !(defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU))
     EXPECT_EQ(h_ref_cby1(0), h_cby1(0));
     for (int i = 1; i < N; i++) {
       EXPECT_LE(Kokkos::abs(h_cby1(i) - h_ref_cby1(i)),
                 Kokkos::abs(h_ref_cby1(i)) * 1e-13);
     }
+#endif
 
     ////Test large arguments
     d_z_large        = ViewType("d_z_large", 6);
@@ -1055,7 +1058,7 @@ struct TestComplexBesselI0K0Function {
   void testit() {
     using Kokkos::Experimental::infinity;
 
-    int N      = 25;
+    int N      = 26;
     d_z        = ViewType("d_z", N);
     d_cbi0     = ViewType("d_cbi0", N);
     d_cbk0     = ViewType("d_cbk0", N);
@@ -1091,6 +1094,7 @@ struct TestComplexBesselI0K0Function {
     h_z(22) = Kokkos::complex<double>(-28.0, 0.0);
     h_z(23) = Kokkos::complex<double>(60.0, 0.0);
     h_z(24) = Kokkos::complex<double>(-60.0, 0.0);
+    h_z(25) = Kokkos::complex<double>(7.998015e-5, 0.0);
 
     Kokkos::deep_copy(d_z, h_z);
 
@@ -1149,6 +1153,7 @@ struct TestComplexBesselI0K0Function {
     h_ref_cbi0(22) = Kokkos::complex<double>(1.095346047317573e+11, 0);
     h_ref_cbi0(23) = Kokkos::complex<double>(5.894077055609803e+24, 0);
     h_ref_cbi0(24) = Kokkos::complex<double>(5.894077055609803e+24, 0);
+    h_ref_cbi0(25) = Kokkos::complex<double>(1.0000000015992061009, 0);
 
     h_ref_cbk0(0) = Kokkos::complex<double>(infinity<double>::value, 0);
     h_ref_cbk0(1) =
@@ -1195,17 +1200,31 @@ struct TestComplexBesselI0K0Function {
     h_ref_cbk0(23) = Kokkos::complex<double>(1.413897840559108e-27, 0);
     h_ref_cbk0(24) =
         Kokkos::complex<double>(1.413897840559108e-27, -1.851678917759592e+25);
+    h_ref_cbk0(25) = Kokkos::complex<double>(9.5496636116079915979, 0.);
 
+    // FIXME_HIP Disable the test when using ROCm 5.5 and 5.6 due to a known
+    // compiler bug
+#if !defined(KOKKOS_ENABLE_HIP) || (HIP_VERSION_MAJOR != 5) || \
+    ((HIP_VERSION_MAJOR == 5) &&                               \
+     !((HIP_VERSION_MINOR == 5) || (HIP_VERSION_MINOR == 6)))
     for (int i = 0; i < N; i++) {
       EXPECT_LE(Kokkos::abs(h_cbi0(i) - h_ref_cbi0(i)),
                 Kokkos::abs(h_ref_cbi0(i)) * 1e-13);
     }
 
     EXPECT_EQ(h_ref_cbk0(0), h_cbk0(0));
-    for (int i = 1; i < N; i++) {
+    int upper_limit_0 = N;
+    // FIXME_SYCL Failing for Intel GPUs, 19 is the first failing test case
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
+    if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+      upper_limit_0 = 19;
+#endif
+    for (int i = 1; i < upper_limit_0; i++) {
       EXPECT_LE(Kokkos::abs(h_cbk0(i) - h_ref_cbk0(i)),
-                Kokkos::abs(h_ref_cbk0(i)) * 1e-13);
+                Kokkos::abs(h_ref_cbk0(i)) * 1e-13)
+          << "at index " << i;
     }
+#endif
 
     ////Test large arguments
     d_z_large        = ViewType("d_z_large", 6);
@@ -1443,9 +1462,16 @@ struct TestComplexBesselI1K1Function {
     }
 
     EXPECT_EQ(h_ref_cbk1(0), h_cbk1(0));
-    for (int i = 1; i < N; i++) {
+    int upper_limit_1 = N;
+    // FIXME_SYCL Failing for Intel GPUs, 8 is the first failing test case
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
+    if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+      upper_limit_1 = 8;
+#endif
+    for (int i = 1; i < upper_limit_1; i++) {
       EXPECT_LE(Kokkos::abs(h_cbk1(i) - h_ref_cbk1(i)),
-                Kokkos::abs(h_ref_cbk1(i)) * 1e-13);
+                Kokkos::abs(h_ref_cbk1(i)) * 1e-13)
+          << "at index " << i;
     }
 
     ////Test large arguments
@@ -1686,19 +1712,37 @@ struct TestComplexBesselH1Function {
     h_ref_ch11(24) =
         Kokkos::complex<double>(-5.430453818237824e-02, -1.530182458039000e-02);
 
+    // FIXME_HIP Disable the test when using ROCm 5.5 and 5.6 due to a known
+    // compiler bug
+#if !defined(KOKKOS_ENABLE_HIP) || (HIP_VERSION_MAJOR != 5) || \
+    ((HIP_VERSION_MAJOR == 5) &&                               \
+     !((HIP_VERSION_MINOR == 5) || (HIP_VERSION_MINOR == 6)))
     EXPECT_EQ(h_ref_ch10(0), h_ch10(0));
-    for (int i = 1; i < N; i++) {
+    int upper_limit_10 = N;
+// FIXME_SYCL Failing for Intel GPUs, 17 is the first failing test case
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
+    if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+      upper_limit_10 = 17;
+#endif
+    for (int i = 1; i < upper_limit_10; i++) {
       EXPECT_LE(Kokkos::abs(h_ch10(i) - h_ref_ch10(i)),
                 Kokkos::abs(h_ref_ch10(i)) * 1e-13)
           << "at index " << i;
     }
 
     EXPECT_EQ(h_ref_ch11(0), h_ch11(0));
-    for (int i = 1; i < N; i++) {
+    int upper_limit_11 = N;
+    // FIXME_SYCL Failing for Intel GPUs, 2 is the first failing test case
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
+    if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+      upper_limit_11 = 2;
+#endif
+    for (int i = 1; i < upper_limit_11; i++) {
       EXPECT_LE(Kokkos::abs(h_ch11(i) - h_ref_ch11(i)),
                 Kokkos::abs(h_ref_ch11(i)) * 1e-13)
           << "at index " << i;
     }
+#endif
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -1868,17 +1912,37 @@ struct TestComplexBesselH2Function {
     h_ref_ch21(24) =
         Kokkos::complex<double>(1.629136145471347e-01, +1.530182458039000e-02);
 
+    // FIXME_HIP Disable the test when using ROCm 5.5 and 5.6 due to a known
+    // compiler bug
+#if !defined(KOKKOS_ENABLE_HIP) || (HIP_VERSION_MAJOR != 5) || \
+    ((HIP_VERSION_MAJOR == 5) &&                               \
+     !((HIP_VERSION_MINOR == 5) || (HIP_VERSION_MINOR == 6)))
     EXPECT_EQ(h_ref_ch20(0), h_ch20(0));
-    for (int i = 1; i < N; i++) {
+    int upper_limit_20 = N;
+// FIXME_SYCL Failing for Intel GPUs, 16 is the first failing test case
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
+    if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+      upper_limit_20 = 16;
+#endif
+    for (int i = 1; i < upper_limit_20; i++) {
       EXPECT_LE(Kokkos::abs(h_ch20(i) - h_ref_ch20(i)),
-                Kokkos::abs(h_ref_ch20(i)) * 1e-13);
+                Kokkos::abs(h_ref_ch20(i)) * 1e-13)
+          << "at index " << i;
     }
 
     EXPECT_EQ(h_ref_ch21(0), h_ch21(0));
-    for (int i = 1; i < N; i++) {
+    int upper_limit_21 = N;
+    // FIXME_SYCL Failing for Intel GPUs, 1 is the first failing test case
+#if defined(KOKKOS_ENABLE_SYCL) && defined(KOKKOS_ARCH_INTEL_GPU)
+    if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::SYCL>)
+      upper_limit_21 = 1;
+#endif
+    for (int i = 1; i < upper_limit_21; i++) {
       EXPECT_LE(Kokkos::abs(h_ch21(i) - h_ref_ch21(i)),
-                Kokkos::abs(h_ref_ch21(i)) * 1e-13);
+                Kokkos::abs(h_ref_ch21(i)) * 1e-13)
+          << "at index " << i;
     }
+#endif
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -1903,31 +1967,61 @@ TEST(TEST_CATEGORY, mathspecialfunc_errorfunc) {
 #endif
 
 TEST(TEST_CATEGORY, mathspecialfunc_cbesselj0y0) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenMPTarget on "
+                    "Intel GPUs";  // FIXME_OPENMPTARGET
+#endif
   TestComplexBesselJ0Y0Function<TEST_EXECSPACE> test;
   test.testit();
 }
 
 TEST(TEST_CATEGORY, mathspecialfunc_cbesselj1y1) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenMPTarget on "
+                    "Intel GPUs";  // FIXME_OPENMPTARGET
+#endif
   TestComplexBesselJ1Y1Function<TEST_EXECSPACE> test;
   test.testit();
 }
 
 TEST(TEST_CATEGORY, mathspecialfunc_cbesseli0k0) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenMPTarget on "
+                    "Intel GPUs";  // FIXME_OPENMPTARGET
+#endif
   TestComplexBesselI0K0Function<TEST_EXECSPACE> test;
   test.testit();
 }
 
 TEST(TEST_CATEGORY, mathspecialfunc_cbesseli1k1) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenMPTarget on "
+                    "Intel GPUs";  // FIXME_OPENMPTARGET
+#endif
   TestComplexBesselI1K1Function<TEST_EXECSPACE> test;
   test.testit();
 }
 
 TEST(TEST_CATEGORY, mathspecialfunc_cbesselh1stkind) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenMPTarget on "
+                    "Intel GPUs";  // FIXME_OPENMPTARGET
+#endif
   TestComplexBesselH1Function<TEST_EXECSPACE> test;
   test.testit();
 }
 
 TEST(TEST_CATEGORY, mathspecialfunc_cbesselh2ndkind) {
+#if defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU)
+  if (std::is_same_v<TEST_EXECSPACE, Kokkos::Experimental::OpenMPTarget>)
+    GTEST_SKIP() << "skipping since test is known to fail with OpenMPTarget on "
+                    "Intel GPUs";  // FIXME_OPENMPTARGET
+#endif
   TestComplexBesselH2Function<TEST_EXECSPACE> test;
   test.testit();
 }
diff --git a/core/unit_test/TestMinMaxClamp.hpp b/core/unit_test/TestMinMaxClamp.hpp
index 7ed2c6d3ba..6466b3b172 100644
--- a/core/unit_test/TestMinMaxClamp.hpp
+++ b/core/unit_test/TestMinMaxClamp.hpp
@@ -174,10 +174,6 @@ TEST(TEST_CATEGORY, minmax) {
   EXPECT_EQ(r2.first, 2);
   EXPECT_EQ(r2.second, 3);
 
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC nvhpc can't deal with device side
-                               // constexpr constructors so I removed the
-                               // constexpr in pair, which makes static_assert
-                               // here fail
   static_assert((Kokkos::pair<float, float>(Kokkos::minmax(3.f, 2.f)) ==
                  Kokkos::make_pair(2.f, 3.f)));
   static_assert(
@@ -208,7 +204,6 @@ TEST(TEST_CATEGORY, minmax) {
                                    ::Test::PairIntCompareFirst{0, 5},
                                })
                     .second.second == 4);  // rightmost
-#endif
 }
 
 template <class ViewType>
diff --git a/core/unit_test/TestMultiGPU.hpp b/core/unit_test/TestMultiGPU.hpp
new file mode 100644
index 0000000000..aad2fa45f4
--- /dev/null
+++ b/core/unit_test/TestMultiGPU.hpp
@@ -0,0 +1,184 @@
+//@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 <Test_InterOp_Streams.hpp>
+
+namespace {
+
+void test_policies(TEST_EXECSPACE exec0, Kokkos::View<int *, TEST_EXECSPACE> v0,
+                   TEST_EXECSPACE exec, Kokkos::View<int *, TEST_EXECSPACE> v) {
+  using MemorySpace = typename TEST_EXECSPACE::memory_space;
+
+  exec.fence();
+  exec0.fence();
+
+  Kokkos::deep_copy(exec, v, 5);
+  Kokkos::deep_copy(exec0, v0, 5);
+
+  Kokkos::deep_copy(v, v0);
+
+  int sum;
+  int sum0;
+
+  Kokkos::parallel_for("Test::Range_0",
+                       Kokkos::RangePolicy<TEST_EXECSPACE>(exec0, 0, 100),
+                       Test::FunctorRange<MemorySpace>(v0));
+  Kokkos::parallel_for("Test::Range",
+                       Kokkos::RangePolicy<TEST_EXECSPACE>(exec, 0, 100),
+                       Test::FunctorRange<MemorySpace>(v));
+  exec.fence();
+  exec0.fence();
+  Kokkos::parallel_reduce(
+      "Test::RangeReduce_0",
+      Kokkos::RangePolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<128, 2>>(exec0,
+                                                                        0, 100),
+      Test::FunctorRangeReduce<MemorySpace>(v0), sum0);
+  Kokkos::parallel_reduce(
+      "Test::RangeReduce",
+      Kokkos::RangePolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<128, 2>>(exec, 0,
+                                                                        100),
+      Test::FunctorRangeReduce<MemorySpace>(v), sum);
+  ASSERT_EQ(600, sum0);
+  ASSERT_EQ(600, sum);
+
+  Kokkos::parallel_for("Test::MDRange_0",
+                       Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                           exec0, {0, 0}, {10, 10}),
+                       Test::FunctorMDRange<MemorySpace>(v0));
+  Kokkos::parallel_for("Test::MDRange",
+                       Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>(
+                           exec, {0, 0}, {10, 10}),
+                       Test::FunctorMDRange<MemorySpace>(v));
+  Kokkos::parallel_reduce("Test::MDRangeReduce_0",
+                          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>,
+                                                Kokkos::LaunchBounds<128, 2>>(
+                              exec0, {0, 0}, {10, 10}),
+                          Test::FunctorMDRangeReduce<MemorySpace>(v0), sum0);
+  Kokkos::parallel_reduce("Test::MDRangeReduce",
+                          Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>,
+                                                Kokkos::LaunchBounds<128, 2>>(
+                              exec, {0, 0}, {10, 10}),
+                          Test::FunctorMDRangeReduce<MemorySpace>(v), sum);
+  ASSERT_EQ(700, sum0);
+  ASSERT_EQ(700, sum);
+
+  Kokkos::parallel_for("Test::Team_0",
+                       Kokkos::TeamPolicy<TEST_EXECSPACE>(exec0, 10, 10),
+                       Test::FunctorTeam<MemorySpace, TEST_EXECSPACE>(v0));
+  Kokkos::parallel_for("Test::Team",
+                       Kokkos::TeamPolicy<TEST_EXECSPACE>(exec, 10, 10),
+                       Test::FunctorTeam<MemorySpace, TEST_EXECSPACE>(v));
+  Kokkos::parallel_reduce(
+      "Test::Team_0",
+      Kokkos::TeamPolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<128, 2>>(exec0,
+                                                                       10, 10),
+      Test::FunctorTeamReduce<MemorySpace, TEST_EXECSPACE>(v0), sum0);
+  Kokkos::parallel_reduce(
+      "Test::Team",
+      Kokkos::TeamPolicy<TEST_EXECSPACE, Kokkos::LaunchBounds<128, 2>>(exec, 10,
+                                                                       10),
+      Test::FunctorTeamReduce<MemorySpace, TEST_EXECSPACE>(v), sum);
+  ASSERT_EQ(800, sum0);
+  ASSERT_EQ(800, sum);
+}
+
+struct ScratchFunctor {
+  int scratch_size;
+  int R;
+
+  ScratchFunctor(int scratch_size_, int R_)
+      : scratch_size(scratch_size_), R(R_) {}
+
+  KOKKOS_FUNCTION
+  void operator()(const Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type &team,
+                  int &error_accum) const {
+    Kokkos::View<int *, TEST_EXECSPACE::scratch_memory_space> scratch_mem(
+        team.team_scratch(1), scratch_size);
+
+    // Initialize scratch memory
+    Kokkos::parallel_for(Kokkos::TeamVectorRange(team, 0, scratch_size),
+                         [&](int i) { scratch_mem(i) = 0; });
+    team.team_barrier();
+
+    // Increment each entry in scratch memory R times
+    for (int r = 0; r < R; ++r) {
+      Kokkos::parallel_for(Kokkos::TeamVectorRange(team, 0, scratch_size),
+                           [&](int i) { scratch_mem(i) += 1; });
+    }
+    team.team_barrier();
+
+    // Check that each scratch entry has been incremented exactly R times
+    int team_error_accum;
+    auto R_loc = R;  // avoid implicit capture of this
+    Kokkos::parallel_reduce(
+        Kokkos::TeamVectorRange(team, 0, scratch_size),
+        [&](int i, int &tsum) {
+          if (scratch_mem(i) != R_loc) {
+            tsum += 1;
+          }
+        },
+        team_error_accum);
+    Kokkos::single(Kokkos::PerTeam(team),
+                   [&]() { error_accum += team_error_accum; });
+  }
+};
+
+void test_scratch(TEST_EXECSPACE exec0, TEST_EXECSPACE exec1) {
+  constexpr int N            = 10;
+  constexpr int R            = 1000;
+  constexpr int scratch_size = 100;
+  using ScratchType = Kokkos::View<int *, TEST_EXECSPACE::scratch_memory_space>;
+
+  // Test allocating and using scratch space
+  ScratchFunctor f(scratch_size, R);
+
+  auto policy0 =
+      Kokkos::TeamPolicy<TEST_EXECSPACE>(exec0, N, 10)
+          .set_scratch_size(
+              1, Kokkos::PerTeam(ScratchType::shmem_size(scratch_size)));
+  auto policy1 =
+      Kokkos::TeamPolicy<TEST_EXECSPACE>(exec1, N, 10)
+          .set_scratch_size(
+              1, Kokkos::PerTeam(ScratchType::shmem_size(scratch_size)));
+
+  int error0, error1;
+
+  Kokkos::parallel_reduce("test_scratch_device_0", policy0, f, error0);
+  Kokkos::parallel_reduce("test_scratch_device_1", policy1, f, error1);
+  ASSERT_EQ(error0, 0);
+  ASSERT_EQ(error1, 0);
+
+  // Request larger scratch size to trigger a realloc and test
+  const auto new_scratch_size = scratch_size + 10;
+  ScratchFunctor f_more_scratch(new_scratch_size, R);
+
+  auto policy0_more_scratch =
+      Kokkos::TeamPolicy<TEST_EXECSPACE>(exec0, N, 10)
+          .set_scratch_size(
+              1, Kokkos::PerTeam(ScratchType::shmem_size(new_scratch_size)));
+  auto policy1_more_scratch =
+      Kokkos::TeamPolicy<TEST_EXECSPACE>(exec1, N, 10)
+          .set_scratch_size(
+              1, Kokkos::PerTeam(ScratchType::shmem_size(new_scratch_size)));
+
+  Kokkos::parallel_reduce("test_realloc_scratch_device_0", policy0_more_scratch,
+                          f_more_scratch, error0);
+  Kokkos::parallel_reduce("test_realloc_scratch_device_1", policy1_more_scratch,
+                          f_more_scratch, error1);
+  ASSERT_EQ(error0, 0);
+  ASSERT_EQ(error1, 0);
+}
+}  // namespace
diff --git a/core/unit_test/TestNestedReducerCTAD.cpp b/core/unit_test/TestNestedReducerCTAD.cpp
new file mode 100644
index 0000000000..95493a5874
--- /dev/null
+++ b/core/unit_test/TestNestedReducerCTAD.cpp
@@ -0,0 +1,246 @@
+//@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 {
+
+struct TestNestedReducerCTAD {
+  using MemorySpace = Kokkos::DefaultExecutionSpace::memory_space;
+  using ScalarType  = int;
+  using IndexType   = int;
+  using TeamPolicy  = Kokkos::TeamPolicy<Kokkos::DefaultExecutionSpace>;
+  using TeamHandle  = TeamPolicy::member_type;
+
+  struct FakeComparator {
+    template <class T>
+    KOKKOS_FUNCTION bool operator()(T const&, T const&) const {
+      return true;
+    }
+  };
+
+  template <class ValueType>
+  struct FakeFunctor {
+    KOKKOS_FUNCTION void operator()(int, ValueType&) const {}
+  };
+
+  template <class ReducerTypeExpected, class ReducerTypeToCheck>
+  KOKKOS_FUNCTION static void check_types([
+      [maybe_unused]] ReducerTypeToCheck const& reducer) {
+    static_assert(std::is_same_v<ReducerTypeExpected, ReducerTypeToCheck>);
+  }
+
+  KOKKOS_FUNCTION void operator()([
+      [maybe_unused]] TeamHandle const& team_handle) const {
+    {
+      using ReducerTypeExpected = Kokkos::Sum<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::Sum reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::Prod<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::Prod reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::Min<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::Min reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::Max<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::Max reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::LAnd<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::LAnd reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::LOr<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::LOr reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::BAnd<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::BAnd reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::BOr<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::BOr reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MinLoc<ScalarType, IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MinLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MaxLoc<ScalarType, IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MaxLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::MinMax<ScalarType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MinMax reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MinMaxLoc<ScalarType, IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MinMaxLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MaxFirstLoc<ScalarType, IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MaxFirstLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MaxFirstLocCustomComparator<ScalarType, IndexType,
+                                              FakeComparator, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      FakeComparator comparator;
+      Kokkos::MaxFirstLocCustomComparator reducer(view, comparator);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MinFirstLoc<ScalarType, IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MinFirstLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MinFirstLocCustomComparator<ScalarType, IndexType,
+                                              FakeComparator, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      FakeComparator comparator;
+      Kokkos::MinFirstLocCustomComparator reducer(view, comparator);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::MinMaxFirstLastLoc<ScalarType, IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::MinMaxFirstLastLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::MinMaxFirstLastLocCustomComparator<
+          ScalarType, IndexType, FakeComparator, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      FakeComparator comparator;
+      Kokkos::MinMaxFirstLastLocCustomComparator reducer(view, comparator);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::FirstLoc<IndexType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::FirstLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected = Kokkos::LastLoc<IndexType, MemorySpace>;
+      using ValueType           = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::LastLoc reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::StdIsPartitioned<IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::StdIsPartitioned reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+
+    {
+      using ReducerTypeExpected =
+          Kokkos::StdPartitionPoint<IndexType, MemorySpace>;
+      using ValueType = ReducerTypeExpected::value_type;
+      Kokkos::View<ValueType, MemorySpace> view;
+      Kokkos::StdPartitionPoint reducer(view);
+      check_types<ReducerTypeExpected>(reducer);
+    }
+  }
+
+  TestNestedReducerCTAD() {
+    Kokkos::parallel_for(TeamPolicy(0, Kokkos::AUTO), *this);
+  }
+};
+
+}  // namespace
diff --git a/core/unit_test/TestNonTrivialScalarTypes.hpp b/core/unit_test/TestNonTrivialScalarTypes.hpp
index eaf7a4125c..116ac58c39 100644
--- a/core/unit_test/TestNonTrivialScalarTypes.hpp
+++ b/core/unit_test/TestNonTrivialScalarTypes.hpp
@@ -214,7 +214,7 @@ struct point_t {
   uint8_t x, y, z;
 
   KOKKOS_FUNCTION
-  point_t() : x(1), y(1), z(1){};
+  point_t() : x(0), y(0), z(0){};
 
   KOKKOS_FUNCTION
   point_t(const point_t &val) : x(val.x), y(val.y), z(val.z){};
diff --git a/core/unit_test/TestNumericTraits.hpp b/core/unit_test/TestNumericTraits.hpp
index f97fe7a699..0c80335488 100644
--- a/core/unit_test/TestNumericTraits.hpp
+++ b/core/unit_test/TestNumericTraits.hpp
@@ -21,6 +21,19 @@
 #include <limits>
 #include "Kokkos_NumericTraits.hpp"
 
+// Suppress "'long double' is treated as 'double' in device code"
+#ifdef KOKKOS_COMPILER_NVCC
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diagnostic push
+#pragma nv_diag_suppress 20208
+#else
+#ifdef __CUDA_ARCH__
+#pragma diagnostic push
+#pragma diag_suppress 20208
+#endif
+#endif
+#endif
+
 struct extrema {
 #define DEFINE_EXTREMA(T, m, M)                 \
   KOKKOS_FUNCTION static T min(T) { return m; } \
@@ -41,8 +54,8 @@ 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)
+#if !defined(KOKKOS_ENABLE_CUDA) || \
+    !defined(KOKKOS_COMPILER_NVHPC)  // 23.7 long double
   DEFINE_EXTREMA(long double, -LDBL_MAX, LDBL_MAX);
 #else
   static long double min(long double) { return -LDBL_MAX; }
@@ -101,8 +114,8 @@ struct TestNumericTraits {
 
   KOKKOS_FUNCTION void operator()(Infinity, int, int& e) const {
     using Kokkos::Experimental::infinity;
-    auto const inf  = infinity<T>::value;
-    auto const zero = T(0);
+    constexpr auto inf = infinity<T>::value;
+    auto const zero    = T(0);
     e += (int)!(inf + inf == inf);
     e += (int)!(inf != zero);
     use_on_device();
@@ -110,8 +123,8 @@ struct TestNumericTraits {
 
   KOKKOS_FUNCTION void operator()(Epsilon, int, int& e) const {
     using Kokkos::Experimental::epsilon;
-    auto const eps = epsilon<T>::value;
-    auto const one = T(1);
+    T const eps = epsilon<T>::value;
+    T const one = 1;
     // Avoid higher precision intermediate representation
     compare() = one + eps;
     e += (int)!(compare() != one);
@@ -145,33 +158,25 @@ struct TestNumericTraits {
   KOKKOS_FUNCTION void operator()(MaxExponent10, int, int&) const { use_on_device(); }
   // clang-format on
   KOKKOS_FUNCTION void operator()(QuietNaN, int, int& e) const {
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
     using Kokkos::Experimental::quiet_NaN;
-    constexpr auto nan  = quiet_NaN<T>::value;
-    constexpr auto zero = T(0);
+    constexpr auto nan = quiet_NaN<T>::value;
+    auto const zero    = T(0);
     e += (int)!(nan != nan);
     e += (int)!(nan != zero);
-#else
-    (void)e;
-#endif
     use_on_device();
   }
   KOKKOS_FUNCTION void operator()(SignalingNaN, int, int& e) const {
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
     using Kokkos::Experimental::signaling_NaN;
-    constexpr auto nan  = signaling_NaN<T>::value;
-    constexpr auto zero = T(0);
+    constexpr auto nan = signaling_NaN<T>::value;
+    auto const zero    = T(0);
     e += (int)!(nan != nan);
     e += (int)!(nan != zero);
-#else
-    (void)e;
-#endif
     use_on_device();
   }
 
   KOKKOS_FUNCTION void use_on_device() const {
-#if defined(KOKKOS_COMPILER_NVCC) || defined(KOKKOS_COMPILER_NVHPC) || \
-    defined(KOKKOS_ENABLE_OPENMPTARGET) || defined(KOKKOS_ENABLE_OPENACC)
+#if defined(KOKKOS_COMPILER_NVCC) || defined(KOKKOS_ENABLE_OPENMPTARGET) || \
+    defined(KOKKOS_ENABLE_OPENACC)
     take_by_value(trait<T>::value);
 #else
     (void)take_address_of(trait<T>::value);
@@ -204,39 +209,46 @@ struct TestNumericTraits<
 #endif
 
 TEST(TEST_CATEGORY, numeric_traits_infinity) {
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, Infinity>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, Infinity>();
   TestNumericTraits<TEST_EXECSPACE, float, Infinity>();
   TestNumericTraits<TEST_EXECSPACE, double, Infinity>();
-  // FIXME_NVHPC long double not supported
-#if !defined(KOKKOS_COMPILER_NVHPC)
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, Infinity>();
 #endif
 }
 
 TEST(TEST_CATEGORY, numeric_traits_epsilon) {
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, Epsilon>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, Epsilon>();
   TestNumericTraits<TEST_EXECSPACE, float, Epsilon>();
   TestNumericTraits<TEST_EXECSPACE, double, Epsilon>();
-  // FIXME_NVHPC long double not supported
-#if !defined(KOKKOS_COMPILER_NVHPC)
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, Epsilon>();
 #endif
 }
 
 TEST(TEST_CATEGORY, numeric_traits_round_error) {
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, RoundError>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t,
+                    RoundError>();
   TestNumericTraits<TEST_EXECSPACE, float, RoundError>();
   TestNumericTraits<TEST_EXECSPACE, double, RoundError>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, RoundError>();
 #endif
 }
 
 TEST(TEST_CATEGORY, numeric_traits_norm_min) {
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, NormMin>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, NormMin>();
   TestNumericTraits<TEST_EXECSPACE, float, NormMin>();
   TestNumericTraits<TEST_EXECSPACE, double, NormMin>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, NormMin>();
 #endif
 }
@@ -244,9 +256,8 @@ TEST(TEST_CATEGORY, numeric_traits_norm_min) {
 TEST(TEST_CATEGORY, numeric_traits_denorm_min) {
   TestNumericTraits<TEST_EXECSPACE, float, DenormMin>();
   TestNumericTraits<TEST_EXECSPACE, double, DenormMin>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, DenormMin>();
 #endif
 }
@@ -283,9 +294,8 @@ TEST(TEST_CATEGORY, numeric_traits_finite_min_max) {
   TestNumericTraits<TEST_EXECSPACE, float, FiniteMax>();
   TestNumericTraits<TEST_EXECSPACE, double, FiniteMin>();
   TestNumericTraits<TEST_EXECSPACE, double, FiniteMax>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, FiniteMin>();
   TestNumericTraits<TEST_EXECSPACE, long double, FiniteMax>();
 #endif
@@ -304,11 +314,12 @@ TEST(TEST_CATEGORY, numeric_traits_digits) {
   TestNumericTraits<TEST_EXECSPACE, unsigned long int, Digits>();
   TestNumericTraits<TEST_EXECSPACE, long long int, Digits>();
   TestNumericTraits<TEST_EXECSPACE, unsigned long long int, Digits>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, Digits>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, Digits>();
   TestNumericTraits<TEST_EXECSPACE, float, Digits>();
   TestNumericTraits<TEST_EXECSPACE, double, Digits>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, Digits>();
 #endif
 }
@@ -326,11 +337,12 @@ TEST(TEST_CATEGORY, numeric_traits_digits10) {
   TestNumericTraits<TEST_EXECSPACE, unsigned long int, Digits10>();
   TestNumericTraits<TEST_EXECSPACE, long long int, Digits10>();
   TestNumericTraits<TEST_EXECSPACE, unsigned long long int, Digits10>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, Digits10>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, Digits10>();
   TestNumericTraits<TEST_EXECSPACE, float, Digits10>();
   TestNumericTraits<TEST_EXECSPACE, double, Digits10>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, Digits10>();
 #endif
 }
@@ -338,9 +350,8 @@ TEST(TEST_CATEGORY, numeric_traits_digits10) {
 TEST(TEST_CATEGORY, numeric_traits_max_digits10) {
   TestNumericTraits<TEST_EXECSPACE, float, MaxDigits10>();
   TestNumericTraits<TEST_EXECSPACE, double, MaxDigits10>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, MaxDigits10>();
 #endif
 }
@@ -357,23 +368,27 @@ TEST(TEST_CATEGORY, numeric_traits_radix) {
   TestNumericTraits<TEST_EXECSPACE, unsigned long int, Radix>();
   TestNumericTraits<TEST_EXECSPACE, long long int, Radix>();
   TestNumericTraits<TEST_EXECSPACE, unsigned long long int, Radix>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, Radix>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, Radix>();
   TestNumericTraits<TEST_EXECSPACE, float, Radix>();
   TestNumericTraits<TEST_EXECSPACE, double, Radix>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, Radix>();
 #endif
 }
 
 TEST(TEST_CATEGORY, numeric_traits_min_max_exponent) {
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t,
+                    MinExponent>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t,
+                    MaxExponent>();
   TestNumericTraits<TEST_EXECSPACE, float, MinExponent>();
   TestNumericTraits<TEST_EXECSPACE, float, MaxExponent>();
   TestNumericTraits<TEST_EXECSPACE, double, MinExponent>();
   TestNumericTraits<TEST_EXECSPACE, double, MaxExponent>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, MinExponent>();
   TestNumericTraits<TEST_EXECSPACE, long double, MaxExponent>();
 #endif
@@ -384,24 +399,29 @@ TEST(TEST_CATEGORY, numeric_traits_min_max_exponent10) {
   TestNumericTraits<TEST_EXECSPACE, float, MaxExponent10>();
   TestNumericTraits<TEST_EXECSPACE, double, MinExponent10>();
   TestNumericTraits<TEST_EXECSPACE, double, MaxExponent10>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, MinExponent10>();
   TestNumericTraits<TEST_EXECSPACE, long double, MaxExponent10>();
 #endif
 }
 TEST(TEST_CATEGORY, numeric_traits_quiet_and_signaling_nan) {
+// FIXME_NVHPC
+#ifdef KOKKOS_COMPILER_NVHPC
+  GTEST_SKIP() << "This test is known to fail with the NVHPC compiler";
+#endif
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t, QuietNaN>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::half_t,
+                    SignalingNaN>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t, QuietNaN>();
+  TestNumericTraits<TEST_EXECSPACE, Kokkos::Experimental::bhalf_t,
+                    SignalingNaN>();
   TestNumericTraits<TEST_EXECSPACE, float, QuietNaN>();
   TestNumericTraits<TEST_EXECSPACE, float, SignalingNaN>();
   TestNumericTraits<TEST_EXECSPACE, double, QuietNaN>();
   TestNumericTraits<TEST_EXECSPACE, double, SignalingNaN>();
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-  // Unsupported unknown data type 38.
-  // Unsupported unknown data type 38.
-  // Unsupported unknown data type 38.
-  // nvc++-Fatal-/home/projects/x86-64/nvidia/hpc_sdk/Linux_x86_64/22.3/compilers/bin/tools/cpp2
-  // TERMINATED by signal 11
+  // FIXME_OPENMPTARGET long double on Intel GPUs
+#if (!defined(KOKKOS_ENABLE_OPENMPTARGET) || !defined(KOKKOS_ARCH_INTEL_GPU))
   TestNumericTraits<TEST_EXECSPACE, long double, QuietNaN>();
   TestNumericTraits<TEST_EXECSPACE, long double, SignalingNaN>();
 #endif
@@ -416,7 +436,7 @@ struct HasNoSpecialization {};
   using TRAIT##_value_t = decltype(Kokkos::Experimental::TRAIT<T>::value); \
   template <class T>                                                       \
   using has_##TRAIT = Kokkos::is_detected<TRAIT##_value_t, T>;             \
-  static_assert(!has_##TRAIT<HasNoSpecialization>::value, "");
+  static_assert(!has_##TRAIT<HasNoSpecialization>::value);
 
 CHECK_TRAIT_IS_SFINAE_FRIENDLY(infinity)
 CHECK_TRAIT_IS_SFINAE_FRIENDLY(finite_min)
@@ -498,39 +518,39 @@ 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(), "");
-static_assert(Kokkos::Experimental::norm_min<long double>::value == std::numeric_limits<long double>::min(), "");
+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());
+static_assert(Kokkos::Experimental::norm_min<long double>::value == std::numeric_limits<long double>::min());
 // integer types
-static_assert(Kokkos::Experimental::finite_min<char                  >::value == std::numeric_limits<                  char>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<signed char           >::value == std::numeric_limits<           signed char>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<unsigned char         >::value == std::numeric_limits<         unsigned char>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<short                 >::value == std::numeric_limits<                 short>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<unsigned short        >::value == std::numeric_limits<        unsigned short>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<int                   >::value == std::numeric_limits<                   int>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<unsigned int          >::value == std::numeric_limits<          unsigned int>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<long int              >::value == std::numeric_limits<              long int>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<unsigned long int     >::value == std::numeric_limits<     unsigned long int>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<long long int         >::value == std::numeric_limits<         long long int>::min(), "");
-static_assert(Kokkos::Experimental::finite_min<unsigned long long int>::value == std::numeric_limits<unsigned long long int>::min(), "");
-static_assert(Kokkos::Experimental::finite_max<char                  >::value == std::numeric_limits<                  char>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<signed char           >::value == std::numeric_limits<           signed char>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<unsigned char         >::value == std::numeric_limits<         unsigned char>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<short                 >::value == std::numeric_limits<                 short>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<unsigned short        >::value == std::numeric_limits<        unsigned short>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<int                   >::value == std::numeric_limits<                   int>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<unsigned int          >::value == std::numeric_limits<          unsigned int>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<long int              >::value == std::numeric_limits<              long int>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<unsigned long int     >::value == std::numeric_limits<     unsigned long int>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<long long int         >::value == std::numeric_limits<         long long int>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<unsigned long long int>::value == std::numeric_limits<unsigned long long int>::max(), "");
+static_assert(Kokkos::Experimental::finite_min<char                  >::value == std::numeric_limits<                  char>::min());
+static_assert(Kokkos::Experimental::finite_min<signed char           >::value == std::numeric_limits<           signed char>::min());
+static_assert(Kokkos::Experimental::finite_min<unsigned char         >::value == std::numeric_limits<         unsigned char>::min());
+static_assert(Kokkos::Experimental::finite_min<short                 >::value == std::numeric_limits<                 short>::min());
+static_assert(Kokkos::Experimental::finite_min<unsigned short        >::value == std::numeric_limits<        unsigned short>::min());
+static_assert(Kokkos::Experimental::finite_min<int                   >::value == std::numeric_limits<                   int>::min());
+static_assert(Kokkos::Experimental::finite_min<unsigned int          >::value == std::numeric_limits<          unsigned int>::min());
+static_assert(Kokkos::Experimental::finite_min<long int              >::value == std::numeric_limits<              long int>::min());
+static_assert(Kokkos::Experimental::finite_min<unsigned long int     >::value == std::numeric_limits<     unsigned long int>::min());
+static_assert(Kokkos::Experimental::finite_min<long long int         >::value == std::numeric_limits<         long long int>::min());
+static_assert(Kokkos::Experimental::finite_min<unsigned long long int>::value == std::numeric_limits<unsigned long long int>::min());
+static_assert(Kokkos::Experimental::finite_max<char                  >::value == std::numeric_limits<                  char>::max());
+static_assert(Kokkos::Experimental::finite_max<signed char           >::value == std::numeric_limits<           signed char>::max());
+static_assert(Kokkos::Experimental::finite_max<unsigned char         >::value == std::numeric_limits<         unsigned char>::max());
+static_assert(Kokkos::Experimental::finite_max<short                 >::value == std::numeric_limits<                 short>::max());
+static_assert(Kokkos::Experimental::finite_max<unsigned short        >::value == std::numeric_limits<        unsigned short>::max());
+static_assert(Kokkos::Experimental::finite_max<int                   >::value == std::numeric_limits<                   int>::max());
+static_assert(Kokkos::Experimental::finite_max<unsigned int          >::value == std::numeric_limits<          unsigned int>::max());
+static_assert(Kokkos::Experimental::finite_max<long int              >::value == std::numeric_limits<              long int>::max());
+static_assert(Kokkos::Experimental::finite_max<unsigned long int     >::value == std::numeric_limits<     unsigned long int>::max());
+static_assert(Kokkos::Experimental::finite_max<long long int         >::value == std::numeric_limits<         long long int>::max());
+static_assert(Kokkos::Experimental::finite_max<unsigned long long int>::value == std::numeric_limits<unsigned long long int>::max());
 // floating point types
-static_assert(Kokkos::Experimental::finite_min<float      >::value == -std::numeric_limits<      float>::max(), "");
-static_assert(Kokkos::Experimental::finite_min<double     >::value == -std::numeric_limits<     double>::max(), "");
-static_assert(Kokkos::Experimental::finite_min<long double>::value == -std::numeric_limits<long double>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<float      >::value ==  std::numeric_limits<      float>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<double     >::value ==  std::numeric_limits<     double>::max(), "");
-static_assert(Kokkos::Experimental::finite_max<long double>::value ==  std::numeric_limits<long double>::max(), "");
+static_assert(Kokkos::Experimental::finite_min<float      >::value == -std::numeric_limits<      float>::max());
+static_assert(Kokkos::Experimental::finite_min<double     >::value == -std::numeric_limits<     double>::max());
+static_assert(Kokkos::Experimental::finite_min<long double>::value == -std::numeric_limits<long double>::max());
+static_assert(Kokkos::Experimental::finite_max<float      >::value ==  std::numeric_limits<      float>::max());
+static_assert(Kokkos::Experimental::finite_max<double     >::value ==  std::numeric_limits<     double>::max());
+static_assert(Kokkos::Experimental::finite_max<long double>::value ==  std::numeric_limits<long double>::max());
 // clang-format on
 
 CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_CONSTANT(bool, digits);
@@ -597,15 +617,13 @@ CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_CONSTANT(long double, max_exponent10);
 #undef CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION
 #undef CHECK_SAME_AS_NUMERIC_LIMITS_MEMBER_CONSTANT
 
-#define CHECK_NAN_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(T, TRAIT)             \
-  static_assert(Kokkos::Experimental::TRAIT<T>::value !=                       \
-                    Kokkos::Experimental::TRAIT<T>::value,                     \
-                "");                                                           \
-  static_assert(                                                               \
-      std::numeric_limits<T>::TRAIT() != std::numeric_limits<T>::TRAIT(), ""); \
-  static_assert(Kokkos::Experimental::TRAIT<T>::value !=                       \
-                    std::numeric_limits<T>::TRAIT(),                           \
-                "")
+#define CHECK_NAN_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(T, TRAIT) \
+  static_assert(Kokkos::Experimental::TRAIT<T>::value !=           \
+                Kokkos::Experimental::TRAIT<T>::value);            \
+  static_assert(std::numeric_limits<T>::TRAIT() !=                 \
+                std::numeric_limits<T>::TRAIT());                  \
+  static_assert(Kokkos::Experimental::TRAIT<T>::value !=           \
+                std::numeric_limits<T>::TRAIT())
 
 // Workaround compiler issue error: expression must have a constant value
 // See kokkos/kokkos#4574
@@ -625,14 +643,11 @@ CHECK_NAN_SAME_AS_NUMERIC_LIMITS_MEMBER_FUNCTION(long double, signaling_NaN);
 
 #define CHECK_INSTANTIATED_ON_CV_QUALIFIED_TYPES(T, TRAIT)              \
   static_assert(Kokkos::Experimental::TRAIT<T const>::value ==          \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "");                                                    \
+                Kokkos::Experimental::TRAIT<T>::value);                 \
   static_assert(Kokkos::Experimental::TRAIT<T volatile>::value ==       \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "");                                                    \
+                Kokkos::Experimental::TRAIT<T>::value);                 \
   static_assert(Kokkos::Experimental::TRAIT<T const volatile>::value == \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "")
+                Kokkos::Experimental::TRAIT<T>::value)
 
 #define CHECK_INSTANTIATED_ON_CV_QUALIFIED_TYPES_FLOATING_POINT(TRAIT) \
   CHECK_INSTANTIATED_ON_CV_QUALIFIED_TYPES(float, TRAIT);              \
@@ -680,17 +695,13 @@ CHECK_INSTANTIATED_ON_CV_QUALIFIED_TYPES_FLOATING_POINT(max_exponent10);
 
 #define CHECK_NAN_INSTANTIATED_ON_CV_QUALIFIED_TYPES(T, TRAIT)          \
   static_assert(Kokkos::Experimental::TRAIT<T>::value !=                \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "");                                                    \
+                Kokkos::Experimental::TRAIT<T>::value);                 \
   static_assert(Kokkos::Experimental::TRAIT<T const>::value !=          \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "");                                                    \
+                Kokkos::Experimental::TRAIT<T>::value);                 \
   static_assert(Kokkos::Experimental::TRAIT<T volatile>::value !=       \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "");                                                    \
+                Kokkos::Experimental::TRAIT<T>::value);                 \
   static_assert(Kokkos::Experimental::TRAIT<T const volatile>::value != \
-                    Kokkos::Experimental::TRAIT<T>::value,              \
-                "")
+                Kokkos::Experimental::TRAIT<T>::value)
 
 #define CHECK_NAN_INSTANTIATED_ON_CV_QUALIFIED_TYPES_FLOATING_POINT(TRAIT) \
   CHECK_NAN_INSTANTIATED_ON_CV_QUALIFIED_TYPES(float, TRAIT);              \
@@ -702,3 +713,13 @@ CHECK_NAN_INSTANTIATED_ON_CV_QUALIFIED_TYPES_FLOATING_POINT(signaling_NaN);
 
 #undef CHECK_NAN_INSTANTIATED_ON_CV_QUALIFIED_TYPES_FLOATING_POINT
 #undef CHECK_NAN_INSTANTIATED_ON_CV_QUALIFIED_TYPES
+
+#ifdef KOKKOS_COMPILER_NVCC
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diagnostic pop
+#else
+#ifdef __CUDA_ARCH__
+#pragma diagnostic pop
+#endif
+#endif
+#endif
diff --git a/core/unit_test/TestOccupancyControlTrait.hpp b/core/unit_test/TestOccupancyControlTrait.hpp
new file mode 100644
index 0000000000..345a906d66
--- /dev/null
+++ b/core/unit_test/TestOccupancyControlTrait.hpp
@@ -0,0 +1,80 @@
+//@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... Properties>
+void test_policy_execution(const Kokkos::RangePolicy<Properties...>& policy) {
+  Kokkos::parallel_for(policy, KOKKOS_LAMBDA(int){});
+}
+template <class... Properties>
+void test_policy_execution(const Kokkos::TeamPolicy<Properties...>& policy) {
+  Kokkos::parallel_for(
+      policy,
+      KOKKOS_LAMBDA(
+          const typename Kokkos::TeamPolicy<Properties...>::member_type&){});
+}
+template <class... Properties>
+void test_policy_execution(const Kokkos::MDRangePolicy<Properties...>& policy) {
+  Kokkos::parallel_for(policy, KOKKOS_LAMBDA(int, int){});
+}
+
+template <class Policy>
+void test_prefer_desired_occupancy(Policy policy) {
+  using Kokkos::Experimental::DesiredOccupancy;
+  using Kokkos::Experimental::MaximizeOccupancy;
+  using Kokkos::Experimental::prefer;
+  using Kokkos::Experimental::WorkItemProperty;
+
+  // MaximizeOccupancy -> MaximizeOccupancy
+  auto const policy_still_no_occ = prefer(policy, MaximizeOccupancy{});
+  test_policy_execution(policy_still_no_occ);
+
+  // MaximizeOccupancy -> DesiredOccupancy
+  auto const policy_with_occ =
+      prefer(policy_still_no_occ, DesiredOccupancy{33});
+  test_policy_execution(policy_with_occ);
+
+  // DesiredOccupancy -> DesiredOccupancy
+  auto const policy_change_occ = prefer(policy_with_occ, DesiredOccupancy{24});
+  test_policy_execution(policy_change_occ);
+
+  // DesiredOccupancy -> DesiredOccupancy w/ hint
+  auto policy_with_occ_and_hint = Kokkos::Experimental::require(
+      policy_change_occ,
+      Kokkos::Experimental::WorkItemProperty::HintLightWeight);
+  test_policy_execution(policy_with_occ_and_hint);
+
+  // DesiredOccupancy -> MaximizeOccupancy
+  auto const policy_drop_occ =
+      prefer(policy_with_occ_and_hint, MaximizeOccupancy{});
+  test_policy_execution(policy_drop_occ);
+}
+
+// FIXME_MSVC_WITH_CUDA
+// This test doesn't compile with CUDA on Windows
+#if !(defined(_WIN32) && defined(KOKKOS_ENABLE_CUDA))
+TEST(TEST_CATEGORY, occupancy_control) {
+  test_prefer_desired_occupancy(Kokkos::RangePolicy<TEST_EXECSPACE>(0, 1));
+  test_prefer_desired_occupancy(
+      Kokkos::TeamPolicy<TEST_EXECSPACE>{1, Kokkos::AUTO});
+  test_prefer_desired_occupancy(
+      Kokkos::MDRangePolicy<TEST_EXECSPACE, Kokkos::Rank<2>>{{0, 0}, {1, 1}});
+}
+#endif
+}  // namespace
diff --git a/core/unit_test/TestOther.hpp b/core/unit_test/TestOther.hpp
index 5d118ce9b0..9daef3ca3f 100644
--- a/core/unit_test/TestOther.hpp
+++ b/core/unit_test/TestOther.hpp
@@ -16,18 +16,8 @@
 
 #ifndef KOKKOS_TEST_OTHER_HPP
 #define KOKKOS_TEST_OTHER_HPP
-#include <TestAggregate.hpp>
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC:
-// NVC++-F-0000-Internal compiler error. Basic LLVM base data type required 23
-// (/ascldap/users/crtrott/Kokkos/kokkos/build/core/unit_test/cuda/TestCuda_Other.cpp:
-// 204) NVC++/x86-64 Linux 22.3-0: compilation aborted
 #include <TestMemoryPool.hpp>
-#endif
 #include <TestCXX11.hpp>
 
 #include <TestViewCtorPropEmbeddedDim.hpp>
-// with VS 16.11.3 and CUDA 11.4.2 getting cudafe stackoverflow crash
-#if !(defined(_WIN32) && defined(KOKKOS_ENABLE_CUDA))
-#include <TestViewLayoutTiled.hpp>
-#endif
 #endif
diff --git a/core/unit_test/TestParseCmdLineArgsAndEnvVars.cpp b/core/unit_test/TestParseCmdLineArgsAndEnvVars.cpp
index 176ce9b5fe..a56dfd9efc 100644
--- a/core/unit_test/TestParseCmdLineArgsAndEnvVars.cpp
+++ b/core/unit_test/TestParseCmdLineArgsAndEnvVars.cpp
@@ -166,22 +166,6 @@ TEST(defaultdevicetype, cmd_line_args_device_id) {
   EXPECT_REMAINING_COMMAND_LINE_ARGUMENTS(cla, {"--dummy"});
 }
 
-TEST(defaultdevicetype, cmd_line_args_num_devices) {
-  CmdLineArgsHelper cla = {{
-      "--kokkos-num-devices=5,6",
-      "--kokkos-num-devices=7",
-      "-v",
-  }};
-  Kokkos::InitializationSettings settings;
-  Kokkos::Impl::parse_command_line_arguments(cla.argc(), cla.argv(), settings);
-  EXPECT_TRUE(settings.has_num_devices());
-  EXPECT_EQ(settings.get_num_devices(), 7);
-  // this is the current behavior, not suggesting this cannot be revisited
-  EXPECT_TRUE(settings.has_skip_device()) << "behavior changed see comment";
-  EXPECT_EQ(settings.get_skip_device(), 6) << "behavior changed see comment";
-  EXPECT_REMAINING_COMMAND_LINE_ARGUMENTS(cla, {"-v"});
-}
-
 TEST(defaultdevicetype, cmd_line_args_disable_warning) {
   CmdLineArgsHelper cla = {{
       "--kokkos-disable-warnings=1",
@@ -351,20 +335,6 @@ TEST(defaultdevicetype, env_vars_device_id) {
   EXPECT_EQ(settings.get_device_id(), 33);
 }
 
-TEST(defaultdevicetype, env_vars_num_devices) {
-  EnvVarsHelper ev = {{
-      {"KOKKOS_NUM_DEVICES", "4"},
-      {"KOKKOS_SKIP_DEVICE", "1"},
-  }};
-  SKIP_IF_ENVIRONMENT_VARIABLE_ALREADY_SET(ev);
-  Kokkos::InitializationSettings settings;
-  Kokkos::Impl::parse_environment_variables(settings);
-  EXPECT_TRUE(settings.has_num_devices());
-  EXPECT_EQ(settings.get_num_devices(), 4);
-  EXPECT_TRUE(settings.has_skip_device());
-  EXPECT_EQ(settings.get_skip_device(), 1);
-}
-
 TEST(defaultdevicetype, env_vars_disable_warnings) {
   for (auto const& value_true : {"1", "true", "TRUE", "yEs"}) {
     EnvVarsHelper ev = {{
@@ -420,22 +390,20 @@ TEST(defaultdevicetype, env_vars_tune_internals) {
 }
 
 TEST(defaultdevicetype, visible_devices) {
-#define KOKKOS_TEST_VISIBLE_DEVICES(ENV, CNT, DEV)                    \
-  do {                                                                \
-    EnvVarsHelper ev{ENV};                                            \
-    SKIP_IF_ENVIRONMENT_VARIABLE_ALREADY_SET(ev);                     \
-    Kokkos::InitializationSettings settings;                          \
-    Kokkos::Impl::parse_environment_variables(settings);              \
-    auto computed = Kokkos::Impl::get_visible_devices(settings, CNT); \
-    std::vector<int> expected = DEV;                                  \
-    EXPECT_EQ(expected.size(), computed.size())                       \
-        << ev << "device count: " << CNT;                             \
-    auto n = std::min<int>(expected.size(), computed.size());         \
-    for (int i = 0; i < n; ++i) {                                     \
-      EXPECT_EQ(expected[i], computed[i])                             \
-          << "devices differ at index " << i << '\n'                  \
-          << ev << "device count: " << CNT;                           \
-    }                                                                 \
+#define KOKKOS_TEST_VISIBLE_DEVICES(ENV, CNT, DEV)                      \
+  do {                                                                  \
+    EnvVarsHelper ev{ENV};                                              \
+    SKIP_IF_ENVIRONMENT_VARIABLE_ALREADY_SET(ev);                       \
+    auto computed             = Kokkos::Impl::get_visible_devices(CNT); \
+    std::vector<int> expected = DEV;                                    \
+    EXPECT_EQ(expected.size(), computed.size())                         \
+        << ev << "device count: " << CNT;                               \
+    auto n = std::min<int>(expected.size(), computed.size());           \
+    for (int i = 0; i < n; ++i) {                                       \
+      EXPECT_EQ(expected[i], computed[i])                               \
+          << "devices differ at index " << i << '\n'                    \
+          << ev << "device count: " << CNT;                             \
+    }                                                                   \
   } while (false)
 
 #define DEV(...) \
@@ -444,6 +412,8 @@ TEST(defaultdevicetype, visible_devices) {
 
   // first test with all environment variables that are involved in determining
   // the visible devices so user set var do not mess up the logic below.
+  // KOKKOS_NUM_DEVICES and KOKKOS_SKIP_DEVICE are deprecated since 3.7 and are
+  // not taken into account anymore.
   KOKKOS_TEST_VISIBLE_DEVICES(
       ENV({"KOKKOS_VISIBLE_DEVICES", "2,1"}, {"KOKKOS_NUM_DEVICES", "8"},
           {"KOKKOS_SKIP_DEVICE", "1"}),
@@ -452,10 +422,10 @@ TEST(defaultdevicetype, visible_devices) {
       ENV({"KOKKOS_VISIBLE_DEVICES", "2,1"}, {"KOKKOS_NUM_DEVICES", "8"}, ), 6,
       DEV(2, 1));
   KOKKOS_TEST_VISIBLE_DEVICES(ENV({"KOKKOS_NUM_DEVICES", "3"}), 6,
-                              DEV(0, 1, 2));
+                              DEV(0, 1, 2, 3, 4, 5));
   KOKKOS_TEST_VISIBLE_DEVICES(
       ENV({"KOKKOS_NUM_DEVICES", "4"}, {"KOKKOS_SKIP_DEVICE", "1"}, ), 6,
-      DEV(0, 2, 3));
+      DEV(0, 1, 2, 3, 4, 5));
   KOKKOS_TEST_VISIBLE_DEVICES(ENV({"KOKKOS_VISIBLE_DEVICES", "1,3,4"}), 6,
                               DEV(1, 3, 4));
   KOKKOS_TEST_VISIBLE_DEVICES(
diff --git a/core/unit_test/TestPrintf.hpp b/core/unit_test/TestPrintf.hpp
new file mode 100644
index 0000000000..8a190aea60
--- /dev/null
+++ b/core/unit_test/TestPrintf.hpp
@@ -0,0 +1,37 @@
+//@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>
+
+template <class ExecutionSpace>
+void test_kokkos_printf() {
+  ::testing::internal::CaptureStdout();
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecutionSpace>(0, 1),
+      KOKKOS_LAMBDA(int) { Kokkos::printf("Print an integer: %d", 2); });
+  Kokkos::fence();
+  auto const captured = ::testing::internal::GetCapturedStdout();
+  std::string expected_string("Print an integer: 2");
+  ASSERT_EQ(captured, expected_string);
+}
+
+// FIXME_OPENMPTARGET non-string-literal argument used in printf is not
+// supported for spir64
+#if !(defined(KOKKOS_ENABLE_OPENMPTARGET) && defined(KOKKOS_ARCH_INTEL_GPU))
+TEST(TEST_CATEGORY, kokkos_printf) { test_kokkos_printf<TEST_EXECSPACE>(); }
+#endif
diff --git a/core/unit_test/TestQuadPrecisionMath.hpp b/core/unit_test/TestQuadPrecisionMath.hpp
index 3801acd4a2..a7a0fbf140 100644
--- a/core/unit_test/TestQuadPrecisionMath.hpp
+++ b/core/unit_test/TestQuadPrecisionMath.hpp
@@ -98,7 +98,7 @@ constexpr bool test_quad_precision_math_constants() {
   static_assert(Kokkos::numbers::log10e_v<__float128> == M_LOG10Eq);
   static_assert(Kokkos::numbers::pi_v    <__float128> == M_PIq);
 #if defined(KOKKOS_COMPILER_GNU) && (KOKKOS_COMPILER_GNU >= 930)
-  static_assert(Kokkos::::inv_pi_v<__float128> == M_1_PIq);
+  static_assert(Kokkos::numbers::inv_pi_v<__float128> == M_1_PIq);
 #endif
   // inv_sqrtpi_v
   static_assert(Kokkos::numbers::ln2_v   <__float128> == M_LN2q);
diff --git a/core/unit_test/TestRange.hpp b/core/unit_test/TestRange.hpp
index 1648cb6ab4..8cd95a24bf 100644
--- a/core/unit_test/TestRange.hpp
+++ b/core/unit_test/TestRange.hpp
@@ -134,8 +134,7 @@ struct TestRange {
   KOKKOS_INLINE_FUNCTION
   void operator()(const VerifyInitTag &, const int i) const {
     if (i != m_flags(i)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("TestRange::test_for_error at %d != %d\n",
-                                    i, m_flags(i));
+      Kokkos::printf("TestRange::test_for_error at %d != %d\n", i, m_flags(i));
     }
   }
 
@@ -147,8 +146,7 @@ struct TestRange {
   KOKKOS_INLINE_FUNCTION
   void operator()(const VerifyResetTag &, const int i) const {
     if (2 * i != m_flags(i)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("TestRange::test_for_error at %d != %d\n",
-                                    i, m_flags(i));
+      Kokkos::printf("TestRange::test_for_error at %d != %d\n", i, m_flags(i));
     }
   }
 
@@ -160,8 +158,8 @@ struct TestRange {
   KOKKOS_INLINE_FUNCTION
   void operator()(const VerifyOffsetTag &, const int i) const {
     if (i + offset != m_flags(i)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("TestRange::test_for_error at %d != %d\n",
-                                    i + offset, m_flags(i));
+      Kokkos::printf("TestRange::test_for_error at %d != %d\n", i + offset,
+                     m_flags(i));
     }
   }
 
diff --git a/core/unit_test/TestRangePolicyCTAD.cpp b/core/unit_test/TestRangePolicyCTAD.cpp
new file mode 100644
index 0000000000..20288e2b40
--- /dev/null
+++ b/core/unit_test/TestRangePolicyCTAD.cpp
@@ -0,0 +1,150 @@
+//@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_Core_fwd.hpp"
+
+namespace {
+
+struct TestRangePolicyCTAD {
+  struct SomeExecutionSpace {
+    using execution_space = SomeExecutionSpace;
+    using size_type       = size_t;
+
+    [[maybe_unused]] static int concurrency() { return 0; }
+  };
+  static_assert(Kokkos::is_execution_space_v<SomeExecutionSpace>);
+
+  struct ImplicitlyConvertibleToDefaultExecutionSpace {
+    [[maybe_unused]] operator Kokkos::DefaultExecutionSpace() const {
+      return Kokkos::DefaultExecutionSpace();
+    }
+  };
+  static_assert(!Kokkos::is_execution_space_v<
+                ImplicitlyConvertibleToDefaultExecutionSpace>);
+
+  [[maybe_unused]] static inline auto i64 = int64_t();
+  [[maybe_unused]] static inline auto i32 = int32_t();
+  [[maybe_unused]] static inline auto cs  = Kokkos::ChunkSize(0);
+  [[maybe_unused]] static inline auto des = Kokkos::DefaultExecutionSpace();
+  [[maybe_unused]] static inline auto nes =
+      ImplicitlyConvertibleToDefaultExecutionSpace();
+  [[maybe_unused]] static inline auto ses = SomeExecutionSpace();
+
+  // RangePolicy()
+
+  [[maybe_unused]] static inline auto rp = Kokkos::RangePolicy{};
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rp)>);
+
+  // RangePolicy(index_type, index_type)
+
+  [[maybe_unused]] static inline auto rpi64i64 = Kokkos::RangePolicy(i64, i64);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i64)>);
+
+  [[maybe_unused]] static inline auto rpi64i32 = Kokkos::RangePolicy(i64, i32);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i32)>);
+
+  [[maybe_unused]] static inline auto rpi32i64 = Kokkos::RangePolicy(i32, i64);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i64)>);
+
+  [[maybe_unused]] static inline auto rpi32i32 = Kokkos::RangePolicy(i32, i32);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i32)>);
+
+  // RangePolicy(index_type, index_type, ChunkSize)
+
+  [[maybe_unused]] static inline auto rpi64i64cs =
+      Kokkos::RangePolicy(i64, i64, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i64cs)>);
+
+  [[maybe_unused]] static inline auto rpi64i32cs =
+      Kokkos::RangePolicy(i64, i32, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi64i32cs)>);
+
+  [[maybe_unused]] static inline auto rpi32i64cs =
+      Kokkos::RangePolicy(i32, i64, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i64cs)>);
+
+  [[maybe_unused]] static inline auto rpi32i32cs =
+      Kokkos::RangePolicy(i32, i32, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpi32i32cs)>);
+
+  // RangePolicy(execution_space, index_type, index_type)
+
+  [[maybe_unused]] static inline auto rpdesi64i64 =
+      Kokkos::RangePolicy(des, i64, i64);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi64i64)>);
+
+  [[maybe_unused]] static inline auto rpdesi32i32 =
+      Kokkos::RangePolicy(des, i32, i32);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi32i32)>);
+
+  [[maybe_unused]] static inline auto rpnesi64i64 =
+      Kokkos::RangePolicy(nes, i64, i64);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi64i64)>);
+
+  [[maybe_unused]] static inline auto rpnesi32i32 =
+      Kokkos::RangePolicy(nes, i32, i32);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi32i32)>);
+
+  [[maybe_unused]] static inline auto rpsesi64i64 =
+      Kokkos::RangePolicy(ses, i64, i64);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
+                               decltype(rpsesi64i64)>);
+
+  [[maybe_unused]] static inline auto rpsesi32i32 =
+      Kokkos::RangePolicy(ses, i32, i32);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
+                               decltype(rpsesi32i32)>);
+
+  // RangePolicy(execution_space, index_type, index_type, ChunkSize)
+
+  [[maybe_unused]] static inline auto rpdesi64i64cs =
+      Kokkos::RangePolicy(des, i64, i64, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi64i64cs)>);
+
+  [[maybe_unused]] static inline auto rpdesi32i32cs =
+      Kokkos::RangePolicy(des, i32, i32, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpdesi32i32cs)>);
+
+  [[maybe_unused]] static inline auto rpnesi64i64cs =
+      Kokkos::RangePolicy(nes, i64, i64, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi64i64cs)>);
+
+  [[maybe_unused]] static inline auto rpnesi32i32cs =
+      Kokkos::RangePolicy(nes, i32, i32, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<>, decltype(rpnesi32i32cs)>);
+
+  [[maybe_unused]] static inline auto rpsesi64i64cs =
+      Kokkos::RangePolicy(ses, i64, i64, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
+                               decltype(rpsesi64i64cs)>);
+
+  [[maybe_unused]] static inline auto rpsesi32i32cs =
+      Kokkos::RangePolicy(ses, i32, i32, cs);
+  static_assert(std::is_same_v<Kokkos::RangePolicy<SomeExecutionSpace>,
+                               decltype(rpsesi32i32cs)>);
+
+};  // TestRangePolicyCTAD struct
+
+// To eliminate maybe_unused warning on some compilers
+
+[[maybe_unused]] const Kokkos::DefaultExecutionSpace nestodes =
+    TestRangePolicyCTAD::ImplicitlyConvertibleToDefaultExecutionSpace();
+
+[[maybe_unused]] const auto sesconcurrency =
+    TestRangePolicyCTAD::ses.concurrency();
+
+}  // namespace
diff --git a/core/unit_test/TestRangePolicyConstructors.hpp b/core/unit_test/TestRangePolicyConstructors.hpp
index 0a7e59ed98..d6920beed0 100644
--- a/core/unit_test/TestRangePolicyConstructors.hpp
+++ b/core/unit_test/TestRangePolicyConstructors.hpp
@@ -18,6 +18,10 @@
 
 #include <Kokkos_Core.hpp>
 
+#include <regex>
+#include <limits>
+#include <type_traits>
+
 namespace {
 
 TEST(TEST_CATEGORY, range_policy_runtime_parameters) {
@@ -70,4 +74,166 @@ TEST(TEST_CATEGORY, range_policy_runtime_parameters) {
   }
 }
 
+TEST(TEST_CATEGORY_DEATH, range_policy_invalid_bounds) {
+  using Policy    = Kokkos::RangePolicy<TEST_EXECSPACE>;
+  using ChunkSize = Kokkos::ChunkSize;
+
+  std::string msg =
+      "Kokkos::RangePolicy bounds error: The lower bound (100) is greater than "
+      "the upper bound (90).\n";
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  // escape the parentheses in the regex to match the error message
+  msg = std::regex_replace(msg, std::regex("\\(|\\)"), "\\$&");
+  ASSERT_DEATH({ (void)Policy(100, 90); }, msg);
+
+  ASSERT_DEATH({ (void)Policy(TEST_EXECSPACE(), 100, 90, ChunkSize(10)); },
+               msg);
+#else
+
+  if (!Kokkos::show_warnings()) {
+    GTEST_SKIP() << "Kokkos warning messages are disabled";
+  }
+
+  {
+    ::testing::internal::CaptureStderr();
+    Policy policy(100, 90);
+    ASSERT_EQ((int)policy.begin(), 0);
+    ASSERT_EQ((int)policy.end(), 0);
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+    ASSERT_EQ(::testing::internal::GetCapturedStderr(), msg);
+#else
+    ASSERT_TRUE(::testing::internal::GetCapturedStderr().empty());
+    (void)msg;
+#endif
+  }
+
+  {
+    ::testing::internal::CaptureStderr();
+    Policy policy(TEST_EXECSPACE(), 100, 90, ChunkSize(10));
+    ASSERT_EQ((int)policy.begin(), 0);
+    ASSERT_EQ((int)policy.end(), 0);
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+    ASSERT_EQ(::testing::internal::GetCapturedStderr(), msg);
+#else
+    ASSERT_TRUE(::testing::internal::GetCapturedStderr().empty());
+    (void)msg;
+#endif
+  }
+
+#endif
+}
+
+TEST(TEST_CATEGORY_DEATH, range_policy_implicitly_converted_bounds) {
+  using UIntIndexType = Kokkos::IndexType<unsigned>;
+  using IntIndexType  = Kokkos::IndexType<int>;
+  using UIntPolicy    = Kokkos::RangePolicy<TEST_EXECSPACE, UIntIndexType>;
+  using IntPolicy     = Kokkos::RangePolicy<TEST_EXECSPACE, IntIndexType>;
+
+  std::string msg =
+      "Kokkos::RangePolicy bound type error: an unsafe implicit conversion is "
+      "performed on a bound (), which may not preserve its original value.\n";
+
+  auto get_error_msg = [](auto str, auto val) {
+    return str.insert(str.find("(") + 1, std::to_string(val).c_str());
+  };
+#ifndef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  std::string expected = std::regex_replace(msg, std::regex("\\(|\\)"), "\\$&");
+  {
+    int test_val = -1;
+    ASSERT_DEATH({ (void)UIntPolicy(test_val, 10); },
+                 get_error_msg(expected, test_val));
+  }
+  {
+    unsigned test_val = std::numeric_limits<unsigned>::max();
+    ASSERT_DEATH({ (void)IntPolicy(0u, test_val); },
+                 get_error_msg(expected, test_val));
+  }
+  {
+    long long test_val = std::numeric_limits<long long>::max();
+    ASSERT_DEATH({ (void)IntPolicy(0LL, test_val); },
+                 get_error_msg(expected, test_val));
+  }
+  {
+    int test_val = -1;
+    ASSERT_DEATH({ (void)UIntPolicy(test_val, 10, Kokkos::ChunkSize(2)); },
+                 get_error_msg(expected, test_val));
+  }
+
+#else
+  {
+    ::testing::internal::CaptureStderr();
+    int test_val = -1;
+    UIntPolicy policy(test_val, 10);
+    ASSERT_EQ(policy.begin(), 0u);
+    ASSERT_EQ(policy.end(), 0u);
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+    if (Kokkos::show_warnings()) {
+      auto s = std::string(::testing::internal::GetCapturedStderr());
+      ASSERT_EQ(s.substr(0, s.find("\n") + 1), get_error_msg(msg, test_val));
+    }
+#else
+    ASSERT_TRUE(::testing::internal::GetCapturedStderr().empty());
+    (void)msg;
+    (void)get_error_msg;
+#endif
+  }
+  {
+    ::testing::internal::CaptureStderr();
+    unsigned test_val = std::numeric_limits<unsigned>::max();
+    IntPolicy policy(0u, test_val);
+    ASSERT_EQ(policy.begin(), 0);
+    ASSERT_EQ(policy.end(), 0);
+#ifdef KOKKOS_ENABLE_DEPRECATION_WARNINGS
+    if (Kokkos::show_warnings()) {
+      auto s = std::string(::testing::internal::GetCapturedStderr());
+      ASSERT_EQ(s.substr(0, s.find("\n") + 1), get_error_msg(msg, test_val));
+    }
+#else
+    ASSERT_TRUE(::testing::internal::GetCapturedStderr().empty());
+    (void)msg;
+    (void)get_error_msg;
+#endif
+  }
+#endif
+}
+
+constexpr bool test_chunk_size_explicit() {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using Kokkos::ChunkSize;
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+  static_assert(std::is_convertible_v<int, ChunkSize>);
+  static_assert(std::is_constructible_v<ChunkSize, int>);
+  // Some execution spaces were implicitly constructible from int
+  // which made the constructor call ambiguous.
+  static_assert(
+      std::is_constructible_v<Kokkos::DefaultExecutionSpace, int> ||
+      std::is_constructible_v<
+          Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>, int, int, int>);
+  static_assert(std::is_constructible_v<
+                Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>, int, int,
+                ChunkSize>);
+  static_assert(std::is_constructible_v<Kokkos::RangePolicy<ExecutionSpace>,
+                                        ExecutionSpace, int, int, int>);
+  static_assert(std::is_constructible_v<Kokkos::RangePolicy<ExecutionSpace>,
+                                        ExecutionSpace, int, int, ChunkSize>);
+#else
+  static_assert(!std::is_convertible_v<int, ChunkSize>);
+  static_assert(std::is_constructible_v<ChunkSize, int>);
+  static_assert(
+      !std::is_constructible_v<
+          Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>, int, int, int>);
+  static_assert(std::is_constructible_v<
+                Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>, int, int,
+                ChunkSize>);
+  static_assert(!std::is_constructible_v<Kokkos::RangePolicy<ExecutionSpace>,
+                                         ExecutionSpace, int, int, int>);
+  static_assert(std::is_constructible_v<Kokkos::RangePolicy<ExecutionSpace>,
+                                        ExecutionSpace, int, int, ChunkSize>);
+#endif
+  return true;
+}
+
+static_assert(test_chunk_size_explicit());
+
 }  // namespace
diff --git a/core/unit_test/TestRangePolicyRequire.hpp b/core/unit_test/TestRangePolicyRequire.hpp
index 4057216288..975ac8bd7e 100644
--- a/core/unit_test/TestRangePolicyRequire.hpp
+++ b/core/unit_test/TestRangePolicyRequire.hpp
@@ -142,8 +142,8 @@ struct TestRangeRequire {
   KOKKOS_INLINE_FUNCTION
   void operator()(const VerifyInitTag &, const int i) const {
     if (i != m_flags(i)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "TestRangeRequire::test_for error at %d != %d\n", i, m_flags(i));
+      Kokkos::printf("TestRangeRequire::test_for error at %d != %d\n", i,
+                     m_flags(i));
     }
   }
 
@@ -155,8 +155,8 @@ struct TestRangeRequire {
   KOKKOS_INLINE_FUNCTION
   void operator()(const VerifyResetTag &, const int i) const {
     if (2 * i != m_flags(i)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "TestRangeRequire::test_for error at %d != %d\n", i, m_flags(i));
+      Kokkos::printf("TestRangeRequire::test_for error at %d != %d\n", i,
+                     m_flags(i));
     }
   }
 
@@ -168,9 +168,8 @@ struct TestRangeRequire {
   KOKKOS_INLINE_FUNCTION
   void operator()(const VerifyOffsetTag &, const int i) const {
     if (i + offset != m_flags(i)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "TestRangeRequire::test_for error at %d != %d\n", i + offset,
-          m_flags(i));
+      Kokkos::printf("TestRangeRequire::test_for error at %d != %d\n",
+                     i + offset, m_flags(i));
     }
   }
 
diff --git a/core/unit_test/TestRealloc.hpp b/core/unit_test/TestRealloc.hpp
index 2c9dc5ee47..f30c9e15e1 100644
--- a/core/unit_test/TestRealloc.hpp
+++ b/core/unit_test/TestRealloc.hpp
@@ -144,6 +144,11 @@ void impl_testRealloc() {
     EXPECT_EQ(oldPointer, newPointer);
   }
 }
+struct NoDefaultConstructor {
+  int value;
+  KOKKOS_FUNCTION
+  NoDefaultConstructor(int x) : value(x) {}
+};
 
 template <class DeviceType>
 void testRealloc() {
@@ -154,6 +159,14 @@ void testRealloc() {
     impl_testRealloc<DeviceType,
                      WithoutInitializing>();  // without data initialization
   }
+  // Check #6992 fix (no default initialization in realloc without initializing)
+  {
+    using view_type = Kokkos::View<NoDefaultConstructor*, DeviceType>;
+    view_type view_1d_no_default(
+        Kokkos::view_alloc(Kokkos::WithoutInitializing, "view_1d_no_default"),
+        5);
+    realloc_dispatch(WithoutInitializing{}, view_1d_no_default, 3);
+  }
 }
 
 }  // namespace TestViewRealloc
diff --git a/core/unit_test/TestReduce.hpp b/core/unit_test/TestReduce.hpp
index e1aa851f10..61b2bfb150 100644
--- a/core/unit_test/TestReduce.hpp
+++ b/core/unit_test/TestReduce.hpp
@@ -625,4 +625,30 @@ TEST(TEST_CATEGORY, int_combined_reduce_mixed) {
 }
 #endif
 #endif
+
+#if defined(NDEBUG)
+// the following test was made for:
+// https://github.com/kokkos/kokkos/issues/6517
+
+struct FunctorReductionWithLargeIterationCount {
+  KOKKOS_FUNCTION void operator()(const int64_t /*i*/, double& update) const {
+    update += 1.0;
+  }
+};
+
+TEST(TEST_CATEGORY, reduction_with_large_iteration_count) {
+  if constexpr (std::is_same_v<typename TEST_EXECSPACE::memory_space,
+                               Kokkos::HostSpace>) {
+    GTEST_SKIP() << "Disabling for host backends";
+  }
+
+  const int64_t N = pow(2LL, 39LL) - pow(2LL, 8LL) + 1;
+  Kokkos::RangePolicy<TEST_EXECSPACE, Kokkos::IndexType<int64_t>> p(0, N);
+  double nu = 0;
+  EXPECT_NO_THROW(Kokkos::parallel_reduce(
+      "sample reduction", p, FunctorReductionWithLargeIterationCount(), nu));
+  ASSERT_DOUBLE_EQ(nu, double(N));
+}
+#endif
+
 }  // namespace Test
diff --git a/core/unit_test/TestReducers.hpp b/core/unit_test/TestReducers.hpp
index ce71f334e0..fbcb9629af 100644
--- a/core/unit_test/TestReducers.hpp
+++ b/core/unit_test/TestReducers.hpp
@@ -19,6 +19,7 @@
 #include <limits>
 
 #include <Kokkos_Core.hpp>
+#include <TestNonTrivialScalarTypes.hpp>
 
 //--------------------------------------------------------------------------
 
@@ -46,6 +47,37 @@ struct TestReducers {
     void operator()(const int& i, Scalar& value) const { value += values(i); }
   };
 
+  struct TeamSumFunctor {
+    using member_type = typename Kokkos::TeamPolicy<ExecSpace>::member_type;
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const member_type& m, Scalar& value) const {
+      if (m.team_rank() == m.team_size() - 1) value += Scalar(1);
+    }
+  };
+
+  struct TeamSumNestedFunctor {
+    using member_type = typename Kokkos::TeamPolicy<ExecSpace>::member_type;
+
+    SumFunctor f;
+    int M, N;
+    Kokkos::View<Scalar*, ExecSpace> result;
+
+    TeamSumNestedFunctor(SumFunctor& f_, const int M_, const int N_,
+                         Kokkos::View<Scalar*, ExecSpace> result_)
+        : f(f_), M(M_), N(N_), result(result_) {}
+
+    KOKKOS_INLINE_FUNCTION
+    void operator()(const member_type& m) const {
+      const int i = m.league_rank();
+      Scalar local_scalar;
+      Kokkos::Sum<Scalar, typename ExecSpace::memory_space> reducer_scalar(
+          local_scalar);
+      Kokkos::parallel_reduce(Kokkos::TeamThreadRange(m, N), f, reducer_scalar);
+      result(i) = local_scalar;
+    }
+  };
+
   struct ProdFunctor {
     Kokkos::View<const Scalar*, ExecSpace> values;
 
@@ -319,6 +351,102 @@ struct TestReducers {
       value = value || values(i);
     }
   };
+
+  // get number of teams for TeamPolicy depending on the tested type
+  constexpr static int get_num_teams() {
+    if constexpr (sizeof(Scalar) == 1) {
+      return 126;
+    } else if constexpr (std::is_same_v<Scalar,
+                                        Kokkos::Experimental::bhalf_t>) {
+      return 256;
+    }
+
+    return 1024;
+  }
+
+  static void test_sum_team_policy(int N, SumFunctor f, Scalar reference_sum) {
+#ifdef KOKKOS_ENABLE_OPENACC
+    if constexpr (std::is_same_v<ExecSpace, Kokkos::Experimental::OpenACC> &&
+                  (std::is_same_v<Scalar, size_t> ||
+                   std::is_same_v<Scalar, double>)) {
+      return;  // FIXME_OPENACC
+    }
+#endif
+
+    Scalar sum_scalar;
+    Kokkos::View<Scalar, ExecSpace> sum_view("result");
+    Kokkos::deep_copy(sum_view, Scalar(1));
+
+    // Test team policy reduction
+    {
+      constexpr int num_teams = get_num_teams();
+      TeamSumFunctor tf;
+      // FIXME_OPENMPTARGET temporary restriction for team size to be at least
+      // 32
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+      int team_size =
+          std::is_same<ExecSpace, Kokkos::Experimental::OpenMPTarget>::value
+              ? 32
+              : 1;
+#else
+      int team_size         = 1;
+#endif
+      auto team_pol = Kokkos::TeamPolicy<ExecSpace>(num_teams, team_size);
+      Kokkos::parallel_reduce(team_pol, tf, sum_view);
+      Kokkos::deep_copy(sum_scalar, sum_view);
+      ASSERT_EQ(sum_scalar, Scalar{num_teams}) << "num_teams: " << num_teams;
+    }
+
+    // Test TeamThreadRange level reduction with 0 work produces 0 result
+    {
+      const int league_size = 1;
+      Kokkos::View<Scalar*, ExecSpace> result("result", league_size);
+      TeamSumNestedFunctor tnf(f, league_size, 0, result);
+      // FIXME_OPENMPTARGET temporary restriction for team size to be at least
+      // 32
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+      int team_size =
+          std::is_same<ExecSpace, Kokkos::Experimental::OpenMPTarget>::value
+              ? 32
+              : 1;
+#else
+      int team_size         = 1;
+#endif
+      auto team_pol = Kokkos::TeamPolicy<ExecSpace>(1, team_size);
+      Kokkos::parallel_for(team_pol, tnf);
+      auto result_h =
+          Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), result);
+      ASSERT_EQ(result_h(0), Scalar{0}) << "N: " << N;
+    }
+
+    // Same test as above, but with inner reduction over N, and league_size=10
+    {
+      const int league_size = 10;
+      Kokkos::View<Scalar*, ExecSpace> result("result", league_size);
+      TeamSumNestedFunctor tnf(f, league_size, N, result);
+      // FIXME_OPENMPTARGET temporary restriction for team size to be at least
+      // 32
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+      int initial_team_size =
+          std::is_same_v<ExecSpace, Kokkos::Experimental::OpenMPTarget> ? 32
+                                                                        : 1;
+#else
+      int initial_team_size = 1;
+#endif
+      auto team_size_max =
+          Kokkos::TeamPolicy<ExecSpace>(league_size, initial_team_size)
+              .team_size_max(tnf, Kokkos::ParallelForTag());
+      auto team_size = std::min(team_size_max, TEST_EXECSPACE().concurrency());
+      auto team_pol  = Kokkos::TeamPolicy<ExecSpace>(league_size, team_size);
+      Kokkos::parallel_for(team_pol, tnf);
+      auto result_h =
+          Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), result);
+      for (int i = 0; i < result_h.extent_int(0); ++i) {
+        ASSERT_EQ(result_h(i), reference_sum) << "N: " << N;
+      }
+    }
+  }
+
   static void test_sum(int N) {
     Kokkos::View<Scalar*, ExecSpace> values("Values", N);
     auto h_values        = Kokkos::create_mirror_view(values);
@@ -374,6 +502,8 @@ struct TestReducers {
       ASSERT_EQ(sum_scalar_view, reference_sum) << "N: " << N;
     }
 
+    test_sum_team_policy(N, f, reference_sum);
+
     {
       Kokkos::View<Scalar, Kokkos::HostSpace> sum_view("View");
       sum_view() = Scalar(1);
@@ -1210,7 +1340,8 @@ struct TestReducers {
 // 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)
+#if defined(KOKKOS_COMPILER_CLANG) && (KOKKOS_COMPILER_CLANG >= 1300) && \
+    (KOKKOS_COMPILER_CLANG <= 1700)
     test_minmaxloc(10007);
 #else
     if (!std::is_same_v<ExecSpace, Kokkos::Experimental::OpenMPTarget>)
@@ -1233,7 +1364,6 @@ struct TestReducers {
 #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
@@ -1241,13 +1371,11 @@ struct TestReducers {
 #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_COMPILER_NVHPC)  // FIXME_NVHPC misaligned memory
 #if defined(KOKKOS_ENABLE_CUDA)
     if (!std::is_same_v<ExecSpace, Kokkos::Cuda>)
 #endif
@@ -1256,7 +1384,6 @@ struct TestReducers {
       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,
diff --git a/core/unit_test/TestReducers_b.hpp b/core/unit_test/TestReducers_b.hpp
index a55870776e..dedd161f6a 100644
--- a/core/unit_test/TestReducers_b.hpp
+++ b/core/unit_test/TestReducers_b.hpp
@@ -16,8 +16,12 @@
 
 #include <TestReducers.hpp>
 
+// FIXME_OPENMPTARGET - Fails at runtime post clang/16
+#if defined(KOKKOS_ENABLE_OPENMPTARGER) && defined(KOKKOS_COMPILER_CLANG) && \
+    (KOKKOS_COMPILER_CLANG >= 1600)
 namespace Test {
 TEST(TEST_CATEGORY, reducers_size_t) {
   TestReducers<size_t, TEST_EXECSPACE>::execute_integer();
 }
 }  // namespace Test
+#endif
diff --git a/core/unit_test/TestReducers_d.hpp b/core/unit_test/TestReducers_d.hpp
index 19eaa6d700..ecf851aa10 100644
--- a/core/unit_test/TestReducers_d.hpp
+++ b/core/unit_test/TestReducers_d.hpp
@@ -80,6 +80,20 @@ TEST(TEST_CATEGORY, reducers_int8_t) {
   TestReducers<ThisTestType, TEST_EXECSPACE>::test_prod(4);
 }
 
+TEST(TEST_CATEGORY, reducers_int16_t) {
+  using ThisTestType = int16_t;
+
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_sum(1);
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_sum(2);
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_sum(3);
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_sum(4);
+
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_prod(1);
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_prod(2);
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_prod(3);
+  TestReducers<ThisTestType, TEST_EXECSPACE>::test_prod(4);
+}
+
 #if !defined(KOKKOS_ENABLE_HIP) && !defined(KOKKOS_ENABLE_OPENMPTARGET)
 // TODO - resolve: "Kokkos_HIP_Vectorization.hpp:80:15: error: call to
 //                 implicitly-deleted default constructor of 'conv_type'
diff --git a/core/unit_test/TestResize.hpp b/core/unit_test/TestResize.hpp
index 13d7e16d58..3102d2b9a1 100644
--- a/core/unit_test/TestResize.hpp
+++ b/core/unit_test/TestResize.hpp
@@ -358,6 +358,12 @@ void impl_testResize() {
   }
 }
 
+struct NoDefaultConstructor {
+  int value;
+  KOKKOS_FUNCTION
+  NoDefaultConstructor(int x) : value(x) {}
+};
+
 template <class DeviceType>
 void testResize() {
   {
@@ -367,6 +373,13 @@ void testResize() {
     impl_testResize<DeviceType,
                     WithoutInitializing>();  // without data initialization
   }
+  {
+    using view_type = Kokkos::View<NoDefaultConstructor*, DeviceType>;
+    view_type view_1d_no_default(
+        Kokkos::view_alloc(Kokkos::WithoutInitializing, "view_1d_no_default"),
+        5);
+    resize_dispatch(WithoutInitializing{}, view_1d_no_default, 3);
+  }
 }
 
 }  // namespace TestViewResize
diff --git a/core/unit_test/TestSharedSpace.cpp b/core/unit_test/TestSharedSpace.cpp
index 8112c956db..3e59b79613 100644
--- a/core/unit_test/TestSharedSpace.cpp
+++ b/core/unit_test/TestSharedSpace.cpp
@@ -104,10 +104,10 @@ TEST(defaultdevicetype, shared_space) {
                                Kokkos::DefaultHostExecutionSpace>)
     GTEST_SKIP() << "Skipping as host and device are the same space";
 
-#if defined(KOKKOS_ARCH_VEGA906) || defined(KOKKOS_ARCH_VEGA908) || \
-    defined(KOKKOS_ARCH_NAVI)
-  GTEST_SKIP()
-      << "skipping because specified arch does not support page migration";
+#if defined(KOKKOS_ARCH_AMD_GPU) && defined(KOKKOS_ENABLE_HIP)
+  if (!Kokkos::SharedSpace().impl_hip_driver_check_page_migration())
+    GTEST_SKIP()
+        << "skipping because specified arch does not support page migration";
 #endif
 #if defined(KOKKOS_ENABLE_SYCL) && !defined(KOKKOS_ARCH_INTEL_GPU)
   GTEST_SKIP()
diff --git a/core/unit_test/TestSpaceAwareAccessor.hpp b/core/unit_test/TestSpaceAwareAccessor.hpp
new file mode 100644
index 0000000000..2fad17cb85
--- /dev/null
+++ b/core/unit_test/TestSpaceAwareAccessor.hpp
@@ -0,0 +1,156 @@
+//@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 <type_traits>
+
+#include <gtest/gtest.h>
+#ifndef KOKKOS_ENABLE_CXX17
+#include <concepts>
+#endif
+
+template <class T>
+struct funky_data_handle {
+  T* val;
+
+  KOKKOS_FUNCTION
+  operator T*() { return val; }
+  KOKKOS_FUNCTION
+  operator const T*() const { return val; }
+};
+
+template <class ElementType>
+struct FunkyAcc {
+  using element_type     = ElementType;
+  using reference        = std::conditional_t<std::is_const_v<element_type>,
+                                       element_type, element_type&>;
+  using data_handle_type = funky_data_handle<element_type>;
+  using offset_policy    = Kokkos::default_accessor<element_type>;
+  KOKKOS_FUNCTION
+  reference access(data_handle_type p, size_t i) const { return p.val[i]; }
+  KOKKOS_FUNCTION
+  element_type* offset(data_handle_type p, size_t i) const { return p.val + i; }
+};
+
+template <class T, class ExecutionSpace,
+          class MemorySpace = typename ExecutionSpace::memory_space>
+void test_space_aware_accessor() {
+  using memory_space_t = MemorySpace;
+  using value_type     = std::remove_const_t<T>;
+  Kokkos::View<value_type*, ExecutionSpace> v("V", 100);
+
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecutionSpace>(0, v.extent(0)),
+      KOKKOS_LAMBDA(int i) { v(i) = i; });
+
+  int errors;
+  using acc_t = Kokkos::Impl::SpaceAwareAccessor<memory_space_t, FunkyAcc<T>>;
+  acc_t acc{};
+  typename acc_t::data_handle_type ptr{v.data()};
+
+  Kokkos::parallel_reduce(
+      Kokkos::RangePolicy<ExecutionSpace>(0, v.extent(0)),
+      KOKKOS_LAMBDA(int i, int& error) {
+        if (acc.access(ptr, i) != ptr[i]) error++;
+        if (acc.offset(ptr, i) != ptr + i) error++;
+        static_assert(std::is_same_v<typename acc_t::element_type, T>);
+        if constexpr (std::is_const_v<T>) {
+          static_assert(std::is_same_v<typename acc_t::reference, T>);
+        } else {
+          static_assert(std::is_same_v<typename acc_t::reference, T&>);
+        }
+        static_assert(std::is_same_v<typename acc_t::data_handle_type,
+                                     funky_data_handle<T>>);
+        static_assert(
+            std::is_same_v<typename acc_t::offset_policy,
+                           Kokkos::Impl::SpaceAwareAccessor<
+                               memory_space_t, Kokkos::default_accessor<T>>>);
+        if constexpr (std::is_const_v<T>) {
+          static_assert(std::is_same_v<decltype(acc.access(ptr, i)),
+                                       std::remove_const_t<T>>);
+        } else {
+          static_assert(std::is_same_v<decltype(acc.access(ptr, i)), T&>);
+        }
+        static_assert(std::is_same_v<decltype(acc.offset(ptr, i)), T*>);
+        static_assert(std::is_same_v<decltype(acc.nested_accessor()),
+                                     const FunkyAcc<T>&>);
+        static_assert(std::is_nothrow_move_constructible_v<acc_t>);
+        static_assert(std::is_nothrow_move_assignable_v<acc_t>);
+        static_assert(std::is_nothrow_swappable_v<acc_t>);
+        static_assert(
+            std::is_same_v<typename acc_t::memory_space, memory_space_t>);
+        static_assert(
+            std::is_same_v<typename acc_t::nested_accessor_type, FunkyAcc<T>>);
+#ifndef KOKKOS_ENABLE_CXX17
+        static_assert(std::copyable<acc_t>);
+        static_assert(std::is_empty_v<acc_t>);
+#endif
+      },
+      errors);
+  ASSERT_EQ(errors, 0);
+}
+
+void test_space_aware_accessor_conversion() {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using memory_space_t = typename ExecutionSpace::memory_space;
+  using T              = float;
+  using acc_t          = Kokkos::Impl::SpaceAwareAccessor<memory_space_t,
+                                                 Kokkos::default_accessor<T>>;
+  using const_acc_t =
+      Kokkos::Impl::SpaceAwareAccessor<memory_space_t,
+                                       Kokkos::default_accessor<const T>>;
+  using int_acc_t =
+      Kokkos::Impl::SpaceAwareAccessor<memory_space_t,
+                                       Kokkos::default_accessor<int>>;
+  using host_acc_t =
+      Kokkos::Impl::SpaceAwareAccessor<Kokkos::HostSpace,
+                                       Kokkos::default_accessor<T>>;
+  using anon_acc_t =
+      Kokkos::Impl::SpaceAwareAccessor<Kokkos::AnonymousSpace,
+                                       Kokkos::default_accessor<T>>;
+
+  Kokkos::parallel_for(
+      Kokkos::RangePolicy<ExecutionSpace>(0, 1), KOKKOS_LAMBDA(int) {
+        static_assert(std::is_constructible_v<const_acc_t, acc_t>);
+        static_assert(std::is_convertible_v<acc_t, const_acc_t>);
+        static_assert(!std::is_constructible_v<acc_t, const_acc_t>);
+        static_assert(!std::is_constructible_v<acc_t, int_acc_t>);
+        static_assert(
+            std::is_constructible_v<acc_t, host_acc_t> ==
+            Kokkos::Impl::MemorySpaceAccess<memory_space_t,
+                                            Kokkos::HostSpace>::assignable);
+        static_assert(
+            std::is_constructible_v<host_acc_t, acc_t> ==
+            Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                            memory_space_t>::assignable);
+        static_assert(std::is_constructible_v<anon_acc_t, acc_t>);
+        static_assert(std::is_constructible_v<acc_t, anon_acc_t>);
+        static_assert(std::is_convertible_v<anon_acc_t, acc_t>);
+        static_assert(std::is_convertible_v<acc_t, anon_acc_t>);
+      });
+}
+
+TEST(TEST_CATEGORY, mdspan_space_aware_accessor) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  test_space_aware_accessor<int, ExecutionSpace>();
+  test_space_aware_accessor<double, ExecutionSpace>();
+  test_space_aware_accessor<const int, ExecutionSpace>();
+  test_space_aware_accessor<const double, ExecutionSpace>();
+  test_space_aware_accessor<double, ExecutionSpace, Kokkos::AnonymousSpace>();
+  test_space_aware_accessor<const int, ExecutionSpace,
+                            Kokkos::AnonymousSpace>();
+  test_space_aware_accessor_conversion();
+}
diff --git a/core/unit_test/TestSpaceAwareAccessorAccessViolation.hpp b/core/unit_test/TestSpaceAwareAccessorAccessViolation.hpp
new file mode 100644
index 0000000000..b9982d5fc4
--- /dev/null
+++ b/core/unit_test/TestSpaceAwareAccessorAccessViolation.hpp
@@ -0,0 +1,128 @@
+//@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>
+
+template <class MemorySpace, class ExecutionSpace>
+struct TestMemoryAccessViolation {
+  Kokkos::Impl::SpaceAwareAccessor<MemorySpace, Kokkos::default_accessor<int>>
+      acc;
+
+  KOKKOS_FUNCTION decltype(auto) bad_access() const {
+    return acc.access(nullptr, 0);
+  }
+
+  KOKKOS_FUNCTION void operator()(int) const { ++bad_access(); }
+
+  TestMemoryAccessViolation(ExecutionSpace const& s,
+                            std::string const& matcher) {
+    constexpr bool accessible_from_execution_space = Kokkos::SpaceAccessibility<
+        /*AccessSpace=*/ExecutionSpace,
+        /*MemorySpace=*/MemorySpace>::accessible;
+    EXPECT_FALSE(accessible_from_execution_space);
+    EXPECT_DEATH(
+        {
+          Kokkos::parallel_for(Kokkos::RangePolicy<ExecutionSpace>(s, 0, 1),
+                               *this);
+          Kokkos::fence();
+        },
+        matcher);
+  }
+};
+
+template <class MemorySpace, class ExecutionSpace>
+void test_memory_access_violation(ExecutionSpace const& s,
+                                  std::string const& m) {
+  TestMemoryAccessViolation<MemorySpace, ExecutionSpace>(s, m);
+}
+
+template <class ExecutionSpace>
+void test_memory_access_violations_from_host() {
+  using memory_space_t = typename ExecutionSpace::memory_space;
+  using exec_space_t   = Kokkos::DefaultHostExecutionSpace;
+  const exec_space_t exec_space{};
+  std::string const message =
+      "Kokkos::SpaceAwareAccessor ERROR: attempt to access inaccessible memory "
+      "space";
+  test_memory_access_violation<memory_space_t, exec_space_t>(exec_space,
+                                                             message);
+}
+
+template <class ExecutionSpace>
+void test_memory_access_violations_from_device() {
+  using memory_space_t = Kokkos::HostSpace;
+  using exec_space_t   = ExecutionSpace;
+  const exec_space_t exec_space{};
+  std::string const message =
+      "Kokkos::SpaceAwareAccessor ERROR: attempt to access inaccessible memory "
+      "space";
+  test_memory_access_violation<memory_space_t, exec_space_t>(exec_space,
+                                                             message);
+}
+
+// FIXME_SYCL
+#if !(defined(KOKKOS_COMPILER_INTEL_LLVM) && defined(KOKKOS_ENABLE_SYCL))
+TEST(TEST_CATEGORY_DEATH,
+     mdspan_space_aware_accessor_invalid_access_from_host) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  if (Kokkos::SpaceAccessibility<
+          /*AccessSpace=*/Kokkos::HostSpace,
+          /*MemorySpace=*/typename ExecutionSpace::memory_space>::accessible) {
+    GTEST_SKIP() << "skipping since no memory access violation would occur";
+  }
+
+  test_memory_access_violations_from_host<ExecutionSpace>();
+}
+#endif
+
+TEST(TEST_CATEGORY_DEATH,
+     mdspan_space_aware_accessor_invalid_access_from_device) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  if (Kokkos::SpaceAccessibility<
+          /*AccessSpace=*/ExecutionSpace,
+          /*MemorySpace=*/Kokkos::HostSpace>::accessible) {
+    GTEST_SKIP() << "skipping since no memory access violation would occur";
+  }
+
+#if defined(KOKKOS_ENABLE_SYCL) && defined(NDEBUG)  // FIXME_SYCL
+  if (std::is_same<ExecutionSpace, Kokkos::Experimental::SYCL>::value) {
+    GTEST_SKIP() << "skipping SYCL device-side abort does not work when NDEBUG "
+                    "is defined";
+  }
+#endif
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)  // FIXME_OPENMPTARGET
+  if (std::is_same<ExecutionSpace, Kokkos::Experimental::OpenMPTarget>::value) {
+    GTEST_SKIP() << "skipping because OpenMPTarget backend is currently not "
+                    "able to abort from the device";
+  }
+#endif
+#if defined(KOKKOS_ENABLE_OPENACC)  // FIXME_OPENACC
+  if (std::is_same<ExecutionSpace, Kokkos::Experimental::OpenACC>::value) {
+    GTEST_SKIP() << "skipping because OpenACC backend is currently not "
+                    "able to abort from the device";
+  }
+#endif
+
+  test_memory_access_violations_from_device<ExecutionSpace>();
+}
diff --git a/core/unit_test/TestSwap.hpp b/core/unit_test/TestSwap.hpp
new file mode 100644
index 0000000000..4e98351cf1
--- /dev/null
+++ b/core/unit_test/TestSwap.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>
+#include <type_traits>
+#include <utility>
+
+namespace {
+
+template <class ExecutionSpace>
+struct TestSwap {
+  KOKKOS_FUNCTION void operator()(int, int& err) const {
+    {
+      int a = 1;
+      int b = 2;
+      Kokkos::kokkos_swap(a, b);
+      if (!(a == 2 && b == 1)) {
+        Kokkos::printf("Failed Kokkos::kokkos_swap(int, int)\n");
+        ++err;
+      }
+    }
+    {
+      float a = 1;
+      float b = 2;
+      Kokkos::kokkos_swap(a, b);
+      if (!(a == 2 && b == 1)) {
+        Kokkos::printf("Failed Kokkos::kokkos_swap(float, float)\n");
+        ++err;
+      }
+    }
+    {
+      int a[3] = {1, 2, 3};
+      int b[3] = {4, 5, 6};
+      Kokkos::kokkos_swap(a, b);
+      if (!(a[0] == 4 && a[1] == 5 && a[2] == 6 && b[0] == 1 && b[1] == 2 &&
+            b[2] == 3)) {
+        Kokkos::printf("Failed Kokkos::kokkos_swap(int[3], int[3])\n");
+        ++err;
+      }
+    }
+  }
+
+  TestSwap() {
+    int errors;
+    Kokkos::parallel_reduce(
+        "TestSwap", Kokkos::RangePolicy<ExecutionSpace>(0, 1), *this, errors);
+    EXPECT_EQ(errors, 0);
+  }
+};
+
+TEST(TEST_CATEGORY, kokkos_swap) { TestSwap<TEST_EXECSPACE>(); }
+
+}  // namespace
diff --git a/core/unit_test/TestTaskScheduler.hpp b/core/unit_test/TestTaskScheduler.hpp
index 1d72662ad2..e9f3a65568 100644
--- a/core/unit_test/TestTaskScheduler.hpp
+++ b/core/unit_test/TestTaskScheduler.hpp
@@ -711,7 +711,7 @@ struct TestMultipleDependence {
     using value_type = int;
     KOKKOS_INLINE_FUNCTION
     void operator()(typename Scheduler::member_type&, int& result) {
-      double value = 0;
+      double value = 1;
       // keep this one busy for a while
       for (int i = 0; i < 10000; ++i) {
         value += i * i / 7.138 / value;
diff --git a/core/unit_test/TestTeam.hpp b/core/unit_test/TestTeam.hpp
index f2a064cbc9..0a40856f93 100644
--- a/core/unit_test/TestTeam.hpp
+++ b/core/unit_test/TestTeam.hpp
@@ -69,10 +69,9 @@ struct TestTeamPolicy {
         member.team_rank() + member.team_size() * member.league_rank();
 
     if (tid != m_flags(member.team_rank(), member.league_rank())) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "TestTeamPolicy member(%d,%d) error %d != %d\n", member.league_rank(),
-          member.team_rank(), tid,
-          m_flags(member.team_rank(), member.league_rank()));
+      Kokkos::printf("TestTeamPolicy member(%d,%d) error %d != %d\n",
+                     member.league_rank(), member.team_rank(), tid,
+                     m_flags(member.team_rank(), member.league_rank()));
     }
   }
 
@@ -391,7 +390,7 @@ class ScanTeamFunctor {
     ind.team_reduce(Kokkos::Max<int64_t>(m));
 
     if (m != ind.league_rank() + (ind.team_size() - 1)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+      Kokkos::printf(
           "ScanTeamFunctor[%i.%i of %i.%i] reduce_max_answer(%li) != "
           "reduce_max(%li)\n",
           static_cast<int>(ind.league_rank()),
@@ -413,7 +412,7 @@ class ScanTeamFunctor {
         ind.team_scan(ind.league_rank() + 1 + ind.team_rank() + 1);
 
     if (answer != result || answer != result2) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+      Kokkos::printf(
           "ScanTeamFunctor[%i.%i of %i.%i] answer(%li) != scan_first(%li) or "
           "scan_second(%li)\n",
           static_cast<int>(ind.league_rank()),
@@ -515,7 +514,7 @@ struct SharedTeamFunctor {
 
     if ((shared_A.data() == nullptr && SHARED_COUNT > 0) ||
         (shared_B.data() == nullptr && SHARED_COUNT > 0)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+      Kokkos::printf(
           "member( %i/%i , %i/%i ) Failed to allocate shared memory of size "
           "%lu\n",
           static_cast<int>(ind.league_rank()),
@@ -644,9 +643,8 @@ struct TestLambdaSharedTeam {
 
           if ((shared_A.data() == nullptr && SHARED_COUNT > 0) ||
               (shared_B.data() == nullptr && SHARED_COUNT > 0)) {
-            KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-                "Failed to allocate shared memory of size %lu\n",
-                static_cast<unsigned long>(SHARED_COUNT));
+            Kokkos::printf("Failed to allocate shared memory of size %lu\n",
+                           static_cast<unsigned long>(SHARED_COUNT));
 
             ++update;  // Failure to allocate is an error.
           } else {
@@ -712,9 +710,8 @@ struct ScratchTeamFunctor {
     if ((scratch_ptr.data() == nullptr) ||
         (scratch_A.data() == nullptr && SHARED_TEAM_COUNT > 0) ||
         (scratch_B.data() == nullptr && SHARED_THREAD_COUNT > 0)) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "Failed to allocate shared memory of size %lu\n",
-          static_cast<unsigned long>(SHARED_TEAM_COUNT));
+      Kokkos::printf("Failed to allocate shared memory of size %lu\n",
+                     static_cast<unsigned long>(SHARED_TEAM_COUNT));
 
       ++update;  // Failure to allocate is an error.
     } else {
@@ -1724,7 +1721,7 @@ struct TestRepeatedTeamReduce {
   KOKKOS_FUNCTION void operator()(const int i, int &bad) const {
     if (v(i) != v(0) + i) {
       ++bad;
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("Failing at %d!\n", i);
+      Kokkos::printf("Failing at %d!\n", i);
     }
   }
 
diff --git a/core/unit_test/TestTeamBasic.hpp b/core/unit_test/TestTeamBasic.hpp
index c395bc0837..a3d84c5e16 100644
--- a/core/unit_test/TestTeamBasic.hpp
+++ b/core/unit_test/TestTeamBasic.hpp
@@ -280,7 +280,7 @@ namespace Test {
 
 // Test for non-arithmetic type
 TEST(TEST_CATEGORY, team_broadcast_long_wrapper) {
-  static_assert(!std::is_arithmetic<long_wrapper>::value, "");
+  static_assert(!std::is_arithmetic<long_wrapper>::value);
 
   TestTeamBroadcast<TEST_EXECSPACE, Kokkos::Schedule<Kokkos::Static>,
                     long_wrapper>::test_teambroadcast(0, 1);
diff --git a/core/unit_test/TestTeamMDRange.hpp b/core/unit_test/TestTeamMDRange.hpp
index 6e65cde0cf..81931467c5 100644
--- a/core/unit_test/TestTeamMDRange.hpp
+++ b/core/unit_test/TestTeamMDRange.hpp
@@ -169,7 +169,14 @@ struct TestTeamThreadMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -202,7 +209,14 @@ struct TestTeamThreadMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -236,7 +250,14 @@ struct TestTeamThreadMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -272,7 +293,14 @@ struct TestTeamThreadMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3, n4);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -310,7 +338,14 @@ struct TestTeamThreadMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3, n4, n5);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -350,7 +385,14 @@ struct TestTeamThreadMDRangeParallelFor : public TestTeamMDParallelFor {
                                           n6);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -420,7 +462,14 @@ struct TestThreadVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -457,7 +506,14 @@ struct TestThreadVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -496,7 +552,14 @@ struct TestThreadVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3, n4);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -536,7 +599,14 @@ struct TestThreadVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3, n4, n5);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -579,7 +649,14 @@ struct TestThreadVectorMDRangeParallelFor : public TestTeamMDParallelFor {
                                           n6);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -620,7 +697,14 @@ struct TestTeamVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -653,7 +737,14 @@ struct TestTeamVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -687,7 +778,14 @@ struct TestTeamVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -723,7 +821,14 @@ struct TestTeamVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3, n4);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -761,7 +866,14 @@ struct TestTeamVectorMDRangeParallelFor : public TestTeamMDParallelFor {
     FillFlattenedIndex fillFlattenedIndex(leagueSize, n0, n1, n2, n3, n4, n5);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -801,7 +913,14 @@ struct TestTeamVectorMDRangeParallelFor : public TestTeamMDParallelFor {
                                           n6);
 
     Kokkos::parallel_for(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(const TeamType& team) {
           int leagueRank = team.league_rank();
 
@@ -908,13 +1027,20 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k) = fillFlattenedIndex(i, j, k);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           Kokkos::parallel_reduce(
               Kokkos::TeamThreadMDRange<Kokkos::Rank<2, Direction>, TeamType>(
@@ -923,7 +1049,13 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 threadSum += v(leagueRank, i, j);
               },
               teamSum);
-          leagueSum += teamSum;
+      // FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -952,13 +1084,20 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l) = fillFlattenedIndex(i, j, k, l);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           Kokkos::parallel_reduce(
               Kokkos::TeamThreadMDRange<Kokkos::Rank<3, Direction>, TeamType>(
@@ -966,7 +1105,13 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
               [=](const int& i, const int& j, const int& k,
                   DataType& threadSum) { threadSum += v(leagueRank, i, j, k); },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -997,13 +1142,20 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l, m) = fillFlattenedIndex(i, j, k, l, m);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           Kokkos::parallel_reduce(
               Kokkos::TeamThreadMDRange<Kokkos::Rank<4, Direction>, TeamType>(
@@ -1013,7 +1165,13 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 threadSum += v(leagueRank, i, j, k, l);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1045,13 +1203,20 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l, m, n) = fillFlattenedIndex(i, j, k, l, m, n);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           Kokkos::parallel_reduce(
               Kokkos::TeamThreadMDRange<Kokkos::Rank<5, Direction>, TeamType>(
@@ -1061,7 +1226,13 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 threadSum += v(leagueRank, i, j, k, l, m);
               },
               teamSum);
-          leagueSum += teamSum;
+      // FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1100,13 +1271,20 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
           }
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           Kokkos::parallel_reduce(
               Kokkos::TeamThreadMDRange<Kokkos::Rank<6, Direction>, TeamType>(
@@ -1116,7 +1294,13 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 threadSum += v(leagueRank, i, j, k, l, m, n);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1157,13 +1341,20 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
           }
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           Kokkos::parallel_reduce(
               Kokkos::TeamThreadMDRange<Kokkos::Rank<7, Direction>, TeamType>(
@@ -1174,7 +1365,13 @@ struct TestTeamThreadMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 threadSum += v(leagueRank, i, j, k, l, m, n, o);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1207,20 +1404,26 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l) = fillFlattenedIndex(i, j, k, l);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
 
           auto teamThreadRange = Kokkos::TeamThreadRange(team, n0);
           auto threadVectorRange =
               Kokkos::ThreadVectorMDRange<Kokkos::Rank<2, Direction>, TeamType>(
                   team, n1, n2);
 
-          Kokkos::parallel_for(teamThreadRange, [=, &teamSum](const int& i) {
+          Kokkos::parallel_for(teamThreadRange, [=, &leagueSum](const int& i) {
             DataType threadSum = 0;
             Kokkos::parallel_reduce(
                 threadVectorRange,
@@ -1228,11 +1431,9 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                   vectorSum += v(leagueRank, i, j, k);
                 },
                 threadSum);
-
-            teamSum += threadSum;
+            Kokkos::single(Kokkos::PerThread(team),
+                           [&]() { leagueSum += threadSum; });
           });
-
-          leagueSum += teamSum;
         },
         finalSum);
 
@@ -1263,20 +1464,26 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l, m) = fillFlattenedIndex(i, j, k, l, m);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
 
           auto teamThreadRange = Kokkos::TeamThreadRange(team, n0);
           auto threadVectorRange =
               Kokkos::ThreadVectorMDRange<Kokkos::Rank<3, Direction>, TeamType>(
                   team, n1, n2, n3);
 
-          Kokkos::parallel_for(teamThreadRange, [=, &teamSum](const int& i) {
+          Kokkos::parallel_for(teamThreadRange, [=, &leagueSum](const int& i) {
             DataType threadSum = 0;
             Kokkos::parallel_reduce(
                 threadVectorRange,
@@ -1286,10 +1493,9 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 },
                 threadSum);
 
-            teamSum += threadSum;
+            Kokkos::single(Kokkos::PerThread(team),
+                           [&]() { leagueSum += threadSum; });
           });
-
-          leagueSum += teamSum;
         },
         finalSum);
 
@@ -1321,20 +1527,26 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l, m, n) = fillFlattenedIndex(i, j, k, l, m, n);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
 
           auto teamThreadRange = Kokkos::TeamThreadRange(team, n0);
           auto threadVectorRange =
               Kokkos::ThreadVectorMDRange<Kokkos::Rank<4, Direction>, TeamType>(
                   team, n1, n2, n3, n4);
 
-          Kokkos::parallel_for(teamThreadRange, [=, &teamSum](const int& i) {
+          Kokkos::parallel_for(teamThreadRange, [=, &leagueSum](const int& i) {
             DataType threadSum = 0;
             Kokkos::parallel_reduce(
                 threadVectorRange,
@@ -1344,10 +1556,9 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 },
                 threadSum);
 
-            teamSum += threadSum;
+            Kokkos::single(Kokkos::PerThread(team),
+                           [&]() { leagueSum += threadSum; });
           });
-
-          leagueSum += teamSum;
         },
         finalSum);
 
@@ -1384,20 +1595,26 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           }
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
 
           auto teamThreadRange = Kokkos::TeamThreadRange(team, n0);
           auto threadVectorRange =
               Kokkos::ThreadVectorMDRange<Kokkos::Rank<5, Direction>, TeamType>(
                   team, n1, n2, n3, n4, n5);
 
-          Kokkos::parallel_for(teamThreadRange, [=, &teamSum](const int& i) {
+          Kokkos::parallel_for(teamThreadRange, [=, &leagueSum](const int& i) {
             DataType threadSum = 0;
             Kokkos::parallel_reduce(
                 threadVectorRange,
@@ -1407,10 +1624,9 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 },
                 threadSum);
 
-            teamSum += threadSum;
+            Kokkos::single(Kokkos::PerThread(team),
+                           [&]() { leagueSum += threadSum; });
           });
-
-          leagueSum += teamSum;
         },
         finalSum);
 
@@ -1451,20 +1667,26 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           }
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
 
           auto teamThreadRange = Kokkos::TeamThreadRange(team, n0);
           auto threadVectorRange =
               Kokkos::ThreadVectorMDRange<Kokkos::Rank<6, Direction>, TeamType>(
                   team, n1, n2, n3, n4, n5, n6);
 
-          Kokkos::parallel_for(teamThreadRange, [=, &teamSum](const int& i) {
+          Kokkos::parallel_for(teamThreadRange, [=, &leagueSum](const int& i) {
             DataType threadSum = 0;
             Kokkos::parallel_reduce(
                 threadVectorRange,
@@ -1474,10 +1696,9 @@ struct TestThreadVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 },
                 threadSum);
 
-            teamSum += threadSum;
+            Kokkos::single(Kokkos::PerThread(team),
+                           [&]() { leagueSum += threadSum; });
           });
-
-          leagueSum += teamSum;
         },
         finalSum);
 
@@ -1510,13 +1731,20 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l) = fillFlattenedIndex(i, j, k, l);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           auto teamVectorRange =
               Kokkos::TeamVectorMDRange<Kokkos::Rank<3, Direction>, TeamType>(
@@ -1527,7 +1755,13 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
               [=](const int& i, const int& j, const int& k,
                   DataType& vectorSum) { vectorSum += v(leagueRank, i, j, k); },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1558,13 +1792,20 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l, m) = fillFlattenedIndex(i, j, k, l, m);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           auto teamVectorRange =
               Kokkos::TeamVectorMDRange<Kokkos::Rank<4, Direction>, TeamType>(
@@ -1577,7 +1818,13 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 vectorSum += v(leagueRank, i, j, k, l);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1609,13 +1856,20 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           v(i, j, k, l, m, n) = fillFlattenedIndex(i, j, k, l, m, n);
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           auto teamVectorRange =
               Kokkos::TeamVectorMDRange<Kokkos::Rank<5, Direction>, TeamType>(
@@ -1628,7 +1882,13 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 vectorSum += v(leagueRank, i, j, k, l, m);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1665,13 +1925,20 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           }
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           auto teamVectorRange =
               Kokkos::TeamVectorMDRange<Kokkos::Rank<6, Direction>, TeamType>(
@@ -1684,7 +1951,13 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 vectorSum += v(leagueRank, i, j, k, l, m, n);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1725,13 +1998,20 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
           }
         });
 
-    DataType finalSum = 0;
+    DataType finalSum;
 
     Kokkos::parallel_reduce(
-        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO),
+        Kokkos::TeamPolicy<ExecSpace>(leagueSize, Kokkos::AUTO,
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+                                      2
+#else
+                                      Kokkos::TeamPolicy<
+                                          ExecSpace>::vector_length_max()
+#endif
+                                      ),
         KOKKOS_LAMBDA(TeamType const& team, DataType& leagueSum) {
-          auto leagueRank  = team.league_rank();
-          DataType teamSum = 0;
+          auto leagueRank = team.league_rank();
+          DataType teamSum;
 
           auto teamVectorRange =
               Kokkos::TeamVectorMDRange<Kokkos::Rank<7, Direction>, TeamType>(
@@ -1745,7 +2025,13 @@ struct TestTeamVectorMDRangeParallelReduce : public TestTeamMDParallelReduce {
                 vectorSum += v(leagueRank, i, j, k, l, m, n, o);
               },
               teamSum);
-          leagueSum += teamSum;
+// FIXME_OPENMPTARGET
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+          if (team.team_rank() == 0) leagueSum += teamSum;
+#else
+          Kokkos::single(Kokkos::PerTeam(team),
+                         [&]() { leagueSum += teamSum; });
+#endif
         },
         finalSum);
 
@@ -1904,13 +2190,6 @@ 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>::
@@ -1944,13 +2223,6 @@ 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/TestTeamMDRangePolicyCTAD.cpp b/core/unit_test/TestTeamMDRangePolicyCTAD.cpp
new file mode 100644
index 0000000000..0de639e02e
--- /dev/null
+++ b/core/unit_test/TestTeamMDRangePolicyCTAD.cpp
@@ -0,0 +1,199 @@
+//@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 {
+
+struct TestTeamThreadMDRangeCTAD {
+  using TeamPolicy = Kokkos::TeamPolicy<Kokkos::DefaultExecutionSpace>;
+  using TeamHandle = TeamPolicy::member_type;
+
+  KOKKOS_FUNCTION void operator()(TeamHandle const& team_handle) const {
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<2>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<3>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<4>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<5>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<6>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<7>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamThreadMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamThreadMDRange<Kokkos::Rank<8>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+  }
+
+  TestTeamThreadMDRangeCTAD() {
+    Kokkos::parallel_for(TeamPolicy(0, Kokkos::AUTO), *this);
+  }
+};
+
+struct TestTeamVectorMDRangeCTAD {
+  using TeamPolicy = Kokkos::TeamPolicy<Kokkos::DefaultExecutionSpace>;
+  using TeamHandle = TeamPolicy::member_type;
+
+  KOKKOS_FUNCTION void operator()(TeamHandle const& team_handle) const {
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<2>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<3>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<4>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<5>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<6>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<7>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+
+    {
+      Kokkos::TeamVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0, 0, 0);
+      static_assert(
+          std::is_same_v<Kokkos::TeamVectorMDRange<Kokkos::Rank<8>, TeamHandle>,
+                         decltype(md_range)>);
+    }
+  }
+
+  TestTeamVectorMDRangeCTAD() {
+    Kokkos::parallel_for(TeamPolicy(0, Kokkos::AUTO), *this);
+  }
+};
+
+struct TestThreadVectorMDRangeCTAD {
+  using TeamPolicy = Kokkos::TeamPolicy<Kokkos::DefaultExecutionSpace>;
+  using TeamHandle = TeamPolicy::member_type;
+
+  template <class PolicyTypeExpected, class PolicyTypeToCheck>
+  KOKKOS_FUNCTION static void check_types([
+      [maybe_unused]] PolicyTypeToCheck const& team_handle) {
+    static_assert(std::is_same_v<PolicyTypeExpected, PolicyTypeToCheck>);
+  }
+
+  KOKKOS_FUNCTION void operator()(TeamHandle const& team_handle) const {
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<2>, TeamHandle>>(
+          md_range);
+    }
+
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<3>, TeamHandle>>(
+          md_range);
+    }
+
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<4>, TeamHandle>>(
+          md_range);
+    }
+
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<5>, TeamHandle>>(
+          md_range);
+    }
+
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<6>, TeamHandle>>(
+          md_range);
+    }
+
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<7>, TeamHandle>>(
+          md_range);
+    }
+
+    {
+      Kokkos::ThreadVectorMDRange md_range(team_handle, 0, 0, 0, 0, 0, 0, 0, 0);
+      check_types<Kokkos::ThreadVectorMDRange<Kokkos::Rank<8>, TeamHandle>>(
+          md_range);
+    }
+  }
+
+  TestThreadVectorMDRangeCTAD() {
+    Kokkos::parallel_for(TeamPolicy(0, Kokkos::AUTO), *this);
+  }
+};
+
+}  // namespace
diff --git a/core/unit_test/TestTeamPolicyCTAD.cpp b/core/unit_test/TestTeamPolicyCTAD.cpp
new file mode 100644
index 0000000000..07aaeae819
--- /dev/null
+++ b/core/unit_test/TestTeamPolicyCTAD.cpp
@@ -0,0 +1,135 @@
+//@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 {
+
+struct TestTeamPolicyCTAD {
+  template <typename... Ts>
+  static void maybe_unused(Ts&&...) {}
+
+  struct SomeExecutionSpace {
+    using execution_space = SomeExecutionSpace;
+    using size_type       = size_t;
+  };
+  static_assert(Kokkos::is_execution_space_v<SomeExecutionSpace>);
+
+  struct ImplicitlyConvertibleToDefaultExecutionSpace {
+    [[maybe_unused]] operator Kokkos::DefaultExecutionSpace() const {
+      return Kokkos::DefaultExecutionSpace();
+    }
+  };
+  static_assert(!Kokkos::is_execution_space_v<
+                ImplicitlyConvertibleToDefaultExecutionSpace>);
+
+  [[maybe_unused]] static inline Kokkos::DefaultExecutionSpace des;
+  [[maybe_unused]] static inline ImplicitlyConvertibleToDefaultExecutionSpace
+      notEs;
+  [[maybe_unused]] static inline SomeExecutionSpace ses;
+
+  [[maybe_unused]] static inline int i;
+
+  // Workaround for nvc++ (CUDA-11.7-NVHPC) ignoring [[maybe_unused]] on
+  // ImplicitlyConvertibleToDefaultExecutionSpace::operator
+  // Kokkos::DefaultExecutionSpace() const
+  [[maybe_unused]] static inline Kokkos::DefaultExecutionSpace notEsToDes =
+      notEs;
+
+  // Workaround for HIP-ROCm-5.2 warning about was declared but never referenced
+  TestTeamPolicyCTAD() { maybe_unused(des, notEs, ses, i, notEsToDes); }
+
+  // Default construction deduces to TeamPolicy<>
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>, decltype(Kokkos::TeamPolicy{})>);
+
+  // Execution space not provided deduces to TeamPolicy<>
+
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>, decltype(Kokkos::TeamPolicy(i, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(i, i, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(i, Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(i, Kokkos::AUTO, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(i, Kokkos::AUTO,
+                                                           Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(i, i, Kokkos::AUTO))>);
+
+  // DefaultExecutionSpace deduces to TeamPolicy<>
+
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(des, i, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(des, i, i, i))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(des, i, Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(des, i, Kokkos::AUTO, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(des, i, Kokkos::AUTO,
+                                                           Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(des, i, i, Kokkos::AUTO))>);
+
+  // Convertible to DefaultExecutionSpace deduces to TeamPolicy<>
+
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(notEs, i, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(notEs, i, i, i))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(notEs, i, Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(notEs, i, Kokkos::AUTO, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<>,
+                               decltype(Kokkos::TeamPolicy(
+                                   notEs, i, Kokkos::AUTO, Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<>,
+                     decltype(Kokkos::TeamPolicy(notEs, i, i, Kokkos::AUTO))>);
+
+  // SES != DefaultExecutionSpace deduces to TeamPolicy<SES>
+
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<SomeExecutionSpace>,
+                               decltype(Kokkos::TeamPolicy(ses, i, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<SomeExecutionSpace>,
+                               decltype(Kokkos::TeamPolicy(ses, i, i, i))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<SomeExecutionSpace>,
+                     decltype(Kokkos::TeamPolicy(ses, i, Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<SomeExecutionSpace>,
+                     decltype(Kokkos::TeamPolicy(ses, i, Kokkos::AUTO, i))>);
+  static_assert(std::is_same_v<Kokkos::TeamPolicy<SomeExecutionSpace>,
+                               decltype(Kokkos::TeamPolicy(ses, i, Kokkos::AUTO,
+                                                           Kokkos::AUTO))>);
+  static_assert(
+      std::is_same_v<Kokkos::TeamPolicy<SomeExecutionSpace>,
+                     decltype(Kokkos::TeamPolicy(ses, i, i, Kokkos::AUTO))>);
+};
+
+}  // namespace
diff --git a/core/unit_test/TestTeamPolicyConstructors.hpp b/core/unit_test/TestTeamPolicyConstructors.hpp
index 5b0bfdb175..9d89f75708 100644
--- a/core/unit_test/TestTeamPolicyConstructors.hpp
+++ b/core/unit_test/TestTeamPolicyConstructors.hpp
@@ -20,11 +20,24 @@
 
 namespace {
 
+struct SomeTag {};
+
+struct FunctorFor {
+  KOKKOS_FUNCTION
+  void operator()(
+      Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type const&) const {}
+
+  KOKKOS_FUNCTION
+  void operator()(
+      SomeTag, Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type const&) const {}
+};
+
 template <typename Policy>
 void test_run_time_parameters() {
   int league_size = 131;
 
   using ExecutionSpace = typename Policy::execution_space;
+  using ParallelTag    = Kokkos::ParallelForTag;
   int team_size =
       4 < ExecutionSpace().concurrency() ? 4 : ExecutionSpace().concurrency();
 #ifdef KOKKOS_ENABLE_HPX
@@ -44,6 +57,8 @@ void test_run_time_parameters() {
   ASSERT_EQ(p1.team_size(), team_size);
   ASSERT_GT(p1.chunk_size(), 0);
   ASSERT_EQ(p1.scratch_size(0), 0u);
+  ASSERT_GT(p1.team_size_max(FunctorFor(), ParallelTag()), 0);
+  ASSERT_GT(p1.team_size_recommended(FunctorFor(), ParallelTag()), 0);
 
   Policy p2 = p1.set_chunk_size(chunk_size);
   ASSERT_EQ(p1.league_size(), league_size);
@@ -112,6 +127,8 @@ void test_run_time_parameters() {
   Policy p8;  // default constructed
   ASSERT_EQ(p8.league_size(), 0);
   ASSERT_EQ(p8.scratch_size(0), 0u);
+  ASSERT_GT(p8.team_size_max(FunctorFor(), ParallelTag()), 0);
+  ASSERT_GT(p8.team_size_recommended(FunctorFor(), ParallelTag()), 0);
   p8 = p3;  // call assignment operator
   ASSERT_EQ(p3.league_size(), league_size);
   ASSERT_EQ(p3.team_size(), team_size);
@@ -121,11 +138,25 @@ void test_run_time_parameters() {
   ASSERT_EQ(p8.team_size(), team_size);
   ASSERT_EQ(p8.chunk_size(), chunk_size);
   ASSERT_EQ(p8.scratch_size(0), size_t(scratch_size));
+
+  Policy p9(league_size, Kokkos::AUTO);
+  ASSERT_EQ(p9.league_size(), league_size);
+  ASSERT_GT(p9.team_size_max(FunctorFor(), ParallelTag()), 0);
+  ASSERT_GT(p9.team_size_recommended(FunctorFor(), ParallelTag()), 0);
+
+  Policy p10(league_size, team_size, Kokkos::AUTO);
+  ASSERT_EQ(p10.league_size(), league_size);
+  ASSERT_EQ(p10.team_size(), team_size);
+  ASSERT_GT(p10.team_size_max(FunctorFor(), ParallelTag()), 0);
+  ASSERT_GT(p10.team_size_recommended(FunctorFor(), ParallelTag()), 0);
+
+  Policy p11(league_size, Kokkos::AUTO, Kokkos::AUTO);
+  ASSERT_EQ(p11.league_size(), league_size);
+  ASSERT_GT(p11.team_size_max(FunctorFor(), ParallelTag()), 0);
+  ASSERT_GT(p11.team_size_recommended(FunctorFor(), ParallelTag()), 0);
 }
 
 TEST(TEST_CATEGORY, team_policy_runtime_parameters) {
-  struct SomeTag {};
-
   using TestExecSpace   = TEST_EXECSPACE;
   using DynamicSchedule = Kokkos::Schedule<Kokkos::Dynamic>;
   using LongIndex       = Kokkos::IndexType<long>;
diff --git a/core/unit_test/TestTeamScan.hpp b/core/unit_test/TestTeamScan.hpp
index cec36236d8..833683227e 100644
--- a/core/unit_test/TestTeamScan.hpp
+++ b/core/unit_test/TestTeamScan.hpp
@@ -130,4 +130,133 @@ TEST(TEST_CATEGORY, team_scan) {
   TestTeamScan<TEST_EXECSPACE, double>{}(2596, 1311);
 }
 
+// Temporary: This condition will progressively be reduced when parallel_scan
+// with return value will be implemented for more backends.
+#if !defined(KOKKOS_ENABLE_OPENACC)
+template <class ExecutionSpace, class DataType>
+struct TestTeamScanRetVal {
+  using execution_space = ExecutionSpace;
+  using value_type      = DataType;
+  using policy_type     = Kokkos::TeamPolicy<execution_space>;
+  using member_type     = typename policy_type::member_type;
+  using view_1d_type    = Kokkos::View<value_type*, execution_space>;
+  using view_2d_type    = Kokkos::View<value_type**, execution_space>;
+
+  view_2d_type a_d;
+  view_2d_type a_r;
+  view_1d_type a_s;
+  int32_t M = 0;
+  int32_t N = 0;
+
+  KOKKOS_FUNCTION
+  void operator()(const member_type& team) const {
+    auto leagueRank = team.league_rank();
+
+    auto beg = 0;
+    auto end = N;
+
+    Kokkos::parallel_for(
+        Kokkos::TeamThreadRange(team, beg, end),
+        [&](const int i) { a_d(leagueRank, i) = leagueRank * N + i; });
+
+    DataType accum;
+    Kokkos::parallel_scan(
+        Kokkos::TeamThreadRange(team, beg, end),
+        [&](int i, DataType& val, const bool final) {
+          val += a_d(leagueRank, i);
+          if (final) a_r(leagueRank, i) = val;
+        },
+        accum);
+
+    // Save return value from parallel_scan
+    Kokkos::single(Kokkos::PerTeam(team), [&]() { a_s(leagueRank) = accum; });
+  }
+
+  auto operator()(int32_t _M, int32_t _N) {
+    std::stringstream ss;
+    ss << Kokkos::Impl::demangle(typeid(*this).name());
+    ss << "(/*M=*/" << _M << ", /*N=*/" << _N << ")";
+    std::string const test_id = ss.str();
+
+    M   = _M;
+    N   = _N;
+    a_d = view_2d_type("a_d", M, N);
+    a_r = view_2d_type("a_r", M, N);
+    a_s = view_1d_type("a_s", M);
+
+    // Set team size explicitly to check whether non-power-of-two team sizes can
+    // be used.
+    if (ExecutionSpace().concurrency() > 10000)
+      Kokkos::parallel_for(policy_type(M, 127), *this);
+    else if (ExecutionSpace().concurrency() > 2)
+      Kokkos::parallel_for(policy_type(M, 3), *this);
+    else
+      Kokkos::parallel_for(policy_type(M, 1), *this);
+
+    Kokkos::fence();
+    auto a_i  = Kokkos::create_mirror_view(a_d);
+    auto a_o  = Kokkos::create_mirror_view(a_r);
+    auto a_os = Kokkos::create_mirror_view(a_s);
+    Kokkos::deep_copy(a_i, a_d);
+    Kokkos::deep_copy(a_o, a_r);
+    Kokkos::deep_copy(a_os, a_s);
+
+    for (int32_t i = 0; i < M; ++i) {
+      value_type scan_ref = 0;
+      value_type scan_calc;
+      value_type abs_err = 0;
+      // each fp addition is subject to small loses in precision and these
+      // compound as loop so we set the base error to be the machine epsilon and
+      // then add in another epsilon each iteration. For example, with CUDA
+      // backend + 32-bit float + large N values (e.g. 1,000) + high
+      // thread-counts (e.g. 1024), this test will fail w/o epsilon
+      // accommodation
+      constexpr value_type epsilon = std::numeric_limits<value_type>::epsilon();
+      for (int32_t j = 0; j < N; ++j) {
+        scan_ref += a_i(i, j);
+        scan_calc = a_o(i, j);
+        if (std::is_integral<value_type>::value) {
+          ASSERT_EQ(scan_ref, scan_calc)
+              << test_id
+              << " calculated scan output value differs from reference at "
+                 "indices i="
+              << i << " and j=" << j;
+        } else {
+          abs_err += epsilon;
+          ASSERT_NEAR(scan_ref, scan_calc, abs_err)
+              << test_id
+              << " calculated scan output value differs from reference at "
+                 "indices i="
+              << i << " and j=" << j;
+        }
+      }
+      // Validate return value from parallel_scan
+      if (std::is_integral<value_type>::value) {
+        ASSERT_EQ(scan_ref, a_os(i));
+      } else {
+        ASSERT_NEAR(scan_ref, a_os(i), abs_err);
+      }
+    }
+  }
+};
+
+TEST(TEST_CATEGORY, team_scan_ret_val) {
+  TestTeamScanRetVal<TEST_EXECSPACE, int32_t>{}(0, 0);
+  TestTeamScanRetVal<TEST_EXECSPACE, int32_t>{}(0, 1);
+  TestTeamScanRetVal<TEST_EXECSPACE, int32_t>{}(1, 0);
+  TestTeamScanRetVal<TEST_EXECSPACE, uint32_t>{}(99, 32);
+  TestTeamScanRetVal<TEST_EXECSPACE, uint32_t>{}(139, 64);
+  TestTeamScanRetVal<TEST_EXECSPACE, uint32_t>{}(163, 128);
+  TestTeamScanRetVal<TEST_EXECSPACE, int64_t>{}(433, 256);
+  TestTeamScanRetVal<TEST_EXECSPACE, uint64_t>{}(976, 512);
+  TestTeamScanRetVal<TEST_EXECSPACE, uint64_t>{}(1234, 1024);
+  TestTeamScanRetVal<TEST_EXECSPACE, float>{}(2596, 34);
+  TestTeamScanRetVal<TEST_EXECSPACE, double>{}(2596, 59);
+  TestTeamScanRetVal<TEST_EXECSPACE, float>{}(2596, 65);
+  TestTeamScanRetVal<TEST_EXECSPACE, double>{}(2596, 371);
+  TestTeamScanRetVal<TEST_EXECSPACE, int64_t>{}(2596, 987);
+  TestTeamScanRetVal<TEST_EXECSPACE, double>{}(2596, 1311);
+}
+#endif
+
 }  // namespace Test
diff --git a/core/unit_test/TestTeamScratch.hpp b/core/unit_test/TestTeamScratch.hpp
index 3fdf81e044..c072a87c7b 100644
--- a/core/unit_test/TestTeamScratch.hpp
+++ b/core/unit_test/TestTeamScratch.hpp
@@ -54,5 +54,23 @@ TEST(TEST_CATEGORY, multi_level_scratch) {
 #endif
 }
 
+struct DummyTeamParallelForFunctor {
+  KOKKOS_FUNCTION void operator()(
+      Kokkos::TeamPolicy<TEST_EXECSPACE>::member_type) const {}
+};
+
+TEST(TEST_CATEGORY, team_scratch_memory_index_parallel_for) {
+  // Requesting per team scratch memory for a largish number of teams, resulted
+  // in problems computing the correct scratch pointer due to missed
+  // initialization of the maximum number of scratch pad indices in the Cuda
+  // baackend.
+  const int scratch_size = 4896;
+  const int league_size  = 7535;
+
+  Kokkos::TeamPolicy<TEST_EXECSPACE> policy(league_size, Kokkos::AUTO);
+  policy.set_scratch_size(1, Kokkos::PerTeam(scratch_size));
+  Kokkos::parallel_for("kernel", policy, DummyTeamParallelForFunctor());
+}
+
 }  // namespace Test
 #endif
diff --git a/core/unit_test/TestTeamVector.hpp b/core/unit_test/TestTeamVector.hpp
index 15410bb63f..4d8f42720d 100644
--- a/core/unit_test/TestTeamVector.hpp
+++ b/core/unit_test/TestTeamVector.hpp
@@ -50,9 +50,8 @@ struct functor_team_for {
 
     if (values.data() == nullptr ||
         static_cast<size_type>(values.extent(0)) < shmemSize) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "FAILED to allocate shared memory of size %u\n",
-          static_cast<unsigned int>(shmemSize));
+      Kokkos::printf("FAILED to allocate shared memory of size %u\n",
+                     static_cast<unsigned int>(shmemSize));
     } else {
       // Initialize shared memory.
       values(team.team_rank()) = 0;
@@ -82,10 +81,9 @@ struct functor_team_for {
         }
 
         if (test != value) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-              "FAILED team_parallel_for %i %i %lf %lf\n", team.league_rank(),
-              team.team_rank(), static_cast<double>(test),
-              static_cast<double>(value));
+          Kokkos::printf("FAILED team_parallel_for %i %i %lf %lf\n",
+                         team.league_rank(), team.team_rank(),
+                         static_cast<double>(test), static_cast<double>(value));
           flag() = 1;
         }
       });
@@ -141,18 +139,17 @@ struct functor_team_reduce {
 
       if (test != value) {
         if (team.league_rank() == 0) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-              "FAILED team_parallel_reduce %i %i %lf %lf %lu\n",
-              team.league_rank(), team.team_rank(), static_cast<double>(test),
-              static_cast<double>(value),
-              static_cast<unsigned long>(sizeof(Scalar)));
+          Kokkos::printf("FAILED team_parallel_reduce %i %i %lf %lf %lu\n",
+                         team.league_rank(), team.team_rank(),
+                         static_cast<double>(test), static_cast<double>(value),
+                         static_cast<unsigned long>(sizeof(Scalar)));
         }
 
         flag() = 1;
       }
       if (test != shared_value(0)) {
         if (team.league_rank() == 0) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          Kokkos::printf(
               "FAILED team_parallel_reduce with shared result %i %i %lf %lf "
               "%lu\n",
               team.league_rank(), team.team_rank(), static_cast<double>(test),
@@ -213,7 +210,7 @@ struct functor_team_reduce_reducer {
       }
 
       if (test != value) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+        Kokkos::printf(
             "FAILED team_vector_parallel_reduce_reducer %i %i %lf %lf\n",
             team.league_rank(), team.team_rank(), static_cast<double>(test),
             static_cast<double>(value));
@@ -221,7 +218,7 @@ struct functor_team_reduce_reducer {
         flag() = 1;
       }
       if (test != shared_value(0)) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+        Kokkos::printf(
             "FAILED team_vector_parallel_reduce_reducer shared value %i %i %lf "
             "%lf\n",
             team.league_rank(), team.team_rank(), static_cast<double>(test),
@@ -260,9 +257,8 @@ struct functor_team_vector_for {
 
     if (values.data() == nullptr ||
         static_cast<size_type>(values.extent(0)) < shmemSize) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "FAILED to allocate shared memory of size %u\n",
-          static_cast<unsigned int>(shmemSize));
+      Kokkos::printf("FAILED to allocate shared memory of size %u\n",
+                     static_cast<unsigned int>(shmemSize));
     } else {
       team.team_barrier();
 
@@ -292,10 +288,9 @@ struct functor_team_vector_for {
         }
 
         if (test != value) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-              "FAILED team_vector_parallel_for %i %i %lf %lf\n",
-              team.league_rank(), team.team_rank(), static_cast<double>(test),
-              static_cast<double>(value));
+          Kokkos::printf("FAILED team_vector_parallel_for %i %i %lf %lf\n",
+                         team.league_rank(), team.team_rank(),
+                         static_cast<double>(test), static_cast<double>(value));
           flag() = 1;
         }
       });
@@ -342,7 +337,7 @@ struct functor_team_vector_reduce {
 
       if (test != value) {
         if (team.league_rank() == 0) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          Kokkos::printf(
               "FAILED team_vector_parallel_reduce %i %i %lf %lf %lu\n",
               team.league_rank(), team.team_rank(), static_cast<double>(test),
               static_cast<double>(value),
@@ -394,7 +389,7 @@ struct functor_team_vector_reduce_reducer {
       }
 
       if (test != value) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+        Kokkos::printf(
             "FAILED team_vector_parallel_reduce_reducer %i %i %lf %lf\n",
             team.league_rank(), team.team_rank(), static_cast<double>(test),
             static_cast<double>(value));
@@ -441,10 +436,9 @@ struct functor_vec_single {
         [&](int /*i*/, Scalar &val) { val += value; }, value2);
 
     if (value2 != (value * Scalar(nEnd - nStart))) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "FAILED vector_single broadcast %i %i %lf %lf\n", team.league_rank(),
-          team.team_rank(), static_cast<double>(value2),
-          static_cast<double>(value));
+      Kokkos::printf("FAILED vector_single broadcast %i %i %lf %lf\n",
+                     team.league_rank(), team.team_rank(),
+                     static_cast<double>(value2), static_cast<double>(value));
 
       flag() = 1;
     }
@@ -474,8 +468,8 @@ struct functor_vec_for {
 
     if (values.data() == nullptr ||
         values.extent(0) < (unsigned)team.team_size() * 13) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF("FAILED to allocate memory of size %i\n",
-                                    static_cast<int>(team.team_size() * 13));
+      Kokkos::printf("FAILED to allocate memory of size %i\n",
+                     static_cast<int>(team.team_size() * 13));
       flag() = 1;
     } else {
       Kokkos::parallel_for(Kokkos::ThreadVectorRange(team, 13), [&](int i) {
@@ -495,10 +489,9 @@ struct functor_vec_for {
         }
 
         if (test != value) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF("FAILED vector_par_for %i %i %lf %lf\n",
-                                        team.league_rank(), team.team_rank(),
-                                        static_cast<double>(test),
-                                        static_cast<double>(value));
+          Kokkos::printf("FAILED vector_par_for %i %i %lf %lf\n",
+                         team.league_rank(), team.team_rank(),
+                         static_cast<double>(test), static_cast<double>(value));
 
           flag() = 1;
         }
@@ -532,9 +525,9 @@ struct functor_vec_red {
       for (int i = 0; i < 13; i++) test += i;
 
       if (test != value) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-            "FAILED vector_par_reduce %i %i %lf %lf\n", team.league_rank(),
-            team.team_rank(), (double)test, (double)value);
+        Kokkos::printf("FAILED vector_par_reduce %i %i %lf %lf\n",
+                       team.league_rank(), team.team_rank(), (double)test,
+                       (double)value);
         flag() = 1;
       }
     });
@@ -570,9 +563,9 @@ struct functor_vec_red_reducer {
       for (int i = 0; i < 13; i++) test *= (i % 5 + 1);
 
       if (test != value) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-            "FAILED vector_par_reduce_reducer %i %i %lf %lf\n",
-            team.league_rank(), team.team_rank(), (double)test, (double)value);
+        Kokkos::printf("FAILED vector_par_reduce_reducer %i %i %lf %lf\n",
+                       team.league_rank(), team.team_rank(), (double)test,
+                       (double)value);
 
         flag() = 1;
       }
@@ -591,27 +584,81 @@ struct functor_vec_scan {
 
   KOKKOS_INLINE_FUNCTION
   void operator()(typename policy_type::member_type team) const {
-    Kokkos::parallel_scan(Kokkos::ThreadVectorRange(team, 13),
-                          [&](int i, Scalar &val, bool final) {
-                            val += i;
-
-                            if (final) {
-                              Scalar test = 0;
-                              for (int k = 0; k <= i; k++) test += k;
-
-                              if (test != val) {
-                                KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-                                    "FAILED vector_par_scan %i %i %lf %lf\n",
-                                    team.league_rank(), team.team_rank(),
-                                    static_cast<double>(test),
-                                    static_cast<double>(val));
-
-                                flag() = 1;
-                              }
-                            }
-                          });
+    Kokkos::parallel_scan(Kokkos::ThreadVectorRange(team, 13), [&](int i,
+                                                                   Scalar &val,
+                                                                   bool final) {
+      val += i;
+
+      if (final) {
+        Scalar test = 0;
+        for (int k = 0; k <= i; k++) test += k;
+
+        if (test != val) {
+          Kokkos::printf("FAILED vector_par_scan %i %i %lf %lf\n",
+                         team.league_rank(), team.team_rank(),
+                         static_cast<double>(test), static_cast<double>(val));
+
+          flag() = 1;
+        }
+      }
+    });
+  }
+};
+
+// Temporary: This condition will progressively be reduced when parallel_scan
+// with return value will be implemented for more backends.
+#if !defined(KOKKOS_ENABLE_OPENACC)
+template <typename Scalar, class ExecutionSpace>
+struct functor_vec_scan_ret_val {
+  using policy_type     = Kokkos::TeamPolicy<ExecutionSpace>;
+  using execution_space = ExecutionSpace;
+
+  Kokkos::View<int, ExecutionSpace> flag;
+  int team_size;
+
+  functor_vec_scan_ret_val(Kokkos::View<int, ExecutionSpace> flag_, int tsize)
+      : flag(flag_), team_size(tsize) {}
+
+  KOKKOS_INLINE_FUNCTION
+  void operator()(typename policy_type::member_type team) const {
+    Scalar return_val;
+    int upper_bound = 13;
+
+    Kokkos::parallel_scan(
+        Kokkos::ThreadVectorRange(team, upper_bound),
+        [&](int i, Scalar &val, bool final) {
+          val += i;
+
+          if (final) {
+            Scalar test = 0;
+            for (int k = 0; k <= i; k++) test += k;
+
+            if (test != val) {
+              Kokkos::printf("FAILED vector_par_scan %i %i %lf %lf\n",
+                             team.league_rank(), team.team_rank(),
+                             static_cast<double>(test),
+                             static_cast<double>(val));
+
+              flag() = 1;
+            }
+          }
+        },
+        return_val);
+
+    Scalar sum_ref = ((upper_bound - 1) * (upper_bound)) / 2;
+
+    if (flag() == 0 && return_val != sum_ref) {
+      Kokkos::printf(
+          "FAILED vector_scan_ret_val: league_rank %i, team_rank %i, sum_ref "
+          "%lf, return_val %lf\n",
+          team.league_rank(), team.team_rank(), static_cast<double>(sum_ref),
+          static_cast<double>(return_val));
+
+      flag() = 1;
+    }
   }
 };
+#endif
 
 template <typename Scalar, class ExecutionSpace>
 struct functor_reduce {
@@ -684,6 +731,14 @@ bool test_scalar(int nteams, int team_size, int test) {
     Kokkos::parallel_for(
         "B", Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
         functor_vec_single<Scalar, ExecutionSpace>(d_flag, 4, 13));
+  } else if (test == 12) {
+// Temporary: This condition will progressively be reduced when parallel_scan
+// with return value will be implemented for more backends.
+#if !defined(KOKKOS_ENABLE_OPENACC)
+    Kokkos::parallel_for(
+        Kokkos::TeamPolicy<ExecutionSpace>(nteams, team_size, 8),
+        functor_vec_scan_ret_val<Scalar, ExecutionSpace>(d_flag, team_size));
+#endif
   }
 
   Kokkos::deep_copy(h_flag, d_flag);
@@ -858,9 +913,6 @@ struct checkScan {
   view_type inputs  = view_type{"inputs"};
   view_type outputs = view_type{"outputs"};
 
-  value_type result;
-  Reducer reducer = {result};
-
   struct ThreadVectorFunctor {
     KOKKOS_FUNCTION void operator()(const size_type j, value_type &update,
                                     const bool final) const {
@@ -908,6 +960,8 @@ struct checkScan {
       const {
     const size_type iTeam       = team.league_rank();
     const size_type iTeamOffset = iTeam * n_per_team;
+    value_type dummy;
+    Reducer reducer = {dummy};
     Kokkos::parallel_for(
         Kokkos::TeamThreadRange(team, n_team_thread_range),
         TeamThreadRangeFunctor{team, reducer, iTeamOffset, outputs, inputs});
@@ -938,7 +992,9 @@ struct checkScan {
     Kokkos::View<value_type[n], Kokkos::HostSpace> expected("expected");
     {
       value_type identity;
+      Reducer reducer = {identity};
       reducer.init(identity);
+
       for (int i = 0; i < expected.extent_int(0); ++i) {
         const int vector       = i % n_vector_range;
         const value_type accum = vector == 0 ? identity : expected(i - 1);
@@ -956,14 +1012,10 @@ struct checkScan {
 };
 }  // namespace VectorScanReducer
 
-#if !(defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND) || defined(KOKKOS_ENABLE_HIP))
 TEST(TEST_CATEGORY, team_vector) {
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(0)));
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(1)));
-#if !(defined(KOKKOS_ENABLE_CUDA) && \
-      defined(KOKKOS_COMPILER_NVHPC))  // FIXME_NVHPC
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(2)));
-#endif
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(3)));
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(4)));
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(5)));
@@ -973,10 +1025,9 @@ TEST(TEST_CATEGORY, team_vector) {
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(9)));
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(10)));
   ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(11)));
+  ASSERT_TRUE((TestTeamVector::Test<TEST_EXECSPACE>(12)));
 }
-#endif
 
-#if !defined(KOKKOS_IMPL_CUDA_CLANG_WORKAROUND)
 TEST(TEST_CATEGORY, triple_nested_parallelism) {
 // With KOKKOS_ENABLE_DEBUG enabled, the functor uses too many registers to run
 // with a team size of 32 on GPUs, 16 is the max possible (at least on a K80
@@ -1001,7 +1052,6 @@ TEST(TEST_CATEGORY, triple_nested_parallelism) {
   TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 16, 16);
   TestTripleNestedReduce<double, TEST_EXECSPACE>(8192, 2048, 7, 16);
 }
-#endif
 
 TEST(TEST_CATEGORY, parallel_scan_with_reducers) {
   using T = double;
@@ -1010,11 +1060,8 @@ TEST(TEST_CATEGORY, parallel_scan_with_reducers) {
   constexpr int n              = 1000000;
   constexpr int n_vector_range = 100;
 
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Cuda>) {
-    GTEST_SKIP() << "All but max inclusive scan differ at index 101";
-  }
+#ifdef KOKKOS_IMPL_32BIT
+  GTEST_SKIP() << "Failing KOKKOS_IMPL_32BIT";  // FIXME_32BIT
 #endif
 
   checkScan<TEST_EXECSPACE, ScanType::Exclusive, n, n_vector_range,
diff --git a/core/unit_test/TestTeamVectorRange.hpp b/core/unit_test/TestTeamVectorRange.hpp
index bc7eb76932..d844756bf4 100644
--- a/core/unit_test/TestTeamVectorRange.hpp
+++ b/core/unit_test/TestTeamVectorRange.hpp
@@ -160,9 +160,8 @@ struct functor_teamvector_for {
     shared_int values         = shared_int(team.team_shmem(), shmemSize);
 
     if (values.data() == nullptr || values.extent(0) < shmemSize) {
-      KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-          "FAILED to allocate shared memory of size %u\n",
-          static_cast<unsigned int>(shmemSize));
+      Kokkos::printf("FAILED to allocate shared memory of size %u\n",
+                     static_cast<unsigned int>(shmemSize));
     } else {
       // Initialize shared memory.
       Kokkos::parallel_for(Kokkos::TeamVectorRange(team, 131),
@@ -195,10 +194,9 @@ struct functor_teamvector_for {
         }
 
         if (test != value) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
-              "FAILED teamvector_parallel_for %i %i %lf %lf\n",
-              team.league_rank(), team.team_rank(), static_cast<double>(test),
-              static_cast<double>(value));
+          Kokkos::printf("FAILED teamvector_parallel_for %i %i %lf %lf\n",
+                         team.league_rank(), team.team_rank(),
+                         static_cast<double>(test), static_cast<double>(value));
           flag() = 1;
         }
       });
@@ -262,7 +260,7 @@ struct functor_teamvector_reduce {
 
       if (test != value) {
         if (team.league_rank() == 0) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          Kokkos::printf(
               "FAILED teamvector_parallel_reduce %i %i %lf %lf %lu\n",
               (int)team.league_rank(), (int)team.team_rank(),
               static_cast<double>(test), static_cast<double>(value),
@@ -273,7 +271,7 @@ struct functor_teamvector_reduce {
       }
       if (test != shared_value(0)) {
         if (team.league_rank() == 0) {
-          KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+          Kokkos::printf(
               "FAILED teamvector_parallel_reduce with shared result %i %i %lf "
               "%lf %lu\n",
               static_cast<int>(team.league_rank()),
@@ -335,7 +333,7 @@ struct functor_teamvector_reduce_reducer {
       }
 
       if (test != value) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+        Kokkos::printf(
             "FAILED teamvector_parallel_reduce_reducer %i %i %lf %lf\n",
             team.league_rank(), team.team_rank(), static_cast<double>(test),
             static_cast<double>(value));
@@ -343,7 +341,7 @@ struct functor_teamvector_reduce_reducer {
         flag() = 1;
       }
       if (test != shared_value(0)) {
-        KOKKOS_IMPL_DO_NOT_USE_PRINTF(
+        Kokkos::printf(
             "FAILED teamvector_parallel_reduce_reducer shared value %i %i %lf "
             "%lf\n",
             team.league_rank(), team.team_rank(), static_cast<double>(test),
@@ -438,12 +436,6 @@ namespace Test {
 
 TEST(TEST_CATEGORY, team_teamvector_range) {
   ASSERT_TRUE((TestTeamVectorRange::Test<TEST_EXECSPACE>(0)));
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  if constexpr (std::is_same_v<TEST_EXECSPACE, Kokkos::Cuda>) {
-    GTEST_SKIP() << "Disabling 2/3rd of the test for now";
-  }
-#endif
   ASSERT_TRUE((TestTeamVectorRange::Test<TEST_EXECSPACE>(1)));
   // FIXME_OPENMPTARGET - Use of kokkos reducers currently results in runtime
   // memory errors.
diff --git a/core/unit_test/TestUtilities.hpp b/core/unit_test/TestUtilities.hpp
index 8de5f5e0d1..ad5a0df92d 100644
--- a/core/unit_test/TestUtilities.hpp
+++ b/core/unit_test/TestUtilities.hpp
@@ -25,20 +25,108 @@ namespace Test {
 
 void test_is_specialization_of() {
   using Kokkos::Impl::is_specialization_of;
-  static_assert(is_specialization_of<Kokkos::pair<float, int>, Kokkos::pair>{},
-                "");
-  static_assert(!is_specialization_of<Kokkos::View<int*>, Kokkos::pair>{}, "");
-  static_assert(is_specialization_of<Kokkos::View<int*>, Kokkos::View>{}, "");
+  static_assert(is_specialization_of<Kokkos::pair<float, int>, Kokkos::pair>{});
+  static_assert(!is_specialization_of<Kokkos::View<int*>, Kokkos::pair>{});
+  static_assert(is_specialization_of<Kokkos::View<int*>, Kokkos::View>{});
   // NOTE Not removing cv-qualifiers
-  static_assert(!is_specialization_of<Kokkos::View<int*> const, Kokkos::View>{},
-                "");
+  static_assert(
+      !is_specialization_of<Kokkos::View<int*> const, Kokkos::View>{});
   // NOTE Would not compile because Kokkos::Array takes a non-type template
   // parameter
-  // static_assert(is_specialization_of<Kokkos::Array<int, 4>, Kokkos::Array>{},
-  // "");
+  // static_assert(is_specialization_of<Kokkos::Array<int, 4>,
+  //               Kokkos::Array>{});
   // But this is fine of course
-  static_assert(!is_specialization_of<Kokkos::Array<float, 2>, Kokkos::pair>{},
-                "");
+  static_assert(!is_specialization_of<Kokkos::Array<float, 2>, Kokkos::pair>{});
+}
+
+namespace {
+enum Enum { EZero, EOne };
+enum EnumBool : bool { EBFalse, EBTrue };
+enum class ScopedEnum { SEZero, SEOne };
+enum class ScopedEnumShort : short { SESZero, SESOne };
+class Class {};
+
+template <typename Base, typename Derived>
+inline constexpr bool is_public_unambiguous_base_of_v =
+    std::is_convertible_v<Derived*, Base*> && !std::is_same_v<Derived, Base>;
+}  // namespace
+
+void test_to_underlying() {
+  using Kokkos::Impl::to_underlying;
+
+  constexpr auto e0 = to_underlying(EZero);
+  static_assert(e0 == 0);
+
+  constexpr auto e1 = to_underlying(EOne);
+  static_assert(e1 == 1);
+
+  constexpr auto eb0 = to_underlying(EBFalse);
+  constexpr bool b0  = false;
+  static_assert(std::is_same_v<decltype(eb0), decltype(b0)>);
+  static_assert(eb0 == b0);
+
+  constexpr auto eb1 = to_underlying(EBTrue);
+  constexpr bool b1  = true;
+  static_assert(std::is_same_v<decltype(eb1), decltype(b1)>);
+  static_assert(eb1 == b1);
+
+  constexpr auto se0 = to_underlying(ScopedEnum::SEZero);
+  static_assert(se0 == 0);
+
+  constexpr auto se1 = to_underlying(ScopedEnum::SEOne);
+  static_assert(se1 == 1);
+
+  constexpr auto ses0 = to_underlying(ScopedEnumShort::SESZero);
+  constexpr short s0  = 0;
+  static_assert(std::is_same_v<decltype(ses0), decltype(s0)>);
+  static_assert(ses0 == s0);
+
+  constexpr auto ses1 = to_underlying(ScopedEnumShort::SESOne);
+  constexpr short s1  = 1;
+  static_assert(std::is_same_v<decltype(ses1), decltype(s1)>);
+  static_assert(ses1 == s1);
+}
+
+void test_is_scoped_enum() {
+  using Kokkos::Impl::is_scoped_enum;
+  using Kokkos::Impl::is_scoped_enum_v;
+
+  static_assert(!is_scoped_enum<int>{});
+  static_assert(!is_scoped_enum<int>::value);
+  static_assert(!is_scoped_enum_v<int>);
+  static_assert(
+      is_public_unambiguous_base_of_v<std::false_type, is_scoped_enum<int>>);
+
+  static_assert(!is_scoped_enum<Class>{});
+  static_assert(!is_scoped_enum<Class>::value);
+  static_assert(!is_scoped_enum_v<Class>);
+  static_assert(
+      is_public_unambiguous_base_of_v<std::false_type, is_scoped_enum<Class>>);
+
+  static_assert(!is_scoped_enum<Enum>{});
+  static_assert(!is_scoped_enum<Enum>::value);
+  static_assert(!is_scoped_enum_v<Enum>);
+  static_assert(
+      is_public_unambiguous_base_of_v<std::false_type, is_scoped_enum<Enum>>);
+
+  static_assert(!is_scoped_enum<EnumBool>{});
+  static_assert(!is_scoped_enum<EnumBool>::value);
+  static_assert(!is_scoped_enum_v<EnumBool>);
+  static_assert(is_public_unambiguous_base_of_v<std::false_type,
+                                                is_scoped_enum<EnumBool>>);
+
+  static_assert(is_scoped_enum<ScopedEnum>{});
+  static_assert(is_scoped_enum<ScopedEnum>::value);
+  static_assert(is_scoped_enum_v<ScopedEnum>);
+  static_assert(is_public_unambiguous_base_of_v<std::true_type,
+                                                is_scoped_enum<ScopedEnum>>);
+
+  static_assert(is_scoped_enum<ScopedEnumShort>{});
+  static_assert(is_scoped_enum<ScopedEnumShort>::value);
+  static_assert(is_scoped_enum_v<ScopedEnumShort>);
+  static_assert(
+      is_public_unambiguous_base_of_v<std::true_type,
+                                      is_scoped_enum<ScopedEnumShort>>);
 }
 
 }  // namespace Test
diff --git a/core/unit_test/TestViewAPI.hpp b/core/unit_test/TestViewAPI.hpp
index 767f6e5e49..53c1f01678 100644
--- a/core/unit_test/TestViewAPI.hpp
+++ b/core/unit_test/TestViewAPI.hpp
@@ -837,18 +837,15 @@ struct TestViewMirror {
                                                     view_const_cast(v));
   }
 
-  template <class MemoryTraits, class Space>
+  template <class View>
   struct CopyUnInit {
-    using mirror_view_type = typename Kokkos::Impl::MirrorViewType<
-        Space, double *, Layout, Kokkos::HostSpace, MemoryTraits>::view_type;
-
-    mirror_view_type a_d;
+    View a_d;
 
     KOKKOS_INLINE_FUNCTION
-    CopyUnInit(mirror_view_type &a_d_) : a_d(a_d_) {}
+    explicit CopyUnInit(View const &a_d_) : a_d(a_d_) {}
 
     KOKKOS_INLINE_FUNCTION
-    void operator()(const typename Space::size_type i) const {
+    void operator()(const typename View::size_type i) const {
       a_d(i) = (double)(10 - i);
     }
   };
@@ -875,7 +872,8 @@ struct TestViewMirror {
 
     Kokkos::parallel_for(
         Kokkos::RangePolicy<typename DeviceType::execution_space>(0, int(10)),
-        CopyUnInit<MemoryTraits, DeviceType>(a_d));
+        // decltype required for Intel classics, that doesn't recognize the CTAD
+        CopyUnInit<decltype(a_d)>(a_d));
 
     Kokkos::deep_copy(a_h, a_d);
 
@@ -958,8 +956,7 @@ class TestViewAPI {
     using mirror_type = typename view_type::HostMirror;
 
     static_assert(std::is_same<typename view_type::memory_space,
-                               typename mirror_type::memory_space>::value,
-                  "");
+                               typename mirror_type::memory_space>::value);
 
     view_type a("a");
     mirror_type am = Kokkos::create_mirror_view(a);
@@ -1005,25 +1002,25 @@ class TestViewAPI {
     hView3 hv_3("dView3::HostMirror", N0);
     hView4 hv_4("dView4::HostMirror", N0);
 
-    dView0 dv_0_1(nullptr, 0);
+    dView0 dv_0_1(nullptr);
     dView0 dv_0_2(hv_0.label(), hv_0.layout());
 
-    dView1 dv_1_1(nullptr, 0);
+    dView1 dv_1_1(nullptr, N0);
     dView1 dv_1_2(hv_1.label(), hv_1.layout());
 
-    dView2 dv_2_1(nullptr, 0);
+    dView2 dv_2_1(nullptr, N0);
     dView2 dv_2_2(hv_2.label(), hv_2.layout());
 
-    dView3 dv_3_1(nullptr, 0);
+    dView3 dv_3_1(nullptr, N0);
     dView3 dv_3_2(hv_3.label(), hv_3.layout());
 
-    dView4 dv_4_1(nullptr, 0);
+    dView4 dv_4_1(nullptr, N0);
     dView4 dv_4_2(hv_4.label(), hv_4.layout());
   }
 
   static void run_test_contruction_from_layout_2() {
     using dView3_0 = Kokkos::View<T ***, device>;
-    using dView3_1 = Kokkos::View<T * * [N1], device>;
+    using dView3_1 = Kokkos::View<T * * [N2], device>;
     using dView3_2 = Kokkos::View<T * [N1][N2], device>;
     using dView3_3 = Kokkos::View<T[N0][N1][N2], device>;
 
@@ -1227,7 +1224,7 @@ class TestViewAPI {
       Kokkos::deep_copy(typename hView4::execution_space(), dx, hx);
       Kokkos::deep_copy(typename hView4::execution_space(), dy, dx);
       Kokkos::deep_copy(typename hView4::execution_space(), hy, dy);
-      typename dView4::execution_space().fence();
+      typename hView4::execution_space().fence();
 
       for (size_t ip = 0; ip < N0; ++ip)
         for (size_t i1 = 0; i1 < N1; ++i1)
@@ -1238,7 +1235,7 @@ class TestViewAPI {
 
       Kokkos::deep_copy(typename hView4::execution_space(), dx, T(0));
       Kokkos::deep_copy(typename hView4::execution_space(), hx, dx);
-      typename dView4::execution_space().fence();
+      typename hView4::execution_space().fence();
 
       for (size_t ip = 0; ip < N0; ++ip)
         for (size_t i1 = 0; i1 < N1; ++i1)
@@ -1340,6 +1337,40 @@ class TestViewAPI {
     ASSERT_EQ(dz.data(), nullptr);
   }
 
+  struct test_refcount_poison_copy_functor {
+    using view_type = Kokkos::View<double *>;
+    explicit test_refcount_poison_copy_functor(view_type v) : view(v) {}
+
+    test_refcount_poison_copy_functor(
+        const test_refcount_poison_copy_functor &other)
+        : view(other.view) {
+      throw std::bad_alloc();
+    }
+
+    KOKKOS_INLINE_FUNCTION void operator()(int) const {}
+
+    view_type view;
+  };
+
+  static void run_test_refcount_exception() {
+    using view_type = typename test_refcount_poison_copy_functor::view_type;
+    view_type original("original", N0);
+    ASSERT_EQ(original.use_count(), 1);
+
+    // test_refcount_poison_copy_functor throws during copy construction
+    try {
+      Kokkos::parallel_for(
+          Kokkos::RangePolicy<typename DeviceType::execution_space>(0, N0),
+          test_refcount_poison_copy_functor(original));
+    } catch (const std::bad_alloc &) {
+    }
+
+    // Ensure refcounting is enabled, we should increment here
+    auto copy = original;
+    ASSERT_EQ(original.use_count(), 2);
+    ASSERT_EQ(copy.use_count(), 2);
+  }
+
   static void run_test_deep_copy_empty() {
     // Check Deep Copy of LayoutLeft to LayoutRight
     {
@@ -1540,53 +1571,6 @@ class TestViewAPI {
     typename multivector_type::const_type cmvX(cmv);
     typename const_multivector_type::const_type ccmvX(cmv);
   }
-
-  static void run_test_error() {
-#ifdef KOKKOS_ENABLE_OPENMPTARGET
-    if (std::is_same<typename dView1::memory_space,
-                     Kokkos::Experimental::OpenMPTargetSpace>::value)
-      return;
-#endif
-// FIXME_MSVC_WITH_CUDA
-// This test doesn't behave as expected on Windows with CUDA
-#if defined(_WIN32) && defined(KOKKOS_ENABLE_CUDA)
-    if (std::is_same<typename dView1::memory_space,
-                     Kokkos::CudaUVMSpace>::value)
-      return;
-#endif
-    auto alloc_size = std::numeric_limits<size_t>::max() - 42;
-    try {
-      auto should_always_fail = dView1("hello_world_failure", alloc_size);
-    } catch (std::runtime_error const &error) {
-      // TODO once we remove the conversion to std::runtime_error, catch the
-      //      appropriate Kokkos error here
-      std::string msg = error.what();
-      ASSERT_PRED_FORMAT2(::testing::IsSubstring, "hello_world_failure", msg);
-      ASSERT_PRED_FORMAT2(::testing::IsSubstring,
-                          typename device::memory_space{}.name(), msg);
-      // Can't figure out how to make assertions either/or, so we'll just use
-      // an if statement here for now.  Test failure message will be a bit
-      // misleading, but developers should figure out what's going on pretty
-      // quickly.
-      if (msg.find("is not a valid size") != std::string::npos) {
-        ASSERT_PRED_FORMAT2(::testing::IsSubstring, "is not a valid size", msg);
-      } else
-#ifdef KOKKOS_ENABLE_SYCL
-          if (msg.find("insufficient memory") != std::string::npos)
-#endif
-      {
-        ASSERT_PRED_FORMAT2(::testing::IsSubstring, "insufficient memory", msg);
-      }
-      // SYCL cannot tell the reason why a memory allocation failed
-#ifdef KOKKOS_ENABLE_SYCL
-      else {
-        // Otherwise, there has to be some sort of "unknown error" error
-        ASSERT_PRED_FORMAT2(::testing::IsSubstring,
-                            "because of an unknown error.", msg);
-      }
-#endif
-    }
-  }
 };
 
 }  // namespace Test
diff --git a/core/unit_test/TestViewAPI_c.hpp b/core/unit_test/TestViewAPI_c.hpp
index 5efbd95bc9..042da1e984 100644
--- a/core/unit_test/TestViewAPI_c.hpp
+++ b/core/unit_test/TestViewAPI_c.hpp
@@ -19,6 +19,7 @@
 namespace Test {
 
 TEST(TEST_CATEGORY, view_api_c) {
+  TestViewAPI<double, TEST_EXECSPACE>::run_test_refcount_exception();
   TestViewAPI<double, TEST_EXECSPACE>::run_test_deep_copy_empty();
   TestViewAPI<double, TEST_EXECSPACE>::run_test_view_operator_b();
 }
diff --git a/core/unit_test/TestViewAPI_d.hpp b/core/unit_test/TestViewAPI_d.hpp
index 08d21f5449..075ac3329c 100644
--- a/core/unit_test/TestViewAPI_d.hpp
+++ b/core/unit_test/TestViewAPI_d.hpp
@@ -26,11 +26,4 @@ TEST(TEST_CATEGORY, view_api_d) {
   TestViewAPI<double, TEST_EXECSPACE>::run_test_view_operator_c();
 }
 
-TEST(TEST_CATEGORY, view_allocation_error) {
-#if ((HIP_VERSION_MAJOR == 5) && (HIP_VERSION_MINOR == 3))
-  GTEST_SKIP() << "ROCm 5.3 segfaults when trying to allocate too much memory";
-#endif
-  TestViewAPI<double, TEST_EXECSPACE>::run_test_error();
-}
-
 }  // namespace Test
diff --git a/core/unit_test/TestViewBadAlloc.hpp b/core/unit_test/TestViewBadAlloc.hpp
new file mode 100644
index 0000000000..7cb2f91655
--- /dev/null
+++ b/core/unit_test/TestViewBadAlloc.hpp
@@ -0,0 +1,86 @@
+//@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 {
+
+template <class MemorySpace>
+void test_view_bad_alloc() {
+  bool did_throw    = false;
+  auto too_large    = std::numeric_limits<size_t>::max() - 42;
+  std::string label = "my_label";
+  try {
+    auto should_always_fail =
+        Kokkos::View<double *, MemorySpace>(label, too_large);
+  } catch (std::runtime_error const &error) {
+    std::string msg = error.what();
+    ASSERT_PRED_FORMAT2(
+        ::testing::IsSubstring,
+        std::string(MemorySpace::name()) + " memory space failed to allocate",
+        msg)
+        << "memory space name is missing";
+    ASSERT_PRED_FORMAT2(::testing::IsSubstring,
+                        std::string("(label=\"") + label + "\")", msg)
+        << "label is missing";
+    did_throw = true;
+  }
+  ASSERT_TRUE(did_throw);
+}
+
+TEST(TEST_CATEGORY, view_bad_alloc) {
+  using ExecutionSpace = TEST_EXECSPACE;
+  using MemorySpace    = ExecutionSpace::memory_space;
+#if defined(__has_feature)
+#if __has_feature(address_sanitizer)
+  if (std::is_same_v<MemorySpace, Kokkos::HostSpace>) {
+    GTEST_SKIP() << "AddressSanitizer detects allocating too much memory "
+                    "preventing our checks to run";
+  }
+#endif
+#endif
+#if ((HIP_VERSION_MAJOR == 5) && (HIP_VERSION_MINOR == 3))
+  if (std::is_same_v<ExecutionSpace, Kokkos::HIP>) {
+    GTEST_SKIP()
+        << "ROCm 5.3 segfaults when trying to allocate too much memory";
+  }
+#endif
+#if defined(KOKKOS_ENABLE_OPENACC)  // FIXME_OPENACC
+  if (std::is_same_v<ExecutionSpace, Kokkos::Experimental::OpenACC>) {
+    GTEST_SKIP() << "acc_malloc() not properly returning nullptr";
+  }
+#endif
+
+  test_view_bad_alloc<MemorySpace>();
+
+  constexpr bool execution_space_is_device =
+      std::is_same_v<ExecutionSpace, Kokkos::DefaultExecutionSpace> &&
+      !std::is_same_v<Kokkos::DefaultExecutionSpace,
+                      Kokkos::DefaultHostExecutionSpace>;
+
+  if constexpr (execution_space_is_device) {
+    if constexpr (Kokkos::has_shared_space) {
+      test_view_bad_alloc<Kokkos::SharedSpace>();
+    }
+    if constexpr (Kokkos::has_shared_host_pinned_space) {
+      test_view_bad_alloc<Kokkos::SharedHostPinnedSpace>();
+    }
+  }
+}
+
+}  // namespace
diff --git a/core/unit_test/TestViewCopy_a.hpp b/core/unit_test/TestViewCopy_a.hpp
index 3bfc93aada..a4735b2998 100644
--- a/core/unit_test/TestViewCopy_a.hpp
+++ b/core/unit_test/TestViewCopy_a.hpp
@@ -147,6 +147,40 @@ TEST(TEST_CATEGORY, view_copy_tests) {
       Kokkos::deep_copy(s_a, hs_a);
       ASSERT_TRUE(run_check(s_a, 6));
     }
+  } else {
+    // These copies won't succeed, but they should each throw
+    // an exception whose message contains the view labels,
+    // and the names of the views' memory spaces.
+    //
+    // Note: original a,b both have the same device type,
+    // and their mirrors have the same device type.
+    using memory_space        = typename decltype(a)::memory_space;
+    using mirror_memory_space = typename decltype(h_a)::memory_space;
+    bool threw                = false;
+    std::string msg;
+    try {
+      Kokkos::deep_copy(hs_b, s_b);
+    } catch (std::exception& e) {
+      threw = true;
+      msg   = e.what();
+    }
+    ASSERT_TRUE(threw);
+    ASSERT_NE(msg.find(hs_b.label()), std::string::npos);
+    ASSERT_NE(msg.find(s_b.label()), std::string::npos);
+    ASSERT_NE(msg.find(memory_space().name()), std::string::npos);
+    ASSERT_NE(msg.find(mirror_memory_space().name()), std::string::npos);
+    threw = false;
+    try {
+      Kokkos::deep_copy(s_a, hs_a);
+    } catch (std::exception& e) {
+      threw = true;
+      msg   = e.what();
+    }
+    ASSERT_TRUE(threw);
+    ASSERT_NE(msg.find(s_a.label()), std::string::npos);
+    ASSERT_NE(msg.find(hs_a.label()), std::string::npos);
+    ASSERT_NE(msg.find(memory_space().name()), std::string::npos);
+    ASSERT_NE(msg.find(mirror_memory_space().name()), std::string::npos);
   }
 
   // Contiguous copies
diff --git a/core/unit_test/TestViewCopy_c.hpp b/core/unit_test/TestViewCopy_c.hpp
new file mode 100644
index 0000000000..758af13c7d
--- /dev/null
+++ b/core/unit_test/TestViewCopy_c.hpp
@@ -0,0 +1,434 @@
+//@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 {
+// Do not rely on deep_copy(0) as we want to test it!
+template <class ViewType, class ExecSpace>
+void reset_view(const ExecSpace& space, ViewType& a, int magic) {
+  auto policy = Kokkos::RangePolicy<ExecSpace>(space, 0, a.span());
+
+  assert(a.span_is_contiguous());
+
+  Kokkos::parallel_for(
+      "TestViewCopy::ResetView", policy,
+      KOKKOS_LAMBDA(int i) { a.data()[i] = magic; });
+}
+
+template <class ViewType, class ExecSpace>
+size_t compute_overall_sum(const ExecSpace& space, ViewType& a) {
+  auto policy = Kokkos::RangePolicy<ExecSpace>(space, 0, a.span());
+
+  assert(a.span_is_contiguous());
+
+  typename ViewType::value_type sum = 0;
+  Kokkos::parallel_reduce(
+      "TestViewCopy::ComputeSum", policy,
+      KOKKOS_LAMBDA(int i, int& lcl_sum) { lcl_sum += a.data()[i]; }, sum);
+
+  return static_cast<size_t>(sum);
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 0>* = nullptr) {
+  auto policy = Kokkos::RangePolicy<ExecSpace>(space, 0, 1);
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank0", policy,
+      KOKKOS_LAMBDA(int, bool& local_check) { local_check &= (a() == magic); },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 1>* = nullptr) {
+  auto policy = Kokkos::RangePolicy<ExecSpace>(space, 0, a.extent(0));
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank1", policy,
+      KOKKOS_LAMBDA(int i, bool& local_check) {
+        local_check &= (a(i) == magic);
+      },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 2>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<2>, ExecSpace>(
+      space, {0, 0}, {a.extent(0), a.extent(1)});
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank2", policy,
+      KOKKOS_LAMBDA(int i0, int i1, bool& local_check) {
+        local_check &= (a(i0, i1) == magic);
+      },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 3>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<3>, ExecSpace>(
+      space, {0, 0, 0}, {a.extent(0), a.extent(1), a.extent(2)});
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank3", policy,
+      KOKKOS_LAMBDA(int i0, int i1, int i2, bool& local_check) {
+        local_check &= (a(i0, i1, i2) == magic);
+      },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 4>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<4>, ExecSpace>(
+      space, {0, 0, 0, 0},
+      {a.extent(0), a.extent(1), a.extent(2), a.extent(3)});
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank4", policy,
+      KOKKOS_LAMBDA(int i0, int i1, int i2, int i3, bool& local_check) {
+        local_check &= (a(i0, i1, i2, i3) == magic);
+      },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 5>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<5>, ExecSpace>(
+      space, {0, 0, 0, 0, 0},
+      {a.extent(0), a.extent(1), a.extent(2), a.extent(3), a.extent(4)});
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank5", policy,
+      KOKKOS_LAMBDA(int i0, int i1, int i2, int i3, int i4, bool& local_check) {
+        local_check &= (a(i0, i1, i2, i3, i4) == magic);
+      },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 6>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<6>, ExecSpace>(
+      space, {0, 0, 0, 0, 0, 0},
+      {a.extent(0), a.extent(1), a.extent(2), a.extent(3), a.extent(4),
+       a.extent(5)});
+
+  bool all_elements_are_set;  // Uninitialized, set by parallel_reduce
+
+  Kokkos::parallel_reduce(
+      "TestViewCopy::CheckMagicValueRank6", policy,
+      KOKKOS_LAMBDA(int i0, int i1, int i2, int i3, int i4, int i5,
+                    bool& local_check) {
+        local_check &= (a(i0, i1, i2, i3, i4, i5) == magic);
+      },
+      Kokkos::LAnd<bool>(all_elements_are_set));
+
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 7>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<6>, ExecSpace>(
+      space, {0, 0, 0, 0, 0, 0},
+      {a.extent(0), a.extent(1), a.extent(2), a.extent(3), a.extent(4),
+       a.extent(5)});
+
+  bool all_elements_are_set = true;
+
+  for (size_t outer = 0; outer < a.extent(6); ++outer) {
+    bool all_local_elements_are_set;  // Uninitialized, set by parallel_reduce
+    Kokkos::parallel_reduce(
+        "TestViewCopy::CheckMagicValueRank7", policy,
+        KOKKOS_LAMBDA(int i0, int i1, int i2, int i3, int i4, int i5,
+                      bool& local_check) {
+          local_check &= (a(i0, i1, i2, i3, i4, i5, outer) == magic);
+        },
+        Kokkos::LAnd<bool>(all_local_elements_are_set));
+
+    all_elements_are_set = all_elements_are_set && all_local_elements_are_set;
+  }
+  return all_elements_are_set;
+}
+
+template <typename ExecSpace, typename DT, typename... DP>
+bool check_magic_value(
+    const ExecSpace& space, const Kokkos::View<DT, DP...>& a, int magic,
+    std::enable_if_t<Kokkos::ViewTraits<DT, DP...>::rank == 8>* = nullptr) {
+  auto policy = Kokkos::MDRangePolicy<Kokkos::Rank<6>, ExecSpace>(
+      space, {0, 0, 0, 0, 0, 0},
+      {a.extent(0), a.extent(1), a.extent(2), a.extent(3), a.extent(4),
+       a.extent(5)});
+
+  bool all_elements_are_set = true;
+
+  for (size_t outer = 0; outer < a.extent(7); ++outer) {
+    for (size_t inner = 0; inner < a.extent(6); ++inner) {
+      bool all_local_elements_are_set;  // Uninitialized, set by parallel_reduce
+      Kokkos::parallel_reduce(
+          "TestViewCopy::CheckMagicValueRank8", policy,
+          KOKKOS_LAMBDA(int i0, int i1, int i2, int i3, int i4, int i5,
+                        bool& local_check) {
+            local_check &= (a(i0, i1, i2, i3, i4, i5, inner, outer) == magic);
+          },
+          Kokkos::LAnd<bool>(all_local_elements_are_set));
+
+      all_elements_are_set = all_elements_are_set && all_local_elements_are_set;
+    }
+  }
+  return all_elements_are_set;
+}
+
+template <class ExecSpace, class ViewType>
+bool view_fill_test(const ExecSpace& space, ViewType& a, int magic) {
+  Kokkos::deep_copy(space, a, magic);
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)
+  // FIXME_OPENMPTARGET Does not work with Land reducer
+  return true;
+#else   // KOKKOS_ENABLE_OPENMPTARGET
+  return check_magic_value(space, a, magic);
+#endif  // KOKKOS_ENABLE_OPENMPTARGET
+}
+
+template <class Layout, class Space>
+void run_test() {
+  int magic = 19;
+
+  using ViewType = Kokkos::View<int********, Layout, Space>;
+  // Create views with different lengths for each dimension
+  // We want to test if all loops are over the correct dimensions
+  // We use prime numbers to make sure that the strides are different
+  ViewType a_decreasing("a", 23, 19, 17, 13, 11, 7, 5, 3);
+  // We also test with increasing strides to catch more "out-of-bounds" errors
+  // within subviews.
+  ViewType a_increasing("a", 3, 5, 7, 11, 13, 17, 19, 23);
+
+  using exec_space = typename Space::execution_space;
+  auto space       = exec_space();
+
+  // Use subviews in the tests to have cases with different ranks and
+  // non-contiguous memory
+  // Tests have two parts:
+  // 1. Fill the subview with a magic value and check that all elements are set
+  // 2. Check if only the subview is set by summing all elements in the view and
+  // comparing to the subview size times the magic value
+
+  // Rank 0
+  {
+    auto sub_dec = Kokkos::subview(a_decreasing, 0, 0, 0, 0, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing),
+              static_cast<size_t>(magic));
+
+    auto sub_inc = Kokkos::subview(a_increasing, 0, 0, 0, 0, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing),
+              static_cast<size_t>(magic));
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+
+  // Rank 1
+  {
+    auto sub_dec =
+        Kokkos::subview(a_decreasing, Kokkos::ALL, 0, 0, 0, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing), sub_dec.size() * magic);
+
+    auto sub_inc =
+        Kokkos::subview(a_increasing, Kokkos::ALL, 0, 0, 0, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+
+  // Rank 2
+  {
+    auto sub_dec = Kokkos::subview(a_decreasing, Kokkos::ALL, Kokkos::ALL, 0, 0,
+                                   0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing), sub_dec.size() * magic);
+
+    auto sub_inc = Kokkos::subview(a_increasing, Kokkos::ALL, Kokkos::ALL, 0, 0,
+                                   0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+  space.fence();
+
+  // Rank 3
+  {
+    auto sub_dec = Kokkos::subview(a_decreasing, Kokkos::ALL, Kokkos::ALL,
+                                   Kokkos::ALL, 0, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(
+        compute_overall_sum(space, a_decreasing),
+        sub_dec.extent(0) * sub_dec.extent(1) * sub_dec.extent(2) * magic);
+
+    auto sub_inc = Kokkos::subview(a_increasing, Kokkos::ALL, Kokkos::ALL,
+                                   Kokkos::ALL, 0, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+  space.fence();
+
+  // Rank 4
+  {
+    auto sub_dec = Kokkos::subview(a_decreasing, Kokkos::ALL, Kokkos::ALL,
+                                   Kokkos::ALL, Kokkos::ALL, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing),
+              sub_dec.extent(0) * sub_dec.extent(1) * sub_dec.extent(2) *
+                  sub_dec.extent(3) * magic);
+
+    auto sub_inc = Kokkos::subview(a_increasing, Kokkos::ALL, Kokkos::ALL,
+                                   Kokkos::ALL, Kokkos::ALL, 0, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+  space.fence();
+
+  // Rank 5
+  {
+    auto sub_dec =
+        Kokkos::subview(a_decreasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+                        Kokkos::ALL, Kokkos::ALL, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing), sub_dec.size() * magic);
+
+    auto sub_inc =
+        Kokkos::subview(a_increasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+                        Kokkos::ALL, Kokkos::ALL, 0, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+  space.fence();
+
+  // Rank 6
+  {
+    auto sub_dec =
+        Kokkos::subview(a_decreasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+                        Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing), sub_dec.size() * magic);
+
+    auto sub_inc =
+        Kokkos::subview(a_increasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+                        Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, 0, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+  space.fence();
+
+  // Rank 7
+  {
+    auto sub_dec =
+        Kokkos::subview(a_decreasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+                        Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing), sub_dec.size() * magic);
+
+    auto sub_inc =
+        Kokkos::subview(a_increasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+                        Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, 0);
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+  reset_view(space, a_decreasing, 0);
+  reset_view(space, a_increasing, 0);
+  space.fence();
+
+  // Rank 8
+  {
+    auto sub_dec = Kokkos::subview(
+        a_decreasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+        Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, std::make_pair(0, 2));
+    EXPECT_TRUE(view_fill_test(space, sub_dec, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_decreasing), sub_dec.size() * magic);
+
+    auto sub_inc = Kokkos::subview(
+        a_increasing, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
+        Kokkos::ALL, Kokkos::ALL, Kokkos::ALL, std::make_pair(0, 2));
+    EXPECT_TRUE(view_fill_test(space, sub_inc, magic));
+    EXPECT_EQ(compute_overall_sum(space, a_increasing), sub_inc.size() * magic);
+  }
+}
+
+TEST(TEST_CATEGORY, view_fill_tests_layout_right) {
+  using Space  = TEST_EXECSPACE;
+  using Layout = Kokkos::LayoutRight;
+  run_test<Layout, Space>();
+}
+
+TEST(TEST_CATEGORY, view_fill_tests_layout_left) {
+  using Space  = TEST_EXECSPACE;
+  using Layout = Kokkos::LayoutLeft;
+  run_test<Layout, Space>();
+}
+
+}  // namespace
diff --git a/core/unit_test/TestViewCtorDimMatch.hpp b/core/unit_test/TestViewCtorDimMatch.hpp
index ff62eaeccc..40b7737f2e 100644
--- a/core/unit_test/TestViewCtorDimMatch.hpp
+++ b/core/unit_test/TestViewCtorDimMatch.hpp
@@ -19,384 +19,183 @@
 
 namespace Test {
 
-#define LIVE(EXPR, ARGS, DYNRANK) EXPECT_NO_THROW(EXPR)
-#define DIE(EXPR, ARGS, DYNRANK)                                           \
-  ASSERT_DEATH(                                                            \
-      EXPR,                                                                \
-      "Constructor for Kokkos View 'v_" #ARGS                              \
-      "' has mismatched number of arguments. Number of arguments = " #ARGS \
-      " but dynamic rank = " #DYNRANK)
+template <int rank, int dynrank, class RankType, std::size_t... Is>
+void test_matching_arguments_rank_helper(std::index_sequence<Is...>) {
+  constexpr int nargs = sizeof...(Is);
+  using view_type     = Kokkos::View<RankType>;
+  if (nargs == rank || nargs == dynrank) {
+    EXPECT_NO_THROW({ view_type v("v", ((Is * 0) + 1)...); });
+    EXPECT_NO_THROW({ view_type v(nullptr, ((Is * 0) + 1)...); });
+  } else {
+    ASSERT_DEATH(
+        { view_type v("v", ((Is * 0) + 1)...); },
+        "Constructor for Kokkos::View 'v' has mismatched number of arguments. "
+        "The number of arguments = " +
+            std::to_string(nargs) +
+            " neither matches the dynamic rank = " + std::to_string(dynrank) +
+            " nor the total rank = " + std::to_string(rank));
+    ASSERT_DEATH(
+        { view_type v(nullptr, ((Is * 0) + 1)...); },
+        "Constructor for Kokkos::View 'UNMANAGED' has mismatched number of "
+        "arguments. "
+        "The number of arguments = " +
+            std::to_string(nargs) +
+            " neither matches the dynamic rank = " + std::to_string(dynrank) +
+            " nor the total rank = " + std::to_string(rank));
+  }
+}
 
-#define PARAM_0
-#define PARAM_1 1
-#define PARAM_2 1, 1
-#define PARAM_3 1, 1, 1
-#define PARAM_4 1, 1, 1, 1
-#define PARAM_5 1, 1, 1, 1, 1
-#define PARAM_6 1, 1, 1, 1, 1, 1
-#define PARAM_7 1, 1, 1, 1, 1, 1, 1
+template <int rank, int dynrank, template <int> class RankType>
+void test_matching_arguments_rank() {
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<0>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<1>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<2>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<3>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<4>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<5>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<6>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<7>());
+  test_matching_arguments_rank_helper<rank, dynrank,
+                                      typename RankType<rank>::type>(
+      std::make_index_sequence<8>());
+}
 
-#define PARAM_0_RANK 0
-#define PARAM_1_RANK 1
-#define PARAM_2_RANK 2
-#define PARAM_3_RANK 3
-#define PARAM_4_RANK 4
-#define PARAM_5_RANK 5
-#define PARAM_6_RANK 6
-#define PARAM_7_RANK 7
+template <int rank>
+struct DynamicRank {
+  using type = typename DynamicRank<rank - 1>::type*;
+};
 
-using DType = int;
+template <>
+struct DynamicRank<0> {
+  using type = int;
+};
 
 // Skip test execution when KOKKOS_ENABLE_OPENMPTARGET is enabled until
 // Kokkos::abort() aborts properly on that backend
-// Skip test execution when KOKKOS_COMPILER_NVHPC until fixed in GTEST
-#if defined(KOKKOS_ENABLE_OPENMPTARGET) || (KOKKOS_COMPILER_NVHPC)
-#else
+#ifndef KOKKOS_ENABLE_OPENMPTARGET
 TEST(TEST_CATEGORY_DEATH, view_construction_with_wrong_params_dyn) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  using DType_0 = DType;
-  using DType_1 = DType *;
-  using DType_2 = DType **;
-  using DType_3 = DType ***;
-  using DType_4 = DType ****;
-  using DType_5 = DType *****;
-  using DType_6 = DType ******;
-  using DType_7 = DType *******;
-  {
-    // test View parameters for View dim = 0, dynamic = 0
-    LIVE({ Kokkos::View<DType_0> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_0> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_0> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_0> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_0> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_0> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_0> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_0> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 1, dynamic = 1
-    DIE({ Kokkos::View<DType_1> v_0("v_0" PARAM_0); }, 0, 1);
-    LIVE({ Kokkos::View<DType_1> v_1("v_1", PARAM_1); }, 1, 1);
-    DIE({ Kokkos::View<DType_1> v_2("v_2", PARAM_2); }, 2, 1);
-    DIE({ Kokkos::View<DType_1> v_3("v_3", PARAM_3); }, 3, 1);
-    DIE({ Kokkos::View<DType_1> v_4("v_4", PARAM_4); }, 4, 1);
-    DIE({ Kokkos::View<DType_1> v_5("v_5", PARAM_5); }, 5, 1);
-    DIE({ Kokkos::View<DType_1> v_6("v_6", PARAM_6); }, 6, 1);
-    DIE({ Kokkos::View<DType_1> v_7("v_7", PARAM_7); }, 7, 1);
-  }
-
-  {
-    // test View parameters for View dim = 2, dynamic = 2
-    DIE({ Kokkos::View<DType_2> v_0("v_0" PARAM_0); }, 0, 2);
-    DIE({ Kokkos::View<DType_2> v_1("v_1", PARAM_1); }, 1, 2);
-    LIVE({ Kokkos::View<DType_2> v_2("v_2", PARAM_2); }, 2, 2);
-    DIE({ Kokkos::View<DType_2> v_3("v_3", PARAM_3); }, 3, 2);
-    DIE({ Kokkos::View<DType_2> v_4("v_4", PARAM_4); }, 4, 2);
-    DIE({ Kokkos::View<DType_2> v_5("v_5", PARAM_5); }, 5, 2);
-    DIE({ Kokkos::View<DType_2> v_6("v_6", PARAM_6); }, 6, 2);
-    DIE({ Kokkos::View<DType_2> v_7("v_7", PARAM_7); }, 7, 2);
-  }
-
-  {
-    // test View parameters for View dim = 3, dynamic = 3
-    DIE({ Kokkos::View<DType_3> v_0("v_0" PARAM_0); }, 0, 3);
-    DIE({ Kokkos::View<DType_3> v_1("v_1", PARAM_1); }, 1, 3);
-    DIE({ Kokkos::View<DType_3> v_2("v_2", PARAM_2); }, 2, 3);
-    LIVE({ Kokkos::View<DType_3> v_3("v_3", PARAM_3); }, 3, 3);
-    DIE({ Kokkos::View<DType_3> v_4("v_4", PARAM_4); }, 4, 3);
-    DIE({ Kokkos::View<DType_3> v_5("v_5", PARAM_5); }, 5, 3);
-    DIE({ Kokkos::View<DType_3> v_6("v_6", PARAM_6); }, 6, 3);
-    DIE({ Kokkos::View<DType_3> v_7("v_7", PARAM_7); }, 7, 3);
-  }
-
-  {
-    // test View parameters for View dim = 4, dynamic = 4
-    DIE({ Kokkos::View<DType_4> v_0("v_0" PARAM_0); }, 0, 4);
-    DIE({ Kokkos::View<DType_4> v_1("v_1", PARAM_1); }, 1, 4);
-    DIE({ Kokkos::View<DType_4> v_2("v_2", PARAM_2); }, 2, 4);
-    DIE({ Kokkos::View<DType_4> v_3("v_3", PARAM_3); }, 3, 4);
-    LIVE({ Kokkos::View<DType_4> v_4("v_4", PARAM_4); }, 4, 4);
-    DIE({ Kokkos::View<DType_4> v_5("v_5", PARAM_5); }, 5, 4);
-    DIE({ Kokkos::View<DType_4> v_6("v_6", PARAM_6); }, 6, 4);
-    DIE({ Kokkos::View<DType_4> v_7("v_7", PARAM_7); }, 7, 4);
-  }
-
-  {
-    // test View parameters for View dim = 5, dynamic = 5
-    DIE({ Kokkos::View<DType_5> v_0("v_0" PARAM_0); }, 0, 5);
-    DIE({ Kokkos::View<DType_5> v_1("v_1", PARAM_1); }, 1, 5);
-    DIE({ Kokkos::View<DType_5> v_2("v_2", PARAM_2); }, 2, 5);
-    DIE({ Kokkos::View<DType_5> v_3("v_3", PARAM_3); }, 3, 5);
-    DIE({ Kokkos::View<DType_5> v_4("v_4", PARAM_4); }, 4, 5);
-    LIVE({ Kokkos::View<DType_5> v_5("v_5", PARAM_5); }, 5, 5);
-    DIE({ Kokkos::View<DType_5> v_6("v_6", PARAM_6); }, 6, 5);
-    DIE({ Kokkos::View<DType_5> v_7("v_7", PARAM_7); }, 7, 5);
-  }
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECKS
+  test_matching_arguments_rank<0, 0, DynamicRank>();  // dim = 0, dynamic = 0
+  test_matching_arguments_rank<1, 1, DynamicRank>();  // dim = 1, dynamic = 1
+  test_matching_arguments_rank<2, 2, DynamicRank>();  // dim = 2, dynamic = 2
+  test_matching_arguments_rank<3, 3, DynamicRank>();  // dim = 3, dynamic = 3
+  test_matching_arguments_rank<4, 4, DynamicRank>();  // dim = 4, dynamic = 4
+  test_matching_arguments_rank<5, 5, DynamicRank>();  // dim = 5, dynamic = 5
+  test_matching_arguments_rank<6, 6, DynamicRank>();  // dim = 6, dynamic = 6
+  test_matching_arguments_rank<7, 7, DynamicRank>();  // dim = 7, dynamic = 7
+  test_matching_arguments_rank<8, 8, DynamicRank>();  // dim = 8, dynamic = 8
+#endif
+}
 
-  {
-    // test View parameters for View dim = 6, dynamic = 6
-    DIE({ Kokkos::View<DType_6> v_0("v_0" PARAM_0); }, 0, 6);
-    DIE({ Kokkos::View<DType_6> v_1("v_1", PARAM_1); }, 1, 6);
-    DIE({ Kokkos::View<DType_6> v_2("v_2", PARAM_2); }, 2, 6);
-    DIE({ Kokkos::View<DType_6> v_3("v_3", PARAM_3); }, 3, 6);
-    DIE({ Kokkos::View<DType_6> v_4("v_4", PARAM_4); }, 4, 6);
-    DIE({ Kokkos::View<DType_6> v_5("v_5", PARAM_5); }, 5, 6);
-    LIVE({ Kokkos::View<DType_6> v_6("v_6", PARAM_6); }, 6, 6);
-    DIE({ Kokkos::View<DType_6> v_7("v_7", PARAM_7); }, 7, 6);
-  }
+template <int rank>
+struct StaticRank {
+  using type = typename StaticRank<rank - 1>::type[1];
+};
 
-  {
-    // test View parameters for View dim = 7, dynamic = 7
-    DIE({ Kokkos::View<DType_7> v_0("v_0" PARAM_0); }, 0, 7);
-    DIE({ Kokkos::View<DType_7> v_1("v_1", PARAM_1); }, 1, 7);
-    DIE({ Kokkos::View<DType_7> v_2("v_2", PARAM_2); }, 2, 7);
-    DIE({ Kokkos::View<DType_7> v_3("v_3", PARAM_3); }, 3, 7);
-    DIE({ Kokkos::View<DType_7> v_4("v_4", PARAM_4); }, 4, 7);
-    DIE({ Kokkos::View<DType_7> v_5("v_5", PARAM_5); }, 5, 7);
-    DIE({ Kokkos::View<DType_7> v_6("v_6", PARAM_6); }, 6, 7);
-    LIVE({ Kokkos::View<DType_7> v_7("v_7", PARAM_7); }, 7, 7);
-  }
-}
+template <>
+struct StaticRank<0> {
+  using type = int;
+};
 
 TEST(TEST_CATEGORY_DEATH, view_construction_with_wrong_params_stat) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  using DType_0 = DType;
-  using DType_1 = DType[1];
-  using DType_2 = DType[1][1];
-  using DType_3 = DType[1][1][1];
-  using DType_4 = DType[1][1][1][1];
-  using DType_5 = DType[1][1][1][1][1];
-  using DType_6 = DType[1][1][1][1][1][1];
-  using DType_7 = DType[1][1][1][1][1][1][1];
-  {
-    // test View parameters for View dim = 0, dynamic = 0
-    LIVE({ Kokkos::View<DType_0> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_0> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_0> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_0> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_0> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_0> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_0> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_0> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 1, dynamic = 0
-    LIVE({ Kokkos::View<DType_1> v_0("v_0" PARAM_0); }, 0, 0);
-    LIVE({ Kokkos::View<DType_1> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_1> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_1> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_1> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_1> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_1> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_1> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 2, dynamic = 0
-    LIVE({ Kokkos::View<DType_2> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_2> v_1("v_1", PARAM_1); }, 1, 0);
-    LIVE({ Kokkos::View<DType_2> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_2> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_2> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_2> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_2> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_2> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 3, dynamic = 0
-    LIVE({ Kokkos::View<DType_3> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_3> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_3> v_2("v_2", PARAM_2); }, 2, 0);
-    LIVE({ Kokkos::View<DType_3> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_3> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_3> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_3> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_3> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 4, dynamic = 0
-    LIVE({ Kokkos::View<DType_4> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_4> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_4> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_4> v_3("v_3", PARAM_3); }, 3, 0);
-    LIVE({ Kokkos::View<DType_4> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_4> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_4> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_4> v_7("v_7", PARAM_7); }, 7, 0);
-  }
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECKS
+  test_matching_arguments_rank<0, 0, StaticRank>();  // dim = 0, dynamic = 0
+  test_matching_arguments_rank<1, 0, StaticRank>();  // dim = 1, dynamic = 0
+  test_matching_arguments_rank<2, 0, StaticRank>();  // dim = 2, dynamic = 0
+  test_matching_arguments_rank<3, 0, StaticRank>();  // dim = 3, dynamic = 0
+  test_matching_arguments_rank<4, 0, StaticRank>();  // dim = 4, dynamic = 0
+  test_matching_arguments_rank<5, 0, StaticRank>();  // dim = 5, dynamic = 0
+  test_matching_arguments_rank<6, 0, StaticRank>();  // dim = 6, dynamic = 0
+  test_matching_arguments_rank<7, 0, StaticRank>();  // dim = 7, dynamic = 0
+  test_matching_arguments_rank<8, 0, StaticRank>();  // dim = 8, dynamic = 0
+#endif
+}
 
-  {
-    // test View parameters for View dim = 5, dynamic = 0
-    LIVE({ Kokkos::View<DType_5> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_5> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_5> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_5> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_5> v_4("v_4", PARAM_4); }, 4, 0);
-    LIVE({ Kokkos::View<DType_5> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_5> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_5> v_7("v_7", PARAM_7); }, 7, 0);
-  }
+template <int rank>
+struct MixedRank {
+  using type = typename DynamicRank<rank - 1>::type[1];
+};
 
-  {
-    // test View parameters for View dim = 6, dynamic = 0
-    LIVE({ Kokkos::View<DType_6> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_6> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_6> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_6> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_6> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_6> v_5("v_5", PARAM_5); }, 5, 0);
-    LIVE({ Kokkos::View<DType_6> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_6> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 7, dynamic = 0
-    LIVE({ Kokkos::View<DType_7> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_7> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_7> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_7> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_7> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_7> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_7> v_6("v_6", PARAM_6); }, 6, 0);
-    LIVE({ Kokkos::View<DType_7> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-}
+template <>
+struct MixedRank<0> {
+  using type = int;
+};
 
 TEST(TEST_CATEGORY_DEATH, view_construction_with_wrong_params_mix) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  using DType_0 = DType;
-  using DType_1 = DType[1];
-  using DType_2 = DType * [1];
-  using DType_3 = DType * * [1];
-  using DType_4 = DType ** * [1];
-  using DType_5 = DType *** * [1];
-  using DType_6 = DType **** * [1];
-  using DType_7 = DType ***** * [1];
-  {
-    // test View parameters for View dim = 0, dynamic = 0
-    LIVE({ Kokkos::View<DType_0> v_0("v_0" PARAM_0); }, 0, 0);
-    DIE({ Kokkos::View<DType_0> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_0> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_0> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_0> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_0> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_0> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_0> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 1, dynamic = 0
-    LIVE({ Kokkos::View<DType_1> v_0("v_0" PARAM_0); }, 0, 0);
-    LIVE({ Kokkos::View<DType_1> v_1("v_1", PARAM_1); }, 1, 0);
-    DIE({ Kokkos::View<DType_1> v_2("v_2", PARAM_2); }, 2, 0);
-    DIE({ Kokkos::View<DType_1> v_3("v_3", PARAM_3); }, 3, 0);
-    DIE({ Kokkos::View<DType_1> v_4("v_4", PARAM_4); }, 4, 0);
-    DIE({ Kokkos::View<DType_1> v_5("v_5", PARAM_5); }, 5, 0);
-    DIE({ Kokkos::View<DType_1> v_6("v_6", PARAM_6); }, 6, 0);
-    DIE({ Kokkos::View<DType_1> v_7("v_7", PARAM_7); }, 7, 0);
-  }
-
-  {
-    // test View parameters for View dim = 2, dynamic = 1
-    DIE({ Kokkos::View<DType_2> v_0("v_0" PARAM_0); }, 0, 1);
-    LIVE({ Kokkos::View<DType_2> v_1("v_1", PARAM_1); }, 1, 1);
-    LIVE({ Kokkos::View<DType_2> v_2("v_2", PARAM_2); }, 2, 1);
-    DIE({ Kokkos::View<DType_2> v_3("v_3", PARAM_3); }, 3, 1);
-    DIE({ Kokkos::View<DType_2> v_4("v_4", PARAM_4); }, 4, 1);
-    DIE({ Kokkos::View<DType_2> v_5("v_5", PARAM_5); }, 5, 1);
-    DIE({ Kokkos::View<DType_2> v_6("v_6", PARAM_6); }, 6, 1);
-    DIE({ Kokkos::View<DType_2> v_7("v_7", PARAM_7); }, 7, 1);
-  }
-
-  {
-    // test View parameters for View dim = 3, dynamic = 2
-    DIE({ Kokkos::View<DType_3> v_0("v_0" PARAM_0); }, 0, 2);
-    DIE({ Kokkos::View<DType_3> v_1("v_1", PARAM_1); }, 1, 2);
-    LIVE({ Kokkos::View<DType_3> v_2("v_2", PARAM_2); }, 2, 2);
-    LIVE({ Kokkos::View<DType_3> v_3("v_3", PARAM_3); }, 3, 2);
-    DIE({ Kokkos::View<DType_3> v_4("v_4", PARAM_4); }, 4, 2);
-    DIE({ Kokkos::View<DType_3> v_5("v_5", PARAM_5); }, 5, 2);
-    DIE({ Kokkos::View<DType_3> v_6("v_6", PARAM_6); }, 6, 2);
-    DIE({ Kokkos::View<DType_3> v_7("v_7", PARAM_7); }, 7, 2);
-  }
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECKS
+  test_matching_arguments_rank<0, 0, MixedRank>();  // dim = 0, dynamic = 0
+  test_matching_arguments_rank<1, 0, MixedRank>();  // dim = 1, dynamic = 0
+  test_matching_arguments_rank<2, 1, MixedRank>();  // dim = 2, dynamic = 1
+  test_matching_arguments_rank<3, 2, MixedRank>();  // dim = 3, dynamic = 2
+  test_matching_arguments_rank<4, 3, MixedRank>();  // dim = 4, dynamic = 3
+  test_matching_arguments_rank<5, 4, MixedRank>();  // dim = 5, dynamic = 4
+  test_matching_arguments_rank<6, 5, MixedRank>();  // dim = 6, dynamic = 5
+  test_matching_arguments_rank<7, 6, MixedRank>();  // dim = 7, dynamic = 6
+  test_matching_arguments_rank<8, 7, MixedRank>();  // dim = 8, dynamic = 7
+#endif
+}
 
-  {
-    // test View parameters for View dim = 4, dynamic = 3
-    DIE({ Kokkos::View<DType_4> v_0("v_0" PARAM_0); }, 0, 3);
-    DIE({ Kokkos::View<DType_4> v_1("v_1", PARAM_1); }, 1, 3);
-    DIE({ Kokkos::View<DType_4> v_2("v_2", PARAM_2); }, 2, 3);
-    LIVE({ Kokkos::View<DType_4> v_3("v_3", PARAM_3); }, 3, 3);
-    LIVE({ Kokkos::View<DType_4> v_4("v_4", PARAM_4); }, 4, 3);
-    DIE({ Kokkos::View<DType_4> v_5("v_5", PARAM_5); }, 5, 3);
-    DIE({ Kokkos::View<DType_4> v_6("v_6", PARAM_6); }, 6, 3);
-    DIE({ Kokkos::View<DType_4> v_7("v_7", PARAM_7); }, 7, 3);
-  }
+#define CHECK_DEATH(EXPR)                                                     \
+  ASSERT_DEATH(EXPR,                                                          \
+               "The specified run-time extent for Kokkos::View 'v' does not " \
+               "match the compile-time extent in dimension 0. The given "     \
+               "extent is 2 but should be 1.")
 
-  {
-    // test View parameters for View dim = 5, dynamic = 4
-    DIE({ Kokkos::View<DType_5> v_0("v_0" PARAM_0); }, 0, 4);
-    DIE({ Kokkos::View<DType_5> v_1("v_1", PARAM_1); }, 1, 4);
-    DIE({ Kokkos::View<DType_5> v_2("v_2", PARAM_2); }, 2, 4);
-    DIE({ Kokkos::View<DType_5> v_3("v_3", PARAM_3); }, 3, 4);
-    LIVE({ Kokkos::View<DType_5> v_4("v_4", PARAM_4); }, 4, 4);
-    LIVE({ Kokkos::View<DType_5> v_5("v_5", PARAM_5); }, 5, 4);
-    DIE({ Kokkos::View<DType_5> v_6("v_6", PARAM_6); }, 6, 4);
-    DIE({ Kokkos::View<DType_5> v_7("v_7", PARAM_7); }, 7, 4);
-  }
+#define CHECK_DEATH_UNMANAGED(EXPR)                                          \
+  ASSERT_DEATH(                                                              \
+      EXPR,                                                                  \
+      "The specified run-time extent for Kokkos::View 'UNMANAGED' does not " \
+      "match the compile-time extent in dimension 0. The given "             \
+      "extent is 2 but should be 1.")
 
-  {
-    // test View parameters for View dim = 6, dynamic = 5
-    DIE({ Kokkos::View<DType_6> v_0("v_0" PARAM_0); }, 0, 5);
-    DIE({ Kokkos::View<DType_6> v_1("v_1", PARAM_1); }, 1, 5);
-    DIE({ Kokkos::View<DType_6> v_2("v_2", PARAM_2); }, 2, 5);
-    DIE({ Kokkos::View<DType_6> v_3("v_3", PARAM_3); }, 3, 5);
-    DIE({ Kokkos::View<DType_6> v_4("v_4", PARAM_4); }, 4, 5);
-    LIVE({ Kokkos::View<DType_6> v_5("v_5", PARAM_5); }, 5, 5);
-    LIVE({ Kokkos::View<DType_6> v_6("v_6", PARAM_6); }, 6, 5);
-    DIE({ Kokkos::View<DType_6> v_7("v_7", PARAM_7); }, 7, 5);
-  }
+TEST(TEST_CATEGORY_DEATH, view_construction_with_wrong_static_extents) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  {
-    // test View parameters for View dim = 7, dynamic = 6
-    DIE({ Kokkos::View<DType_7> v_0("v_0" PARAM_0); }, 0, 6);
-    DIE({ Kokkos::View<DType_7> v_1("v_1", PARAM_1); }, 1, 6);
-    DIE({ Kokkos::View<DType_7> v_2("v_2", PARAM_2); }, 2, 6);
-    DIE({ Kokkos::View<DType_7> v_3("v_3", PARAM_3); }, 3, 6);
-    DIE({ Kokkos::View<DType_7> v_4("v_4", PARAM_4); }, 4, 6);
-    DIE({ Kokkos::View<DType_7> v_5("v_5", PARAM_5); }, 5, 6);
-    LIVE({ Kokkos::View<DType_7> v_6("v_6", PARAM_6); }, 6, 6);
-    LIVE({ Kokkos::View<DType_7> v_7("v_7", PARAM_7); }, 7, 6);
-  }
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECKS
+  // clang-format off
+  CHECK_DEATH({ Kokkos::View<int[1]>                      v("v", 2); });
+  CHECK_DEATH({ Kokkos::View<int[1][1]>                   v("v", 2, 1); });
+  CHECK_DEATH({ Kokkos::View<int[1][1][1]>                v("v", 2, 1, 1); });
+  CHECK_DEATH({ Kokkos::View<int[1][1][1][1]>             v("v", 2, 1, 1, 1); });
+  CHECK_DEATH({ Kokkos::View<int[1][1][1][1][1]>          v("v", 2, 1, 1, 1, 1); });
+  CHECK_DEATH({ Kokkos::View<int[1][1][1][1][1][1]>       v("v", 2, 1, 1, 1, 1, 1); });
+  CHECK_DEATH({ Kokkos::View<int[1][1][1][1][1][1][1]>    v("v", 2, 1, 1, 1, 1, 1, 1); });
+  CHECK_DEATH({ Kokkos::View<int[1][1][1][1][1][1][1][1]> v("v", 2, 1, 1, 1, 1, 1, 1, 1); });
+
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1]>                      v(nullptr, 2); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1]>                   v(nullptr, 2, 1); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1][1]>                v(nullptr, 2, 1, 1); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1][1][1]>             v(nullptr, 2, 1, 1, 1); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1][1][1][1]>          v(nullptr, 2, 1, 1, 1, 1); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1][1][1][1][1]>       v(nullptr, 2, 1, 1, 1, 1, 1); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1][1][1][1][1][1]>    v(nullptr, 2, 1, 1, 1, 1, 1, 1); });
+  CHECK_DEATH_UNMANAGED({ Kokkos::View<int[1][1][1][1][1][1][1][1]> v(nullptr, 2, 1, 1, 1, 1, 1, 1, 1); });
+  // clang-format on
+#endif
 }
-#endif  // KOKKOS_ENABLE_OPENMPTARGET
-
-#undef PARAM_0
-#undef PARAM_1
-#undef PARAM_2
-#undef PARAM_3
-#undef PARAM_4
-#undef PARAM_5
-#undef PARAM_6
-#undef PARAM_7
 
-#undef PARAM_0_RANK
-#undef PARAM_1_RANK
-#undef PARAM_2_RANK
-#undef PARAM_3_RANK
-#undef PARAM_4_RANK
-#undef PARAM_5_RANK
-#undef PARAM_6_RANK
-#undef PARAM_7_RANK
-
-#undef DType
-
-#undef LIVE
-#undef DIE
+#undef CHECK_DEATH
+#endif  // KOKKOS_ENABLE_OPENMPTARGET
 }  // namespace Test
diff --git a/core/unit_test/TestViewEmptyRuntimeUnmanaged.hpp b/core/unit_test/TestViewEmptyRuntimeUnmanaged.hpp
new file mode 100644
index 0000000000..b156b72860
--- /dev/null
+++ b/core/unit_test/TestViewEmptyRuntimeUnmanaged.hpp
@@ -0,0 +1,55 @@
+//@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 <class T>
+void test_empty_view_runtime_unmanaged() {
+  T d{};
+  auto* p = reinterpret_cast<T*>(0xABADBABE);
+
+  (void)Kokkos::View<T>(p);
+  (void)Kokkos::View<T>(&d);
+  (void)Kokkos::View<T>(nullptr);
+  (void)Kokkos::View<T>(NULL);  // NOLINT(modernize-use-nullptr)
+  (void)Kokkos::View<T>(0);     // NOLINT(modernize-use-nullptr)
+
+  (void)Kokkos::View<T*>(p, 0);
+  (void)Kokkos::View<T*>(&d, 0);
+  (void)Kokkos::View<T*>(nullptr, 0);
+  (void)Kokkos::View<T*>(NULL, 0);  // NOLINT(modernize-use-nullptr)
+  (void)Kokkos::View<T*>(0, 0);     // NOLINT(modernize-use-nullptr)
+
+  (void)Kokkos::View<T**>(p, 0, 0);
+  (void)Kokkos::View<T**>(&d, 0, 0);
+  (void)Kokkos::View<T**>(nullptr, 0, 0);
+  (void)Kokkos::View<T**>(NULL, 0, 0);  // NOLINT(modernize-use-nullptr)
+  (void)Kokkos::View<T**>(0, 0, 0);     // NOLINT(modernize-use-nullptr)
+}
+
+TEST(TEST_CATEGORY, view_empty_runtime_unmanaged) {
+  test_empty_view_runtime_unmanaged<float>();
+  test_empty_view_runtime_unmanaged<const double>();
+  test_empty_view_runtime_unmanaged<int>();
+  test_empty_view_runtime_unmanaged<char>();
+  test_empty_view_runtime_unmanaged<const char>();
+}
+
+}  // namespace
diff --git a/core/unit_test/TestViewLayoutStrideAssignment.hpp b/core/unit_test/TestViewLayoutStrideAssignment.hpp
index 865f87efae..d383ab223b 100644
--- a/core/unit_test/TestViewLayoutStrideAssignment.hpp
+++ b/core/unit_test/TestViewLayoutStrideAssignment.hpp
@@ -582,7 +582,6 @@ TEST(TEST_CATEGORY, view_layoutstride_right_to_layoutright_assignment) {
   }
 }
 
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
 TEST(TEST_CATEGORY_DEATH, view_layoutstride_right_to_layoutleft_assignment) {
   using exec_space = TEST_EXECSPACE;
 
@@ -886,7 +885,6 @@ TEST(TEST_CATEGORY_DEATH, view_layoutstride_left_to_layoutright_assignment) {
                  "View assignment must have compatible layouts");
   }
 }
-#endif
 
 }  // namespace Test
 
diff --git a/core/unit_test/TestViewLayoutTiled.hpp b/core/unit_test/TestViewLayoutTiled.hpp
deleted file mode 100644
index 67308212ee..0000000000
--- a/core/unit_test/TestViewLayoutTiled.hpp
+++ /dev/null
@@ -1,1756 +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 <cstdio>
-
-#include <gtest/gtest.h>
-
-#include <Kokkos_Core.hpp>
-#include <impl/Kokkos_ViewLayoutTiled.hpp>
-
-#include <type_traits>
-#include <typeinfo>
-
-namespace Test {
-
-namespace {
-
-template <typename ExecSpace>
-struct TestViewLayoutTiled {
-  using Scalar = double;
-
-  static constexpr int T0 = 2;
-  static constexpr int T1 = 4;
-  static constexpr int T2 = 4;
-  static constexpr int T3 = 2;
-  static constexpr int T4 = 2;
-  static constexpr int T5 = 2;
-  static constexpr int T6 = 2;
-  static constexpr int T7 = 2;
-
-  // Rank 2
-  using LayoutLL_2D_2x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
-                                        Kokkos::Iterate::Left, T0, T1>;
-  using LayoutRL_2D_2x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
-                                        Kokkos::Iterate::Left, T0, T1>;
-  using LayoutLR_2D_2x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
-                                        Kokkos::Iterate::Right, T0, T1>;
-  using LayoutRR_2D_2x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
-                                        Kokkos::Iterate::Right, T0, T1>;
-
-  // Rank 3
-  using LayoutLL_3D_2x4x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
-                                        Kokkos::Iterate::Left, T0, T1, T2>;
-  using LayoutRL_3D_2x4x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
-                                        Kokkos::Iterate::Left, T0, T1, T2>;
-  using LayoutLR_3D_2x4x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
-                                        Kokkos::Iterate::Right, T0, T1, T2>;
-  using LayoutRR_3D_2x4x4 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
-                                        Kokkos::Iterate::Right, T0, T1, T2>;
-
-  // Rank 4
-  using LayoutLL_4D_2x4x4x2 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
-                                        Kokkos::Iterate::Left, T0, T1, T2, T3>;
-  using LayoutRL_4D_2x4x4x2 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
-                                        Kokkos::Iterate::Left, T0, T1, T2, T3>;
-  using LayoutLR_4D_2x4x4x2 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Left,
-                                        Kokkos::Iterate::Right, T0, T1, T2, T3>;
-  using LayoutRR_4D_2x4x4x2 =
-      Kokkos::Experimental::LayoutTiled<Kokkos::Iterate::Right,
-                                        Kokkos::Iterate::Right, T0, T1, T2, T3>;
-
-#if !defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-  static void test_view_layout_tiled_2d(const int, const int) {
-#else
-  static void test_view_layout_tiled_2d(const int N0, const int N1) {
-    const int FT = T0 * T1;
-
-    const int NT0 = int(std::ceil(N0 / T0));
-    const int NT1 = int(std::ceil(N1 / T1));
-    // Test create_mirror_view, deep_copy
-    // Create LL View
-    {
-      using ViewType =
-          typename Kokkos::View<Scalar**, LayoutLL_2D_2x4, ExecSpace>;
-      ViewType v("v", N0, N1);
-
-      typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
-
-      // Initialize host-view
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              hv(ti * T0 + i, tj * T1 + j) =
-                  (ti + tj * NT0) * FT + (i + j * T0);
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(v, hv);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Left>,
-          ExecSpace>
-          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 2 LL", mdrangepolicy,
-          KOKKOS_LAMBDA(const int ti, const int tj) {
-            for (int j = 0; j < T1; ++j) {
-              for (int i = 0; i < T0; ++i) {
-                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
-                  v(ti * T0 + i, tj * T1 + j) += 1;
-                }
-              }
-            }
-          });
-
-      Kokkos::deep_copy(hv, v);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
-                ++counter_subview;
-              }
-              if (tile_subview(i, j) !=
-                  ((ti + tj * NT0) * FT + (i + j * T0) + 1)) {
-                ++counter_inc;
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }
-
-    // Create RL View
-    {
-      using ViewType =
-          typename Kokkos::View<Scalar**, LayoutRL_2D_2x4, ExecSpace>;
-      Kokkos::View<Scalar**, LayoutRL_2D_2x4, ExecSpace> v("v", N0, N1);
-
-      typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
-
-      // Initialize host-view
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              hv(ti * T0 + i, tj * T1 + j) =
-                  (ti * NT1 + tj) * FT + (i + j * T0);
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(v, hv);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<2, Kokkos::Iterate::Right, Kokkos::Iterate::Left>,
-          ExecSpace>
-          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 2 RL", mdrangepolicy,
-          KOKKOS_LAMBDA(const int ti, const int tj) {
-            for (int j = 0; j < T1; ++j) {
-              for (int i = 0; i < T0; ++i) {
-                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
-                  v(ti * T0 + i, tj * T1 + j) += 1;
-                }
-              }
-            }
-          });
-
-      Kokkos::deep_copy(hv, v);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
-                ++counter_subview;
-              }
-              if (tile_subview(i, j) !=
-                  ((ti * NT1 + tj) * FT + (i + j * T0) + 1)) {
-                ++counter_inc;
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create LR View
-    {
-      using ViewType =
-          typename Kokkos::View<Scalar**, LayoutLR_2D_2x4, ExecSpace>;
-      Kokkos::View<Scalar**, LayoutLR_2D_2x4, ExecSpace> v("v", N0, N1);
-
-      typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
-
-      // Initialize host-view
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              hv(ti * T0 + i, tj * T1 + j) =
-                  (ti + tj * NT0) * FT + (i * T1 + j);
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(v, hv);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
-          ExecSpace>
-          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 2 LR", mdrangepolicy,
-          KOKKOS_LAMBDA(const int ti, const int tj) {
-            for (int j = 0; j < T1; ++j) {
-              for (int i = 0; i < T0; ++i) {
-                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
-                  v(ti * T0 + i, tj * T1 + j) += 1;
-                }
-              }
-            }
-          });
-
-      Kokkos::deep_copy(hv, v);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
-                ++counter_subview;
-              }
-              if (tile_subview(i, j) !=
-                  ((ti + tj * NT0) * FT + (i * T1 + j) + 1)) {
-                ++counter_inc;
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create RR View
-    {
-      using ViewType =
-          typename Kokkos::View<Scalar**, LayoutRR_2D_2x4, ExecSpace>;
-      Kokkos::View<Scalar**, LayoutRR_2D_2x4, ExecSpace> v("v", N0, N1);
-
-      typename ViewType::HostMirror hv = Kokkos::create_mirror_view(v);
-
-      // Initialize host-view
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              hv(ti * T0 + i, tj * T1 + j) =
-                  (ti * NT1 + tj) * FT + (i * T1 + j);
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(v, hv);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<2, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
-          ExecSpace>
-          mdrangepolicy({0, 0}, {NT0, NT1}, {T0, T1});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 2 LR", mdrangepolicy,
-          KOKKOS_LAMBDA(const int ti, const int tj) {
-            for (int j = 0; j < T1; ++j) {
-              for (int i = 0; i < T0; ++i) {
-                if ((ti * T0 + i < N0) && (tj * T1 + j < N1)) {
-                  v(ti * T0 + i, tj * T1 + j) += 1;
-                }
-              }
-            }
-          });
-
-      Kokkos::deep_copy(hv, v);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          auto tile_subview = Kokkos::tile_subview(hv, ti, tj);
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              if (tile_subview(i, j) != hv(ti * T0 + i, tj * T1 + j)) {
-                ++counter_subview;
-              }
-              if (tile_subview(i, j) !=
-                  ((ti * NT1 + tj) * FT + (i * T1 + j) + 1)) {
-                ++counter_inc;
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-#endif
-  }  // end test_view_layout_tiled_2d
-
-#if !defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-  static void test_view_layout_tiled_3d(const int, const int, const int) {
-#else
-  static void test_view_layout_tiled_3d(const int N0, const int N1,
-                                        const int N2) {
-    const int FT = T0 * T1 * T2;
-
-    const int NT0 = int(std::ceil(N0 / T0));
-    const int NT1 = int(std::ceil(N1 / T1));
-    const int NT2 = int(std::ceil(N2 / T2));
-
-    // Create LL View
-    {
-      using ViewType = Kokkos::View<Scalar***, LayoutLL_3D_2x4x4, ExecSpace>;
-      Kokkos::View<Scalar***, LayoutLL_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
-                                                               N2);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti + tj * NT0 + tk * N0 * N1) * FT +
-                      (i + j * T0 + k * T0 * T1);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Left>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 3 LL", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k) {
-            dv(i, j, k) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter_subview;
-                  }
-                  if (tile_subview(i, j, k) !=
-                      ((ti + tj * NT0 + tk * N0 * N1) * FT +
-                       (i + j * T0 + k * T0 * T1) + 1)) {
-                    ++counter_inc;
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create RL View
-    {
-      using ViewType = Kokkos::View<Scalar***, LayoutRL_3D_2x4x4, ExecSpace>;
-      Kokkos::View<Scalar***, LayoutRL_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
-                                                               N2);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                      (i + j * T0 + k * T0 * T1);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<3, Kokkos::Iterate::Right, Kokkos::Iterate::Left>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 3 RL", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k) {
-            dv(i, j, k) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter_subview;
-                  }
-                  if (tile_subview(i, j, k) !=
-                      ((ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                       (i + j * T0 + k * T0 * T1) + 1)) {
-                    ++counter_inc;
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create LR View
-    {
-      using ViewType = Kokkos::View<Scalar***, LayoutLR_3D_2x4x4, ExecSpace>;
-      Kokkos::View<Scalar***, LayoutLR_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
-                                                               N2);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti + tj * NT0 + tk * NT0 * NT1) * FT +
-                      (i * T1 * T2 + j * T2 + k);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<3, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 3 LR", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k) {
-            dv(i, j, k) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter_subview;
-                  }
-                  if (tile_subview(i, j, k) !=
-                      ((ti + tj * NT0 + tk * NT0 * NT1) * FT +
-                       (i * T1 * T2 + j * T2 + k) + 1)) {
-                    ++counter_inc;
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create RR View
-    {
-      using ViewType = Kokkos::View<Scalar***, LayoutRR_3D_2x4x4, ExecSpace>;
-      Kokkos::View<Scalar***, LayoutRR_3D_2x4x4, ExecSpace> dv("dv", N0, N1,
-                                                               N2);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                      (i * T1 * T2 + j * T2 + k);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<3, Kokkos::Iterate::Right, Kokkos::Iterate::Right>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0}, {N0, N1, N2}, {T0, T1, T2});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 3 RR", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k) {
-            dv(i, j, k) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter_subview;
-                  }
-                  if (tile_subview(i, j, k) !=
-                      ((ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                       (i * T1 * T2 + j * T2 + k) + 1)) {
-                    ++counter_inc;
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-#endif
-  }  // end test_view_layout_tiled_3d
-
-#if !defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
-  static void test_view_layout_tiled_4d(const int, const int, const int,
-                                        const int){
-#else
-  static void test_view_layout_tiled_4d(const int N0, const int N1,
-                                        const int N2, const int N3) {
-    const int FT = T0 * T1 * T2 * T3;
-
-    const int NT0 = int(std::ceil(N0 / T0));
-    const int NT1 = int(std::ceil(N1 / T1));
-    const int NT2 = int(std::ceil(N2 / T2));
-    const int NT3 = int(std::ceil(N3 / T3));
-
-    // Create LL View
-    {
-      using ViewType = Kokkos::View<Scalar****, LayoutLL_4D_2x4x4x2, ExecSpace>;
-      Kokkos::View<Scalar****, LayoutLL_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
-                                                                  N2, N3);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti + tj * NT0 + tk * N0 * N1 + tl * N0 * N1 * N2) *
-                              FT +
-                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<4, Kokkos::Iterate::Left, Kokkos::Iterate::Left>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 4 LL", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
-            dv(i, j, k, l) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter_subview;
-                      }
-                      if (tile_subview(i, j, k, l) !=
-                          ((ti + tj * NT0 + tk * N0 * N1 + tl * N0 * N1 * N2) *
-                               FT +
-                           (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2) + 1)) {
-                        ++counter_inc;
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create RL View
-    {
-      using ViewType = Kokkos::View<Scalar****, LayoutRL_4D_2x4x4x2, ExecSpace>;
-      Kokkos::View<Scalar****, LayoutRL_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
-                                                                  N2, N3);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 + tl) *
-                              FT +
-                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<4, Kokkos::Iterate::Right, Kokkos::Iterate::Left>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 4 RL", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
-            dv(i, j, k, l) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter_subview;
-                      }
-                      if (tile_subview(i, j, k, l) !=
-                          ((ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 +
-                            tl) *
-                               FT +
-                           (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2) + 1)) {
-                        ++counter_inc;
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create LR View
-    {
-      using ViewType = Kokkos::View<Scalar****, LayoutLR_4D_2x4x4x2, ExecSpace>;
-      Kokkos::View<Scalar****, LayoutLR_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
-                                                                  N2, N3);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti + tj * NT0 + tk * NT0 * NT1 +
-                           tl * NT0 * NT1 * NT2) *
-                              FT +
-                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<4, Kokkos::Iterate::Left, Kokkos::Iterate::Right>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 4 LR", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
-            dv(i, j, k, l) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter_subview;
-                      }
-                      if (tile_subview(i, j, k, l) !=
-                          ((ti + tj * NT0 + tk * NT0 * NT1 +
-                            tl * NT0 * NT1 * NT2) *
-                               FT +
-                           (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l) + 1)) {
-                        ++counter_inc;
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-
-    // Create RR View
-    {
-      using ViewType = Kokkos::View<Scalar****, LayoutRR_4D_2x4x4x2, ExecSpace>;
-      Kokkos::View<Scalar****, LayoutRR_4D_2x4x4x2, ExecSpace> dv("dv", N0, N1,
-                                                                  N2, N3);
-
-      typename ViewType::HostMirror v = Kokkos::create_mirror_view(dv);
-
-      // Initialize on host
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
-                           tl) *
-                              FT +
-                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      // copy to device
-      Kokkos::deep_copy(dv, v);
-
-      Kokkos::MDRangePolicy<
-          Kokkos::Rank<4, Kokkos::Iterate::Right, Kokkos::Iterate::Right>,
-          ExecSpace>
-          mdrangepolicy({0, 0, 0, 0}, {N0, N1, N2, N3}, {T0, T1, T2, T3});
-
-      // iterate by tile
-      Kokkos::parallel_for(
-          "ViewTile rank 4 RR", mdrangepolicy,
-          KOKKOS_LAMBDA(const int i, const int j, const int k, const int l) {
-            dv(i, j, k, l) += 1;
-          });
-
-      Kokkos::deep_copy(v, dv);
-
-      long counter_subview = 0;
-      long counter_inc     = 0;
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter_subview;
-                      }
-                      if (tile_subview(i, j, k, l) !=
-                          ((ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
-                            tl) *
-                               FT +
-                           (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l) + 1)) {
-                        ++counter_inc;
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-      ASSERT_EQ(counter_subview, long(0));
-      ASSERT_EQ(counter_inc, long(0));
-    }  // end scope
-#endif
-  }  // end test_view_layout_tiled_4d
-
-  static void test_view_layout_tiled_subtile_2d(const int N0, const int N1) {
-    const int FT = T0 * T1;
-
-    const int NT0 = int(std::ceil(N0 / T0));
-    const int NT1 = int(std::ceil(N1 / T1));
-
-    // Counter to check for errors at the end
-    long counter[4] = {0};
-
-    // Create LL View
-    {
-      Kokkos::View<Scalar**, LayoutLL_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              v(ti * T0 + i, tj * T1 + j) = (ti + tj * NT0) * FT + (i + j * T0);
-            }
-          }
-        }
-      }
-
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
-                ++counter[0];
-              }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
-                        << std::endl;
-              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
-                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
-                        << "  flat idx = "
-                        << (ti + tj * NT0) * FT + (i + j * T0) << std::endl;
-              std::cout << "subview_tile output = " << tile_subview(i, j)
-                        << std::endl;
-#endif
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create RL View
-    {
-      Kokkos::View<Scalar**, LayoutRL_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              v(ti * T0 + i, tj * T1 + j) = (ti * NT1 + tj) * FT + (i + j * T0);
-            }
-          }
-        }
-      }
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
-          for (int j = 0; j < T1; ++j) {
-            for (int i = 0; i < T0; ++i) {
-              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
-                ++counter[1];
-              }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
-                        << std::endl;
-              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
-                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
-                        << "  flat idx = "
-                        << (ti * NT1 + tj) * FT + (i + j * T0) << std::endl;
-              std::cout << "subview_tile output = " << tile_subview(i, j)
-                        << std::endl;
-#endif
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create LR View
-    {
-      Kokkos::View<Scalar**, LayoutLR_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              v(ti * T0 + i, tj * T1 + j) = (ti + tj * NT0) * FT + (i * T1 + j);
-            }
-          }
-        }
-      }
-
-      for (int tj = 0; tj < NT1; ++tj) {
-        for (int ti = 0; ti < NT0; ++ti) {
-          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
-                ++counter[2];
-              }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
-                        << std::endl;
-              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
-                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
-                        << "  flat idx = "
-                        << (ti + tj * NT0) * FT + (i * T1 + j) << std::endl;
-              std::cout << "subview_tile output = " << tile_subview(i, j)
-                        << std::endl;
-#endif
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create RR View
-    {
-      Kokkos::View<Scalar**, LayoutRR_2D_2x4, Kokkos::HostSpace> v("v", N0, N1);
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              v(ti * T0 + i, tj * T1 + j) = (ti * NT1 + tj) * FT + (i * T1 + j);
-            }
-          }
-        }
-      }
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          auto tile_subview = Kokkos::tile_subview(v, ti, tj);
-          for (int i = 0; i < T0; ++i) {
-            for (int j = 0; j < T1; ++j) {
-              if (tile_subview(i, j) != v(ti * T0 + i, tj * T1 + j)) {
-                ++counter[3];
-              }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-              std::cout << "idx0,idx1 = " << ti * T0 + i << "," << tj * T1 + j
-                        << std::endl;
-              std::cout << "ti,tj,i,j: " << ti << "," << tj << "," << i << ","
-                        << j << "  v = " << v(ti * T0 + i, tj * T1 + j)
-                        << "  flat idx = "
-                        << (ti * NT1 + tj) * FT + (i * T1 + j) << std::endl;
-              std::cout << "subview_tile output = " << tile_subview(i, j)
-                        << std::endl;
-              std::cout << "subview tile rank = " << Kokkos::rank(tile_subview)
-                        << std::endl;
-#endif
-            }
-          }
-        }
-      }
-    }  // end scope
-
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-    std::cout << "subview_tile vs view errors:\n"
-              << " LL: " << counter[0] << " RL: " << counter[1]
-              << " LR: " << counter[2] << " RR: " << counter[3] << std::endl;
-#endif
-
-    ASSERT_EQ(counter[0], long(0));
-    ASSERT_EQ(counter[1], long(0));
-    ASSERT_EQ(counter[2], long(0));
-    ASSERT_EQ(counter[3], long(0));
-  }  // end test_view_layout_tiled_subtile_2d
-
-  static void test_view_layout_tiled_subtile_3d(const int N0, const int N1,
-                                                const int N2) {
-    const int FT = T0 * T1 * T2;
-
-    const int NT0 = int(std::ceil(N0 / T0));
-    const int NT1 = int(std::ceil(N1 / T1));
-    const int NT2 = int(std::ceil(N2 / T2));
-
-    // Counter to check for errors at the end
-    long counter[4] = {0};
-    // Create LL View
-    {
-      Kokkos::View<Scalar***, LayoutLL_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
-                                                                      N1, N2);
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti + tj * NT0 + tk * N0 * N1) * FT +
-                      (i + j * T0 + k * T0 * T1);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter[0];
-                  }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
-                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
-                  std::cout
-                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
-                      << "," << i << "," << j << "," << k
-                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
-                      << "  flat idx = "
-                      << (ti + tj * NT0 + tk * N0 * N1) * FT +
-                             (i + j * T0 + k * T0 * T1)
-                      << std::endl;
-                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
-                            << std::endl;
-                  std::cout
-                      << "subview tile rank = " << Kokkos::rank(tile_subview)
-                      << std::endl;
-#endif
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create RL View
-    {
-      Kokkos::View<Scalar***, LayoutRL_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
-                                                                      N1, N2);
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                      (i + j * T0 + k * T0 * T1);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int k = 0; k < T2; ++k) {
-              for (int j = 0; j < T1; ++j) {
-                for (int i = 0; i < T0; ++i) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter[1];
-                  }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
-                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
-                  std::cout
-                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
-                      << "," << i << "," << j << "," << k
-                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
-                      << "  flat idx = "
-                      << (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                             (i + j * T0 + k * T0 * T1)
-                      << std::endl;
-                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
-                            << std::endl;
-#endif
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create LR View
-    {
-      Kokkos::View<Scalar***, LayoutLR_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
-                                                                      N1, N2);
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti + tj * NT0 + tk * NT0 * NT1) * FT +
-                      (i * T1 * T2 + j * T2 + k);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int tk = 0; tk < NT2; ++tk) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int ti = 0; ti < NT0; ++ti) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter[2];
-                  }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
-                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
-                  std::cout
-                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
-                      << "," << i << "," << j << "," << k
-                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
-                      << "  flat idx = "
-                      << (ti + tj * NT0 + tk * NT0 * NT1) * FT +
-                             (i * T1 * T2 + j * T2 + k)
-                      << std::endl;
-                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
-                            << std::endl;
-                  std::cout
-                      << "subview tile rank = " << Kokkos::rank(tile_subview)
-                      << std::endl;
-#endif
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create RR View
-    {
-      Kokkos::View<Scalar***, LayoutRR_3D_2x4x4, Kokkos::HostSpace> v("v", N0,
-                                                                      N1, N2);
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  v(ti * T0 + i, tj * T1 + j, tk * T2 + k) =
-                      (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                      (i * T1 * T2 + j * T2 + k);
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk);
-            for (int i = 0; i < T0; ++i) {
-              for (int j = 0; j < T1; ++j) {
-                for (int k = 0; k < T2; ++k) {
-                  if (tile_subview(i, j, k) !=
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k)) {
-                    ++counter[3];
-                  }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                  std::cout << "idx0,idx1,idx2 = " << ti * T0 + i << ","
-                            << tj * T1 + j << "," << tk * T2 + k << std::endl;
-                  std::cout
-                      << "ti,tj,tk,i,j,k: " << ti << "," << tj << "," << tk
-                      << "," << i << "," << j << "," << k
-                      << "  v = " << v(ti * T0 + i, tj * T1 + j, tk * T2 + k)
-                      << "  flat idx = "
-                      << (ti * NT1 * NT2 + tj * NT2 + tk) * FT +
-                             (i * T1 * T2 + j * T2 + k)
-                      << std::endl;
-                  std::cout << "subview_tile output = " << tile_subview(i, j, k)
-                            << std::endl;
-                  std::cout
-                      << "subview tile rank = " << Kokkos::rank(tile_subview)
-                      << std::endl;
-#endif
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-    std::cout << "subview_tile vs view errors:\n"
-              << " LL: " << counter[0] << " RL: " << counter[1]
-              << " LR: " << counter[2] << " RR: " << counter[3] << std::endl;
-#endif
-
-    ASSERT_EQ(counter[0], long(0));
-    ASSERT_EQ(counter[1], long(0));
-    ASSERT_EQ(counter[2], long(0));
-    ASSERT_EQ(counter[3], long(0));
-
-  }  // end test_view_layout_tiled_subtile_3d
-
-  static void test_view_layout_tiled_subtile_4d(const int N0, const int N1,
-                                                const int N2, const int N3) {
-    const int FT = T0 * T1 * T2 * T3;
-
-    const int NT0 = int(std::ceil(N0 / T0));
-    const int NT1 = int(std::ceil(N1 / T1));
-    const int NT2 = int(std::ceil(N2 / T2));
-    const int NT3 = int(std::ceil(N3 / T3));
-
-    // Counter to check for errors at the end
-    long counter[4] = {0};
-    // Create LL View
-    {
-      Kokkos::View<Scalar****, LayoutLL_4D_2x4x4x2, Kokkos::HostSpace> v(
-          "v", N0, N1, N2, N3);
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti + tj * NT0 + tk * N0 * N1 + tl * N0 * N1 * N2) *
-                              FT +
-                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter[0];
-                      }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
-                                << "," << tj * T1 + j << "," << tk * T2 + k
-                                << "," << tl * T3 + l << std::endl;
-                      std::cout
-                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
-                          << "," << tl << ","
-                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
-                          << l << "  v = "
-                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                               tl * T3 + l)
-                          << "  flat idx = "
-                          << (ti + tj * NT0 + tk * N0 * N1 +
-                              tl * N0 * N1 * N2) *
-                                     FT +
-                                 (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2)
-                          << std::endl;
-                      std::cout << "subview_tile output = "
-                                << tile_subview(i, j, k, l) << std::endl;
-                      std::cout << "subview tile rank = "
-                                << Kokkos::rank(tile_subview) << std::endl;
-#endif
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create RL View
-    {
-      Kokkos::View<Scalar****, LayoutRL_4D_2x4x4x2, Kokkos::HostSpace> v(
-          "v", N0, N1, N2, N3);
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 + tl) *
-                              FT +
-                          (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int l = 0; l < T3; ++l) {
-                for (int k = 0; k < T2; ++k) {
-                  for (int j = 0; j < T1; ++j) {
-                    for (int i = 0; i < T0; ++i) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter[1];
-                      }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
-                                << "," << tj * T1 + j << "," << tk * T2 + k
-                                << "," << tl * T3 + l << std::endl;
-                      std::cout
-                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
-                          << "," << tl << ","
-                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
-                          << l << "  v = "
-                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                               tl * T3 + l)
-                          << "  flat idx = "
-                          << (ti * NT1 * NT2 * N3 + tj * NT2 * N3 + tk * N3 +
-                              tl) * FT +
-                                 (i + j * T0 + k * T0 * T1 + l * T0 * T1 * T2)
-                          << std::endl;
-                      std::cout << "subview_tile output = "
-                                << tile_subview(i, j, k, l) << std::endl;
-                      std::cout << "subview tile rank = "
-                                << Kokkos::rank(tile_subview) << std::endl;
-#endif
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create LR View
-    {
-      Kokkos::View<Scalar****, LayoutLR_4D_2x4x4x2, Kokkos::HostSpace> v(
-          "v", N0, N1, N2, N3);
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti + tj * NT0 + tk * NT0 * NT1 +
-                           tl * NT0 * NT1 * NT2) *
-                              FT +
-                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int tl = 0; tl < NT3; ++tl) {
-        for (int tk = 0; tk < NT2; ++tk) {
-          for (int tj = 0; tj < NT1; ++tj) {
-            for (int ti = 0; ti < NT0; ++ti) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter[2];
-                      }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
-                                << "," << tj * T1 + j << "," << tk * T2 + k
-                                << "," << tl * T3 + l << std::endl;
-                      std::cout
-                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
-                          << "," << tl << ","
-                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
-                          << l << "  v = "
-                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                               tl * T3 + l)
-                          << "  flat idx = "
-                          << (ti + tj * NT0 + tk * NT0 * NT1 +
-                              tl * NT0 * NT1 * NT2) *
-                                     FT +
-                                 (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l)
-                          << std::endl;
-                      std::cout << "subview_tile output = "
-                                << tile_subview(i, j, k, l) << std::endl;
-                      std::cout << "subview tile rank = "
-                                << Kokkos::rank(tile_subview) << std::endl;
-#endif
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-    // Create RR View
-    {
-      Kokkos::View<Scalar****, LayoutRR_4D_2x4x4x2, Kokkos::HostSpace> v(
-          "v", N0, N1, N2, N3);
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      v(ti * T0 + i, tj * T1 + j, tk * T2 + k, tl * T3 + l) =
-                          (ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
-                           tl) *
-                              FT +
-                          (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l);
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-
-      for (int ti = 0; ti < NT0; ++ti) {
-        for (int tj = 0; tj < NT1; ++tj) {
-          for (int tk = 0; tk < NT2; ++tk) {
-            for (int tl = 0; tl < NT3; ++tl) {
-              auto tile_subview = Kokkos::tile_subview(v, ti, tj, tk, tl);
-              for (int i = 0; i < T0; ++i) {
-                for (int j = 0; j < T1; ++j) {
-                  for (int k = 0; k < T2; ++k) {
-                    for (int l = 0; l < T3; ++l) {
-                      if (tile_subview(i, j, k, l) !=
-                          v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                            tl * T3 + l)) {
-                        ++counter[3];
-                      }
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-                      std::cout << "idx0,idx1,idx2,idx3 = " << ti * T0 + i
-                                << "," << tj * T1 + j << "," << tk * T2 + k
-                                << "," << tl * T3 + l << std::endl;
-                      std::cout
-                          << "ti,tj,tk,tl: " << ti << "," << tj << "," << tk
-                          << "," << tl << ","
-                          << "  i,j,k,l: " << i << "," << j << "," << k << ","
-                          << l << "  v = "
-                          << v(ti * T0 + i, tj * T1 + j, tk * T2 + k,
-                               tl * T3 + l)
-                          << "  flat idx = "
-                          << (ti * NT1 * NT2 * NT3 + tj * NT2 * NT3 + tk * NT3 +
-                              tl) * FT +
-                                 (i * T1 * T2 * T3 + j * T2 * T3 + k * T3 + l)
-                          << std::endl;
-                      std::cout << "subview_tile output = "
-                                << tile_subview(i, j, k, l) << std::endl;
-                      std::cout << "subview tile rank = "
-                                << Kokkos::rank(tile_subview) << std::endl;
-#endif
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }  // end scope
-
-#ifdef KOKKOS_VERBOSE_LAYOUTTILED_OUTPUT
-    std::cout << "subview_tile vs view errors:\n"
-              << " LL: " << counter[0] << " RL: " << counter[1]
-              << " LR: " << counter[2] << " RR: " << counter[3] << std::endl;
-#endif
-
-    ASSERT_EQ(counter[0], long(0));
-    ASSERT_EQ(counter[1], long(0));
-    ASSERT_EQ(counter[2], long(0));
-    ASSERT_EQ(counter[3], long(0));
-
-  }  // end test_view_layout_tiled_subtile_4d
-
-};  // end TestViewLayoutTiled struct
-
-}  // namespace
-
-TEST(TEST_CATEGORY, view_layouttiled) {
-  // These two examples are iterating by tile, then within a tile - not by
-  // extents If N# is not a power of two, but want to iterate by tile then
-  // within a tile, need to check that mapped index is within extent
-  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_2d(4, 12);
-  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_3d(4, 12, 16);
-  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_4d(4, 12, 16, 12);
-}
-TEST(TEST_CATEGORY, view_layouttiled_subtile) {
-  // These two examples are iterating by tile, then within a tile - not by
-  // extents If N# is not a power of two, but want to iterate by tile then
-  // within a tile, need to check that mapped index is within extent
-  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_subtile_2d(4, 12);
-  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_subtile_3d(4, 12,
-                                                                         16);
-  TestViewLayoutTiled<TEST_EXECSPACE>::test_view_layout_tiled_subtile_4d(
-      4, 12, 16, 12);
-}
-}  // namespace Test
-
-#undef KOKKOS_IMPL_PUBLIC_INCLUDE
diff --git a/core/unit_test/TestViewMapping_a.hpp b/core/unit_test/TestViewMapping_a.hpp
index 9173f0d431..a4dfdb26e3 100644
--- a/core/unit_test/TestViewMapping_a.hpp
+++ b/core/unit_test/TestViewMapping_a.hpp
@@ -73,67 +73,67 @@ void test_view_mapping() {
   ASSERT_LE(sizeof(dim_s0_s0_s0_s0_s0_s0_s0), 8 * sizeof(unsigned));
   ASSERT_EQ(sizeof(dim_s0_s0_s0_s0_s0_s0_s0_s0), 8 * sizeof(unsigned));
 #endif
-  static_assert(int(dim_0::rank) == int(0), "");
-  static_assert(int(dim_0::rank_dynamic) == int(0), "");
-  static_assert(int(dim_0::ArgN0) == 1, "");
-  static_assert(int(dim_0::ArgN1) == 1, "");
-  static_assert(int(dim_0::ArgN2) == 1, "");
-
-  static_assert(int(dim_s2::rank) == int(1), "");
-  static_assert(int(dim_s2::rank_dynamic) == int(0), "");
-  static_assert(int(dim_s2::ArgN0) == 2, "");
-  static_assert(int(dim_s2::ArgN1) == 1, "");
-
-  static_assert(int(dim_s2_s3::rank) == int(2), "");
-  static_assert(int(dim_s2_s3::rank_dynamic) == int(0), "");
-  static_assert(int(dim_s2_s3::ArgN0) == 2, "");
-  static_assert(int(dim_s2_s3::ArgN1) == 3, "");
-  static_assert(int(dim_s2_s3::ArgN2) == 1, "");
-
-  static_assert(int(dim_s2_s3_s4::rank) == int(3), "");
-  static_assert(int(dim_s2_s3_s4::rank_dynamic) == int(0), "");
-  static_assert(int(dim_s2_s3_s4::ArgN0) == 2, "");
-  static_assert(int(dim_s2_s3_s4::ArgN1) == 3, "");
-  static_assert(int(dim_s2_s3_s4::ArgN2) == 4, "");
-  static_assert(int(dim_s2_s3_s4::ArgN3) == 1, "");
-
-  static_assert(int(dim_s0::rank) == int(1), "");
-  static_assert(int(dim_s0::rank_dynamic) == int(1), "");
-
-  static_assert(int(dim_s0_s3::rank) == int(2), "");
-  static_assert(int(dim_s0_s3::rank_dynamic) == int(1), "");
-  static_assert(int(dim_s0_s3::ArgN0) == 0, "");
-  static_assert(int(dim_s0_s3::ArgN1) == 3, "");
-
-  static_assert(int(dim_s0_s3_s4::rank) == int(3), "");
-  static_assert(int(dim_s0_s3_s4::rank_dynamic) == int(1), "");
-  static_assert(int(dim_s0_s3_s4::ArgN0) == 0, "");
-  static_assert(int(dim_s0_s3_s4::ArgN1) == 3, "");
-  static_assert(int(dim_s0_s3_s4::ArgN2) == 4, "");
-
-  static_assert(int(dim_s0_s0_s4::rank) == int(3), "");
-  static_assert(int(dim_s0_s0_s4::rank_dynamic) == int(2), "");
-  static_assert(int(dim_s0_s0_s4::ArgN0) == 0, "");
-  static_assert(int(dim_s0_s0_s4::ArgN1) == 0, "");
-  static_assert(int(dim_s0_s0_s4::ArgN2) == 4, "");
-
-  static_assert(int(dim_s0_s0_s0::rank) == int(3), "");
-  static_assert(int(dim_s0_s0_s0::rank_dynamic) == int(3), "");
-
-  static_assert(int(dim_s0_s0_s0_s0::rank) == int(4), "");
-  static_assert(int(dim_s0_s0_s0_s0::rank_dynamic) == int(4), "");
-
-  static_assert(int(dim_s0_s0_s0_s0_s0::rank) == int(5), "");
-  static_assert(int(dim_s0_s0_s0_s0_s0::rank_dynamic) == int(5), "");
-
-  static_assert(int(dim_s0_s0_s0_s0_s0_s0::rank) == int(6), "");
-  static_assert(int(dim_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(6), "");
-
-  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0::rank) == int(7), "");
-  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(7), "");
-
-  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0_s0::rank) == int(8), "");
-  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(8), "");
+  static_assert(int(dim_0::rank) == int(0));
+  static_assert(int(dim_0::rank_dynamic) == int(0));
+  static_assert(int(dim_0::ArgN0) == 1);
+  static_assert(int(dim_0::ArgN1) == 1);
+  static_assert(int(dim_0::ArgN2) == 1);
+
+  static_assert(int(dim_s2::rank) == int(1));
+  static_assert(int(dim_s2::rank_dynamic) == int(0));
+  static_assert(int(dim_s2::ArgN0) == 2);
+  static_assert(int(dim_s2::ArgN1) == 1);
+
+  static_assert(int(dim_s2_s3::rank) == int(2));
+  static_assert(int(dim_s2_s3::rank_dynamic) == int(0));
+  static_assert(int(dim_s2_s3::ArgN0) == 2);
+  static_assert(int(dim_s2_s3::ArgN1) == 3);
+  static_assert(int(dim_s2_s3::ArgN2) == 1);
+
+  static_assert(int(dim_s2_s3_s4::rank) == int(3));
+  static_assert(int(dim_s2_s3_s4::rank_dynamic) == int(0));
+  static_assert(int(dim_s2_s3_s4::ArgN0) == 2);
+  static_assert(int(dim_s2_s3_s4::ArgN1) == 3);
+  static_assert(int(dim_s2_s3_s4::ArgN2) == 4);
+  static_assert(int(dim_s2_s3_s4::ArgN3) == 1);
+
+  static_assert(int(dim_s0::rank) == int(1));
+  static_assert(int(dim_s0::rank_dynamic) == int(1));
+
+  static_assert(int(dim_s0_s3::rank) == int(2));
+  static_assert(int(dim_s0_s3::rank_dynamic) == int(1));
+  static_assert(int(dim_s0_s3::ArgN0) == 0);
+  static_assert(int(dim_s0_s3::ArgN1) == 3);
+
+  static_assert(int(dim_s0_s3_s4::rank) == int(3));
+  static_assert(int(dim_s0_s3_s4::rank_dynamic) == int(1));
+  static_assert(int(dim_s0_s3_s4::ArgN0) == 0);
+  static_assert(int(dim_s0_s3_s4::ArgN1) == 3);
+  static_assert(int(dim_s0_s3_s4::ArgN2) == 4);
+
+  static_assert(int(dim_s0_s0_s4::rank) == int(3));
+  static_assert(int(dim_s0_s0_s4::rank_dynamic) == int(2));
+  static_assert(int(dim_s0_s0_s4::ArgN0) == 0);
+  static_assert(int(dim_s0_s0_s4::ArgN1) == 0);
+  static_assert(int(dim_s0_s0_s4::ArgN2) == 4);
+
+  static_assert(int(dim_s0_s0_s0::rank) == int(3));
+  static_assert(int(dim_s0_s0_s0::rank_dynamic) == int(3));
+
+  static_assert(int(dim_s0_s0_s0_s0::rank) == int(4));
+  static_assert(int(dim_s0_s0_s0_s0::rank_dynamic) == int(4));
+
+  static_assert(int(dim_s0_s0_s0_s0_s0::rank) == int(5));
+  static_assert(int(dim_s0_s0_s0_s0_s0::rank_dynamic) == int(5));
+
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0::rank) == int(6));
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(6));
+
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0::rank) == int(7));
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(7));
+
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0_s0::rank) == int(8));
+  static_assert(int(dim_s0_s0_s0_s0_s0_s0_s0_s0::rank_dynamic) == int(8));
 
   dim_s0 d1(2, 3, 4, 5, 6, 7, 8, 9);
   dim_s0_s0 d2(2, 3, 4, 5, 6, 7, 8, 9);
@@ -514,11 +514,11 @@ void test_view_mapping() {
   {
     using namespace Kokkos::Impl;
 
-    static_assert(rank_dynamic<>::value == 0, "");
-    static_assert(rank_dynamic<1>::value == 0, "");
-    static_assert(rank_dynamic<0>::value == 1, "");
-    static_assert(rank_dynamic<0, 1>::value == 1, "");
-    static_assert(rank_dynamic<0, 0, 1>::value == 2, "");
+    static_assert(rank_dynamic<>::value == 0);
+    static_assert(rank_dynamic<1>::value == 0);
+    static_assert(rank_dynamic<0>::value == 1);
+    static_assert(rank_dynamic<0, 1>::value == 1);
+    static_assert(rank_dynamic<0, 0, 1>::value == 2);
   }
 
   {
@@ -529,54 +529,48 @@ void test_view_mapping() {
     using a_const_int_r1 = ViewArrayAnalysis<const int[]>;
     using a_const_int_r5 = ViewArrayAnalysis<const int* * [4][5][6]>;
 
-    static_assert(a_int_r1::dimension::rank == 1, "");
-    static_assert(a_int_r1::dimension::rank_dynamic == 1, "");
-    static_assert(a_int_r5::dimension::ArgN0 == 0, "");
-    static_assert(a_int_r5::dimension::ArgN1 == 0, "");
-    static_assert(a_int_r5::dimension::ArgN2 == 4, "");
-    static_assert(a_int_r5::dimension::ArgN3 == 5, "");
-    static_assert(a_int_r5::dimension::ArgN4 == 6, "");
-    static_assert(a_int_r5::dimension::ArgN5 == 1, "");
+    static_assert(a_int_r1::dimension::rank == 1);
+    static_assert(a_int_r1::dimension::rank_dynamic == 1);
+    static_assert(a_int_r5::dimension::ArgN0 == 0);
+    static_assert(a_int_r5::dimension::ArgN1 == 0);
+    static_assert(a_int_r5::dimension::ArgN2 == 4);
+    static_assert(a_int_r5::dimension::ArgN3 == 5);
+    static_assert(a_int_r5::dimension::ArgN4 == 6);
+    static_assert(a_int_r5::dimension::ArgN5 == 1);
 
     static_assert(
-        std::is_same<typename a_int_r1::dimension, ViewDimension<0> >::value,
-        "");
+        std::is_same<typename a_int_r1::dimension, ViewDimension<0> >::value);
     static_assert(
-        std::is_same<typename a_int_r1::non_const_value_type, int>::value, "");
+        std::is_same<typename a_int_r1::non_const_value_type, int>::value);
 
-    static_assert(a_const_int_r1::dimension::rank == 1, "");
-    static_assert(a_const_int_r1::dimension::rank_dynamic == 1, "");
+    static_assert(a_const_int_r1::dimension::rank == 1);
+    static_assert(a_const_int_r1::dimension::rank_dynamic == 1);
     static_assert(std::is_same<typename a_const_int_r1::dimension,
-                               ViewDimension<0> >::value,
-                  "");
-    static_assert(
-        std::is_same<typename a_const_int_r1::non_const_value_type, int>::value,
-        "");
+                               ViewDimension<0> >::value);
+    static_assert(std::is_same<typename a_const_int_r1::non_const_value_type,
+                               int>::value);
 
-    static_assert(a_const_int_r5::dimension::rank == 5, "");
-    static_assert(a_const_int_r5::dimension::rank_dynamic == 2, "");
+    static_assert(a_const_int_r5::dimension::rank == 5);
+    static_assert(a_const_int_r5::dimension::rank_dynamic == 2);
 
-    static_assert(a_const_int_r5::dimension::ArgN0 == 0, "");
-    static_assert(a_const_int_r5::dimension::ArgN1 == 0, "");
-    static_assert(a_const_int_r5::dimension::ArgN2 == 4, "");
-    static_assert(a_const_int_r5::dimension::ArgN3 == 5, "");
-    static_assert(a_const_int_r5::dimension::ArgN4 == 6, "");
-    static_assert(a_const_int_r5::dimension::ArgN5 == 1, "");
+    static_assert(a_const_int_r5::dimension::ArgN0 == 0);
+    static_assert(a_const_int_r5::dimension::ArgN1 == 0);
+    static_assert(a_const_int_r5::dimension::ArgN2 == 4);
+    static_assert(a_const_int_r5::dimension::ArgN3 == 5);
+    static_assert(a_const_int_r5::dimension::ArgN4 == 6);
+    static_assert(a_const_int_r5::dimension::ArgN5 == 1);
 
     static_assert(std::is_same<typename a_const_int_r5::dimension,
-                               ViewDimension<0, 0, 4, 5, 6> >::value,
-                  "");
-    static_assert(
-        std::is_same<typename a_const_int_r5::non_const_value_type, int>::value,
-        "");
+                               ViewDimension<0, 0, 4, 5, 6> >::value);
+    static_assert(std::is_same<typename a_const_int_r5::non_const_value_type,
+                               int>::value);
 
-    static_assert(a_int_r5::dimension::rank == 5, "");
-    static_assert(a_int_r5::dimension::rank_dynamic == 2, "");
+    static_assert(a_int_r5::dimension::rank == 5);
+    static_assert(a_int_r5::dimension::rank_dynamic == 2);
     static_assert(std::is_same<typename a_int_r5::dimension,
-                               ViewDimension<0, 0, 4, 5, 6> >::value,
-                  "");
+                               ViewDimension<0, 0, 4, 5, 6> >::value);
     static_assert(
-        std::is_same<typename a_int_r5::non_const_value_type, int>::value, "");
+        std::is_same<typename a_int_r5::non_const_value_type, int>::value);
   }
 
   {
@@ -587,15 +581,15 @@ void test_view_mapping() {
     // Dimensions of t_i4 are appended to the multdimensional array.
     using a_int_r5 = ViewArrayAnalysis<t_i4** * [3]>;
 
-    static_assert(a_int_r5::dimension::rank == 5, "");
-    static_assert(a_int_r5::dimension::rank_dynamic == 3, "");
-    static_assert(a_int_r5::dimension::ArgN0 == 0, "");
-    static_assert(a_int_r5::dimension::ArgN1 == 0, "");
-    static_assert(a_int_r5::dimension::ArgN2 == 0, "");
-    static_assert(a_int_r5::dimension::ArgN3 == 3, "");
-    static_assert(a_int_r5::dimension::ArgN4 == 4, "");
+    static_assert(a_int_r5::dimension::rank == 5);
+    static_assert(a_int_r5::dimension::rank_dynamic == 3);
+    static_assert(a_int_r5::dimension::ArgN0 == 0);
+    static_assert(a_int_r5::dimension::ArgN1 == 0);
+    static_assert(a_int_r5::dimension::ArgN2 == 0);
+    static_assert(a_int_r5::dimension::ArgN3 == 3);
+    static_assert(a_int_r5::dimension::ArgN4 == 4);
     static_assert(
-        std::is_same<typename a_int_r5::non_const_value_type, int>::value, "");
+        std::is_same<typename a_int_r5::non_const_value_type, int>::value);
   }
 
   {
@@ -603,71 +597,54 @@ void test_view_mapping() {
 
     using a_const_int_r1 = ViewDataAnalysis<const int[], void>;
 
-    static_assert(std::is_void<typename a_const_int_r1::specialize>::value, "");
+    static_assert(std::is_void<typename a_const_int_r1::specialize>::value);
     static_assert(std::is_same<typename a_const_int_r1::dimension,
-                               Kokkos::Impl::ViewDimension<0> >::value,
-                  "");
+                               Kokkos::Impl::ViewDimension<0> >::value);
 
     static_assert(
-        std::is_same<typename a_const_int_r1::type, const int*>::value, "");
+        std::is_same<typename a_const_int_r1::type, const int*>::value);
     static_assert(
-        std::is_same<typename a_const_int_r1::value_type, const int>::value,
-        "");
+        std::is_same<typename a_const_int_r1::value_type, const int>::value);
 
     static_assert(std::is_same<typename a_const_int_r1::scalar_array_type,
-                               const int*>::value,
-                  "");
+                               const int*>::value);
     static_assert(
-        std::is_same<typename a_const_int_r1::const_type, const int*>::value,
-        "");
+        std::is_same<typename a_const_int_r1::const_type, const int*>::value);
     static_assert(std::is_same<typename a_const_int_r1::const_value_type,
-                               const int>::value,
-                  "");
+                               const int>::value);
     static_assert(std::is_same<typename a_const_int_r1::const_scalar_array_type,
-                               const int*>::value,
-                  "");
+                               const int*>::value);
     static_assert(
-        std::is_same<typename a_const_int_r1::non_const_type, int*>::value, "");
-    static_assert(
-        std::is_same<typename a_const_int_r1::non_const_value_type, int>::value,
-        "");
+        std::is_same<typename a_const_int_r1::non_const_type, int*>::value);
+    static_assert(std::is_same<typename a_const_int_r1::non_const_value_type,
+                               int>::value);
 
     using a_const_int_r3 = ViewDataAnalysis<const int* * [4], void>;
 
-    static_assert(std::is_void<typename a_const_int_r3::specialize>::value, "");
+    static_assert(std::is_void<typename a_const_int_r3::specialize>::value);
 
     static_assert(std::is_same<typename a_const_int_r3::dimension,
-                               Kokkos::Impl::ViewDimension<0, 0, 4> >::value,
-                  "");
+                               Kokkos::Impl::ViewDimension<0, 0, 4> >::value);
 
     static_assert(
-        std::is_same<typename a_const_int_r3::type, const int* * [4]>::value,
-        "");
+        std::is_same<typename a_const_int_r3::type, const int* * [4]>::value);
     static_assert(
-        std::is_same<typename a_const_int_r3::value_type, const int>::value,
-        "");
+        std::is_same<typename a_const_int_r3::value_type, const int>::value);
     static_assert(std::is_same<typename a_const_int_r3::scalar_array_type,
-                               const int* * [4]>::value,
-                  "");
+                               const int* * [4]>::value);
     static_assert(std::is_same<typename a_const_int_r3::const_type,
-                               const int* * [4]>::value,
-                  "");
+                               const int* * [4]>::value);
     static_assert(std::is_same<typename a_const_int_r3::const_value_type,
-                               const int>::value,
-                  "");
+                               const int>::value);
     static_assert(std::is_same<typename a_const_int_r3::const_scalar_array_type,
-                               const int* * [4]>::value,
-                  "");
+                               const int* * [4]>::value);
     static_assert(std::is_same<typename a_const_int_r3::non_const_type,
-                               int* * [4]>::value,
-                  "");
-    static_assert(
-        std::is_same<typename a_const_int_r3::non_const_value_type, int>::value,
-        "");
+                               int* * [4]>::value);
+    static_assert(std::is_same<typename a_const_int_r3::non_const_value_type,
+                               int>::value);
     static_assert(
         std::is_same<typename a_const_int_r3::non_const_scalar_array_type,
-                     int* * [4]>::value,
-        "");
+                     int* * [4]>::value);
 
     // std::cout << "typeid( const int**[4] ).name() = " << typeid( const
     // int**[4] ).name() << std::endl;
diff --git a/core/unit_test/TestViewMapping_b.hpp b/core/unit_test/TestViewMapping_b.hpp
index 9ac4e7da84..4aee035d17 100644
--- a/core/unit_test/TestViewMapping_b.hpp
+++ b/core/unit_test/TestViewMapping_b.hpp
@@ -156,7 +156,7 @@ TEST(TEST_CATEGORY, view_mapping_assignable) {
     using dst_traits = Kokkos::ViewTraits<int, Kokkos::LayoutLeft, exec_space>;
     using src_traits = Kokkos::ViewTraits<int, Kokkos::LayoutRight, exec_space>;
     using mapping    = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
-    static_assert(mapping::is_assignable, "");
+    static_assert(mapping::is_assignable);
 
     Kokkos::View<int, Kokkos::LayoutRight, exec_space> src;
     Kokkos::View<int, Kokkos::LayoutLeft, exec_space> dst(src);
@@ -167,7 +167,7 @@ TEST(TEST_CATEGORY, view_mapping_assignable) {
     using dst_traits = Kokkos::ViewTraits<int, Kokkos::LayoutRight, exec_space>;
     using src_traits = Kokkos::ViewTraits<int, Kokkos::LayoutLeft, exec_space>;
     using mapping    = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
-    static_assert(mapping::is_assignable, "");
+    static_assert(mapping::is_assignable);
 
     Kokkos::View<int, Kokkos::LayoutLeft, exec_space> src;
     Kokkos::View<int, Kokkos::LayoutRight, exec_space> dst(src);
@@ -180,7 +180,7 @@ TEST(TEST_CATEGORY, view_mapping_assignable) {
     using src_traits =
         Kokkos::ViewTraits<int *, Kokkos::LayoutRight, exec_space>;
     using mapping = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
-    static_assert(mapping::is_assignable, "");
+    static_assert(mapping::is_assignable);
 
     Kokkos::View<int *, Kokkos::LayoutRight, exec_space> src;
     Kokkos::View<int *, Kokkos::LayoutLeft, exec_space> dst(src);
@@ -193,7 +193,7 @@ TEST(TEST_CATEGORY, view_mapping_assignable) {
     using src_traits =
         Kokkos::ViewTraits<int *, Kokkos::LayoutLeft, exec_space>;
     using mapping = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
-    static_assert(mapping::is_assignable, "");
+    static_assert(mapping::is_assignable);
 
     Kokkos::View<int *, Kokkos::LayoutLeft, exec_space> src;
     Kokkos::View<int *, Kokkos::LayoutRight, exec_space> dst(src);
@@ -206,7 +206,7 @@ TEST(TEST_CATEGORY, view_mapping_assignable) {
     using src_traits =
         Kokkos::ViewTraits<int **, Kokkos::LayoutRight, exec_space>;
     using mapping = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
-    static_assert(!mapping::is_assignable, "");
+    static_assert(!mapping::is_assignable);
   }
 
   {  // Assignment of rank-2 Right = Left
@@ -215,7 +215,7 @@ TEST(TEST_CATEGORY, view_mapping_assignable) {
     using src_traits =
         Kokkos::ViewTraits<int **, Kokkos::LayoutLeft, exec_space>;
     using mapping = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
-    static_assert(!mapping::is_assignable, "");
+    static_assert(!mapping::is_assignable);
   }
 }
 
@@ -226,7 +226,7 @@ TEST(TEST_CATEGORY, view_mapping_trivially_copyable) {
   using src_traits = dst_traits;
   using mapping    = Kokkos::Impl::ViewMapping<dst_traits, src_traits, void>;
 
-  static_assert(std::is_trivially_copyable<mapping>{}, "");
+  static_assert(std::is_trivially_copyable<mapping>{});
 }
 
 }  // namespace Test
diff --git a/core/unit_test/TestViewMemoryAccessViolation.hpp b/core/unit_test/TestViewMemoryAccessViolation.hpp
index d8febd2ba1..daf24ce7c0 100644
--- a/core/unit_test/TestViewMemoryAccessViolation.hpp
+++ b/core/unit_test/TestViewMemoryAccessViolation.hpp
@@ -18,7 +18,6 @@
 
 #include <gtest/gtest.h>
 
-#ifndef KOKKOS_COMPILER_NVHPC  // FIXME_NVHPC
 template <class View, class ExecutionSpace>
 struct TestViewMemoryAccessViolation {
   View v;
@@ -182,7 +181,12 @@ TEST(TEST_CATEGORY_DEATH, view_memory_access_violations_from_device) {
                     "able to abort from the device";
   }
 #endif
+#if defined(KOKKOS_ENABLE_OPENACC)  // FIXME_OPENACC
+  if (std::is_same<ExecutionSpace, Kokkos::Experimental::OpenACC>::value) {
+    GTEST_SKIP() << "skipping because OpenACC backend is currently not "
+                    "able to abort from the device";
+  }
+#endif
 
   test_view_memory_access_violations_from_device<ExecutionSpace>();
 }
-#endif
diff --git a/core/unit_test/TestViewOfViews.hpp b/core/unit_test/TestViewOfViews.hpp
new file mode 100644
index 0000000000..a87c829bb7
--- /dev/null
+++ b/core/unit_test/TestViewOfViews.hpp
@@ -0,0 +1,75 @@
+//@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 {
+
+// User-defined type with a View data member
+template <class V>
+class S {
+  V v_;
+
+ public:
+  template <class... Extents>
+  S(std::string label, Extents... extents) : v_(std::move(label), extents...) {}
+  S() = default;
+};
+
+template <class V>
+void test_view_of_views() {
+  using VoV = Kokkos::View<V**, Kokkos::HostSpace>;
+  {  // assigning a default-constructed view to destruct the inner objects
+    VoV vov("vov", 2, 3);
+    V a("a");
+    V b("b");
+    vov(0, 0) = a;
+    vov(1, 0) = a;
+    vov(0, 1) = b;
+#ifndef KOKKOS_ENABLE_IMPL_VIEW_OF_VIEWS_DESTRUCTOR_PRECONDITION_VIOLATION_WORKAROUND
+    vov(0, 0) = V();
+    vov(1, 0) = V();
+    vov(0, 1) = V();
+#endif
+  }
+  {  // using placement new to construct the inner objects and explicitly
+     // calling the destructor
+    VoV vov(Kokkos::view_alloc("vov", Kokkos::WithoutInitializing), 2, 3);
+    V a("a");
+    V b("b");
+    new (&vov(0, 0)) V(a);
+    new (&vov(1, 0)) V(a);
+    new (&vov(0, 1)) V(b);
+#ifndef KOKKOS_ENABLE_IMPL_VIEW_OF_VIEWS_DESTRUCTOR_PRECONDITION_VIOLATION_WORKAROUND
+    vov(0, 0).~V();
+    vov(1, 0).~V();
+    vov(0, 1).~V();
+#else
+    // leaks memory
+#endif
+  }
+}
+
+TEST(TEST_CATEGORY, view_of_views) {
+  test_view_of_views<Kokkos::View<int, TEST_EXECSPACE>>();
+  test_view_of_views<Kokkos::View<int[4], TEST_EXECSPACE>>();
+  // User-defined type with View data member
+  test_view_of_views<S<Kokkos::View<float, TEST_EXECSPACE>>>();
+}
+
+}  // namespace
diff --git a/core/unit_test/TestViewOutOfBoundsAccess.hpp b/core/unit_test/TestViewOutOfBoundsAccess.hpp
new file mode 100644
index 0000000000..2716856c1f
--- /dev/null
+++ b/core/unit_test/TestViewOutOfBoundsAccess.hpp
@@ -0,0 +1,175 @@
+//@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 <sstream>
+
+#include <gtest/gtest.h>
+
+namespace {
+
+TEST(TEST_CATEGORY, append_formatted_multidimensional_index) {
+  using Kokkos::Impl::append_formatted_multidimensional_index;
+  {
+    char buffer[64] = "my prefix ";
+    append_formatted_multidimensional_index(buffer, 1);
+    EXPECT_STREQ(buffer, "my prefix [1]");
+  }
+  {
+    char buffer[64] = "I was here";
+    append_formatted_multidimensional_index(buffer, 1, 2, 3);
+    EXPECT_STREQ(buffer, "I was here[1,2,3]");
+  }
+  {
+    char buffer[64] = "with mixed integer types ";
+    append_formatted_multidimensional_index(buffer, 1u, -2);
+    EXPECT_STREQ(buffer, "with mixed integer types [1,-2]");
+  }
+}
+
+#ifdef KOKKOS_ENABLE_DEBUG_BOUNDS_CHECK
+
+template <class View, class ExecutionSpace>
+struct TestViewOutOfBoundAccess {
+  View v;
+  static constexpr auto rank = View::rank;
+
+  template <std::size_t... Is>
+  KOKKOS_FUNCTION decltype(auto) bad_access(std::index_sequence<Is...>) const {
+    return v((Is * 1 + Is == 0 ? v.extent(Is) + 3 : 0)...);
+  }
+
+  KOKKOS_FUNCTION void operator()(int) const {
+    ++bad_access(std::make_index_sequence<rank>{});
+  }
+
+  template <std::size_t... Is>
+  std::string get_details(std::index_sequence<Is...>) {
+    std::stringstream ss;
+    ss << "with indices \\[";
+    ((ss << (Is == 0 ? v.extent(Is) + 3 : 0)
+         << (Is == View::rank() - 1 ? "\\]" : ",")),
+     ...);
+    ss << " but extents \\[";
+    ((ss << v.extent(Is) << (Is == View::rank() - 1 ? "\\]" : ",")), ...);
+    return ss.str();
+  }
+
+  auto get_details() {
+    return get_details(std::make_index_sequence<View::rank()>());
+  }
+
+  TestViewOutOfBoundAccess(View w, ExecutionSpace const& s, std::string matcher)
+      : v(std::move(w)) {
+    constexpr bool view_accessible_from_execution_space =
+        Kokkos::SpaceAccessibility<
+            /*AccessSpace=*/ExecutionSpace,
+            /*MemorySpace=*/typename View::memory_space>::accessible;
+    EXPECT_TRUE(view_accessible_from_execution_space);
+
+    matcher += ".*" + get_details();
+
+    EXPECT_DEATH(
+        {
+          Kokkos::parallel_for(Kokkos::RangePolicy<ExecutionSpace>(s, 0, 1),
+                               *this);
+          Kokkos::fence();
+        },
+        matcher);
+  }
+};
+
+template <class View, class LblOrPtr, std::size_t... Is>
+auto make_view_impl(LblOrPtr x, std::index_sequence<Is...>) {
+  return View(x, (Is + 1)...);
+}
+
+template <class View, class LblOrPtr>
+auto make_view(LblOrPtr x) {
+  return make_view_impl<View>(std::move(x),
+                              std::make_index_sequence<View::rank>());
+}
+
+template <class ExecutionSpace>
+void test_view_out_of_bounds_access() {
+  ExecutionSpace const exec_space{};
+  // clang-format off
+  using V1 = Kokkos::View<int*,        ExecutionSpace>;
+  using V2 = Kokkos::View<int**,       ExecutionSpace>;
+  using V3 = Kokkos::View<int***,      ExecutionSpace>;
+  using V4 = Kokkos::View<int****,     ExecutionSpace>;
+  using V5 = Kokkos::View<int*****,    ExecutionSpace>;
+  using V6 = Kokkos::View<int******,   ExecutionSpace>;
+  using V7 = Kokkos::View<int*******,  ExecutionSpace>;
+  using V8 = Kokkos::View<int********, ExecutionSpace>;
+  std::string const prefix = "Kokkos::View ERROR: out of bounds access";
+  std::string const lbl = "my_label";
+  TestViewOutOfBoundAccess(make_view<V1>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V2>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V3>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V4>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V5>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V6>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V7>(lbl), exec_space, prefix + ".*" + lbl);
+  TestViewOutOfBoundAccess(make_view<V8>(lbl), exec_space, prefix + ".*" + lbl);
+  int* const ptr = nullptr;
+  TestViewOutOfBoundAccess(make_view<V1>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V2>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V3>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V4>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V5>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V6>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V7>(ptr), exec_space, prefix + ".*UNMANAGED");
+  TestViewOutOfBoundAccess(make_view<V8>(ptr), exec_space, prefix + ".*UNMANAGED");
+  // clang-format on
+}
+
+TEST(TEST_CATEGORY_DEATH, view_out_of_bounds_access) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+
+  using ExecutionSpace = TEST_EXECSPACE;
+
+  if (false && Kokkos::SpaceAccessibility<
+                   /*AccessSpace=*/ExecutionSpace,
+                   /*MemorySpace=*/Kokkos::HostSpace>::accessible) {
+    GTEST_SKIP() << "skipping since no memory access violation would occur";
+  }
+
+#if defined(KOKKOS_ENABLE_SYCL) && defined(NDEBUG)  // FIXME_SYCL
+  if (std::is_same_v<ExecutionSpace, Kokkos::Experimental::SYCL>) {
+    GTEST_SKIP() << "skipping SYCL device-side abort does not work when NDEBUG "
+                    "is defined";
+  }
+#endif
+#if defined(KOKKOS_ENABLE_OPENMPTARGET)  // FIXME_OPENMPTARGET
+  if (std::is_same_v<ExecutionSpace, Kokkos::Experimental::OpenMPTarget>) {
+    GTEST_SKIP() << "skipping because OpenMPTarget backend is currently not "
+                    "able to abort from the device";
+  }
+#endif
+#if defined(KOKKOS_ENABLE_OPENACC)  // FIXME_OPENACC
+  if (std::is_same<ExecutionSpace, Kokkos::Experimental::OpenACC>::value) {
+    GTEST_SKIP() << "skipping because OpenACC backend is currently not "
+                    "able to abort from the device";
+  }
+#endif
+
+  test_view_out_of_bounds_access<ExecutionSpace>();
+}
+
+#endif
+
+}  // namespace
diff --git a/core/unit_test/TestViewSubview.hpp b/core/unit_test/TestViewSubview.hpp
index 386887d923..c60aa2fe26 100644
--- a/core/unit_test/TestViewSubview.hpp
+++ b/core/unit_test/TestViewSubview.hpp
@@ -2294,9 +2294,8 @@ template <class Space>
 struct TestExtentsStaticTests {
   using test1 = typename static_expect_same<
       /* expected */
-      Kokkos::Experimental::Extents<Kokkos::Experimental::dynamic_extent,
-                                    Kokkos::Experimental::dynamic_extent, 1, 2,
-                                    3>,
+      Kokkos::Experimental::Extents<Kokkos::dynamic_extent,
+                                    Kokkos::dynamic_extent, 1, 2, 3>,
       /* actual */
       typename Kokkos::Impl::ParseViewExtents<double* * [1][2][3]>::type>::type;
 
diff --git a/core/unit_test/UnitTest_DeviceAndThreads.cpp b/core/unit_test/UnitTest_DeviceAndThreads.cpp
index b522ac3e69..25442146fb 100644
--- a/core/unit_test/UnitTest_DeviceAndThreads.cpp
+++ b/core/unit_test/UnitTest_DeviceAndThreads.cpp
@@ -19,22 +19,23 @@
 #include <string>
 #include <thread>
 
-int get_device_count() {
+int get_num_devices() {
+  int num_devices;
 #if defined(KOKKOS_ENABLE_CUDA)
-  int count;
-  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&count));
-  return count;
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&num_devices));
 #elif defined(KOKKOS_ENABLE_HIP)
-  int count;
-  KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDevice(&count));
-  return count;
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDeviceCount(&num_devices));
 #elif defined(KOKKOS_ENABLE_OPENMPTARGET)
-  return omp_get_num_devices();
+  num_devices = omp_get_num_devices();
 #elif defined(KOKKOS_ENABLE_OPENACC)
-  return acc_get_num_devices(acc_get_device_type());
+  num_devices = acc_get_num_devices(acc_get_device_type());
+#elif defined(KOKKOS_ENABLE_SYCL)
+  num_devices = sycl::device::get_devices(sycl::info::device_type::gpu).size();
 #else
-  return 0;
+  num_devices = -1;
 #endif
+  assert(num_devices == Kokkos::num_devices());
+  return num_devices;
 }
 
 int get_device_id() {
@@ -44,15 +45,17 @@ int get_device_id() {
 #elif defined(KOKKOS_ENABLE_HIP)
   KOKKOS_IMPL_HIP_SAFE_CALL(hipGetDevice(&device_id));
 #elif defined(KOKKOS_ENABLE_OPENMPTARGET)
-  device_id = omp_get_device_num();
+  device_id   = omp_get_default_device();
 #elif defined(KOKKOS_ENABLE_OPENACC)
-  device_id = 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;
+  // Not able to query the underlying runtime because there is no such thing as
+  // device currently being used with SYCL.  We go through the Kokkos runtime
+  // which makes the assert below pointless but it still let us check that
+  // Kokkos selected the device we asked for from the Python tests.
+  device_id = Kokkos::device_id();
 #else
-  device_id = -1;
+  device_id   = -1;
 #endif
   assert(device_id == Kokkos::device_id());
   return device_id;
@@ -68,6 +71,14 @@ int get_max_threads() {
 #endif
 }
 
+int get_hwloc_enabled() {
+#ifdef KOKKOS_ENABLE_HWLOC
+  return 1;
+#else
+  return 0;
+#endif
+}
+
 int get_num_threads() {
   int const num_threads = Kokkos::DefaultHostExecutionSpace().concurrency();
   assert(num_threads == Kokkos::num_threads());
@@ -90,9 +101,10 @@ int print_flag(std::string const& flag) {
   KOKKOS_TEST_PRINT_FLAG(num_threads);
   KOKKOS_TEST_PRINT_FLAG(max_threads);
   KOKKOS_TEST_PRINT_FLAG(device_id);
-  KOKKOS_TEST_PRINT_FLAG(device_count);
+  KOKKOS_TEST_PRINT_FLAG(num_devices);
   KOKKOS_TEST_PRINT_FLAG(disable_warnings);
   KOKKOS_TEST_PRINT_FLAG(tune_internals);
+  KOKKOS_TEST_PRINT_FLAG(hwloc_enabled);
 
 #undef KOKKOS_TEST_PRINT_FLAG
 
diff --git a/core/unit_test/UnitTest_ScopeGuard.cpp b/core/unit_test/UnitTest_ScopeGuard.cpp
new file mode 100644
index 0000000000..b2176f3ef0
--- /dev/null
+++ b/core/unit_test/UnitTest_ScopeGuard.cpp
@@ -0,0 +1,155 @@
+//@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 <cstdlib>
+#include <gtest/gtest.h>
+#include <Kokkos_Core.hpp>
+
+namespace {
+
+/**
+ * Fixture that checks Kokkos is neither initialized nor finalized before and
+ * after the test.
+ */
+class AssertEnvironmentTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    ASSERT_FALSE(Kokkos::is_initialized());
+    ASSERT_FALSE(Kokkos::is_finalized());
+  }
+
+  void TearDown() override {
+    ASSERT_FALSE(Kokkos::is_initialized());
+    ASSERT_FALSE(Kokkos::is_finalized());
+  }
+};
+
+using scope_guard_DeathTest = AssertEnvironmentTest;
+
+/**
+ * Test to create a scope guard normally.
+ */
+TEST_F(scope_guard_DeathTest, create) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  // run it in a different process so side effects are not kept
+  EXPECT_EXIT(
+      {
+        {
+          Kokkos::ScopeGuard guard{};
+
+          if (!Kokkos::is_initialized()) std::exit(EXIT_FAILURE);
+          if (Kokkos::is_finalized()) std::exit(EXIT_FAILURE);
+        }
+
+        if (Kokkos::is_initialized()) std::exit(EXIT_FAILURE);
+        if (!Kokkos::is_finalized()) std::exit(EXIT_FAILURE);
+
+        std::exit(EXIT_SUCCESS);
+      },
+      testing::ExitedWithCode(EXIT_SUCCESS), "");
+}
+
+/**
+ * Test to create a scope guard with an argument.
+ */
+TEST_F(scope_guard_DeathTest, create_argument) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  // run it in a different process so side effects are not kept
+  EXPECT_EXIT(
+      {
+        {
+          Kokkos::InitializationSettings settings{};
+          Kokkos::ScopeGuard guard{settings};
+        }
+
+        std::exit(EXIT_SUCCESS);
+      },
+      testing::ExitedWithCode(EXIT_SUCCESS), "");
+}
+
+/**
+ * Test to create another scope guard when one has been created.
+ */
+TEST_F(scope_guard_DeathTest, create_while_initialize) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  EXPECT_DEATH(
+      {
+        Kokkos::ScopeGuard guard1{};
+
+        // create a second scope guard while there is one already existing
+        Kokkos::ScopeGuard guard2{};
+      },
+      "Creating a ScopeGuard while Kokkos is initialized");
+}
+
+/**
+ * Test to create a scope guard when initialization has been done manually.
+ */
+TEST_F(scope_guard_DeathTest, create_after_initialize) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  EXPECT_DEATH(
+      {
+        Kokkos::initialize();
+
+        // create a scope guard after manual initialization
+        Kokkos::ScopeGuard guard{};
+      },
+      "Creating a ScopeGuard while Kokkos is initialized");
+}
+
+/**
+ * Test to create another scope guard when one has been destroyed.
+ */
+TEST_F(scope_guard_DeathTest, create_after_finalize) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  EXPECT_DEATH(
+      {
+        { Kokkos::ScopeGuard guard1{}; }
+
+        // create a second scope guard while the first one has been destroyed
+        // already
+        Kokkos::ScopeGuard guard2{};
+      },
+      "Creating a ScopeGuard after Kokkos was finalized");
+}
+
+/**
+ * Test to destroy a scope guard when finalization has been done manually.
+ */
+TEST_F(scope_guard_DeathTest, destroy_after_finalize) {
+  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
+  EXPECT_DEATH(
+      {
+        // create a scope guard and finalize it manually
+        Kokkos::ScopeGuard guard{};
+        Kokkos::finalize();
+      },
+      "Destroying a ScopeGuard after Kokkos was finalized");
+}
+
+/**
+ * Static tests
+ */
+
+// Test scope guard is not copyable.
+static_assert(!std::is_copy_assignable<Kokkos::ScopeGuard>());
+static_assert(!std::is_copy_constructible<Kokkos::ScopeGuard>());
+
+// Test scope guard is not movable.
+static_assert(!std::is_move_assignable<Kokkos::ScopeGuard>());
+static_assert(!std::is_move_constructible<Kokkos::ScopeGuard>());
+
+}  // namespace
diff --git a/core/unit_test/category_files/TestHPX_Category.hpp b/core/unit_test/category_files/TestHPX_Category.hpp
index d3a7cdbea5..c6a2aa9f20 100644
--- a/core/unit_test/category_files/TestHPX_Category.hpp
+++ b/core/unit_test/category_files/TestHPX_Category.hpp
@@ -23,5 +23,6 @@
 #define TEST_CATEGORY_NUMBER 3
 #define TEST_CATEGORY_DEATH hpx_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::HPX
+#define TEST_CATEGORY_FIXTURE(name) hpx_##name
 
 #endif
diff --git a/core/unit_test/category_files/TestOpenACC_Category.hpp b/core/unit_test/category_files/TestOpenACC_Category.hpp
index 0c4e4b7e11..6105eadf14 100644
--- a/core/unit_test/category_files/TestOpenACC_Category.hpp
+++ b/core/unit_test/category_files/TestOpenACC_Category.hpp
@@ -23,5 +23,6 @@
 #define TEST_CATEGORY_NUMBER 8
 #define TEST_CATEGORY_DEATH openacc_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::OpenACC
+#define TEST_CATEGORY_FIXTURE(name) openacc_##name
 
 #endif
diff --git a/core/unit_test/category_files/TestOpenMPTarget_Category.hpp b/core/unit_test/category_files/TestOpenMPTarget_Category.hpp
index 235b34ffab..921cff7890 100644
--- a/core/unit_test/category_files/TestOpenMPTarget_Category.hpp
+++ b/core/unit_test/category_files/TestOpenMPTarget_Category.hpp
@@ -23,5 +23,6 @@
 #define TEST_CATEGORY_NUMBER 4
 #define TEST_CATEGORY_DEATH openmptarget_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::OpenMPTarget
+#define TEST_CATEGORY_FIXTURE(name) openmptarget_##name
 
 #endif
diff --git a/core/unit_test/category_files/TestSYCL_Category.hpp b/core/unit_test/category_files/TestSYCL_Category.hpp
index 8e1b18c9ac..59e72c72c7 100644
--- a/core/unit_test/category_files/TestSYCL_Category.hpp
+++ b/core/unit_test/category_files/TestSYCL_Category.hpp
@@ -23,5 +23,6 @@
 #define TEST_CATEGORY_NUMBER 7
 #define TEST_CATEGORY_DEATH sycl_DeathTest
 #define TEST_EXECSPACE Kokkos::Experimental::SYCL
+#define TEST_CATEGORY_FIXTURE(name) sycl_##name
 
 #endif
diff --git a/core/unit_test/category_files/TestThreads_Category.hpp b/core/unit_test/category_files/TestThreads_Category.hpp
index 13b0b653f2..ae8ac60833 100644
--- a/core/unit_test/category_files/TestThreads_Category.hpp
+++ b/core/unit_test/category_files/TestThreads_Category.hpp
@@ -23,5 +23,6 @@
 #define TEST_CATEGORY_NUMBER 1
 #define TEST_CATEGORY_DEATH threads_DeathTest
 #define TEST_EXECSPACE Kokkos::Threads
+#define TEST_CATEGORY_FIXTURE(name) threads_##name
 
 #endif
diff --git a/core/unit_test/configuration/test-code/test_config_arch_list.bash b/core/unit_test/configuration/test-code/test_config_arch_list.bash
index 8fe8e2b5ec..8bc8ef21cd 100755
--- a/core/unit_test/configuration/test-code/test_config_arch_list.bash
+++ b/core/unit_test/configuration/test-code/test_config_arch_list.bash
@@ -4,7 +4,7 @@ HostArch=(SNB HSW SKX KNL)
 DeviceArch=(Kepler35 Kepler37 Pascal60 Pascal61 Volta70)
 if [ ! -z "$KOKKOS_HOST_ARCH_TEST" ]; then
   export KOKKOS_ARCH_TEST=1
-  HostArch=(WSM SNB HSW SKX WSM AMDAVX ARMv80 ARMv81 BDW KNC KNL BGQ Power7 Power8 Power9 Zen Zen2 Zen3 ARMv8_ThunderX ARMv8_ThunderX2)
+  HostArch=(SNB HSW SKX AMDAVX ARMv80 ARMv81 BDW KNC KNL Power8 Power9 Zen Zen2 Zen3 ARMv8_ThunderX ARMv8_ThunderX2)
   DeviceArch=()
 fi
 
diff --git a/core/unit_test/cuda/TestCuda_InterOp_StreamsMultiGPU.cpp b/core/unit_test/cuda/TestCuda_InterOp_StreamsMultiGPU.cpp
new file mode 100644
index 0000000000..40955e9c7c
--- /dev/null
+++ b/core/unit_test/cuda/TestCuda_InterOp_StreamsMultiGPU.cpp
@@ -0,0 +1,108 @@
+//@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 <TestCuda_Category.hpp>
+#include <TestMultiGPU.hpp>
+
+namespace {
+
+struct StreamsAndDevices {
+  std::array<cudaStream_t, 2> streams;
+  std::array<int, 2> devices;
+
+  StreamsAndDevices() {
+    int n_devices;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDeviceCount(&n_devices));
+
+    devices = {0, n_devices - 1};
+    for (int i = 0; i < 2; ++i) {
+      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(devices[i]));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamCreate(&streams[i]));
+    }
+  }
+  StreamsAndDevices(const StreamsAndDevices &) = delete;
+  StreamsAndDevices &operator=(const StreamsAndDevices &) = delete;
+  ~StreamsAndDevices() {
+    for (int i = 0; i < 2; ++i) {
+      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(devices[i]));
+      KOKKOS_IMPL_CUDA_SAFE_CALL(cudaStreamDestroy(streams[i]));
+    }
+  }
+};
+
+std::array<TEST_EXECSPACE, 2> get_execution_spaces(
+    const StreamsAndDevices &streams_and_devices) {
+  TEST_EXECSPACE exec0(streams_and_devices.streams[0]);
+  TEST_EXECSPACE exec1(streams_and_devices.streams[1]);
+
+  // Must return void to use ASSERT_EQ
+  [&]() {
+    ASSERT_EQ(exec0.cuda_device(), streams_and_devices.devices[0]);
+    ASSERT_EQ(exec1.cuda_device(), streams_and_devices.devices[1]);
+  }();
+
+  return {exec0, exec1};
+}
+
+TEST(cuda_multi_gpu, managed_views) {
+  StreamsAndDevices streams_and_devices;
+  {
+    std::array<TEST_EXECSPACE, 2> execs =
+        get_execution_spaces(streams_and_devices);
+
+    Kokkos::View<int *, TEST_EXECSPACE> view0(
+        Kokkos::view_alloc("v0", execs[0]), 100);
+    Kokkos::View<int *, TEST_EXECSPACE> view(Kokkos::view_alloc("v", execs[1]),
+                                             100);
+
+    test_policies(execs[0], view0, execs[1], view);
+  }
+}
+
+TEST(cuda_multi_gpu, unmanaged_views) {
+  StreamsAndDevices streams_and_devices;
+  {
+    std::array<TEST_EXECSPACE, 2> execs =
+        get_execution_spaces(streams_and_devices);
+
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(execs[0].cuda_device()));
+    int *p0;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        cudaMalloc(reinterpret_cast<void **>(&p0), sizeof(int) * 100));
+    Kokkos::View<int *, TEST_EXECSPACE> view0(p0, 100);
+
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(execs[1].cuda_device()));
+    int *p;
+    KOKKOS_IMPL_CUDA_SAFE_CALL(
+        cudaMalloc(reinterpret_cast<void **>(&p), sizeof(int) * 100));
+    Kokkos::View<int *, TEST_EXECSPACE> view(p, 100);
+
+    test_policies(execs[0], view0, execs[1], view);
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(p0));
+    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaFree(p));
+  }
+}
+
+TEST(cuda_multi_gpu, scratch_space) {
+  StreamsAndDevices streams_and_devices;
+  {
+    std::array<TEST_EXECSPACE, 2> execs =
+        get_execution_spaces(streams_and_devices);
+
+    test_scratch(execs[0], execs[1]);
+  }
+}
+}  // namespace
diff --git a/core/unit_test/cuda/TestCuda_Spaces.cpp b/core/unit_test/cuda/TestCuda_Spaces.cpp
index d71984a75a..11fe6b8555 100644
--- a/core/unit_test/cuda/TestCuda_Spaces.cpp
+++ b/core/unit_test/cuda/TestCuda_Spaces.cpp
@@ -29,200 +29,166 @@ __global__ void test_cuda_spaces_int_value(int *ptr) {
 
 TEST(cuda, space_access) {
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                Kokkos::HostSpace>::assignable,
-                "");
+                                                Kokkos::HostSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                      Kokkos::CudaHostPinnedSpace>::assignable,
-      "");
+                                      Kokkos::CudaHostPinnedSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                 Kokkos::CudaSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                       Kokkos::CudaSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                 Kokkos::CudaSpace>::accessible,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                       Kokkos::CudaSpace>::accessible);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                       Kokkos::CudaUVMSpace>::assignable,
-      "");
+                                       Kokkos::CudaUVMSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                      Kokkos::CudaUVMSpace>::accessible,
-      "");
+                                      Kokkos::CudaUVMSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                                Kokkos::CudaSpace>::assignable,
-                "");
+                                                Kokkos::CudaSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                      Kokkos::CudaUVMSpace>::assignable,
-      "");
+                                      Kokkos::CudaUVMSpace>::assignable);
 
-  static_assert(
-      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                       Kokkos::CudaHostPinnedSpace>::assignable,
-      "");
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<
+                Kokkos::CudaSpace, Kokkos::CudaHostPinnedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                      Kokkos::CudaHostPinnedSpace>::accessible,
-      "");
+                                      Kokkos::CudaHostPinnedSpace>::accessible);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                                 Kokkos::HostSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                       Kokkos::HostSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
-                                                 Kokkos::HostSpace>::accessible,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaSpace,
+                                       Kokkos::HostSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                      Kokkos::CudaUVMSpace>::assignable,
-      "");
+                                      Kokkos::CudaUVMSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                                 Kokkos::CudaSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                       Kokkos::CudaSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                                Kokkos::CudaSpace>::accessible,
-                "");
-
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                                 Kokkos::HostSpace>::assignable,
-                "");
+                                                Kokkos::CudaSpace>::accessible);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                                 Kokkos::HostSpace>::accessible,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
+                                       Kokkos::HostSpace>::assignable);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                       Kokkos::CudaHostPinnedSpace>::assignable,
-      "");
+                                       Kokkos::HostSpace>::accessible);
+
+  static_assert(!Kokkos::Impl::MemorySpaceAccess<
+                Kokkos::CudaUVMSpace, Kokkos::CudaHostPinnedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaUVMSpace,
-                                      Kokkos::CudaHostPinnedSpace>::accessible,
-      "");
+                                      Kokkos::CudaHostPinnedSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                      Kokkos::CudaHostPinnedSpace>::assignable,
-      "");
+                                      Kokkos::CudaHostPinnedSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                                 Kokkos::HostSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                       Kokkos::HostSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                                Kokkos::HostSpace>::accessible,
-                "");
+                                                Kokkos::HostSpace>::accessible);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                                 Kokkos::CudaSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                       Kokkos::CudaSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                                 Kokkos::CudaSpace>::accessible,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
+                                       Kokkos::CudaSpace>::accessible);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                       Kokkos::CudaUVMSpace>::assignable,
-      "");
+                                       Kokkos::CudaUVMSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::CudaHostPinnedSpace,
-                                      Kokkos::CudaUVMSpace>::accessible,
-      "");
+                                      Kokkos::CudaUVMSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(
-      !Kokkos::SpaceAccessibility<Kokkos::Cuda, Kokkos::HostSpace>::accessible,
-      "");
+      !Kokkos::SpaceAccessibility<Kokkos::Cuda, Kokkos::HostSpace>::accessible);
 
   static_assert(
-      Kokkos::SpaceAccessibility<Kokkos::Cuda, Kokkos::CudaSpace>::accessible,
-      "");
+      Kokkos::SpaceAccessibility<Kokkos::Cuda, Kokkos::CudaSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<Kokkos::Cuda,
-                                           Kokkos::CudaUVMSpace>::accessible,
-                "");
+                                           Kokkos::CudaUVMSpace>::accessible);
 
   static_assert(
       Kokkos::SpaceAccessibility<Kokkos::Cuda,
-                                 Kokkos::CudaHostPinnedSpace>::accessible,
-      "");
+                                 Kokkos::CudaHostPinnedSpace>::accessible);
 
   static_assert(!Kokkos::SpaceAccessibility<Kokkos::HostSpace,
-                                            Kokkos::CudaSpace>::accessible,
-                "");
+                                            Kokkos::CudaSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<Kokkos::HostSpace,
-                                           Kokkos::CudaUVMSpace>::accessible,
-                "");
+                                           Kokkos::CudaUVMSpace>::accessible);
 
   static_assert(
       Kokkos::SpaceAccessibility<Kokkos::HostSpace,
-                                 Kokkos::CudaHostPinnedSpace>::accessible,
-      "");
+                                 Kokkos::CudaHostPinnedSpace>::accessible);
 
   static_assert(std::is_same<Kokkos::Impl::HostMirror<Kokkos::CudaSpace>::Space,
-                             Kokkos::HostSpace>::value,
-                "");
+                             Kokkos::HostSpace>::value);
 
   static_assert(
       std::is_same<Kokkos::Impl::HostMirror<Kokkos::CudaUVMSpace>::Space,
                    Kokkos::Device<Kokkos::HostSpace::execution_space,
-                                  Kokkos::CudaUVMSpace>>::value,
-      "");
+                                  Kokkos::CudaUVMSpace>>::value);
 
   static_assert(
       std::is_same<Kokkos::Impl::HostMirror<Kokkos::CudaHostPinnedSpace>::Space,
-                   Kokkos::CudaHostPinnedSpace>::value,
-      "");
+                   Kokkos::CudaHostPinnedSpace>::value);
 
   static_assert(std::is_same<Kokkos::Device<Kokkos::HostSpace::execution_space,
                                             Kokkos::CudaUVMSpace>,
                              Kokkos::Device<Kokkos::HostSpace::execution_space,
-                                            Kokkos::CudaUVMSpace>>::value,
-                "");
+                                            Kokkos::CudaUVMSpace>>::value);
 
   static_assert(
       Kokkos::SpaceAccessibility<Kokkos::Impl::HostMirror<Kokkos::Cuda>::Space,
-                                 Kokkos::HostSpace>::accessible,
-      "");
+                                 Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<Kokkos::CudaSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<Kokkos::CudaSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<Kokkos::CudaUVMSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<Kokkos::CudaUVMSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 
-  static_assert(
-      Kokkos::SpaceAccessibility<
-          Kokkos::Impl::HostMirror<Kokkos::CudaHostPinnedSpace>::Space,
-          Kokkos::HostSpace>::accessible,
-      "");
+  static_assert(Kokkos::SpaceAccessibility<
+                Kokkos::Impl::HostMirror<Kokkos::CudaHostPinnedSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 #ifdef KOKKOS_ENABLE_CUDA_UVM
   using uvm_view = Kokkos::View<double *, Kokkos::CudaUVMSpace>;
   static_assert(std::is_same<uvm_view::HostMirror::execution_space,
@@ -338,11 +304,6 @@ struct TestViewCudaTexture {
 };
 
 TEST(cuda, impl_view_texture) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC
-  GTEST_SKIP()
-      << "Getting error_count of 1000 meaning all assertions are failing";
-#endif
   TestViewCudaTexture<Kokkos::CudaSpace>::run();
   TestViewCudaTexture<Kokkos::CudaUVMSpace>::run();
 }
@@ -407,11 +368,6 @@ void test_view_subview_const_randomaccess() {
 }  // namespace issue_5594
 
 TEST(cuda, view_subview_const_randomaccess) {
-#if defined(KOKKOS_ENABLE_CUDA) && \
-    defined(KOKKOS_COMPILER_NVHPC)  // FIXME_NVHPC (similar failure to
-                                    // TestViewCudaTexture?)
-  GTEST_SKIP() << "RandomAccess view not working on NVHPC?";
-#endif
   issue_5594::test_view_subview_const_randomaccess<Kokkos::Cuda,
                                                    Kokkos::CudaSpace>();
   issue_5594::test_view_subview_const_randomaccess<Kokkos::Cuda,
diff --git a/core/unit_test/default/TestDefaultDeviceType.cpp b/core/unit_test/default/TestDefaultDeviceType.cpp
index 4a70d9e79b..b88f052ea2 100644
--- a/core/unit_test/default/TestDefaultDeviceType.cpp
+++ b/core/unit_test/default/TestDefaultDeviceType.cpp
@@ -32,16 +32,13 @@ TEST(TEST_CATEGORY, host_space_access) {
       Kokkos::Impl::HostMirror<Kokkos::DefaultExecutionSpace>::Space;
 
   static_assert(Kokkos::SpaceAccessibility<host_exec_space,
-                                           Kokkos::HostSpace>::accessible,
-                "");
+                                           Kokkos::HostSpace>::accessible);
 
   static_assert(
-      Kokkos::SpaceAccessibility<device_space, Kokkos::HostSpace>::accessible,
-      "");
+      Kokkos::SpaceAccessibility<device_space, Kokkos::HostSpace>::accessible);
 
   static_assert(
-      Kokkos::SpaceAccessibility<mirror_space, Kokkos::HostSpace>::accessible,
-      "");
+      Kokkos::SpaceAccessibility<mirror_space, Kokkos::HostSpace>::accessible);
 }
 
 }  // namespace Test
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp
deleted file mode 100644
index 348b9feeab..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_1.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_01
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp
deleted file mode 100644
index a77a55ea65..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_10.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_10
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp
deleted file mode 100644
index 1b6a140920..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_11.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_11
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp
deleted file mode 100644
index 316bc85526..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_12.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_12
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp
deleted file mode 100644
index 6344960a1c..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_13.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_13
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp
deleted file mode 100644
index 4515174b82..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_14.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_14
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp
deleted file mode 100644
index 7ead50f094..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_15.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_15
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp
deleted file mode 100644
index e12b9b3894..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_16.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_16
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_17.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_17.cpp
deleted file mode 100644
index 959d0ab750..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_17.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_17
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_18.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_18.cpp
deleted file mode 100644
index 07d841519d..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_18.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_18
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp
deleted file mode 100644
index 042a515b16..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_2.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_02
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp
deleted file mode 100644
index dba401e5bc..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_3.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_03
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp
deleted file mode 100644
index a44c58bdb5..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_4.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_04
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp
deleted file mode 100644
index cac0841dd8..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_5.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_05
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp
deleted file mode 100644
index bafe3b3fd2..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_6.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_06
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp
deleted file mode 100644
index 3a4dd9d253..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_7.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_07
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp
deleted file mode 100644
index 4e92aae565..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_8.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_08
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp b/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp
deleted file mode 100644
index 44b8f3428d..0000000000
--- a/core/unit_test/default/TestDefaultDeviceTypeInit_9.cpp
+++ /dev/null
@@ -1,18 +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
-
-#define KOKKOS_DEFAULTDEVICETYPE_INIT_TEST_09
-#include <TestDefaultDeviceTypeInit.hpp>
diff --git a/core/unit_test/headers_self_contained/CMakeLists.txt b/core/unit_test/headers_self_contained/CMakeLists.txt
index 5a0c589ac7..4c364ceee7 100644
--- a/core/unit_test/headers_self_contained/CMakeLists.txt
+++ b/core/unit_test/headers_self_contained/CMakeLists.txt
@@ -10,6 +10,11 @@ file(GLOB KOKKOS_CONTAINERS_HEADERS RELATIVE ${BASE_DIR}/containers/src
 file(GLOB KOKKOS_ALGORITHMS_HEADERS RELATIVE  ${BASE_DIR}/algorithms/src
      ${BASE_DIR}/algorithms/src/*.hpp)
 
+# erroring out when deprecated code is disabled and raising warnings that are treated as errors in the CI otherwise
+if(NOT Kokkos_ENABLE_DEPRECATED_CODE_4 OR Kokkos_ENABLE_DEPRECATION_WARNINGS)
+  list(REMOVE_ITEM KOKKOS_CONTAINERS_HEADERS "Kokkos_Vector.hpp")
+endif()
+
 foreach (_header ${KOKKOS_CORE_HEADERS} ${KOKKOS_CONTAINERS_HEADERS} ${KOKKOS_ALGORITHMS_HEADERS})
   string(REGEX REPLACE "[\./]" "_" header_test_name ${_header})
   set(header_test_name Kokkos_HeaderSelfContained_${header_test_name})
diff --git a/core/unit_test/hip/TestHIP_Graph.cpp b/core/unit_test/hip/TestHIP_Graph.cpp
deleted file mode 100644
index 405cb76c64..0000000000
--- a/core/unit_test/hip/TestHIP_Graph.cpp
+++ /dev/null
@@ -1,18 +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 <TestHIP_Category.hpp>
-#include <TestGraph.hpp>
diff --git a/core/unit_test/hip/TestHIP_Spaces.cpp b/core/unit_test/hip/TestHIP_Spaces.cpp
index 14fd4e2883..673c0f0fff 100644
--- a/core/unit_test/hip/TestHIP_Spaces.cpp
+++ b/core/unit_test/hip/TestHIP_Spaces.cpp
@@ -29,198 +29,180 @@ __global__ void test_hip_spaces_int_value(int *ptr) {
 
 TEST(hip, space_access) {
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                Kokkos::HostSpace>::assignable,
-                "");
+                                                Kokkos::HostSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                      Kokkos::HIPHostPinnedSpace>::assignable,
-      "");
+                                      Kokkos::HIPHostPinnedSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                 Kokkos::HIPSpace>::assignable,
-                "");
+                                                 Kokkos::HIPSpace>::assignable);
 
+#if !defined(KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY)
   static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                 Kokkos::HIPSpace>::accessible,
-                "");
+                                                 Kokkos::HIPSpace>::accessible);
+#else
+  static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
+                                                Kokkos::HIPSpace>::accessible);
+#endif
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                       Kokkos::HIPManagedSpace>::assignable,
-      "");
+                                       Kokkos::HIPManagedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                      Kokkos::HIPManagedSpace>::accessible,
-      "");
+                                      Kokkos::HIPManagedSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                                Kokkos::HIPSpace>::assignable,
-                "");
+                                                Kokkos::HIPSpace>::assignable);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                       Kokkos::HIPHostPinnedSpace>::assignable,
-      "");
+                                       Kokkos::HIPHostPinnedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                      Kokkos::HIPHostPinnedSpace>::accessible,
-      "");
+                                      Kokkos::HIPHostPinnedSpace>::accessible);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                                 Kokkos::HostSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
+                                       Kokkos::HostSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                                 Kokkos::HostSpace>::accessible,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
+                                       Kokkos::HostSpace>::accessible);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                      Kokkos::HIPManagedSpace>::assignable,
-      "");
+                                      Kokkos::HIPManagedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPSpace,
-                                      Kokkos::HIPManagedSpace>::accessible,
-      "");
+                                      Kokkos::HIPManagedSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                      Kokkos::HIPHostPinnedSpace>::assignable,
-      "");
+                                      Kokkos::HIPHostPinnedSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                                 Kokkos::HostSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
+                                       Kokkos::HostSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                                Kokkos::HostSpace>::accessible,
-                "");
+                                                Kokkos::HostSpace>::accessible);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                                 Kokkos::HIPSpace>::assignable,
-                "");
+                                                 Kokkos::HIPSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                                 Kokkos::HIPSpace>::accessible,
-                "");
+                                                 Kokkos::HIPSpace>::accessible);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                       Kokkos::HIPManagedSpace>::assignable,
-      "");
+                                       Kokkos::HIPManagedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPHostPinnedSpace,
-                                      Kokkos::HIPManagedSpace>::accessible,
-      "");
+                                      Kokkos::HIPManagedSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                      Kokkos::HIPManagedSpace>::assignable,
-      "");
+                                      Kokkos::HIPManagedSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                                 Kokkos::HostSpace>::assignable,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
+                                       Kokkos::HostSpace>::assignable);
 
-  static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                                 Kokkos::HostSpace>::accessible,
-                "");
+  static_assert(
+      !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
+                                       Kokkos::HostSpace>::accessible);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                                 Kokkos::HIPSpace>::assignable,
-                "");
+                                                 Kokkos::HIPSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                                Kokkos::HIPSpace>::accessible,
-                "");
+                                                Kokkos::HIPSpace>::accessible);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                       Kokkos::HIPHostPinnedSpace>::assignable,
-      "");
+                                       Kokkos::HIPHostPinnedSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::HIPManagedSpace,
-                                      Kokkos::HIPHostPinnedSpace>::accessible,
-      "");
+                                      Kokkos::HIPHostPinnedSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(
-      !Kokkos::SpaceAccessibility<Kokkos::HIP, Kokkos::HostSpace>::accessible,
-      "");
+      !Kokkos::SpaceAccessibility<Kokkos::HIP, Kokkos::HostSpace>::accessible);
 
   static_assert(
-      Kokkos::SpaceAccessibility<Kokkos::HIP, Kokkos::HIPSpace>::accessible,
-      "");
+      Kokkos::SpaceAccessibility<Kokkos::HIP, Kokkos::HIPSpace>::accessible);
 
   static_assert(
       Kokkos::SpaceAccessibility<Kokkos::HIP,
-                                 Kokkos::HIPHostPinnedSpace>::accessible,
-      "");
+                                 Kokkos::HIPHostPinnedSpace>::accessible);
 
-  static_assert(Kokkos::SpaceAccessibility<Kokkos::HIP,
-                                           Kokkos::HIPManagedSpace>::accessible,
-                "");
+  static_assert(
+      Kokkos::SpaceAccessibility<Kokkos::HIP,
+                                 Kokkos::HIPManagedSpace>::accessible);
 
+#if !defined(KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY)
   static_assert(!Kokkos::SpaceAccessibility<Kokkos::HostSpace,
-                                            Kokkos::HIPSpace>::accessible,
-                "");
+                                            Kokkos::HIPSpace>::accessible);
+#else
+  static_assert(Kokkos::SpaceAccessibility<Kokkos::HostSpace,
+                                           Kokkos::HIPSpace>::accessible);
+#endif
 
   static_assert(
       Kokkos::SpaceAccessibility<Kokkos::HostSpace,
-                                 Kokkos::HIPHostPinnedSpace>::accessible,
-      "");
+                                 Kokkos::HIPHostPinnedSpace>::accessible);
 
-  static_assert(Kokkos::SpaceAccessibility<Kokkos::HostSpace,
-                                           Kokkos::HIPManagedSpace>::accessible,
-                "");
+  static_assert(
+      Kokkos::SpaceAccessibility<Kokkos::HostSpace,
+                                 Kokkos::HIPManagedSpace>::accessible);
 
+#if !defined(KOKKOS_ENABLE_IMPL_HIP_UNIFIED_MEMORY)
+  static_assert(std::is_same<Kokkos::Impl::HostMirror<Kokkos::HIPSpace>::Space,
+                             Kokkos::HostSpace>::value);
+#else
   static_assert(std::is_same<Kokkos::Impl::HostMirror<Kokkos::HIPSpace>::Space,
-                             Kokkos::HostSpace>::value,
-                "");
+                             Kokkos::Device<Kokkos::HostSpace::execution_space,
+                                            Kokkos::HIPSpace>>::value);
+#endif
 
   static_assert(
       std::is_same<Kokkos::Impl::HostMirror<Kokkos::HIPHostPinnedSpace>::Space,
-                   Kokkos::HIPHostPinnedSpace>::value,
-      "");
+                   Kokkos::HIPHostPinnedSpace>::value);
 
   static_assert(
       std::is_same<Kokkos::Impl::HostMirror<Kokkos::HIPManagedSpace>::Space,
                    Kokkos::Device<Kokkos::HostSpace::execution_space,
-                                  Kokkos::HIPManagedSpace>>::value,
-      "");
+                                  Kokkos::HIPManagedSpace>>::value);
 
   static_assert(
       Kokkos::SpaceAccessibility<Kokkos::Impl::HostMirror<Kokkos::HIP>::Space,
-                                 Kokkos::HostSpace>::accessible,
-      "");
+                                 Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<Kokkos::HIPSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<Kokkos::HIPSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<Kokkos::HIPHostPinnedSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<Kokkos::HIPHostPinnedSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<Kokkos::HIPManagedSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<Kokkos::HIPManagedSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 }
 
 template <class MemSpace, class ExecSpace>
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstances.cpp b/core/unit_test/hpx/TestHPX_IndependentInstances.cpp
index 7ca48afeff..b36f56501b 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstances.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstances.cpp
@@ -18,7 +18,7 @@
 #include <TestHPX_Category.hpp>
 
 #include <hpx/config.hpp>
-#include <hpx/local/future.hpp>
+#include <hpx/future.hpp>
 
 #ifndef HPX_COMPUTE_DEVICE_CODE
 
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp b/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
index 3759d85438..dc6b5d7afb 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstancesDelayedExecution.cpp
@@ -17,7 +17,7 @@
 #include <Kokkos_Core.hpp>
 #include <TestHPX_Category.hpp>
 
-#include <hpx/local/execution.hpp>
+#include <hpx/execution.hpp>
 
 namespace {
 
diff --git a/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp b/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp
index 2c9b50f049..9059a1d9ea 100644
--- a/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp
+++ b/core/unit_test/hpx/TestHPX_IndependentInstancesInstanceIds.cpp
@@ -17,7 +17,7 @@
 #include <Kokkos_Core.hpp>
 #include <TestHPX_Category.hpp>
 
-#include <hpx/local/execution.hpp>
+#include <hpx/execution.hpp>
 
 namespace {
 
diff --git a/core/unit_test/incremental/Test01_execspace.hpp b/core/unit_test/incremental/Test01_execspace.hpp
index 25c7138ed3..a7fa26c728 100644
--- a/core/unit_test/incremental/Test01_execspace.hpp
+++ b/core/unit_test/incremental/Test01_execspace.hpp
@@ -62,8 +62,12 @@ struct TestIncrExecSpace {
     auto concurrency = ExecSpace().concurrency();
     ASSERT_GT(concurrency, 0);
 
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+    KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
     int in_parallel = ExecSpace::in_parallel();
+    KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP()
     ASSERT_FALSE(in_parallel);
+#endif
 
     const char* name = ExecSpace::name();
     std::cout << name << std::endl;
diff --git a/core/unit_test/openmp/TestOpenMP_Graph.cpp b/core/unit_test/openmp/TestOpenMP_Graph.cpp
deleted file mode 100644
index 22c8ab1bf8..0000000000
--- a/core/unit_test/openmp/TestOpenMP_Graph.cpp
+++ /dev/null
@@ -1,18 +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 <TestOpenMP_Category.hpp>
-#include <TestGraph.hpp>
diff --git a/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp b/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp
deleted file mode 100644
index 92b8032bf0..0000000000
--- a/core/unit_test/openmp/TestOpenMP_PartitionMaster.cpp
+++ /dev/null
@@ -1,105 +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 <TestOpenMP_Category.hpp>
-#include <Kokkos_Core.hpp>
-
-#include <mutex>
-
-namespace Test {
-
-#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_3
-TEST(openmp, partition_master) {
-  using Mutex = Kokkos::Experimental::MasterLock<Kokkos::OpenMP>;
-
-  Mutex mtx;
-  int errors = 0;
-
-  auto master = [&errors, &mtx](int /*partition_id*/, int /*num_partitions*/) {
-    const int pool_size = Kokkos::OpenMP().impl_thread_pool_size();
-
-    {
-      std::unique_lock<Mutex> lock(mtx);
-      if (Kokkos::OpenMP::in_parallel()) {
-        ++errors;
-      }
-      if (Kokkos::OpenMP::impl_thread_pool_rank() != 0) {
-        ++errors;
-      }
-    }
-
-    {
-      int local_errors = 0;
-      Kokkos::parallel_reduce(
-          Kokkos::RangePolicy<Kokkos::OpenMP>(0, 1000),
-          [pool_size](const int, int& errs) {
-            if (Kokkos::OpenMP().impl_thread_pool_size() != pool_size) {
-              ++errs;
-            }
-          },
-          local_errors);
-      Kokkos::atomic_add(&errors, local_errors);
-    }
-
-    Kokkos::Experimental::UniqueToken<Kokkos::OpenMP> token;
-
-    Kokkos::View<int*, Kokkos::OpenMP> count("", token.size());
-
-    Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::OpenMP>(0, 1000),
-                         [=](const int) {
-                           int i = token.acquire();
-                           ++count[i];
-                           token.release(i);
-                         });
-
-    Kokkos::View<int, Kokkos::OpenMP> sum("");
-    Kokkos::parallel_for(
-        Kokkos::RangePolicy<Kokkos::OpenMP>(0, token.size()),
-        [=](const int i) { Kokkos::atomic_add(sum.data(), count[i]); });
-
-    if (sum() != 1000) {
-      Kokkos::atomic_add(&errors, 1);
-    }
-  };
-
-  master(0, 1);
-
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master);
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master, 4, 0);
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master, 0, 4);
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master, 2, 2);
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master, 8, 0);
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master, 0, 8);
-  ASSERT_EQ(errors, 0);
-
-  Kokkos::OpenMP::partition_master(master, 8, 8);
-  ASSERT_EQ(errors, 0);
-}
-#endif
-
-}  // namespace Test
diff --git a/core/unit_test/serial/TestSerial_Graph.cpp b/core/unit_test/serial/TestSerial_Graph.cpp
deleted file mode 100644
index bff64d83e2..0000000000
--- a/core/unit_test/serial/TestSerial_Graph.cpp
+++ /dev/null
@@ -1,18 +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 <TestSerial_Category.hpp>
-#include <TestGraph.hpp>
diff --git a/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp b/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp
index 4b2530316d..8b6f08c14a 100644
--- a/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp
+++ b/core/unit_test/sycl/TestSYCL_InterOp_Init.cpp
@@ -29,7 +29,8 @@ TEST(sycl, raw_sycl_interop) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::queue queue(default_context, sycl::default_selector_v);
+  sycl::queue queue(default_context, sycl::default_selector_v,
+                    sycl::property::queue::in_order());
   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 bbd3d2af94..4811fb6d97 100644
--- a/core/unit_test/sycl/TestSYCL_InterOp_Init_Context.cpp
+++ b/core/unit_test/sycl/TestSYCL_InterOp_Init_Context.cpp
@@ -27,7 +27,8 @@ TEST(sycl, raw_sycl_interop_context_1) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::queue queue(default_context, sycl::default_selector_v);
+  sycl::queue queue(default_context, sycl::default_selector_v,
+                    sycl::property::queue::in_order());
   constexpr int n = 100;
   int* p          = sycl::malloc_device<int>(n, queue);
 
@@ -60,7 +61,8 @@ TEST(sycl, raw_sycl_interop_context_2) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::queue queue(default_context, sycl::default_selector_v);
+  sycl::queue queue(default_context, sycl::default_selector_v,
+                    sycl::property::queue::in_order());
   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 0cfaab8813..c0070adb0c 100644
--- a/core/unit_test/sycl/TestSYCL_InterOp_Streams.cpp
+++ b/core/unit_test/sycl/TestSYCL_InterOp_Streams.cpp
@@ -25,7 +25,8 @@ TEST(sycl, raw_sycl_queues) {
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::queue queue(default_context, sycl::default_selector_v);
+  sycl::queue queue(default_context, sycl::default_selector_v,
+                    sycl::property::queue::in_order());
   int* p            = sycl::malloc_device<int>(100, queue);
   using MemorySpace = typename TEST_EXECSPACE::memory_space;
 
diff --git a/core/unit_test/sycl/TestSYCL_InterOp_StreamsMultiGPU.cpp b/core/unit_test/sycl/TestSYCL_InterOp_StreamsMultiGPU.cpp
new file mode 100644
index 0000000000..d3906e409f
--- /dev/null
+++ b/core/unit_test/sycl/TestSYCL_InterOp_StreamsMultiGPU.cpp
@@ -0,0 +1,64 @@
+//@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 <TestSYCL_Category.hpp>
+#include <TestMultiGPU.hpp>
+
+namespace {
+
+std::array<TEST_EXECSPACE, 2> get_execution_spaces() {
+  std::vector<sycl::device> gpu_devices =
+      sycl::device::get_devices(sycl::info::device_type::gpu);
+
+  TEST_EXECSPACE exec0(
+      sycl::queue{gpu_devices.front(), sycl::property::queue::in_order()});
+  TEST_EXECSPACE exec1(
+      sycl::queue{gpu_devices.back(), sycl::property::queue::in_order()});
+
+  return {exec0, exec1};
+}
+
+TEST(sycl_multi_gpu, managed_views) {
+  std::array<TEST_EXECSPACE, 2> execs = get_execution_spaces();
+
+  Kokkos::View<int *, TEST_EXECSPACE> view0(Kokkos::view_alloc("v0", execs[0]),
+                                            100);
+  Kokkos::View<int *, TEST_EXECSPACE> view(Kokkos::view_alloc("v", execs[1]),
+                                           100);
+
+  test_policies(execs[0], view0, execs[1], view);
+}
+
+TEST(sycl_multi_gpu, unmanaged_views) {
+  std::array<TEST_EXECSPACE, 2> execs = get_execution_spaces();
+
+  int *p0 = sycl::malloc_device<int>(100, execs[0].sycl_queue());
+  Kokkos::View<int *, TEST_EXECSPACE> view0(p0, 100);
+
+  int *p1 = sycl::malloc_device<int>(100, execs[1].sycl_queue());
+  Kokkos::View<int *, TEST_EXECSPACE> view1(p1, 100);
+
+  test_policies(execs[0], view0, execs[1], view1);
+  sycl::free(p0, execs[0].sycl_queue());
+  sycl::free(p1, execs[1].sycl_queue());
+}
+
+TEST(sycl_multi_gpu, scratch_space) {
+  std::array<TEST_EXECSPACE, 2> execs = get_execution_spaces();
+
+  test_scratch(execs[0], execs[1]);
+}
+}  // namespace
diff --git a/core/unit_test/sycl/TestSYCL_Spaces.cpp b/core/unit_test/sycl/TestSYCL_Spaces.cpp
index 914f843248..a4fd053e83 100644
--- a/core/unit_test/sycl/TestSYCL_Spaces.cpp
+++ b/core/unit_test/sycl/TestSYCL_Spaces.cpp
@@ -21,235 +21,192 @@ namespace Test {
 
 TEST(sycl, space_access) {
   static_assert(Kokkos::Impl::MemorySpaceAccess<Kokkos::HostSpace,
-                                                Kokkos::HostSpace>::assignable,
-                "");
+                                                Kokkos::HostSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::assignable,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::assignable,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::accessible,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLDeviceUSMSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLDeviceUSMSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLDeviceUSMSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLDeviceUSMSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLDeviceUSMSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLDeviceUSMSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLDeviceUSMSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCLDeviceUSMSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::accessible);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                                       Kokkos::HostSpace>::assignable,
-      "");
+                                       Kokkos::HostSpace>::assignable);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLDeviceUSMSpace,
-                                       Kokkos::HostSpace>::accessible,
-      "");
+                                       Kokkos::HostSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLSharedUSMSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLSharedUSMSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLSharedUSMSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLSharedUSMSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLSharedUSMSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCLSharedUSMSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLSharedUSMSpace,
-                                       Kokkos::HostSpace>::assignable,
-      "");
+                                       Kokkos::HostSpace>::assignable);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLSharedUSMSpace,
-                                       Kokkos::HostSpace>::accessible,
-      "");
+                                       Kokkos::HostSpace>::accessible);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLSharedUSMSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLSharedUSMSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLSharedUSMSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCLSharedUSMSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLHostUSMSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLHostUSMSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::assignable);
 
   static_assert(
       !Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLHostUSMSpace,
-                                       Kokkos::HostSpace>::assignable,
-      "");
+                                       Kokkos::HostSpace>::assignable);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLHostUSMSpace,
-                                      Kokkos::HostSpace>::accessible,
-      "");
+                                      Kokkos::HostSpace>::accessible);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLHostUSMSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLHostUSMSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::assignable);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLHostUSMSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCLHostUSMSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible);
 
   static_assert(!Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLHostUSMSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::assignable,
-                "");
+                Kokkos::Experimental::SYCLHostUSMSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::assignable);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::Experimental::SYCLHostUSMSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCLHostUSMSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::accessible);
 
   //--------------------------------------
 
   static_assert(!Kokkos::SpaceAccessibility<Kokkos::Experimental::SYCL,
-                                            Kokkos::HostSpace>::accessible,
-                "");
+                                            Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Experimental::SYCL,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCL,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Experimental::SYCL,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCL,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Experimental::SYCL,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::accessible,
-                "");
+                Kokkos::Experimental::SYCL,
+                Kokkos::Experimental::SYCLHostUSMSpace>::accessible);
 
   static_assert(!Kokkos::SpaceAccessibility<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLDeviceUSMSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLSharedUSMSpace>::accessible,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLSharedUSMSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::accessible,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::accessible);
 
   static_assert(
       std::is_same<Kokkos::Impl::HostMirror<
                        Kokkos::Experimental::SYCLDeviceUSMSpace>::Space,
-                   Kokkos::HostSpace>::value,
-      "");
+                   Kokkos::HostSpace>::value);
 
   static_assert(
       std::is_same<
           Kokkos::Impl::HostMirror<
               Kokkos::Experimental::SYCLSharedUSMSpace>::Space,
           Kokkos::Device<Kokkos::HostSpace::execution_space,
-                         Kokkos::Experimental::SYCLSharedUSMSpace>>::value,
-      "");
+                         Kokkos::Experimental::SYCLSharedUSMSpace>>::value);
 
   static_assert(
       Kokkos::Impl::MemorySpaceAccess<Kokkos::Experimental::SYCLHostUSMSpace,
-                                      Kokkos::HostSpace>::accessible,
-      "");
+                                      Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::Impl::MemorySpaceAccess<
-                    Kokkos::HostSpace,
-                    Kokkos::Experimental::SYCLHostUSMSpace>::accessible,
-                "");
+                Kokkos::HostSpace,
+                Kokkos::Experimental::SYCLHostUSMSpace>::accessible);
 
   static_assert(std::is_same<Kokkos::Impl::HostMirror<
                                  Kokkos::Experimental::SYCLHostUSMSpace>::Space,
-                             Kokkos::Experimental::SYCLHostUSMSpace>::value,
-                "");
+                             Kokkos::Experimental::SYCLHostUSMSpace>::value);
 
   static_assert(
       std::is_same<
           Kokkos::Device<Kokkos::HostSpace::execution_space,
                          Kokkos::Experimental::SYCLSharedUSMSpace>,
           Kokkos::Device<Kokkos::HostSpace::execution_space,
-                         Kokkos::Experimental::SYCLSharedUSMSpace>>::value,
-      "");
+                         Kokkos::Experimental::SYCLSharedUSMSpace>>::value);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<Kokkos::Experimental::SYCL>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<Kokkos::Experimental::SYCL>::Space,
+                Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<
-                        Kokkos::Experimental::SYCLDeviceUSMSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<
+                    Kokkos::Experimental::SYCLDeviceUSMSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<
-                        Kokkos::Experimental::SYCLSharedUSMSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<
+                    Kokkos::Experimental::SYCLSharedUSMSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 
   static_assert(Kokkos::SpaceAccessibility<
-                    Kokkos::Impl::HostMirror<
-                        Kokkos::Experimental::SYCLHostUSMSpace>::Space,
-                    Kokkos::HostSpace>::accessible,
-                "");
+                Kokkos::Impl::HostMirror<
+                    Kokkos::Experimental::SYCLHostUSMSpace>::Space,
+                Kokkos::HostSpace>::accessible);
 }
 
 TEST(sycl, uvm) {
diff --git a/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp b/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp
index d7ed93d49e..9ab89df977 100644
--- a/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp
+++ b/core/unit_test/sycl/TestSYCL_TeamScratchStreams.cpp
@@ -76,12 +76,14 @@ void sycl_queue_scratch_test(
   Kokkos::Experimental::SYCL default_space;
   sycl::context default_context = default_space.sycl_queue().get_context();
 
-  sycl::queue queue(default_context, sycl::default_selector_v);
+  sycl::queue queue(default_context, sycl::default_selector_v,
+                    sycl::property::queue::in_order());
 
   std::array<Kokkos::Experimental::SYCL, K> sycl;
   for (int i = 0; i < K; i++) {
     sycl[i] = Kokkos::Experimental::SYCL(
-        sycl::queue(default_context, sycl::default_selector_v));
+        sycl::queue(default_context, sycl::default_selector_v,
+                    sycl::property::queue::in_order()));
   }
 
   // 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 3c85f661aa..946169a786 100644
--- a/core/unit_test/tools/TestEventCorrectness.hpp
+++ b/core/unit_test/tools/TestEventCorrectness.hpp
@@ -409,14 +409,19 @@ TEST(kokkosp, parallel_scan_no_fence) {
         << "skipping since the OpenMPTarget backend has unexpected fences";
 #endif
 
+  // Execute the parallel_scan first without looking for fence events.
+  // Depending on the backend implementation and the order of tests,
+  // it might be that the first call to parallel_scan is reallocating scratch
+  // memory which implies a fence when deallocating. We are not interested in
+  // detecting this event.
+  TestScanFunctor tf;
+  Kokkos::parallel_scan("dogs", Kokkos::RangePolicy<>(0, 1), tf);
+
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableKernels(),
                      Config::EnableFences());
   auto success = validate_absence(
-      [=]() {
-        TestScanFunctor tf;
-        Kokkos::parallel_scan("dogs", Kokkos::RangePolicy<>(0, 1), tf);
-      },
+      [=]() { Kokkos::parallel_scan("dogs", Kokkos::RangePolicy<>(0, 1), tf); },
       [=](BeginFenceEvent begin_event) {
         if (begin_event.name.find("Debug Only Check for Execution Error") !=
                 std::string::npos ||
@@ -450,13 +455,20 @@ TEST(kokkosp, parallel_scan_no_fence_view) {
         << "skipping since the OpenMPTarget backend has unexpected fences";
 #endif
 
+  // Execute the parallel_scan first without looking for fence events.
+  // Depending on the backend implementation and the order of tests,
+  // it might be that the first call to parallel_scan is reallocating scratch
+  // memory which implies a fence when deallocating. We are not interested in
+  // detecting this event.
+  TestScanFunctor tf;
+  Kokkos::View<typename TestScanFunctor::value_type> v("scan_result");
+  Kokkos::parallel_scan("dogs", Kokkos::RangePolicy<>(0, 1), tf, v);
+
   using namespace Kokkos::Test::Tools;
   listen_tool_events(Config::DisableAll(), Config::EnableKernels(),
                      Config::EnableFences());
-  Kokkos::View<typename TestScanFunctor::value_type> v("scan_result");
   auto success = validate_absence(
       [=]() {
-        TestScanFunctor tf;
         Kokkos::parallel_scan("dogs", Kokkos::RangePolicy<>(0, 1), tf, v);
       },
       [=](BeginFenceEvent begin_event) {
diff --git a/core/unit_test/tools/TestLogicalSpaces.hpp b/core/unit_test/tools/TestLogicalSpaces.hpp
deleted file mode 100644
index 4e56f8996a..0000000000
--- a/core/unit_test/tools/TestLogicalSpaces.hpp
+++ /dev/null
@@ -1,177 +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 <iostream>
-#include <gtest/gtest.h>
-#include "Kokkos_Core.hpp"
-
-#include <impl/Kokkos_Stacktrace.hpp>
-
-namespace Test {
-
-void debug_print(const Kokkos_Profiling_SpaceHandle hand, const char* name,
-                 const void* ptr, const size_t size) {
-  std::cout << "Alloc: " << hand.name << ", [" << name << "," << ptr << "] "
-            << size << std::endl;
-}
-void debug_dealloc(const Kokkos_Profiling_SpaceHandle hand, const char* name,
-                   const void* ptr, const size_t size) {
-  std::cout << "Dealloc: " << hand.name << ", [" << name << "," << ptr << "] "
-            << size << std::endl;
-}
-
-void fail_on_event(const Kokkos::Profiling::SpaceHandle, const char*,
-                   const void*, const uint64_t) {
-  ASSERT_TRUE(false) << "Unexpected memory event";
-}
-
-void expect_no_events() {
-  Kokkos::Tools::Experimental::set_allocate_data_callback(&fail_on_event);
-  Kokkos::Tools::Experimental::set_deallocate_data_callback(&fail_on_event);
-}
-
-std::string expected_view_name;
-std::string expected_space_name;
-std::string error_message;
-void expect_allocation_event(const std::string evn, const std::string esn,
-                             const std::string em) {
-  expected_view_name  = evn;
-  expected_space_name = esn;
-  error_message       = em;
-  Kokkos::Tools::Experimental::set_allocate_data_callback(
-      [](const Kokkos_Profiling_SpaceHandle hand, const char* name, const void*,
-         const uint64_t) {
-        ASSERT_EQ(std::string(hand.name), expected_space_name)
-            << error_message << " (bad handle)";
-        ASSERT_EQ(std::string(name), expected_view_name)
-            << error_message << " (bad view name)";
-        expect_no_events();
-      });
-}
-void expect_deallocation_event(const std::string& evn, const std::string& esn,
-                               const std::string em) {
-  expected_view_name  = evn;
-  expected_space_name = esn;
-  error_message       = em;
-  Kokkos::Tools::Experimental::set_deallocate_data_callback(
-      [](const Kokkos_Profiling_SpaceHandle hand, const char* name, const void*,
-         const uint64_t) {
-        ASSERT_EQ(std::string(hand.name), expected_space_name)
-            << error_message << " (bad handle)";
-        ASSERT_EQ(std::string(name), expected_view_name)
-            << error_message << " (bad view name)";
-        expect_no_events();
-      });
-}
-
-struct TestSpaceNamer {
-  static constexpr const char* get_name() { return "TestSpace"; }
-};
-struct TestSpaceNamerTwo {
-  static constexpr const char* get_name() { return "YoDawg"; }
-};
-struct TestSpaceNamerThree {
-  static constexpr const char* get_name() { return "CustomAccessSpace"; }
-};
-using fake_memory_space = Kokkos::Experimental::LogicalMemorySpace<
-    Kokkos::HostSpace, Kokkos::DefaultHostExecutionSpace, TestSpaceNamer,
-    Kokkos::Experimental::LogicalSpaceSharesAccess::shared_access>;
-
-void test_view_construct() {
-  {
-    expect_allocation_event("puppy_view", "TestSpace", "View allocation");
-    Kokkos::View<double*, fake_memory_space> pup_view("puppy_view", 1000);
-    expect_deallocation_event("puppy_view", "TestSpace", "View free");
-  }
-  Kokkos::Tools::Experimental::pause_tools();
-}
-void test_malloc_free() {
-  expect_allocation_event("does_malloc_work", "TestSpace",
-                          "Error in malloc event");
-  auto* temp =
-      Kokkos::kokkos_malloc<fake_memory_space>("does_malloc_work", 1000);
-  expect_deallocation_event("does_malloc_work", "TestSpace", "Error in free");
-  Kokkos::kokkos_free<fake_memory_space>(temp);
-  Kokkos::Tools::Experimental::pause_tools();
-}
-void test_chained_spaces() {
-  using doubly_fake_memory_space = Kokkos::Experimental::LogicalMemorySpace<
-      fake_memory_space, Kokkos::DefaultHostExecutionSpace, TestSpaceNamerTwo,
-      Kokkos::Experimental::LogicalSpaceSharesAccess::shared_access>;
-  {
-    expect_allocation_event("xzibit_dot_jpeg", "YoDawg",
-                            "Chained space view allocation");
-    Kokkos::View<double*, doubly_fake_memory_space> pup_view("xzibit_dot_jpeg",
-                                                             1000);
-    expect_deallocation_event("xzibit_dot_jpeg", "YoDawg",
-                              "Chained space free");
-  }
-  Kokkos::Tools::Experimental::pause_tools();
-}
-void test_space_allocations() {
-  fake_memory_space debug_space;
-  expect_allocation_event("allocation_from_space", "TestSpace",
-                          "Space allocation");
-  auto* temp = debug_space.allocate("allocation_from_space", 1000);
-  expect_deallocation_event("allocation_from_space", "TestSpace",
-                            "Space deallocation");
-  debug_space.deallocate("allocation_from_space", temp, 1000);
-  Kokkos::Tools::Experimental::pause_tools();
-}
-template <typename Space>
-struct AccessCheckKernel {
-  Kokkos::View<double*, Space> data;
-  KOKKOS_FUNCTION void operator()(const int i) const { data[i] = i; }
-};
-
-template <typename Space>
-void test_allowed_access() {
-  constexpr const int data_size = 1000;
-  // We use an unmananged View here since we want to detect a memory access
-  // violation in the parallel_for and not in the initialization of the View.
-  std::vector<double> test_data(data_size);
-  Kokkos::View<double*, Space> test_view(test_data.data(), data_size);
-  AccessCheckKernel<Space> functor{test_view};
-  Kokkos::parallel_for(
-      "access_allowed",
-      Kokkos::RangePolicy<typename Space::execution_space>(0, data_size),
-      functor);
-  Kokkos::fence();
-}
-
-using semantically_independent_logical_space =
-    Kokkos::Experimental::LogicalMemorySpace<
-        Kokkos::HostSpace, Kokkos::DefaultHostExecutionSpace,
-        TestSpaceNamerThree,
-        Kokkos::Experimental::LogicalSpaceSharesAccess::no_shared_access>;
-
-TEST(defaultdevicetype, logical_space_views) { test_view_construct(); }
-TEST(defaultdevicetype, logical_space_malloc) { test_malloc_free(); }
-TEST(defaultdevicetype, logical_space_alloc) { test_space_allocations(); }
-TEST(defaultdevicetype, chained_logical_spaces) { test_chained_spaces(); }
-TEST(defaultdevicetype, access_allowed) {
-  test_allowed_access<fake_memory_space>();
-}
-// FIXME_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(
-      { test_allowed_access<semantically_independent_logical_space>(); },
-      "Kokkos::View ERROR: attempt to access inaccessible memory space");
-}
-#endif
-
-}  // namespace Test
diff --git a/core/unit_test/tools/TestProfilingSection.cpp b/core/unit_test/tools/TestProfilingSection.cpp
index 318766ac45..9d35d67feb 100644
--- a/core/unit_test/tools/TestProfilingSection.cpp
+++ b/core/unit_test/tools/TestProfilingSection.cpp
@@ -108,8 +108,8 @@ TEST(defaultdevicetype, profiling_section) {
 }
 
 using Kokkos::Profiling::ProfilingSection;
-static_assert(!std::is_default_constructible<ProfilingSection>::value, "");
-static_assert(!std::is_copy_constructible<ProfilingSection>::value, "");
-static_assert(!std::is_move_constructible<ProfilingSection>::value, "");
-static_assert(!std::is_copy_assignable<ProfilingSection>::value, "");
-static_assert(!std::is_move_assignable<ProfilingSection>::value, "");
+static_assert(!std::is_default_constructible<ProfilingSection>::value);
+static_assert(!std::is_copy_constructible<ProfilingSection>::value);
+static_assert(!std::is_move_constructible<ProfilingSection>::value);
+static_assert(!std::is_copy_assignable<ProfilingSection>::value);
+static_assert(!std::is_move_assignable<ProfilingSection>::value);
diff --git a/core/unit_test/view/TestExtentsDatatypeConversion.cpp b/core/unit_test/view/TestExtentsDatatypeConversion.cpp
index a48052ab8a..1b9b2a3681 100644
--- a/core/unit_test/view/TestExtentsDatatypeConversion.cpp
+++ b/core/unit_test/view/TestExtentsDatatypeConversion.cpp
@@ -23,67 +23,59 @@ namespace {
 
 // Helper to make static tests more succinct
 template <typename DataType, typename Extent>
-constexpr bool datatype_matches_extent =
-    std::is_same_v<typename Kokkos::Experimental::Impl::ExtentsFromDataType<
-                       std::size_t, DataType>::type,
-                   Extent>;
+constexpr bool datatype_matches_extent = std::is_same_v<
+    typename Kokkos::Impl::ExtentsFromDataType<std::size_t, DataType>::type,
+    Extent>;
 
 template <typename DataType, typename BaseType, typename Extents>
 constexpr bool extent_matches_datatype =
-    std::is_same_v<DataType, typename Kokkos::Experimental::Impl::
-                                 DataTypeFromExtents<BaseType, Extents>::type>;
+    std::is_same_v<DataType, typename Kokkos::Impl::DataTypeFromExtents<
+                                 BaseType, Extents>::type>;
 
 // Conversion from DataType to extents
 // 0-rank view
-static_assert(
-    datatype_matches_extent<double, std::experimental::extents<std::size_t>>);
+static_assert(datatype_matches_extent<double, Kokkos::extents<std::size_t>>);
 
 // Only dynamic
 static_assert(datatype_matches_extent<
-              double***, std::experimental::extents<
-                             std::size_t, std::experimental::dynamic_extent,
-                             std::experimental::dynamic_extent,
-                             std::experimental::dynamic_extent>>);
+              double***,
+              Kokkos::extents<std::size_t, Kokkos::dynamic_extent,
+                              Kokkos::dynamic_extent, Kokkos::dynamic_extent>>);
 // Only static
-static_assert(datatype_matches_extent<
-              double[2][3][17],
-              std::experimental::extents<std::size_t, std::size_t{2},
-                                         std::size_t{3}, std::size_t{17}>>);
+static_assert(
+    datatype_matches_extent<double[2][3][17],
+                            Kokkos::extents<std::size_t, std::size_t{2},
+                                            std::size_t{3}, std::size_t{17}>>);
 
 // Both dynamic and static
 static_assert(datatype_matches_extent<
               double* * [3][2][8],
-              std::experimental::extents<
-                  std::size_t, std::experimental::dynamic_extent,
-                  std::experimental::dynamic_extent, std::size_t{3},
-                  std::size_t{2}, std::size_t{8}>>);
+              Kokkos::extents<std::size_t, Kokkos::dynamic_extent,
+                              Kokkos::dynamic_extent, std::size_t{3},
+                              std::size_t{2}, std::size_t{8}>>);
 
 // Conversion from extents to DataType
 // 0-rank extents
-static_assert(extent_matches_datatype<double, double,
-                                      std::experimental::extents<std::size_t>>);
+static_assert(
+    extent_matches_datatype<double, double, Kokkos::extents<std::size_t>>);
 
 // only dynamic
-static_assert(
-    extent_matches_datatype<double****, double,
-                            std::experimental::extents<
-                                std::size_t, std::experimental::dynamic_extent,
-                                std::experimental::dynamic_extent,
-                                std::experimental::dynamic_extent,
-                                std::experimental::dynamic_extent>>);
+static_assert(extent_matches_datatype<
+              double****, double,
+              Kokkos::extents<std::size_t, Kokkos::dynamic_extent,
+                              Kokkos::dynamic_extent, Kokkos::dynamic_extent,
+                              Kokkos::dynamic_extent>>);
 
 // only static
-static_assert(
-    extent_matches_datatype<double[7][5][3], double,
-                            std::experimental::extents<std::size_t, 7, 5, 3>>);
+static_assert(extent_matches_datatype<double[7][5][3], double,
+                                      Kokkos::extents<std::size_t, 7, 5, 3>>);
 
 // both dynamic and static
 static_assert(
     extent_matches_datatype<double** * [20][45], double,
-                            std::experimental::extents<
-                                std::size_t, std::experimental::dynamic_extent,
-                                std::experimental::dynamic_extent,
-                                std::experimental::dynamic_extent, 20, 45>>);
+                            Kokkos::extents<std::size_t, Kokkos::dynamic_extent,
+                                            Kokkos::dynamic_extent,
+                                            Kokkos::dynamic_extent, 20, 45>>);
 }  // namespace
 
 #endif  // KOKKOS_ENABLE_IMPL_MDSPAN
diff --git a/example/README b/example/README
index 6686051244..2fe8727648 100644
--- a/example/README
+++ b/example/README
@@ -1,7 +1,7 @@
 This directory contains example application proxies that use different
 parts of Kokkos.  If you are looking for the FENL ("finite element
-nonlinear" solve) example, it has moved into the LinAlg subpackage of
-Tpetra.
+nonlinear" solve) example, it has moved into the TrilinosCouplings
+package in Trilinos.
 
 MANIFEST:
 
diff --git a/example/build_cmake_in_tree/cmake_example.cpp b/example/build_cmake_in_tree/cmake_example.cpp
index b345c48f53..2b9a263f87 100644
--- a/example/build_cmake_in_tree/cmake_example.cpp
+++ b/example/build_cmake_in_tree/cmake_example.cpp
@@ -15,7 +15,9 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
+
 #include <cstdio>
+#include <iostream>
 
 int main(int argc, char* argv[]) {
   Kokkos::initialize(argc, argv);
diff --git a/example/build_cmake_installed/CMakeLists.txt b/example/build_cmake_installed/CMakeLists.txt
index aaf745b418..c025f1d7d2 100644
--- a/example/build_cmake_installed/CMakeLists.txt
+++ b/example/build_cmake_installed/CMakeLists.txt
@@ -12,6 +12,7 @@ find_package(Kokkos REQUIRED)
 add_executable(example cmake_example.cpp foo.f)
 if(CMAKE_Fortran_COMPILER_ID STREQUAL LLVMFlang)
   set_target_properties(example PROPERTIES LINKER_LANGUAGE Fortran)
+  target_link_options(example PRIVATE -fno-fortran-main)
 endif()
 
 # This is the only thing required to set up compiler/linker flags
diff --git a/example/build_cmake_installed/cmake_example.cpp b/example/build_cmake_installed/cmake_example.cpp
index ca11250edd..ba50165979 100644
--- a/example/build_cmake_installed/cmake_example.cpp
+++ b/example/build_cmake_installed/cmake_example.cpp
@@ -15,7 +15,9 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
+
 #include <cstdio>
+#include <iostream>
 
 extern "C" void print_fortran_();
 
diff --git a/example/build_cmake_installed_different_compiler/foo.cpp b/example/build_cmake_installed_different_compiler/foo.cpp
index e17d34aab1..7630802ae9 100644
--- a/example/build_cmake_installed_different_compiler/foo.cpp
+++ b/example/build_cmake_installed_different_compiler/foo.cpp
@@ -15,7 +15,7 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
-#include <cstdio>
+#include <iostream>
 
 struct CountFunctor {
   KOKKOS_FUNCTION void operator()(const long i, long& lcount) const {
diff --git a/example/build_cmake_installed_kk_as_language/cmake_example.cpp b/example/build_cmake_installed_kk_as_language/cmake_example.cpp
index c7f24bd5ab..c71d75eeb8 100644
--- a/example/build_cmake_installed_kk_as_language/cmake_example.cpp
+++ b/example/build_cmake_installed_kk_as_language/cmake_example.cpp
@@ -15,7 +15,9 @@
 //@HEADER
 
 #include <Kokkos_Core.hpp>
+
 #include <cstdio>
+#include <iostream>
 
 extern "C" void print_fortran_();
 void print_cxx();
diff --git a/example/tutorial/01_hello_world/hello_world.cpp b/example/tutorial/01_hello_world/hello_world.cpp
index 5b8a21af83..3104003fb4 100644
--- a/example/tutorial/01_hello_world/hello_world.cpp
+++ b/example/tutorial/01_hello_world/hello_world.cpp
@@ -16,7 +16,6 @@
 
 #include <Kokkos_Core.hpp>
 #include <cstdio>
-#include <typeinfo>
 
 //
 // "Hello world" parallel_for example:
@@ -25,12 +24,12 @@
 //      using a functor to define the loop body
 //   3. Shut down Kokkos
 //
-// If Kokkos was built with C++11 enabled, try comparing this example
-// to 01_hello_world_lambda.  The latter uses C++11 lambdas (anonymous
-// functions) to define the loop body of the parallel_for.  That makes
-// the code much more concise and readable.  On the other hand,
-// breaking out the loop body into an explicit functor makes it easier
-// to test the loop independently of the parallel pattern.
+// Try comparing this example to 01_hello_world_lambda, which uses
+// C++11 lambdas (anonymous functions) to define the loop body of the
+// parallel_for.  That makes the code much more concise and readable.
+// On the other hand, breaking out the loop body into an explicit
+// functor makes it easier to test the loop independently of the
+// parallel pattern.
 //
 
 // Functor that defines the parallel_for's loop body.
@@ -58,12 +57,7 @@ struct hello_world {
   // is unnecessary but harmless.
   KOKKOS_INLINE_FUNCTION
   void operator()(const int i) const {
-    // FIXME_SYCL needs workaround for printf
-#ifndef __SYCL_DEVICE_ONLY__
-    printf("Hello from i = %i\n", i);
-#else
-    (void)i;
-#endif
+    Kokkos::printf("Hello from i = %i\n", i);
   }
 };
 
@@ -77,11 +71,9 @@ int main(int argc, char* argv[]) {
   // start with "--kokkos-".
   Kokkos::initialize(argc, argv);
 
-  // Print the name of Kokkos' default execution space.  We're using
-  // typeid here, so the name might get a bit mangled by the linker,
-  // but you should still be able to figure out what it is.
+  // Print the name of Kokkos' default execution space.
   printf("Hello World on Kokkos execution space %s\n",
-         typeid(Kokkos::DefaultExecutionSpace).name());
+         Kokkos::DefaultExecutionSpace::name());
 
   // Run the above functor on the default Kokkos execution space in
   // parallel, with a parallel for loop count of 15.
diff --git a/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp b/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp
index c78f307636..ad2c258c0f 100644
--- a/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp
+++ b/example/tutorial/01_hello_world_lambda/hello_world_lambda.cpp
@@ -16,7 +16,6 @@
 
 #include <Kokkos_Core.hpp>
 #include <cstdio>
-#include <typeinfo>
 
 //
 // "Hello world" parallel_for example:
@@ -25,10 +24,9 @@
 //      using a C++11 lambda to define the loop body
 //   3. Shut down Kokkos
 //
-// This example only builds if C++11 is enabled.  Compare this example
-// to 01_hello_world, which uses functors (explicitly defined classes)
-// to define the loop body of the parallel_for.  Both functors and
-// lambdas have their places.
+// Compare this example to 01_hello_world, which uses functors
+// (explicitly defined classes) to define the loop body of the
+// parallel_for. Both functors and lambdas have their places.
 //
 
 int main(int argc, char* argv[]) {
@@ -41,11 +39,9 @@ int main(int argc, char* argv[]) {
   // start with "--kokkos-".
   Kokkos::initialize(argc, argv);
 
-  // Print the name of Kokkos' default execution space.  We're using
-  // typeid here, so the name might get a bit mangled by the linker,
-  // but you should still be able to figure out what it is.
+  // Print the name of Kokkos' default execution space.
   printf("Hello World on Kokkos execution space %s\n",
-         typeid(Kokkos::DefaultExecutionSpace).name());
+         Kokkos::DefaultExecutionSpace::name());
 
   // Run lambda on the default Kokkos execution space in parallel,
   // with a parallel for loop count of 15.  The lambda's argument is
@@ -76,13 +72,9 @@ int main(int argc, char* argv[]) {
 #if defined(KOKKOS_ENABLE_CXX11_DISPATCH_LAMBDA)
   Kokkos::parallel_for(
       15, KOKKOS_LAMBDA(const int i) {
-  // FIXME_SYCL needs workaround for printf
-#ifndef __SYCL_DEVICE_ONLY__
-        // printf works in a CUDA parallel kernel; std::ostream does not.
-        printf("Hello from i = %i\n", i);
-#else
-	(void)i;
-#endif
+        // Kokko::printf works for all backends in a parallel kernel;
+        // std::ostream does not.
+        Kokkos::printf("Hello from i = %i\n", i);
       });
 #endif
   // You must call finalize() after you are done using Kokkos.
diff --git a/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp b/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp
index 5cae6da16c..1ca30e07e8 100644
--- a/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp
+++ b/example/tutorial/02_simple_reduce_lambda/simple_reduce_lambda.cpp
@@ -24,9 +24,8 @@
 //      using a C++11 lambda to define the loop body
 //   3. Shut down Kokkos
 //
-// This example only builds if C++11 is enabled.  Compare this example
-// to 02_simple_reduce, which uses a functor to define the loop body
-// of the parallel_reduce.
+// Compare this example to 02_simple_reduce, which uses a functor to
+// define the loop body of the parallel_reduce.
 //
 
 int main(int argc, char* argv[]) {
diff --git a/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp b/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp
index b041f8d435..ee3f4721d9 100644
--- a/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp
+++ b/example/tutorial/Hierarchical_Parallelism/01_thread_teams/thread_teams.cpp
@@ -47,13 +47,9 @@ struct hello_world {
     // The TeamPolicy<>::member_type provides functions to query the multi
     // dimensional index of a thread as well as the number of thread-teams and
     // the size of each team.
-#ifndef __SYCL_DEVICE_ONLY__
-    // FIXME_SYCL needs printf workaround
-    printf("Hello World: %i %i // %i %i\n", thread.league_rank(),
-           thread.team_rank(), thread.league_size(), thread.team_size());
-#else
-    (void)thread;
-#endif
+    Kokkos::printf("Hello World: %i %i // %i %i\n", thread.league_rank(),
+                   thread.team_rank(), thread.league_size(),
+                   thread.team_size());
   }
 };
 
diff --git a/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp b/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp
index 933b254f7c..1e6812adea 100644
--- a/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp
+++ b/example/tutorial/Hierarchical_Parallelism/01_thread_teams_lambda/thread_teams_lambda.cpp
@@ -57,16 +57,12 @@ int main(int narg, char* args[]) {
       policy,
       KOKKOS_LAMBDA(const team_member& thread, int& lsum) {
         lsum += 1;
-    // TeamPolicy<>::member_type provides functions to query the
-    // multidimensional index of a thread, as well as the number of
-    // thread teams and the size of each team.
-#ifndef __SYCL_DEVICE_ONLY__
-        // FIXME_SYCL needs workaround for printf
-        printf("Hello World: %i %i // %i %i\n", thread.league_rank(),
-               thread.team_rank(), thread.league_size(), thread.team_size());
-#else
-        (void)thread;
-#endif
+        // TeamPolicy<>::member_type provides functions to query the
+        // multidimensional index of a thread, as well as the number of
+        // thread teams and the size of each team.
+        Kokkos::printf("Hello World: %i %i // %i %i\n", thread.league_rank(),
+                       thread.team_rank(), thread.league_size(),
+                       thread.team_size());
       },
       sum);
 #endif
diff --git a/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp b/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp
index 398810d133..75d6089e9a 100644
--- a/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp
+++ b/example/tutorial/Hierarchical_Parallelism/02_nested_parallel_for/nested_parallel_for.cpp
@@ -43,16 +43,11 @@ struct hello_world {
     // the operator using a team_policy acts like a parallel region for the
     // team. That means that everything outside of the nested parallel_for is
     // also executed by all threads of the team.
-    Kokkos::parallel_for(Kokkos::TeamThreadRange(thread, 31),
-                         [&](const int& i) {
-#ifndef __SYCL_DEVICE_ONLY__
-                           // FIXME_SYCL needs printf workaround
-                           printf("Hello World: (%i , %i) executed loop %i \n",
-                                  thread.league_rank(), thread.team_rank(), i);
-#else
-			   (void) i;
-#endif
-                         });
+    Kokkos::parallel_for(
+        Kokkos::TeamThreadRange(thread, 31), [&](const int& i) {
+          Kokkos::printf("Hello World: (%i , %i) executed loop %i \n",
+                         thread.league_rank(), thread.team_rank(), i);
+        });
   }
 };
 
diff --git a/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp b/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp
index ae9430a93b..4a7a2cebe3 100644
--- a/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp
+++ b/example/tutorial/Hierarchical_Parallelism/03_vectorization/vectorization.cpp
@@ -56,7 +56,8 @@ struct SomeCorrelation {
 
     // With each team run a parallel_for with its threads
     Kokkos::parallel_for(
-        Kokkos::TeamThreadRange(thread, data.extent(1)), [=](const int& j) {
+        Kokkos::TeamThreadRange(thread, data.extent(1)),
+        [=, *this](const int& j) {
           int tsum;
           // Run a vector loop reduction over the inner dimension of data
           // Count how many values are multiples of 4
@@ -64,7 +65,7 @@ struct SomeCorrelation {
           // broadcast to all vector lanes
           Kokkos::parallel_reduce(
               Kokkos::ThreadVectorRange(thread, data.extent(2)),
-              [=](const int& k, int& vsum) {
+              [=, *this](const int& k, int& vsum) {
                 vsum += (data(i, j, k) % 4 == 0) ? 1 : 0;
               },
               tsum);
@@ -103,7 +104,7 @@ struct SomeCorrelation {
     // Add with one thread and vectorlane of the team the team_sum to the global
     // value
     Kokkos::single(Kokkos::PerTeam(thread),
-                   [=]() { Kokkos::atomic_add(&gsum(), team_sum); });
+                   [=, *this]() { Kokkos::atomic_add(&gsum(), team_sum); });
   }
 
   // The functor needs to define how much shared memory it requests given a
diff --git a/generate_makefile.bash b/generate_makefile.bash
index 018426c9b8..25370daa3f 100755
--- a/generate_makefile.bash
+++ b/generate_makefile.bash
@@ -157,23 +157,22 @@ display_help_text() {
       echo "                 ZEN2            = AMD Zen2-Core CPU"
       echo "                 ZEN3            = AMD Zen3-Core CPU"
       echo "               [AMD: GPU]"
-      echo "                 VEGA906         = AMD GPU MI50/MI60 GFX906"
-      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 "                 AMD_GFX906      = AMD GPU MI50/MI60 GFX906"
+      echo "                 AMD_GFX908      = AMD GPU MI100 GFX908"
+      echo "                 AMD_GFX90A      = AMD GPU MI200 GFX90A"
+      echo "                 AMD_GFX940      = AMD GPU MI300 GFX940"
+      echo "                 AMD_GFX942      = AMD GPU MI300 GFX942"
+      echo "                 AMD_GFX1030     = AMD GPU V620/W6800 GFX1030"
+      echo "                 AMD_GFX1100     = AMD GPU RX 7900 XT(X) GFX1100"
       echo "               [ARM]"
       echo "                 ARMV80          = ARMv8.0 Compatible CPU"
       echo "                 ARMV81          = ARMv8.1 Compatible CPU"
       echo "                 ARMV8_THUNDERX  = ARMv8 Cavium ThunderX CPU"
       echo "                 ARMV8_THUNDERX2 = ARMv8 Cavium ThunderX2 CPU"
       echo "               [IBM]"
-      echo "                 BGQ             = IBM Blue Gene Q"
-      echo "                 Power7          = IBM POWER7 and POWER7+ CPUs"
       echo "                 Power8          = IBM POWER8 CPUs"
       echo "                 Power9          = IBM POWER9 CPUs"
       echo "               [Intel]"
-      echo "                 WSM             = Intel Westmere CPUs"
       echo "                 SNB             = Intel Sandy/Ivy Bridge CPUs"
       echo "                 HSW             = Intel Haswell CPUs"
       echo "                 BDW             = Intel Broadwell Xeon E-class CPUs"
@@ -224,7 +223,6 @@ display_help_text() {
       echo "--with-gtest=/Path/To/Gtest:  Set path to gtest.  (Used in unit and performance"
       echo "                                tests.)"
       echo "--with-hwloc=/Path/To/Hwloc:  Set path to hwloc library."
-      echo "--with-memkind=/Path/To/MemKind:  Set path to memkind library."
       echo "--with-options=[OPT]:         Additional options to Kokkos:"
       echo "                                compiler_warnings"
       echo "                                aggressive_vectorization = add ivdep on loops"
@@ -340,10 +338,6 @@ do
       KOKKOS_HWLOC=ON
       HWLOC_PATH="${key#*=}"
       ;;
-    --with-memkind*)
-      KOKKOS_MEMKIND=ON
-      MEMKIND_PATH="${key#*=}"
-      ;;
     --arch*)
       KOKKOS_ARCH="${key#*=}"
       ;;
@@ -450,15 +444,6 @@ else
     KOKKOS_HWLOC_CMD=
 fi
 
-if [ "$KOKKOS_MEMKIND" == "ON" ]; then
-    KOKKOS_MEMKIND_CMD=-DKokkos_ENABLE_MEMKIND=ON
-    if [ "$MEMKIND_PATH" != "" ]; then
-      KOKKOS_MEMKIND_PATH_CMD=-DMEMKIND_ROOT=$MEMKIND_PATH
-    fi
-else
-    KOKKOS_MEMKIND_CMD=
-fi
-
 if [ ! -e ${KOKKOS_PATH}/CMakeLists.txt ]; then
    if [ "${KOKKOS_PATH}" == "" ]; then
       CM_SCRIPT=$0
@@ -504,5 +489,5 @@ if [[ ${COMPILER} == *clang* ]]; then
    fi
 fi
 
-echo cmake $COMPILER_CMD  -DCMAKE_CXX_FLAGS="${KOKKOS_CXXFLAGS}" -DCMAKE_EXE_LINKER_FLAGS="${KOKKOS_LDFLAGS}" -DCMAKE_INSTALL_PREFIX=${PREFIX} ${KOKKOS_DEVICE_CMD} ${KOKKOS_ARCH_CMD} -DKokkos_ENABLE_TESTS=${KOKKOS_DO_TESTS} -DKokkos_ENABLE_EXAMPLES=${KOKKOS_DO_EXAMPLES} ${KOKKOS_OPTION_CMD} ${KOKKOS_CUDA_OPTION_CMD} ${KOKKOS_HIP_OPTION_CMD} -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_CXX_EXTENSIONS=OFF ${STANDARD_CMD} ${KOKKOS_DEBUG_CMD} ${KOKKOS_BC_CMD} ${KOKKOS_HWLOC_CMD} ${KOKKOS_HWLOC_PATH_CMD} ${KOKKOS_MEMKIND_CMD} ${KOKKOS_MEMKIND_PATH_CMD} -DKokkos_ENABLE_DEPRECATION_WARNINGS=${KOKKOS_DEPRECATED_CODE_WARNINGS} -DKokkos_ENABLE_DEPRECATED_CODE_4=${KOKKOS_DEPRECATED_CODE} ${KOKKOS_PATH}
-cmake $COMPILER_CMD  -DCMAKE_CXX_FLAGS="${KOKKOS_CXXFLAGS//\"}" -DCMAKE_EXE_LINKER_FLAGS="${KOKKOS_LDFLAGS//\"}" -DCMAKE_INSTALL_PREFIX=${PREFIX} ${KOKKOS_DEVICE_CMD} ${KOKKOS_ARCH_CMD} -DKokkos_ENABLE_TESTS=${KOKKOS_DO_TESTS} -DKokkos_ENABLE_EXAMPLES=${KOKKOS_DO_EXAMPLES} ${KOKKOS_OPTION_CMD} ${KOKKOS_CUDA_OPTION_CMD} ${KOKKOS_HIP_OPTION_CMD} -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_CXX_EXTENSIONS=OFF ${STANDARD_CMD} ${KOKKOS_DEBUG_CMD} ${KOKKOS_BC_CMD} ${KOKKOS_HWLOC_CMD} ${KOKKOS_HWLOC_PATH_CMD} ${KOKKOS_MEMKIND_CMD} ${KOKKOS_MEMKIND_PATH_CMD} ${PASSTHRU_CMAKE_FLAGS} -DKokkos_ENABLE_DEPRECATION_WARNINGS=${KOKKOS_DEPRECATED_CODE_WARNINGS} -DKokkos_ENABLE_DEPRECATED_CODE_4=${KOKKOS_DEPRECATED_CODE} ${KOKKOS_PATH}
+echo cmake $COMPILER_CMD  -DCMAKE_CXX_FLAGS="${KOKKOS_CXXFLAGS}" -DCMAKE_EXE_LINKER_FLAGS="${KOKKOS_LDFLAGS}" -DCMAKE_INSTALL_PREFIX=${PREFIX} ${KOKKOS_DEVICE_CMD} ${KOKKOS_ARCH_CMD} -DKokkos_ENABLE_TESTS=${KOKKOS_DO_TESTS} -DKokkos_ENABLE_EXAMPLES=${KOKKOS_DO_EXAMPLES} ${KOKKOS_OPTION_CMD} ${KOKKOS_CUDA_OPTION_CMD} ${KOKKOS_HIP_OPTION_CMD} -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_CXX_EXTENSIONS=OFF ${STANDARD_CMD} ${KOKKOS_DEBUG_CMD} ${KOKKOS_BC_CMD} ${KOKKOS_HWLOC_CMD} ${KOKKOS_HWLOC_PATH_CMD} -DKokkos_ENABLE_DEPRECATION_WARNINGS=${KOKKOS_DEPRECATED_CODE_WARNINGS} -DKokkos_ENABLE_DEPRECATED_CODE_4=${KOKKOS_DEPRECATED_CODE} ${KOKKOS_PATH}
+cmake $COMPILER_CMD  -DCMAKE_CXX_FLAGS="${KOKKOS_CXXFLAGS//\"}" -DCMAKE_EXE_LINKER_FLAGS="${KOKKOS_LDFLAGS//\"}" -DCMAKE_INSTALL_PREFIX=${PREFIX} ${KOKKOS_DEVICE_CMD} ${KOKKOS_ARCH_CMD} -DKokkos_ENABLE_TESTS=${KOKKOS_DO_TESTS} -DKokkos_ENABLE_EXAMPLES=${KOKKOS_DO_EXAMPLES} ${KOKKOS_OPTION_CMD} ${KOKKOS_CUDA_OPTION_CMD} ${KOKKOS_HIP_OPTION_CMD} -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_CXX_EXTENSIONS=OFF ${STANDARD_CMD} ${KOKKOS_DEBUG_CMD} ${KOKKOS_BC_CMD} ${KOKKOS_HWLOC_CMD} ${KOKKOS_HWLOC_PATH_CMD} ${PASSTHRU_CMAKE_FLAGS} -DKokkos_ENABLE_DEPRECATION_WARNINGS=${KOKKOS_DEPRECATED_CODE_WARNINGS} -DKokkos_ENABLE_DEPRECATED_CODE_4=${KOKKOS_DEPRECATED_CODE} ${KOKKOS_PATH}
diff --git a/gnu_generate_makefile.bash b/gnu_generate_makefile.bash
index 5ea159cdd4..7a197bb71d 100755
--- a/gnu_generate_makefile.bash
+++ b/gnu_generate_makefile.bash
@@ -74,9 +74,6 @@ do
     --with-hwloc*)
       HWLOC_PATH="${key#*=}"
       ;;
-    --with-memkind*)
-      MEMKIND_PATH="${key#*=}"
-      ;;
     --arch*)
       KOKKOS_ARCH="${key#*=}"
       ;;
@@ -148,12 +145,9 @@ do
       echo "                 ARMv8-ThunderX  = ARMv8 Cavium ThunderX CPU"
       echo "                 ARMv8-TX2       = ARMv8 Cavium ThunderX2 CPU"
       echo "               [IBM]"
-      echo "                 BGQ             = IBM Blue Gene Q"
-      echo "                 Power7          = IBM POWER7 and POWER7+ CPUs"
       echo "                 Power8          = IBM POWER8 CPUs"
       echo "                 Power9          = IBM POWER9 CPUs"
       echo "               [Intel]"
-      echo "                 WSM             = Intel Westmere CPUs"
       echo "                 SNB             = Intel Sandy/Ivy Bridge CPUs"
       echo "                 HSW             = Intel Haswell CPUs"
       echo "                 BDW             = Intel Broadwell Xeon E-class CPUs"
@@ -198,7 +192,6 @@ do
       echo "--with-gtest=/Path/To/Gtest:  Set path to gtest.  (Used in unit and performance"
       echo "                                tests.)"
       echo "--with-hwloc=/Path/To/Hwloc:  Set path to hwloc library."
-      echo "--with-memkind=/Path/To/MemKind:  Set path to memkind library."
       echo "--with-options=[OPT]:         Additional options to Kokkos:"
       echo "                                compiler_warnings"
       echo "                                aggressive_vectorization = add ivdep on loops"
@@ -298,11 +291,6 @@ if [ ${#HWLOC_PATH} -gt 0 ]; then
   KOKKOS_USE_TPLS="${KOKKOS_USE_TPLS},hwloc"
 fi
 
-if [ ${#MEMKIND_PATH} -gt 0 ]; then
-  KOKKOS_SETTINGS="${KOKKOS_SETTINGS} MEMKIND_PATH=${MEMKIND_PATH}" 
-  KOKKOS_USE_TPLS="${KOKKOS_USE_TPLS},experimental_memkind"
-fi
-
 if [ ${#KOKKOS_USE_TPLS} -gt 0 ]; then
   KOKKOS_SETTINGS="${KOKKOS_SETTINGS} KOKKOS_USE_TPLS=${KOKKOS_USE_TPLS}"
 fi
diff --git a/master_history.txt b/master_history.txt
index 41c0a5c393..a0e83bef23 100644
--- a/master_history.txt
+++ b/master_history.txt
@@ -33,3 +33,8 @@ tag:  3.7.01     date: 12:01:2022    master: 61d7db55    release: d3bb8cfe
 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
+tag:  4.2.00     date: 11:09:2023    master: 1a3ea28f    release: abe01c88
+tag:  4.2.01     date: 01:30:2024    master: 71a9bcae    release: 221e5f7a
+tag:  4.3.00     date: 04:03:2024    master: e0dc0128    release: f08217a4
+tag:  4.3.01     date: 05:07:2024    master: 486cc745    release: 262d2d6e
+tag:  4.4.00     date: 08:08:2024    master: 6ecdf605    release: 6068673c
diff --git a/scripts/check-copyright b/scripts/check-copyright
index be696d069a..9c4ba6a842 100755
--- a/scripts/check-copyright
+++ b/scripts/check-copyright
@@ -1,16 +1,15 @@
-files=`git ls-files | grep -e '.*\.\(cc\|cpp\|hpp\)' | grep -v 'tpls/'`
+files=$(git ls-files | grep -e '.*\.\(cc\|cpp\|hpp\)' | grep -v 'tpls/')
 echo "" &> scripts/diff_files
-tmp=`cat LICENSE_FILE_HEADER | wc -l`
+tmp=$(wc -l < LICENSE_FILE_HEADER)
 NNEW=$(($tmp))
-for file in $files; do
-  head -n +$NNEW $file &> header
-  diff header LICENSE_FILE_HEADER &> header_diff
-  count=`cat header_diff | wc -l`
-  #echo $file " " COUNT " " $count >> diff_headers
-  if [ "$count" -ne "0" ]; then
-    echo $file >> scripts/diff_files
+for file in $files
+do
+  head -n +$NNEW "${file}" | diff -q - LICENSE_FILE_HEADER > /dev/null
+  if [[ "${?}" == 1 ]]
+  then
+    echo "${file}" >> scripts/diff_files
   fi
 done
 tmpfile=$(mktemp -t kokkos_diff_files.XXXX)
-cat scripts/diff_files | sort &> $tmpfile
-mv $tmpfile scripts/diff_files
+sort < scripts/diff_files &> "${tmpfile}"
+mv "${tmpfile}" scripts/diff_files
diff --git a/scripts/docker/Dockerfile.clang b/scripts/docker/Dockerfile.clang
index 5c6abc1c6d..b493c3bbff 100644
--- a/scripts/docker/Dockerfile.clang
+++ b/scripts/docker/Dockerfile.clang
@@ -1,49 +1,13 @@
-FROM ubuntu:18.04
+FROM ubuntu:20.04
 
 RUN apt-get update && apt-get install -y \
         bc \
         git \
         build-essential \
+        clang-format-8 \
         wget \
-        ccache \
         && \
     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} && \
-    wget --quiet ${KEYDUMP_URL}/${KEYDUMP_FILE}.sig && \
-    gpg --import ${KEYDUMP_FILE} && \
-    gpg --verify ${KEYDUMP_FILE}.sig ${KEYDUMP_FILE} && \
-    rm ${KEYDUMP_FILE}*
-
-ARG CMAKE_VERSION=3.16.8
-ENV CMAKE_DIR=/opt/cmake
-RUN CMAKE_URL=https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION} && \
-    CMAKE_SCRIPT=cmake-${CMAKE_VERSION}-Linux-x86_64.sh && \
-    CMAKE_SHA256=cmake-${CMAKE_VERSION}-SHA-256.txt && \
-    wget --quiet ${CMAKE_URL}/${CMAKE_SHA256} && \
-    wget --quiet ${CMAKE_URL}/${CMAKE_SHA256}.asc && \
-    wget --quiet ${CMAKE_URL}/${CMAKE_SCRIPT} && \
-    gpg --verify ${CMAKE_SHA256}.asc ${CMAKE_SHA256} && \
-    grep -i ${CMAKE_SCRIPT} ${CMAKE_SHA256} | sed -e s/linux/Linux/ | sha256sum --check && \
-    mkdir -p ${CMAKE_DIR} && \
-    sh ${CMAKE_SCRIPT} --skip-license --prefix=${CMAKE_DIR} && \
-    rm cmake*
-ENV PATH=${CMAKE_DIR}/bin:$PATH
-
-ENV LLVM_DIR=/opt/llvm
-RUN LLVM_VERSION=8.0.0 && \
-    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} && \
-    wget --quiet ${LLVM_URL}.sig --output-document=${LLVM_ARCHIVE}.sig && \
-    gpg --verify ${LLVM_ARCHIVE}.sig ${LLVM_ARCHIVE} && \
-    mkdir -p ${LLVM_DIR} && \
-    tar -xvf ${LLVM_ARCHIVE} -C ${LLVM_DIR} --strip-components=1 && \
-    echo "${LLVM_DIR}/lib" > /etc/ld.so.conf.d/llvm.conf && ldconfig && \
-    rm -rf /root/.gnupg && \
-    rm -rf ${SCRATCH_DIR}
-ENV PATH=${LLVM_DIR}/bin:$PATH
+ENV CLANG_FORMAT_EXE=clang-format-8
diff --git a/scripts/docker/Dockerfile.kokkosllvmproject b/scripts/docker/Dockerfile.kokkosllvmproject
index 9086cba5e8..a46d00f019 100644
--- a/scripts/docker/Dockerfile.kokkosllvmproject
+++ b/scripts/docker/Dockerfile.kokkosllvmproject
@@ -1,8 +1,8 @@
-FROM nvidia/cuda:10.1-devel
+FROM nvidia/cuda:11.0.3-devel
 
 RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
 
-RUN apt-get update && apt-get install -y \
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
         bc \
         git \
         wget \
@@ -15,10 +15,10 @@ RUN apt-get update && apt-get install -y \
 
 # unbuntu18.04-based images have libstdc++ that is lacking filesystem support
 RUN apt-get update && \
-    apt-get install -y software-properties-common && \
+    DEBIAN_FRONTEND=noninteractive 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 && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y g++-9 && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
@@ -49,7 +49,7 @@ ARG NPROC=8
 
 # Clone Kokkos fork of the LLVM Project and build Clang
 ENV LLVM_DIR=/opt/llvm
-RUN LLVM_VERSION=55b3bcf643685c63fcc529d434bed112fdf03939 && \
+RUN LLVM_VERSION=32413084ecbb5e739c6b35d8bf13ad972985acb3 && \
     LLVM_URL=https://github.com/kokkos/llvm-project/archive/${LLVM_VERSION}.tar.gz &&\
     LLVM_ARCHIVE=llvm.tar.xz && \
     SCRATCH_DIR=/scratch && mkdir -p ${SCRATCH_DIR} && cd ${SCRATCH_DIR} && \
diff --git a/scripts/docker/Dockerfile.nvhpc b/scripts/docker/Dockerfile.nvhpc
index c0b8cc19d1..88e59de282 100644
--- a/scripts/docker/Dockerfile.nvhpc
+++ b/scripts/docker/Dockerfile.nvhpc
@@ -1,4 +1,4 @@
-ARG BASE=nvcr.io/nvidia/nvhpc:22.3-devel-cuda11.6-ubuntu20.04
+ARG BASE=nvcr.io/nvidia/nvhpc:23.7-devel-cuda12.2-ubuntu20.04
 FROM $BASE
 
 RUN KEYDUMP_URL=https://cloud.cees.ornl.gov/download && \
diff --git a/scripts/docker/Dockerfile.openmptarget b/scripts/docker/Dockerfile.openmptarget
index 44c53fef1d..b9e8442c74 100644
--- a/scripts/docker/Dockerfile.openmptarget
+++ b/scripts/docker/Dockerfile.openmptarget
@@ -1,4 +1,4 @@
-ARG BASE=nvidia/cuda:11.1.1-devel-ubuntu20.04
+ARG BASE=nvcr.io/nvidia/cuda:12.3.2-devel-ubuntu22.04
 FROM $BASE
 
 RUN apt-get update && apt-get install -y \
@@ -23,7 +23,7 @@ RUN KEYDUMP_URL=https://cloud.cees.ornl.gov/download && \
     gpg --verify ${KEYDUMP_FILE}.sig ${KEYDUMP_FILE} && \
     rm ${KEYDUMP_FILE}*
 
-ARG CMAKE_VERSION=3.18.5
+ARG CMAKE_VERSION=3.27.7
 ENV CMAKE_DIR=/opt/cmake
 RUN CMAKE_URL=https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION} && \
     CMAKE_SCRIPT=cmake-${CMAKE_VERSION}-Linux-x86_64.sh && \
@@ -38,7 +38,7 @@ RUN CMAKE_URL=https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSIO
     rm ${CMAKE_SCRIPT}
 ENV PATH=${CMAKE_DIR}/bin:$PATH
 
-ARG LLVM_VERSION=llvmorg-15.0.0
+ARG LLVM_VERSION=llvmorg-17.0.3
 ENV LLVM_DIR=/opt/llvm
 RUN LLVM_URL=https://github.com/llvm/llvm-project/archive &&\
     LLVM_ARCHIVE=${LLVM_VERSION}.tar.gz &&\
@@ -55,8 +55,7 @@ RUN LLVM_URL=https://github.com/llvm/llvm-project/archive &&\
       -DCMAKE_CXX_COMPILER=g++ \
       -DLLVM_ENABLE_PROJECTS="clang" \
       -DLLVM_ENABLE_RUNTIMES="openmp" \
-      -DCLANG_OPENMP_NVPTX_DEFAULT_ARCH=sm_70 \
-      -DLIBOMPTARGET_NVPTX_COMPUTE_CAPABILITIES=70 \
+      -DLIBOMPTARGET_DEVICE_ARCHITECTURES=sm_70 \
     ../llvm && \
     make -j${NPROC} && \
     make install && \
diff --git a/scripts/docker/Dockerfile.sycl b/scripts/docker/Dockerfile.sycl
index 4e185f4c1b..d6162975b4 100644
--- a/scripts/docker/Dockerfile.sycl
+++ b/scripts/docker/Dockerfile.sycl
@@ -1,4 +1,4 @@
-ARG BASE=nvidia/cuda:11.7.0-devel-ubuntu22.04
+ARG BASE=nvidia/cuda:11.7.1-devel-ubuntu22.04
 FROM $BASE
 
 RUN apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/3bf863cc.pub
@@ -51,7 +51,25 @@ RUN wget https://cloud.cees.ornl.gov/download/oneapi-for-nvidia-gpus-2023.0.0-li
     ./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
+ENV ONE_DPL_DIR=/opt/onedpl
+RUN . /opt/intel/oneapi/setvars.sh --include-intel-llvm && \
+    ONE_DPL_VERSION=oneDPL-2022.2.0 && \
+    ONE_DPL_URL=https://github.com/oneapi-src/oneDPL/archive && \
+    ONE_DPL_ARCHIVE=${ONE_DPL_VERSION}-rc1.tar.gz && \
+    SCRATCH_DIR=/scratch && mkdir -p ${SCRATCH_DIR} && cd ${SCRATCH_DIR} && \
+    wget --quiet ${ONE_DPL_URL}/${ONE_DPL_ARCHIVE} && \
+    mkdir onedpl && \
+    tar -xf ${ONE_DPL_ARCHIVE} -C onedpl --strip-components=1 && cd onedpl && \
+    mkdir build && cd build && \
+    cmake -DCMAKE_CXX_COMPILER=icpx -DCMAKE_CXX_FLAGS="-w" -DCMAKE_INSTALL_PREFIX=${ONE_DPL_DIR} -DCMAKE_SKIP_INSTALL_ALL_DEPENDENCY=TRUE -DONEDPL_BACKEND="dpcpp_only" .. && \
+    make -j${NPROCS} install && \
+    rm -rf ${SCRATCH_DIR}
+
+# clang++
+ENV PATH=/opt/intel/oneapi/compiler/latest/linux/bin-llvm/:$PATH
+# sycl-ls, icpx
+ENV PATH=/opt/intel/oneapi/compiler/latest/linux/bin/:$PATH
+# libsycl
+ENV LD_LIBRARY_PATH=/opt/intel/oneapi/compiler/latest/linux/lib:$LD_LIBRARY_PATH
+# libsvml
+ENV LD_LIBRARY_PATH=/opt/intel/oneapi/compiler/latest/linux/compiler/lib/intel64_lin:$LD_LIBRARY_PATH
diff --git a/scripts/testing_scripts/generate_makefile.bash b/scripts/testing_scripts/generate_makefile.bash
index ae1db3186f..830d7b12d9 100755
--- a/scripts/testing_scripts/generate_makefile.bash
+++ b/scripts/testing_scripts/generate_makefile.bash
@@ -59,9 +59,6 @@ do
     --with-hwloc*)
       HWLOC_PATH="${key#*=}"
       ;;
-    --with-memkind*)
-      MEMKIND_PATH="${key#*=}"
-      ;;
     --arch*)
       KOKKOS_ARCH="${key#*=}"
       ;;
@@ -136,12 +133,9 @@ do
       echo "                 ARMv8-ThunderX  = ARMv8 Cavium ThunderX CPU"
       echo "                 ARMv8-TX2       = ARMv8 Cavium ThunderX2 CPU"
       echo "               [IBM]"
-      echo "                 BGQ             = IBM Blue Gene Q"
-      echo "                 Power7          = IBM POWER7 and POWER7+ CPUs"
       echo "                 Power8          = IBM POWER8 CPUs"
       echo "                 Power9          = IBM POWER9 CPUs"
       echo "               [Intel]"
-      echo "                 WSM             = Intel Westmere CPUs"
       echo "                 SNB             = Intel Sandy/Ivy Bridge CPUs"
       echo "                 HSW             = Intel Haswell CPUs"
       echo "                 BDW             = Intel Broadwell Xeon E-class CPUs"
@@ -177,7 +171,6 @@ do
       echo "--with-gtest=/Path/To/Gtest:  Set path to gtest.  (Used in unit and performance"
       echo "                                tests.)"
       echo "--with-hwloc=/Path/To/Hwloc:  Set path to hwloc library."
-      echo "--with-memkind=/Path/To/MemKind:  Set path to memkind library."
       echo "--with-options=[OPT]:         Additional options to Kokkos:"
       echo "                                compiler_warnings"
       echo "                                aggressive_vectorization = add ivdep on loops"
@@ -269,11 +262,6 @@ if [ ${#HWLOC_PATH} -gt 0 ]; then
   KOKKOS_USE_TPLS="${KOKKOS_USE_TPLS},hwloc"
 fi
 
-if [ ${#MEMKIND_PATH} -gt 0 ]; then
-  KOKKOS_SETTINGS="${KOKKOS_SETTINGS} MEMKIND_PATH=${MEMKIND_PATH}" 
-  KOKKOS_USE_TPLS="${KOKKOS_USE_TPLS},experimental_memkind"
-fi
-
 if [ ${#KOKKOS_USE_TPLS} -gt 0 ]; then
   KOKKOS_SETTINGS="${KOKKOS_SETTINGS} KOKKOS_USE_TPLS=${KOKKOS_USE_TPLS}"
 fi
diff --git a/scripts/testing_scripts/test_all_sandia b/scripts/testing_scripts/test_all_sandia
index a3dc9ffd34..6e463addb9 100755
--- a/scripts/testing_scripts/test_all_sandia
+++ b/scripts/testing_scripts/test_all_sandia
@@ -75,6 +75,7 @@ CUDA_ENABLE_CMD=
 
 if [[ "$HOSTNAME" =~ weaver.* ]]; then
   MACHINE=weaver
+  source /etc/profile.d/modules.sh
   module load git
 fi
 
@@ -105,6 +106,14 @@ if [[ "$HOSTNAME" == caraway* ]]; then
   MACHINE=caraway
 fi
 
+if [[ "$HOSTNAME" == fat* ]]; then # Caraway MI250 queues
+  MACHINE=caraway
+fi
+
+if [[ "$HOSTNAME" == lean* ]]; then # Caraway MI210 queues
+  MACHINE=caraway
+fi
+
 if [[ "$HOSTNAME" == sogpu01* ]]; then
   MACHINE=sogpu
 fi
@@ -324,11 +333,12 @@ elif [ "$MACHINE" = "sogpu" ]; then
   echo "COMPILER VAR : $COMPILERS"
 
 elif [ "$MACHINE" = "weaver" ]; then
-  source /etc/profile.d/modules.sh
+  # Use the legacy env for now until all modules are part of the new system
+  source /projects/ppc64le-pwr9-rhel8/legacy-env.sh
   SKIP_HWLOC=True
 
   # 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>"
+  CUDA11_MODULE_LIST="cmake/3.23.1,<COMPILER_NAME>/<COMPILER_VERSION>"
 
   # Don't do pthread with Power
   GCC_BUILD_LIST="OpenMP,Serial,OpenMP_Serial"
@@ -337,11 +347,6 @@ elif [ "$MACHINE" = "weaver" ]; then
   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"
-             "gcc/8.3.1 $RHEL8_BASE_MODULE_LIST $GCC_IBM_BUILD_LIST g++ $GCC_WARNING_FLAGS"
-             "cuda/11.2.2 $RHEL8_CUDA11_MODULE_LIST $CUDA_IBM_BUILD_LIST ${KOKKOS_PATH}/bin/nvcc_wrapper $CUDA_WARNING_FLAGS"
-  )
   if [ -z "$ARCH_FLAG" ]; then
     ARCH_FLAG="--arch=Power9,Volta70"
   fi
@@ -391,7 +396,7 @@ elif [ "$MACHINE" = "caraway" ]; then
   )
 
   if [ -z "$ARCH_FLAG" ]; then
-    ARCH_FLAG="--arch=VEGA908"
+    ARCH_FLAG="--arch=AMD_GFX908"
   fi
 
 elif [ "$MACHINE" = "blake" ]; then
@@ -403,15 +408,20 @@ elif [ "$MACHINE" = "blake" ]; then
 
   BASE_MODULE_LIST="cmake/3.19.3,<COMPILER_NAME>/<COMPILER_VERSION>"
   BASE_MODULE_LIST_INTEL="cmake/3.19.3,<COMPILER_NAME>/compilers/<COMPILER_VERSION>"
-  BASE_MODULE_LIST_ONEAPI="cmake/3.19.3,<COMPILER_NAME>/oneAPI/base-toolkit/<COMPILER_VERSION>"
+  BASE_MODULE_LIST_ONEAPI="cmake/3.19.3,<COMPILER_NAME>/oneAPI/base-toolkit/<COMPILER_VERSION>,<COMPILER_NAME>/oneAPI/hpc-toolkit/<COMPILER_VERSION>"
   ONEAPI_WARNING_FLAGS=""
 
   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"
+             "intel/2021.2.0 $BASE_MODULE_LIST_ONEAPI $INTEL_BUILD_LIST icpx $ONEAPI_WARNING_FLAGS"
+             "intel/2021.4.0 $BASE_MODULE_LIST_ONEAPI $INTEL_BUILD_LIST icpx $ONEAPI_WARNING_FLAGS"
+             "intel/2022.1.2 $BASE_MODULE_LIST_ONEAPI $INTEL_BUILD_LIST icpx $ONEAPI_WARNING_FLAGS"
              "gcc/8.2.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"
              "gcc/10.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "gcc/11.2.0 $BASE_MODULE_LIST $GCC_BUILD_LIST g++ $GCC_WARNING_FLAGS"
+             "clang/10.0.0 $BASE_MODULE_LIST $CLANG_BUILD_LIST clang++ $CLANG_WARNING_FLAGS"
   )
 
   if [ -z "$ARCH_FLAG" ]; then
diff --git a/simd/src/Kokkos_SIMD.hpp b/simd/src/Kokkos_SIMD.hpp
index a587394acd..5e34e51989 100644
--- a/simd/src/Kokkos_SIMD.hpp
+++ b/simd/src/Kokkos_SIMD.hpp
@@ -19,19 +19,62 @@
 
 #include <Kokkos_SIMD_Common.hpp>
 
+// suppress NVCC warnings with the [[nodiscard]] attribute on overloaded
+// operators implemented as hidden friends
+#if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC < 1130
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wattributes"
+#endif
+
 #include <Kokkos_SIMD_Scalar.hpp>
 
-#ifdef KOKKOS_ARCH_AVX2
+#include <Kokkos_Macros.hpp>
+
+// FIXME_OPENMPTARGET The device pass disables all compiler macros checked
+#ifdef KOKKOS_ENABLE_OPENMPTARGET
+#if defined(KOKKOS_ARCH_AVX2)
 #include <Kokkos_SIMD_AVX2.hpp>
 #endif
 
-#ifdef KOKKOS_ARCH_AVX512XEON
+#if defined(KOKKOS_ARCH_AVX512XEON)
 #include <Kokkos_SIMD_AVX512.hpp>
 #endif
 
-#ifdef __ARM_NEON
+#if defined(KOKKOS_ARCH_ARM_NEON)
 #include <Kokkos_SIMD_NEON.hpp>
 #endif
+#else  // KOKKOS_ENABLE_OPENMPTARGET
+#if defined(KOKKOS_ARCH_AVX) && !defined(__AVX__)
+#error "__AVX__ must be defined for KOKKOS_ARCH_AVX"
+#endif
+
+#if defined(KOKKOS_ARCH_AVX2)
+#if !defined(__AVX2__)
+#error "__AVX2__ must be defined for KOKKOS_ARCH_AVX2"
+#endif
+#include <Kokkos_SIMD_AVX2.hpp>
+#endif
+
+#if defined(KOKKOS_ARCH_AVX512XEON)
+#if !defined(__AVX512F__)
+#error "__AVX512F__ must be defined for KOKKOS_ARCH_AVX512XEON"
+#endif
+#include <Kokkos_SIMD_AVX512.hpp>
+#endif
+
+#if defined(KOKKOS_ARCH_ARM_NEON)
+#if !defined(__ARM_NEON)
+#error "__ARM_NEON must be definded for KOKKOS_ARCH_ARM_NEON"
+#endif
+#include <Kokkos_SIMD_NEON.hpp>
+#endif
+#endif
+
+#if defined(KOKKOS_COMPILER_NVCC) && KOKKOS_COMPILER_NVCC < 1130
+#pragma GCC diagnostic pop
+#endif
+
+#include <Kokkos_SIMD_Common_Math.hpp>
 
 namespace Kokkos {
 namespace Experimental {
@@ -44,7 +87,7 @@ namespace Impl {
 using host_native = avx512_fixed_size<8>;
 #elif defined(KOKKOS_ARCH_AVX2)
 using host_native  = avx2_fixed_size<4>;
-#elif defined(__ARM_NEON)
+#elif defined(KOKKOS_ARCH_ARM_NEON)
 using host_native  = neon_fixed_size<2>;
 #else
 using host_native   = scalar;
@@ -140,21 +183,24 @@ 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>,
+                             simd_abi::avx512_fixed_size<16>>;
 using data_type_set = data_types<std::int32_t, std::uint32_t, std::int64_t,
-                                 std::uint64_t, double>;
+                                 std::uint64_t, double, float>;
 #elif defined(KOKKOS_ARCH_AVX2)
-using host_abi_set = abi_set<simd_abi::scalar, simd_abi::avx2_fixed_size<4>>;
+using host_abi_set = abi_set<simd_abi::scalar, simd_abi::avx2_fixed_size<4>,
+                             simd_abi::avx2_fixed_size<8>>;
 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>>;
+    data_types<std::int32_t, std::int64_t, std::uint64_t, double, float>;
+#elif defined(KOKKOS_ARCH_ARM_NEON)
+using host_abi_set = abi_set<simd_abi::scalar, simd_abi::neon_fixed_size<2>,
+                             simd_abi::neon_fixed_size<4>>;
 using data_type_set =
-    data_types<std::int32_t, std::int64_t, std::uint64_t, double>;
+    data_types<std::int32_t, std::int64_t, std::uint64_t, double, float>;
 #else
 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>;
+                                 std::uint64_t, double, float>;
 #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 1c4ff4765d..27c8af79ab 100644
--- a/simd/src/Kokkos_SIMD_AVX2.hpp
+++ b/simd/src/Kokkos_SIMD_AVX2.hpp
@@ -25,6 +25,19 @@
 
 #include <immintrin.h>
 
+#ifdef KOKKOS_SIMD_COMMON_MATH_HPP
+#error \
+    "Kokkos_SIMD_AVX2.hpp must be included before Kokkos_SIMD_Common_Math.hpp!"
+#endif
+
+// FIXME_HIP ROCm 5.6, 5.7, and 6.0 can't compile with the intrinsic used here.
+#if defined(__HIPCC__) &&                                        \
+    (((HIP_VERSION_MAJOR == 5) &&                                \
+      ((HIP_VERSION_MINOR == 6) || (HIP_VERSION_MINOR == 7))) || \
+     ((HIP_VERSION_MAJOR == 6) && ((HIP_VERSION_MINOR == 0))))
+#define KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+#endif
+
 namespace Kokkos {
 
 namespace Experimental {
@@ -73,6 +86,18 @@ class simd_mask<double, simd_abi::avx2_fixed_size<4>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd_mask(value_type value)
       : m_value(_mm256_castsi256_pd(_mm256_set1_epi64x(-std::int64_t(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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm256_castsi256_pd(_mm256_setr_epi64x(
+            -std::int64_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 3>()))))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
       simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>> const& i32_mask);
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
@@ -115,6 +140,194 @@ class simd_mask<double, simd_abi::avx2_fixed_size<4>> {
   }
 };
 
+template <>
+class simd_mask<float, simd_abi::avx2_fixed_size<4>> {
+  __m128 m_value;
+
+ public:
+  class reference {
+    __m128& m_mask;
+    int m_lane;
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION __m128 bit_mask() const {
+      return _mm_castsi128_ps(_mm_setr_epi32(
+          -std::int32_t(m_lane == 0), -std::int32_t(m_lane == 1),
+          -std::int32_t(m_lane == 2), -std::int32_t(m_lane == 3)));
+    }
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(__m128& mask_arg,
+                                                    int lane_arg)
+        : m_mask(mask_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(bool value) const {
+      if (value) {
+        m_mask = _mm_or_ps(bit_mask(), m_mask);
+      } else {
+        m_mask = _mm_andnot_ps(bit_mask(), m_mask);
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator bool() const {
+      return (_mm_movemask_ps(m_mask) & (1 << m_lane)) != 0;
+    }
+  };
+  using value_type = bool;
+  using abi_type   = simd_abi::avx2_fixed_size<4>;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask() = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd_mask(value_type value)
+      : m_value(_mm_castsi128_ps(_mm_set1_epi32(-std::int32_t(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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm_castsi128_ps(_mm_setr_epi32(
+            -std::int32_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 3>()))))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
+    return 4;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      __m128 const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m128()
+      const {
+    return m_value;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  operator[](std::size_t i) const {
+    return static_cast<value_type>(
+        reference(const_cast<__m128&>(m_value), int(i)));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator||(simd_mask const& other) const {
+    return simd_mask(_mm_or_ps(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator&&(simd_mask const& other) const {
+    return simd_mask(_mm_and_ps(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask operator!() const {
+    auto const true_value = static_cast<__m128>(simd_mask(true));
+    return simd_mask(_mm_andnot_ps(m_value, true_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator==(
+      simd_mask const& other) const {
+    return _mm_movemask_ps(m_value) == _mm_movemask_ps(other.m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator!=(
+      simd_mask const& other) const {
+    return !operator==(other);
+  }
+};
+
+template <>
+class simd_mask<float, simd_abi::avx2_fixed_size<8>> {
+  __m256 m_value;
+
+ public:
+  class reference {
+    __m256& m_mask;
+    int m_lane;
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION __m256 bit_mask() const {
+      // FIXME_HIP ROCm 5.6, 5.7, and 6.0 can't compile with the intrinsic used
+      // here.
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+      return _mm256_cvtepi32_ps(_mm256_setr_epi32(
+#else
+      return _mm256_castsi256_ps(_mm256_setr_epi32(
+#endif
+          -std::int32_t(m_lane == 0), -std::int32_t(m_lane == 1),
+          -std::int32_t(m_lane == 2), -std::int32_t(m_lane == 3),
+          -std::int32_t(m_lane == 4), -std::int32_t(m_lane == 5),
+          -std::int32_t(m_lane == 6), -std::int32_t(m_lane == 7)));
+    }
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(__m256& mask_arg,
+                                                    int lane_arg)
+        : m_mask(mask_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(bool value) const {
+      if (value) {
+        m_mask = _mm256_or_ps(bit_mask(), m_mask);
+      } else {
+        m_mask = _mm256_andnot_ps(bit_mask(), m_mask);
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator bool() const {
+      return (_mm256_movemask_ps(m_mask) & (1 << m_lane)) != 0;
+    }
+  };
+  using value_type = bool;
+  using abi_type   = simd_abi::avx2_fixed_size<8>;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask() = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd_mask(value_type value)
+      : m_value(_mm256_castsi256_ps(_mm256_set1_epi32(-std::int32_t(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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm256_castsi256_ps(_mm256_setr_epi32(
+            -std::int32_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 3>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 4>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 5>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 6>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 7>()))))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
+    return 8;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      __m256 const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256()
+      const {
+    return m_value;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  operator[](std::size_t i) const {
+    return static_cast<value_type>(
+        reference(const_cast<__m256&>(m_value), int(i)));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator||(simd_mask const& other) const {
+    return simd_mask(_mm256_or_ps(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator&&(simd_mask const& other) const {
+    return simd_mask(_mm256_and_ps(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask operator!() const {
+    auto const true_value = static_cast<__m256>(simd_mask(true));
+    return simd_mask(_mm256_andnot_ps(m_value, true_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator==(
+      simd_mask const& other) const {
+    return _mm256_movemask_ps(m_value) == _mm256_movemask_ps(other.m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator!=(
+      simd_mask const& other) const {
+    return !operator==(other);
+  }
+};
+
 template <>
 class simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>> {
   __m128i m_value;
@@ -159,6 +372,18 @@ class simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
       __m128i const& value_in)
       : m_value(value_in) {}
+  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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm_setr_epi32(
+            -std::int32_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 3>())))) {}
   template <class U>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
       simd_mask<U, abi_type> const& other) {
@@ -199,6 +424,109 @@ class simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>> {
   }
 };
 
+template <>
+class simd_mask<std::int32_t, simd_abi::avx2_fixed_size<8>> {
+  __m256i m_value;
+
+ public:
+  class reference {
+    __m256i& m_mask;
+    int m_lane;
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION __m256i bit_mask() const {
+      return _mm256_setr_epi32(
+          -std::int32_t(m_lane == 0), -std::int32_t(m_lane == 1),
+          -std::int32_t(m_lane == 2), -std::int32_t(m_lane == 3),
+          -std::int32_t(m_lane == 4), -std::int32_t(m_lane == 5),
+          -std::int32_t(m_lane == 6), -std::int32_t(m_lane == 7));
+    }
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(__m256i& mask_arg,
+                                                    int lane_arg)
+        : m_mask(mask_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(bool value) const {
+      if (value) {
+        m_mask = _mm256_or_si256(bit_mask(), m_mask);
+      } else {
+        m_mask = _mm256_andnot_si256(bit_mask(), m_mask);
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator bool() const {
+      return (_mm256_movemask_ps(_mm256_castsi256_ps(m_mask)) &
+              (1 << m_lane)) != 0;
+    }
+  };
+  using value_type = bool;
+  using abi_type   = simd_abi::avx2_fixed_size<8>;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask()                 = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(simd_mask const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(simd_mask&&)      = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd_mask(value_type value)
+      : m_value(_mm256_set1_epi32(-std::int32_t(value))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
+    return 8;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      __m256i const& value_in)
+      : m_value(value_in) {}
+  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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm256_setr_epi32(
+            -std::int32_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 3>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 4>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 5>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 6>())),
+            -std::int32_t(gen(std::integral_constant<std::size_t, 7>())))) {}
+  template <class U>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
+      simd_mask<U, abi_type> const& other) {
+    for (std::size_t i = 0; i < size(); ++i) (*this)[i] = other[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
+      const {
+    return m_value;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  operator[](std::size_t i) const {
+    return static_cast<value_type>(
+        reference(const_cast<__m256i&>(m_value), int(i)));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator||(simd_mask const& other) const {
+    return simd_mask(_mm256_or_si256(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator&&(simd_mask const& other) const {
+    return simd_mask(_mm256_and_si256(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask operator!() const {
+    auto const true_value = static_cast<__m256i>(simd_mask(true));
+    return simd_mask(_mm256_andnot_si256(m_value, true_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator==(
+      simd_mask const& other) const {
+    return _mm256_movemask_ps(_mm256_castsi256_ps(m_value)) ==
+           _mm256_movemask_ps(_mm256_castsi256_ps(other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator!=(
+      simd_mask const& other) const {
+    return !operator==(other);
+  }
+};
+
 template <>
 class simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>> {
   __m256i m_value;
@@ -244,6 +572,18 @@ class simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
       __m256i const& value_in)
       : m_value(value_in) {}
+  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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm256_setr_epi64x(
+            -std::int64_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 3>())))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
       simd_mask<std::int32_t, abi_type> const& other)
       : m_value(_mm256_cvtepi32_epi64(static_cast<__m128i>(other))) {}
@@ -328,6 +668,18 @@ class simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
       __m256i const& value_in)
       : m_value(value_in) {}
+  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 constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : m_value(_mm256_setr_epi64x(
+            -std::int64_t(gen(std::integral_constant<std::size_t, 0>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 1>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 2>())),
+            -std::int64_t(gen(std::integral_constant<std::size_t, 3>())))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
       const {
     return m_value;
@@ -393,6 +745,18 @@ class simd<double, simd_abi::avx2_fixed_size<4>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
       __m256d const& value_in)
       : m_value(value_in) {}
+  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 constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(_mm256_setr_pd(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 reference operator[](std::size_t i) {
     return reinterpret_cast<value_type*>(&m_value)[i];
   }
@@ -404,165 +768,729 @@ class simd<double, simd_abi::avx2_fixed_size<4>> {
                                                        element_aligned_tag) {
     m_value = _mm256_loadu_pd(ptr);
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm256_load_pd(ptr);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
     _mm256_storeu_pd(ptr, m_value);
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm256_store_pd(ptr, m_value);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256d()
       const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm256_cmp_pd(m_value, other.m_value, _CMP_LT_OS));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(
+        _mm256_sub_pd(_mm256_set1_pd(0.0), static_cast<__m256d>(m_value)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm256_cmp_pd(m_value, other.m_value, _CMP_GT_OS));
-  }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(_mm256_cmp_pd(m_value, other.m_value, _CMP_LE_OS));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_mul_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(_mm256_cmp_pd(m_value, other.m_value, _CMP_GE_OS));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_div_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm256_cmp_pd(m_value, other.m_value, _CMP_EQ_OS));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_add_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return mask_type(_mm256_cmp_pd(m_value, other.m_value, _CMP_NEQ_OS));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_sub_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
   }
-};
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx2_fixed_size<4>>
-    operator*(simd<double, simd_abi::avx2_fixed_size<4>> const& lhs,
-              simd<double, simd_abi::avx2_fixed_size<4>> const& rhs) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_mul_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
-}
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_pd(static_cast<__m256d>(lhs),
+                                   static_cast<__m256d>(rhs), _CMP_LT_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_pd(static_cast<__m256d>(lhs),
+                                   static_cast<__m256d>(rhs), _CMP_GT_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_pd(static_cast<__m256d>(lhs),
+                                   static_cast<__m256d>(rhs), _CMP_LE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_pd(static_cast<__m256d>(lhs),
+                                   static_cast<__m256d>(rhs), _CMP_GE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_pd(static_cast<__m256d>(lhs),
+                                   static_cast<__m256d>(rhs), _CMP_EQ_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_pd(static_cast<__m256d>(lhs),
+                                   static_cast<__m256d>(rhs), _CMP_NEQ_OS));
+  }
+};
+
+}  // namespace Experimental
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx2_fixed_size<4>>
-    operator/(simd<double, simd_abi::avx2_fixed_size<4>> const& lhs,
-              simd<double, simd_abi::avx2_fixed_size<4>> const& rhs) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_div_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    copysign(Experimental::simd<
+                 double, Experimental::simd_abi::avx2_fixed_size<4>> const& a,
+             Experimental::simd<
+                 double, Experimental::simd_abi::avx2_fixed_size<4>> const& b) {
+  __m256d const sign_mask = _mm256_set1_pd(-0.0);
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_xor_pd(_mm256_andnot_pd(sign_mask, static_cast<__m256d>(a)),
+                    _mm256_and_pd(sign_mask, static_cast<__m256d>(b))));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx2_fixed_size<4>>
-    operator+(simd<double, simd_abi::avx2_fixed_size<4>> const& lhs,
-              simd<double, simd_abi::avx2_fixed_size<4>> const& rhs) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_add_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    abs(Experimental::simd<
+        double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  __m256d const sign_mask = _mm256_set1_pd(-0.0);
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_andnot_pd(sign_mask, static_cast<__m256d>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx2_fixed_size<4>>
-    operator-(simd<double, simd_abi::avx2_fixed_size<4>> const& lhs,
-              simd<double, simd_abi::avx2_fixed_size<4>> const& rhs) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_sub_pd(static_cast<__m256d>(lhs), static_cast<__m256d>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    floor(Experimental::simd<
+          double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_round_pd(static_cast<__m256d>(a),
+                      (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx2_fixed_size<4>>
-    operator-(simd<double, simd_abi::avx2_fixed_size<4>> const& a) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_sub_pd(_mm256_set1_pd(0.0), static_cast<__m256d>(a)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    ceil(Experimental::simd<
+         double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_round_pd(static_cast<__m256d>(a),
+                      (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> copysign(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& b) {
-  __m256d const sign_mask = _mm256_set1_pd(-0.0);
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_xor_pd(_mm256_andnot_pd(sign_mask, static_cast<__m256d>(a)),
-                    _mm256_and_pd(sign_mask, static_cast<__m256d>(b))));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    round(Experimental::simd<
+          double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_round_pd(static_cast<__m256d>(a),
+                      (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> abs(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a) {
-  __m256d const sign_mask = _mm256_set1_pd(-0.0);
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
-      _mm256_andnot_pd(sign_mask, static_cast<__m256d>(a)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    trunc(Experimental::simd<
+          double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_round_pd(static_cast<__m256d>(a),
+                      (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> sqrt(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    sqrt(Experimental::simd<
+         double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_sqrt_pd(static_cast<__m256d>(a)));
 }
 
 #ifdef __INTEL_COMPILER
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> cbrt(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    cbrt(Experimental::simd<
+         double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_cbrt_pd(static_cast<__m256d>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> exp(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    exp(Experimental::simd<
+        double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_exp_pd(static_cast<__m256d>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> log(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    log(Experimental::simd<
+        double, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_log_pd(static_cast<__m256d>(a)));
 }
 
 #endif
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> fma(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& b,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& c) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    fma(Experimental::simd<double,
+                           Experimental::simd_abi::avx2_fixed_size<4>> const& a,
+        Experimental::simd<double,
+                           Experimental::simd_abi::avx2_fixed_size<4>> const& b,
+        Experimental::simd<
+            double, Experimental::simd_abi::avx2_fixed_size<4>> const& c) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_fmadd_pd(static_cast<__m256d>(a), static_cast<__m256d>(b),
                       static_cast<__m256d>(c)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> max(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& b) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    max(Experimental::simd<double,
+                           Experimental::simd_abi::avx2_fixed_size<4>> const& a,
+        Experimental::simd<
+            double, Experimental::simd_abi::avx2_fixed_size<4>> const& b) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_max_pd(static_cast<__m256d>(a), static_cast<__m256d>(b)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> min(
-    simd<double, simd_abi::avx2_fixed_size<4>> const& a,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& b) {
-  return simd<double, simd_abi::avx2_fixed_size<4>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    min(Experimental::simd<double,
+                           Experimental::simd_abi::avx2_fixed_size<4>> const& a,
+        Experimental::simd<
+            double, Experimental::simd_abi::avx2_fixed_size<4>> const& b) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
       _mm256_min_pd(static_cast<__m256d>(a), static_cast<__m256d>(b)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx2_fixed_size<4>> condition(
-    simd_mask<double, simd_abi::avx2_fixed_size<4>> const& a,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& b,
-    simd<double, simd_abi::avx2_fixed_size<4>> const& c) {
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<double, simd_abi::avx2_fixed_size<4>>
+    condition(simd_mask<double, simd_abi::avx2_fixed_size<4>> const& a,
+              simd<double, simd_abi::avx2_fixed_size<4>> const& b,
+              simd<double, simd_abi::avx2_fixed_size<4>> const& c) {
   return simd<double, simd_abi::avx2_fixed_size<4>>(
       _mm256_blendv_pd(static_cast<__m256d>(c), static_cast<__m256d>(b),
                        static_cast<__m256d>(a)));
 }
 
+template <>
+class simd<float, simd_abi::avx2_fixed_size<4>> {
+  __m128 m_value;
+
+ public:
+  using value_type = float;
+  using abi_type   = simd_abi::avx2_fixed_size<4>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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 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(_mm_set1_ps(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(_mm_setr_ps(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(
+      __m128 const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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 = _mm_loadu_ps(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm_load_ps(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm_storeu_ps(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm_store_ps(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m128()
+      const {
+    return m_value;
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm_sub_ps(_mm_set1_ps(0.0), m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm_mul_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm_div_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm_add_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm_sub_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm_cmplt_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm_cmpgt_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm_cmple_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm_cmpge_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm_cmpeq_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm_cmpneq_ps(lhs.m_value, rhs.m_value));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<4>>
+copysign(
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        b) {
+  __m128 const sign_mask = _mm_set1_ps(-0.0);
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_xor_ps(_mm_andnot_ps(sign_mask, static_cast<__m128>(a)),
+                 _mm_and_ps(sign_mask, static_cast<__m128>(b))));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    abs(Experimental::simd<
+        float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  __m128 const sign_mask = _mm_set1_ps(-0.0);
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_andnot_ps(sign_mask, static_cast<__m128>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    floor(Experimental::simd<
+          float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_round_ps(static_cast<__m128>(a),
+                   (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    ceil(Experimental::simd<
+         float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_round_ps(static_cast<__m128>(a),
+                   (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    round(Experimental::simd<
+          float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_round_ps(static_cast<__m128>(a),
+                   (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    trunc(Experimental::simd<
+          float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_round_ps(static_cast<__m128>(a),
+                   (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    sqrt(Experimental::simd<
+         float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_sqrt_ps(static_cast<__m128>(a)));
+}
+
+#ifdef __INTEL_COMPILER
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    cbrt(Experimental::simd<
+         float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_cbrt_ps(static_cast<__m128>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    exp(Experimental::simd<
+        float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_exp_ps(static_cast<__m128>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>
+    log(Experimental::simd<
+        float, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_log_ps(static_cast<__m128>(a)));
+}
+
+#endif
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<4>>
+fma(Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        b,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        c) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_fmadd_ps(static_cast<__m128>(a), static_cast<__m128>(b),
+                   static_cast<__m128>(c)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<4>>
+max(Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_max_ps(static_cast<__m128>(a), static_cast<__m128>(b)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<4>>
+min(Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_min_ps(static_cast<__m128>(a), static_cast<__m128>(b)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<float, simd_abi::avx2_fixed_size<4>>
+    condition(simd_mask<float, simd_abi::avx2_fixed_size<4>> const& a,
+              simd<float, simd_abi::avx2_fixed_size<4>> const& b,
+              simd<float, simd_abi::avx2_fixed_size<4>> const& c) {
+  return simd<float, simd_abi::avx2_fixed_size<4>>(_mm_blendv_ps(
+      static_cast<__m128>(c), static_cast<__m128>(b), static_cast<__m128>(a)));
+}
+
+template <>
+class simd<float, simd_abi::avx2_fixed_size<8>> {
+  __m256 m_value;
+
+ public:
+  using value_type = float;
+  using abi_type   = simd_abi::avx2_fixed_size<8>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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;
+  }
+  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_ps(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_ps(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>()),
+                               gen(std::integral_constant<std::size_t, 4>()),
+                               gen(std::integral_constant<std::size_t, 5>()),
+                               gen(std::integral_constant<std::size_t, 6>()),
+                               gen(std::integral_constant<std::size_t, 7>()))) {
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      __m256 const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_loadu_ps(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm256_load_ps(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm256_storeu_ps(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm256_store_ps(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256()
+      const {
+    return m_value;
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm256_sub_ps(_mm256_set1_ps(0.0), m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_mul_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_div_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_add_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_sub_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps(static_cast<__m256>(lhs),
+                                   static_cast<__m256>(rhs), _CMP_LT_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps(static_cast<__m256>(lhs),
+                                   static_cast<__m256>(rhs), _CMP_GT_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps(static_cast<__m256>(lhs),
+                                   static_cast<__m256>(rhs), _CMP_LE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps(static_cast<__m256>(lhs),
+                                   static_cast<__m256>(rhs), _CMP_GE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps(static_cast<__m256>(lhs),
+                                   static_cast<__m256>(rhs), _CMP_EQ_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps(static_cast<__m256>(lhs),
+                                   static_cast<__m256>(rhs), _CMP_NEQ_OS));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<8>>
+copysign(
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        b) {
+  __m256 const sign_mask = _mm256_set1_ps(-0.0);
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_xor_ps(_mm256_andnot_ps(sign_mask, static_cast<__m256>(a)),
+                    _mm256_and_ps(sign_mask, static_cast<__m256>(b))));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    abs(Experimental::simd<
+        float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  __m256 const sign_mask = _mm256_set1_ps(-0.0);
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_andnot_ps(sign_mask, static_cast<__m256>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    floor(Experimental::simd<
+          float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_round_ps(static_cast<__m256>(a),
+                      (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    ceil(Experimental::simd<
+         float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_round_ps(static_cast<__m256>(a),
+                      (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    round(Experimental::simd<
+          float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_round_ps(static_cast<__m256>(a),
+                      (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    trunc(Experimental::simd<
+          float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_round_ps(static_cast<__m256>(a),
+                      (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    sqrt(Experimental::simd<
+         float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_sqrt_ps(static_cast<__m256>(a)));
+}
+
+#ifdef __INTEL_COMPILER
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    cbrt(Experimental::simd<
+         float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_cbrt_ps(static_cast<__m256>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    exp(Experimental::simd<
+        float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_exp_ps(static_cast<__m256>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    log(Experimental::simd<
+        float, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_log_ps(static_cast<__m256>(a)));
+}
+
+#endif
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<8>>
+fma(Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        b,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        c) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_fmadd_ps(static_cast<__m256>(a), static_cast<__m256>(b),
+                      static_cast<__m256>(c)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<8>>
+max(Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_max_ps(static_cast<__m256>(a), static_cast<__m256>(b)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx2_fixed_size<8>>
+min(Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_min_ps(static_cast<__m256>(a), static_cast<__m256>(b)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<float, simd_abi::avx2_fixed_size<8>>
+    condition(simd_mask<float, simd_abi::avx2_fixed_size<8>> const& a,
+              simd<float, simd_abi::avx2_fixed_size<8>> const& b,
+              simd<float, simd_abi::avx2_fixed_size<8>> const& c) {
+  return simd<float, simd_abi::avx2_fixed_size<8>>(_mm256_blendv_ps(
+      static_cast<__m256>(c), static_cast<__m256>(b), static_cast<__m256>(a)));
+}
+
 template <>
 class simd<std::int32_t, simd_abi::avx2_fixed_size<4>> {
   __m128i m_value;
@@ -589,7 +1517,8 @@ class simd<std::int32_t, simd_abi::avx2_fixed_size<4>> {
                 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)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
       : 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>()),
@@ -609,58 +1538,147 @@ class simd<std::int32_t, simd_abi::avx2_fixed_size<4>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
+    // FIXME_HIP ROCm 5.6, 5.7, and 6.0 can't compile with the intrinsic used
+    // here.
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm_loadu_si128(reinterpret_cast<__m128i const*>(ptr));
+#else
     m_value = _mm_maskload_epi32(ptr, static_cast<__m128i>(mask_type(true)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    // FIXME_HIP ROCm 5.6 can't compile with the intrinsic used here.
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm_load_si128(reinterpret_cast<__m128i const*>(ptr));
+#else
+    m_value = _mm_maskload_epi32(ptr, static_cast<__m128i>(mask_type(true)));
+#endif
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
     _mm_maskstore_epi32(ptr, static_cast<__m128i>(mask_type(true)), m_value);
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm_maskstore_epi32(ptr, static_cast<__m128i>(mask_type(true)), m_value);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m128i()
       const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm_cmpeq_epi32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        _mm_cmpeq_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        _mm_cmpgt_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        _mm_cmplt_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return (lhs < rhs) || (lhs == rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm_cmpgt_epi32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return (lhs > rhs) || (lhs == rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm_cmplt_epi32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return ((*this) < other) || ((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm_sub_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return ((*this) > other) || ((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm_add_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm_mullo_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm_srai_epi32(static_cast<__m128i>(lhs), rhs));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm_srav_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm_slli_epi32(static_cast<__m128i>(lhs), rhs));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm_sllv_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
   }
 };
 
+}  // namespace Experimental
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::avx2_fixed_size<4>>
-    operator-(simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& lhs,
-              simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& rhs) {
-  return simd<std::int32_t, simd_abi::avx2_fixed_size<4>>(
-      _mm_sub_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+    Experimental::simd<std::int32_t, Experimental::simd_abi::avx2_fixed_size<4>>
+    abs(Experimental::simd<
+        std::int32_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  __m128i const rhs = static_cast<__m128i>(a);
+  return Experimental::simd<std::int32_t,
+                            Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm_abs_epi32(rhs));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::avx2_fixed_size<4>>
-    operator+(simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& lhs,
-              simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& rhs) {
-  return simd<std::int32_t, simd_abi::avx2_fixed_size<4>>(
-      _mm_add_epi32(static_cast<__m128i>(lhs), static_cast<__m128i>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    floor(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_cvtepi32_pd(static_cast<__m128i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    ceil(Experimental::simd<
+         std::int32_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_cvtepi32_pd(static_cast<__m128i>(a)));
 }
 
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    round(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_cvtepi32_pd(static_cast<__m128i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    trunc(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_cvtepi32_pd(static_cast<__m128i>(a)));
+}
+
+namespace Experimental {
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
     simd<std::int32_t, simd_abi::avx2_fixed_size<4>>
     condition(simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>> const& a,
@@ -672,6 +1690,207 @@ class simd<std::int32_t, simd_abi::avx2_fixed_size<4>> {
                     _mm_castsi128_ps(static_cast<__m128i>(a)))));
 }
 
+template <>
+class simd<std::int32_t, simd_abi::avx2_fixed_size<8>> {
+  __m256i m_value;
+
+ public:
+  using value_type = std::int32_t;
+  using abi_type   = simd_abi::avx2_fixed_size<8>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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;
+  }
+  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(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 constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(
+            _mm256_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>()),
+                              gen(std::integral_constant<std::size_t, 4>()),
+                              gen(std::integral_constant<std::size_t, 5>()),
+                              gen(std::integral_constant<std::size_t, 6>()),
+                              gen(std::integral_constant<std::size_t, 7>()))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      __m256i const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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) {
+    // FIXME_HIP ROCm 5.6, 5.7, and 6.0 can't compile with the intrinsic used
+    // here.
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(ptr));
+#else
+    m_value = _mm256_maskload_epi32(ptr, static_cast<__m256i>(mask_type(true)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    // FIXME_HIP ROCm 5.6, 5.7, and 6.0 can't compile with the intrinsic used
+    // here.
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(ptr));
+#else
+    m_value = _mm256_maskload_epi32(ptr, static_cast<__m256i>(mask_type(true)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm256_maskstore_epi32(ptr, static_cast<__m256i>(mask_type(true)), m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm256_maskstore_epi32(ptr, static_cast<__m256i>(mask_type(true)), m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
+      const {
+    return m_value;
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpeq_epi32(static_cast<__m256i>(lhs),
+                                        static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpgt_epi32(static_cast<__m256i>(lhs),
+                                        static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs >= rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return (lhs < rhs) || (lhs == rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return (lhs > rhs) || (lhs == rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_sub_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_add_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_mullo_epi32(static_cast<__m256i>(lhs),
+                                   static_cast<__m256i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_srai_epi32(static_cast<__m256i>(lhs), rhs));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_srav_epi32(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_slli_epi32(static_cast<__m256i>(lhs), rhs));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_sllv_epi32(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::avx2_fixed_size<8>>
+    abs(Experimental::simd<
+        std::int32_t, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  __m256i const rhs = static_cast<__m256i>(a);
+  return Experimental::simd<std::int32_t,
+                            Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_abs_epi32(rhs));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    floor(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_cvtepi32_ps(static_cast<__m256i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    ceil(Experimental::simd<
+         std::int32_t, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_cvtepi32_ps(static_cast<__m256i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    round(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_cvtepi32_ps(static_cast<__m256i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>
+    trunc(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::avx2_fixed_size<8>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::avx2_fixed_size<8>>(
+      _mm256_cvtepi32_ps(static_cast<__m256i>(a)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int32_t, simd_abi::avx2_fixed_size<8>>
+    condition(simd_mask<std::int32_t, simd_abi::avx2_fixed_size<8>> const& a,
+              simd<std::int32_t, simd_abi::avx2_fixed_size<8>> const& b,
+              simd<std::int32_t, simd_abi::avx2_fixed_size<8>> const& c) {
+  return simd<std::int32_t, simd_abi::avx2_fixed_size<8>>(_mm256_castps_si256(
+      _mm256_blendv_ps(_mm256_castsi256_ps(static_cast<__m256i>(c)),
+                       _mm256_castsi256_ps(static_cast<__m256i>(b)),
+                       _mm256_castsi256_ps(static_cast<__m256i>(a)))));
+}
+
 template <>
 class simd<std::int64_t, simd_abi::avx2_fixed_size<4>> {
   __m256i m_value;
@@ -700,7 +1919,8 @@ class simd<std::int64_t, simd_abi::avx2_fixed_size<4>> {
                 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)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
       : m_value(_mm256_setr_epi64x(
             gen(std::integral_constant<std::size_t, 0>()),
             gen(std::integral_constant<std::size_t, 1>()),
@@ -723,72 +1943,167 @@ 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) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(ptr));
+#else
     m_value = _mm256_maskload_epi64(reinterpret_cast<long long const*>(ptr),
                                     static_cast<__m256i>(mask_type(true)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm256_load_si256(reinterpret_cast<__m256i const*>(ptr));
+#else
+    m_value = _mm256_maskload_epi64(reinterpret_cast<long long const*>(ptr),
+                                    static_cast<__m256i>(mask_type(true)));
+#endif
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
     _mm256_maskstore_epi64(reinterpret_cast<long long*>(ptr),
                            static_cast<__m256i>(mask_type(true)), m_value);
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _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 {
     return m_value;
   }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(
+        _mm256_sub_epi64(_mm256_set1_epi64x(0), static_cast<__m256i>(m_value)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_sub_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_add_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+
+  // fallback simd multiplication using generator constructor
+  // multiplying vectors of 64-bit signed integers is not available in AVX2
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd([&](std::size_t i) { return lhs[i] * rhs[i]; });
+  }
+
   // AVX2 only has eq and gt comparisons for int64
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm256_cmpeq_epi64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpeq_epi64(static_cast<__m256i>(lhs),
+                                        static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpgt_epi64(static_cast<__m256i>(lhs),
+                                        static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return rhs > lhs;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm256_cmpgt_epi64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return (lhs < rhs) || (lhs == rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return other > (*this);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return (lhs > rhs) || (lhs == rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return ((*this) < other) || ((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return ((*this) > other) || ((*this) == other);
+
+  // fallback simd shift right arithmetic using generator constructor
+  // Shift right arithmetic for 64bit packed ints is not availalbe in AVX2
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd([&](std::size_t i) { return lhs[i] >> rhs; });
+  }
+
+  // fallback simd shift right arithmetic using generator constructor
+  // Shift right arithmetic for 64bit packed ints is not availalbe in AVX2
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd([&](std::size_t i) { return lhs[i] >> rhs[i]; });
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_slli_epi64(static_cast<__m256i>(lhs), rhs));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !((*this) == other);
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_sllv_epi64(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
   }
 };
 
+}  // namespace Experimental
+
+// Manually computing absolute values, because _mm256_abs_epi64
+// is not in AVX2; it's available in AVX512.
 [[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_sub_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<std::int64_t, Experimental::simd_abi::avx2_fixed_size<4>>
+    abs(Experimental::simd<
+        std::int64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<std::int64_t,
+                            Experimental::simd_abi::avx2_fixed_size<4>>(
+      [&](std::size_t i) { return (a[i] < 0) ? -a[i] : a[i]; });
 }
 
 [[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& a) {
-  return simd<std::int64_t, simd_abi::avx2_fixed_size<4>>(0) - a;
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    floor(Experimental::simd<
+          std::int64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
 }
 
 [[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)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    ceil(Experimental::simd<
+         std::int64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
 }
 
-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,
-    simd<std::int64_t, simd_abi::avx2_fixed_size<4>> const& b,
-    simd<std::int64_t, simd_abi::avx2_fixed_size<4>> const& c) {
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    round(Experimental::simd<
+          std::int64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    trunc(Experimental::simd<
+          std::int64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
+}
+
+namespace Experimental {
+
+[[nodiscard]] 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,
+              simd<std::int64_t, simd_abi::avx2_fixed_size<4>> const& b,
+              simd<std::int64_t, simd_abi::avx2_fixed_size<4>> const& c) {
   return simd<std::int64_t, simd_abi::avx2_fixed_size<4>>(_mm256_castpd_si256(
       _mm256_blendv_pd(_mm256_castsi256_pd(static_cast<__m256i>(c)),
                        _mm256_castsi256_pd(static_cast<__m256i>(b)),
@@ -822,7 +2137,8 @@ class simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> {
                 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)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
       : m_value(_mm256_setr_epi64x(
             gen(std::integral_constant<std::size_t, 0>()),
             gen(std::integral_constant<std::size_t, 1>()),
@@ -845,46 +2161,90 @@ class simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(ptr));
+#else
     m_value = _mm256_maskload_epi64(reinterpret_cast<long long const*>(ptr),
                                     static_cast<__m256i>(mask_type(true)));
+#endif
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator>>(unsigned int rhs) const {
-    return _mm256_srli_epi64(m_value, rhs);
-  }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator>>(
-      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& rhs) const {
-    return _mm256_srlv_epi64(m_value,
-                             _mm256_cvtepi32_epi64(static_cast<__m128i>(rhs)));
-  }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator<<(unsigned int rhs) const {
-    return _mm256_slli_epi64(m_value, rhs);
-  }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator<<(
-      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& rhs) const {
-    return _mm256_sllv_epi64(m_value,
-                             _mm256_cvtepi32_epi64(static_cast<__m128i>(rhs)));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    m_value = _mm256_load_si256(reinterpret_cast<__m256i const*>(ptr));
+#else
+    m_value = _mm256_maskload_epi64(reinterpret_cast<long long const*>(ptr),
+                                    static_cast<__m256i>(mask_type(true)));
+#endif
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator&(simd const& other) const {
-    return _mm256_and_si256(m_value, other.m_value);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm256_maskstore_epi64(reinterpret_cast<long long*>(ptr),
+                           static_cast<__m256i>(mask_type(true)), m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator|(simd const& other) const {
-    return _mm256_or_si256(m_value, other.m_value);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _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 {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm256_cmpeq_epi64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_add_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_sub_epi64(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+
+  // fallback simd multiplication using generator constructor
+  // multiplying vectors of 64-bit unsigned integers is not available in AVX2
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd([&](std::size_t i) { return lhs[i] * rhs[i]; });
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return _mm256_srli_epi64(static_cast<__m256i>(lhs), rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm256_srlv_epi64(static_cast<__m256i>(lhs),
+                             static_cast<__m256i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return _mm256_slli_epi64(static_cast<__m256i>(lhs), rhs);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm256_sllv_epi64(static_cast<__m256i>(lhs),
+                             static_cast<__m256i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator&(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm256_and_si256(static_cast<__m256i>(lhs),
+                            static_cast<__m256i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator|(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm256_or_si256(static_cast<__m256i>(lhs),
+                           static_cast<__m256i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpeq_epi64(static_cast<__m256i>(lhs),
+                                        static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
   }
 };
 
@@ -893,27 +2253,54 @@ 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)) {}
 
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint64_t, Experimental::simd_abi::avx2_fixed_size<4>>
+abs(Experimental::simd<std::uint64_t,
+                       Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    floor(Experimental::simd<
+          std::uint64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    ceil(Experimental::simd<
+         std::uint64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
+}
+
 [[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)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    round(Experimental::simd<
+          std::uint64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
 }
 
 [[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)));
+    Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>
+    trunc(Experimental::simd<
+          std::uint64_t, Experimental::simd_abi::avx2_fixed_size<4>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::avx2_fixed_size<4>>(
+      _mm256_setr_pd(a[0], a[1], a[2], a[3]));
 }
 
-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,
-    simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& b,
-    simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& c) {
+namespace Experimental {
+
+[[nodiscard]] 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,
+              simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& b,
+              simd<std::uint64_t, simd_abi::avx2_fixed_size<4>> const& c) {
   return simd<std::uint64_t, simd_abi::avx2_fixed_size<4>>(_mm256_castpd_si256(
       _mm256_blendv_pd(_mm256_castsi256_pd(static_cast<__m256i>(c)),
                        _mm256_castsi256_pd(static_cast<__m256i>(b)),
@@ -950,6 +2337,11 @@ class const_where_expression<simd_mask<double, simd_abi::avx2_fixed_size<4>>,
                         static_cast<__m256d>(m_value));
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(double* mem, vector_aligned_tag) const {
+    _mm256_maskstore_pd(mem, _mm256_castpd_si256(static_cast<__m256d>(m_mask)),
+                        static_cast<__m256d>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void scatter_to(
       double* mem,
       simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) const {
@@ -986,11 +2378,16 @@ class where_expression<simd_mask<double, simd_abi::avx2_fixed_size<4>>,
         mem, _mm256_castpd_si256(static_cast<__m256d>(m_mask))));
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(double const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm256_maskload_pd(
+        mem, _mm256_castpd_si256(static_cast<__m256d>(m_mask))));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void gather_from(
       double const* mem,
       simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) {
     m_value = value_type(_mm256_mask_i32gather_pd(
-        _mm256_set1_pd(0.0), mem, static_cast<__m128i>(index),
+        static_cast<__m256d>(m_value), mem, static_cast<__m128i>(index),
         static_cast<__m256d>(m_mask), 8));
   }
   template <class U,
@@ -1007,6 +2404,183 @@ class where_expression<simd_mask<double, simd_abi::avx2_fixed_size<4>>,
   }
 };
 
+template <>
+class const_where_expression<simd_mask<float, simd_abi::avx2_fixed_size<4>>,
+                             simd<float, simd_abi::avx2_fixed_size<4>>> {
+ public:
+  using abi_type   = simd_abi::avx2_fixed_size<4>;
+  using value_type = simd<float, abi_type>;
+  using mask_type  = simd_mask<float, 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(float* mem, element_aligned_tag) const {
+    _mm_maskstore_ps(mem, _mm_castps_si128(static_cast<__m128>(m_mask)),
+                     static_cast<__m128>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(float* mem, vector_aligned_tag) const {
+    _mm_maskstore_ps(mem, _mm_castps_si128(static_cast<__m128>(m_mask)),
+                     static_cast<__m128>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      float* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) const {
+    for (std::size_t lane = 0; lane < 4; ++lane) {
+      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 <>
+class where_expression<simd_mask<float, simd_abi::avx2_fixed_size<4>>,
+                       simd<float, simd_abi::avx2_fixed_size<4>>>
+    : public const_where_expression<
+          simd_mask<float, simd_abi::avx2_fixed_size<4>>,
+          simd<float, simd_abi::avx2_fixed_size<4>>> {
+ public:
+  where_expression(
+      simd_mask<float, simd_abi::avx2_fixed_size<4>> const& mask_arg,
+      simd<float, simd_abi::avx2_fixed_size<4>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, element_aligned_tag) {
+    m_value = value_type(
+        _mm_maskload_ps(mem, _mm_castps_si128(static_cast<__m128>(m_mask))));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, vector_aligned_tag) {
+    m_value = value_type(
+        _mm_maskload_ps(mem, _mm_castps_si128(static_cast<__m128>(m_mask))));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      float const* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) {
+    m_value = value_type(_mm_mask_i32gather_ps(static_cast<__m128>(m_value),
+                                               mem, static_cast<__m128i>(index),
+                                               static_cast<__m128>(m_mask), 4));
+  }
+  template <class U,
+            std::enable_if_t<std::is_convertible_v<
+                                 U, simd<float, 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<float, simd_abi::avx2_fixed_size<4>>>(
+            std::forward<U>(x));
+    m_value = simd<float, simd_abi::avx2_fixed_size<4>>(_mm_blendv_ps(
+        static_cast<__m128>(m_value), static_cast<__m128>(x_as_value_type),
+        static_cast<__m128>(m_mask)));
+  }
+};
+
+template <>
+class const_where_expression<simd_mask<float, simd_abi::avx2_fixed_size<8>>,
+                             simd<float, simd_abi::avx2_fixed_size<8>>> {
+ public:
+  using abi_type   = simd_abi::avx2_fixed_size<8>;
+  using value_type = simd<float, abi_type>;
+  using mask_type  = simd_mask<float, 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(float* mem, element_aligned_tag) const {
+    _mm256_maskstore_ps(mem, _mm256_castps_si256(static_cast<__m256>(m_mask)),
+                        static_cast<__m256>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(float* mem, vector_aligned_tag) const {
+    _mm256_maskstore_ps(mem, _mm256_castps_si256(static_cast<__m256>(m_mask)),
+                        static_cast<__m256>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      float* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<8>> const& index) const {
+    for (std::size_t lane = 0; lane < value_type::size(); ++lane) {
+      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 <>
+class where_expression<simd_mask<float, simd_abi::avx2_fixed_size<8>>,
+                       simd<float, simd_abi::avx2_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<float, simd_abi::avx2_fixed_size<8>>,
+          simd<float, simd_abi::avx2_fixed_size<8>>> {
+ public:
+  where_expression(
+      simd_mask<float, simd_abi::avx2_fixed_size<8>> const& mask_arg,
+      simd<float, simd_abi::avx2_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, element_aligned_tag) {
+    m_value = value_type(_mm256_maskload_ps(
+        mem, _mm256_castps_si256(static_cast<__m256>(m_mask))));
+  }
+  void copy_from(float const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm256_maskload_ps(
+        mem, _mm256_castps_si256(static_cast<__m256>(m_mask))));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      float const* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<8>> const& index) {
+    m_value = value_type(_mm256_mask_i32gather_ps(
+        static_cast<__m256>(m_value), mem, static_cast<__m256i>(index),
+        static_cast<__m256>(m_mask), 4));
+  }
+  template <class U,
+            std::enable_if_t<std::is_convertible_v<
+                                 U, simd<float, simd_abi::avx2_fixed_size<8>>>,
+                             bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
+    auto const x_as_value_type =
+        static_cast<simd<float, simd_abi::avx2_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<float, simd_abi::avx2_fixed_size<8>>(_mm256_blendv_ps(
+        static_cast<__m256>(m_value), static_cast<__m256>(x_as_value_type),
+        static_cast<__m256>(m_mask)));
+  }
+};
+
 template <>
 class const_where_expression<
     simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>>,
@@ -1029,6 +2603,20 @@ class const_where_expression<
     _mm_maskstore_epi32(mem, static_cast<__m128i>(m_mask),
                         static_cast<__m128i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int32_t* mem, vector_aligned_tag) const {
+    _mm_maskstore_epi32(mem, static_cast<__m128i>(m_mask),
+                        static_cast<__m128i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int32_t* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) const {
+    for (std::size_t lane = 0; lane < 4; ++lane) {
+      if (m_mask[lane]) mem[index[lane]] = m_value[lane];
+    }
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -1054,7 +2642,30 @@ class where_expression<simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>>,
       : const_where_expression(mask_arg, value_arg) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void copy_from(std::int32_t const* mem, element_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m128i tmp = _mm_loadu_si128(reinterpret_cast<__m128i const*>(mem));
+    m_value     = value_type(_mm_and_si128(tmp, static_cast<__m128i>(m_mask)));
+#else
     m_value = value_type(_mm_maskload_epi32(mem, static_cast<__m128i>(m_mask)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, vector_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m128i tmp = _mm_load_si128(reinterpret_cast<__m128i const*>(mem));
+    m_value     = value_type(_mm_and_si128(tmp, static_cast<__m128i>(m_mask)));
+#else
+    m_value = value_type(_mm_maskload_epi32(mem, static_cast<__m128i>(m_mask)));
+#endif
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int32_t const* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) {
+    m_value = value_type(_mm_mask_i32gather_epi32(
+        static_cast<__m128i>(m_value), mem, static_cast<__m128i>(index),
+        static_cast<__m128i>(m_mask), 4));
   }
   template <
       class U,
@@ -1072,6 +2683,109 @@ class where_expression<simd_mask<std::int32_t, simd_abi::avx2_fixed_size<4>>,
   }
 };
 
+template <>
+class const_where_expression<
+    simd_mask<std::int32_t, simd_abi::avx2_fixed_size<8>>,
+    simd<std::int32_t, simd_abi::avx2_fixed_size<8>>> {
+ public:
+  using abi_type   = simd_abi::avx2_fixed_size<8>;
+  using value_type = simd<std::int32_t, abi_type>;
+  using mask_type  = simd_mask<std::int32_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::int32_t* mem, element_aligned_tag) const {
+    _mm256_maskstore_epi32(mem, static_cast<__m256i>(m_mask),
+                           static_cast<__m256i>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int32_t* mem, vector_aligned_tag) const {
+    _mm256_maskstore_epi32(mem, static_cast<__m256i>(m_mask),
+                           static_cast<__m256i>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int32_t* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<8>> const& index) const {
+    for (std::size_t lane = 0; lane < value_type::size(); ++lane) {
+      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 <>
+class where_expression<simd_mask<std::int32_t, simd_abi::avx2_fixed_size<8>>,
+                       simd<std::int32_t, simd_abi::avx2_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<std::int32_t, simd_abi::avx2_fixed_size<8>>,
+          simd<std::int32_t, simd_abi::avx2_fixed_size<8>>> {
+ public:
+  where_expression(
+      simd_mask<std::int32_t, simd_abi::avx2_fixed_size<8>> const& mask_arg,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, element_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m256i tmp = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(mem));
+    m_value = value_type(_mm256_and_si256(tmp, static_cast<__m256i>(m_mask)));
+#else
+    m_value =
+        value_type(_mm256_maskload_epi32(mem, static_cast<__m256i>(m_mask)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, vector_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m256i tmp = _mm256_load_si256(reinterpret_cast<__m256i const*>(mem));
+    m_value = value_type(_mm256_and_si256(tmp, static_cast<__m256i>(m_mask)));
+#else
+    m_value =
+        value_type(_mm256_maskload_epi32(mem, static_cast<__m256i>(m_mask)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int32_t const* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<8>> const& index) {
+    m_value = value_type(_mm256_mask_i32gather_epi32(
+        static_cast<__m256i>(m_value), mem, static_cast<__m256i>(index),
+        static_cast<__m256i>(m_mask), 4));
+  }
+  template <
+      class U,
+      std::enable_if_t<std::is_convertible_v<
+                           U, simd<std::int32_t, simd_abi::avx2_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::avx2_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<std::int32_t, simd_abi::avx2_fixed_size<8>>(
+        _mm256_castps_si256(_mm256_blendv_ps(
+            _mm256_castsi256_ps(static_cast<__m256i>(m_value)),
+            _mm256_castsi256_ps(static_cast<__m256i>(x_as_value_type)),
+            _mm256_castsi256_ps(static_cast<__m256i>(m_mask)))));
+  }
+};
+
 template <>
 class const_where_expression<
     simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>>,
@@ -1095,6 +2809,21 @@ class const_where_expression<
                            static_cast<__m256i>(m_mask),
                            static_cast<__m256i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(std::int64_t* mem,
+                                                     vector_aligned_tag) const {
+    _mm256_maskstore_epi64(reinterpret_cast<long long*>(mem),
+                           static_cast<__m256i>(m_mask),
+                           static_cast<__m256i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int64_t* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) const {
+    for (std::size_t lane = 0; lane < 4; ++lane) {
+      if (m_mask[lane]) mem[index[lane]] = m_value[lane];
+    }
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -1120,8 +2849,32 @@ class where_expression<simd_mask<std::int64_t, simd_abi::avx2_fixed_size<4>>,
       : const_where_expression(mask_arg, value_arg) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(std::int64_t const* mem,
                                                        element_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m256i tmp = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(mem));
+    m_value = value_type(_mm256_and_si256(tmp, static_cast<__m256i>(m_mask)));
+#else
+    m_value = value_type(_mm256_maskload_epi64(
+        reinterpret_cast<long long const*>(mem), static_cast<__m256i>(m_mask)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(std::int64_t const* mem,
+                                                       vector_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m256i tmp = _mm256_load_si256(reinterpret_cast<__m256i const*>(mem));
+    m_value = value_type(_mm256_and_si256(tmp, static_cast<__m256i>(m_mask)));
+#else
     m_value = value_type(_mm256_maskload_epi64(
         reinterpret_cast<long long const*>(mem), static_cast<__m256i>(m_mask)));
+#endif
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int64_t const* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) {
+    m_value = value_type(_mm256_mask_i32gather_epi64(
+        static_cast<__m256i>(m_value), reinterpret_cast<long long const*>(mem),
+        static_cast<__m128i>(index), static_cast<__m256i>(m_mask), 8));
   }
   template <
       class u,
@@ -1163,6 +2916,21 @@ class const_where_expression<
                            static_cast<__m256i>(m_mask),
                            static_cast<__m256i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(std::uint64_t* mem,
+                                                     vector_aligned_tag) const {
+    _mm256_maskstore_epi64(reinterpret_cast<long long*>(mem),
+                           static_cast<__m256i>(m_mask),
+                           static_cast<__m256i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::uint64_t* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) const {
+    for (std::size_t lane = 0; lane < 4; ++lane) {
+      if (m_mask[lane]) mem[index[lane]] = m_value[lane];
+    }
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -1188,8 +2956,32 @@ class where_expression<simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>>,
       : const_where_expression(mask_arg, value_arg) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(std::uint64_t const* mem,
                                                        element_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m256i tmp = _mm256_loadu_si256(reinterpret_cast<__m256i const*>(mem));
+    m_value = value_type(_mm256_and_si256(tmp, static_cast<__m256i>(m_mask)));
+#else
+    m_value = value_type(_mm256_maskload_epi64(
+        reinterpret_cast<long long const*>(mem), static_cast<__m256i>(m_mask)));
+#endif
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(std::uint64_t const* mem,
+                                                       vector_aligned_tag) {
+#ifdef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+    __m256i tmp = _mm256_load_si256(reinterpret_cast<__m256i const*>(mem));
+    m_value = value_type(_mm256_and_si256(tmp, static_cast<__m256i>(m_mask)));
+#else
     m_value = value_type(_mm256_maskload_epi64(
         reinterpret_cast<long long const*>(mem), static_cast<__m256i>(m_mask)));
+#endif
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::uint64_t const* mem,
+      simd<std::int32_t, simd_abi::avx2_fixed_size<4>> const& index) {
+    m_value = value_type(_mm256_mask_i32gather_epi64(
+        static_cast<__m256i>(m_value), reinterpret_cast<long long const*>(mem),
+        static_cast<__m128i>(index), static_cast<__m256i>(m_mask), 8));
   }
   template <class u,
             std::enable_if_t<
@@ -1211,4 +3003,6 @@ class where_expression<simd_mask<std::uint64_t, simd_abi::avx2_fixed_size<4>>,
 }  // namespace Experimental
 }  // namespace Kokkos
 
+#undef KOKKOS_IMPL_WORKAROUND_ROCM_AVX2_ISSUE
+
 #endif
diff --git a/simd/src/Kokkos_SIMD_AVX512.hpp b/simd/src/Kokkos_SIMD_AVX512.hpp
index 240314a8c1..84e8af3cd7 100644
--- a/simd/src/Kokkos_SIMD_AVX512.hpp
+++ b/simd/src/Kokkos_SIMD_AVX512.hpp
@@ -25,6 +25,11 @@
 
 #include <immintrin.h>
 
+#ifdef KOKKOS_SIMD_COMMON_MATH_HPP
+#error \
+    "Kokkos_SIMD_AVX512.hpp must be included before Kokkos_SIMD_Common_Math.hpp!"
+#endif
+
 namespace Kokkos {
 namespace Experimental {
 
@@ -72,6 +77,29 @@ class simd_mask<T, simd_abi::avx512_fixed_size<8>> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
       simd_mask<U, simd_abi::avx512_fixed_size<8>> const& other)
       : m_value(static_cast<__mmask8>(other)) {}
+  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_mask(G&& gen) : m_value(false) {
+    reference(m_value, int(0)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 0>()));
+    reference(m_value, int(1)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 1>()));
+    reference(m_value, int(2)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 2>()));
+    reference(m_value, int(3)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 3>()));
+    reference(m_value, int(4)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 4>()));
+    reference(m_value, int(5)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 5>()));
+    reference(m_value, int(6)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 6>()));
+    reference(m_value, int(7)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 7>()));
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
     return 8;
   }
@@ -112,12 +140,128 @@ class simd_mask<T, simd_abi::avx512_fixed_size<8>> {
   }
 };
 
+template <class T>
+class simd_mask<T, simd_abi::avx512_fixed_size<16>> {
+  __mmask16 m_value;
+
+ public:
+  class reference {
+    __mmask16& m_mask;
+    int m_lane;
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION __mmask16 bit_mask() const {
+      return __mmask16(std::int32_t(1 << m_lane));
+    }
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(__mmask16& mask_arg,
+                                                    int lane_arg)
+        : m_mask(mask_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(bool value) const {
+      if (value) {
+        m_mask |= bit_mask();
+      } else {
+        m_mask &= ~bit_mask();
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator bool() const {
+      return (m_mask & bit_mask()) != 0;
+    }
+  };
+  using value_type                                  = bool;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask() = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd_mask(value_type value)
+      : m_value(-std::int32_t(value)) {}
+  template <class U>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
+      simd_mask<U, simd_abi::avx512_fixed_size<16>> const& other)
+      : m_value(static_cast<__mmask16>(other)) {}
+  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_mask(G&& gen) : m_value(false) {
+    reference(m_value, int(0)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 0>()));
+    reference(m_value, int(1)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 1>()));
+    reference(m_value, int(2)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 2>()));
+    reference(m_value, int(3)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 3>()));
+    reference(m_value, int(4)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 4>()));
+    reference(m_value, int(5)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 5>()));
+    reference(m_value, int(6)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 6>()));
+    reference(m_value, int(7)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 7>()));
+    reference(m_value, int(8)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 8>()));
+    reference(m_value, int(9)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 9>()));
+    reference(m_value, int(10)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 10>()));
+    reference(m_value, int(11)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 11>()));
+    reference(m_value, int(12)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 12>()));
+    reference(m_value, int(13)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 13>()));
+    reference(m_value, int(14)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 14>()));
+    reference(m_value, int(15)) =
+        static_cast<bool>(gen(std::integral_constant<std::size_t, 15>()));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
+    return 16;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      __mmask16 const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __mmask16()
+      const {
+    return m_value;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  operator[](std::size_t i) const {
+    auto const bit_mask = __mmask16(std::int32_t(1 << i));
+    return (m_value & bit_mask) != 0;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator||(simd_mask const& other) const {
+    return simd_mask(_kor_mask16(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask
+  operator&&(simd_mask const& other) const {
+    return simd_mask(_kand_mask16(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask operator!() const {
+    static const __mmask16 true_value(static_cast<__mmask16>(simd_mask(true)));
+    return simd_mask(_kxor_mask16(true_value, m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator==(
+      simd_mask const& other) const {
+    return m_value == other.m_value;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator!=(
+      simd_mask const& other) const {
+    return m_value != other.m_value;
+  }
+};
+
 template <>
-class simd<std::int32_t, simd_abi::avx512_fixed_size<8>> {
-  __m256i m_value;
+class simd<double, simd_abi::avx512_fixed_size<8>> {
+  __m512d m_value;
 
  public:
-  using value_type = std::int32_t;
+  using value_type = double;
   using abi_type   = simd_abi::avx512_fixed_size<8>;
   using mask_type  = simd_mask<value_type, abi_type>;
   using reference  = value_type&;
@@ -132,12 +276,10 @@ class simd<std::int32_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(value_type(value))) {}
+      : m_value(_mm512_set1_pd(value_type(value))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
-      __m256i const& value_in)
+      __m512d const& value_in)
       : m_value(value_in) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::uint64_t, abi_type> const& other);
   template <class G,
             std::enable_if_t<
                 // basically, can you do { value_type r =
@@ -145,16 +287,17 @@ 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_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>()),
-                              gen(std::integral_constant<std::size_t, 2>()),
-                              gen(std::integral_constant<std::size_t, 3>()),
-                              gen(std::integral_constant<std::size_t, 4>()),
-                              gen(std::integral_constant<std::size_t, 5>()),
-                              gen(std::integral_constant<std::size_t, 6>()),
-                              gen(std::integral_constant<std::size_t, 7>()))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(_mm512_setr_pd(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>()),
+                               gen(std::integral_constant<std::size_t, 4>()),
+                               gen(std::integral_constant<std::size_t, 5>()),
+                               gen(std::integral_constant<std::size_t, 6>()),
+                               gen(std::integral_constant<std::size_t, 7>()))) {
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reinterpret_cast<value_type*>(&m_value)[i];
   }
@@ -162,92 +305,256 @@ class simd<std::int32_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;
-  }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm256_cmplt_epi32_mask(m_value, other.m_value));
+    m_value = _mm512_loadu_pd(ptr);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm256_cmplt_epi32_mask(other.m_value, m_value));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm512_load_pd(ptr);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(_mm256_cmple_epi32_mask(m_value, other.m_value));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm512_storeu_pd(ptr, m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(_mm256_cmple_epi32_mask(other.m_value, m_value));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm512_store_pd(ptr, m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm256_cmpeq_epi32_mask(m_value, other.m_value));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512d()
+      const {
+    return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return mask_type(_mm256_cmpneq_epi32_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm512_sub_pd(_mm512_set1_pd(0.0), m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_mul_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_div_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_add_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_sub_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_pd_mask(static_cast<__m512d>(lhs),
+                                        static_cast<__m512d>(rhs), _CMP_LT_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_pd_mask(static_cast<__m512d>(rhs),
+                                        static_cast<__m512d>(lhs), _CMP_GT_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_pd_mask(static_cast<__m512d>(lhs),
+                                        static_cast<__m512d>(rhs), _CMP_LE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_pd_mask(static_cast<__m512d>(rhs),
+                                        static_cast<__m512d>(lhs), _CMP_GE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_pd_mask(static_cast<__m512d>(lhs),
+                                        static_cast<__m512d>(rhs), _CMP_EQ_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_pd_mask(
+        static_cast<__m512d>(lhs), static_cast<__m512d>(rhs), _CMP_NEQ_OS));
   }
 };
 
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+copysign(
+    Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b) {
+  static const __m512i sign_mask =
+      reinterpret_cast<__m512i>(static_cast<__m512d>(
+          Experimental::simd<
+              double, Experimental::simd_abi::avx512_fixed_size<8>>(-0.0)));
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      reinterpret_cast<__m512d>(_mm512_xor_epi64(
+          _mm512_andnot_epi64(
+              sign_mask, reinterpret_cast<__m512i>(static_cast<__m512d>(a))),
+          _mm512_and_epi64(
+              sign_mask, reinterpret_cast<__m512i>(static_cast<__m512d>(b))))));
+}
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::avx512_fixed_size<8>>
-    operator*(simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_mullo_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    abs(Experimental::simd<
+        double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m512d const rhs = static_cast<__m512d>(a);
+#if defined(KOKKOS_COMPILER_GNU) && (KOKKOS_COMPILER_GNU < 830)
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      (__m512d)_mm512_and_epi64((__m512i)rhs,
+                                _mm512_set1_epi64(0x7fffffffffffffffLL)));
+#else
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_abs_pd(rhs));
+#endif
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::avx512_fixed_size<8>>
-    operator+(simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_add_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    floor(Experimental::simd<
+          double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m512d const val = static_cast<__m512d>(a);
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_roundscale_pd(val, _MM_FROUND_TO_NEG_INF));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_sub_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    ceil(Experimental::simd<
+         double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m512d const val = static_cast<__m512d>(a);
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_roundscale_pd(val, _MM_FROUND_TO_POS_INF));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(0) - a;
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    round(Experimental::simd<
+          double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m512d const val = static_cast<__m512d>(a);
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_roundscale_pd(val, _MM_FROUND_TO_NEAREST_INT));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::int32_t, simd_abi::avx512_fixed_size<8>> condition(
-    simd_mask<std::int32_t, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& b,
-    simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& c) {
-  return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_mask_blend_epi32(static_cast<__mmask8>(a), static_cast<__m256i>(c),
-                              static_cast<__m256i>(b)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    trunc(Experimental::simd<
+          double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m512d const val = static_cast<__m512d>(a);
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_roundscale_pd(val, _MM_FROUND_TO_ZERO));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    sqrt(Experimental::simd<
+         double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_sqrt_pd(static_cast<__m512d>(a)));
+}
+
+#ifdef __INTEL_COMPILER
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    cbrt(Experimental::simd<
+         double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cbrt_pd(static_cast<__m512d>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    exp(Experimental::simd<
+        double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_exp_pd(static_cast<__m512d>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    log(Experimental::simd<
+        double, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_log_pd(static_cast<__m512d>(a)));
+}
+
+#endif
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+fma(Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b,
+    Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& c) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_fmadd_pd(static_cast<__m512d>(a), static_cast<__m512d>(b),
+                      static_cast<__m512d>(c)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+max(Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_max_pd(static_cast<__m512d>(a), static_cast<__m512d>(b)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+min(Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<double,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_min_pd(static_cast<__m512d>(a), static_cast<__m512d>(b)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<double, simd_abi::avx512_fixed_size<8>>
+    condition(simd_mask<double, simd_abi::avx512_fixed_size<8>> const& a,
+              simd<double, simd_abi::avx512_fixed_size<8>> const& b,
+              simd<double, simd_abi::avx512_fixed_size<8>> const& c) {
+  return simd<double, simd_abi::avx512_fixed_size<8>>(
+      _mm512_mask_blend_pd(static_cast<__mmask8>(a), static_cast<__m512d>(c),
+                           static_cast<__m512d>(b)));
 }
 
 template <>
-class simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> {
-  __m256i m_value;
+class simd<float, simd_abi::avx512_fixed_size<8>> {
+  __m256 m_value;
 
  public:
-  using value_type = std::uint32_t;
+  using value_type = float;
   using abi_type   = simd_abi::avx512_fixed_size<8>;
   using mask_type  = simd_mask<value_type, abi_type>;
   using reference  = value_type&;
@@ -262,14 +569,25 @@ 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(
-            Kokkos::bit_cast<std::int32_t>(value_type(value)))) {}
+      : m_value(_mm256_set1_ps(value_type(value))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
-      __m256i const& value_in)
+      __m256 const& value_in)
       : m_value(value_in) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& other)
-      : m_value(static_cast<__m256i>(other)) {}
+  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_ps(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>()),
+                               gen(std::integral_constant<std::size_t, 4>()),
+                               gen(std::integral_constant<std::size_t, 5>()),
+                               gen(std::integral_constant<std::size_t, 6>()),
+                               gen(std::integral_constant<std::size_t, 7>()))) {
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reinterpret_cast<value_type*>(&m_value)[i];
   }
@@ -277,108 +595,274 @@ 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_from(value_type const* ptr,
+                                                       element_aligned_tag) {
+    m_value = _mm256_loadu_ps(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm256_load_ps(ptr);
+  }
   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);
+    _mm256_storeu_ps(ptr, 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 void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm256_store_ps(ptr, m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256()
       const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm256_cmplt_epu32_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm256_sub_ps(_mm256_set1_ps(0.0), m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm256_cmplt_epu32_mask(other.m_value, m_value));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_mul_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_div_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_add_ps(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_sub_ps(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(_mm256_cmple_epu32_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_LT_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(_mm256_cmple_epu32_mask(other.m_value, m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_GT_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm256_cmpeq_epu32_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_LE_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return mask_type(_mm256_cmpneq_epu32_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_GE_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_EQ_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_NEQ_OS));
   }
 };
 
+}  // namespace Experimental
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>>
+copysign(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b) {
+  __m256 const sign_mask = _mm256_set1_ps(-0.0);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_xor_ps(_mm256_andnot_ps(sign_mask, static_cast<__m256>(a)),
+                    _mm256_and_ps(sign_mask, static_cast<__m256>(b))));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> abs(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m256 const sign_mask = _mm256_set1_ps(-0.0);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_andnot_ps(sign_mask, static_cast<__m256>(a)));
+}
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>
-    operator*(simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_mullo_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>>
+    floor(Experimental::simd<
+          float, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m256 const val = static_cast<__m256>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_roundscale_ps(val, _MM_FROUND_TO_NEG_INF));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>
-    operator+(simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_add_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>>
+    ceil(Experimental::simd<
+         float, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m256 const val = static_cast<__m256>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_roundscale_ps(val, _MM_FROUND_TO_POS_INF));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_sub_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>>
+    round(Experimental::simd<
+          float, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m256 const val = static_cast<__m256>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_roundscale_ps(val, _MM_FROUND_TO_NEAREST_INT));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>>
+    trunc(Experimental::simd<
+          float, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m256 const val = static_cast<__m256>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_roundscale_ps(val, _MM_FROUND_TO_ZERO));
 }
 
 KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> condition(
-    simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& b,
-    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& c) {
-  return simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>(
-      _mm256_mask_blend_epi32(static_cast<__mmask8>(a), static_cast<__m256i>(c),
-                              static_cast<__m256i>(b)));
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> sqrt(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_sqrt_ps(static_cast<__m256>(a)));
 }
 
-template <>
-class simd<std::int64_t, simd_abi::avx512_fixed_size<8>> {
-  __m512i m_value;
+#ifdef __INTEL_COMPILER
 
- public:
-  using value_type = std::int64_t;
-  using abi_type   = simd_abi::avx512_fixed_size<8>;
-  using mask_type  = simd_mask<value_type, abi_type>;
-  using reference  = value_type&;
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
-  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;
-  }
-  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(value_type(value))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& other)
-      : m_value(_mm512_cvtepi32_epi64(static_cast<__m256i>(other))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& other);
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr simd(__m512i const& value_in)
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> cbrt(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_cbrt_ps(static_cast<__m256>(a)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> exp(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_exp_ps(static_cast<__m256>(a)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> log(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_log_ps(static_cast<__m256>(a)));
+}
+
+#endif
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> fma(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b,
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& c) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_fmadd_ps(static_cast<__m256>(a), static_cast<__m256>(b),
+                      static_cast<__m256>(c)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> max(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_max_ps(static_cast<__m256>(a), static_cast<__m256>(b)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<8>> min(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a,
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& b) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_min_ps(static_cast<__m256>(a), static_cast<__m256>(b)));
+}
+
+namespace Experimental {
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+simd<float, simd_abi::avx512_fixed_size<8>> condition(
+    simd_mask<float, simd_abi::avx512_fixed_size<8>> const& a,
+    simd<float, simd_abi::avx512_fixed_size<8>> const& b,
+    simd<float, simd_abi::avx512_fixed_size<8>> const& c) {
+  return simd<float, simd_abi::avx512_fixed_size<8>>(
+      _mm256_mask_blend_ps(static_cast<__mmask8>(a), static_cast<__m256>(c),
+                           static_cast<__m256>(b)));
+}
+
+template <>
+class simd<float, simd_abi::avx512_fixed_size<16>> {
+  __m512 m_value;
+
+ public:
+  using value_type = float;
+  using abi_type   = simd_abi::avx512_fixed_size<16>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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 16;
+  }
+  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_ps(value_type(value))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      __m512 const& value_in)
       : m_value(value_in) {}
+  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(
+            _mm512_setr_ps(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>()),
+                           gen(std::integral_constant<std::size_t, 4>()),
+                           gen(std::integral_constant<std::size_t, 5>()),
+                           gen(std::integral_constant<std::size_t, 6>()),
+                           gen(std::integral_constant<std::size_t, 7>()),
+                           gen(std::integral_constant<std::size_t, 8>()),
+                           gen(std::integral_constant<std::size_t, 9>()),
+                           gen(std::integral_constant<std::size_t, 10>()),
+                           gen(std::integral_constant<std::size_t, 11>()),
+                           gen(std::integral_constant<std::size_t, 12>()),
+                           gen(std::integral_constant<std::size_t, 13>()),
+                           gen(std::integral_constant<std::size_t, 14>()),
+                           gen(std::integral_constant<std::size_t, 15>()))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reinterpret_cast<value_type*>(&m_value)[i];
   }
@@ -388,104 +872,230 @@ class simd<std::int64_t, simd_abi::avx512_fixed_size<8>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
-    m_value = _mm512_loadu_si512(ptr);
+    m_value = _mm512_loadu_ps(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm512_load_ps(ptr);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
-    _mm512_storeu_si512(ptr, m_value);
+    _mm512_storeu_ps(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm512_store_ps(ptr, m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator>>(int rhs) const {
-    return _mm512_srai_epi64(m_value, rhs);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512()
+      const {
+    return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator>>(simd<int, simd_abi::avx512_fixed_size<8>> const& rhs) const {
-    return _mm512_srav_epi64(m_value,
-                             _mm512_cvtepi32_epi64(static_cast<__m256i>(rhs)));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm512_sub_ps(_mm512_set1_ps(0.0), m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator<<(int rhs) const {
-    return _mm512_slli_epi64(m_value, rhs);
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_mul_ps(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator<<(simd<int, simd_abi::avx512_fixed_size<8>> const& rhs) const {
-    return _mm512_sllv_epi64(m_value,
-                             _mm512_cvtepi32_epi64(static_cast<__m256i>(rhs)));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_div_ps(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512i()
-      const {
-    return m_value;
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_add_ps(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm512_cmplt_epi64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_sub_ps(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm512_cmplt_epi64_mask(other.m_value, m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_LT_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(_mm512_cmple_epi64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_GT_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(_mm512_cmple_epi64_mask(other.m_value, m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_LE_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm512_cmpeq_epi64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_GE_OS));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return mask_type(_mm512_cmpneq_epi64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_EQ_OS));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmp_ps_mask(lhs.m_value, rhs.m_value, _CMP_NEQ_OS));
   }
 };
 
+}  // namespace Experimental
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>>
+copysign(Experimental::simd<
+             float, Experimental::simd_abi::avx512_fixed_size<16>> const& a,
+         Experimental::simd<
+             float, Experimental::simd_abi::avx512_fixed_size<16>> const& b) {
+  __m512 const sign_mask = _mm512_set1_ps(-0.0);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_xor_ps(_mm512_andnot_ps(sign_mask, static_cast<__m512>(a)),
+                    _mm512_and_ps(sign_mask, static_cast<__m512>(b))));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> abs(
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  __m512 const sign_mask = _mm512_set1_ps(-0.0);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_andnot_ps(sign_mask, static_cast<__m512>(a)));
+}
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::avx512_fixed_size<8>>
-    operator*(simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_mullo_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>>
+    floor(Experimental::simd<
+          float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  __m512 const val = static_cast<__m512>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_roundscale_ps(val, _MM_FROUND_TO_NEG_INF));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::avx512_fixed_size<8>>
-    operator+(simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_add_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>>
+    ceil(Experimental::simd<
+         float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  __m512 const val = static_cast<__m512>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_roundscale_ps(val, _MM_FROUND_TO_POS_INF));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_sub_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>>
+    round(Experimental::simd<
+          float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  __m512 const val = static_cast<__m512>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_roundscale_ps(val, _MM_FROUND_TO_NEAREST_INT));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(0) - a;
+    Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>>
+    trunc(Experimental::simd<
+          float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  __m512 const val = static_cast<__m512>(a);
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_roundscale_ps(val, _MM_FROUND_TO_ZERO));
 }
 
 KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::int64_t, simd_abi::avx512_fixed_size<8>> condition(
-    simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& b,
-    simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& c) {
-  return simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_mask_blend_epi64(static_cast<__mmask8>(a), static_cast<__m512i>(c),
-                              static_cast<__m512i>(b)));
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> sqrt(
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_sqrt_ps(static_cast<__m512>(a)));
+}
+
+#ifdef __INTEL_COMPILER
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> cbrt(
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cbrt_ps(static_cast<__m512>(a)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> exp(
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_exp_ps(static_cast<__m512>(a)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> log(
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_log_ps(static_cast<__m512>(a)));
+}
+
+#endif
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> fma(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<16>> const& a,
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<16>> const& b,
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& c) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_fmadd_ps(static_cast<__m512>(a), static_cast<__m512>(b),
+                      static_cast<__m512>(c)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> max(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<16>> const& a,
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& b) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_max_ps(static_cast<__m512>(a), static_cast<__m512>(b)));
+}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+Experimental::simd<float, Experimental::simd_abi::avx512_fixed_size<16>> min(
+    Experimental::simd<float,
+                       Experimental::simd_abi::avx512_fixed_size<16>> const& a,
+    Experimental::simd<
+        float, Experimental::simd_abi::avx512_fixed_size<16>> const& b) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_min_ps(static_cast<__m512>(a), static_cast<__m512>(b)));
+}
+
+namespace Experimental {
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+simd<float, simd_abi::avx512_fixed_size<16>> condition(
+    simd_mask<float, simd_abi::avx512_fixed_size<16>> const& a,
+    simd<float, simd_abi::avx512_fixed_size<16>> const& b,
+    simd<float, simd_abi::avx512_fixed_size<16>> const& c) {
+  return simd<float, simd_abi::avx512_fixed_size<16>>(
+      _mm512_mask_blend_ps(static_cast<__mmask16>(a), static_cast<__m512>(c),
+                           static_cast<__m512>(b)));
 }
 
 template <>
-class simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> {
-  __m512i m_value;
+class simd<std::int32_t, simd_abi::avx512_fixed_size<8>> {
+  __m256i m_value;
 
  public:
-  using value_type = std::uint64_t;
+  using value_type = std::int32_t;
   using abi_type   = simd_abi::avx512_fixed_size<8>;
   using mask_type  = simd_mask<value_type, abi_type>;
   using reference  = value_type&;
@@ -500,16 +1110,30 @@ 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(
-            Kokkos::bit_cast<std::int64_t>(value_type(value)))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr simd(__m512i const& value_in)
+      : m_value(_mm256_set1_epi32(value_type(value))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      __m256i const& value_in)
       : m_value(value_in) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::int32_t, abi_type> const& other)
-      : m_value(_mm512_cvtepi32_epi64(static_cast<__m256i>(other))) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::int64_t, abi_type> const& other)
-      : m_value(static_cast<__m512i>(other)) {}
+      simd<std::uint64_t, abi_type> const& other);
+  template <class G,
+            std::enable_if_t<
+                // basically, can you do { value_type r =
+                // gen(std::integral_constant<std::size_t, i>()); }
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(
+            _mm256_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>()),
+                              gen(std::integral_constant<std::size_t, 4>()),
+                              gen(std::integral_constant<std::size_t, 5>()),
+                              gen(std::integral_constant<std::size_t, 6>()),
+                              gen(std::integral_constant<std::size_t, 7>()))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reinterpret_cast<value_type*>(&m_value)[i];
   }
@@ -519,119 +1143,167 @@ class simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
-    m_value = _mm512_loadu_si512(ptr);
+    m_value = _mm256_mask_loadu_epi32(
+        _mm256_set1_epi32(0), static_cast<__mmask8>(mask_type(true)), ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm256_mask_load_epi32(
+        _mm256_set1_epi32(0), static_cast<__mmask8>(mask_type(true)), ptr);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
-    _mm512_storeu_si512(ptr, m_value);
+    _mm256_mask_storeu_epi32(ptr, static_cast<__mmask8>(mask_type(true)),
+                             m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator>>(unsigned int rhs) const {
-    return _mm512_srli_epi64(m_value, rhs);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm256_mask_store_epi32(ptr, static_cast<__mmask8>(mask_type(true)),
+                            m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator>>(
-      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& rhs) const {
-    return _mm512_srlv_epi64(m_value,
-                             _mm512_cvtepi32_epi64(static_cast<__m256i>(rhs)));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m256i()
+      const {
+    return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator<<(unsigned int rhs) const {
-    return _mm512_slli_epi64(m_value, rhs);
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm256_sub_epi32(_mm256_set1_epi32(0), m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator<<(
-      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& rhs) const {
-    return _mm512_sllv_epi64(m_value,
-                             _mm512_cvtepi32_epi64(static_cast<__m256i>(rhs)));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_mullo_epi32(static_cast<__m256i>(lhs),
+                                   static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator&(simd const& other) const {
-    return _mm512_and_epi64(m_value, other.m_value);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
+        _mm256_add_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator|(simd const& other) const {
-    return _mm512_or_epi64(m_value, other.m_value);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
+        _mm256_sub_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512i()
-      const {
-    return m_value;
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmplt_epi32_mask(static_cast<__m256i>(lhs),
+                                             static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmplt_epi32_mask(static_cast<__m256i>(rhs),
+                                             static_cast<__m256i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmple_epi32_mask(static_cast<__m256i>(lhs),
+                                             static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm512_cmplt_epu64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmple_epi32_mask(static_cast<__m256i>(rhs),
+                                             static_cast<__m256i>(lhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm512_cmplt_epu64_mask(other.m_value, m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpeq_epi32_mask(static_cast<__m256i>(lhs),
+                                             static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(_mm512_cmple_epu64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpneq_epi32_mask(static_cast<__m256i>(lhs),
+                                              static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(_mm512_cmple_epu64_mask(other.m_value, m_value));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_srai_epi32(static_cast<__m256i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_srav_epi32(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm512_cmpeq_epu64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_slli_epi32(static_cast<__m256i>(lhs), rhs));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return mask_type(_mm512_cmpneq_epu64_mask(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_sllv_epi32(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
   }
 };
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>
-    operator*(simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_mullo_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::int32_t, Experimental::simd_abi::avx512_fixed_size<8>>
+abs(Experimental::simd<std::int32_t,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m256i const rhs = static_cast<__m256i>(a);
+  return Experimental::simd<std::int32_t,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm256_abs_epi32(rhs));
 }
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>
-    operator+(simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_add_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+floor(Experimental::simd<
+      std::int32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi32_pd(static_cast<__m256i>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_sub_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    ceil(Experimental::simd<
+         std::int32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi32_pd(static_cast<__m256i>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> condition(
-    simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& b,
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& c) {
-  return simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>(
-      _mm512_mask_blend_epi64(static_cast<__mmask8>(a), static_cast<__m512i>(c),
-                              static_cast<__m512i>(b)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+round(Experimental::simd<
+      std::int32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi32_pd(static_cast<__m256i>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::int32_t, simd_abi::avx512_fixed_size<8>>::simd(
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& other)
-    : m_value(_mm512_cvtepi64_epi32(static_cast<__m512i>(other))) {}
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+trunc(Experimental::simd<
+      std::int32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi32_pd(static_cast<__m256i>(a)));
+}
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::int64_t, simd_abi::avx512_fixed_size<8>>::simd(
-    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& other)
-    : m_value(static_cast<__m512i>(other)) {}
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int32_t, simd_abi::avx512_fixed_size<8>>
+    condition(simd_mask<std::int32_t, simd_abi::avx512_fixed_size<8>> const& a,
+              simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& b,
+              simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& c) {
+  return simd<std::int32_t, simd_abi::avx512_fixed_size<8>>(
+      _mm256_mask_blend_epi32(static_cast<__mmask8>(a), static_cast<__m256i>(c),
+                              static_cast<__m256i>(b)));
+}
 
 template <>
-class simd<double, simd_abi::avx512_fixed_size<8>> {
-  __m512d m_value;
+class simd<std::int32_t, simd_abi::avx512_fixed_size<16>> {
+  __m512i m_value;
 
  public:
-  using value_type = double;
-  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using value_type = std::int32_t;
+  using abi_type   = simd_abi::avx512_fixed_size<16>;
   using mask_type  = simd_mask<value_type, abi_type>;
   using reference  = value_type&;
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
@@ -640,15 +1312,43 @@ class simd<double, simd_abi::avx512_fixed_size<8>> {
   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 16;
   }
   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_pd(value_type(value))) {}
+      : m_value(_mm512_set1_epi32(value_type(value))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
-      __m512d const& value_in)
+      __m512i const& value_in)
       : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::uint64_t, abi_type> const& other);
+  template <class G,
+            std::enable_if_t<
+                // basically, can you do { value_type r =
+                // gen(std::integral_constant<std::size_t, i>()); }
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(_mm512_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>()),
+            gen(std::integral_constant<std::size_t, 4>()),
+            gen(std::integral_constant<std::size_t, 5>()),
+            gen(std::integral_constant<std::size_t, 6>()),
+            gen(std::integral_constant<std::size_t, 7>()),
+            gen(std::integral_constant<std::size_t, 8>()),
+            gen(std::integral_constant<std::size_t, 9>()),
+            gen(std::integral_constant<std::size_t, 10>()),
+            gen(std::integral_constant<std::size_t, 11>()),
+            gen(std::integral_constant<std::size_t, 12>()),
+            gen(std::integral_constant<std::size_t, 13>()),
+            gen(std::integral_constant<std::size_t, 14>()),
+            gen(std::integral_constant<std::size_t, 15>()))) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reinterpret_cast<value_type*>(&m_value)[i];
   }
@@ -656,181 +1356,1191 @@ class simd<double, 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 {
+    _mm512_mask_storeu_epi32(ptr, static_cast<__mmask16>(mask_type(true)),
+                             m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm512_mask_store_epi32(ptr, static_cast<__mmask16>(mask_type(true)),
+                            m_value);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
-    m_value = _mm512_loadu_pd(ptr);
+    m_value = _mm512_mask_loadu_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(mask_type(true)), ptr);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
-      value_type* ptr, element_aligned_tag) const {
-    _mm512_storeu_pd(ptr, m_value);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm512_mask_load_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(mask_type(true)), ptr);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512d()
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512i()
       const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(_mm512_cmp_pd_mask(m_value, other.m_value, _CMP_LT_OS));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm512_sub_epi32(_mm512_set1_epi32(0), m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_mullo_epi32(static_cast<__m512i>(lhs),
+                                   static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd<std::int32_t, simd_abi::avx512_fixed_size<16>>(
+        _mm512_add_epi32(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(_mm512_cmp_pd_mask(m_value, other.m_value, _CMP_GT_OS));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd<std::int32_t, simd_abi::avx512_fixed_size<16>>(
+        _mm512_sub_epi32(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(_mm512_cmp_pd_mask(m_value, other.m_value, _CMP_LE_OS));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epi32_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(_mm512_cmp_pd_mask(m_value, other.m_value, _CMP_GE_OS));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epi32_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(_mm512_cmp_pd_mask(m_value, other.m_value, _CMP_EQ_OS));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epi32_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return mask_type(_mm512_cmp_pd_mask(m_value, other.m_value, _CMP_NEQ_OS));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epi32_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpeq_epi32_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpneq_epi32_mask(static_cast<__m512i>(lhs),
+                                              static_cast<__m512i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm512_srai_epi32(static_cast<__m512i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_srav_epi32(static_cast<__m512i>(lhs),
+                                  static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm512_slli_epi32(static_cast<__m512i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_sllv_epi32(static_cast<__m512i>(lhs),
+                                  static_cast<__m512i>(rhs)));
   }
 };
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx512_fixed_size<8>>
-    operator*(simd<double, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<double, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_mul_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::int32_t, Experimental::simd_abi::avx512_fixed_size<16>>
+abs(Experimental::simd<
+    std::int32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  __m512i const rhs = static_cast<__m512i>(a);
+  return Experimental::simd<std::int32_t,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_abs_epi32(rhs));
 }
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx512_fixed_size<8>>
-    operator/(simd<double, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<double, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_div_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+floor(Experimental::simd<
+      std::int32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepi32_ps(static_cast<__m512i>(a)));
 }
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx512_fixed_size<8>>
-    operator+(simd<double, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<double, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_add_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+ceil(Experimental::simd<
+     std::int32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepi32_ps(static_cast<__m512i>(a)));
 }
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<double, simd_abi::avx512_fixed_size<8>> const& lhs,
-              simd<double, simd_abi::avx512_fixed_size<8>> const& rhs) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_sub_pd(static_cast<__m512d>(lhs), static_cast<__m512d>(rhs)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+round(Experimental::simd<
+      std::int32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepi32_ps(static_cast<__m512i>(a)));
 }
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::avx512_fixed_size<8>>
-    operator-(simd<double, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_sub_pd(_mm512_set1_pd(0.0), static_cast<__m512d>(a)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+trunc(Experimental::simd<
+      std::int32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepi32_ps(static_cast<__m512i>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> copysign(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& b) {
-  static const __m512i sign_mask = reinterpret_cast<__m512i>(
-      static_cast<__m512d>(simd<double, simd_abi::avx512_fixed_size<8>>(-0.0)));
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      reinterpret_cast<__m512d>(_mm512_xor_epi64(
-          _mm512_andnot_epi64(
-              sign_mask, reinterpret_cast<__m512i>(static_cast<__m512d>(a))),
-          _mm512_and_epi64(
-              sign_mask, reinterpret_cast<__m512i>(static_cast<__m512d>(b))))));
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int32_t, simd_abi::avx512_fixed_size<16>>
+    condition(simd_mask<std::int32_t, simd_abi::avx512_fixed_size<16>> const& a,
+              simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& b,
+              simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& c) {
+  return simd<std::int32_t, simd_abi::avx512_fixed_size<16>>(
+      _mm512_mask_blend_epi32(static_cast<__mmask16>(a),
+                              static_cast<__m512i>(c),
+                              static_cast<__m512i>(b)));
+}
+
+template <>
+class simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> {
+  __m256i m_value;
+
+ public:
+  using value_type = std::uint32_t;
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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;
+  }
+  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(
+            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) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& other)
+      : m_value(static_cast<__m256i>(other)) {}
+  template <class G,
+            std::enable_if_t<
+                // basically, can you do { value_type r =
+                // gen(std::integral_constant<std::size_t, i>()); }
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(
+            _mm256_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>()),
+                              gen(std::integral_constant<std::size_t, 4>()),
+                              gen(std::integral_constant<std::size_t, 5>()),
+                              gen(std::integral_constant<std::size_t, 6>()),
+                              gen(std::integral_constant<std::size_t, 7>()))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm256_mask_store_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 void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm256_mask_load_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;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_mullo_epi32(static_cast<__m256i>(lhs),
+                                   static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_add_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm256_sub_epi32(static_cast<__m256i>(lhs), static_cast<__m256i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmplt_epu32_mask(static_cast<__m256i>(lhs),
+                                             static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmplt_epu32_mask(static_cast<__m256i>(rhs),
+                                             static_cast<__m256i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmple_epu32_mask(static_cast<__m256i>(lhs),
+                                             static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmple_epu32_mask(static_cast<__m256i>(rhs),
+                                             static_cast<__m256i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpeq_epu32_mask(static_cast<__m256i>(lhs),
+                                             static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm256_cmpneq_epu32_mask(static_cast<__m256i>(lhs),
+                                              static_cast<__m256i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_srli_epi32(static_cast<__m256i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_srlv_epi32(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm256_slli_epi32(static_cast<__m256i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm256_sllv_epi32(static_cast<__m256i>(lhs),
+                                  static_cast<__m256i>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint32_t, Experimental::simd_abi::avx512_fixed_size<8>>
+abs(Experimental::simd<std::uint32_t,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+floor(Experimental::simd<
+      std::uint32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu32_pd(static_cast<__m256i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+ceil(Experimental::simd<
+     std::uint32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu32_pd(static_cast<__m256i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+round(Experimental::simd<
+      std::uint32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu32_pd(static_cast<__m256i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+trunc(Experimental::simd<
+      std::uint32_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu32_pd(static_cast<__m256i>(a)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>
+    condition(simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& a,
+              simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& b,
+              simd<std::uint32_t, simd_abi::avx512_fixed_size<8>> const& c) {
+  return simd<std::uint32_t, simd_abi::avx512_fixed_size<8>>(
+      _mm256_mask_blend_epi32(static_cast<__mmask8>(a), static_cast<__m256i>(c),
+                              static_cast<__m256i>(b)));
+}
+
+template <>
+class simd<std::uint32_t, simd_abi::avx512_fixed_size<16>> {
+  __m512i m_value;
+
+ public:
+  using value_type = std::uint32_t;
+  using abi_type   = simd_abi::avx512_fixed_size<16>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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 16;
+  }
+  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_epi32(
+            Kokkos::bit_cast<std::int32_t>(value_type(value)))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      __m512i const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& other)
+      : m_value(static_cast<__m512i>(other)) {}
+  template <class G,
+            std::enable_if_t<
+                // basically, can you do { value_type r =
+                // gen(std::integral_constant<std::size_t, i>()); }
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(_mm512_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>()),
+            gen(std::integral_constant<std::size_t, 4>()),
+            gen(std::integral_constant<std::size_t, 5>()),
+            gen(std::integral_constant<std::size_t, 6>()),
+            gen(std::integral_constant<std::size_t, 7>()),
+            gen(std::integral_constant<std::size_t, 8>()),
+            gen(std::integral_constant<std::size_t, 9>()),
+            gen(std::integral_constant<std::size_t, 10>()),
+            gen(std::integral_constant<std::size_t, 11>()),
+            gen(std::integral_constant<std::size_t, 12>()),
+            gen(std::integral_constant<std::size_t, 13>()),
+            gen(std::integral_constant<std::size_t, 14>()),
+            gen(std::integral_constant<std::size_t, 15>()))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_mask_loadu_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(mask_type(true)), ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm512_mask_load_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(mask_type(true)), ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    _mm512_mask_storeu_epi32(ptr, static_cast<__mmask16>(mask_type(true)),
+                             m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm512_mask_store_epi32(ptr, static_cast<__mmask16>(mask_type(true)),
+                            m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512i()
+      const {
+    return m_value;
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_mullo_epi32(static_cast<__m512i>(lhs),
+                                   static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_add_epi32(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_sub_epi32(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epu32_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epu32_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epu32_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epu32_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpeq_epu32_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpneq_epu32_mask(static_cast<__m512i>(lhs),
+                                              static_cast<__m512i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm512_srli_epi32(static_cast<__m512i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_srlv_epi32(static_cast<__m512i>(lhs),
+                                  static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(_mm512_slli_epi32(static_cast<__m512i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_sllv_epi32(static_cast<__m512i>(lhs),
+                                  static_cast<__m512i>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint32_t, Experimental::simd_abi::avx512_fixed_size<16>>
+abs(Experimental::simd<
+    std::uint32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+floor(Experimental::simd<
+      std::uint32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepu32_ps(static_cast<__m512i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+ceil(Experimental::simd<
+     std::uint32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepu32_ps(static_cast<__m512i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+round(Experimental::simd<
+      std::uint32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepu32_ps(static_cast<__m512i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::avx512_fixed_size<16>>
+trunc(Experimental::simd<
+      std::uint32_t, Experimental::simd_abi::avx512_fixed_size<16>> const& a) {
+  return Experimental::simd<float,
+                            Experimental::simd_abi::avx512_fixed_size<16>>(
+      _mm512_cvtepu32_ps(static_cast<__m512i>(a)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>
+    condition(
+        simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<16>> const& a,
+        simd<std::uint32_t, simd_abi::avx512_fixed_size<16>> const& b,
+        simd<std::uint32_t, simd_abi::avx512_fixed_size<16>> const& c) {
+  return simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>(
+      _mm512_mask_blend_epi32(static_cast<__mmask16>(a),
+                              static_cast<__m512i>(c),
+                              static_cast<__m512i>(b)));
+}
+
+template <>
+class simd<std::int64_t, simd_abi::avx512_fixed_size<8>> {
+  __m512i m_value;
+
+ public:
+  using value_type = std::int64_t;
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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;
+  }
+  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(value_type(value))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& other)
+      : m_value(_mm512_cvtepi32_epi64(static_cast<__m256i>(other))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& other);
+  template <class G,
+            std::enable_if_t<
+                // basically, can you do { value_type r =
+                // gen(std::integral_constant<std::size_t, i>()); }
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(
+            _mm512_setr_epi64(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>()),
+                              gen(std::integral_constant<std::size_t, 4>()),
+                              gen(std::integral_constant<std::size_t, 5>()),
+                              gen(std::integral_constant<std::size_t, 6>()),
+                              gen(std::integral_constant<std::size_t, 7>()))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr simd(__m512i const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm512_load_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 void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm512_store_si512(ptr, m_value);
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512i()
+      const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(_mm512_sub_epi64(_mm512_set1_epi64(0), m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_mullo_epi64(static_cast<__m512i>(lhs),
+                                   static_cast<__m512i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_add_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_sub_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epi64_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epi64_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epi64_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epi64_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpeq_epi64_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpneq_epi64_mask(static_cast<__m512i>(lhs),
+                                              static_cast<__m512i>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) {
+    return simd(_mm512_srai_epi64(static_cast<__m512i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) {
+    return simd(_mm512_srav_epi64(static_cast<__m512i>(lhs),
+                                  static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) {
+    return simd(_mm512_slli_epi64(static_cast<__m512i>(lhs), rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) {
+    return simd(_mm512_sllv_epi64(static_cast<__m512i>(lhs),
+                                  static_cast<__m512i>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::int64_t, Experimental::simd_abi::avx512_fixed_size<8>>
+abs(Experimental::simd<std::int64_t,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  __m512i const rhs = static_cast<__m512i>(a);
+  return Experimental::simd<std::int64_t,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_abs_epi64(rhs));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> abs(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a) {
-  __m512d const rhs = static_cast<__m512d>(a);
-  return simd<double, simd_abi::avx512_fixed_size<8>>(reinterpret_cast<__m512d>(
-      _mm512_and_epi64(_mm512_set1_epi64(0x7FFFFFFFFFFFFFFF),
-                       reinterpret_cast<__m512i>(rhs))));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+floor(Experimental::simd<
+      std::int64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi64_pd(static_cast<__m512i>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> sqrt(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_sqrt_pd(static_cast<__m512d>(a)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::avx512_fixed_size<8>>
+    ceil(Experimental::simd<
+         std::int64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi64_pd(static_cast<__m512i>(a)));
 }
 
-#ifdef __INTEL_COMPILER
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+round(Experimental::simd<
+      std::int64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi64_pd(static_cast<__m512i>(a)));
+}
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> cbrt(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_cbrt_pd(static_cast<__m512d>(a)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+trunc(Experimental::simd<
+      std::int64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepi64_pd(static_cast<__m512i>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> exp(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_exp_pd(static_cast<__m512d>(a)));
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int64_t, simd_abi::avx512_fixed_size<8>>
+    condition(simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>> const& a,
+              simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& b,
+              simd<std::int64_t, simd_abi::avx512_fixed_size<8>> const& c) {
+  return simd<std::int64_t, simd_abi::avx512_fixed_size<8>>(
+      _mm512_mask_blend_epi64(static_cast<__mmask8>(a), static_cast<__m512i>(c),
+                              static_cast<__m512i>(b)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> log(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_log_pd(static_cast<__m512d>(a)));
+template <>
+class simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> {
+  __m512i m_value;
+
+ public:
+  using value_type = std::uint64_t;
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  using reference  = value_type&;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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;
+  }
+  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(
+            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(
+      simd<std::int32_t, abi_type> const& other)
+      : m_value(_mm512_cvtepi32_epi64(static_cast<__m256i>(other))) {}
+  template <class G,
+            std::enable_if_t<
+                // basically, can you do { value_type r =
+                // gen(std::integral_constant<std::size_t, i>()); }
+                std::is_invocable_r_v<value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept
+      : m_value(
+            _mm512_setr_epi64(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>()),
+                              gen(std::integral_constant<std::size_t, 4>()),
+                              gen(std::integral_constant<std::size_t, 5>()),
+                              gen(std::integral_constant<std::size_t, 6>()),
+                              gen(std::integral_constant<std::size_t, 7>()))) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::int64_t, abi_type> const& other)
+      : m_value(static_cast<__m512i>(other)) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reinterpret_cast<value_type*>(&m_value)[i];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = _mm512_load_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 void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    _mm512_store_si512(ptr, m_value);
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator __m512i()
+      const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(_mm512_mullo_epi64(static_cast<__m512i>(lhs),
+                                   static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_add_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        _mm512_sub_epi64(static_cast<__m512i>(lhs), static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return _mm512_srli_epi64(static_cast<__m512i>(lhs), rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm512_srlv_epi64(static_cast<__m512i>(lhs),
+                             static_cast<__m512i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return _mm512_slli_epi64(static_cast<__m512i>(lhs), rhs);
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm512_sllv_epi64(static_cast<__m512i>(lhs),
+                             static_cast<__m512i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator&(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm512_and_epi64(static_cast<__m512i>(lhs),
+                            static_cast<__m512i>(rhs));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator|(
+      simd const& lhs, simd const& rhs) noexcept {
+    return _mm512_or_epi64(static_cast<__m512i>(lhs),
+                           static_cast<__m512i>(rhs));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epu64_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmplt_epu64_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epu64_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmple_epu64_mask(static_cast<__m512i>(rhs),
+                                             static_cast<__m512i>(lhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpeq_epu64_mask(static_cast<__m512i>(lhs),
+                                             static_cast<__m512i>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(_mm512_cmpneq_epu64_mask(static_cast<__m512i>(lhs),
+                                              static_cast<__m512i>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint64_t, Experimental::simd_abi::avx512_fixed_size<8>>
+abs(Experimental::simd<std::uint64_t,
+                       Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return a;
 }
 
-#endif
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+floor(Experimental::simd<
+      std::uint64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu64_pd(static_cast<__m512i>(a)));
+}
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> fma(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& b,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& c) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_fmadd_pd(static_cast<__m512d>(a), static_cast<__m512d>(b),
-                      static_cast<__m512d>(c)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+ceil(Experimental::simd<
+     std::uint64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu64_pd(static_cast<__m512i>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> max(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& b) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_max_pd(static_cast<__m512d>(a), static_cast<__m512d>(b)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+round(Experimental::simd<
+      std::uint64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu64_pd(static_cast<__m512i>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    double, Experimental::simd_abi::avx512_fixed_size<8>>
+trunc(Experimental::simd<
+      std::uint64_t, Experimental::simd_abi::avx512_fixed_size<8>> const& a) {
+  return Experimental::simd<double,
+                            Experimental::simd_abi::avx512_fixed_size<8>>(
+      _mm512_cvtepu64_pd(static_cast<__m512i>(a)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>
+    condition(simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& a,
+              simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& b,
+              simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& c) {
+  return simd<std::uint64_t, simd_abi::avx512_fixed_size<8>>(
+      _mm512_mask_blend_epi64(static_cast<__mmask8>(a), static_cast<__m512i>(c),
+                              static_cast<__m512i>(b)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> min(
-    simd<double, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& b) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_min_pd(static_cast<__m512d>(a), static_cast<__m512d>(b)));
-}
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+simd<std::int32_t, simd_abi::avx512_fixed_size<8>>::simd(
+    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& other)
+    : m_value(_mm512_cvtepi64_epi32(static_cast<__m512i>(other))) {}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+simd<std::int64_t, simd_abi::avx512_fixed_size<8>>::simd(
+    simd<std::uint64_t, simd_abi::avx512_fixed_size<8>> const& other)
+    : m_value(static_cast<__m512i>(other)) {}
+
+template <>
+class const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
+                             simd<double, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using value_type = simd<double, abi_type>;
+  using mask_type  = simd_mask<double, 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(double* mem, element_aligned_tag) const {
+    _mm512_mask_storeu_pd(mem, static_cast<__mmask8>(m_mask),
+                          static_cast<__m512d>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(double* mem, vector_aligned_tag) const {
+    _mm512_mask_store_pd(mem, static_cast<__mmask8>(m_mask),
+                         static_cast<__m512d>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      double* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
+    _mm512_mask_i32scatter_pd(mem, static_cast<__mmask8>(m_mask),
+                              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 <>
+class where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
+                       simd<double, simd_abi::avx512_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<double, simd_abi::avx512_fixed_size<8>>,
+          simd<double, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  where_expression(
+      simd_mask<double, simd_abi::avx512_fixed_size<8>> const& mask_arg,
+      simd<double, simd_abi::avx512_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(double const* mem, element_aligned_tag) {
+    m_value = value_type(_mm512_mask_loadu_pd(
+        _mm512_set1_pd(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(double const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm512_mask_load_pd(
+        _mm512_set1_pd(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      double const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
+    m_value = value_type(_mm512_mask_i32gather_pd(
+        static_cast<__m512d>(m_value), static_cast<__mmask8>(m_mask),
+        static_cast<__m256i>(index), mem, 8));
+  }
+  template <class U, std::enable_if_t<
+                         std::is_convertible_v<
+                             U, simd<double, 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<double, simd_abi::avx512_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<double, simd_abi::avx512_fixed_size<8>>(_mm512_mask_blend_pd(
+        static_cast<__mmask8>(m_mask), static_cast<__m512d>(m_value),
+        static_cast<__m512d>(x_as_value_type)));
+  }
+};
+
+template <>
+class const_where_expression<simd_mask<float, simd_abi::avx512_fixed_size<8>>,
+                             simd<float, simd_abi::avx512_fixed_size<8>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<8>;
+  using value_type = simd<float, abi_type>;
+  using mask_type  = simd_mask<float, 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(float* mem, element_aligned_tag) const {
+    _mm256_mask_storeu_ps(mem, static_cast<__mmask8>(m_mask),
+                          static_cast<__m256>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(float* mem, vector_aligned_tag) const {
+    _mm256_mask_store_ps(mem, static_cast<__mmask8>(m_mask),
+                         static_cast<__m256>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      float* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
+    _mm256_mask_i32scatter_ps(mem, static_cast<__mmask8>(m_mask),
+                              static_cast<__m256i>(index),
+                              static_cast<__m256>(m_value), 4);
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
+    return m_value;
+  }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::avx512_fixed_size<8>> condition(
-    simd_mask<double, simd_abi::avx512_fixed_size<8>> const& a,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& b,
-    simd<double, simd_abi::avx512_fixed_size<8>> const& c) {
-  return simd<double, simd_abi::avx512_fixed_size<8>>(
-      _mm512_mask_blend_pd(static_cast<__mmask8>(a), static_cast<__m512d>(c),
-                           static_cast<__m512d>(b)));
-}
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
 
 template <>
-class const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
-                             simd<double, simd_abi::avx512_fixed_size<8>>> {
+class where_expression<simd_mask<float, simd_abi::avx512_fixed_size<8>>,
+                       simd<float, simd_abi::avx512_fixed_size<8>>>
+    : public const_where_expression<
+          simd_mask<float, simd_abi::avx512_fixed_size<8>>,
+          simd<float, simd_abi::avx512_fixed_size<8>>> {
  public:
-  using abi_type   = simd_abi::avx512_fixed_size<8>;
-  using value_type = simd<double, abi_type>;
-  using mask_type  = simd_mask<double, abi_type>;
+  where_expression(
+      simd_mask<float, simd_abi::avx512_fixed_size<8>> const& mask_arg,
+      simd<float, simd_abi::avx512_fixed_size<8>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, element_aligned_tag) {
+    m_value = value_type(_mm256_mask_loadu_ps(
+        _mm256_set1_ps(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  void copy_from(float const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm256_mask_load_ps(
+        _mm256_set1_ps(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      float const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
+    __m256 on   = _mm256_castsi256_ps(_mm256_set1_epi32(-1));
+    __m256 mask = _mm256_maskz_mov_ps(static_cast<__mmask8>(m_mask), on);
+    m_value     = value_type(
+        _mm256_mask_i32gather_ps(static_cast<__m256>(m_value), mem,
+                                 static_cast<__m256i>(index), mask, 4));
+  }
+  template <
+      class U,
+      std::enable_if_t<
+          std::is_convertible_v<U, simd<float, 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<float, simd_abi::avx512_fixed_size<8>>>(
+            std::forward<U>(x));
+    m_value = simd<float, simd_abi::avx512_fixed_size<8>>(_mm256_mask_blend_ps(
+        static_cast<__mmask8>(m_mask), static_cast<__m256>(m_value),
+        static_cast<__m256>(x_as_value_type)));
+  }
+};
+
+template <>
+class const_where_expression<simd_mask<float, simd_abi::avx512_fixed_size<16>>,
+                             simd<float, simd_abi::avx512_fixed_size<16>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<16>;
+  using value_type = simd<float, abi_type>;
+  using mask_type  = simd_mask<float, abi_type>;
 
  protected:
   value_type& m_value;
@@ -841,17 +2551,22 @@ class const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
 
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-  void copy_to(double* mem, element_aligned_tag) const {
-    _mm512_mask_storeu_pd(mem, static_cast<__mmask8>(m_mask),
-                          static_cast<__m512d>(m_value));
+  void copy_to(float* mem, element_aligned_tag) const {
+    _mm512_mask_storeu_ps(mem, static_cast<__mmask16>(m_mask),
+                          static_cast<__m512>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(float* mem, vector_aligned_tag) const {
+    _mm512_mask_store_ps(mem, static_cast<__mmask16>(m_mask),
+                         static_cast<__m512>(m_value));
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void scatter_to(
-      double* mem,
-      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
-    _mm512_mask_i32scatter_pd(mem, static_cast<__mmask8>(m_mask),
-                              static_cast<__m256i>(index),
-                              static_cast<__m512d>(m_value), 8);
+      float* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& index) const {
+    _mm512_mask_i32scatter_ps(mem, static_cast<__mmask16>(m_mask),
+                              static_cast<__m512i>(index),
+                              static_cast<__m512>(m_value), 4);
   }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
@@ -866,40 +2581,45 @@ class const_where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
 };
 
 template <>
-class where_expression<simd_mask<double, simd_abi::avx512_fixed_size<8>>,
-                       simd<double, simd_abi::avx512_fixed_size<8>>>
+class where_expression<simd_mask<float, simd_abi::avx512_fixed_size<16>>,
+                       simd<float, simd_abi::avx512_fixed_size<16>>>
     : public const_where_expression<
-          simd_mask<double, simd_abi::avx512_fixed_size<8>>,
-          simd<double, simd_abi::avx512_fixed_size<8>>> {
+          simd_mask<float, simd_abi::avx512_fixed_size<16>>,
+          simd<float, simd_abi::avx512_fixed_size<16>>> {
  public:
   where_expression(
-      simd_mask<double, simd_abi::avx512_fixed_size<8>> const& mask_arg,
-      simd<double, simd_abi::avx512_fixed_size<8>>& value_arg)
+      simd_mask<float, simd_abi::avx512_fixed_size<16>> const& mask_arg,
+      simd<float, simd_abi::avx512_fixed_size<16>>& value_arg)
       : const_where_expression(mask_arg, value_arg) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-  void copy_from(double const* mem, element_aligned_tag) {
-    m_value = value_type(_mm512_mask_loadu_pd(
-        _mm512_set1_pd(0.0), static_cast<__mmask8>(m_mask), mem));
+  void copy_from(float const* mem, element_aligned_tag) {
+    m_value = value_type(_mm512_mask_loadu_ps(
+        _mm512_set1_ps(0.0), static_cast<__mmask16>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm512_mask_load_ps(
+        _mm512_set1_ps(0.0), static_cast<__mmask16>(m_mask), mem));
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void gather_from(
-      double const* mem,
-      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
-    m_value = value_type(_mm512_mask_i32gather_pd(
-        _mm512_set1_pd(0.0), static_cast<__mmask8>(m_mask),
-        static_cast<__m256i>(index), mem, 8));
+      float const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& index) {
+    m_value = value_type(_mm512_mask_i32gather_ps(
+        static_cast<__m512>(m_value), static_cast<__mmask16>(m_mask),
+        static_cast<__m512i>(index), mem, 4));
   }
   template <class U, std::enable_if_t<
                          std::is_convertible_v<
-                             U, simd<double, simd_abi::avx512_fixed_size<8>>>,
+                             U, simd<float, simd_abi::avx512_fixed_size<16>>>,
                          bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
     auto const x_as_value_type =
-        static_cast<simd<double, simd_abi::avx512_fixed_size<8>>>(
+        static_cast<simd<float, simd_abi::avx512_fixed_size<16>>>(
             std::forward<U>(x));
-    m_value = simd<double, simd_abi::avx512_fixed_size<8>>(_mm512_mask_blend_pd(
-        static_cast<__mmask8>(m_mask), static_cast<__m512d>(m_value),
-        static_cast<__m512d>(x_as_value_type)));
+    m_value = simd<float, simd_abi::avx512_fixed_size<16>>(_mm512_mask_blend_ps(
+        static_cast<__mmask16>(m_mask), static_cast<__m512>(m_value),
+        static_cast<__m512>(x_as_value_type)));
   }
 };
 
@@ -925,6 +2645,20 @@ class const_where_expression<
     _mm256_mask_storeu_epi32(mem, static_cast<__mmask8>(m_mask),
                              static_cast<__m256i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int32_t* mem, vector_aligned_tag) const {
+    _mm256_mask_store_epi32(mem, static_cast<__mmask8>(m_mask),
+                            static_cast<__m256i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int32_t* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
+    _mm256_mask_i32scatter_epi32(mem, static_cast<__mmask8>(m_mask),
+                                 static_cast<__m256i>(index),
+                                 static_cast<__m256i>(m_value), 4);
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -953,6 +2687,20 @@ 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));
   }
+  void copy_from(std::int32_t const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm256_mask_load_epi32(
+        _mm256_set1_epi32(0), static_cast<__mmask8>(m_mask), mem));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int32_t const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
+    m_value = value_type(_mm256_mmask_i32gather_epi32(
+        static_cast<__m256i>(m_value), static_cast<__mmask8>(m_mask),
+        static_cast<__m256i>(index), mem, 4));
+  }
+
   template <class U,
             std::enable_if_t<
                 std::is_convertible_v<
@@ -969,6 +2717,98 @@ class where_expression<simd_mask<std::int32_t, simd_abi::avx512_fixed_size<8>>,
   }
 };
 
+template <>
+class const_where_expression<
+    simd_mask<std::int32_t, simd_abi::avx512_fixed_size<16>>,
+    simd<std::int32_t, simd_abi::avx512_fixed_size<16>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<16>;
+  using value_type = simd<std::int32_t, abi_type>;
+  using mask_type  = simd_mask<std::int32_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::int32_t* mem, element_aligned_tag) const {
+    _mm512_mask_storeu_epi32(mem, static_cast<__mmask16>(m_mask),
+                             static_cast<__m512i>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int32_t* mem, vector_aligned_tag) const {
+    _mm512_mask_store_epi32(mem, static_cast<__mmask16>(m_mask),
+                            static_cast<__m512i>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int32_t* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& index) const {
+    _mm512_mask_i32scatter_epi32(mem, static_cast<__mmask16>(m_mask),
+                                 static_cast<__m512i>(index),
+                                 static_cast<__m512i>(m_value), 4);
+  }
+
+  [[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::int32_t, simd_abi::avx512_fixed_size<16>>,
+                       simd<std::int32_t, simd_abi::avx512_fixed_size<16>>>
+    : public const_where_expression<
+          simd_mask<std::int32_t, simd_abi::avx512_fixed_size<16>>,
+          simd<std::int32_t, simd_abi::avx512_fixed_size<16>>> {
+ public:
+  where_expression(
+      simd_mask<std::int32_t, simd_abi::avx512_fixed_size<16>> const& mask_arg,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, element_aligned_tag) {
+    m_value = value_type(_mm512_mask_loadu_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm512_mask_load_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int32_t const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& index) {
+    m_value = value_type(_mm512_mask_i32gather_epi32(
+        static_cast<__m512i>(m_value), static_cast<__mmask16>(m_mask),
+        static_cast<__m512i>(index), mem, 4));
+  }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::int32_t, simd_abi::avx512_fixed_size<16>>>,
+                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<16>>>(
+            std::forward<U>(x));
+    m_value = simd<std::int32_t, simd_abi::avx512_fixed_size<16>>(
+        _mm512_mask_blend_epi32(static_cast<__mmask16>(m_mask),
+                                static_cast<__m512i>(m_value),
+                                static_cast<__m512i>(x_as_value_type)));
+  }
+};
+
 template <>
 class const_where_expression<
     simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>>,
@@ -991,6 +2831,20 @@ class const_where_expression<
     _mm256_mask_storeu_epi32(mem, static_cast<__mmask8>(m_mask),
                              static_cast<__m256i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint32_t* mem, vector_aligned_tag) const {
+    _mm256_mask_store_epi32(mem, static_cast<__mmask8>(m_mask),
+                            static_cast<__m256i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::uint32_t* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
+    _mm256_mask_i32scatter_epi32(mem, static_cast<__mmask8>(m_mask),
+                                 static_cast<__m256i>(index),
+                                 static_cast<__m256i>(m_value), 4);
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -1019,6 +2873,21 @@ class where_expression<simd_mask<std::uint32_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));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint32_t const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm256_mask_load_epi32(
+        _mm256_set1_epi32(0), static_cast<__mmask8>(m_mask), mem));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::uint32_t const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
+    m_value = value_type(_mm256_mmask_i32gather_epi32(
+        static_cast<__m256i>(m_value), static_cast<__mmask8>(m_mask),
+        static_cast<__m256i>(index), mem, 4));
+  }
+
   template <class U,
             std::enable_if_t<
                 std::is_convertible_v<
@@ -1035,6 +2904,99 @@ class where_expression<simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<8>>,
   }
 };
 
+template <>
+class const_where_expression<
+    simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<16>>,
+    simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>> {
+ public:
+  using abi_type   = simd_abi::avx512_fixed_size<16>;
+  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 {
+    _mm512_mask_storeu_epi32(mem, static_cast<__mmask16>(m_mask),
+                             static_cast<__m512i>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint32_t* mem, vector_aligned_tag) const {
+    _mm512_mask_store_epi32(mem, static_cast<__mmask16>(m_mask),
+                            static_cast<__m512i>(m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::uint32_t* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& index) const {
+    _mm512_mask_i32scatter_epi32(mem, static_cast<__mmask16>(m_mask),
+                                 static_cast<__m512i>(index),
+                                 static_cast<__m512i>(m_value), 4);
+  }
+
+  [[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<16>>,
+    simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>>
+    : public const_where_expression<
+          simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<16>>,
+          simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>> {
+ public:
+  where_expression(
+      simd_mask<std::uint32_t, simd_abi::avx512_fixed_size<16>> const& mask_arg,
+      simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>& 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(_mm512_mask_loadu_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint32_t const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm512_mask_load_epi32(
+        _mm512_set1_epi32(0), static_cast<__mmask16>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::uint32_t const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<16>> const& index) {
+    m_value = value_type(_mm512_mask_i32gather_epi32(
+        static_cast<__m512i>(m_value), static_cast<__mmask16>(m_mask),
+        static_cast<__m512i>(index), mem, 4));
+  }
+  template <class U,
+            std::enable_if_t<
+                std::is_convertible_v<
+                    U, simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>>,
+                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<16>>>(
+            std::forward<U>(x));
+    m_value = simd<std::uint32_t, simd_abi::avx512_fixed_size<16>>(
+        _mm512_mask_blend_epi32(static_cast<__mmask16>(m_mask),
+                                static_cast<__m512i>(m_value),
+                                static_cast<__m512i>(x_as_value_type)));
+  }
+};
+
 template <>
 class const_where_expression<
     simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>>,
@@ -1057,6 +3019,20 @@ class const_where_expression<
     _mm512_mask_storeu_epi64(mem, static_cast<__mmask8>(m_mask),
                              static_cast<__m512i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int64_t* mem, vector_aligned_tag) const {
+    _mm512_mask_store_epi64(mem, static_cast<__mmask8>(m_mask),
+                            static_cast<__m512i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int64_t* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
+    _mm512_mask_i32scatter_epi64(mem, static_cast<__mmask8>(m_mask),
+                                 static_cast<__m256i>(index),
+                                 static_cast<__m512i>(m_value), 8);
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -1085,6 +3061,21 @@ class where_expression<simd_mask<std::int64_t, simd_abi::avx512_fixed_size<8>>,
     m_value = value_type(_mm512_mask_loadu_epi64(
         _mm512_set1_epi64(0.0), static_cast<__mmask8>(m_mask), mem));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int64_t const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm512_mask_load_epi64(
+        _mm512_set1_epi64(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int64_t const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
+    m_value = value_type(_mm512_mask_i32gather_epi64(
+        static_cast<__m512i>(m_value), static_cast<__mmask8>(m_mask),
+        static_cast<__m256i>(index), mem, 8));
+  }
+
   template <class U,
             std::enable_if_t<
                 std::is_convertible_v<
@@ -1123,6 +3114,20 @@ class const_where_expression<
     _mm512_mask_storeu_epi64(mem, static_cast<__mmask8>(m_mask),
                              static_cast<__m512i>(m_value));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint64_t* mem, vector_aligned_tag) const {
+    _mm512_mask_store_epi64(mem, static_cast<__mmask8>(m_mask),
+                            static_cast<__m512i>(m_value));
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::uint64_t* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) const {
+    _mm512_mask_i32scatter_epi64(mem, static_cast<__mmask8>(m_mask),
+                                 static_cast<__m256i>(index),
+                                 static_cast<__m512i>(m_value), 8);
+  }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
   impl_get_value() const {
@@ -1151,6 +3156,20 @@ class where_expression<simd_mask<std::uint64_t, simd_abi::avx512_fixed_size<8>>,
     m_value = value_type(_mm512_mask_loadu_epi64(
         _mm512_set1_epi64(0.0), static_cast<__mmask8>(m_mask), mem));
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint64_t const* mem, vector_aligned_tag) {
+    m_value = value_type(_mm512_mask_load_epi64(
+        _mm512_set1_epi64(0.0), static_cast<__mmask8>(m_mask), mem));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::uint64_t const* mem,
+      simd<std::int32_t, simd_abi::avx512_fixed_size<8>> const& index) {
+    m_value = value_type(_mm512_mask_i32gather_epi64(
+        static_cast<__m512i>(m_value), static_cast<__mmask8>(m_mask),
+        static_cast<__m256i>(index), mem, 8));
+  }
+
   template <class U,
             std::enable_if_t<
                 std::is_convertible_v<
diff --git a/simd/src/Kokkos_SIMD_Common.hpp b/simd/src/Kokkos_SIMD_Common.hpp
index de11640430..c39749b8b8 100644
--- a/simd/src/Kokkos_SIMD_Common.hpp
+++ b/simd/src/Kokkos_SIMD_Common.hpp
@@ -17,7 +17,6 @@
 #ifndef KOKKOS_SIMD_COMMON_HPP
 #define KOKKOS_SIMD_COMMON_HPP
 
-#include <cmath>
 #include <cstring>
 
 #include <Kokkos_Core.hpp>
@@ -32,7 +31,16 @@ class simd;
 template <class T, class Abi>
 class simd_mask;
 
-struct element_aligned_tag {};
+class simd_alignment_vector_aligned {};
+
+template <typename... Flags>
+struct simd_flags {};
+
+inline constexpr simd_flags<> simd_flag_default{};
+inline constexpr simd_flags<simd_alignment_vector_aligned> simd_flag_aligned{};
+
+using element_aligned_tag = simd_flags<>;
+using vector_aligned_tag  = simd_flags<simd_alignment_vector_aligned>;
 
 // class template declarations for const_where_expression and where_expression
 
@@ -118,44 +126,6 @@ template <class T>
   return const_where_expression(mask, value);
 }
 
-// fallback simd multiplication using generator constructor
-// At the time of this writing, this fallback is only used
-// to multiply vectors of 64-bit signed integers for the AVX2 backend
-
-template <class T, class Abi>
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd<T, Abi> operator*(
-    simd<T, Abi> const& lhs, simd<T, Abi> const& rhs) {
-  return simd<T, Abi>([&](std::size_t i) { return lhs[i] * rhs[i]; });
-}
-
-// fallback simd shift using generator constructor
-// At the time of this writing, these fallbacks are only used
-// to shift vectors of 64-bit unsigned integers for the NEON backend
-
-template <class T, class U, class Abi>
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd<T, Abi> operator>>(
-    simd<T, Abi> const& lhs, unsigned int rhs) {
-  return simd<T, Abi>([&](std::size_t i) { return lhs[i] >> rhs; });
-}
-
-template <class T, class U, class Abi>
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd<T, Abi> operator<<(
-    simd<T, Abi> const& lhs, unsigned int rhs) {
-  return simd<T, Abi>([&](std::size_t i) { return lhs[i] << rhs; });
-}
-
-template <class T, class U, class Abi>
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd<T, Abi> operator>>(
-    simd<T, Abi> const& lhs, simd<U, Abi> const& rhs) {
-  return simd<T, Abi>([&](std::size_t i) { return lhs[i] >> rhs[i]; });
-}
-
-template <class T, class U, class Abi>
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd<T, Abi> operator<<(
-    simd<T, Abi> const& lhs, simd<U, Abi> const& rhs) {
-  return simd<T, Abi>([&](std::size_t i) { return lhs[i] << rhs[i]; });
-}
-
 // The code below provides:
 // operator@(simd<T, Abi>, Arithmetic)
 // operator@(Arithmetic, simd<T, Abi>)
@@ -325,143 +295,21 @@ template <class T, class Abi>
   return a == simd_mask<T, Abi>(false);
 }
 
-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.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]);
-  }
-  return result;
-}
+// A temporary device-callable implemenation of round half to nearest even
+template <typename T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto round_half_to_nearest_even(
+    T const& x) {
+  auto ceil  = Kokkos::ceil(x);
+  auto floor = Kokkos::floor(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.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]);
-  }
-  return result;
-}
-
-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.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];
+  if (Kokkos::abs(ceil - x) == Kokkos::abs(floor - x)) {
+    auto rem = Kokkos::remainder(ceil, 2.0);
+    return (rem == 0) ? ceil : floor;
   }
-  return result;
+  return Kokkos::round(x);
 }
 
 }  // namespace Experimental
-
-template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> min(
-    Experimental::simd<T, Abi> const& a, Experimental::simd<T, Abi> const& b) {
-  Experimental::simd<T, Abi> result;
-  for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {
-    result[i] = Kokkos::min(a[i], b[i]);
-  }
-  return result;
-}
-
-template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> max(
-    Experimental::simd<T, Abi> const& a, Experimental::simd<T, Abi> const& b) {
-  Experimental::simd<T, Abi> result;
-  for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {
-    result[i] = Kokkos::max(a[i], b[i]);
-  }
-  return result;
-}
-
-// fallback implementations of <cmath> functions.
-// individual Abi types may provide overloads with more efficient
-// implementations.
-// These are not in the Experimental namespace because their double
-// overloads are not either
-
-#define KOKKOS_IMPL_SIMD_UNARY_FUNCTION(FUNC)                               \
-  template <class Abi>                                                      \
-  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<double, Abi> \
-  FUNC(Experimental::simd<double, Abi> const& a) {                          \
-    Experimental::simd<double, Abi> result;                                 \
-    for (std::size_t i = 0; i < Experimental::simd<double, Abi>::size();    \
-         ++i) {                                                             \
-      result[i] = Kokkos::FUNC(a[i]);                                       \
-    }                                                                       \
-    return result;                                                          \
-  }
-
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(abs)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(exp)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(exp2)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(log)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(log10)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(log2)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(sqrt)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(cbrt)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(sin)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(cos)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(tan)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(asin)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(acos)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(atan)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(sinh)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(cosh)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(tanh)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(asinh)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(acosh)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(atanh)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(erf)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(erfc)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(tgamma)
-KOKKOS_IMPL_SIMD_UNARY_FUNCTION(lgamma)
-
-#define KOKKOS_IMPL_SIMD_BINARY_FUNCTION(FUNC)                              \
-  template <class Abi>                                                      \
-  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<double, Abi> \
-  FUNC(Experimental::simd<double, Abi> const& a,                            \
-       Experimental::simd<double, Abi> const& b) {                          \
-    Experimental::simd<double, Abi> result;                                 \
-    for (std::size_t i = 0; i < Experimental::simd<double, Abi>::size();    \
-         ++i) {                                                             \
-      result[i] = Kokkos::FUNC(a[i], b[i]);                                 \
-    }                                                                       \
-    return result;                                                          \
-  }
-
-KOKKOS_IMPL_SIMD_BINARY_FUNCTION(pow)
-KOKKOS_IMPL_SIMD_BINARY_FUNCTION(hypot)
-KOKKOS_IMPL_SIMD_BINARY_FUNCTION(atan2)
-KOKKOS_IMPL_SIMD_BINARY_FUNCTION(copysign)
-
-#define KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(FUNC)                             \
-  template <class Abi>                                                      \
-  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<double, Abi> \
-  FUNC(Experimental::simd<double, Abi> const& a,                            \
-       Experimental::simd<double, Abi> const& b,                            \
-       Experimental::simd<double, Abi> const& c) {                          \
-    Experimental::simd<double, Abi> result;                                 \
-    for (std::size_t i = 0; i < Experimental::simd<double, Abi>::size();    \
-         ++i) {                                                             \
-      result[i] = Kokkos::FUNC(a[i], b[i], c[i]);                           \
-    }                                                                       \
-    return result;                                                          \
-  }
-
-KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(fma)
-KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(hypot)
-
 }  // namespace Kokkos
 
 #endif
diff --git a/simd/src/Kokkos_SIMD_Common_Math.hpp b/simd/src/Kokkos_SIMD_Common_Math.hpp
new file mode 100644
index 0000000000..8c6a955960
--- /dev/null
+++ b/simd/src/Kokkos_SIMD_Common_Math.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_SIMD_COMMON_MATH_HPP
+#define KOKKOS_SIMD_COMMON_MATH_HPP
+
+#include <Kokkos_Core.hpp>  // Kokkos::min, etc.
+
+namespace Kokkos {
+
+namespace Experimental {
+
+template <class T, class Abi>
+class simd;
+
+template <class T, class Abi>
+class simd_mask;
+
+template <class M, class T>
+class const_where_expression;
+
+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.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]);
+  }
+  return result;
+}
+
+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.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]);
+  }
+  return result;
+}
+
+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.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];
+  }
+  return result;
+}
+
+}  // namespace Experimental
+
+template <class T, class Abi>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> min(
+    Experimental::simd<T, Abi> const& a, Experimental::simd<T, Abi> const& b) {
+  Experimental::simd<T, Abi> result;
+  for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {
+    result[i] = Kokkos::min(a[i], b[i]);
+  }
+  return result;
+}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+namespace Experimental {
+template <class T, class Abi>
+[[nodiscard]] KOKKOS_DEPRECATED KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<T, Abi>
+    min(Experimental::simd<T, Abi> const& a,
+        Experimental::simd<T, Abi> const& b) {
+  return Kokkos::min(a, b);
+}
+}  // namespace Experimental
+#endif
+
+template <class T, class Abi>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> max(
+    Experimental::simd<T, Abi> const& a, Experimental::simd<T, Abi> const& b) {
+  Experimental::simd<T, Abi> result;
+  for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {
+    result[i] = Kokkos::max(a[i], b[i]);
+  }
+  return result;
+}
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+namespace Experimental {
+template <class T, class Abi>
+[[nodiscard]] KOKKOS_DEPRECATED KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<T, Abi>
+    max(Experimental::simd<T, Abi> const& a,
+        Experimental::simd<T, Abi> const& b) {
+  return Kokkos::max(a, b);
+}
+}  // namespace Experimental
+#endif
+
+// fallback implementations of <cmath> functions.
+// individual Abi types may provide overloads with more efficient
+// implementations.
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+#define KOKKOS_IMPL_SIMD_UNARY_FUNCTION(FUNC)                                \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> FUNC( \
+      Experimental::simd<T, Abi> const& a) {                                 \
+    Experimental::simd<T, Abi> result;                                       \
+    for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {   \
+      result[i] = Kokkos::FUNC(a[i]);                                        \
+    }                                                                        \
+    return result;                                                           \
+  }                                                                          \
+  namespace Experimental {                                                   \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_DEPRECATED KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION      \
+      simd<T, Abi>                                                           \
+      FUNC(simd<T, Abi> const& a) {                                          \
+    return Kokkos::FUNC(a);                                                  \
+  }                                                                          \
+  }
+#else
+#define KOKKOS_IMPL_SIMD_UNARY_FUNCTION(FUNC)                                \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> FUNC( \
+      Experimental::simd<T, Abi> const& a) {                                 \
+    Experimental::simd<T, Abi> result;                                       \
+    for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {   \
+      result[i] = Kokkos::FUNC(a[i]);                                        \
+    }                                                                        \
+    return result;                                                           \
+  }
+#endif
+
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(abs)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(exp)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(exp2)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(log)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(log10)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(log2)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(sqrt)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(cbrt)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(sin)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(cos)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(tan)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(asin)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(acos)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(atan)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(sinh)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(cosh)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(tanh)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(asinh)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(acosh)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(atanh)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(erf)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(erfc)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(tgamma)
+KOKKOS_IMPL_SIMD_UNARY_FUNCTION(lgamma)
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+#define KOKKOS_IMPL_SIMD_BINARY_FUNCTION(FUNC)                               \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> FUNC( \
+      Experimental::simd<T, Abi> const& a,                                   \
+      Experimental::simd<T, Abi> const& b) {                                 \
+    Experimental::simd<T, Abi> result;                                       \
+    for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {   \
+      result[i] = Kokkos::FUNC(a[i], b[i]);                                  \
+    }                                                                        \
+    return result;                                                           \
+  }                                                                          \
+  namespace Experimental {                                                   \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_DEPRECATED KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION      \
+      simd<T, Abi>                                                           \
+      FUNC(simd<T, Abi> const& a, simd<T, Abi> const& b) {                   \
+    Kokkos::FUNC(a, b);                                                      \
+  }                                                                          \
+  }
+#else
+#define KOKKOS_IMPL_SIMD_BINARY_FUNCTION(FUNC)                               \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> FUNC( \
+      Experimental::simd<T, Abi> const& a,                                   \
+      Experimental::simd<T, Abi> const& b) {                                 \
+    Experimental::simd<T, Abi> result;                                       \
+    for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {   \
+      result[i] = Kokkos::FUNC(a[i], b[i]);                                  \
+    }                                                                        \
+    return result;                                                           \
+  }
+#endif
+
+KOKKOS_IMPL_SIMD_BINARY_FUNCTION(pow)
+KOKKOS_IMPL_SIMD_BINARY_FUNCTION(hypot)
+KOKKOS_IMPL_SIMD_BINARY_FUNCTION(atan2)
+KOKKOS_IMPL_SIMD_BINARY_FUNCTION(copysign)
+
+#ifdef KOKKOS_ENABLE_DEPRECATED_CODE_4
+#define KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(FUNC)                              \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> FUNC( \
+      Experimental::simd<T, Abi> const& a,                                   \
+      Experimental::simd<T, Abi> const& b,                                   \
+      Experimental::simd<T, Abi> const& c) {                                 \
+    Experimental::simd<T, Abi> result;                                       \
+    for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {   \
+      result[i] = Kokkos::FUNC(a[i], b[i], c[i]);                            \
+    }                                                                        \
+    return result;                                                           \
+  }                                                                          \
+  namespace Experimental {                                                   \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_DEPRECATED KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION      \
+      simd<T, Abi>                                                           \
+      FUNC(simd<T, Abi> const& a, simd<T, Abi> const& b,                     \
+           simd<T, Abi> const& c) {                                          \
+    return Kokkos::FUNC(a, b, c);                                            \
+  }                                                                          \
+  }
+#else
+#define KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(FUNC)                              \
+  template <class T, class Abi>                                              \
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION Experimental::simd<T, Abi> FUNC( \
+      Experimental::simd<T, Abi> const& a,                                   \
+      Experimental::simd<T, Abi> const& b,                                   \
+      Experimental::simd<T, Abi> const& c) {                                 \
+    Experimental::simd<T, Abi> result;                                       \
+    for (std::size_t i = 0; i < Experimental::simd<T, Abi>::size(); ++i) {   \
+      result[i] = Kokkos::FUNC(a[i], b[i], c[i]);                            \
+    }                                                                        \
+    return result;                                                           \
+  }
+#endif
+
+KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(fma)
+KOKKOS_IMPL_SIMD_TERNARY_FUNCTION(hypot)
+
+}  // namespace Kokkos
+
+#endif
diff --git a/simd/src/Kokkos_SIMD_NEON.hpp b/simd/src/Kokkos_SIMD_NEON.hpp
index 612137a060..8cb0cc75fc 100644
--- a/simd/src/Kokkos_SIMD_NEON.hpp
+++ b/simd/src/Kokkos_SIMD_NEON.hpp
@@ -24,6 +24,11 @@
 
 #include <arm_neon.h>
 
+#ifdef KOKKOS_SIMD_COMMON_MATH_HPP
+#error \
+    "Kokkos_SIMD_NEON.hpp must be included before Kokkos_SIMD_Common_Math.hpp!"
+#endif
+
 namespace Kokkos {
 
 namespace Experimental {
@@ -37,11 +42,11 @@ class neon_fixed_size {};
 
 namespace Impl {
 
-template <class Derived, int Bits>
+template <class Derived, int Bits, int Size>
 class neon_mask;
 
 template <class Derived>
-class neon_mask<Derived, 64> {
+class neon_mask<Derived, 64, 2> {
   uint64x2_t m_value;
 
  public:
@@ -81,14 +86,31 @@ class neon_mask<Derived, 64> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask() = default;
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit neon_mask(value_type value)
       : m_value(vmovq_n_u64(value ? 0xFFFFFFFFFFFFFFFFULL : 0)) {}
+  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 constexpr explicit neon_mask(
+      G&& gen) noexcept {
+    m_value = vsetq_lane_u64(
+        (gen(std::integral_constant<std::size_t, 0>()) ? 0xFFFFFFFFFFFFFFFFULL
+                                                       : 0),
+        m_value, 0);
+    m_value = vsetq_lane_u64(
+        (gen(std::integral_constant<std::size_t, 1>()) ? 0xFFFFFFFFFFFFFFFFULL
+                                                       : 0),
+        m_value, 1);
+  }
   template <class U>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(
-      neon_mask<U, 32> const& other) {
+      neon_mask<U, 32, 2> const& other) {
     operator[](0) = bool(other[0]);
     operator[](1) = bool(other[1]);
   }
   template <class U>
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(neon_mask<U, 64> const& other)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(
+      neon_mask<U, 64, 2> const& other)
       : neon_mask(static_cast<uint64x2_t>(other)) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
     return 2;
@@ -137,7 +159,7 @@ class neon_mask<Derived, 64> {
 };
 
 template <class Derived>
-class neon_mask<Derived, 32> {
+class neon_mask<Derived, 32, 2> {
   uint32x2_t m_value;
 
  public:
@@ -175,11 +197,27 @@ class neon_mask<Derived, 32> {
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask() = default;
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit neon_mask(value_type value)
       : m_value(vmov_n_u32(value ? 0xFFFFFFFFU : 0)) {}
+  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 constexpr explicit neon_mask(
+      G&& gen) noexcept {
+    m_value = vset_lane_u32(
+        (gen(std::integral_constant<std::size_t, 0>()) ? 0xFFFFFFFFU : 0),
+        m_value, 0);
+    m_value = vset_lane_u32(
+        (gen(std::integral_constant<std::size_t, 1>()) ? 0xFFFFFFFFU : 0),
+        m_value, 1);
+  }
   template <class U>
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(neon_mask<U, 64> const& other)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(
+      neon_mask<U, 64, 2> const& other)
       : m_value(vqmovn_u64(static_cast<uint64x2_t>(other))) {}
   template <class U>
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(neon_mask<U, 32> const& other)
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask(
+      neon_mask<U, 32, 2> const& other)
       : m_value(static_cast<uint32x2_t>(other)) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
     return 2;
@@ -225,14 +263,125 @@ class neon_mask<Derived, 32> {
   }
 };
 
+template <class Derived>
+class neon_mask<Derived, 32, 4> {
+  uint32x4_t m_value;
+
+ public:
+  class reference {
+    uint32x4_t& m_mask;
+    int m_lane;
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(uint32x4_t& mask_arg,
+                                                    int lane_arg)
+        : m_mask(mask_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(bool value) const {
+      switch (m_lane) {
+        case 0:
+          m_mask = vsetq_lane_u32(value ? 0xFFFFFFFFU : 0, m_mask, 0);
+          break;
+        case 1:
+          m_mask = vsetq_lane_u32(value ? 0xFFFFFFFFU : 0, m_mask, 1);
+          break;
+        case 2:
+          m_mask = vsetq_lane_u32(value ? 0xFFFFFFFFU : 0, m_mask, 2);
+          break;
+        case 3:
+          m_mask = vsetq_lane_u32(value ? 0xFFFFFFFFU : 0, m_mask, 3);
+          break;
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator bool() const {
+      switch (m_lane) {
+        case 0: return vgetq_lane_u32(m_mask, 0) != 0;
+        case 1: return vgetq_lane_u32(m_mask, 1) != 0;
+        case 2: return vgetq_lane_u32(m_mask, 2) != 0;
+        case 3: return vgetq_lane_u32(m_mask, 3) != 0;
+      }
+      return false;
+    }
+  };
+  using value_type          = bool;
+  using abi_type            = simd_abi::neon_fixed_size<4>;
+  using implementation_type = uint32x4_t;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION neon_mask() = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit neon_mask(value_type value)
+      : m_value(vmovq_n_u32(value ? 0xFFFFFFFFU : 0)) {}
+  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 constexpr explicit neon_mask(
+      G&& gen) noexcept {
+    m_value = vsetq_lane_u32(
+        (gen(std::integral_constant<std::size_t, 0>()) ? 0xFFFFFFFFU : 0),
+        m_value, 0);
+    m_value = vsetq_lane_u32(
+        (gen(std::integral_constant<std::size_t, 1>()) ? 0xFFFFFFFFU : 0),
+        m_value, 1);
+    m_value = vsetq_lane_u32(
+        (gen(std::integral_constant<std::size_t, 2>()) ? 0xFFFFFFFFU : 0),
+        m_value, 2);
+    m_value = vsetq_lane_u32(
+        (gen(std::integral_constant<std::size_t, 3>()) ? 0xFFFFFFFFU : 0),
+        m_value, 3);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION static constexpr std::size_t size() {
+    return 4;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit neon_mask(
+      uint32x4_t const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator uint32x4_t()
+      const {
+    return m_value;
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  operator[](std::size_t i) const {
+    return static_cast<value_type>(
+        reference(const_cast<uint32x4_t&>(m_value), int(i)));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Derived
+  operator||(neon_mask const& other) const {
+    return Derived(vorrq_u32(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Derived
+  operator&&(neon_mask const& other) const {
+    return Derived(vandq_u32(m_value, other.m_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Derived operator!() const {
+    auto const true_value = static_cast<uint32x4_t>(neon_mask(true));
+    return Derived(veorq_u32(m_value, true_value));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator==(
+      neon_mask const& other) const {
+    uint32x4_t const elementwise_equality = vceqq_u32(m_value, other.m_value);
+    uint64x2_t const overall_equality_neon =
+        vreinterpretq_u64_u32(elementwise_equality);
+    return (overall_equality_neon[0] == 0xFFFFFFFFFFFFFFFFULL) &&
+           (overall_equality_neon[1] == 0xFFFFFFFFFFFFFFFFULL);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION bool operator!=(
+      neon_mask const& other) const {
+    return !operator==(other);
+  }
+};
+
 }  // namespace Impl
 
 template <class T>
 class simd_mask<T, simd_abi::neon_fixed_size<2>>
     : public Impl::neon_mask<simd_mask<T, simd_abi::neon_fixed_size<2>>,
-                             sizeof(T) * 8> {
+                             sizeof(T) * 8, 2> {
   using base_type = Impl::neon_mask<simd_mask<T, simd_abi::neon_fixed_size<2>>,
-                                    sizeof(T) * 8>;
+                                    sizeof(T) * 8, 2>;
 
  public:
   using implementation_type = typename base_type::implementation_type;
@@ -246,6 +395,43 @@ class simd_mask<T, simd_abi::neon_fixed_size<2>>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
       implementation_type const& value)
       : base_type(value) {}
+  template <class G,
+            std::enable_if_t<
+                std::is_invocable_r_v<typename base_type::value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : base_type(gen) {}
+};
+
+template <class T>
+class simd_mask<T, simd_abi::neon_fixed_size<4>>
+    : public Impl::neon_mask<simd_mask<T, simd_abi::neon_fixed_size<4>>,
+                             sizeof(T) * 8, 4> {
+  using base_type = Impl::neon_mask<simd_mask<T, simd_abi::neon_fixed_size<4>>,
+                                    sizeof(T) * 8, 4>;
+
+ public:
+  using implementation_type = typename base_type::implementation_type;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask() = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd_mask(bool value)
+      : base_type(value) {}
+  template <class U>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd_mask(
+      simd_mask<U, simd_abi::neon_fixed_size<4>> const& other)
+      : base_type(other) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      implementation_type const& value)
+      : base_type(value) {}
+  template <class G,
+            std::enable_if_t<
+                std::is_invocable_r_v<typename base_type::value_type, G,
+                                      std::integral_constant<std::size_t, 0>>,
+                bool> = false>
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd_mask(
+      G&& gen) noexcept
+      : base_type(gen) {}
 };
 
 template <>
@@ -299,7 +485,8 @@ 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_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen) {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept {
     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>()),
@@ -319,130 +506,179 @@ class simd<double, simd_abi::neon_fixed_size<2>> {
                                                        element_aligned_tag) {
     m_value = vld1q_f64(ptr);
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1q_f64(ptr);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
     vst1q_f64(ptr, m_value);
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1q_f64(ptr, m_value);
+  }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit
   operator float64x2_t() const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(vcltq_f64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(vnegq_f64(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vmulq_f64(static_cast<float64x2_t>(lhs),
+                          static_cast<float64x2_t>(rhs)));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vdivq_f64(static_cast<float64x2_t>(lhs),
+                          static_cast<float64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vaddq_f64(static_cast<float64x2_t>(lhs),
+                          static_cast<float64x2_t>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(vcgtq_f64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vsubq_f64(static_cast<float64x2_t>(lhs),
+                          static_cast<float64x2_t>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(vcleq_f64(m_value, other.m_value));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcltq_f64(static_cast<float64x2_t>(lhs),
+                               static_cast<float64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcgtq_f64(static_cast<float64x2_t>(lhs),
+                               static_cast<float64x2_t>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(vcgeq_f64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcleq_f64(static_cast<float64x2_t>(lhs),
+                               static_cast<float64x2_t>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(vceqq_f64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcgeq_f64(static_cast<float64x2_t>(lhs),
+                               static_cast<float64x2_t>(rhs)));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !(operator==(other));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vceqq_f64(static_cast<float64x2_t>(lhs),
+                               static_cast<float64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(operator==(lhs, rhs));
   }
 };
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::neon_fixed_size<2>>
-    operator*(simd<double, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<double, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
-      vmulq_f64(static_cast<float64x2_t>(lhs), static_cast<float64x2_t>(rhs)));
-}
+}  // namespace Experimental
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::neon_fixed_size<2>>
-    operator/(simd<double, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<double, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
-      vdivq_f64(static_cast<float64x2_t>(lhs), static_cast<float64x2_t>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    abs(Experimental::simd<
+        double, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
+      vabsq_f64(static_cast<float64x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::neon_fixed_size<2>>
-    operator+(simd<double, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<double, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
-      vaddq_f64(static_cast<float64x2_t>(lhs), static_cast<float64x2_t>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    floor(Experimental::simd<
+          double, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndmq_f64(static_cast<float64x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::neon_fixed_size<2>>
-    operator-(simd<double, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<double, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
-      vsubq_f64(static_cast<float64x2_t>(lhs), static_cast<float64x2_t>(rhs)));
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    ceil(Experimental::simd<
+         double, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndpq_f64(static_cast<float64x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<double, simd_abi::neon_fixed_size<2>>
-    operator-(simd<double, simd_abi::neon_fixed_size<2>> const& a) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
-      vnegq_f64(static_cast<float64x2_t>(a)));
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    round(Experimental::simd<
+          double, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndxq_f64(static_cast<float64x2_t>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::neon_fixed_size<2>> abs(
-    simd<double, simd_abi::neon_fixed_size<2>> const& a) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
-      vabsq_f64(static_cast<float64x2_t>(a)));
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    trunc(Experimental::simd<
+          double, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndq_f64(static_cast<float64x2_t>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::neon_fixed_size<2>> copysign(
-    simd<double, simd_abi::neon_fixed_size<2>> const& a,
-    simd<double, simd_abi::neon_fixed_size<2>> const& b) {
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    copysign(Experimental::simd<
+                 double, Experimental::simd_abi::neon_fixed_size<2>> const& a,
+             Experimental::simd<
+                 double, Experimental::simd_abi::neon_fixed_size<2>> const& b) {
   uint64x2_t const sign_mask = vreinterpretq_u64_f64(vmovq_n_f64(-0.0));
-  return simd<double, simd_abi::neon_fixed_size<2>>(vreinterpretq_f64_u64(
-      vorrq_u64(vreinterpretq_u64_f64(static_cast<float64x2_t>(abs(a))),
-                vandq_u64(sign_mask, vreinterpretq_u64_f64(
-                                         static_cast<float64x2_t>(b))))));
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
+      vreinterpretq_f64_u64(vorrq_u64(
+          vreinterpretq_u64_f64(static_cast<float64x2_t>(abs(a))),
+          vandq_u64(sign_mask,
+                    vreinterpretq_u64_f64(static_cast<float64x2_t>(b))))));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::neon_fixed_size<2>> sqrt(
-    simd<double, simd_abi::neon_fixed_size<2>> const& a) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    sqrt(Experimental::simd<
+         double, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
       vsqrtq_f64(static_cast<float64x2_t>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::neon_fixed_size<2>> fma(
-    simd<double, simd_abi::neon_fixed_size<2>> const& a,
-    simd<double, simd_abi::neon_fixed_size<2>> const& b,
-    simd<double, simd_abi::neon_fixed_size<2>> const& c) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    fma(Experimental::simd<double,
+                           Experimental::simd_abi::neon_fixed_size<2>> const& a,
+        Experimental::simd<double,
+                           Experimental::simd_abi::neon_fixed_size<2>> const& b,
+        Experimental::simd<
+            double, Experimental::simd_abi::neon_fixed_size<2>> const& c) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
       vfmaq_f64(static_cast<float64x2_t>(c), static_cast<float64x2_t>(b),
                 static_cast<float64x2_t>(a)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::neon_fixed_size<2>> max(
-    simd<double, simd_abi::neon_fixed_size<2>> const& a,
-    simd<double, simd_abi::neon_fixed_size<2>> const& b) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    max(Experimental::simd<double,
+                           Experimental::simd_abi::neon_fixed_size<2>> const& a,
+        Experimental::simd<
+            double, Experimental::simd_abi::neon_fixed_size<2>> const& b) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
       vmaxq_f64(static_cast<float64x2_t>(a), static_cast<float64x2_t>(b)));
 }
 
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<double, simd_abi::neon_fixed_size<2>> min(
-    simd<double, simd_abi::neon_fixed_size<2>> const& a,
-    simd<double, simd_abi::neon_fixed_size<2>> const& b) {
-  return simd<double, simd_abi::neon_fixed_size<2>>(
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>
+    min(Experimental::simd<double,
+                           Experimental::simd_abi::neon_fixed_size<2>> const& a,
+        Experimental::simd<
+            double, Experimental::simd_abi::neon_fixed_size<2>> const& b) {
+  return Experimental::simd<double, Experimental::simd_abi::neon_fixed_size<2>>(
       vminq_f64(static_cast<float64x2_t>(a), static_cast<float64x2_t>(b)));
 }
 
+namespace Experimental {
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
     simd<double, simd_abi::neon_fixed_size<2>>
     condition(simd_mask<double, simd_abi::neon_fixed_size<2>> const& a,
@@ -454,33 +690,33 @@ simd<double, simd_abi::neon_fixed_size<2>> min(
 }
 
 template <>
-class simd<std::int32_t, simd_abi::neon_fixed_size<2>> {
-  int32x2_t m_value;
+class simd<float, simd_abi::neon_fixed_size<2>> {
+  float32x2_t m_value;
 
  public:
-  using value_type = std::int32_t;
+  using value_type = float;
   using abi_type   = simd_abi::neon_fixed_size<2>;
   using mask_type  = simd_mask<value_type, abi_type>;
   class reference {
-    int32x2_t& m_value;
+    float32x2_t& m_value;
     int m_lane;
 
    public:
-    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(int32x2_t& value_arg,
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(float32x2_t& value_arg,
                                                     int lane_arg)
         : m_value(value_arg), m_lane(lane_arg) {}
     KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
-    operator=(std::int32_t value) const {
+    operator=(float value) const {
       switch (m_lane) {
-        case 0: m_value = vset_lane_s32(value, m_value, 0); break;
-        case 1: m_value = vset_lane_s32(value, m_value, 1); break;
+        case 0: m_value = vset_lane_f32(value, m_value, 0); break;
+        case 1: m_value = vset_lane_f32(value, m_value, 1); break;
       }
       return *this;
     }
-    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator std::int32_t() const {
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator float() const {
       switch (m_lane) {
-        case 0: return vget_lane_s32(m_value, 0);
-        case 1: return vget_lane_s32(m_value, 1);
+        case 0: return vget_lane_f32(m_value, 0);
+        case 1: return vget_lane_f32(m_value, 1);
       }
       return 0;
     }
@@ -496,23 +732,21 @@ class simd<std::int32_t, simd_abi::neon_fixed_size<2>> {
   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(vmov_n_s32(value_type(value))) {}
+      : m_value(vmov_n_f32(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 = vset_lane_s32(gen(std::integral_constant<std::size_t, 0>()),
+    m_value = vset_lane_f32(gen(std::integral_constant<std::size_t, 0>()),
                             m_value, 0);
-    m_value = vset_lane_s32(gen(std::integral_constant<std::size_t, 1>()),
+    m_value = vset_lane_f32(gen(std::integral_constant<std::size_t, 1>()),
                             m_value, 1);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
-      int32x2_t const& value_in)
+      float32x2_t const& value_in)
       : m_value(value_in) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::uint64_t, abi_type> const& other);
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reference(m_value, int(i));
   }
@@ -522,103 +756,213 @@ class simd<std::int32_t, simd_abi::neon_fixed_size<2>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
-    m_value = vld1_s32(ptr);
+    m_value = vld1_f32(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1_f32(ptr);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
-    vst1_s32(ptr, m_value);
+    vst1_f32(ptr, m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator int32x2_t()
-      const {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1_f32(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit
+  operator float32x2_t() const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(vceq_s32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(vneg_f32(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vmul_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vdiv_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vadd_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vsub_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vclt_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(vcgt_s32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcgt_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(vclt_s32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcle_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(vcle_s32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcge_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(vcge_s32(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vceq_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
   }
 };
 
+}  // namespace Experimental
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::neon_fixed_size<2>>
-    operator-(simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& a) {
-  return simd<std::int32_t, simd_abi::neon_fixed_size<2>>(
-      vneg_s32(static_cast<int32x2_t>(a)));
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>
+    abs(Experimental::simd<
+        float, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vabs_f32(static_cast<float32x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::neon_fixed_size<2>>
-    operator-(simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<std::int32_t, simd_abi::neon_fixed_size<2>>(
-      vsub_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>
+    floor(Experimental::simd<
+          float, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndm_f32(static_cast<float32x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::neon_fixed_size<2>>
-    operator+(simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<std::int32_t, simd_abi::neon_fixed_size<2>>(
-      vadd_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>
+    ceil(Experimental::simd<
+         float, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndp_f32(static_cast<float32x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int32_t, simd_abi::neon_fixed_size<2>>
-    condition(simd_mask<std::int32_t, simd_abi::neon_fixed_size<2>> const& a,
-              simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& b,
-              simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& c) {
-  return simd<std::int32_t, simd_abi::neon_fixed_size<2>>(
-      vbsl_s32(static_cast<uint32x2_t>(a), static_cast<int32x2_t>(b),
-               static_cast<int32x2_t>(c)));
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>
+    round(Experimental::simd<
+          float, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrndx_f32(static_cast<float32x2_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>
+    trunc(Experimental::simd<
+          float, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vrnd_f32(static_cast<float32x2_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<2>>
+copysign(
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        b) {
+  uint32x2_t const sign_mask = vreinterpret_u32_f32(vmov_n_f32(-0.0));
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vreinterpret_f32_u32(vorr_u32(
+          vreinterpret_u32_f32(static_cast<float32x2_t>(abs(a))),
+          vand_u32(sign_mask,
+                   vreinterpret_u32_f32(static_cast<float32x2_t>(b))))));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>
+    sqrt(Experimental::simd<
+         float, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vsqrt_f32(static_cast<float32x2_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<2>>
+fma(Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        b,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        c) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vfma_f32(static_cast<float32x2_t>(c), static_cast<float32x2_t>(b),
+               static_cast<float32x2_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<2>>
+max(Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vmax_f32(static_cast<float32x2_t>(a), static_cast<float32x2_t>(b)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<2>>
+min(Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<2>>(
+      vmin_f32(static_cast<float32x2_t>(a), static_cast<float32x2_t>(b)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<float, simd_abi::neon_fixed_size<2>>
+    condition(simd_mask<float, simd_abi::neon_fixed_size<2>> const& a,
+              simd<float, simd_abi::neon_fixed_size<2>> const& b,
+              simd<float, simd_abi::neon_fixed_size<2>> const& c) {
+  return simd<float, simd_abi::neon_fixed_size<2>>(
+      vbsl_f32(static_cast<uint32x2_t>(a), static_cast<float32x2_t>(b),
+               static_cast<float32x2_t>(c)));
 }
 
 template <>
-class simd<std::int64_t, simd_abi::neon_fixed_size<2>> {
-  int64x2_t m_value;
+class simd<float, simd_abi::neon_fixed_size<4>> {
+  float32x4_t m_value;
 
  public:
-  using value_type = std::int64_t;
-  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using value_type = float;
+  using abi_type   = simd_abi::neon_fixed_size<4>;
   using mask_type  = simd_mask<value_type, abi_type>;
   class reference {
-    int64x2_t& m_value;
+    float32x4_t& m_value;
     int m_lane;
 
    public:
-    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(int64x2_t& value_arg,
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(float32x4_t& value_arg,
                                                     int lane_arg)
         : m_value(value_arg), m_lane(lane_arg) {}
     KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
-    operator=(std::int64_t value) const {
+    operator=(float value) const {
       switch (m_lane) {
-        case 0: m_value = vsetq_lane_s64(value, m_value, 0); break;
-        case 1: m_value = vsetq_lane_s64(value, m_value, 1); break;
+        case 0: m_value = vsetq_lane_f32(value, m_value, 0); break;
+        case 1: m_value = vsetq_lane_f32(value, m_value, 1); break;
+        case 2: m_value = vsetq_lane_f32(value, m_value, 2); break;
+        case 3: m_value = vsetq_lane_f32(value, m_value, 3); break;
       }
       return *this;
     }
-    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator std::int64_t() const {
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator float() const {
       switch (m_lane) {
-        case 0: return vgetq_lane_s64(m_value, 0);
-        case 1: return vgetq_lane_s64(m_value, 1);
+        case 0: return vgetq_lane_f32(m_value, 0);
+        case 1: return vgetq_lane_f32(m_value, 1);
+        case 2: return vgetq_lane_f32(m_value, 2);
+        case 3: return vgetq_lane_f32(m_value, 3);
       }
       return 0;
     }
@@ -629,28 +973,30 @@ class simd<std::int64_t, simd_abi::neon_fixed_size<2>> {
   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 2;
+    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(vmovq_n_s64(value_type(value))) {}
+      : m_value(vmovq_n_f32(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 = vsetq_lane_s64(gen(std::integral_constant<std::size_t, 0>()),
+    m_value = vsetq_lane_f32(gen(std::integral_constant<std::size_t, 0>()),
                              m_value, 0);
-    m_value = vsetq_lane_s64(gen(std::integral_constant<std::size_t, 1>()),
+    m_value = vsetq_lane_f32(gen(std::integral_constant<std::size_t, 1>()),
                              m_value, 1);
+    m_value = vsetq_lane_f32(gen(std::integral_constant<std::size_t, 2>()),
+                             m_value, 2);
+    m_value = vsetq_lane_f32(gen(std::integral_constant<std::size_t, 3>()),
+                             m_value, 3);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
-      int64x2_t const& value_in)
+      float32x4_t const& value_in)
       : m_value(value_in) {}
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
-      simd<std::uint64_t, abi_type> const&);
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
     return reference(m_value, int(i));
   }
@@ -660,65 +1006,814 @@ class simd<std::int64_t, simd_abi::neon_fixed_size<2>> {
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
                                                        element_aligned_tag) {
-    m_value = vld1q_s64(ptr);
+    m_value = vld1q_f32(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1q_f32(ptr);
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
       value_type* ptr, element_aligned_tag) const {
-    vst1q_s64(ptr, m_value);
+    vst1q_f32(ptr, m_value);
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator int64x2_t()
-      const {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1q_f32(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit
+  operator float32x4_t() const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(vceqq_s64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(vnegq_f32(m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>(simd const& other) const {
-    return mask_type(vcgtq_s64(m_value, other.m_value));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vmulq_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<(simd const& other) const {
-    return mask_type(vcltq_s64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vdivq_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator<=(simd const& other) const {
-    return mask_type(vcleq_s64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vaddq_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator>=(simd const& other) const {
-    return mask_type(vcgeq_s64(m_value, other.m_value));
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vsubq_f32(lhs.m_value, rhs.m_value));
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !((*this) == other);
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcltq_f32(lhs.m_value, rhs.m_value));
   }
-};
-
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcgtq_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcleq_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vcgeq_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(vceqq_f32(lhs.m_value, rhs.m_value));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>
+    abs(Experimental::simd<
+        float, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vabsq_f32(static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>
+    floor(Experimental::simd<
+          float, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vrndmq_f32(static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>
+    ceil(Experimental::simd<
+         float, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vrndpq_f32(static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>
+    round(Experimental::simd<
+          float, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vrndxq_f32(static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>
+    trunc(Experimental::simd<
+          float, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vrndq_f32(static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<4>>
+copysign(
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        b) {
+  uint32x4_t const sign_mask = vreinterpretq_u32_f32(vmovq_n_f32(-0.0));
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vreinterpretq_f32_u32(vorrq_u32(
+          vreinterpretq_u32_f32(static_cast<float32x4_t>(abs(a))),
+          vandq_u32(sign_mask,
+                    vreinterpretq_u32_f32(static_cast<float32x4_t>(b))))));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>
+    sqrt(Experimental::simd<
+         float, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vsqrtq_f32(static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<4>>
+fma(Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        b,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        c) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vfmaq_f32(static_cast<float32x4_t>(c), static_cast<float32x4_t>(b),
+                static_cast<float32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<4>>
+max(Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vmaxq_f32(static_cast<float32x4_t>(a), static_cast<float32x4_t>(b)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    float, Experimental::simd_abi::neon_fixed_size<4>>
+min(Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        a,
+    Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>> const&
+        b) {
+  return Experimental::simd<float, Experimental::simd_abi::neon_fixed_size<4>>(
+      vminq_f32(static_cast<float32x4_t>(a), static_cast<float32x4_t>(b)));
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<float, simd_abi::neon_fixed_size<4>>
+    condition(simd_mask<float, simd_abi::neon_fixed_size<4>> const& a,
+              simd<float, simd_abi::neon_fixed_size<4>> const& b,
+              simd<float, simd_abi::neon_fixed_size<4>> const& c) {
+  return simd<float, simd_abi::neon_fixed_size<4>>(
+      vbslq_f32(static_cast<uint32x4_t>(a), static_cast<float32x4_t>(b),
+                static_cast<float32x4_t>(c)));
+}
+
+template <>
+class simd<std::int32_t, simd_abi::neon_fixed_size<2>> {
+  int32x2_t m_value;
+
+ public:
+  using value_type = std::int32_t;
+  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  class reference {
+    int32x2_t& m_value;
+    int m_lane;
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(int32x2_t& value_arg,
+                                                    int lane_arg)
+        : m_value(value_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(std::int32_t value) const {
+      switch (m_lane) {
+        case 0: m_value = vset_lane_s32(value, m_value, 0); break;
+        case 1: m_value = vset_lane_s32(value, m_value, 1); break;
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator std::int32_t() const {
+      switch (m_lane) {
+        case 0: return vget_lane_s32(m_value, 0);
+        case 1: return vget_lane_s32(m_value, 1);
+      }
+      return 0;
+    }
+  };
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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 2;
+  }
+  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(vmov_n_s32(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 constexpr explicit simd(
+      G&& gen) noexcept {
+    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>()),
+                            m_value, 1);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      int32x2_t const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::uint64_t, abi_type> const& other);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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 = vld1_s32(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1_s32(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    vst1_s32(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1_s32(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator int32x2_t()
+      const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(vneg_s32(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vsub_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vadd_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vmul_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vceq_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcgt_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vclt_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcle_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcge_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(vshl_s32(static_cast<int32x2_t>(lhs),
+                         vneg_s32(vmov_n_s32(std::int32_t(rhs)))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vshl_s32(static_cast<int32x2_t>(lhs),
+                         vneg_s32(static_cast<int32x2_t>(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(
+        vshl_s32(static_cast<int32x2_t>(lhs), vmov_n_s32(std::int32_t(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vshl_s32(static_cast<int32x2_t>(lhs), static_cast<int32x2_t>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<2>>
+    abs(Experimental::simd<
+        std::int32_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<std::int32_t,
+                            Experimental::simd_abi::neon_fixed_size<2>>(
+      vabs_s32(static_cast<int32x2_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<2>>
+    floor(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<2>>
+    ceil(Experimental::simd<
+         std::int32_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<2>>
+    round(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<2>>
+    trunc(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int32_t, simd_abi::neon_fixed_size<2>>
+    condition(simd_mask<std::int32_t, simd_abi::neon_fixed_size<2>> const& a,
+              simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& b,
+              simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& c) {
+  return simd<std::int32_t, simd_abi::neon_fixed_size<2>>(
+      vbsl_s32(static_cast<uint32x2_t>(a), static_cast<int32x2_t>(b),
+               static_cast<int32x2_t>(c)));
+}
+
+template <>
+class simd<std::int32_t, simd_abi::neon_fixed_size<4>> {
+  int32x4_t m_value;
+
+ public:
+  using value_type = std::int32_t;
+  using abi_type   = simd_abi::neon_fixed_size<4>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  class reference {
+    int32x4_t& m_value;
+    int m_lane;
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(int32x4_t& value_arg,
+                                                    int lane_arg)
+        : m_value(value_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(std::int32_t value) const {
+      switch (m_lane) {
+        case 0: m_value = vsetq_lane_s32(value, m_value, 0); break;
+        case 1: m_value = vsetq_lane_s32(value, m_value, 1); break;
+        case 2: m_value = vsetq_lane_s32(value, m_value, 2); break;
+        case 3: m_value = vsetq_lane_s32(value, m_value, 3); break;
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator std::int32_t() const {
+      switch (m_lane) {
+        case 0: return vgetq_lane_s32(m_value, 0);
+        case 1: return vgetq_lane_s32(m_value, 1);
+        case 2: return vgetq_lane_s32(m_value, 2);
+        case 3: return vgetq_lane_s32(m_value, 3);
+      }
+      return 0;
+    }
+  };
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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 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(vmovq_n_s32(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 constexpr explicit simd(
+      G&& gen) noexcept {
+    m_value = vsetq_lane_s32(gen(std::integral_constant<std::size_t, 0>()),
+                             m_value, 0);
+    m_value = vsetq_lane_s32(gen(std::integral_constant<std::size_t, 1>()),
+                             m_value, 1);
+    m_value = vsetq_lane_s32(gen(std::integral_constant<std::size_t, 2>()),
+                             m_value, 2);
+    m_value = vsetq_lane_s32(gen(std::integral_constant<std::size_t, 3>()),
+                             m_value, 3);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      int32x4_t const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::uint64_t, abi_type> const& other);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_s32(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1q_s32(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    vst1q_s32(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1q_s32(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator int32x4_t()
+      const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(vnegq_s32(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vsubq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vaddq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vmulq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vceqq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcgtq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcltq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcleq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcgeq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(vshlq_s32(static_cast<int32x4_t>(lhs),
+                          vnegq_s32(vmovq_n_s32(std::int32_t(rhs)))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vshlq_s32(static_cast<int32x4_t>(lhs),
+                          vnegq_s32(static_cast<int32x4_t>(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(
+        vshlq_s32(static_cast<int32x4_t>(lhs), vmovq_n_s32(std::int32_t(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vshlq_s32(static_cast<int32x4_t>(lhs), static_cast<int32x4_t>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<4>>
+    abs(Experimental::simd<
+        std::int32_t, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return Experimental::simd<std::int32_t,
+                            Experimental::simd_abi::neon_fixed_size<4>>(
+      vabsq_s32(static_cast<int32x4_t>(a)));
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<4>>
+    floor(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<4>>
+    ceil(Experimental::simd<
+         std::int32_t, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<4>>
+    round(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int32_t, Experimental::simd_abi::neon_fixed_size<4>>
+    trunc(Experimental::simd<
+          std::int32_t, Experimental::simd_abi::neon_fixed_size<4>> const& a) {
+  return a;
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::int32_t, simd_abi::neon_fixed_size<4>>
+    condition(simd_mask<std::int32_t, simd_abi::neon_fixed_size<4>> const& a,
+              simd<std::int32_t, simd_abi::neon_fixed_size<4>> const& b,
+              simd<std::int32_t, simd_abi::neon_fixed_size<4>> const& c) {
+  return simd<std::int32_t, simd_abi::neon_fixed_size<4>>(
+      vbslq_s32(static_cast<uint32x4_t>(a), static_cast<int32x4_t>(b),
+                static_cast<int32x4_t>(c)));
+}
+
+template <>
+class simd<std::int64_t, simd_abi::neon_fixed_size<2>> {
+  int64x2_t m_value;
+
+ public:
+  using value_type = std::int64_t;
+  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using mask_type  = simd_mask<value_type, abi_type>;
+  class reference {
+    int64x2_t& m_value;
+    int m_lane;
+
+   public:
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference(int64x2_t& value_arg,
+                                                    int lane_arg)
+        : m_value(value_arg), m_lane(lane_arg) {}
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference
+    operator=(std::int64_t value) const {
+      switch (m_lane) {
+        case 0: m_value = vsetq_lane_s64(value, m_value, 0); break;
+        case 1: m_value = vsetq_lane_s64(value, m_value, 1); break;
+      }
+      return *this;
+    }
+    KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION operator std::int64_t() const {
+      switch (m_lane) {
+        case 0: return vgetq_lane_s64(m_value, 0);
+        case 1: return vgetq_lane_s64(m_value, 1);
+      }
+      return 0;
+    }
+  };
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd()            = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd const&) = default;
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd(simd&&)      = default;
+  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 2;
+  }
+  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(vmovq_n_s64(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 constexpr explicit simd(
+      G&& gen) noexcept {
+    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>()),
+                             m_value, 1);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      int64x2_t const& value_in)
+      : m_value(value_in) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION explicit simd(
+      simd<std::uint64_t, abi_type> const&);
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION reference operator[](std::size_t i) {
+    return reference(m_value, int(i));
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type
+  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_s64(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1q_s64(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    vst1q_s64(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1q_s64(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator int64x2_t()
+      const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd operator-() const
+      noexcept {
+    return simd(vnegq_s64(m_value));
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vsubq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vaddq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd([&](std::size_t i) { return lhs[i] * rhs[i]; });
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vceqq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcgtq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcltq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcleq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vcgeq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(vshlq_s64(static_cast<int64x2_t>(lhs),
+                          vnegq_s64(vmovq_n_s64(std::int64_t(rhs)))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vshlq_s64(static_cast<int64x2_t>(lhs),
+                          vnegq_s64(static_cast<int64x2_t>(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(
+        vshlq_s64(static_cast<int64x2_t>(lhs), vmovq_n_s64(std::int64_t(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vshlq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+  }
+};
+
+}  // namespace Experimental
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::neon_fixed_size<2>>
-    operator-(simd<std::int64_t, simd_abi::neon_fixed_size<2>> const& a) {
-  return simd<std::int64_t, simd_abi::neon_fixed_size<2>>(
-      vnegq_s64(static_cast<int64x2_t>(a)));
+    Experimental::simd<std::int64_t, Experimental::simd_abi::neon_fixed_size<2>>
+    abs(Experimental::simd<
+        std::int64_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return Experimental::simd<std::int64_t,
+                            Experimental::simd_abi::neon_fixed_size<2>>(
+      vabsq_s64(static_cast<int64x2_t>(a)));
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::neon_fixed_size<2>>
-    operator-(simd<std::int64_t, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<std::int64_t, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<std::int64_t, simd_abi::neon_fixed_size<2>>(
-      vsubq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+    Experimental::simd<std::int64_t, Experimental::simd_abi::neon_fixed_size<2>>
+    floor(Experimental::simd<
+          std::int64_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
 }
 
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::int64_t, simd_abi::neon_fixed_size<2>>
-    operator+(simd<std::int64_t, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<std::int64_t, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<std::int64_t, simd_abi::neon_fixed_size<2>>(
-      vaddq_s64(static_cast<int64x2_t>(lhs), static_cast<int64x2_t>(rhs)));
+    Experimental::simd<std::int64_t, Experimental::simd_abi::neon_fixed_size<2>>
+    ceil(Experimental::simd<
+         std::int64_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
 }
 
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int64_t, Experimental::simd_abi::neon_fixed_size<2>>
+    round(Experimental::simd<
+          std::int64_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    Experimental::simd<std::int64_t, Experimental::simd_abi::neon_fixed_size<2>>
+    trunc(Experimental::simd<
+          std::int64_t, Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+namespace Experimental {
+
 [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
     simd<std::int64_t, simd_abi::neon_fixed_size<2>>
     condition(simd_mask<std::int64_t, simd_abi::neon_fixed_size<2>> const& a,
@@ -778,7 +1873,8 @@ 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_IMPL_HOST_FORCEINLINE_FUNCTION simd(G&& gen) {
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit simd(
+      G&& gen) noexcept {
     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>()),
@@ -802,80 +1898,321 @@ class simd<std::uint64_t, simd_abi::neon_fixed_size<2>> {
                                                        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));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_from(value_type const* ptr,
+                                                       vector_aligned_tag) {
+    m_value = vld1q_u64(ptr);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(
+      value_type* ptr, element_aligned_tag) const {
+    vst1q_u64(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void copy_to(value_type* ptr,
+                                                     vector_aligned_tag) const {
+    vst1q_u64(ptr, m_value);
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator uint64x2_t()
+      const {
+    return m_value;
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vsubq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vaddq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd([&](std::size_t i) { return lhs[i] * rhs[i]; });
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator&(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vandq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator|(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(
+        vorrq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(
+        vceqq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return !(lhs == rhs);
+  }
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(vshlq_u64(static_cast<uint64x2_t>(lhs),
+                          vnegq_s64(vmovq_n_s64(std::int64_t(rhs)))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vshlq_u64(
+        static_cast<uint64x2_t>(lhs),
+        vnegq_s64(vreinterpretq_s64_u64(static_cast<uint64x2_t>(rhs)))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(vshlq_u64(static_cast<uint64x2_t>(lhs),
+                          vmovq_n_s64(std::int64_t(rhs))));
+  }
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION friend simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(vshlq_u64(static_cast<uint64x2_t>(lhs),
+                          vreinterpretq_s64_u64(static_cast<uint64x2_t>(rhs))));
+  }
+};
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+simd<std::int32_t, simd_abi::neon_fixed_size<2>>::simd(
+    simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& other)
+    : m_value(
+          vmovn_s64(vreinterpretq_s64_u64(static_cast<uint64x2_t>(other)))) {}
+
+KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+simd<std::int64_t, simd_abi::neon_fixed_size<2>>::simd(
+    simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& other)
+    : m_value(vreinterpretq_s64_u64(static_cast<uint64x2_t>(other))) {}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint64_t, simd_abi::neon_fixed_size<2>>
+    abs(simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+}  // namespace Experimental
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint64_t, Experimental::simd_abi::neon_fixed_size<2>>
+floor(Experimental::simd<std::uint64_t,
+                         Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint64_t, Experimental::simd_abi::neon_fixed_size<2>>
+ceil(Experimental::simd<std::uint64_t,
+                        Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint64_t, Experimental::simd_abi::neon_fixed_size<2>>
+round(Experimental::simd<std::uint64_t,
+                         Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION Experimental::simd<
+    std::uint64_t, Experimental::simd_abi::neon_fixed_size<2>>
+trunc(Experimental::simd<std::uint64_t,
+                         Experimental::simd_abi::neon_fixed_size<2>> const& a) {
+  return a;
+}
+
+namespace Experimental {
+
+[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+    simd<std::uint64_t, simd_abi::neon_fixed_size<2>>
+    condition(simd_mask<std::uint64_t, simd_abi::neon_fixed_size<2>> const& a,
+              simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& b,
+              simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& c) {
+  return simd<std::uint64_t, simd_abi::neon_fixed_size<2>>(
+      vbslq_u64(static_cast<uint64x2_t>(a), static_cast<uint64x2_t>(b),
+                static_cast<uint64x2_t>(c)));
+}
+
+template <>
+class const_where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
+                             simd<double, simd_abi::neon_fixed_size<2>>> {
+ public:
+  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using value_type = simd<double, abi_type>;
+  using mask_type  = simd_mask<double, 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(double* mem, element_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(double* mem, vector_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      double* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) const {
+    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 <>
+class where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
+                       simd<double, simd_abi::neon_fixed_size<2>>>
+    : public const_where_expression<
+          simd_mask<double, simd_abi::neon_fixed_size<2>>,
+          simd<double, simd_abi::neon_fixed_size<2>>> {
+ public:
+  where_expression(
+      simd_mask<double, simd_abi::neon_fixed_size<2>> const& mask_arg,
+      simd<double, simd_abi::neon_fixed_size<2>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(double const* mem, element_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(double const* mem, vector_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      double const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) {
+    if (m_mask[0]) m_value[0] = mem[index[0]];
+    if (m_mask[1]) m_value[1] = mem[index[1]];
+  }
+  template <class U,
+            std::enable_if_t<std::is_convertible_v<
+                                 U, simd<double, 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<double, simd_abi::neon_fixed_size<2>>>(
+            std::forward<U>(x));
+    m_value = static_cast<simd<double, simd_abi::neon_fixed_size<2>>>(
+        vbslq_f64(static_cast<uint64x2_t>(m_mask),
+                  static_cast<float64x2_t>(x_as_value_type),
+                  static_cast<float64x2_t>(m_value)));
+  }
+};
+
+template <>
+class const_where_expression<simd_mask<float, simd_abi::neon_fixed_size<2>>,
+                             simd<float, simd_abi::neon_fixed_size<2>>> {
+ public:
+  using abi_type   = simd_abi::neon_fixed_size<2>;
+  using value_type = simd<float, abi_type>;
+  using mask_type  = simd_mask<float, 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(float* mem, element_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(float* mem, vector_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator|(simd const& other) const {
-    return simd(vorrq_u64(m_value, other.m_value));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      float* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) const {
+    if (m_mask[0]) mem[index[0]] = m_value[0];
+    if (m_mask[1]) mem[index[1]] = m_value[1];
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION constexpr explicit operator uint64x2_t()
-      const {
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
+  impl_get_value() const {
     return m_value;
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator<<(unsigned int rhs) const {
-    return simd(vshlq_u64(m_value, vmovq_n_s64(std::int64_t(rhs))));
+
+  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type const&
+  impl_get_mask() const {
+    return m_mask;
+  }
+};
+
+template <>
+class where_expression<simd_mask<float, simd_abi::neon_fixed_size<2>>,
+                       simd<float, simd_abi::neon_fixed_size<2>>>
+    : public const_where_expression<
+          simd_mask<float, simd_abi::neon_fixed_size<2>>,
+          simd<float, simd_abi::neon_fixed_size<2>>> {
+ public:
+  where_expression(
+      simd_mask<float, simd_abi::neon_fixed_size<2>> const& mask_arg,
+      simd<float, simd_abi::neon_fixed_size<2>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, element_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION simd
-  operator>>(unsigned int rhs) const {
-    return simd(vshlq_u64(m_value, vmovq_n_s64(-std::int64_t(rhs))));
+  void copy_from(float const* mem, vector_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator==(simd const& other) const {
-    return mask_type(vceqq_u64(m_value, other.m_value));
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      float const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) {
+    if (m_mask[0]) m_value[0] = mem[index[0]];
+    if (m_mask[1]) m_value[1] = mem[index[1]];
   }
-  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION mask_type
-  operator!=(simd const& other) const {
-    return !((*this) == other);
+  template <class U,
+            std::enable_if_t<std::is_convertible_v<
+                                 U, simd<float, 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<float, simd_abi::neon_fixed_size<2>>>(
+            std::forward<U>(x));
+    m_value = static_cast<simd<float, simd_abi::neon_fixed_size<2>>>(
+        vbsl_f32(static_cast<uint32x2_t>(m_mask),
+                 static_cast<float32x2_t>(x_as_value_type),
+                 static_cast<float32x2_t>(m_value)));
   }
 };
 
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint64_t, simd_abi::neon_fixed_size<2>>
-    operator-(simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<std::uint64_t, simd_abi::neon_fixed_size<2>>(
-      vsubq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
-}
-
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint64_t, simd_abi::neon_fixed_size<2>>
-    operator+(simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& lhs,
-              simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& rhs) {
-  return simd<std::uint64_t, simd_abi::neon_fixed_size<2>>(
-      vaddq_u64(static_cast<uint64x2_t>(lhs), static_cast<uint64x2_t>(rhs)));
-}
-
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::int32_t, simd_abi::neon_fixed_size<2>>::simd(
-    simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& other)
-    : m_value(
-          vmovn_s64(vreinterpretq_s64_u64(static_cast<uint64x2_t>(other)))) {}
-
-KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-simd<std::int64_t, simd_abi::neon_fixed_size<2>>::simd(
-    simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& other)
-    : m_value(vreinterpretq_s64_u64(static_cast<uint64x2_t>(other))) {}
-
-[[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-    simd<std::uint64_t, simd_abi::neon_fixed_size<2>>
-    condition(simd_mask<std::uint64_t, simd_abi::neon_fixed_size<2>> const& a,
-              simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& b,
-              simd<std::uint64_t, simd_abi::neon_fixed_size<2>> const& c) {
-  return simd<std::uint64_t, simd_abi::neon_fixed_size<2>>(
-      vbslq_u64(static_cast<uint64x2_t>(a), static_cast<uint64x2_t>(b),
-                static_cast<uint64x2_t>(c)));
-}
-
 template <>
-class const_where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
-                             simd<double, simd_abi::neon_fixed_size<2>>> {
+class const_where_expression<simd_mask<float, simd_abi::neon_fixed_size<4>>,
+                             simd<float, simd_abi::neon_fixed_size<4>>> {
  public:
-  using abi_type   = simd_abi::neon_fixed_size<2>;
-  using value_type = simd<double, abi_type>;
-  using mask_type  = simd_mask<double, abi_type>;
+  using abi_type   = simd_abi::neon_fixed_size<4>;
+  using value_type = simd<float, abi_type>;
+  using mask_type  = simd_mask<float, abi_type>;
 
  protected:
   value_type& m_value;
@@ -886,16 +2223,27 @@ class const_where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
       : m_value(const_cast<value_type&>(value_arg)), m_mask(mask_arg) {}
 
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-  void copy_to(double* mem, element_aligned_tag) const {
+  void copy_to(float* mem, element_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+    if (m_mask[2]) mem[2] = m_value[2];
+    if (m_mask[3]) mem[3] = m_value[3];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(float* mem, vector_aligned_tag) const {
     if (m_mask[0]) mem[0] = m_value[0];
     if (m_mask[1]) mem[1] = m_value[1];
+    if (m_mask[2]) mem[2] = m_value[2];
+    if (m_mask[3]) mem[3] = m_value[3];
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void scatter_to(
-      double* mem,
-      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) const {
+      float* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<4>> const& index) const {
     if (m_mask[0]) mem[index[0]] = m_value[0];
     if (m_mask[1]) mem[index[1]] = m_value[1];
+    if (m_mask[2]) mem[index[2]] = m_value[2];
+    if (m_mask[3]) mem[index[3]] = m_value[3];
   }
 
   [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
@@ -910,40 +2258,51 @@ class const_where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
 };
 
 template <>
-class where_expression<simd_mask<double, simd_abi::neon_fixed_size<2>>,
-                       simd<double, simd_abi::neon_fixed_size<2>>>
+class where_expression<simd_mask<float, simd_abi::neon_fixed_size<4>>,
+                       simd<float, simd_abi::neon_fixed_size<4>>>
     : public const_where_expression<
-          simd_mask<double, simd_abi::neon_fixed_size<2>>,
-          simd<double, simd_abi::neon_fixed_size<2>>> {
+          simd_mask<float, simd_abi::neon_fixed_size<4>>,
+          simd<float, simd_abi::neon_fixed_size<4>>> {
  public:
   where_expression(
-      simd_mask<double, simd_abi::neon_fixed_size<2>> const& mask_arg,
-      simd<double, simd_abi::neon_fixed_size<2>>& value_arg)
+      simd_mask<float, simd_abi::neon_fixed_size<4>> const& mask_arg,
+      simd<float, simd_abi::neon_fixed_size<4>>& value_arg)
       : const_where_expression(mask_arg, value_arg) {}
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
-  void copy_from(double const* mem, element_aligned_tag) {
+  void copy_from(float const* mem, element_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+    if (m_mask[2]) m_value[2] = mem[2];
+    if (m_mask[3]) m_value[3] = mem[3];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(float const* mem, vector_aligned_tag) {
     if (m_mask[0]) m_value[0] = mem[0];
     if (m_mask[1]) m_value[1] = mem[1];
+    if (m_mask[2]) m_value[2] = mem[2];
+    if (m_mask[3]) m_value[3] = mem[3];
   }
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
   void gather_from(
-      double const* mem,
-      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) {
+      float const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<4>> const& index) {
     if (m_mask[0]) m_value[0] = mem[index[0]];
     if (m_mask[1]) m_value[1] = mem[index[1]];
+    if (m_mask[2]) m_value[2] = mem[index[2]];
+    if (m_mask[3]) m_value[3] = mem[index[3]];
   }
   template <class U,
             std::enable_if_t<std::is_convertible_v<
-                                 U, simd<double, simd_abi::neon_fixed_size<2>>>,
+                                 U, simd<float, simd_abi::neon_fixed_size<4>>>,
                              bool> = false>
   KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION void operator=(U&& x) {
     auto const x_as_value_type =
-        static_cast<simd<double, simd_abi::neon_fixed_size<2>>>(
+        static_cast<simd<float, simd_abi::neon_fixed_size<4>>>(
             std::forward<U>(x));
-    m_value = static_cast<simd<double, simd_abi::neon_fixed_size<2>>>(
-        vbslq_f64(static_cast<uint64x2_t>(m_mask),
-                  static_cast<float64x2_t>(x_as_value_type),
-                  static_cast<float64x2_t>(m_value)));
+    m_value = static_cast<simd<float, simd_abi::neon_fixed_size<4>>>(
+        vbslq_f32(static_cast<uint32x4_t>(m_mask),
+                  static_cast<float32x4_t>(x_as_value_type),
+                  static_cast<float32x4_t>(m_value)));
   }
 };
 
@@ -969,6 +2328,19 @@ class const_where_expression<
     if (m_mask[0]) mem[0] = m_value[0];
     if (m_mask[1]) mem[1] = m_value[1];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int32_t* mem, vector_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int32_t* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) const {
+    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 {
@@ -997,6 +2369,20 @@ 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];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, vector_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int32_t const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) {
+    if (m_mask[0]) m_value[0] = mem[index[0]];
+    if (m_mask[1]) m_value[1] = mem[index[1]];
+  }
+
   template <
       class U,
       std::enable_if_t<
@@ -1013,6 +2399,108 @@ class where_expression<simd_mask<std::int32_t, simd_abi::neon_fixed_size<2>>,
   }
 };
 
+template <>
+class const_where_expression<
+    simd_mask<std::int32_t, simd_abi::neon_fixed_size<4>>,
+    simd<std::int32_t, simd_abi::neon_fixed_size<4>>> {
+ public:
+  using abi_type   = simd_abi::neon_fixed_size<4>;
+  using value_type = simd<std::int32_t, abi_type>;
+  using mask_type  = simd_mask<std::int32_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::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];
+    if (m_mask[2]) mem[2] = m_value[2];
+    if (m_mask[3]) mem[3] = m_value[3];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int32_t* mem, vector_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+    if (m_mask[2]) mem[2] = m_value[2];
+    if (m_mask[3]) mem[3] = m_value[3];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int32_t* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<4>> const& index) const {
+    if (m_mask[0]) mem[index[0]] = m_value[0];
+    if (m_mask[1]) mem[index[1]] = m_value[1];
+    if (m_mask[2]) mem[index[2]] = m_value[2];
+    if (m_mask[3]) mem[index[3]] = m_value[3];
+  }
+
+  [[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::int32_t, simd_abi::neon_fixed_size<4>>,
+                       simd<std::int32_t, simd_abi::neon_fixed_size<4>>>
+    : public const_where_expression<
+          simd_mask<std::int32_t, simd_abi::neon_fixed_size<4>>,
+          simd<std::int32_t, simd_abi::neon_fixed_size<4>>> {
+ public:
+  where_expression(
+      simd_mask<std::int32_t, simd_abi::neon_fixed_size<4>> const& mask_arg,
+      simd<std::int32_t, simd_abi::neon_fixed_size<4>>& value_arg)
+      : const_where_expression(mask_arg, value_arg) {}
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, element_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+    if (m_mask[2]) m_value[2] = mem[2];
+    if (m_mask[3]) m_value[3] = mem[3];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int32_t const* mem, vector_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+    if (m_mask[2]) m_value[2] = mem[2];
+    if (m_mask[3]) m_value[3] = mem[3];
+  }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int32_t const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<4>> const& index) {
+    if (m_mask[0]) m_value[0] = mem[index[0]];
+    if (m_mask[1]) m_value[1] = mem[index[1]];
+    if (m_mask[2]) m_value[2] = mem[index[2]];
+    if (m_mask[3]) m_value[3] = mem[index[3]];
+  }
+  template <
+      class U,
+      std::enable_if_t<
+          std::is_convertible_v<U, simd<int32_t, simd_abi::neon_fixed_size<4>>>,
+          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<4>>>(
+            std::forward<U>(x));
+    m_value = static_cast<simd<int32_t, simd_abi::neon_fixed_size<4>>>(
+        vbslq_s32(static_cast<uint32x4_t>(m_mask),
+                  static_cast<int32x4_t>(x_as_value_type),
+                  static_cast<int32x4_t>(m_value)));
+  }
+};
+
 template <>
 class const_where_expression<
     simd_mask<std::int64_t, simd_abi::neon_fixed_size<2>>,
@@ -1035,6 +2523,19 @@ class const_where_expression<
     if (m_mask[0]) mem[0] = m_value[0];
     if (m_mask[1]) mem[1] = m_value[1];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::int64_t* mem, vector_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::int64_t* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) const {
+    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 {
@@ -1063,6 +2564,20 @@ class where_expression<simd_mask<std::int64_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];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::int64_t const* mem, vector_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::int64_t const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) {
+    if (m_mask[0]) m_value[0] = mem[index[0]];
+    if (m_mask[1]) m_value[1] = mem[index[1]];
+  }
+
   template <
       class U,
       std::enable_if_t<std::is_convertible_v<
@@ -1101,6 +2616,19 @@ class const_where_expression<
     if (m_mask[0]) mem[0] = m_value[0];
     if (m_mask[1]) mem[1] = m_value[1];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_to(std::uint64_t* mem, vector_aligned_tag) const {
+    if (m_mask[0]) mem[0] = m_value[0];
+    if (m_mask[1]) mem[1] = m_value[1];
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void scatter_to(
+      std::uint64_t* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) const {
+    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 {
@@ -1129,6 +2657,20 @@ class where_expression<simd_mask<std::uint64_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];
   }
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void copy_from(std::uint64_t const* mem, vector_aligned_tag) {
+    if (m_mask[0]) m_value[0] = mem[0];
+    if (m_mask[1]) m_value[1] = mem[1];
+  }
+
+  KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION
+  void gather_from(
+      std::uint64_t const* mem,
+      simd<std::int32_t, simd_abi::neon_fixed_size<2>> const& index) {
+    if (m_mask[0]) m_value[0] = mem[index[0]];
+    if (m_mask[1]) m_value[1] = mem[index[1]];
+  }
+
   template <class U,
             std::enable_if_t<
                 std::is_convertible_v<
diff --git a/simd/src/Kokkos_SIMD_Scalar.hpp b/simd/src/Kokkos_SIMD_Scalar.hpp
index 8803417447..9de46dbed9 100644
--- a/simd/src/Kokkos_SIMD_Scalar.hpp
+++ b/simd/src/Kokkos_SIMD_Scalar.hpp
@@ -23,6 +23,11 @@
 
 #include <Kokkos_SIMD_Common.hpp>
 
+#ifdef KOKKOS_SIMD_COMMON_MATH_HPP
+#error \
+    "Kokkos_SIMD_Scalar.hpp must be included before Kokkos_SIMD_Common_Math.hpp!"
+#endif
+
 namespace Kokkos {
 namespace Experimental {
 
@@ -45,6 +50,13 @@ class simd_mask<T, simd_abi::scalar> {
   KOKKOS_FORCEINLINE_FUNCTION static constexpr std::size_t size() { return 1; }
   KOKKOS_FORCEINLINE_FUNCTION explicit simd_mask(value_type value)
       : m_value(value) {}
+  template <
+      class G,
+      std::enable_if_t<std::is_invocable_r_v<
+                           value_type, G, std::integral_constant<bool, false>>,
+                       bool> = false>
+  KOKKOS_FORCEINLINE_FUNCTION constexpr explicit simd_mask(G&& gen) noexcept
+      : m_value(gen(0)) {}
   template <class U>
   KOKKOS_FORCEINLINE_FUNCTION simd_mask(
       simd_mask<U, simd_abi::scalar> const& other)
@@ -106,113 +118,173 @@ class simd<T, simd_abi::scalar> {
                 std::is_invocable_r_v<value_type, G,
                                       std::integral_constant<std::size_t, 0>>,
                 bool> = false>
-  KOKKOS_FORCEINLINE_FUNCTION simd(G&& gen)
-      : m_value(gen(std::integral_constant<std::size_t, 0>())) {}
-  KOKKOS_FORCEINLINE_FUNCTION simd operator-() const { return simd(-m_value); }
-  KOKKOS_FORCEINLINE_FUNCTION simd operator>>(int rhs) const {
-    return simd(m_value >> rhs);
+  KOKKOS_FORCEINLINE_FUNCTION constexpr explicit simd(G&& gen) noexcept
+      : m_value(gen(0)) {}
+  KOKKOS_FORCEINLINE_FUNCTION constexpr explicit operator T() const {
+    return m_value;
   }
-  KOKKOS_FORCEINLINE_FUNCTION simd
-  operator>>(simd<int, abi_type> const& rhs) const {
-    return simd(m_value >> static_cast<int>(rhs));
+  KOKKOS_FORCEINLINE_FUNCTION void copy_from(T const* ptr,
+                                             element_aligned_tag) {
+    m_value = *ptr;
   }
-  KOKKOS_FORCEINLINE_FUNCTION simd operator<<(int rhs) const {
-    return simd(m_value << rhs);
+  KOKKOS_FORCEINLINE_FUNCTION void copy_from(T const* ptr, vector_aligned_tag) {
+    m_value = *ptr;
   }
-  KOKKOS_FORCEINLINE_FUNCTION simd
-  operator<<(simd<int, abi_type> const& rhs) const {
-    return simd(m_value << static_cast<int>(rhs));
+  KOKKOS_FORCEINLINE_FUNCTION void copy_to(T* ptr, element_aligned_tag) const {
+    *ptr = m_value;
   }
-  KOKKOS_FORCEINLINE_FUNCTION simd operator&(simd const& other) const {
-    return m_value & other.m_value;
+  KOKKOS_FORCEINLINE_FUNCTION void copy_to(T* ptr, vector_aligned_tag) const {
+    *ptr = m_value;
   }
-  KOKKOS_FORCEINLINE_FUNCTION simd operator|(simd const& other) const {
-    return m_value | other.m_value;
+
+  KOKKOS_FORCEINLINE_FUNCTION reference operator[](std::size_t) {
+    return m_value;
   }
-  KOKKOS_FORCEINLINE_FUNCTION constexpr explicit operator T() const {
+  KOKKOS_FORCEINLINE_FUNCTION value_type operator[](std::size_t) const {
     return m_value;
   }
-  KOKKOS_FORCEINLINE_FUNCTION mask_type operator<(simd const& other) const {
-    return mask_type(m_value < other.m_value);
+  KOKKOS_FORCEINLINE_FUNCTION simd operator-() const noexcept {
+    return simd(-m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION mask_type operator>(simd const& other) const {
-    return mask_type(m_value > other.m_value);
+
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator*(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(lhs.m_value * rhs.m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION mask_type operator<=(simd const& other) const {
-    return mask_type(m_value <= other.m_value);
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator/(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(lhs.m_value / rhs.m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION mask_type operator>=(simd const& other) const {
-    return mask_type(m_value >= other.m_value);
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator+(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(lhs.m_value + rhs.m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION mask_type operator==(simd const& other) const {
-    return mask_type(m_value == other.m_value);
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator-(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(lhs.m_value - rhs.m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION mask_type operator!=(simd const& other) const {
-    return mask_type(m_value != other.m_value);
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator>>(
+      simd const& lhs, int rhs) noexcept {
+    return simd(lhs.m_value >> rhs);
   }
-  KOKKOS_FORCEINLINE_FUNCTION void copy_from(T const* ptr,
-                                             element_aligned_tag) {
-    m_value = *ptr;
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator>>(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(lhs.m_value >> rhs.m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION void copy_to(T* ptr, element_aligned_tag) const {
-    *ptr = m_value;
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator<<(
+      simd const& lhs, int rhs) noexcept {
+    return simd(lhs.m_value << rhs);
   }
-  KOKKOS_FORCEINLINE_FUNCTION reference operator[](std::size_t) {
-    return m_value;
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator<<(
+      simd const& lhs, simd const& rhs) noexcept {
+    return simd(lhs.m_value << rhs.m_value);
   }
-  KOKKOS_FORCEINLINE_FUNCTION value_type operator[](std::size_t) const {
-    return m_value;
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator&(
+      simd const& lhs, simd const& rhs) noexcept {
+    return lhs.m_value & rhs.m_value;
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr simd operator|(
+      simd const& lhs, simd const& rhs) noexcept {
+    return lhs.m_value | rhs.m_value;
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type
+  operator<(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(lhs.m_value < rhs.m_value);
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type
+  operator>(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(lhs.m_value > rhs.m_value);
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type
+  operator<=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(lhs.m_value <= rhs.m_value);
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type
+  operator>=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(lhs.m_value >= rhs.m_value);
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type
+  operator==(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(lhs.m_value == rhs.m_value);
+  }
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION friend constexpr mask_type
+  operator!=(simd const& lhs, simd const& rhs) noexcept {
+    return mask_type(lhs.m_value != rhs.m_value);
   }
 };
 
+}  // namespace Experimental
+
 template <class T>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> operator*(
-    simd<T, simd_abi::scalar> const& lhs,
-    simd<T, simd_abi::scalar> const& rhs) {
-  return simd<T, simd_abi::scalar>(static_cast<T>(lhs) * static_cast<T>(rhs));
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+    Experimental::simd<T, Experimental::simd_abi::scalar>
+    abs(Experimental::simd<T, Experimental::simd_abi::scalar> const& a) {
+  if constexpr (std::is_signed_v<T>) {
+    return (a < 0 ? -a : a);
+  }
+  return a;
 }
 
-template <class T>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> operator/(
-    simd<T, simd_abi::scalar> const& lhs,
-    simd<T, simd_abi::scalar> const& rhs) {
-  return simd<T, simd_abi::scalar>(static_cast<T>(lhs) / static_cast<T>(rhs));
+template <typename T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto floor(
+    Experimental::simd<T, Experimental::simd_abi::scalar> const& a) {
+  using data_type = std::conditional_t<std::is_floating_point_v<T>, T, double>;
+  return Experimental::simd<data_type, Experimental::simd_abi::scalar>(
+      Kokkos::floor(static_cast<data_type>(a[0])));
 }
 
-template <class T>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> operator+(
-    simd<T, simd_abi::scalar> const& lhs,
-    simd<T, simd_abi::scalar> const& rhs) {
-  return simd<T, simd_abi::scalar>(static_cast<T>(lhs) + static_cast<T>(rhs));
+template <typename T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto ceil(
+    Experimental::simd<T, Experimental::simd_abi::scalar> const& a) {
+  using data_type = std::conditional_t<std::is_floating_point_v<T>, T, double>;
+  return Experimental::simd<data_type, Experimental::simd_abi::scalar>(
+      Kokkos::ceil(static_cast<data_type>(a[0])));
 }
 
-template <class T>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> operator-(
-    simd<T, simd_abi::scalar> const& lhs,
-    simd<T, simd_abi::scalar> const& rhs) {
-  return simd<T, simd_abi::scalar>(static_cast<T>(lhs) - static_cast<T>(rhs));
+template <typename T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto round(
+    Experimental::simd<T, Experimental::simd_abi::scalar> const& a) {
+  using data_type = std::conditional_t<std::is_floating_point_v<T>, T, double>;
+  return Experimental::simd<data_type, Experimental::simd_abi::scalar>(
+      Experimental::round_half_to_nearest_even(static_cast<data_type>(a[0])));
+}
+
+template <typename T>
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION auto trunc(
+    Experimental::simd<T, Experimental::simd_abi::scalar> const& a) {
+  using data_type = std::conditional_t<std::is_floating_point_v<T>, T, double>;
+  return Experimental::simd<data_type, Experimental::simd_abi::scalar>(
+      Kokkos::trunc(static_cast<data_type>(a[0])));
 }
 
 template <class T>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> abs(
-    simd<T, simd_abi::scalar> const& a) {
-  return simd<T, simd_abi::scalar>(std::abs(static_cast<T>(a)));
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+    Experimental::simd<T, Experimental::simd_abi::scalar>
+    sqrt(Experimental::simd<T, Experimental::simd_abi::scalar> const& a) {
+  return Experimental::simd<T, Experimental::simd_abi::scalar>(
+      std::sqrt(static_cast<T>(a)));
 }
 
 template <class T>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> sqrt(
-    simd<T, simd_abi::scalar> const& a) {
-  return simd<T, simd_abi::scalar>(std::sqrt(static_cast<T>(a)));
+KOKKOS_FORCEINLINE_FUNCTION
+    Experimental::simd<T, Experimental::simd_abi::scalar>
+    fma(Experimental::simd<T, Experimental::simd_abi::scalar> const& x,
+        Experimental::simd<T, Experimental::simd_abi::scalar> const& y,
+        Experimental::simd<T, Experimental::simd_abi::scalar> const& z) {
+  return Experimental::simd<T, Experimental::simd_abi::scalar>(
+      (static_cast<T>(x) * static_cast<T>(y)) + static_cast<T>(z));
 }
 
 template <class T>
-KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> fma(
-    simd<T, simd_abi::scalar> const& x, simd<T, simd_abi::scalar> const& y,
-    simd<T, simd_abi::scalar> const& z) {
-  return simd<T, simd_abi::scalar>((static_cast<T>(x) * static_cast<T>(y)) +
-                                   static_cast<T>(z));
+[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION
+    Experimental::simd<T, Experimental::simd_abi::scalar>
+    copysign(Experimental::simd<T, Experimental::simd_abi::scalar> const& a,
+             Experimental::simd<T, Experimental::simd_abi::scalar> const& b) {
+  return std::copysign(static_cast<T>(a), static_cast<T>(b));
 }
 
+namespace Experimental {
+
 template <class T>
 KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> condition(
     desul::Impl::dont_deduce_this_parameter_t<
@@ -222,12 +294,6 @@ KOKKOS_FORCEINLINE_FUNCTION simd<T, simd_abi::scalar> condition(
                                                         : static_cast<T>(c));
 }
 
-template <class T, class Abi>
-[[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION simd<T, Abi> copysign(
-    simd<T, Abi> const& a, simd<T, Abi> const& b) {
-  return std::copysign(static_cast<T>(a), static_cast<T>(b));
-}
-
 template <class T>
 class const_where_expression<simd_mask<T, simd_abi::scalar>,
                              simd<T, simd_abi::scalar>> {
@@ -249,6 +315,10 @@ class const_where_expression<simd_mask<T, simd_abi::scalar>,
   void copy_to(T* mem, element_aligned_tag) const {
     if (static_cast<bool>(m_mask)) *mem = static_cast<T>(m_value);
   }
+  KOKKOS_FORCEINLINE_FUNCTION
+  void copy_to(T* mem, vector_aligned_tag) const {
+    if (static_cast<bool>(m_mask)) *mem = static_cast<T>(m_value);
+  }
   template <class Integral>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<std::is_integral_v<Integral>>
   scatter_to(T* mem, simd<Integral, simd_abi::scalar> const& index) const {
@@ -256,13 +326,13 @@ class const_where_expression<simd_mask<T, simd_abi::scalar>,
       mem[static_cast<Integral>(index)] = static_cast<T>(m_value);
   }
 
-  [[nodiscard]] KOKKOS_IMPL_HOST_FORCEINLINE_FUNCTION value_type const&
-  impl_get_value() const {
+  [[nodiscard]] KOKKOS_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 {
+  [[nodiscard]] KOKKOS_FORCEINLINE_FUNCTION mask_type const& impl_get_mask()
+      const {
     return m_mask;
   }
 };
@@ -285,6 +355,10 @@ class where_expression<simd_mask<T, simd_abi::scalar>,
   void copy_from(T const* mem, element_aligned_tag) {
     if (static_cast<bool>(this->m_mask)) this->m_value = *mem;
   }
+  KOKKOS_FORCEINLINE_FUNCTION
+  void copy_from(T const* mem, vector_aligned_tag) {
+    if (static_cast<bool>(this->m_mask)) this->m_value = *mem;
+  }
   template <class Integral>
   KOKKOS_FORCEINLINE_FUNCTION std::enable_if_t<std::is_integral_v<Integral>>
   gather_from(T const* mem, simd<Integral, simd_abi::scalar> const& index) {
diff --git a/simd/unit_tests/CMakeLists.txt b/simd/unit_tests/CMakeLists.txt
index f4de862418..109effc710 100644
--- a/simd/unit_tests/CMakeLists.txt
+++ b/simd/unit_tests/CMakeLists.txt
@@ -1,5 +1,9 @@
-KOKKOS_ADD_EXECUTABLE_AND_TEST(
-  UnitTest_SIMD
-  SOURCES
-  UnitTestMain.cpp
-  TestSIMD.cpp)
+KOKKOS_INCLUDE_DIRECTORIES(${KOKKOS_SOURCE_DIR}/simd/unit_tests/include)
+
+IF((NOT (Kokkos_ENABLE_CUDA AND WIN32)))
+  KOKKOS_ADD_EXECUTABLE_AND_TEST(
+    UnitTest_SIMD
+    SOURCES
+    UnitTestMain.cpp
+    TestSIMD.cpp)
+ENDIF()
diff --git a/simd/unit_tests/TestSIMD.cpp b/simd/unit_tests/TestSIMD.cpp
index cf00cc36cb..7a1f9be2a0 100644
--- a/simd/unit_tests/TestSIMD.cpp
+++ b/simd/unit_tests/TestSIMD.cpp
@@ -14,544 +14,11 @@
 //
 //@HEADER
 
-#include <gtest/gtest.h>
-
-#include <Kokkos_SIMD.hpp>
-
-class gtest_checker {
- public:
-  void truth(bool x) const { EXPECT_TRUE(x); }
-  template <class T>
-  void equality(T const& a, T const& b) const {
-    EXPECT_EQ(a, b);
-  }
-};
-
-class kokkos_checker {
- public:
-  KOKKOS_INLINE_FUNCTION void truth(bool x) const {
-    if (!x) Kokkos::abort("SIMD unit test truth condition failed on device");
-  }
-  template <class T>
-  KOKKOS_INLINE_FUNCTION void equality(T const& a, T const& b) const {
-    if (a != b)
-      Kokkos::abort("SIMD unit test equality condition failed on device");
-  }
-};
-
-template <class T, class Abi>
-inline void host_check_equality(
-    Kokkos::Experimental::simd<T, Abi> const& expected_result,
-    Kokkos::Experimental::simd<T, Abi> const& computed_result,
-    std::size_t nlanes) {
-  gtest_checker checker;
-  for (std::size_t i = 0; i < nlanes; ++i) {
-    checker.equality(expected_result[i], computed_result[i]);
-  }
-  using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
-  mask_type mask(false);
-  for (std::size_t i = 0; i < nlanes; ++i) {
-    mask[i] = true;
-  }
-  checker.equality((expected_result == computed_result) && mask, mask);
-}
-
-template <class T, class Abi>
-KOKKOS_INLINE_FUNCTION void device_check_equality(
-    Kokkos::Experimental::simd<T, Abi> const& expected_result,
-    Kokkos::Experimental::simd<T, Abi> const& computed_result,
-    std::size_t nlanes) {
-  kokkos_checker checker;
-  for (std::size_t i = 0; i < nlanes; ++i) {
-    checker.equality(expected_result[i], computed_result[i]);
-  }
-  using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
-  mask_type mask(false);
-  for (std::size_t i = 0; i < nlanes; ++i) {
-    mask[i] = true;
-  }
-  checker.equality((expected_result == computed_result) && mask, mask);
-}
-
-class load_element_aligned {
- public:
-  template <class T, class Abi>
-  bool host_load(T const* mem, std::size_t n,
-                 Kokkos::Experimental::simd<T, Abi>& result) const {
-    if (n < result.size()) return false;
-    result.copy_from(mem, Kokkos::Experimental::element_aligned_tag());
-    return true;
-  }
-  template <class T, class Abi>
-  KOKKOS_INLINE_FUNCTION bool device_load(
-      T const* mem, std::size_t n,
-      Kokkos::Experimental::simd<T, Abi>& result) const {
-    if (n < result.size()) return false;
-    result.copy_from(mem, Kokkos::Experimental::element_aligned_tag());
-    return true;
-  }
-};
-
-class load_masked {
- public:
-  template <class T, class Abi>
-  bool host_load(T const* mem, std::size_t n,
-                 Kokkos::Experimental::simd<T, Abi>& result) const {
-    using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
-    mask_type mask(false);
-    for (std::size_t i = 0; i < n; ++i) {
-      mask[i] = true;
-    }
-    where(mask, result)
-        .copy_from(mem, Kokkos::Experimental::element_aligned_tag());
-    where(!mask, result) = 0;
-    return true;
-  }
-  template <class T, class Abi>
-  KOKKOS_INLINE_FUNCTION bool device_load(
-      T const* mem, std::size_t n,
-      Kokkos::Experimental::simd<T, Abi>& result) const {
-    using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
-    mask_type mask(false);
-    for (std::size_t i = 0; i < n; ++i) {
-      mask[i] = true;
-    }
-    where(mask, result)
-        .copy_from(mem, Kokkos::Experimental::element_aligned_tag());
-    where(!mask, result) = T(0);
-    return true;
-  }
-};
-
-class load_as_scalars {
- public:
-  template <class T, class Abi>
-  bool host_load(T const* mem, std::size_t n,
-                 Kokkos::Experimental::simd<T, Abi>& result) const {
-    for (std::size_t i = 0; i < n; ++i) {
-      result[i] = mem[i];
-    }
-    for (std::size_t i = n; i < result.size(); ++i) {
-      result[i] = T(0);
-    }
-    return true;
-  }
-  template <class T, class Abi>
-  KOKKOS_INLINE_FUNCTION bool device_load(
-      T const* mem, std::size_t n,
-      Kokkos::Experimental::simd<T, Abi>& result) const {
-    for (std::size_t i = 0; i < n; ++i) {
-      result[i] = mem[i];
-    }
-    for (std::size_t i = n; i < result.size(); ++i) {
-      result[i] = T(0);
-    }
-    return true;
-  }
-};
-
-template <class Abi, class Loader, class BinaryOp, class T>
-void host_check_binary_op_one_loader(BinaryOp binary_op, std::size_t n,
-                                     T const* first_args,
-                                     T const* second_args) {
-  Loader loader;
-  using simd_type             = Kokkos::Experimental::simd<T, Abi>;
-  std::size_t constexpr width = simd_type::size();
-  for (std::size_t i = 0; i < n; i += width) {
-    std::size_t const nremaining = n - i;
-    std::size_t const nlanes     = Kokkos::min(nremaining, width);
-    simd_type first_arg;
-    bool const loaded_first_arg =
-        loader.host_load(first_args + i, nlanes, first_arg);
-    simd_type second_arg;
-    bool const loaded_second_arg =
-        loader.host_load(second_args + i, nlanes, second_arg);
-    if (!(loaded_first_arg && loaded_second_arg)) continue;
-    simd_type expected_result;
-    // 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);
-  }
-}
-
-template <class Abi, class Loader, class BinaryOp, class T>
-KOKKOS_INLINE_FUNCTION void device_check_binary_op_one_loader(
-    BinaryOp binary_op, std::size_t n, T const* first_args,
-    T const* second_args) {
-  Loader loader;
-  using simd_type             = Kokkos::Experimental::simd<T, Abi>;
-  std::size_t constexpr width = simd_type::size();
-  for (std::size_t i = 0; i < n; i += width) {
-    std::size_t const nremaining = n - i;
-    std::size_t const nlanes     = Kokkos::min(nremaining, width);
-    simd_type first_arg;
-    bool const loaded_first_arg =
-        loader.device_load(first_args + i, nlanes, first_arg);
-    simd_type second_arg;
-    bool const loaded_second_arg =
-        loader.device_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_device(first_arg[lane], second_arg[lane]);
-    }
-    simd_type const computed_result =
-        binary_op.on_device(first_arg, second_arg);
-    device_check_equality(expected_result, computed_result, nlanes);
-  }
-}
-
-template <class Abi, class BinaryOp, class T>
-inline void host_check_binary_op_all_loaders(BinaryOp binary_op, std::size_t n,
-                                             T const* first_args,
-                                             T const* second_args) {
-  host_check_binary_op_one_loader<Abi, load_element_aligned>(
-      binary_op, n, first_args, second_args);
-  host_check_binary_op_one_loader<Abi, load_masked>(binary_op, n, first_args,
-                                                    second_args);
-  host_check_binary_op_one_loader<Abi, load_as_scalars>(
-      binary_op, n, first_args, second_args);
-}
-
-template <class Abi, class BinaryOp, class T>
-KOKKOS_INLINE_FUNCTION void device_check_binary_op_all_loaders(
-    BinaryOp binary_op, std::size_t n, T const* first_args,
-    T const* second_args) {
-  device_check_binary_op_one_loader<Abi, load_element_aligned>(
-      binary_op, n, first_args, second_args);
-  device_check_binary_op_one_loader<Abi, load_masked>(binary_op, n, first_args,
-                                                      second_args);
-  device_check_binary_op_one_loader<Abi, load_as_scalars>(
-      binary_op, n, first_args, second_args);
-}
-
-class plus {
- public:
-  template <class T>
-  auto on_host(T const& a, T const& b) const {
-    return a + b;
-  }
-  template <class T>
-  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
-    return a + b;
-  }
-};
-
-class minus {
- public:
-  template <class T>
-  auto on_host(T const& a, T const& b) const {
-    return a - b;
-  }
-  template <class T>
-  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
-    return a - b;
-  }
-};
-
-class multiplies {
- public:
-  template <class T>
-  auto on_host(T const& a, T const& b) const {
-    return a * b;
-  }
-  template <class T>
-  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
-    return a * b;
-  }
-};
-
-class divides {
- public:
-  template <class T>
-  auto on_host(T const& a, T const& b) const {
-    return a / b;
-  }
-  template <class T>
-  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
-    return a / b;
-  }
-};
-
-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);
-
-  // 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>
-inline void host_check_mask_ops() {
-  using mask_type = Kokkos::Experimental::simd_mask<double, Abi>;
-  EXPECT_FALSE(none_of(mask_type(true)));
-  EXPECT_TRUE(none_of(mask_type(false)));
-  EXPECT_TRUE(all_of(mask_type(true)));
-  EXPECT_FALSE(all_of(mask_type(false)));
-}
-
-template <class Abi>
-inline void host_check_conversions() {
-  {
-    auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
-    auto b = Kokkos::Experimental::simd<std::int64_t, Abi>(a);
-    EXPECT_TRUE(all_of(b == decltype(b)(1)));
-  }
-  {
-    auto a = Kokkos::Experimental::simd<std::int32_t, Abi>(1);
-    auto b = Kokkos::Experimental::simd<std::uint64_t, Abi>(a);
-    EXPECT_TRUE(all_of(b == decltype(b)(1)));
-  }
-  {
-    auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
-    auto b = Kokkos::Experimental::simd<std::int32_t, Abi>(a);
-    EXPECT_TRUE(all_of(b == decltype(b)(1)));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<double, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(a);
-    EXPECT_TRUE(b == decltype(b)(true));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<std::uint64_t, Abi>(a);
-    EXPECT_TRUE(b == decltype(b)(true));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<std::int64_t, Abi>(a);
-    EXPECT_TRUE(b == decltype(b)(true));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<double, Abi>(a);
-    EXPECT_TRUE(b == decltype(b)(true));
-  }
-}
-
-template <class Abi>
-inline void host_check_shifts() {
-  auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(8);
-  auto b = a >> 1;
-  EXPECT_TRUE(all_of(b == decltype(b)(4)));
-}
-
-template <class Abi>
-inline void host_check_condition() {
-  auto a = Kokkos::Experimental::condition(
-      Kokkos::Experimental::simd<std::int32_t, Abi>(1) > 0,
-      Kokkos::Experimental::simd<std::uint64_t, Abi>(16),
-      Kokkos::Experimental::simd<std::uint64_t, Abi>(20));
-  EXPECT_TRUE(all_of(a == decltype(a)(16)));
-}
-
-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);
-
-  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>
-KOKKOS_INLINE_FUNCTION void device_check_mask_ops() {
-  using mask_type = Kokkos::Experimental::simd_mask<double, Abi>;
-  kokkos_checker checker;
-  checker.truth(!none_of(mask_type(true)));
-  checker.truth(none_of(mask_type(false)));
-  checker.truth(all_of(mask_type(true)));
-  checker.truth(!all_of(mask_type(false)));
-}
-
-template <class Abi>
-KOKKOS_INLINE_FUNCTION void device_check_conversions() {
-  kokkos_checker checker;
-  {
-    auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
-    auto b = Kokkos::Experimental::simd<std::int64_t, Abi>(a);
-    checker.truth(all_of(b == decltype(b)(1)));
-  }
-  {
-    auto a = Kokkos::Experimental::simd<std::int32_t, Abi>(1);
-    auto b = Kokkos::Experimental::simd<std::uint64_t, Abi>(a);
-    checker.truth(all_of(b == decltype(b)(1)));
-  }
-  {
-    auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
-    auto b = Kokkos::Experimental::simd<std::int32_t, Abi>(a);
-    checker.truth(all_of(b == decltype(b)(1)));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<double, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(a);
-    checker.truth(b == decltype(b)(true));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<std::uint64_t, Abi>(a);
-    checker.truth(b == decltype(b)(true));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<std::int64_t, Abi>(a);
-    checker.truth(b == decltype(b)(true));
-  }
-  {
-    auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
-    auto b = Kokkos::Experimental::simd_mask<double, Abi>(a);
-    checker.truth(b == decltype(b)(true));
-  }
-}
-
-template <class Abi>
-KOKKOS_INLINE_FUNCTION void device_check_shifts() {
-  kokkos_checker checker;
-  auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(8);
-  auto b = a >> 1;
-  checker.truth(all_of(b == decltype(b)(4)));
-}
-
-template <class Abi>
-KOKKOS_INLINE_FUNCTION void device_check_condition() {
-  kokkos_checker checker;
-  auto a = Kokkos::Experimental::condition(
-      Kokkos::Experimental::simd<std::int32_t, Abi>(1) > 0,
-      Kokkos::Experimental::simd<std::uint64_t, Abi>(16),
-      Kokkos::Experimental::simd<std::uint64_t, Abi>(20));
-  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() {
-  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() {
-  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>();
-  device_check_condition<Abi>();
-}
-
-inline void host_check_abis(Kokkos::Experimental::Impl::abi_set<>) {}
-
-KOKKOS_INLINE_FUNCTION void device_check_abis(
-    Kokkos::Experimental::Impl::abi_set<>) {}
-
-template <class FirstAbi, class... RestAbis>
-inline void host_check_abis(
-    Kokkos::Experimental::Impl::abi_set<FirstAbi, RestAbis...>) {
-  host_check_abi<FirstAbi>();
-  host_check_abis(Kokkos::Experimental::Impl::abi_set<RestAbis...>());
-}
-
-template <class FirstAbi, class... RestAbis>
-KOKKOS_INLINE_FUNCTION void device_check_abis(
-    Kokkos::Experimental::Impl::abi_set<FirstAbi, RestAbis...>) {
-  device_check_abi<FirstAbi>();
-  device_check_abis(Kokkos::Experimental::Impl::abi_set<RestAbis...>());
-}
-
-TEST(simd, host) {
-  host_check_abis(Kokkos::Experimental::Impl::host_abi_set());
-}
-
-class simd_device_functor {
- public:
-  KOKKOS_INLINE_FUNCTION void operator()(int) const {
-    device_check_abis(Kokkos::Experimental::Impl::device_abi_set());
-  }
-};
-
-TEST(simd, device) {
-  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::IndexType<int>>(0, 1),
-                       simd_device_functor());
-}
+#include <TestSIMD_MathOps.hpp>
+#include <TestSIMD_MaskOps.hpp>
+#include <TestSIMD_Conversions.hpp>
+#include <TestSIMD_ShiftOps.hpp>
+#include <TestSIMD_Condition.hpp>
+#include <TestSIMD_GeneratorCtors.hpp>
+#include <TestSIMD_WhereExpressions.hpp>
+#include <TestSIMD_Reductions.hpp>
diff --git a/simd/unit_tests/include/SIMDTesting_Ops.hpp b/simd/unit_tests/include/SIMDTesting_Ops.hpp
new file mode 100644
index 0000000000..74141f2531
--- /dev/null
+++ b/simd/unit_tests/include/SIMDTesting_Ops.hpp
@@ -0,0 +1,375 @@
+//@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_SIMD_TESTING_OPS_HPP
+#define KOKKOS_SIMD_TESTING_OPS_HPP
+
+#include <Kokkos_SIMD.hpp>
+
+class plus {
+ public:
+  template <class T>
+  auto on_host(T const& a, T const& b) const {
+    return a + b;
+  }
+  template <class T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
+    return a + b;
+  }
+};
+
+class minus {
+ public:
+  template <class T>
+  auto on_host(T const& a, T const& b) const {
+    return a - b;
+  }
+  template <class T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
+    return a - b;
+  }
+};
+
+class multiplies {
+ public:
+  template <class T>
+  auto on_host(T const& a, T const& b) const {
+    return a * b;
+  }
+  template <class T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
+    return a * b;
+  }
+};
+
+class divides {
+ public:
+  template <class T>
+  auto on_host(T const& a, T const& b) const {
+    return a / b;
+  }
+  template <class T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a, T const& b) const {
+    return a / b;
+  }
+};
+
+class absolutes {
+  template <typename T>
+  static KOKKOS_FUNCTION auto abs_impl(T const& x) {
+    if constexpr (std::is_signed_v<T>) {
+      return Kokkos::abs(x);
+    }
+    return x;
+  }
+
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    if constexpr (std::is_signed_v<typename T::value_type>) {
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+      KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_PUSH()
+      return Kokkos::Experimental::abs(a);
+      KOKKOS_IMPL_DISABLE_DEPRECATED_WARNINGS_POP()
+#else
+      return Kokkos::abs(a);
+#endif
+    }
+    return a;
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return abs_impl(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    if constexpr (std::is_signed_v<typename T::value_type>) {
+      return Kokkos::abs(a);
+    }
+    return a;
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    return abs_impl(a);
+  }
+};
+
+class floors {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    return Kokkos::floor(a);
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return Kokkos::floor(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    return Kokkos::floor(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    return Kokkos::floor(a);
+  }
+};
+
+class ceils {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    return Kokkos::ceil(a);
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return Kokkos::ceil(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    return Kokkos::ceil(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    return Kokkos::ceil(a);
+  }
+};
+
+class rounds {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    return Kokkos::round(a);
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return std::rint(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    return Kokkos::round(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    return Kokkos::Experimental::round_half_to_nearest_even(a);
+  }
+};
+
+class truncates {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    return Kokkos::trunc(a);
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return Kokkos::trunc(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    return Kokkos::trunc(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    return Kokkos::trunc(a);
+  }
+};
+
+class shift_right {
+ public:
+  template <typename T, typename U>
+  auto on_host(T&& a, U&& b) const {
+    return a >> b;
+  }
+  template <typename T, typename U>
+  KOKKOS_INLINE_FUNCTION auto on_device(T&& a, U&& b) const {
+    return a >> b;
+  }
+};
+
+class shift_left {
+ public:
+  template <typename T, typename U>
+  auto on_host(T&& a, U&& b) const {
+    return a << b;
+  }
+  template <typename T, typename U>
+  KOKKOS_INLINE_FUNCTION auto on_device(T&& a, U&& b) const {
+    return a << b;
+  }
+};
+
+class cbrt_op {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+    return Kokkos::Experimental::cbrt(a);
+#else
+    return Kokkos::cbrt(a);
+#endif
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return Kokkos::cbrt(a);
+  }
+};
+
+class exp_op {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+    return Kokkos::Experimental::exp(a);
+#else
+    return Kokkos::exp(a);
+#endif
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return Kokkos::exp(a);
+  }
+};
+
+class log_op {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+#if defined(KOKKOS_ENABLE_DEPRECATED_CODE_4)
+    return Kokkos::Experimental::log(a);
+#else
+    return Kokkos::log(a);
+#endif
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    return Kokkos::log(a);
+  }
+};
+
+class hmin {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    return Kokkos::Experimental::hmin(a);
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+
+    auto const& v = a.impl_get_value();
+    auto const& m = a.impl_get_mask();
+    auto result   = Kokkos::reduction_identity<DataType>::min();
+    for (std::size_t i = 0; i < v.size(); ++i) {
+      if (m[i]) result = Kokkos::min(result, v[i]);
+    }
+    return result;
+  }
+
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    return Kokkos::Experimental::hmin(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+
+    auto const& v = a.impl_get_value();
+    auto const& m = a.impl_get_mask();
+    auto result   = Kokkos::reduction_identity<DataType>::min();
+    for (std::size_t i = 0; i < v.size(); ++i) {
+      if (m[i]) result = Kokkos::min(result, v[i]);
+    }
+    return result;
+  }
+};
+
+class hmax {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    return Kokkos::Experimental::hmax(a);
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+
+    auto const& v = a.impl_get_value();
+    auto const& m = a.impl_get_mask();
+    auto result   = Kokkos::reduction_identity<DataType>::max();
+    for (std::size_t i = 0; i < v.size(); ++i) {
+      if (m[i]) result = Kokkos::max(result, v[i]);
+    }
+    return result;
+  }
+
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    return Kokkos::Experimental::hmax(a);
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+
+    auto const& v = a.impl_get_value();
+    auto const& m = a.impl_get_mask();
+    auto result   = Kokkos::reduction_identity<DataType>::max();
+    for (std::size_t i = 0; i < v.size(); ++i) {
+      if (m[i]) result = Kokkos::max(result, v[i]);
+    }
+    return result;
+  }
+};
+
+class reduce {
+ public:
+  template <typename T>
+  auto on_host(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+    return Kokkos::Experimental::reduce(a, DataType(0), std::plus<>());
+  }
+  template <typename T>
+  auto on_host_serial(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+
+    auto const& v = a.impl_get_value();
+    auto const& m = a.impl_get_mask();
+    auto result   = Kokkos::reduction_identity<DataType>::sum();
+    for (std::size_t i = 0; i < v.size(); ++i) {
+      if (m[i]) result += v[i];
+    }
+    return result;
+  }
+
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+    return Kokkos::Experimental::reduce(a, DataType(0), std::plus<>());
+  }
+  template <typename T>
+  KOKKOS_INLINE_FUNCTION auto on_device_serial(T const& a) const {
+    using DataType = typename T::value_type::value_type;
+
+    auto const& v = a.impl_get_value();
+    auto const& m = a.impl_get_mask();
+    auto result   = Kokkos::reduction_identity<DataType>::sum();
+    for (std::size_t i = 0; i < v.size(); ++i) {
+      if (m[i]) result += v[i];
+    }
+    return result;
+  }
+};
+
+#endif
diff --git a/simd/unit_tests/include/SIMDTesting_Utilities.hpp b/simd/unit_tests/include/SIMDTesting_Utilities.hpp
new file mode 100644
index 0000000000..9719855f0f
--- /dev/null
+++ b/simd/unit_tests/include/SIMDTesting_Utilities.hpp
@@ -0,0 +1,194 @@
+//@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_SIMD_TESTING_UTILITIES_HPP
+#define KOKKOS_SIMD_TESTING_UTILITIES_HPP
+
+#include <gtest/gtest.h>
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Ops.hpp>
+
+class gtest_checker {
+ public:
+  void truth(bool x) const { EXPECT_TRUE(x); }
+  template <class T>
+  void equality(T const& a, T const& b) const {
+    EXPECT_EQ(a, b);
+  }
+};
+
+class kokkos_checker {
+ public:
+  KOKKOS_INLINE_FUNCTION void truth(bool x) const {
+    if (!x) Kokkos::abort("SIMD unit test truth condition failed on device");
+  }
+  template <class T>
+  KOKKOS_INLINE_FUNCTION void equality(T const& a, T const& b) const {
+    if (a != b)
+      Kokkos::abort("SIMD unit test equality condition failed on device");
+  }
+};
+
+template <class T, class Abi>
+inline void host_check_equality(
+    Kokkos::Experimental::simd<T, Abi> const& expected_result,
+    Kokkos::Experimental::simd<T, Abi> const& computed_result,
+    std::size_t nlanes) {
+  gtest_checker checker;
+  for (std::size_t i = 0; i < nlanes; ++i) {
+    checker.equality(expected_result[i], computed_result[i]);
+  }
+  using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
+  mask_type mask(false);
+  for (std::size_t i = 0; i < nlanes; ++i) {
+    mask[i] = true;
+  }
+  checker.equality((expected_result == computed_result) && mask, mask);
+}
+
+template <class T, class Abi>
+KOKKOS_INLINE_FUNCTION void device_check_equality(
+    Kokkos::Experimental::simd<T, Abi> const& expected_result,
+    Kokkos::Experimental::simd<T, Abi> const& computed_result,
+    std::size_t nlanes) {
+  kokkos_checker checker;
+  for (std::size_t i = 0; i < nlanes; ++i) {
+    checker.equality(expected_result[i], computed_result[i]);
+  }
+  using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
+  mask_type mask(false);
+  for (std::size_t i = 0; i < nlanes; ++i) {
+    mask[i] = true;
+  }
+  checker.equality((expected_result == computed_result) && mask, mask);
+}
+
+template <typename T, typename Abi>
+KOKKOS_INLINE_FUNCTION void check_equality(
+    Kokkos::Experimental::simd<T, Abi> const& expected_result,
+    Kokkos::Experimental::simd<T, Abi> const& computed_result,
+    std::size_t nlanes) {
+  KOKKOS_IF_ON_HOST(
+      (host_check_equality(expected_result, computed_result, nlanes);))
+  KOKKOS_IF_ON_DEVICE(
+      (device_check_equality(expected_result, computed_result, nlanes);))
+}
+
+class load_element_aligned {
+ public:
+  template <class T, class Abi>
+  bool host_load(T const* mem, std::size_t n,
+                 Kokkos::Experimental::simd<T, Abi>& result) const {
+    if (n < result.size()) return false;
+    result.copy_from(mem, Kokkos::Experimental::simd_flag_default);
+    return true;
+  }
+  template <class T, class Abi>
+  KOKKOS_INLINE_FUNCTION bool device_load(
+      T const* mem, std::size_t n,
+      Kokkos::Experimental::simd<T, Abi>& result) const {
+    if (n < result.size()) return false;
+    result.copy_from(mem, Kokkos::Experimental::simd_flag_default);
+    return true;
+  }
+};
+
+class load_vector_aligned {
+ public:
+  template <class T, class Abi>
+  bool host_load(T const* mem, std::size_t n,
+                 Kokkos::Experimental::simd<T, Abi>& result) const {
+    if (n < result.size()) return false;
+    result.copy_from(mem, Kokkos::Experimental::simd_flag_aligned);
+    return true;
+  }
+  template <class T, class Abi>
+  KOKKOS_INLINE_FUNCTION bool device_load(
+      T const* mem, std::size_t n,
+      Kokkos::Experimental::simd<T, Abi>& result) const {
+    if (n < result.size()) return false;
+    result.copy_from(mem, Kokkos::Experimental::simd_flag_aligned);
+    return true;
+  }
+};
+
+class load_masked {
+ public:
+  template <class T, class Abi>
+  bool host_load(T const* mem, std::size_t n,
+                 Kokkos::Experimental::simd<T, Abi>& result) const {
+    using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
+    mask_type mask(false);
+    for (std::size_t i = 0; i < n; ++i) {
+      mask[i] = true;
+    }
+    result = T(0);
+    where(mask, result).copy_from(mem, Kokkos::Experimental::simd_flag_default);
+    return true;
+  }
+  template <class T, class Abi>
+  KOKKOS_INLINE_FUNCTION bool device_load(
+      T const* mem, std::size_t n,
+      Kokkos::Experimental::simd<T, Abi>& result) const {
+    using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
+    mask_type mask(false);
+    for (std::size_t i = 0; i < n; ++i) {
+      mask[i] = true;
+    }
+    where(mask, result).copy_from(mem, Kokkos::Experimental::simd_flag_default);
+    where(!mask, result) = T(0);
+    return true;
+  }
+};
+
+class load_as_scalars {
+ public:
+  template <class T, class Abi>
+  bool host_load(T const* mem, std::size_t n,
+                 Kokkos::Experimental::simd<T, Abi>& result) const {
+    for (std::size_t i = 0; i < n; ++i) {
+      result[i] = mem[i];
+    }
+    for (std::size_t i = n; i < result.size(); ++i) {
+      result[i] = T(0);
+    }
+    return true;
+  }
+  template <class T, class Abi>
+  KOKKOS_INLINE_FUNCTION bool device_load(
+      T const* mem, std::size_t n,
+      Kokkos::Experimental::simd<T, Abi>& result) const {
+    for (std::size_t i = 0; i < n; ++i) {
+      result[i] = mem[i];
+    }
+    for (std::size_t i = n; i < result.size(); ++i) {
+      result[i] = T(0);
+    }
+    return true;
+  }
+};
+
+// Simple check to loosely test that T is a complete type.
+// Some capabilities are only defined for specific data type and abi pairs (i.e.
+// extended vector width); this is used to exclude pairs that
+// are not defined from being tested.
+template <typename T, typename = void>
+constexpr bool is_type_v = false;
+
+template <typename T>
+constexpr bool is_type_v<T, decltype(void(sizeof(T)))> = true;
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_Condition.hpp b/simd/unit_tests/include/TestSIMD_Condition.hpp
new file mode 100644
index 0000000000..bf22cf3352
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_Condition.hpp
@@ -0,0 +1,109 @@
+//@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_SIMD_CONDITION_HPP
+#define KOKKOS_TEST_SIMD_CONDITION_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi, typename DataType>
+inline void host_check_condition() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type = typename Kokkos::Experimental::simd<DataType, Abi>;
+    using mask_type = typename simd_type::mask_type;
+
+    auto condition_op = [](mask_type const& mask, simd_type const& a,
+                           simd_type const& b) {
+      return Kokkos::Experimental::condition(mask, a, b);
+    };
+
+    simd_type value_a(16);
+    simd_type value_b(20);
+
+    auto condition_result = condition_op(mask_type(false), value_a, value_b);
+    EXPECT_TRUE(all_of(condition_result == value_b));
+    condition_result = condition_op(mask_type(true), value_a, value_b);
+    EXPECT_TRUE(all_of(condition_result == value_a));
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+inline void host_check_condition_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_condition<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+inline void host_check_condition_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_condition_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_condition() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type = typename Kokkos::Experimental::simd<DataType, Abi>;
+    using mask_type = typename simd_type::mask_type;
+    kokkos_checker checker;
+
+    auto condition_op = [](mask_type const& mask, simd_type const& a,
+                           simd_type const& b) {
+      return Kokkos::Experimental::condition(mask, a, b);
+    };
+
+    simd_type value_a(16);
+    simd_type value_b(20);
+
+    auto condition_result = condition_op(mask_type(false), value_a, value_b);
+    checker.truth(all_of(condition_result == value_b));
+    condition_result = condition_op(mask_type(true), value_a, value_b);
+    checker.truth(all_of(condition_result == value_a));
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_condition_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_condition<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_condition_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_condition_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_condition_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_condition_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_condition) {
+  host_check_condition_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_condition) {
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::IndexType<int>>(0, 1),
+                       simd_device_condition_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_Conversions.hpp b/simd/unit_tests/include/TestSIMD_Conversions.hpp
new file mode 100644
index 0000000000..20b0729762
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_Conversions.hpp
@@ -0,0 +1,135 @@
+//@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_SIMD_CONVERSIONS_HPP
+#define KOKKOS_TEST_SIMD_CONVERSIONS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi>
+inline void host_check_conversions() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<uint64_t, Abi>>) {
+    {
+      auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
+      auto b = Kokkos::Experimental::simd<std::int64_t, Abi>(a);
+      EXPECT_TRUE(all_of(b == decltype(b)(1)));
+    }
+    {
+      auto a = Kokkos::Experimental::simd<std::int32_t, Abi>(1);
+      auto b = Kokkos::Experimental::simd<std::uint64_t, Abi>(a);
+      EXPECT_TRUE(all_of(b == decltype(b)(1)));
+    }
+    {
+      auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
+      auto b = Kokkos::Experimental::simd<std::int32_t, Abi>(a);
+      EXPECT_TRUE(all_of(b == decltype(b)(1)));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<double, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(a);
+      EXPECT_TRUE(b == decltype(b)(true));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<std::uint64_t, Abi>(a);
+      EXPECT_TRUE(b == decltype(b)(true));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<std::int64_t, Abi>(a);
+      EXPECT_TRUE(b == decltype(b)(true));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<double, Abi>(a);
+      EXPECT_TRUE(b == decltype(b)(true));
+    }
+  }
+}
+
+template <typename... Abis>
+inline void host_check_conversions_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  (host_check_conversions<Abis>(), ...);
+}
+
+template <typename Abi>
+KOKKOS_INLINE_FUNCTION void device_check_conversions() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<uint64_t, Abi>>) {
+    kokkos_checker checker;
+    {
+      auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
+      auto b = Kokkos::Experimental::simd<std::int64_t, Abi>(a);
+      checker.truth(all_of(b == decltype(b)(1)));
+    }
+    {
+      auto a = Kokkos::Experimental::simd<std::int32_t, Abi>(1);
+      auto b = Kokkos::Experimental::simd<std::uint64_t, Abi>(a);
+      checker.truth(all_of(b == decltype(b)(1)));
+    }
+    {
+      auto a = Kokkos::Experimental::simd<std::uint64_t, Abi>(1);
+      auto b = Kokkos::Experimental::simd<std::int32_t, Abi>(a);
+      checker.truth(all_of(b == decltype(b)(1)));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<double, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(a);
+      checker.truth(b == decltype(b)(true));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<std::uint64_t, Abi>(a);
+      checker.truth(b == decltype(b)(true));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<std::int64_t, Abi>(a);
+      checker.truth(b == decltype(b)(true));
+    }
+    {
+      auto a = Kokkos::Experimental::simd_mask<std::int32_t, Abi>(true);
+      auto b = Kokkos::Experimental::simd_mask<double, Abi>(a);
+      checker.truth(b == decltype(b)(true));
+    }
+  }
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_conversions_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  (device_check_conversions<Abis>(), ...);
+}
+
+class simd_device_conversions_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_conversions_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_conversions) {
+  host_check_conversions_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_conversions) {
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::IndexType<int>>(0, 1),
+                       simd_device_conversions_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_GeneratorCtors.hpp b/simd/unit_tests/include/TestSIMD_GeneratorCtors.hpp
new file mode 100644
index 0000000000..1a61fd9cbb
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_GeneratorCtors.hpp
@@ -0,0 +1,146 @@
+//@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_SIMD_GENERATOR_CTORS_HPP
+#define KOKKOS_TEST_SIMD_GENERATOR_CTORS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi, typename DataType>
+inline void host_check_gen_ctor() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+    using mask_type             = typename simd_type::mask_type;
+    constexpr std::size_t lanes = simd_type::size();
+
+    DataType init[lanes];
+    DataType expected[lanes];
+    mask_type init_mask(false);
+
+    for (std::size_t i = 0; i < lanes; ++i) {
+      if (i % 3 == 0) init_mask[i] = true;
+      init[i]     = 7;
+      expected[i] = (init_mask[i]) ? init[i] * 9 : init[i];
+    }
+
+    simd_type rhs;
+    rhs.copy_from(init, Kokkos::Experimental::simd_flag_default);
+
+    simd_type blend;
+    blend.copy_from(expected, Kokkos::Experimental::simd_flag_default);
+
+#if !(defined(KOKKOS_ENABLE_CUDA) && defined(KOKKOS_COMPILER_MSVC))
+    if constexpr (std::is_same_v<Abi, Kokkos::Experimental::simd_abi::scalar>) {
+      simd_type basic(KOKKOS_LAMBDA(std::size_t i) { return init[i]; });
+      host_check_equality(basic, rhs, lanes);
+
+      simd_type lhs(KOKKOS_LAMBDA(std::size_t i) { return init[i] * 9; });
+      mask_type mask(KOKKOS_LAMBDA(std::size_t i) { return init_mask[i]; });
+      simd_type result(
+          KOKKOS_LAMBDA(std::size_t i) { return (mask[i]) ? lhs[i] : rhs[i]; });
+
+      host_check_equality(blend, result, lanes);
+    } else {
+      simd_type basic([=](std::size_t i) { return init[i]; });
+      host_check_equality(basic, rhs, lanes);
+
+      simd_type lhs([=](std::size_t i) { return init[i] * 9; });
+      mask_type mask([=](std::size_t i) { return init_mask[i]; });
+      simd_type result(
+          [=](std::size_t i) { return (mask[i]) ? lhs[i] : rhs[i]; });
+
+      host_check_equality(blend, result, lanes);
+    }
+#endif
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+inline void host_check_gen_ctors_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_gen_ctor<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+inline void host_check_gen_ctors_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_gen_ctors_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_gen_ctor() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+    using mask_type             = typename simd_type::mask_type;
+    constexpr std::size_t lanes = simd_type::size();
+
+    DataType init[lanes];
+    DataType expected[lanes];
+    mask_type mask(false);
+
+    for (std::size_t i = 0; i < lanes; ++i) {
+      if (i % 3 == 0) mask[i] = true;
+      init[i]     = 7;
+      expected[i] = (mask[i]) ? init[i] * 9 : init[i];
+    }
+
+    simd_type basic(KOKKOS_LAMBDA(std::size_t i) { return init[i]; });
+    simd_type rhs;
+    rhs.copy_from(init, Kokkos::Experimental::simd_flag_default);
+    device_check_equality(basic, rhs, lanes);
+
+    simd_type lhs(KOKKOS_LAMBDA(std::size_t i) { return init[i] * 9; });
+    simd_type result(
+        KOKKOS_LAMBDA(std::size_t i) { return (mask[i]) ? lhs[i] : rhs[i]; });
+
+    simd_type blend;
+    blend.copy_from(expected, Kokkos::Experimental::simd_flag_default);
+    device_check_equality(result, blend, lanes);
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_gen_ctors_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_gen_ctor<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_gen_ctors_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_gen_ctors_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_gen_ctor_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_gen_ctors_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_gen_ctors) {
+  host_check_gen_ctors_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_gen_ctors) {
+  Kokkos::parallel_for(1, simd_device_gen_ctor_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_MaskOps.hpp b/simd/unit_tests/include/TestSIMD_MaskOps.hpp
new file mode 100644
index 0000000000..c3d4ac594d
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_MaskOps.hpp
@@ -0,0 +1,120 @@
+//@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_SIMD_MASK_OPS_HPP
+#define KOKKOS_TEST_SIMD_MASK_OPS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi, typename DataType>
+inline void host_check_mask_ops() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using mask_type = Kokkos::Experimental::simd_mask<DataType, Abi>;
+
+    EXPECT_FALSE(none_of(mask_type(true)));
+    EXPECT_TRUE(none_of(mask_type(false)));
+    EXPECT_TRUE(all_of(mask_type(true)));
+    EXPECT_FALSE(all_of(mask_type(false)));
+    EXPECT_TRUE(any_of(mask_type(true)));
+    EXPECT_FALSE(any_of(mask_type(false)));
+
+    for (std::size_t i = 0; i < mask_type::size(); ++i) {
+      mask_type test_mask(KOKKOS_LAMBDA(std::size_t j) { return i == j; });
+
+      EXPECT_TRUE(any_of(test_mask));
+      EXPECT_FALSE(none_of(test_mask));
+
+      if constexpr (mask_type::size() > 1) {
+        EXPECT_FALSE(all_of(test_mask));
+      } else {
+        EXPECT_TRUE(all_of(test_mask));
+      }
+    }
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+inline void host_check_mask_ops_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_mask_ops<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+inline void host_check_mask_ops_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_mask_ops_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_mask_ops() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using mask_type = Kokkos::Experimental::simd_mask<DataType, Abi>;
+    kokkos_checker checker;
+    checker.truth(!none_of(mask_type(true)));
+    checker.truth(none_of(mask_type(false)));
+    checker.truth(all_of(mask_type(true)));
+    checker.truth(!all_of(mask_type(false)));
+    checker.truth(any_of(mask_type(true)));
+    checker.truth(!any_of(mask_type(false)));
+
+    for (std::size_t i = 0; i < mask_type::size(); ++i) {
+      mask_type test_mask(KOKKOS_LAMBDA(std::size_t j) { return i == j; });
+
+      checker.truth(any_of(test_mask));
+      checker.truth(!none_of(test_mask));
+
+      if constexpr (mask_type::size() > 1) {
+        checker.truth(!all_of(test_mask));
+      } else {
+        checker.truth(all_of(test_mask));
+      }
+    }
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_mask_ops_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_mask_ops<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_mask_ops_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_mask_ops_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_mask_ops_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_mask_ops_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_mask_ops) {
+  host_check_mask_ops_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_mask_ops) {
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::IndexType<int>>(0, 1),
+                       simd_device_mask_ops_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_MathOps.hpp b/simd/unit_tests/include/TestSIMD_MathOps.hpp
new file mode 100644
index 0000000000..4891a54f6c
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_MathOps.hpp
@@ -0,0 +1,323 @@
+//@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_SIMD_MATH_OPS_HPP
+#define KOKKOS_TEST_SIMD_MATH_OPS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <class Abi, class Loader, class BinaryOp, class T>
+void host_check_math_op_one_loader(BinaryOp binary_op, std::size_t n,
+                                   T const* first_args, T const* second_args) {
+  Loader loader;
+  using simd_type             = Kokkos::Experimental::simd<T, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  for (std::size_t i = 0; i < n; i += width) {
+    std::size_t const nremaining = n - i;
+    std::size_t const nlanes     = Kokkos::min(nremaining, width);
+    simd_type first_arg;
+    bool const loaded_first_arg =
+        loader.host_load(first_args + i, nlanes, first_arg);
+    simd_type second_arg;
+    bool const loaded_second_arg =
+        loader.host_load(second_args + i, nlanes, second_arg);
+    if (!(loaded_first_arg && loaded_second_arg)) continue;
+    simd_type expected_result;
+    // 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);
+  }
+}
+
+template <class Abi, class Loader, class UnaryOp, class T>
+void host_check_math_op_one_loader(UnaryOp unary_op, std::size_t n,
+                                   T const* args) {
+  Loader loader;
+  using simd_type             = Kokkos::Experimental::simd<T, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  for (std::size_t i = 0; i < n; i += width) {
+    std::size_t const nremaining = n - i;
+    std::size_t const nlanes     = Kokkos::min(nremaining, width);
+    simd_type arg;
+    bool const loaded_arg = loader.host_load(args + i, nlanes, arg);
+    if (!loaded_arg) continue;
+
+    decltype(unary_op.on_host(arg)) expected_result;
+    for (std::size_t lane = 0; lane < simd_type::size(); ++lane) {
+      if (lane < nlanes) {
+        if constexpr (std::is_same_v<UnaryOp, cbrt_op> ||
+                      std::is_same_v<UnaryOp, exp_op> ||
+                      std::is_same_v<UnaryOp, log_op>)
+          arg[lane] = Kokkos::abs(arg[lane]);
+        expected_result[lane] = unary_op.on_host_serial(T(arg[lane]));
+      }
+    }
+    auto computed_result = unary_op.on_host(arg);
+    host_check_equality(expected_result, computed_result, nlanes);
+  }
+}
+
+template <class Abi, class Op, class... T>
+inline void host_check_math_op_all_loaders(Op op, std::size_t n,
+                                           T const*... args) {
+  host_check_math_op_one_loader<Abi, load_element_aligned>(op, n, args...);
+  host_check_math_op_one_loader<Abi, load_masked>(op, n, args...);
+  host_check_math_op_one_loader<Abi, load_as_scalars>(op, n, args...);
+  host_check_math_op_one_loader<Abi, load_vector_aligned>(op, n, args...);
+}
+
+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_math_op_all_loaders<Abi>(plus(), n, first_args, second_args);
+  host_check_math_op_all_loaders<Abi>(minus(), n, first_args, second_args);
+  host_check_math_op_all_loaders<Abi>(multiplies(), n, first_args, second_args);
+  host_check_math_op_all_loaders<Abi>(absolutes(), n, first_args);
+
+  host_check_math_op_all_loaders<Abi>(floors(), n, first_args);
+  host_check_math_op_all_loaders<Abi>(ceils(), n, first_args);
+  host_check_math_op_all_loaders<Abi>(rounds(), n, first_args);
+  host_check_math_op_all_loaders<Abi>(truncates(), n, first_args);
+
+  // TODO: Place fallback implementations for all simd integer types
+  if constexpr (std::is_floating_point_v<DataType>) {
+    host_check_math_op_all_loaders<Abi>(divides(), n, first_args, second_args);
+
+#if defined(__INTEL_COMPILER) && \
+    (defined(KOKKOS_ARCH_AVX2) || defined(KOKKOS_ARCH_AVX512XEON))
+    host_check_math_op_all_loaders<Abi>(cbrt_op(), n, first_args);
+    host_check_math_op_all_loaders<Abi>(exp_op(), n, first_args);
+    host_check_math_op_all_loaders<Abi>(log_op(), n, first_args);
+#endif
+  }
+}
+
+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 <typename Abi, typename DataType>
+inline void host_check_math_ops() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    constexpr size_t alignment =
+        Kokkos::Experimental::simd<DataType, Abi>::size() * sizeof(DataType);
+
+    host_check_abi_size<Abi, DataType>();
+
+    if constexpr (!std::is_integral_v<DataType>) {
+      alignas(alignment) DataType const first_args[] = {
+          0.1, 0.4, 0.5,  0.7, 1.0, 1.5,  -2.0, 10.0,
+          0.0, 1.2, -2.8, 3.0, 4.0, -0.1, 5.0,  -0.2};
+      alignas(alignment) DataType const second_args[] = {
+          1.0,  0.2,  1.1,  1.8, -0.1,  -3.0, -2.4, 1.0,
+          13.0, -3.2, -2.1, 3.0, -15.0, -0.5, -0.2, -0.2};
+      host_check_all_math_ops<Abi>(first_args, second_args);
+    } else {
+      if constexpr (std::is_signed_v<DataType>) {
+        alignas(alignment) DataType const first_args[] = {
+            1, 2, -1, 10, 0, 1, -2, 10, 0, 1, -2, -3, 7, 4, -9, -15};
+        alignas(alignment) DataType const second_args[] = {
+            1, 2, 1, 1, 1, -3, -2, 1, 13, -3, -2, 10, -15, 7, 2, -10};
+        host_check_all_math_ops<Abi>(first_args, second_args);
+      } else {
+        alignas(alignment) DataType const first_args[] = {
+            1, 2, 1, 10, 0, 1, 2, 10, 0, 1, 2, 11, 5, 8, 2, 14};
+        alignas(alignment) DataType const second_args[] = {
+            1, 2, 1, 1, 1, 3, 2, 1, 13, 3, 2, 3, 6, 20, 5, 14};
+        host_check_all_math_ops<Abi>(first_args, second_args);
+      }
+    }
+  }
+}
+
+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 <typename... Abis>
+inline void host_check_math_ops_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_math_ops_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename Loader, typename BinaryOp, typename T>
+KOKKOS_INLINE_FUNCTION void device_check_math_op_one_loader(
+    BinaryOp binary_op, std::size_t n, T const* first_args,
+    T const* second_args) {
+  Loader loader;
+  using simd_type             = Kokkos::Experimental::simd<T, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  for (std::size_t i = 0; i < n; i += width) {
+    std::size_t const nremaining = n - i;
+    std::size_t const nlanes     = Kokkos::min(nremaining, width);
+    simd_type first_arg;
+    bool const loaded_first_arg =
+        loader.device_load(first_args + i, nlanes, first_arg);
+    simd_type second_arg;
+    bool const loaded_second_arg =
+        loader.device_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_device(first_arg[lane], second_arg[lane]);
+    }
+    simd_type const computed_result =
+        binary_op.on_device(first_arg, second_arg);
+    device_check_equality(expected_result, computed_result, nlanes);
+  }
+}
+
+template <typename Abi, typename Loader, typename UnaryOp, typename T>
+KOKKOS_INLINE_FUNCTION void device_check_math_op_one_loader(UnaryOp unary_op,
+                                                            std::size_t n,
+                                                            T const* args) {
+  Loader loader;
+  using simd_type             = Kokkos::Experimental::simd<T, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  for (std::size_t i = 0; i < n; i += width) {
+    std::size_t const nremaining = n - i;
+    std::size_t const nlanes     = Kokkos::min(nremaining, width);
+    simd_type arg;
+    bool const loaded_arg = loader.device_load(args + i, nlanes, arg);
+    if (!loaded_arg) continue;
+    auto computed_result = unary_op.on_device(arg);
+
+    decltype(computed_result) expected_result;
+    for (std::size_t lane = 0; lane < nlanes; ++lane) {
+      expected_result[lane] = unary_op.on_device_serial(arg[lane]);
+    }
+    device_check_equality(expected_result, computed_result, nlanes);
+  }
+}
+
+template <typename Abi, typename Op, typename... T>
+KOKKOS_INLINE_FUNCTION void device_check_math_op_all_loaders(Op op,
+                                                             std::size_t n,
+                                                             T const*... args) {
+  device_check_math_op_one_loader<Abi, load_element_aligned>(op, n, args...);
+  device_check_math_op_one_loader<Abi, load_masked>(op, n, args...);
+  device_check_math_op_one_loader<Abi, load_as_scalars>(op, n, args...);
+  device_check_math_op_one_loader<Abi, load_vector_aligned>(op, n, args...);
+}
+
+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_math_op_all_loaders<Abi>(plus(), n, first_args, second_args);
+  device_check_math_op_all_loaders<Abi>(minus(), n, first_args, second_args);
+  device_check_math_op_all_loaders<Abi>(multiplies(), n, first_args,
+                                        second_args);
+  device_check_math_op_all_loaders<Abi>(absolutes(), n, first_args);
+
+  device_check_math_op_all_loaders<Abi>(floors(), n, first_args);
+  device_check_math_op_all_loaders<Abi>(ceils(), n, first_args);
+  device_check_math_op_all_loaders<Abi>(rounds(), n, first_args);
+  device_check_math_op_all_loaders<Abi>(truncates(), n, first_args);
+
+  if constexpr (std::is_floating_point_v<DataType>) {
+    device_check_math_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 <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_math_ops() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    device_check_abi_size<Abi, DataType>();
+
+    if constexpr (!std::is_integral_v<DataType>) {
+      DataType const first_args[]  = {0.1,  0.4,  0.5, 0.7, 1.0,  1.5,
+                                     -2.0, 10.0, 0.0, 1.2, -2.8, 3.0,
+                                     4.0,  -0.1, 5.0, -0.2};
+      DataType const second_args[] = {1.0,   0.2,  1.1,  1.8,  -0.1, -3.0,
+                                      -2.4,  1.0,  13.0, -3.2, -2.1, 3.0,
+                                      -15.0, -0.5, -0.2, -0.2};
+      device_check_all_math_ops<Abi>(first_args, second_args);
+    } else {
+      if constexpr (std::is_signed_v<DataType>) {
+        DataType const first_args[]  = {1, 2, -1, 10, 0, 1, -2, 10,
+                                       0, 1, -2, -3, 7, 4, -9, -15};
+        DataType const second_args[] = {1,  2,  1,  1,  1,   -3, -2, 1,
+                                        13, -3, -2, 10, -15, 7,  2,  -10};
+        device_check_all_math_ops<Abi>(first_args, second_args);
+      } else {
+        DataType const first_args[]  = {1, 2, 1, 10, 0, 1, 2, 10,
+                                       0, 1, 2, 11, 5, 8, 2, 14};
+        DataType const second_args[] = {1,  2, 1, 1, 1, 3,  2, 1,
+                                        13, 3, 2, 3, 6, 20, 5, 14};
+        device_check_all_math_ops<Abi>(first_args, second_args);
+      }
+    }
+  }
+}
+
+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 <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_math_ops_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_math_ops_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_math_ops_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_math_ops_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_math_ops) {
+  host_check_math_ops_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_math_ops) {
+#ifdef KOKKOS_ENABLE_OPENMPTARGET  // FIXME_OPENMPTARGET
+  GTEST_SKIP()
+      << "skipping because of a non-deterministic failure reporting: "
+         "Failure to synchronize stream (nil): Error in "
+         "cuStreamSynchronize: an illegal memory access was encountered";
+#endif
+  Kokkos::parallel_for(1, simd_device_math_ops_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_Reductions.hpp b/simd/unit_tests/include/TestSIMD_Reductions.hpp
new file mode 100644
index 0000000000..a3e796a030
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_Reductions.hpp
@@ -0,0 +1,192 @@
+//@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_SIMD_REDUCTIONS_HPP
+#define KOKKOS_TEST_SIMD_REDUCTIONS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi, typename Loader, typename ReductionOp, typename T>
+inline void host_check_reduction_one_loader(ReductionOp reduce_op,
+                                            std::size_t n, T const* args) {
+  Loader loader;
+  using simd_type = Kokkos::Experimental::simd<T, Abi>;
+  using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
+  constexpr std::size_t width = simd_type::size();
+
+  for (std::size_t i = 0; i < n; i += width) {
+    std::size_t const nremaining = n - i;
+    std::size_t const nlanes     = Kokkos::min(nremaining, width);
+    simd_type arg;
+    bool const loaded_arg = loader.host_load(args + i, nlanes, arg);
+    if (!loaded_arg) continue;
+
+    mask_type mask(false);
+    for (std::size_t j = 0; j < n; ++j) {
+      mask[j] = true;
+    }
+    auto value    = where(mask, arg);
+    auto expected = reduce_op.on_host_serial(value);
+    auto computed = reduce_op.on_host(value);
+
+    gtest_checker().equality(expected, computed);
+  }
+}
+
+template <typename Abi, typename ReductionOp, typename T>
+inline void host_check_reduction_all_loaders(ReductionOp reduce_op,
+                                             std::size_t n, T const* args) {
+  host_check_reduction_one_loader<Abi, load_element_aligned>(reduce_op, n,
+                                                             args);
+  host_check_reduction_one_loader<Abi, load_masked>(reduce_op, n, args);
+  host_check_reduction_one_loader<Abi, load_as_scalars>(reduce_op, n, args);
+}
+
+template <typename Abi, typename DataType, size_t n>
+inline void host_check_all_reductions(const DataType (&args)[n]) {
+  host_check_reduction_all_loaders<Abi>(hmin(), n, args);
+  host_check_reduction_all_loaders<Abi>(hmax(), n, args);
+  host_check_reduction_all_loaders<Abi>(reduce(), n, args);
+}
+
+template <typename Abi, typename DataType>
+inline void host_check_reductions() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    constexpr size_t n = 16;
+
+    if constexpr (std::is_signed_v<DataType>) {
+      DataType const args[n] = {1, 2, -1, 10,  0, 1,  -2,  10,
+                                0, 1, -2, -15, 5, 17, -22, 20};
+      host_check_all_reductions<Abi>(args);
+    } else {
+      DataType const args[n] = {1, 2, 1, 10, 0, 1,  2,  10,
+                                0, 1, 2, 15, 5, 17, 22, 20};
+      host_check_all_reductions<Abi>(args);
+    }
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+inline void host_check_reductions_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_reductions<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+inline void host_check_reductions_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_reductions_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename Loader, typename ReductionOp, typename T>
+KOKKOS_INLINE_FUNCTION void device_check_reduction_one_loader(
+    ReductionOp reduce_op, std::size_t n, T const* args) {
+  Loader loader;
+  using simd_type = Kokkos::Experimental::simd<T, Abi>;
+  using mask_type = typename Kokkos::Experimental::simd<T, Abi>::mask_type;
+  constexpr std::size_t width = simd_type::size();
+
+  for (std::size_t i = 0; i < n; i += width) {
+    std::size_t const nremaining = n - i;
+    std::size_t const nlanes     = Kokkos::min(nremaining, width);
+    simd_type arg;
+    bool const loaded_arg = loader.device_load(args + i, nlanes, arg);
+    if (!loaded_arg) continue;
+
+    mask_type mask(false);
+    for (std::size_t j = 0; j < n; ++j) {
+      mask[j] = true;
+    }
+    auto value    = where(mask, arg);
+    auto expected = reduce_op.on_device_serial(value);
+    auto computed = reduce_op.on_device(value);
+
+    kokkos_checker().equality(expected, computed);
+  }
+}
+
+template <typename Abi, typename ReductionOp, typename T>
+KOKKOS_INLINE_FUNCTION void device_check_reduction_all_loaders(
+    ReductionOp reduce_op, std::size_t n, T const* args) {
+  device_check_reduction_one_loader<Abi, load_element_aligned>(reduce_op, n,
+                                                               args);
+  device_check_reduction_one_loader<Abi, load_masked>(reduce_op, n, args);
+  device_check_reduction_one_loader<Abi, load_as_scalars>(reduce_op, n, args);
+}
+
+template <typename Abi, typename DataType, size_t n>
+KOKKOS_INLINE_FUNCTION void device_check_all_reductions(
+    const DataType (&args)[n]) {
+  device_check_reduction_all_loaders<Abi>(hmin(), n, args);
+  device_check_reduction_all_loaders<Abi>(hmax(), n, args);
+  device_check_reduction_all_loaders<Abi>(reduce(), n, args);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_reductions() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    constexpr size_t n = 16;
+
+    if constexpr (std::is_signed_v<DataType>) {
+      DataType const args[n] = {1, 2, -1, 10,  0, 1,  -2,  10,
+                                0, 1, -2, -15, 5, 17, -22, 20};
+      device_check_all_reductions<Abi>(args);
+    } else {
+      DataType const args[n] = {1, 2, 1, 10, 0, 1,  2,  10,
+                                0, 1, 2, 15, 5, 17, 22, 20};
+      device_check_all_reductions<Abi>(args);
+    }
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_reductions_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_reductions<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_reductions_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_reductions_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_reduction_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_reductions_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_reductions) {
+  host_check_reductions_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_reductions) {
+#ifdef KOKKOS_ENABLE_OPENMPTARGET  // FIXME_OPENMPTARGET
+  GTEST_SKIP()
+      << "skipping because of a non-deterministic failure reporting: "
+         "Failure to synchronize stream (nil): Error in "
+         "cuStreamSynchronize: an illegal memory access was encountered";
+#endif
+  Kokkos::parallel_for(1, simd_device_reduction_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_ShiftOps.hpp b/simd/unit_tests/include/TestSIMD_ShiftOps.hpp
new file mode 100644
index 0000000000..7329f08501
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_ShiftOps.hpp
@@ -0,0 +1,290 @@
+//@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_SIMD_SHIFT_OPS_HPP
+#define KOKKOS_TEST_SIMD_SHIFT_OPS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi, typename Loader, typename ShiftOp, typename DataType>
+inline void host_check_shift_on_one_loader(ShiftOp shift_op,
+                                           DataType test_vals[],
+                                           DataType shift_by[], std::size_t n) {
+  using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  Loader loader;
+
+  for (std::size_t i = 0; i < n; ++i) {
+    simd_type simd_vals;
+    bool const loaded_arg = loader.host_load(test_vals, width, simd_vals);
+    if (!loaded_arg) {
+      continue;
+    }
+
+    simd_type expected_result;
+
+    for (std::size_t lane = 0; lane < width; ++lane) {
+      DataType value = simd_vals[lane];
+      expected_result[lane] =
+          shift_op.on_host(value, static_cast<int>(shift_by[i]));
+      EXPECT_EQ(value, value);
+    }
+
+    simd_type const computed_result =
+        shift_op.on_host(simd_vals, static_cast<int>(shift_by[i]));
+    host_check_equality(expected_result, computed_result, width);
+  }
+}
+
+template <typename Abi, typename Loader, typename ShiftOp, typename DataType>
+inline void host_check_shift_by_lanes_on_one_loader(
+    ShiftOp shift_op, DataType test_vals[],
+    Kokkos::Experimental::simd<DataType, Abi>& shift_by) {
+  using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  Loader loader;
+
+  simd_type simd_vals;
+  bool const loaded_arg = loader.host_load(test_vals, width, simd_vals);
+  ASSERT_TRUE(loaded_arg);
+
+  simd_type expected_result;
+
+  for (std::size_t lane = 0; lane < width; ++lane) {
+    DataType value = simd_vals[lane];
+    expected_result[lane] =
+        shift_op.on_host(value, static_cast<int>(shift_by[lane]));
+    EXPECT_EQ(value, value);
+  }
+  simd_type const computed_result = shift_op.on_host(simd_vals, shift_by);
+  host_check_equality(expected_result, computed_result, width);
+}
+
+template <typename Abi, typename ShiftOp, typename DataType>
+inline void host_check_shift_op_all_loaders(ShiftOp shift_op,
+                                            DataType test_vals[],
+                                            DataType shift_by[],
+                                            std::size_t n) {
+  host_check_shift_on_one_loader<Abi, load_element_aligned>(shift_op, test_vals,
+                                                            shift_by, n);
+  host_check_shift_on_one_loader<Abi, load_masked>(shift_op, test_vals,
+                                                   shift_by, n);
+  host_check_shift_on_one_loader<Abi, load_as_scalars>(shift_op, test_vals,
+                                                       shift_by, n);
+  host_check_shift_on_one_loader<Abi, load_vector_aligned>(shift_op, test_vals,
+                                                           shift_by, n);
+
+  Kokkos::Experimental::simd<DataType, Abi> shift_by_lanes;
+  shift_by_lanes.copy_from(shift_by, Kokkos::Experimental::simd_flag_default);
+
+  host_check_shift_by_lanes_on_one_loader<Abi, load_element_aligned>(
+      shift_op, test_vals, shift_by_lanes);
+  host_check_shift_by_lanes_on_one_loader<Abi, load_masked>(shift_op, test_vals,
+                                                            shift_by_lanes);
+  host_check_shift_by_lanes_on_one_loader<Abi, load_as_scalars>(
+      shift_op, test_vals, shift_by_lanes);
+  host_check_shift_by_lanes_on_one_loader<Abi, load_vector_aligned>(
+      shift_op, test_vals, shift_by_lanes);
+}
+
+template <typename Abi, typename DataType>
+inline void host_check_shift_ops() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    if constexpr (std::is_integral_v<DataType>) {
+      using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+      constexpr std::size_t width = simd_type::size();
+      constexpr std::size_t num_cases = 16;
+      constexpr size_t alignment =
+          Kokkos::Experimental::simd<DataType, Abi>::size() * sizeof(DataType);
+
+      DataType max = std::numeric_limits<DataType>::max();
+
+      alignas(alignment) DataType shift_by[num_cases] = {
+          0, 1, 3, width / 2, width / 2 + 1, width - 1, width, width + 1,
+          0, 1, 3, width / 2, width / 2 + 1, width - 1, width, width + 1};
+      alignas(alignment) DataType test_vals[width];
+      for (std::size_t i = 0; i < width; ++i) {
+        DataType inc = max / width;
+        test_vals[i] = i * inc + 1;
+      }
+
+      host_check_shift_op_all_loaders<Abi>(shift_right(), test_vals, shift_by,
+                                           num_cases);
+      host_check_shift_op_all_loaders<Abi>(shift_left(), test_vals, shift_by,
+                                           num_cases);
+
+      if constexpr (std::is_signed_v<DataType>) {
+        for (std::size_t i = 0; i < width; ++i) test_vals[i] *= -1;
+        host_check_shift_op_all_loaders<Abi>(shift_right(), test_vals, shift_by,
+                                             num_cases);
+      }
+    }
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+inline void host_check_shift_ops_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_shift_ops<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+inline void host_check_shift_ops_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_shift_ops_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename Loader, typename ShiftOp, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_shift_on_one_loader(
+    ShiftOp shift_op, DataType test_vals[], DataType shift_by[],
+    std::size_t n) {
+  using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  Loader loader;
+
+  for (std::size_t i = 0; i < n; ++i) {
+    simd_type simd_vals;
+    bool const loaded_arg = loader.device_load(test_vals, width, simd_vals);
+    if (!loaded_arg) {
+      continue;
+    }
+
+    simd_type expected_result;
+
+    for (std::size_t lane = 0; lane < width; ++lane) {
+      expected_result[lane] = shift_op.on_device(DataType(simd_vals[lane]),
+                                                 static_cast<int>(shift_by[i]));
+    }
+
+    simd_type const computed_result =
+        shift_op.on_device(simd_vals, static_cast<int>(shift_by[i]));
+    device_check_equality(expected_result, computed_result, width);
+  }
+}
+
+template <typename Abi, typename Loader, typename ShiftOp, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_shift_by_lanes_on_one_loader(
+    ShiftOp shift_op, DataType test_vals[],
+    Kokkos::Experimental::simd<DataType, Abi>& shift_by) {
+  using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+  constexpr std::size_t width = simd_type::size();
+  Loader loader;
+  simd_type simd_vals;
+  loader.device_load(test_vals, width, simd_vals);
+
+  simd_type expected_result;
+
+  for (std::size_t lane = 0; lane < width; ++lane) {
+    expected_result[lane] = shift_op.on_device(
+        DataType(simd_vals[lane]), static_cast<int>(shift_by[lane]));
+  }
+  simd_type const computed_result = shift_op.on_device(simd_vals, shift_by);
+  device_check_equality(expected_result, computed_result, width);
+}
+
+template <typename Abi, typename ShiftOp, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_shift_op_all_loaders(
+    ShiftOp shift_op, DataType test_vals[], DataType shift_by[],
+    std::size_t n) {
+  device_check_shift_on_one_loader<Abi, load_element_aligned>(
+      shift_op, test_vals, shift_by, n);
+  device_check_shift_on_one_loader<Abi, load_masked>(shift_op, test_vals,
+                                                     shift_by, n);
+  device_check_shift_on_one_loader<Abi, load_as_scalars>(shift_op, test_vals,
+                                                         shift_by, n);
+  device_check_shift_on_one_loader<Abi, load_vector_aligned>(
+      shift_op, test_vals, shift_by, n);
+
+  Kokkos::Experimental::simd<DataType, Abi> shift_by_lanes;
+  shift_by_lanes.copy_from(shift_by, Kokkos::Experimental::simd_flag_default);
+
+  device_check_shift_by_lanes_on_one_loader<Abi, load_element_aligned>(
+      shift_op, test_vals, shift_by_lanes);
+  device_check_shift_by_lanes_on_one_loader<Abi, load_masked>(
+      shift_op, test_vals, shift_by_lanes);
+  device_check_shift_by_lanes_on_one_loader<Abi, load_as_scalars>(
+      shift_op, test_vals, shift_by_lanes);
+  device_check_shift_by_lanes_on_one_loader<Abi, load_vector_aligned>(
+      shift_op, test_vals, shift_by_lanes);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_shift_ops() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    if constexpr (std::is_integral_v<DataType>) {
+      using simd_type             = Kokkos::Experimental::simd<DataType, Abi>;
+      constexpr std::size_t width = simd_type::size();
+      constexpr std::size_t num_cases = 16;
+
+      DataType max = Kokkos::reduction_identity<DataType>::max();
+
+      DataType shift_by[num_cases] = {
+          0, 1, 3, width / 2, width / 2 + 1, width - 1, width, width + 1,
+          0, 1, 3, width / 2, width / 2 + 1, width - 1, width, width + 1};
+      DataType test_vals[width];
+
+      for (std::size_t i = 0; i < width; ++i) {
+        DataType inc = max / width;
+        test_vals[i] = i * inc + 1;
+      }
+
+      device_check_shift_op_all_loaders<Abi>(shift_right(), test_vals, shift_by,
+                                             num_cases);
+      device_check_shift_op_all_loaders<Abi>(shift_left(), test_vals, shift_by,
+                                             num_cases);
+
+      if constexpr (std::is_signed_v<DataType>) {
+        for (std::size_t i = 0; i < width; ++i) test_vals[i] *= -1;
+        device_check_shift_op_all_loaders<Abi>(shift_right(), test_vals,
+                                               shift_by, num_cases);
+      }
+    }
+  }
+}
+
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_shift_ops_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_shift_ops<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_shift_ops_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_shift_ops_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_shift_ops_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_shift_ops_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_shift_ops) {
+  host_check_shift_ops_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_shift_ops) {
+  Kokkos::parallel_for(Kokkos::RangePolicy<Kokkos::IndexType<int>>(0, 1),
+                       simd_device_shift_ops_functor());
+}
+
+#endif
diff --git a/simd/unit_tests/include/TestSIMD_WhereExpressions.hpp b/simd/unit_tests/include/TestSIMD_WhereExpressions.hpp
new file mode 100644
index 0000000000..904b2c665e
--- /dev/null
+++ b/simd/unit_tests/include/TestSIMD_WhereExpressions.hpp
@@ -0,0 +1,205 @@
+//@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_SIMD_WHERE_EXPRESSIONS_HPP
+#define KOKKOS_TEST_SIMD_WHERE_EXPRESSIONS_HPP
+
+#include <Kokkos_SIMD.hpp>
+#include <SIMDTesting_Utilities.hpp>
+
+template <typename Abi, typename DataType>
+inline void host_check_where_expr_scatter_to() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type  = Kokkos::Experimental::simd<DataType, Abi>;
+    using index_type = Kokkos::Experimental::simd<std::int32_t, Abi>;
+    using mask_type  = typename simd_type::mask_type;
+
+    std::size_t nlanes = simd_type::size();
+    DataType init[]    = {11, 13, 17, 19, 23, 29, 31, 37,
+                       53, 71, 79, 83, 89, 93, 97, 103};
+    simd_type src;
+    src.copy_from(init, Kokkos::Experimental::simd_flag_default);
+
+    for (std::size_t idx = 0; idx < nlanes; ++idx) {
+      mask_type mask(true);
+      mask[idx] = false;
+
+      DataType dst[simd_type::size()] = {0};
+      index_type index;
+      simd_type expected_result;
+      for (std::size_t i = 0; i < nlanes; ++i) {
+        dst[i]             = (2 + (i * 2));
+        index[i]           = i;
+        expected_result[i] = (mask[i]) ? src[index[i]] : dst[i];
+      }
+      where(mask, src).scatter_to(dst, index);
+
+      simd_type dst_simd;
+      dst_simd.copy_from(dst, Kokkos::Experimental::simd_flag_default);
+
+      host_check_equality(expected_result, dst_simd, nlanes);
+    }
+  }
+}
+
+template <typename Abi, typename DataType>
+inline void host_check_where_expr_gather_from() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type  = Kokkos::Experimental::simd<DataType, Abi>;
+    using index_type = Kokkos::Experimental::simd<std::int32_t, Abi>;
+    using mask_type  = typename simd_type::mask_type;
+
+    std::size_t nlanes = simd_type::size();
+    DataType src[]     = {11, 13, 17, 19, 23, 29, 31, 37,
+                      53, 71, 79, 83, 89, 93, 97, 103};
+
+    for (std::size_t idx = 0; idx < nlanes; ++idx) {
+      mask_type mask(true);
+      mask[idx] = false;
+
+      simd_type dst;
+      index_type index;
+      simd_type expected_result;
+      for (std::size_t i = 0; i < nlanes; ++i) {
+        dst[i]             = (2 + (i * 2));
+        index[i]           = i;
+        expected_result[i] = (mask[i]) ? src[index[i]] : dst[i];
+      }
+      where(mask, dst).gather_from(src, index);
+
+      host_check_equality(expected_result, dst, nlanes);
+    }
+  }
+}
+
+template <class Abi, typename DataType>
+inline void host_check_where_expr() {
+  host_check_where_expr_scatter_to<Abi, DataType>();
+  host_check_where_expr_gather_from<Abi, DataType>();
+}
+
+template <typename Abi, typename... DataTypes>
+inline void host_check_where_expr_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (host_check_where_expr<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+inline void host_check_where_expr_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (host_check_where_expr_all_types<Abis>(DataTypes()), ...);
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_where_expr_scatter_to() {
+  if constexpr (is_type_v<Kokkos::Experimental::simd<DataType, Abi>>) {
+    using simd_type  = Kokkos::Experimental::simd<DataType, Abi>;
+    using index_type = Kokkos::Experimental::simd<std::int32_t, Abi>;
+    using mask_type  = typename simd_type::mask_type;
+
+    std::size_t nlanes = simd_type::size();
+    DataType init[]    = {11, 13, 17, 19, 23, 29, 31, 37,
+                       53, 71, 79, 83, 89, 93, 97, 103};
+    simd_type src;
+    src.copy_from(init, Kokkos::Experimental::simd_flag_default);
+
+    for (std::size_t idx = 0; idx < nlanes; ++idx) {
+      mask_type mask(true);
+      mask[idx] = false;
+
+      DataType dst[simd_type::size()] = {0};
+      index_type index;
+      simd_type expected_result;
+      for (std::size_t i = 0; i < nlanes; ++i) {
+        dst[i]             = (2 + (i * 2));
+        index[i]           = i;
+        expected_result[i] = (mask[i]) ? src[index[i]] : dst[i];
+      }
+      where(mask, src).scatter_to(dst, index);
+
+      simd_type dst_simd;
+      dst_simd.copy_from(dst, Kokkos::Experimental::simd_flag_default);
+
+      device_check_equality(expected_result, dst_simd, nlanes);
+    }
+  }
+}
+
+template <typename Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_where_expr_gather_from() {
+  using simd_type  = Kokkos::Experimental::simd<DataType, Abi>;
+  using index_type = Kokkos::Experimental::simd<std::int32_t, Abi>;
+  using mask_type  = typename simd_type::mask_type;
+
+  std::size_t nlanes = simd_type::size();
+  DataType src[]     = {11, 13, 17, 19, 23, 29, 31, 37,
+                    53, 71, 79, 83, 89, 93, 97, 103};
+
+  for (std::size_t idx = 0; idx < nlanes; ++idx) {
+    mask_type mask(true);
+    mask[idx] = false;
+
+    simd_type dst;
+    index_type index;
+    simd_type expected_result;
+    for (std::size_t i = 0; i < nlanes; ++i) {
+      dst[i]             = (2 + (i * 2));
+      index[i]           = i;
+      expected_result[i] = (mask[i]) ? src[index[i]] : dst[i];
+    }
+    where(mask, dst).gather_from(src, index);
+
+    device_check_equality(expected_result, dst, nlanes);
+  }
+}
+
+template <class Abi, typename DataType>
+KOKKOS_INLINE_FUNCTION void device_check_where_expr() {
+  device_check_where_expr_scatter_to<Abi, DataType>();
+  device_check_where_expr_gather_from<Abi, DataType>();
+}
+
+template <typename Abi, typename... DataTypes>
+KOKKOS_INLINE_FUNCTION void device_check_where_expr_all_types(
+    Kokkos::Experimental::Impl::data_types<DataTypes...>) {
+  (device_check_where_expr<Abi, DataTypes>(), ...);
+}
+
+template <typename... Abis>
+KOKKOS_INLINE_FUNCTION void device_check_where_expr_all_abis(
+    Kokkos::Experimental::Impl::abi_set<Abis...>) {
+  using DataTypes = Kokkos::Experimental::Impl::data_type_set;
+  (device_check_where_expr_all_types<Abis>(DataTypes()), ...);
+}
+
+class simd_device_where_expr_functor {
+ public:
+  KOKKOS_INLINE_FUNCTION void operator()(int) const {
+    device_check_where_expr_all_abis(
+        Kokkos::Experimental::Impl::device_abi_set());
+  }
+};
+
+TEST(simd, host_where_expressions) {
+  host_check_where_expr_all_abis(Kokkos::Experimental::Impl::host_abi_set());
+}
+
+TEST(simd, device_where_expressions) {
+  Kokkos::parallel_for(1, simd_device_where_expr_functor());
+}
+
+#endif
diff --git a/tpls/desul/Config.hpp.cmake.in b/tpls/desul/Config.hpp.cmake.in
index a7bc738191..aed7ecfabc 100644
--- a/tpls/desul/Config.hpp.cmake.in
+++ b/tpls/desul/Config.hpp.cmake.in
@@ -14,6 +14,8 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #cmakedefine DESUL_ATOMICS_ENABLE_HIP
 #cmakedefine DESUL_ATOMICS_ENABLE_HIP_SEPARABLE_COMPILATION
 #cmakedefine DESUL_ATOMICS_ENABLE_SYCL
+#cmakedefine DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
 #cmakedefine DESUL_ATOMICS_ENABLE_OPENMP
+#cmakedefine DESUL_ATOMICS_ENABLE_OPENACC
 
 #endif
diff --git a/tpls/desul/include/desul/atomics/Adapt_HIP.hpp b/tpls/desul/include/desul/atomics/Adapt_HIP.hpp
new file mode 100644
index 0000000000..0eab27fe98
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Adapt_HIP.hpp
@@ -0,0 +1,77 @@
+/*
+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_ADAPT_HIP_HPP_
+#define DESUL_ATOMICS_ADAPT_HIP_HPP_
+
+#include <desul/atomics/Common.hpp>
+
+namespace desul {
+namespace Impl {
+
+// FIXME same code as GCCMemoryOrder
+template <class MemoryOrder>
+struct HIPMemoryOrder;
+
+template <>
+struct HIPMemoryOrder<MemoryOrderRelaxed> {
+  static constexpr int value = __ATOMIC_RELAXED;
+};
+
+template <>
+struct HIPMemoryOrder<MemoryOrderAcquire> {
+  static constexpr int value = __ATOMIC_ACQUIRE;
+};
+
+template <>
+struct HIPMemoryOrder<MemoryOrderRelease> {
+  static constexpr int value = __ATOMIC_RELEASE;
+};
+
+template <>
+struct HIPMemoryOrder<MemoryOrderAcqRel> {
+  static constexpr int value = __ATOMIC_ACQ_REL;
+};
+
+template <>
+struct HIPMemoryOrder<MemoryOrderSeqCst> {
+  static constexpr int value = __ATOMIC_SEQ_CST;
+};
+
+// __HIP_MEMORY_SCOPE_SYSTEM
+// __HIP_MEMORY_SCOPE_AGENT
+// __HIP_MEMORY_SCOPE_WORKGROUP
+// __HIP_MEMORY_SCOPE_WAVEFRONT
+// __HIP_MEMORY_SCOPE_SINGLETHREAD
+template <class MemoryScope>
+struct HIPMemoryScope;
+
+template <>
+struct HIPMemoryScope<MemoryScopeCore> {
+  static constexpr int value = __HIP_MEMORY_SCOPE_WORKGROUP;
+};
+
+template <>
+struct HIPMemoryScope<MemoryScopeDevice> {
+  static constexpr int value = __HIP_MEMORY_SCOPE_AGENT;
+};
+
+template <>
+struct HIPMemoryScope<MemoryScopeNode> {
+  static constexpr int value = __HIP_MEMORY_SCOPE_SYSTEM;
+};
+
+template <>
+struct HIPMemoryScope<MemoryScopeSystem> {
+  static constexpr int value = __HIP_MEMORY_SCOPE_SYSTEM;
+};
+
+}  // namespace Impl
+}  // namespace desul
+
+#endif
diff --git a/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp b/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp
index 082fc132de..15c6d78d94 100644
--- a/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp
+++ b/tpls/desul/include/desul/atomics/Adapt_SYCL.hpp
@@ -88,15 +88,18 @@ 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.
+#ifdef SYCL_EXT_ONEAPI_DEVICE_GLOBAL
+template <class T>
+using sycl_device_global = sycl::ext::oneapi::experimental::device_global<T>;
+#else
 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
+#endif
 
 }  // namespace Impl
 }  // namespace desul
diff --git a/tpls/desul/include/desul/atomics/Atomic_Ref.hpp b/tpls/desul/include/desul/atomics/Atomic_Ref.hpp
index 3d69dcf6c5..e7f9239e03 100644
--- a/tpls/desul/include/desul/atomics/Atomic_Ref.hpp
+++ b/tpls/desul/include/desul/atomics/Atomic_Ref.hpp
@@ -6,533 +6,95 @@ Source: https://github.com/desul/desul
 SPDX-License-Identifier: (BSD-3-Clause)
 */
 
-#ifndef DESUL_ATOMIC_REF_IMPL_HPP_
-#define DESUL_ATOMIC_REF_IMPL_HPP_
+#ifndef DESUL_ATOMIC_REF_HPP_
+#define DESUL_ATOMIC_REF_HPP_
 
-#include <cstddef>
 #include <desul/atomics/Common.hpp>
 #include <desul/atomics/Generic.hpp>
 #include <desul/atomics/Macros.hpp>
-#include <memory>
-#include <type_traits>
 
 namespace desul {
-namespace Impl {
 
-// TODO current implementation is missing the following:
-// * member functions
-//   * wait
-//   * notify_one
-//   * notify_all
-
-template <typename T,
-          typename MemoryOrder,
-          typename MemoryScope,
-          bool = std::is_integral<T>{},
-          bool = std::is_floating_point<T>{}>
-struct basic_atomic_ref;
-
-// base class for non-integral, non-floating-point, non-pointer types
-template <typename T, typename MemoryOrder, typename MemoryScope>
-struct basic_atomic_ref<T, MemoryOrder, MemoryScope, false, false> {
-  static_assert(std::is_trivially_copyable<T>{}, "");
-
- private:
-  T* _ptr;
-
-  // 1/2/4/8/16-byte types must be aligned to at least their size
-  static constexpr int _min_alignment = (sizeof(T) & (sizeof(T) - 1)) || sizeof(T) > 16
-                                            ? 0
-                                            : sizeof(T);
-
- public:
-  using value_type = T;
-
-  static constexpr bool is_always_lock_free = atomic_always_lock_free(sizeof(T));
-
-  static constexpr std::size_t required_alignment = _min_alignment > alignof(T)
-                                                        ? _min_alignment
-                                                        : alignof(T);
-
-  basic_atomic_ref() = delete;
-  basic_atomic_ref& operator=(basic_atomic_ref const&) = delete;
-
-  basic_atomic_ref(basic_atomic_ref const&) = default;
-
-  explicit basic_atomic_ref(T& obj) : _ptr(std::addressof(obj)) {}
-
-  T operator=(T desired) const noexcept {
-    this->store(desired);
-    return desired;
-  }
-
-  operator T() const noexcept { return this->load(); }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION void store(T desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    atomic_store(_ptr, desired, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T load(_MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T exchange(T desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, desired, order, MemoryScope());
-  }
-
-  DESUL_FUNCTION bool is_lock_free() const noexcept {
-    return atomic_is_lock_free<sizeof(T), required_alignment>();
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(T& expected,
-                                            T desired,
-                                            SuccessMemoryOrder success,
-                                            FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_weak(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(
-      T& expected, T desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_weak(expected,
-                                 desired,
-                                 order,
-                                 cmpexch_failure_memory_order<_MemoryOrder>(),
-                                 MemoryScope());
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T& expected,
-      T desired,
-      SuccessMemoryOrder success,
-      FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_strong(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T& expected, T desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_strong(expected,
-                                   desired,
-                                   order,
-                                   cmpexch_failure_memory_order<_MemoryOrder>(),
-                                   MemoryScope());
-  }
-};
-
-// base class for atomic_ref<integral-type>
-template <typename T, typename MemoryOrder, typename MemoryScope>
-struct basic_atomic_ref<T, MemoryOrder, MemoryScope, true, false> {
-  static_assert(std::is_integral<T>{}, "");
-
- private:
-  T* _ptr;
-
- public:
-  using value_type = T;
-  using difference_type = value_type;
-
-  static constexpr bool is_always_lock_free = atomic_always_lock_free(sizeof(T));
-
-  static constexpr std::size_t required_alignment = sizeof(T) > alignof(T) ? sizeof(T)
-                                                                           : alignof(T);
-
-  basic_atomic_ref() = delete;
-  basic_atomic_ref& operator=(basic_atomic_ref const&) = delete;
-
-  explicit basic_atomic_ref(T& obj) : _ptr(&obj) {}
-
-  basic_atomic_ref(basic_atomic_ref const&) = default;
-
-  T operator=(T desired) const noexcept {
-    this->store(desired);
-    return desired;
-  }
-
-  operator T() const noexcept { return this->load(); }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION void store(T desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    atomic_store(_ptr, desired, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T load(_MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T exchange(T desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, desired, order, MemoryScope());
-  }
-
-  DESUL_FUNCTION bool is_lock_free() const noexcept {
-    return atomic_is_lock_free<sizeof(T), required_alignment>();
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(T& expected,
-                                            T desired,
-                                            SuccessMemoryOrder success,
-                                            FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_weak(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(
-      T& expected, T desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_weak(expected,
-                                 desired,
-                                 order,
-                                 cmpexch_failure_memory_order<_MemoryOrder>(),
-                                 MemoryScope());
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T& expected,
-      T desired,
-      SuccessMemoryOrder success,
-      FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_strong(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T& expected, T desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_strong(expected,
-                                   desired,
-                                   order,
-                                   cmpexch_failure_memory_order<_MemoryOrder>(),
-                                   MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_add(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_add(_ptr, arg, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_sub(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_sub(_ptr, arg, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_and(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_and(_ptr, arg, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_or(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_or(_ptr, arg, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_xor(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_xor(_ptr, arg, order, MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator++() const noexcept {
-    return atomic_add_fetch(_ptr, value_type(1), MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator++(int) const noexcept { return fetch_add(1); }
-
-  DESUL_FUNCTION value_type operator--() const noexcept {
-    return atomic_sub_fetch(_ptr, value_type(1), MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator--(int) const noexcept { return fetch_sub(1); }
-
-  DESUL_FUNCTION value_type operator+=(value_type arg) const noexcept {
-    atomic_add_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator-=(value_type arg) const noexcept {
-    atomic_sub_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator&=(value_type arg) const noexcept {
-    atomic_and_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator|=(value_type arg) const noexcept {
-    atomic_or_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator^=(value_type arg) const noexcept {
-    atomic_xor_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-};
-
-// base class for atomic_ref<floating-point-type>
 template <typename T, typename MemoryOrder, typename MemoryScope>
-struct basic_atomic_ref<T, MemoryOrder, MemoryScope, false, true> {
-  static_assert(std::is_floating_point<T>{}, "");
-
- private:
-  T* _ptr;
+class AtomicRef {
+  T* ptr_;
 
  public:
   using value_type = T;
-  using difference_type = value_type;
-
-  static constexpr bool is_always_lock_free = atomic_always_lock_free(sizeof(T));
-
-  static constexpr std::size_t required_alignment = alignof(T);
-
-  basic_atomic_ref() = delete;
-  basic_atomic_ref& operator=(basic_atomic_ref const&) = delete;
-
-  explicit basic_atomic_ref(T& obj) : _ptr(&obj) {}
-
-  basic_atomic_ref(basic_atomic_ref const&) = default;
-
-  T operator=(T desired) const noexcept {
-    this->store(desired);
-    return desired;
-  }
-
-  operator T() const noexcept { return this->load(); }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION void store(T desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    atomic_store(_ptr, desired, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T load(_MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T exchange(T desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, desired, order, MemoryScope());
-  }
-
-  DESUL_FUNCTION bool is_lock_free() const noexcept {
-    return atomic_is_lock_free<sizeof(T), required_alignment>();
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(T& expected,
-                                            T desired,
-                                            SuccessMemoryOrder success,
-                                            FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_weak(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(
-      T& expected, T desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_weak(expected,
-                                 desired,
-                                 order,
-                                 cmpexch_failure_memory_order<_MemoryOrder>(),
-                                 MemoryScope());
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T& expected,
-      T desired,
-      SuccessMemoryOrder success,
-      FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_strong(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T& expected, T desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_strong(expected,
-                                   desired,
-                                   order,
-                                   cmpexch_failure_memory_order<_MemoryOrder>(),
-                                   MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_add(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_add(_ptr, arg, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_sub(value_type arg, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_sub(_ptr, arg, order, MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator+=(value_type arg) const noexcept {
-    atomic_add_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator-=(value_type arg) const noexcept {
-    atomic_sub_fetch(_ptr, arg, MemoryOrder(), MemoryScope());
-  }
-};
-
-// base class for atomic_ref<pointer-type>
-template <typename T, typename MemoryOrder, typename MemoryScope>
-struct basic_atomic_ref<T*, MemoryOrder, MemoryScope, false, false> {
- private:
-  T** _ptr;
+  using memory_order = MemoryOrder;
+  using memory_scope = MemoryScope;
 
- public:
-  using value_type = T*;
-  using difference_type = std::ptrdiff_t;
-
-  static constexpr bool is_always_lock_free = atomic_always_lock_free(sizeof(T));
-
-  static constexpr std::size_t required_alignment = alignof(T*);
-
-  basic_atomic_ref() = delete;
-  basic_atomic_ref& operator=(basic_atomic_ref const&) = delete;
-
-  explicit basic_atomic_ref(T*& arg) : _ptr(std::addressof(arg)) {}
+  DESUL_FUNCTION explicit AtomicRef(T& obj) : ptr_(&obj) {}
 
-  basic_atomic_ref(basic_atomic_ref const&) = default;
-
-  T* operator=(T* desired) const noexcept {
-    this->store(desired);
+  DESUL_FUNCTION T operator=(T desired) const noexcept {
+    store(desired);
     return desired;
   }
 
-  operator T*() const noexcept { return this->load(); }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION void store(T* desired,
-                            _MemoryOrder order = _MemoryOrder()) const noexcept {
-    atomic_store(_ptr, desired, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T* load(_MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, order, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION T* exchange(T* desired,
-                             _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_load(_ptr, desired, order, MemoryScope());
-  }
-
-  DESUL_FUNCTION bool is_lock_free() const noexcept {
-    return atomic_is_lock_free<sizeof(T*), required_alignment>();
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(T*& expected,
-                                            T* desired,
-                                            SuccessMemoryOrder success,
-                                            FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_weak(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_weak(
-      T*& expected, T* desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_weak(expected,
-                                 desired,
-                                 order,
-                                 cmpexch_failure_memory_order<_MemoryOrder>(),
-                                 MemoryScope());
-  }
-
-  template <typename SuccessMemoryOrder, typename FailureMemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T*& expected,
-      T* desired,
-      SuccessMemoryOrder success,
-      FailureMemoryOrder failure) const noexcept {
-    return atomic_compare_exchange_strong(
-        _ptr, expected, desired, success, failure, MemoryScope());
-  }
-
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION bool compare_exchange_strong(
-      T*& expected, T* desired, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return compare_exchange_strong(expected,
-                                   desired,
-                                   order,
-                                   cmpexch_failure_memory_order<_MemoryOrder>(),
-                                   MemoryScope());
-  }
+  DESUL_FUNCTION operator T() const noexcept { return load(); }
 
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_add(difference_type d, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_add(_ptr, _type_size(d), order, MemoryScope());
+  DESUL_FUNCTION T load() const noexcept {
+    return desul::atomic_load(ptr_, MemoryOrder(), MemoryScope());
   }
 
-  template <typename _MemoryOrder = MemoryOrder>
-  DESUL_FUNCTION value_type
-  fetch_sub(difference_type d, _MemoryOrder order = _MemoryOrder()) const noexcept {
-    return atomic_fetch_sub(_ptr, _type_size(d), order, MemoryScope());
+  DESUL_FUNCTION void store(T desired) const noexcept {
+    return desul::atomic_store(ptr_, desired, MemoryOrder(), MemoryScope());
   }
 
-  DESUL_FUNCTION value_type operator++() const noexcept {
-    return atomic_add_fetch(_ptr, _type_size(1), MemoryOrder(), MemoryScope());
-  }
-
-  DESUL_FUNCTION value_type operator++(int) const noexcept { return fetch_add(1); }
-
-  DESUL_FUNCTION value_type operator--() const noexcept {
-    return atomic_sub_fetch(_ptr, _type_size(1), MemoryOrder(), MemoryScope());
+  DESUL_FUNCTION T exchange(T desired) const noexcept {
+    return desul::atomic_exchange(ptr_, desired, MemoryOrder(), MemoryScope());
   }
 
-  DESUL_FUNCTION value_type operator--(int) const noexcept { return fetch_sub(1); }
+  // TODO compare_exchange_{weak,strong} and is_lock_free
 
-  DESUL_FUNCTION value_type operator+=(difference_type d) const noexcept {
-    atomic_add_fetch(_ptr, _type_size(d), MemoryOrder(), MemoryScope());
+#define DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(FETCH_OP, OP_FETCH)                 \
+  DESUL_FUNCTION T FETCH_OP(T arg) const noexcept {                           \
+    return desul::atomic_##FETCH_OP(ptr_, arg, MemoryOrder(), MemoryScope()); \
+  }                                                                           \
+  DESUL_FUNCTION T OP_FETCH(T arg) const noexcept {                           \
+    return desul::atomic_##OP_FETCH(ptr_, arg, MemoryOrder(), MemoryScope()); \
   }
 
-  DESUL_FUNCTION value_type operator-=(difference_type d) const noexcept {
-    atomic_sub_fetch(_ptr, _type_size(d), MemoryOrder(), MemoryScope());
-  }
+#define DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(COMPD_ASGMT, OP_FETCH) \
+  DESUL_FUNCTION T operator COMPD_ASGMT(T arg) const noexcept { return OP_FETCH(arg); }
 
- private:
-  static constexpr std::ptrdiff_t _type_size(std::ptrdiff_t d) noexcept {
-    static_assert(std::is_object<T>{}, "");
-    return d * sizeof(T);
-  }
-};
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_add, add_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(+=, add_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_sub, sub_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(-=, sub_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_min, min_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_max, max_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_mul, mul_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(*=, mul_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_div, div_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(/=, div_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_mod, mod_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(%=, mod_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_and, and_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(&=, and_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_or, or_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(|=, or_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_xor, xor_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP(^=, xor_fetch)
+  DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP(fetch_nand, nand_fetch)
 
-}  // namespace Impl
-
-template <typename T, typename MemoryOrder, typename MemoryScope>
-struct scoped_atomic_ref : Impl::basic_atomic_ref<T, MemoryOrder, MemoryScope> {
-  explicit scoped_atomic_ref(T& obj) noexcept
-      : Impl::basic_atomic_ref<T, MemoryOrder, MemoryScope>(obj) {}
+#undef DESUL_IMPL_DEFINE_ATOMIC_COMPOUND_ASSIGNMENT_OP
+#undef DESUL_IMPL_DEFINE_ATOMIC_FETCH_OP
 
-  scoped_atomic_ref& operator=(scoped_atomic_ref const&) = delete;
+#define DESUL_IMPL_DEFINE_ATOMIC_INCREMENT_DECREMENT(OPER, NAME)             \
+  DESUL_FUNCTION T fetch_##NAME() const noexcept {                           \
+    return desul::atomic_fetch_##NAME(ptr_, MemoryOrder(), MemoryScope());   \
+  }                                                                          \
+  DESUL_FUNCTION T NAME##_fetch() const noexcept {                           \
+    return desul::atomic_##NAME##_fetch(ptr_, MemoryOrder(), MemoryScope()); \
+  }                                                                          \
+  DESUL_FUNCTION T operator OPER() const noexcept { return NAME##_fetch(); } \
+  DESUL_FUNCTION T operator OPER(int) const noexcept { return fetch_##NAME(); }
 
-  scoped_atomic_ref(scoped_atomic_ref const&) = default;
+  DESUL_IMPL_DEFINE_ATOMIC_INCREMENT_DECREMENT(++, inc)
+  DESUL_IMPL_DEFINE_ATOMIC_INCREMENT_DECREMENT(--, dec)
 
-  using Impl::basic_atomic_ref<T, MemoryOrder, MemoryScope>::operator=;
+#undef DESUL_IMPL_DEFINE_ATOMIC_INCREMENT_DECREMENT
 };
 
 }  // namespace desul
diff --git a/tpls/desul/include/desul/atomics/Compare_Exchange.hpp b/tpls/desul/include/desul/atomics/Compare_Exchange.hpp
index e91569e1de..72639fc493 100644
--- a/tpls/desul/include/desul/atomics/Compare_Exchange.hpp
+++ b/tpls/desul/include/desul/atomics/Compare_Exchange.hpp
@@ -26,6 +26,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifdef DESUL_HAVE_OPENMP_ATOMICS
 #include <desul/atomics/Compare_Exchange_OpenMP.hpp>
 #endif
+#ifdef DESUL_HAVE_OPENACC_ATOMICS
+#include <desul/atomics/Compare_Exchange_OpenACC.hpp>
+#endif
 #ifdef DESUL_HAVE_SYCL_ATOMICS
 #include <desul/atomics/Compare_Exchange_SYCL.hpp>
 #endif
diff --git a/tpls/desul/include/desul/atomics/Compare_Exchange_HIP.hpp b/tpls/desul/include/desul/atomics/Compare_Exchange_HIP.hpp
index 8c909bacdf..0ade34f25d 100644
--- a/tpls/desul/include/desul/atomics/Compare_Exchange_HIP.hpp
+++ b/tpls/desul/include/desul/atomics/Compare_Exchange_HIP.hpp
@@ -9,6 +9,7 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifndef DESUL_ATOMICS_COMPARE_EXCHANGE_HIP_HPP_
 #define DESUL_ATOMICS_COMPARE_EXCHANGE_HIP_HPP_
 
+#include <desul/atomics/Adapt_HIP.hpp>
 #include <desul/atomics/Common.hpp>
 #include <desul/atomics/Lock_Array_HIP.hpp>
 #include <desul/atomics/Thread_Fence_HIP.hpp>
@@ -17,130 +18,40 @@ SPDX-License-Identifier: (BSD-3-Clause)
 namespace desul {
 namespace Impl {
 
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4, T> device_atomic_compare_exchange(
-    T* const dest, T compare, T value, MemoryOrderRelaxed, MemoryScope) {
-  static_assert(sizeof(unsigned int) == 4,
-                "this function assumes an unsigned int is 32-bit");
-  unsigned int return_val = atomicCAS(reinterpret_cast<unsigned int*>(dest),
-                                      reinterpret_cast<unsigned int&>(compare),
-                                      reinterpret_cast<unsigned int&>(value));
-  return reinterpret_cast<T&>(return_val);
-}
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 8, T> device_atomic_compare_exchange(
-    T* const dest, T compare, T value, MemoryOrderRelaxed, MemoryScope) {
-  static_assert(sizeof(unsigned long long int) == 8,
-                "this function assumes an unsigned long long is 64-bit");
-  unsigned long long int return_val =
-      atomicCAS(reinterpret_cast<unsigned long long int*>(dest),
-                reinterpret_cast<unsigned long long int&>(compare),
-                reinterpret_cast<unsigned long long int&>(value));
-  return reinterpret_cast<T&>(return_val);
-}
+template <class T>
+struct atomic_exchange_available_hip {
+  constexpr static bool value =
+      ((sizeof(T) == 1 && alignof(T) == 1) || (sizeof(T) == 4 && alignof(T) == 4) ||
+       (sizeof(T) == 8 && alignof(T) == 8)) &&
+      std::is_trivially_copyable<T>::value;
+};
 
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T>
-device_atomic_compare_exchange(
-    T* const dest, T compare, T value, MemoryOrderRelease, MemoryScope) {
-  T return_val = atomic_compare_exchange(
-      dest, compare, value, MemoryOrderRelaxed(), MemoryScope());
-  atomic_thread_fence(MemoryOrderRelease(), MemoryScope());
-  return return_val;
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T>
-device_atomic_compare_exchange(
-    T* const dest, T compare, T value, MemoryOrderAcquire, MemoryScope) {
-  atomic_thread_fence(MemoryOrderAcquire(), MemoryScope());
-  T return_val = atomic_compare_exchange(
-      dest, compare, value, MemoryOrderRelaxed(), MemoryScope());
-  return return_val;
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T>
+template <class T, class MemoryOrder, class MemoryScope>
+__device__ std::enable_if_t<atomic_exchange_available_hip<T>::value, T>
 device_atomic_compare_exchange(
-    T* const dest, T compare, T value, MemoryOrderAcqRel, MemoryScope) {
-  atomic_thread_fence(MemoryOrderAcquire(), MemoryScope());
-  T return_val = atomic_compare_exchange(
-      dest, compare, value, MemoryOrderRelaxed(), MemoryScope());
-  atomic_thread_fence(MemoryOrderRelease(), MemoryScope());
-  return return_val;
+    T* const dest, T compare, T value, MemoryOrder, MemoryScope) {
+  (void)__hip_atomic_compare_exchange_strong(
+      dest,
+      &compare,
+      value,
+      HIPMemoryOrder<MemoryOrder>::value,
+      HIPMemoryOrder<cmpexch_failure_memory_order<MemoryOrder>>::value,
+      HIPMemoryScope<MemoryScope>::value);
+  return compare;
 }
 
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4, T> device_atomic_exchange(
-    T* const dest, T value, MemoryOrderRelaxed, MemoryScope) {
-  static_assert(sizeof(unsigned int) == 4,
-                "this function assumes an unsigned int is 32-bit");
-  unsigned int return_val = atomicExch(reinterpret_cast<unsigned int*>(dest),
-                                       reinterpret_cast<unsigned int&>(value));
-  return reinterpret_cast<T&>(return_val);
-}
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 8, T> device_atomic_exchange(
-    T* const dest, T value, MemoryOrderRelaxed, MemoryScope) {
-  static_assert(sizeof(unsigned long long int) == 8,
-                "this function assumes an unsigned long long is 64-bit");
-  unsigned long long int return_val =
-      atomicExch(reinterpret_cast<unsigned long long int*>(dest),
-                 reinterpret_cast<unsigned long long int&>(value));
-  return reinterpret_cast<T&>(return_val);
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T> device_atomic_exchange(
-    T* const dest, T compare, T value, MemoryOrderRelease, MemoryScope) {
-  T return_val = device_atomic_compare_exchange(
-      dest, compare, value, MemoryOrderRelaxed(), MemoryScope());
-  device_atomic_thread_fence(MemoryOrderRelease(), MemoryScope());
-  return reinterpret_cast<T&>(return_val);
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T> device_atomic_exchange(
-    T* const dest, T /*compare*/, T value, MemoryOrderAcquire, MemoryScope) {
-  device_atomic_thread_fence(MemoryOrderAcquire(), MemoryScope());
-  T return_val =
-      device_atomic_exchange(dest, value, MemoryOrderRelaxed(), MemoryScope());
-  return reinterpret_cast<T&>(return_val);
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T> device_atomic_exchange(
-    T* const dest, T value, MemoryOrderAcqRel, MemoryScope) {
-  device_atomic_thread_fence(MemoryOrderAcquire(), MemoryScope());
-  T return_val =
-      device_atomic_exchange(dest, value, MemoryOrderRelaxed(), MemoryScope());
-  device_atomic_thread_fence(MemoryOrderRelease(), MemoryScope());
-  return reinterpret_cast<T&>(return_val);
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T> device_atomic_exchange(
-    T* const dest, T value, MemoryOrderSeqCst, MemoryScope) {
-  device_atomic_thread_fence(MemoryOrderAcquire(), MemoryScope());
-  T return_val =
-      device_atomic_exchange(dest, value, MemoryOrderRelaxed(), MemoryScope());
-  device_atomic_thread_fence(MemoryOrderRelease(), MemoryScope());
-  return reinterpret_cast<T&>(return_val);
-}
-
-template <class T, class MemoryScope>
-__device__ std::enable_if_t<sizeof(T) == 4 || sizeof(T) == 8, T>
-device_atomic_compare_exchange(
-    T* const dest, T compare, T value, MemoryOrderSeqCst, MemoryScope) {
-  device_atomic_thread_fence(MemoryOrderAcquire(), MemoryScope());
-  T return_val = device_atomic_compare_exchange(
-      dest, compare, value, MemoryOrderRelaxed(), MemoryScope());
-  device_atomic_thread_fence(MemoryOrderRelease(), MemoryScope());
+template <class T, class MemoryOrder, class MemoryScope>
+__device__ std::enable_if_t<atomic_exchange_available_hip<T>::value, T>
+device_atomic_exchange(T* const dest, T value, MemoryOrder, MemoryScope) {
+  T return_val = __hip_atomic_exchange(dest,
+                                       value,
+                                       HIPMemoryOrder<MemoryOrder>::value,
+                                       HIPMemoryScope<MemoryScope>::value);
   return return_val;
 }
 
 template <class T, class MemoryOrder, class MemoryScope>
-__device__ std::enable_if_t<(sizeof(T) != 8) && (sizeof(T) != 4), T>
+__device__ std::enable_if_t<!atomic_exchange_available_hip<T>::value, T>
 device_atomic_compare_exchange(
     T* const dest, T compare, T value, MemoryOrder, MemoryScope scope) {
   // This is a way to avoid deadlock in a warp or wave front
@@ -169,7 +80,7 @@ device_atomic_compare_exchange(
 }
 
 template <class T, class MemoryOrder, class MemoryScope>
-__device__ std::enable_if_t<(sizeof(T) != 8) && (sizeof(T) != 4), T>
+__device__ std::enable_if_t<!atomic_exchange_available_hip<T>::value, T>
 device_atomic_exchange(T* const dest, T value, MemoryOrder, MemoryScope scope) {
   // This is a way to avoid deadlock in a warp or wave front
   T return_val;
diff --git a/tpls/desul/include/desul/atomics/Compare_Exchange_OpenACC.hpp b/tpls/desul/include/desul/atomics/Compare_Exchange_OpenACC.hpp
new file mode 100644
index 0000000000..77149bd474
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Compare_Exchange_OpenACC.hpp
@@ -0,0 +1,153 @@
+/*
+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_COMPARE_EXCHANGE_OPENACC_HPP_
+#define DESUL_ATOMICS_COMPARE_EXCHANGE_OPENACC_HPP_
+
+#include <openacc.h>
+
+#include <desul/atomics/Common.hpp>
+#include <desul/atomics/Thread_Fence_OpenACC.hpp>
+#include <type_traits>
+
+namespace desul {
+namespace Impl {
+
+#ifdef __NVCOMPILER
+
+#pragma acc routine seq
+template <class T, class MemoryOrder, class MemoryScope>
+T device_atomic_exchange(T* dest, T value, MemoryOrder, MemoryScope /*scope*/) {
+  if constexpr (std::is_arithmetic_v<T> && ((sizeof(T) == 4) || (sizeof(T) == 8))) {
+    T return_val;
+#pragma acc atomic capture
+    {
+      return_val = *dest;
+      *dest = value;
+    }
+    return return_val;
+  } else {
+    // FIXME_OPENACC
+    if (acc_on_device(acc_device_not_host)) {
+      printf(
+          "DESUL error in device_atomic_exchange(): Not supported atomic operation in "
+          "the OpenACC backend\n");
+    }
+    //  Acquire a lock for the address
+    // while (!lock_address_openacc((void*)dest, scope)) {
+    // }
+    // device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+    T return_val = *dest;
+    *dest = value;
+    // device_atomic_thread_fence(MemoryOrderRelease(), scope);
+    // unlock_address_openacc((void*)dest, scope);
+    return return_val;
+  }
+}
+
+#pragma acc routine seq
+template <class T, class MemoryOrder, class MemoryScope>
+T device_atomic_compare_exchange(
+    T* dest, T compare, T value, MemoryOrder, MemoryScope scope) {
+  // Floating point types treated separetely to work around compiler errors
+  // "parse invalid cast opcode for cast from 'i32' to 'float'".
+  // Also not just "forwarding" arguments to atomicCAS because it does not have an
+  // overload that takes int64_t
+  if constexpr (std::is_integral_v<T> && ((sizeof(T) == 4) || (sizeof(T) == 8))) {
+    static_assert(sizeof(unsigned int) == 4);
+    static_assert(sizeof(unsigned long long int) == 8);
+    using cas_t =
+        std::conditional_t<(sizeof(T) == 4), unsigned int, unsigned long long int>;
+    cas_t return_val = atomicCAS(reinterpret_cast<cas_t*>(dest),
+                                 reinterpret_cast<cas_t&>(compare),
+                                 reinterpret_cast<cas_t&>(value));
+    return reinterpret_cast<T&>(return_val);
+#ifdef DESUL_CUDA_ARCH_IS_PRE_PASCAL
+  } else if constexpr (std::is_same_v<T, float>) {
+#else
+  } else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+#endif
+    return atomicCAS(dest, compare, value);
+  } else {
+    // FIXME_OPENACC
+    if (acc_on_device(acc_device_not_host)) {
+      printf(
+          "DESUL error in device_atomic_compare_exchange(): Not supported atomic "
+          "operation in the OpenACC backend\n");
+    }
+    T current_val = *dest;
+    // Acquire a lock for the address
+    // while (!lock_address_openacc((void*)dest, scope)) {
+    //}
+    // device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+    if (current_val == compare) {
+      *dest = value;
+      // device_atomic_thread_fence(MemoryOrderRelease(), scope);
+    }
+    // unlock_address_openacc((void*)dest, scope);
+    return current_val;
+  }
+}
+
+#else  // not NVHPC
+
+#pragma acc routine seq
+template <class T, class MemoryOrder, class MemoryScope>
+T device_atomic_exchange(T* dest, T value, MemoryOrder, MemoryScope) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    T return_val;
+#pragma acc atomic capture
+    {
+      return_val = *dest;
+      *dest = value;
+    }
+    return return_val;
+  } else {
+    // FIXME_OPENACC
+    printf(
+        "DESUL error in device_atomic_exchange(): Not supported atomic operation in "
+        "the OpenACC backend\n");
+    //  Acquire a lock for the address
+    // while (!lock_address_openacc((void*)dest, scope)) {
+    // }
+    // device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+    T return_val = *dest;
+    *dest = value;
+    // device_atomic_thread_fence(MemoryOrderRelease(), scope);
+    // unlock_address_openacc((void*)dest, scope);
+    return return_val;
+  }
+}
+
+#pragma acc routine seq
+template <class T, class MemoryOrder, class MemoryScope>
+T device_atomic_compare_exchange(
+    T* dest, T compare, T value, MemoryOrder, MemoryScope scope) {
+  // FIXME_OPENACC
+  printf(
+      "DESUL error in device_atomic_compare_exchange(): Not supported atomic operation "
+      "in the OpenACC backend\n");
+  T current_val = *dest;
+  // Acquire a lock for the address
+  // while (!lock_address_openacc((void*)dest, scope)) {
+  //}
+  // device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+  if (current_val == compare) {
+    *dest = value;
+    // device_atomic_thread_fence(MemoryOrderRelease(), scope);
+  }
+  // unlock_address_openacc((void*)dest, scope);
+  return current_val;
+}
+
+#endif
+
+}  // namespace Impl
+}  // namespace desul
+
+#endif
diff --git a/tpls/desul/include/desul/atomics/Fetch_Op.hpp b/tpls/desul/include/desul/atomics/Fetch_Op.hpp
index adf75c5743..1b161397c7 100644
--- a/tpls/desul/include/desul/atomics/Fetch_Op.hpp
+++ b/tpls/desul/include/desul/atomics/Fetch_Op.hpp
@@ -23,6 +23,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifdef DESUL_HAVE_OPENMP_ATOMICS
 #include <desul/atomics/Fetch_Op_OpenMP.hpp>
 #endif
+#ifdef DESUL_HAVE_OPENACC_ATOMICS
+#include <desul/atomics/Fetch_Op_OpenACC.hpp>
+#endif
 #ifdef DESUL_HAVE_SYCL_ATOMICS
 #include <desul/atomics/Fetch_Op_SYCL.hpp>
 #endif
diff --git a/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp b/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp
index 69ed8bcb9f..68622758d8 100644
--- a/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp
+++ b/tpls/desul/include/desul/atomics/Fetch_Op_CUDA.hpp
@@ -69,56 +69,56 @@ inline __device__       unsigned int device_atomic_fetch_inc_mod(  unsigned int*
 inline __device__       unsigned int device_atomic_fetch_dec_mod(  unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicDec(ptr,  val); }
 // clang-format on
 
-#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, TYPE)                               \
+#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, TYPE)                         \
   template <class MemoryOrder>                                                         \
-  __device__ TYPE device_atomic_fetch_##OP(                                            \
+  __device__ TYPE device_atomic_##FETCH_OP(                                            \
       TYPE* ptr, TYPE val, MemoryOrder, MemoryScopeDevice) {                           \
     __threadfence();                                                                   \
     TYPE return_val =                                                                  \
-        device_atomic_fetch_##OP(ptr, val, MemoryOrderRelaxed(), MemoryScopeDevice()); \
+        device_atomic_##FETCH_OP(ptr, val, MemoryOrderRelaxed(), MemoryScopeDevice()); \
     __threadfence();                                                                   \
     return return_val;                                                                 \
   }                                                                                    \
   template <class MemoryOrder>                                                         \
-  __device__ TYPE device_atomic_fetch_##OP(                                            \
+  __device__ TYPE device_atomic_##FETCH_OP(                                            \
       TYPE* ptr, TYPE val, MemoryOrder, MemoryScopeCore) {                             \
-    return device_atomic_fetch_##OP(ptr, val, MemoryOrder(), MemoryScopeDevice());     \
+    return device_atomic_##FETCH_OP(ptr, val, MemoryOrder(), MemoryScopeDevice());     \
   }
 
-#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(OP) \
-  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, int)           \
-  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, unsigned int)  \
-  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, unsigned long long)
+#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(FETCH_OP) \
+  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, int)           \
+  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, unsigned int)  \
+  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, unsigned long long)
 
 #ifdef DESUL_CUDA_ARCH_IS_PRE_PASCAL
 
-#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(OP) \
-  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, float)
+#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(FETCH_OP) \
+  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, float)
 
 #else
 
-#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(OP) \
-  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, float)               \
-  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(OP, double)
+#define DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(FETCH_OP) \
+  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, float)               \
+  DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(FETCH_OP, double)
 
 #endif
 
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(min)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(max)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(and)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(or)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(xor)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_min)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_max)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_and)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_or)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_xor)
 
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(add)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(add)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(sub)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(sub)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(fetch_add)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_add)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(fetch_sub)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_sub)
 
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(inc)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(dec)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_inc)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(fetch_dec)
 
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(inc_mod, unsigned int)
-DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(dec_mod, unsigned int)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(fetch_inc_mod, unsigned int)
+DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP(fetch_dec_mod, unsigned int)
 
 #undef DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT
 #undef DESUL_IMPL_CUDA_DEVICE_ATOMIC_FETCH_OP_INTEGRAL
diff --git a/tpls/desul/include/desul/atomics/Fetch_Op_Generic.hpp b/tpls/desul/include/desul/atomics/Fetch_Op_Generic.hpp
index a94ff8ef18..530195a832 100644
--- a/tpls/desul/include/desul/atomics/Fetch_Op_Generic.hpp
+++ b/tpls/desul/include/desul/atomics/Fetch_Op_Generic.hpp
@@ -18,38 +18,38 @@ SPDX-License-Identifier: (BSD-3-Clause)
 namespace desul {
 namespace Impl {
 
-#define DESUL_IMPL_ATOMIC_FETCH_OP(ANNOTATION, HOST_OR_DEVICE, OP)        \
-  template <class T, class MemoryOrder, class MemoryScope>                \
-  ANNOTATION T HOST_OR_DEVICE##_atomic_fetch_##OP(                        \
-      T* const dest, const T val, MemoryOrder order, MemoryScope scope) { \
-    return HOST_OR_DEVICE##_atomic_fetch_oper(                            \
-        OP##_operator<T, const T>(), dest, val, order, scope);            \
-  }                                                                       \
-  template <class T, class MemoryOrder, class MemoryScope>                \
-  ANNOTATION T HOST_OR_DEVICE##_atomic_##OP##_fetch(                      \
-      T* const dest, const T val, MemoryOrder order, MemoryScope scope) { \
-    return HOST_OR_DEVICE##_atomic_oper_fetch(                            \
-        OP##_operator<T, const T>(), dest, val, order, scope);            \
+#define DESUL_IMPL_ATOMIC_FETCH_OP(ANNOTATION, HOST_OR_DEVICE, FETCH_OP, OP_FETCH) \
+  template <class T, class MemoryOrder, class MemoryScope>                         \
+  ANNOTATION T HOST_OR_DEVICE##_atomic_##FETCH_OP(                                 \
+      T* const dest, const T val, MemoryOrder order, MemoryScope scope) {          \
+    return HOST_OR_DEVICE##_atomic_fetch_oper(                                     \
+        OP_FETCH##_operator<T, const T>(), dest, val, order, scope);               \
+  }                                                                                \
+  template <class T, class MemoryOrder, class MemoryScope>                         \
+  ANNOTATION T HOST_OR_DEVICE##_atomic_##OP_FETCH(                                 \
+      T* const dest, const T val, MemoryOrder order, MemoryScope scope) {          \
+    return HOST_OR_DEVICE##_atomic_oper_fetch(                                     \
+        OP_FETCH##_operator<T, const T>(), dest, val, order, scope);               \
   }
 
-#define DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(OP)           \
-  DESUL_IMPL_ATOMIC_FETCH_OP(DESUL_IMPL_HOST_FUNCTION, host, OP) \
-  DESUL_IMPL_ATOMIC_FETCH_OP(DESUL_IMPL_DEVICE_FUNCTION, device, OP)
-
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(add)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(sub)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(max)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(min)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(mul)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(div)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(mod)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(and)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(or)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(xor)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(nand)
-
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(inc_mod)
-DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(dec_mod)
+#define DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(FETCH_OP, OP_FETCH)           \
+  DESUL_IMPL_ATOMIC_FETCH_OP(DESUL_IMPL_HOST_FUNCTION, host, FETCH_OP, OP_FETCH) \
+  DESUL_IMPL_ATOMIC_FETCH_OP(DESUL_IMPL_DEVICE_FUNCTION, device, FETCH_OP, OP_FETCH)
+
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_add, add_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_sub, sub_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_max, max_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_min, min_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_mul, mul_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_div, div_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_mod, mod_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_and, and_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_or, or_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_xor, xor_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_nand, nand_fetch)
+
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_inc_mod, inc_mod_fetch)
+DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(fetch_dec_mod, dec_mod_fetch)
 
 #undef DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE
 #undef DESUL_IMPL_ATOMIC_FETCH_OP
@@ -59,13 +59,13 @@ DESUL_IMPL_ATOMIC_FETCH_OP_HOST_AND_DEVICE(dec_mod)
   ANNOTATION T HOST_OR_DEVICE##_atomic_fetch_##OP(                                   \
       T* const dest, const unsigned int val, MemoryOrder order, MemoryScope scope) { \
     return HOST_OR_DEVICE##_atomic_fetch_oper(                                       \
-        OP##_operator<T, const unsigned int>(), dest, val, order, scope);            \
+        OP##_fetch_operator<T, const unsigned int>(), dest, val, order, scope);      \
   }                                                                                  \
   template <class T, class MemoryOrder, class MemoryScope>                           \
   ANNOTATION T HOST_OR_DEVICE##_atomic_##OP##_fetch(                                 \
       T* const dest, const unsigned int val, MemoryOrder order, MemoryScope scope) { \
     return HOST_OR_DEVICE##_atomic_oper_fetch(                                       \
-        OP##_operator<T, const unsigned int>(), dest, val, order, scope);            \
+        OP##_fetch_operator<T, const unsigned int>(), dest, val, order, scope);      \
   }
 
 #define DESUL_IMPL_ATOMIC_FETCH_OP_SHIFT_HOST_AND_DEVICE(OP)           \
@@ -78,19 +78,21 @@ DESUL_IMPL_ATOMIC_FETCH_OP_SHIFT_HOST_AND_DEVICE(rshift)
 #undef DESUL_IMPL_ATOMIC_FETCH_OP_SHIFT_HOST_AND_DEVICE
 #undef DESUL_IMPL_ATOMIC_FETCH_OP_SHIFT
 
-#define DESUL_IMPL_ATOMIC_LOAD_AND_STORE(ANNOTATION, HOST_OR_DEVICE)           \
-  template <class T, class MemoryOrder, class MemoryScope>                     \
-  ANNOTATION T HOST_OR_DEVICE##_atomic_load(                                   \
-      const T* const dest, MemoryOrder order, MemoryScope scope) {             \
-    return HOST_OR_DEVICE##_atomic_fetch_oper(                                 \
-        load_operator<T, const T>(), const_cast<T*>(dest), T(), order, scope); \
-  }                                                                            \
-                                                                               \
-  template <class T, class MemoryOrder, class MemoryScope>                     \
-  ANNOTATION void HOST_OR_DEVICE##_atomic_store(                               \
-      T* const dest, const T val, MemoryOrder order, MemoryScope scope) {      \
-    (void)HOST_OR_DEVICE##_atomic_fetch_oper(                                  \
-        store_operator<T, const T>(), dest, val, order, scope);                \
+// NOTE: using atomic_oper_fetch in the fallback implementation of atomic_store to avoid
+// reading potentially uninitialized values which would yield undefined behavior.
+#define DESUL_IMPL_ATOMIC_LOAD_AND_STORE(ANNOTATION, HOST_OR_DEVICE)                 \
+  template <class T, class MemoryOrder, class MemoryScope>                           \
+  ANNOTATION T HOST_OR_DEVICE##_atomic_load(                                         \
+      const T* const dest, MemoryOrder order, MemoryScope scope) {                   \
+    return HOST_OR_DEVICE##_atomic_fetch_oper(                                       \
+        load_fetch_operator<T, const T>(), const_cast<T*>(dest), T(), order, scope); \
+  }                                                                                  \
+                                                                                     \
+  template <class T, class MemoryOrder, class MemoryScope>                           \
+  ANNOTATION void HOST_OR_DEVICE##_atomic_store(                                     \
+      T* const dest, const T val, MemoryOrder order, MemoryScope scope) {            \
+    (void)HOST_OR_DEVICE##_atomic_oper_fetch(                                        \
+        store_fetch_operator<T, const T>(), dest, val, order, scope);                \
   }
 
 DESUL_IMPL_ATOMIC_LOAD_AND_STORE(DESUL_IMPL_HOST_FUNCTION, host)
diff --git a/tpls/desul/include/desul/atomics/Fetch_Op_HIP.hpp b/tpls/desul/include/desul/atomics/Fetch_Op_HIP.hpp
index e9c749809d..8d9bd86825 100644
--- a/tpls/desul/include/desul/atomics/Fetch_Op_HIP.hpp
+++ b/tpls/desul/include/desul/atomics/Fetch_Op_HIP.hpp
@@ -9,99 +9,108 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifndef DESUL_ATOMICS_FECH_OP_HIP_HPP_
 #define DESUL_ATOMICS_FECH_OP_HIP_HPP_
 
+#include <desul/atomics/Adapt_HIP.hpp>
+
 namespace desul {
 namespace Impl {
 
-// clang-format off
-inline __device__                int device_atomic_fetch_add(               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_add(      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_add(unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr,  val); }
-inline __device__              float device_atomic_fetch_add(             float* ptr,              float val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr,  val); }
-inline __device__             double device_atomic_fetch_add(            double* ptr,             double val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr,  val); }
-
-inline __device__                int device_atomic_fetch_sub(               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicSub(ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_sub(      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicSub(ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_sub(unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, -val); }
-inline __device__              float device_atomic_fetch_sub(             float* ptr,              float val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, -val); }
-inline __device__             double device_atomic_fetch_sub(            double* ptr,             double val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, -val); }
-
-inline __device__                int device_atomic_fetch_min(               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicMin(ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_min(      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicMin(ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_min(unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicMin(ptr,  val); }
-
-inline __device__                int device_atomic_fetch_max(               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicMax(ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_max(      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicMax(ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_max(unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicMax(ptr,  val); }
-
-inline __device__                int device_atomic_fetch_and(               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAnd(ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_and(      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAnd(ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_and(unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAnd(ptr,  val); }
-
-inline __device__                int device_atomic_fetch_or (               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicOr (ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_or (      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicOr (ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_or (unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicOr (ptr,  val); }
+#define DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, T)                           \
+  template <class MemoryOrder, class MemoryScope>                       \
+  __device__ inline T device_atomic_fetch_##OP(                         \
+      T* ptr, T val, MemoryOrder, MemoryScope) {                        \
+    return __hip_atomic_fetch_##OP(ptr,                                 \
+                                   val,                                 \
+                                   HIPMemoryOrder<MemoryOrder>::value,  \
+                                   HIPMemoryScope<MemoryScope>::value); \
+  }
 
-inline __device__                int device_atomic_fetch_xor(               int* ptr,                int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicXor(ptr,  val); }
-inline __device__       unsigned int device_atomic_fetch_xor(      unsigned int* ptr,       unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicXor(ptr,  val); }
-inline __device__ unsigned long long device_atomic_fetch_xor(unsigned long long* ptr, unsigned long long val, MemoryOrderRelaxed, MemoryScopeDevice) { return atomicXor(ptr,  val); }
+#define DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(OP) \
+  DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, int)           \
+  DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, long long)     \
+  DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, unsigned int)  \
+  DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, unsigned long long)
+
+#define DESUL_IMPL_HIP_ATOMIC_FETCH_OP_FLOATING_POINT(OP) \
+  DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, float)               \
+  DESUL_IMPL_HIP_ATOMIC_FETCH_OP(OP, double)
+
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(add)
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(min)
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(max)
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(and)
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(or)
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL(xor)
+DESUL_IMPL_HIP_ATOMIC_FETCH_OP_FLOATING_POINT(add)
+// atomic min/max gives the wrong results (tested with ROCm 6.0 on Frontier)
+// DESUL_IMPL_HIP_ATOMIC_FETCH_OP_FLOATING_POINT(min)
+// DESUL_IMPL_HIP_ATOMIC_FETCH_OP_FLOATING_POINT(max)
+
+#undef DESUL_IMPL_HIP_ATOMIC_FETCH_OP_FLOATING_POINT
+#undef DESUL_IMPL_HIP_ATOMIC_FETCH_OP_INTEGRAL
+#undef DESUL_IMPL_HIP_ATOMIC_FETCH_OP
+
+#define DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(T)                             \
+  template <class MemoryOrder, class MemoryScope>                      \
+  __device__ inline T device_atomic_fetch_sub(                         \
+      T* ptr, T val, MemoryOrder, MemoryScope) {                       \
+    return __hip_atomic_fetch_add(ptr,                                 \
+                                  -val,                                \
+                                  HIPMemoryOrder<MemoryOrder>::value,  \
+                                  HIPMemoryScope<MemoryScope>::value); \
+  }
 
-inline __device__                int device_atomic_fetch_inc(               int* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, 1   ); }
-inline __device__       unsigned int device_atomic_fetch_inc(      unsigned int* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, 1u  ); }
-inline __device__ unsigned long long device_atomic_fetch_inc(unsigned long long* ptr,                         MemoryOrderRelaxed, MemoryScopeDevice) { return atomicAdd(ptr, 1ull); }
+DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(int)
+DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(long long)
+DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(unsigned int)
+DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(unsigned long long)
+DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(float)
+DESUL_IMPL_HIP_ATOMIC_FETCH_SUB(double)
+
+#undef DESUL_IMPL_HIP_ATOMIC_FETCH_SUB
+
+#define DESUL_IMPL_HIP_ATOMIC_FETCH_INC(T)                                        \
+  template <class MemoryOrder, class MemoryScope>                                 \
+  __device__ inline T device_atomic_fetch_inc(T* ptr, MemoryOrder, MemoryScope) { \
+    return __hip_atomic_fetch_add(ptr,                                            \
+                                  1,                                              \
+                                  HIPMemoryOrder<MemoryOrder>::value,             \
+                                  HIPMemoryScope<MemoryScope>::value);            \
+  }                                                                               \
+  template <class MemoryOrder, class MemoryScope>                                 \
+  __device__ inline T device_atomic_fetch_dec(T* ptr, MemoryOrder, MemoryScope) { \
+    return __hip_atomic_fetch_add(ptr,                                            \
+                                  -1,                                             \
+                                  HIPMemoryOrder<MemoryOrder>::value,             \
+                                  HIPMemoryScope<MemoryScope>::value);            \
+  }
 
-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  ); }
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC(int)
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC(long long)
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC(unsigned int)
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC(unsigned long long)
 
-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); }
-// clang-format on
+#undef DESUL_IMPL_HIP_ATOMIC_FETCH_INC
 
-#define DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(OP, TYPE)                                \
+#define DESUL_IMPL_HIP_ATOMIC_FETCH_INC_MOD(MEMORY_SCOPE, MEMORY_SCOPE_STRING_LITERAL) \
   template <class MemoryOrder>                                                         \
-  __device__ TYPE device_atomic_fetch_##OP(                                            \
-      TYPE* ptr, TYPE val, MemoryOrder, MemoryScopeDevice) {                           \
-    __threadfence();                                                                   \
-    TYPE return_val =                                                                  \
-        device_atomic_fetch_##OP(ptr, val, MemoryOrderRelaxed(), MemoryScopeDevice()); \
-    __threadfence();                                                                   \
-    return return_val;                                                                 \
+  __device__ inline unsigned int device_atomic_fetch_inc_mod(                          \
+      unsigned int* ptr, unsigned int val, MemoryOrder, MEMORY_SCOPE) {                \
+    return __builtin_amdgcn_atomic_inc32(                                              \
+        ptr, val, HIPMemoryOrder<MemoryOrder>::value, MEMORY_SCOPE_STRING_LITERAL);    \
   }                                                                                    \
   template <class MemoryOrder>                                                         \
-  __device__ TYPE device_atomic_fetch_##OP(                                            \
-      TYPE* ptr, TYPE val, MemoryOrder, MemoryScopeCore) {                             \
-    return device_atomic_fetch_##OP(ptr, val, MemoryOrder(), MemoryScopeDevice());     \
+  __device__ inline unsigned int device_atomic_fetch_dec_mod(                          \
+      unsigned int* ptr, unsigned int val, MemoryOrder, MEMORY_SCOPE) {                \
+    return __builtin_amdgcn_atomic_dec32(                                              \
+        ptr, val, HIPMemoryOrder<MemoryOrder>::value, MEMORY_SCOPE_STRING_LITERAL);    \
   }
 
-#define DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(OP) \
-  DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(OP, int)           \
-  DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(OP, unsigned int)  \
-  DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(OP, unsigned long long)
-
-#define DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(OP) \
-  DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(OP, float)               \
-  DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(OP, double)
-
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(min)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(max)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(and)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(or)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(xor)
-
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(add)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(add)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT(sub)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(sub)
-
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(inc)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL(dec)
-
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(inc_mod, unsigned int)
-DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP(dec_mod, unsigned int)
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC_MOD(MemoryScopeCore, "workgroup")
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC_MOD(MemoryScopeDevice, "agent")
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC_MOD(MemoryScopeNode, "")
+DESUL_IMPL_HIP_ATOMIC_FETCH_INC_MOD(MemoryScopeSystem, "")
 
-#undef DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_FLOATING_POINT
-#undef DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP_INTEGRAL
-#undef DESUL_IMPL_HIP_DEVICE_ATOMIC_FETCH_OP
+#undef DESUL_IMPL_HIP_ATOMIC_FETCH_INC_MOD
 
 }  // namespace Impl
 }  // namespace desul
diff --git a/tpls/desul/include/desul/atomics/Fetch_Op_OpenACC.hpp b/tpls/desul/include/desul/atomics/Fetch_Op_OpenACC.hpp
new file mode 100644
index 0000000000..ab570ac578
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Fetch_Op_OpenACC.hpp
@@ -0,0 +1,431 @@
+/*
+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_FETCH_OP_OPENACC_HPP_
+#define DESUL_ATOMICS_FETCH_OP_OPENACC_HPP_
+
+#include <algorithm>  // min, max
+#include <desul/atomics/Common.hpp>
+#include <type_traits>
+
+namespace desul {
+namespace Impl {
+
+#ifdef __NVCOMPILER
+
+template <class T>
+inline constexpr bool is_openacc_integral_type_v =
+    std::is_same_v<T, int> || std::is_same_v<T, unsigned int> ||
+    std::is_same_v<T, unsigned long long>;
+
+template <class T>
+inline constexpr bool is_openacc_arithmetic_type_v = std::is_same_v<T, float> ||
+#ifndef DESUL_CUDA_ARCH_IS_PRE_PASCAL
+                                                     std::is_same_v<T, double> ||
+#endif
+                                                     is_openacc_integral_type_v<T>;
+
+#else
+
+template <class T>
+inline constexpr bool is_openacc_integral_type_v = std::is_integral_v<T>;
+
+template <class T>
+inline constexpr bool is_openacc_arithmetic_type_v = std::is_arithmetic_v<T>;
+
+#endif
+
+//<editor-fold
+// desc="device_atomic_fetch_{add,sub,mul,div,lshift,rshift,mod,max,min,and,or,xor}">
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_add(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr += val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_inc(
+    T* ptr, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr += T(1);
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_sub(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr -= val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_dec(
+    T* ptr, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr -= T(1);
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_mul(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr *= val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_div(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr /= val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_fetch_lshift(
+    T* ptr, const unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr = *ptr << val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_fetch_rshift(
+    T* ptr, const unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr = *ptr >> val;
+  }
+  return old;
+}
+
+#ifdef __NVCOMPILER
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_max(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+  old = atomicMax(ptr, val);
+  return old;
+}
+#endif
+
+#ifdef __NVCOMPILER
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_fetch_min(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  int old;
+  old = atomicMin(ptr, val);
+  return old;
+}
+#endif
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_fetch_and(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr &= val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_fetch_or(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr |= val;
+  }
+  return old;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_fetch_xor(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T old;
+#pragma acc atomic capture
+  {
+    old = *ptr;
+    *ptr ^= val;
+  }
+  return old;
+}
+//</editor-fold>
+
+//<editor-fold
+// desc="device_atomic_{add,sub,mul,div,lshift,rshift,mod,max,min,and,or,xor}_fetch">
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_add_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr += val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_inc_fetch(
+    T* ptr, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr += T(1);
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_sub_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr -= val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_dec_fetch(
+    T* ptr, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr -= T(1);
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_mul_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr *= val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_div_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr /= val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_lshift_fetch(
+    T* ptr, const unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr = *ptr << val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_rshift_fetch(
+    T* ptr, const unsigned int val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr = *ptr >> val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#ifdef __NVCOMPILER
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_max_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+  tmp = atomicMax(ptr, val);
+  tmp = std::max(tmp, val);
+  return tmp;
+}
+#endif
+
+#ifdef __NVCOMPILER
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_min_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+  tmp = atomicMin(ptr, val);
+  tmp = std::min(tmp, val);
+  return tmp;
+}
+#endif
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_and_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr &= val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_or_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr |= val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_integral_type_v<T>, T> device_atomic_xor_fetch(
+    T* ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T tmp;
+#pragma acc atomic capture
+  {
+    *ptr ^= val;
+    tmp = *ptr;
+  }
+  return tmp;
+}
+//</editor-fold>
+
+//<editor-fold desc="device_atomic_{store,load}">
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, void> device_atomic_store(
+    T* const ptr, const T val, MemoryOrderRelaxed, MemoryScopeDevice) {
+#pragma acc atomic write
+  *ptr = val;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, void> device_atomic_store(
+    T* const ptr, const T val, MemoryOrderRelease, MemoryScopeDevice) {
+  if (acc_on_device(acc_device_not_host)) {
+    printf(
+        "DESUL error in device_atomic_store(MemoryOrderRelease): Not supported atomic "
+        "operation in the OpenACC backend\n");
+  }
+#pragma acc atomic write
+  *ptr = val;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_load(
+    const T* const ptr, MemoryOrderRelaxed, MemoryScopeDevice) {
+  T retval;
+#pragma acc atomic read
+  retval = *ptr;
+  return retval;
+}
+
+#pragma acc routine seq
+template <class T>
+std::enable_if_t<is_openacc_arithmetic_type_v<T>, T> device_atomic_load(
+    const T* const ptr, MemoryOrderAcquire, MemoryScopeDevice) {
+  if (acc_on_device(acc_device_not_host)) {
+    printf(
+        "DESUL error in device_atomic_load(MemoryOrderAcquire): Not supported atomic "
+        "operation in the OpenACC backend\n");
+  }
+  T retval;
+#pragma acc atomic read
+  retval = *ptr;
+  return retval;
+}
+//</editor-fold>
+
+}  // namespace Impl
+}  // namespace desul
+
+#endif
diff --git a/tpls/desul/include/desul/atomics/Generic.hpp b/tpls/desul/include/desul/atomics/Generic.hpp
index fef10222e3..fa71477c29 100644
--- a/tpls/desul/include/desul/atomics/Generic.hpp
+++ b/tpls/desul/include/desul/atomics/Generic.hpp
@@ -18,11 +18,14 @@ SPDX-License-Identifier: (BSD-3-Clause)
 
 namespace desul {
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_thread_fence(MemoryOrder order, MemoryScope scope) {
   DESUL_IF_ON_DEVICE(return Impl::device_atomic_thread_fence(order, scope);)
   DESUL_IF_ON_HOST(return Impl::host_atomic_thread_fence(order, scope);)
 }
+
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_exchange(T* dest, T val, MemoryOrder order, MemoryScope scope) {
@@ -30,6 +33,7 @@ atomic_exchange(T* dest, T val, MemoryOrder order, MemoryScope scope) {
   DESUL_IF_ON_HOST(return Impl::host_atomic_exchange(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_compare_exchange(T* dest, T cmp, T val, MemoryOrder order, MemoryScope scope) {
@@ -40,6 +44,7 @@ atomic_compare_exchange(T* dest, T cmp, T val, MemoryOrder order, MemoryScope sc
 }
 
 // Fetch_Oper atomics: return value before operation
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_add(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -47,6 +52,7 @@ atomic_fetch_add(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_add(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_sub(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -54,6 +60,7 @@ atomic_fetch_sub(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_sub(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_max(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -61,6 +68,7 @@ atomic_fetch_max(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_max(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_min(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -68,6 +76,7 @@ atomic_fetch_min(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_min(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_mul(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -75,6 +84,7 @@ atomic_fetch_mul(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_mul(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_div(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -82,6 +92,7 @@ atomic_fetch_div(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_div(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_mod(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -89,6 +100,7 @@ atomic_fetch_mod(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_mod(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_and(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -96,6 +108,7 @@ atomic_fetch_and(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_and(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_or(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -103,6 +116,7 @@ atomic_fetch_or(T* const dest, const T val, MemoryOrder order, MemoryScope scope
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_or(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_xor(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -110,6 +124,7 @@ atomic_fetch_xor(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_xor(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_nand(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -117,6 +132,7 @@ atomic_fetch_nand(T* const dest, const T val, MemoryOrder order, MemoryScope sco
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_nand(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_fetch_lshift(T* const dest,
                                             const unsigned int val,
@@ -126,6 +142,7 @@ DESUL_INLINE_FUNCTION T atomic_fetch_lshift(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_lshift(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_fetch_rshift(T* const dest,
                                             const unsigned int val,
@@ -136,6 +153,7 @@ DESUL_INLINE_FUNCTION T atomic_fetch_rshift(T* const dest,
 }
 
 // Oper Fetch atomics: return value after operation
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_add_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -143,6 +161,7 @@ atomic_add_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_add_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_sub_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -150,6 +169,7 @@ atomic_sub_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_sub_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_max_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -157,6 +177,7 @@ atomic_max_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_max_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_min_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -164,6 +185,7 @@ atomic_min_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_min_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_mul_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -171,6 +193,7 @@ atomic_mul_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_mul_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_div_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -178,6 +201,7 @@ atomic_div_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_div_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_mod_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -185,6 +209,7 @@ atomic_mod_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_mod_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_and_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -192,6 +217,7 @@ atomic_and_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_and_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_or_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -199,6 +225,7 @@ atomic_or_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope
   DESUL_IF_ON_HOST(return Impl::host_atomic_or_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_xor_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -206,6 +233,7 @@ atomic_xor_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scop
   DESUL_IF_ON_HOST(return Impl::host_atomic_xor_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_nand_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope scope) {
@@ -213,6 +241,7 @@ atomic_nand_fetch(T* const dest, const T val, MemoryOrder order, MemoryScope sco
   DESUL_IF_ON_HOST(return Impl::host_atomic_nand_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_lshift_fetch(T* const dest,
                                             const unsigned int val,
@@ -222,6 +251,7 @@ DESUL_INLINE_FUNCTION T atomic_lshift_fetch(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_lshift_fetch(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_rshift_fetch(T* const dest,
                                             const unsigned int val,
@@ -233,6 +263,7 @@ DESUL_INLINE_FUNCTION T atomic_rshift_fetch(T* const dest,
 
 // Other atomics
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_load(const T* const dest,
                                     MemoryOrder order,
@@ -241,6 +272,7 @@ DESUL_INLINE_FUNCTION T atomic_load(const T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_load(dest, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_store(T* const dest,
                                         const T val,
@@ -250,6 +282,7 @@ DESUL_INLINE_FUNCTION void atomic_store(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_store(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_add(T* const dest,
                                       const T val,
@@ -259,6 +292,7 @@ DESUL_INLINE_FUNCTION void atomic_add(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_add(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_sub(T* const dest,
                                       const T val,
@@ -268,6 +302,7 @@ DESUL_INLINE_FUNCTION void atomic_sub(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_sub(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_mul(T* const dest,
                                       const T val,
@@ -277,6 +312,7 @@ DESUL_INLINE_FUNCTION void atomic_mul(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_mul(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_div(T* const dest,
                                       const T val,
@@ -286,6 +322,7 @@ DESUL_INLINE_FUNCTION void atomic_div(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_div(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_min(T* const dest,
                                       const T val,
@@ -295,6 +332,7 @@ DESUL_INLINE_FUNCTION void atomic_min(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_min(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_max(T* const dest,
                                       const T val,
@@ -304,6 +342,7 @@ DESUL_INLINE_FUNCTION void atomic_max(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_max(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_inc_fetch(T* const dest,
                                          MemoryOrder order,
@@ -312,6 +351,7 @@ DESUL_INLINE_FUNCTION T atomic_inc_fetch(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_inc_fetch(dest, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_dec_fetch(T* const dest,
                                          MemoryOrder order,
@@ -320,6 +360,7 @@ DESUL_INLINE_FUNCTION T atomic_dec_fetch(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_dec_fetch(dest, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_fetch_inc(T* const dest,
                                          MemoryOrder order,
@@ -328,6 +369,7 @@ DESUL_INLINE_FUNCTION T atomic_fetch_inc(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_inc(dest, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_inc_mod(T* const dest, T val, MemoryOrder order, MemoryScope scope) {
@@ -335,6 +377,7 @@ atomic_fetch_inc_mod(T* const dest, T val, MemoryOrder order, MemoryScope scope)
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_inc_mod(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T atomic_fetch_dec(T* const dest,
                                          MemoryOrder order,
@@ -343,6 +386,7 @@ DESUL_INLINE_FUNCTION T atomic_fetch_dec(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_dec(dest, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION T
 atomic_fetch_dec_mod(T* const dest, T val, MemoryOrder order, MemoryScope scope) {
@@ -350,6 +394,7 @@ atomic_fetch_dec_mod(T* const dest, T val, MemoryOrder order, MemoryScope scope)
   DESUL_IF_ON_HOST(return Impl::host_atomic_fetch_dec_mod(dest, val, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_inc(T* const dest,
                                       MemoryOrder order,
@@ -358,6 +403,7 @@ DESUL_INLINE_FUNCTION void atomic_inc(T* const dest,
   DESUL_IF_ON_HOST(return Impl::host_atomic_inc(dest, order, scope);)
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T, class MemoryOrder, class MemoryScope>
 DESUL_INLINE_FUNCTION void atomic_dec(T* const dest,
                                       MemoryOrder order,
@@ -367,6 +413,7 @@ DESUL_INLINE_FUNCTION void atomic_dec(T* const dest,
 }
 
 // FIXME
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T,
           class SuccessMemoryOrder,
           class FailureMemoryOrder,
@@ -387,6 +434,7 @@ DESUL_INLINE_FUNCTION bool atomic_compare_exchange_strong(
   }
 }
 
+DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
 template <class T,
           class SuccessMemoryOrder,
           class FailureMemoryOrder,
diff --git a/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp b/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp
index 8216f9a797..e1170ed2aa 100644
--- a/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp
+++ b/tpls/desul/include/desul/atomics/Lock_Array_SYCL.hpp
@@ -57,14 +57,35 @@ 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.
+ * When relocatable device code is enabled, 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 then be extern). This one
+ * instance will be initialized by initialize_host_sycl_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_SYCL_Locks.cpp translation unit cannot initialize the instances in other
+ * translation units, we must update this SYCL global variable based on the Host global
+ * variable prior to running any kernels that will use it. That is the purpose of the
+ * ensure_sycl_lock_arrays_on_device function.
  */
-SYCL_EXTERNAL extern sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_DEVICE;
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
+SYCL_EXTERNAL extern
+#else
+static
+#endif
+    sycl_device_global<int32_t*>
+        SYCL_SPACE_ATOMIC_LOCKS_DEVICE;
 
-SYCL_EXTERNAL extern sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_NODE;
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
+SYCL_EXTERNAL extern
+#else
+static
+#endif
+    sycl_device_global<int32_t*>
+        SYCL_SPACE_ATOMIC_LOCKS_NODE;
 
 #define SYCL_SPACE_ATOMIC_MASK 0x1FFFF
 
@@ -128,6 +149,34 @@ inline void unlock_address_sycl(void* ptr, MemoryScopeNode) {
   lock_node_ref.exchange(0);
 }
 
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
+inline
+#else
+inline static
+#endif
+    void
+    copy_sycl_lock_arrays_to_device(sycl::queue q) {
+  static bool once = [&q]() {
+#ifdef SYCL_EXT_ONEAPI_DEVICE_GLOBAL
+    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*));
+#else
+    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;
+    });
+#endif
+    return true;
+  }();
+  (void)once;
+}
+
 #else  // not supported
 
 template <typename /*AlwaysInt*/ = int>
@@ -155,7 +204,26 @@ inline bool lock_address_sycl(void*, MemoryScopeNode) {
 inline void unlock_address_sycl(void*, MemoryScopeDevice) { assert(false); }
 
 inline void unlock_address_sycl(void*, MemoryScopeNode) { assert(false); }
+
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
+inline
+#else
+inline static
+#endif
+    void
+    copy_sycl_lock_arrays_to_device(sycl::queue) {
+}
+
 #endif
 }  // namespace Impl
+
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
+inline void ensure_sycl_lock_arrays_on_device(sycl::queue) {}
+#else
+static inline void ensure_sycl_lock_arrays_on_device(sycl::queue q) {
+  Impl::copy_sycl_lock_arrays_to_device(q);
+}
+#endif
+
 }  // 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 cb97f4a906..b6a399100b 100644
--- a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op.hpp
+++ b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op.hpp
@@ -17,6 +17,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifdef DESUL_HAVE_HIP_ATOMICS
 #include <desul/atomics/Lock_Based_Fetch_Op_HIP.hpp>
 #endif
+#ifdef DESUL_HAVE_OPENACC_ATOMICS
+#include <desul/atomics/Lock_Based_Fetch_Op_OpenACC.hpp>
+#endif
 #ifdef DESUL_HAVE_SYCL_ATOMICS
 #include <desul/atomics/Lock_Based_Fetch_Op_SYCL.hpp>
 #endif
diff --git a/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_OpenACC.hpp b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_OpenACC.hpp
new file mode 100644
index 0000000000..d4dd74588b
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Lock_Based_Fetch_Op_OpenACC.hpp
@@ -0,0 +1,81 @@
+/*
+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_OPENACC_HPP_
+#define DESUL_ATOMICS_LOCK_BASED_FETCH_OP_OPENACC_HPP_
+
+#include <desul/atomics/Common.hpp>
+#include <desul/atomics/Lock_Array.hpp>
+#include <desul/atomics/Thread_Fence.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>
+inline T device_atomic_fetch_oper(const Oper& op,
+                                  T* const dest,
+                                  dont_deduce_this_parameter_t<const T> val,
+                                  MemoryOrder /*order*/,
+                                  MemoryScope scope) {
+  if (acc_on_device(acc_device_not_host)) {
+    printf(
+        "DESUL error in device_atomic_fetch_oper(): Not supported atomic operation in "
+        "the OpenACC backend\n");
+  }
+  // Acquire a lock for the address
+  while (!lock_address((void*)dest, scope)) {
+  }
+
+  device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+  T return_val = *dest;
+  *dest = op.apply(return_val, val);
+  device_atomic_thread_fence(MemoryOrderRelease(), scope);
+  unlock_address((void*)dest, scope);
+  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>
+inline T device_atomic_oper_fetch(const Oper& op,
+                                  T* const dest,
+                                  dont_deduce_this_parameter_t<const T> val,
+                                  MemoryOrder /*order*/,
+                                  MemoryScope scope) {
+  if (acc_on_device(acc_device_not_host)) {
+    printf(
+        "DESUL error in device_atomic_oper_fetch(): Not supported atomic operation in "
+        "the OpenACC backend\n");
+  }
+  // Acquire a lock for the address
+  while (!lock_address((void*)dest, scope)) {
+  }
+
+  device_atomic_thread_fence(MemoryOrderAcquire(), scope);
+  T return_val = op.apply(*dest, val);
+  *dest = return_val;
+  device_atomic_thread_fence(MemoryOrderRelease(), scope);
+  unlock_address((void*)dest, scope);
+  return return_val;
+}
+
+}  // namespace Impl
+}  // namespace desul
+
+#endif
diff --git a/tpls/desul/include/desul/atomics/Macros.hpp b/tpls/desul/include/desul/atomics/Macros.hpp
index 3a14b93d32..d11beb0c80 100644
--- a/tpls/desul/include/desul/atomics/Macros.hpp
+++ b/tpls/desul/include/desul/atomics/Macros.hpp
@@ -57,6 +57,10 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #define DESUL_HAVE_OPENMP_ATOMICS
 #endif
 
+#if defined(DESUL_ATOMICS_ENABLE_OPENACC)
+#define DESUL_HAVE_OPENACC_ATOMICS
+#endif
+
 // ONLY use GNUC atomics if not explicitly say to use OpenMP atomics
 #if !defined(DESUL_HAVE_OPENMP_ATOMICS) && defined(__GNUC__)
 #define DESUL_HAVE_GCC_ATOMICS
@@ -123,6 +127,30 @@ static constexpr bool desul_impl_omp_on_host() { return false; }
 #endif
 #endif
 
+#if defined(DESUL_HAVE_OPENACC_ATOMICS)
+#include <openacc.h>
+#ifdef __NVCOMPILER
+// FIXME_OPENACC We cannot determine in a constant expresion whether we are on host or
+// on device with NVHPC.  We use the device implementation on both sides.
+#define DESUL_IF_ON_DEVICE(CODE) \
+  { DESUL_IMPL_STRIP_PARENS(CODE) }
+#define DESUL_IF_ON_HOST(CODE) \
+  {}
+#else
+#define DESUL_IF_ON_DEVICE(CODE)                      \
+  if constexpr (acc_on_device(acc_device_not_host)) { \
+    DESUL_IMPL_STRIP_PARENS(CODE)                     \
+  }
+#define DESUL_IF_ON_HOST(CODE)                    \
+  if constexpr (acc_on_device(acc_device_host)) { \
+    DESUL_IMPL_STRIP_PARENS(CODE)                 \
+  }
+#endif
+#define DESUL_IMPL_ACC_ROUTINE_DIRECTIVE _Pragma("acc routine seq")
+#else
+#define DESUL_IMPL_ACC_ROUTINE_DIRECTIVE
+#endif
+
 #if !defined(DESUL_IF_ON_HOST) && !defined(DESUL_IF_ON_DEVICE)
 #if (defined(DESUL_ATOMICS_ENABLE_CUDA) && defined(__CUDA_ARCH__)) ||         \
     (defined(DESUL_ATOMICS_ENABLE_HIP) && defined(__HIP_DEVICE_COMPILE__)) || \
diff --git a/tpls/desul/include/desul/atomics/Operator_Function_Objects.hpp b/tpls/desul/include/desul/atomics/Operator_Function_Objects.hpp
index be90cdbbd8..1f5159c4f8 100644
--- a/tpls/desul/include/desul/atomics/Operator_Function_Objects.hpp
+++ b/tpls/desul/include/desul/atomics/Operator_Function_Objects.hpp
@@ -18,7 +18,7 @@ namespace desul {
 namespace Impl {
 
 template <class Scalar1, class Scalar2>
-struct max_operator {
+struct max_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return (val1 > val2 ? val1 : val2);
@@ -30,7 +30,7 @@ struct max_operator {
 };
 
 template <class Scalar1, class Scalar2>
-struct min_operator {
+struct min_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return (val1 < val2 ? val1 : val2);
@@ -70,55 +70,55 @@ constexpr DESUL_FUNCTION
 }
 
 template <class Scalar1, class Scalar2>
-struct add_operator {
+struct add_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 + val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct sub_operator {
+struct sub_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 - val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct mul_operator {
+struct mul_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 * val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct div_operator {
+struct div_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 / val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct mod_operator {
+struct mod_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 % val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct and_operator {
+struct and_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 & val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct or_operator {
+struct or_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 | val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct xor_operator {
+struct xor_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) { return val1 ^ val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct nand_operator {
+struct nand_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return ~(val1 & val2);
@@ -126,7 +126,7 @@ struct nand_operator {
 };
 
 template <class Scalar1, class Scalar2>
-struct lshift_operator {
+struct lshift_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return val1 << val2;
@@ -134,7 +134,7 @@ struct lshift_operator {
 };
 
 template <class Scalar1, class Scalar2>
-struct rshift_operator {
+struct rshift_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return val1 >> val2;
@@ -142,7 +142,7 @@ struct rshift_operator {
 };
 
 template <class Scalar1, class Scalar2>
-struct inc_mod_operator {
+struct inc_mod_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return ((val1 >= val2) ? Scalar1(0) : val1 + Scalar1(1));
@@ -150,7 +150,7 @@ struct inc_mod_operator {
 };
 
 template <class Scalar1, class Scalar2>
-struct dec_mod_operator {
+struct dec_mod_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2& val2) {
     return (((val1 == Scalar1(0)) | (val1 > val2)) ? val2 : (val1 - Scalar1(1)));
@@ -158,13 +158,13 @@ struct dec_mod_operator {
 };
 
 template <class Scalar1, class Scalar2>
-struct store_operator {
+struct store_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1&, const Scalar2& val2) { return val2; }
 };
 
 template <class Scalar1, class Scalar2>
-struct load_operator {
+struct load_fetch_operator {
   DESUL_FORCEINLINE_FUNCTION
   static Scalar1 apply(const Scalar1& val1, const Scalar2&) { return val1; }
 };
diff --git a/tpls/desul/include/desul/atomics/Thread_Fence.hpp b/tpls/desul/include/desul/atomics/Thread_Fence.hpp
index 24078aae07..6a741f6d47 100644
--- a/tpls/desul/include/desul/atomics/Thread_Fence.hpp
+++ b/tpls/desul/include/desul/atomics/Thread_Fence.hpp
@@ -26,6 +26,9 @@ SPDX-License-Identifier: (BSD-3-Clause)
 #ifdef DESUL_HAVE_OPENMP_ATOMICS
 #include <desul/atomics/Thread_Fence_OpenMP.hpp>
 #endif
+#ifdef DESUL_HAVE_OPENACC_ATOMICS
+#include <desul/atomics/Thread_Fence_OpenACC.hpp>
+#endif
 #ifdef DESUL_HAVE_SYCL_ATOMICS
 #include <desul/atomics/Thread_Fence_SYCL.hpp>
 #endif
diff --git a/tpls/desul/include/desul/atomics/Thread_Fence_OpenACC.hpp b/tpls/desul/include/desul/atomics/Thread_Fence_OpenACC.hpp
new file mode 100644
index 0000000000..a5c8aa1c8a
--- /dev/null
+++ b/tpls/desul/include/desul/atomics/Thread_Fence_OpenACC.hpp
@@ -0,0 +1,25 @@
+/*
+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_THREAD_FENCE_OPENACC_HPP_
+#define DESUL_ATOMICS_THREAD_FENCE_OPENACC_HPP_
+
+namespace desul {
+namespace Impl {
+
+#pragma acc routine seq
+template <class MemoryOrder, class MemoryScope>
+void device_atomic_thread_fence(MemoryOrder, MemoryScope) {
+  // FIXME_OPENACC: The current OpenACC standard does not support explicit thread fence
+  // operations.
+}
+
+}  // namespace Impl
+}  // namespace desul
+
+#endif
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_forceglobal b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_forceglobal
deleted file mode 100644
index b235163820..0000000000
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_forceglobal
+++ /dev/null
@@ -1,153 +0,0 @@
-
-// Inline PTX: h u16 , r u32,  l u64, f f32, d f64
-// Ops:
-
-// binary operations
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND() \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==4, ctype>::type atomic_fetch_and(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint32_t asm_value = reinterpret_cast<uint32_t&>(value); \
-  uint32_t asm_result = 0u; \
-  asm volatile("atom.and.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b32" " %0,[%1],%2;" : "=r"(asm_result) : "l"(dest),"r"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-} \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==8, ctype>::type atomic_fetch_and(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint64_t asm_value = reinterpret_cast<uint64_t&>(value); \
-  uint64_t asm_result = 0u; \
-  asm volatile("atom.and.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b64" " %0,[%1],%2;" : "=l"(asm_result) : "l"(dest),"l"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_OR() \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==4, ctype>::type atomic_fetch_or(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint32_t asm_value = reinterpret_cast<uint32_t&>(value); \
-  uint32_t asm_result = 0u; \
-  asm volatile("atom.or.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b32" " %0,[%1],%2;" : "=r"(asm_result) : "l"(dest),"r"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-} \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==8, ctype>::type atomic_fetch_or(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint64_t asm_value = reinterpret_cast<uint64_t&>(value); \
-  uint64_t asm_result = 0u; \
-  asm volatile("atom.or.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b64" " %0,[%1],%2;" : "=l"(asm_result) : "l"(dest),"l"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_XOR() \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==4, ctype>::type atomic_fetch_xor(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint32_t asm_value = reinterpret_cast<uint32_t&>(value); \
-  uint32_t asm_result = 0u; \
-  asm volatile("atom.xor.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b32" " %0,[%1],%2;" : "=r"(asm_result) : "l"(dest),"r"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-} \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==8, ctype>::type atomic_fetch_xor(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint64_t asm_value = reinterpret_cast<uint64_t&>(value); \
-  uint64_t asm_result = 0u; \
-  asm volatile("atom.xor.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b64" " %0,[%1],%2;" : "=l"(asm_result) : "l"(dest),"l"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-}
-
-// Fetch atomics
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_add(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  asm volatile("atom.add.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_sub(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  ctype neg_value = -value; \
-  asm volatile("atom.add.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(neg_value) : "memory"); \
-  return result; \
-}
-
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_min(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  asm volatile("atom.min.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_max(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  asm volatile("atom.max.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_inc(ctype* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  ctype limit = desul::Impl::numeric_limits_max<ctype>::value; \
-  asm volatile("atom.inc.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-} \
-inline __device__ ctype atomic_fetch_inc_mod(ctype* dest, ctype limit, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  asm volatile("atom.inc.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_dec(ctype* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  ctype limit = desul::Impl::numeric_limits_max<ctype>::value; \
-  asm volatile("atom.dec.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-} \
-inline __device__ ctype atomic_fetch_dec_mod(ctype* dest, ctype limit, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  asm volatile("atom.dec.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-}
-
-// Group ops for integer ctypes
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP() \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND() \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_OR() \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_XOR()
-
-
-// Instantiate Functions
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(float,".f32","f","=f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(float,".f32","f","=f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(double,".f64","d","=d")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(double,".f64","d","=d")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint32_t,".u32","r","=r")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint64_t,".u64","l","=l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int32_t,".s32","r","=r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int64_t,".s64","l","=l")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(uint32_t,".u32","r","=r")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(uint32_t,".u32","r","=r")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP()
-
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND
-
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_generic b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_generic
deleted file mode 100644
index 0484d109c3..0000000000
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_generic
+++ /dev/null
@@ -1,151 +0,0 @@
-
-// Inline PTX: h u16 , r u32,  l u64, f f32, d f64
-// Ops: 
-
-// binary operations
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND() \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==4, ctype>::type atomic_fetch_and(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint32_t asm_value = reinterpret_cast<uint32_t&>(value); \
-  uint32_t asm_result = 0u; \
-  asm volatile("atom.and" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b32" " %0,[%1],%2;" : "=r"(asm_result) : "l"(dest),"r"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-} \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==8, ctype>::type atomic_fetch_and(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint64_t asm_value = reinterpret_cast<uint64_t&>(value); \
-  uint64_t asm_result = 0u; \
-  asm volatile("atom.and" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b64" " %0,[%1],%2;" : "=l"(asm_result) : "l"(dest),"l"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_OR() \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==4, ctype>::type atomic_fetch_or(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint32_t asm_value = reinterpret_cast<uint32_t&>(value); \
-  uint32_t asm_result = 0u; \
-  asm volatile("atom.or" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b32" " %0,[%1],%2;" : "=r"(asm_result) : "l"(dest),"r"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-} \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==8, ctype>::type atomic_fetch_or(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint64_t asm_value = reinterpret_cast<uint64_t&>(value); \
-  uint64_t asm_result = 0u; \
-  asm volatile("atom.or" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b64" " %0,[%1],%2;" : "=l"(asm_result) : "l"(dest),"l"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_XOR() \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==4, ctype>::type atomic_fetch_xor(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint32_t asm_value = reinterpret_cast<uint32_t&>(value); \
-  uint32_t asm_result = 0u; \
-  asm volatile("atom.xor" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b32" " %0,[%1],%2;" : "=r"(asm_result) : "l"(dest),"r"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-} \
-template<class ctype> \
-inline __device__ typename std::enable_if<sizeof(ctype)==8, ctype>::type atomic_fetch_xor(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  uint64_t asm_value = reinterpret_cast<uint64_t&>(value); \
-  uint64_t asm_result = 0u; \
-  asm volatile("atom.xor" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM ".b64" " %0,[%1],%2;" : "=l"(asm_result) : "l"(dest),"l"(asm_value) : "memory"); \
-  return reinterpret_cast<ctype&>(asm_result); \
-}
-
-// Fetch atomics
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_add(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  asm volatile("atom.add" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_sub(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  ctype neg_value = -value; \
-  asm volatile("atom.add" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(neg_value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_min(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  asm volatile("atom.min" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_max(ctype* dest, ctype value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result=0; \
-  asm volatile("atom.max" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(value) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_inc(ctype* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  ctype limit = desul::Impl::numeric_limits_max<ctype>::value; \
-  asm volatile("atom.inc" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-} \
-inline __device__ ctype atomic_fetch_inc_mod(ctype* dest, ctype limit, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  asm volatile("atom.inc" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-inline __device__ ctype atomic_fetch_dec(ctype* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  ctype limit = desul::Impl::numeric_limits_max<ctype>::value; \
-  asm volatile("atom.dec" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-} \
-inline __device__ ctype atomic_fetch_dec_mod(ctype* dest, ctype limit, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  ctype result = 0; \
-  asm volatile("atom.dec" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_ctype " %0,[%1],%2;" : reg_ret_ctype(result) : "l"(dest),reg_ctype(limit) : "memory"); \
-  return result; \
-}
-// Group ops for integer ctypes
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP() \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND() \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_OR() \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_XOR()
-
-
-// Instantiate Functions
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(float,".f32","f","=f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(float,".f32","f","=f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(double,".f64","d","=d")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(double,".f64","d","=d")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint32_t,".u32","r","=r")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint64_t,".u64","l","=l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int32_t,".s32","r","=r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int64_t,".s64","l","=l")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(uint32_t,".u32","r","=r")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(uint32_t,".u32","r","=r")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP()
-
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC
-#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND
-
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_isglobal b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_isglobal
index ef5798f211..dd359405b5 100644
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_isglobal
+++ b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_isglobal
@@ -164,39 +164,56 @@ inline __device__ ctype device_atomic_fetch_dec_mod(ctype* dest, ctype limit, __
   return result; \
 }
 
-// Group ops for integer ctypes
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
 #define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP() \
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND() \
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_OR() \
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_XOR()
 
-
 // Instantiate Functions
+
+// General comments:
+//  - float/double only support add
+//  - inc/dec only supported with uint32_t
+//  - int64_t does not support add
+
+// floating point types
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(float,".f32","f","=f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(float,".f32","f","=f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(double,".f64","d","=d")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(double,".f64","d","=d")
 
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint32_t,".u32","r","=r")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint64_t,".u64","l","=l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int32_t,".s32","r","=r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int64_t,".s64","l","=l")
-
+// uint32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(uint32_t,".u32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(uint32_t,".u32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(uint32_t,".u32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(uint32_t,".u32","r","=r")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(uint32_t,".u32","r","=r")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(uint32_t,".u32","r","=r")
 
+// uint64_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(uint64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(uint64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(uint64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(uint64_t,".u64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(uint64_t,".u64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(uint64_t,".u64","l","=l")
+
+// int32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(int32_t,".s32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(int32_t,".s32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(int32_t,".s32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(int32_t,".s32","r","=r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(int32_t,".s32","r","=r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(int32_t,".s32","r","=r")
+
+// int64_t note: add/sub is using unsigned register
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(int64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(int64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(int64_t,".s64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(int64_t,".s64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(int64_t,".s64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(int64_t,".s64","l","=l")
+
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP()
 
 #undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD
@@ -205,4 +222,4 @@ __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP()
 #undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC
 #undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC
 #undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND
-
+#undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_predicate b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_predicate
index c80efc5e7c..2c0fe9e132 100644
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_predicate
+++ b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_fetch_op.inc_predicate
@@ -206,19 +206,6 @@ inline __device__ ctype device_atomic_fetch_dec_mod(ctype* dest, ctype limit, __
   return result; \
 }
 
-// Group ops for integer ctypes
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(ctype,asm_ctype,reg_ctype,reg_ret_ctype) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(ctype,asm_ctype,reg_ctype,reg_ret_ctype)
-
 #define __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP() \
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_AND() \
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_OR() \
@@ -226,19 +213,50 @@ __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_XOR()
 
 
 // Instantiate Functions
+
+// General comments:
+//  - float/double only support add
+//  - inc/dec only supported with uint32_t
+//  - int64_t does not support add
+
+// floating point types
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(float,".f32","f","=f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(float,".f32","f","=f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(double,".f64","d","=d")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(double,".f64","d","=d")
 
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint32_t,".u32","r","=r")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_UNSIGNED_OP(uint64_t,".u64","l","=l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int32_t,".s32","r","=r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INTEGER_OP(int64_t,".s64","l","=l")
-
+// uint32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(uint32_t,".u32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(uint32_t,".u32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(uint32_t,".u32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(uint32_t,".u32","r","=r")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(uint32_t,".u32","r","=r")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(uint32_t,".u32","r","=r")
 
+// uint64_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(uint64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(uint64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(uint64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(uint64_t,".u64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(uint64_t,".u64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(uint64_t,".u64","l","=l")
+
+// int32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(int32_t,".s32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(int32_t,".s32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(int32_t,".s32","r","=r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(int32_t,".s32","r","=r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(int32_t,".s32","r","=r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(int32_t,".s32","r","=r")
+
+// int64_t note: add/sub is using unsigned register
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD(int64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_SUB(int64_t,".u64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MIN(int64_t,".s64","l","=l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_MAX(int64_t,".s64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_INC(int64_t,".s64","l","=l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_DEC(int64_t,".s64","l","=l")
+
 __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_BIN_OP()
 
 #undef __DESUL_IMPL_CUDA_ASM_ATOMIC_FETCH_ADD
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_forceglobal b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_forceglobal
deleted file mode 100644
index 3767b2ab49..0000000000
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_forceglobal
+++ /dev/null
@@ -1,64 +0,0 @@
-
-// Inline PTX: h u16 , r u32,  l u64, f f32, d f64
-// Ops:
-
-// Non Returning Atomic Operations
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-inline __device__ void atomic_add(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  asm volatile("red.add.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-inline __device__ void atomic_sub(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  type neg_value = -value; \
-  asm volatile("red.add.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(neg_value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-inline __device__ void atomic_min(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  asm volatile("red.min.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type) \
-inline __device__ void atomic_max(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  asm volatile("red.max.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_INC(type,asm_type,reg_type) \
-inline __device__ void atomic_inc(type* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  type limit = desul::Impl::numeric_limits_max<type>::value; \
-  asm volatile("red.inc.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(limit) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(type,asm_type,reg_type) \
-inline __device__ void atomic_dec(type* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  type limit = desul::Impl::numeric_limits_max<type>::value; \
-  asm volatile("red.dec.global" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(limit) : "memory"); \
-}
-
-// Group ops for integer types
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(type,asm_type,reg_type)
-
-// Instantiate Functions
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(float,".f32","f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(float,".f32","f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(double,".f64","d")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(double,".f64","d")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(uint32_t,".u32","r")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".u64","l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int32_t,".s32","r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".s64","l")
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_generic b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_generic
deleted file mode 100644
index 5de36a3e0a..0000000000
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_generic
+++ /dev/null
@@ -1,64 +0,0 @@
-
-// Inline PTX: h u16 , r u32,  l u64, f f32, d f64
-// Ops:
-
-// Non Returning Atomic Operations
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-inline __device__ void atomic_add(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  asm volatile("red.add" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-inline __device__ void atomic_sub(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  type neg_value = -value; \
-  asm volatile("red.add" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(neg_value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-inline __device__ void atomic_min(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  asm volatile("red.min" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type) \
-inline __device__ void atomic_max(type* dest, type value, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  asm volatile("red.max" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(value) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_INC(type,asm_type,reg_type) \
-inline __device__ void atomic_inc(type* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  type limit = desul::Impl::numeric_limits_max<type>::value; \
-  asm volatile("red.inc" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(limit) : "memory"); \
-}
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(type,asm_type,reg_type) \
-inline __device__ void atomic_dec(type* dest, __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER, __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE) { \
-  type limit = desul::Impl::numeric_limits_max<type>::value; \
-  asm volatile("red.dec" __DESUL_IMPL_CUDA_ASM_MEMORY_ORDER_ASM __DESUL_IMPL_CUDA_ASM_MEMORY_SCOPE_ASM asm_type " [%0],%1;" :: "l"(dest),reg_type(limit) : "memory"); \
-}
-
-// Group ops for integer types
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type)
-
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(type,asm_type,reg_type)
-
-// Instantiate Functions
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(float,".f32","f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(float,".f32","f")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(double,".f64","d")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(double,".f64","d")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(uint32_t,".u32","r")
-
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".u64","l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int32_t,".s32","r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".s64","l")
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_isglobal b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_isglobal
index 7bc6d4d9d1..6b6e3593fd 100644
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_isglobal
+++ b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_isglobal
@@ -60,29 +60,48 @@ inline __device__ void device_atomic_dec(type* dest, __DESUL_IMPL_CUDA_ASM_MEMOR
   } \
 }
 
-// Group ops for integer types
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type)
+// Instantiate Functions
 
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(type,asm_type,reg_type)
+// General comments:
+//  - float/double only support add
+//  - inc/dec only supported with uint32_t
+//  - int64_t does not support add
 
-// Instantiate Functions
+// floating point types
 __DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(float,".f32","f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(float,".f32","f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(double,".f64","d")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(double,".f64","d")
 
-__DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(uint32_t,".u32","r")
+// uint32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(uint32_t,".u32","r")
+
+// uint64_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(uint64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(uint64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(uint64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(uint64_t,".u64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(uint64_t,".u64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(uint64_t,".u64","l")
+
+// int32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(int32_t,".s32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(int32_t,".s32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(int32_t,".s32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(int32_t,".s32","r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(int32_t,".s32","r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(int32_t,".s32","r")
+
+// int64_t note: add/sub is using unsigned register
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(int64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(int64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(int64_t,".s64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(int64_t,".s64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(int64_t,".s64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(int64_t,".s64","l")
 
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".u64","l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int32_t,".s32","r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".s64","l")
diff --git a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_predicate b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_predicate
index 4ae8e46266..b9569faf1b 100644
--- a/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_predicate
+++ b/tpls/desul/include/desul/atomics/cuda/cuda_cc7_asm_atomic_op.inc_predicate
@@ -78,29 +78,48 @@ inline __device__ void device_atomic_dec(type* dest, __DESUL_IMPL_CUDA_ASM_MEMOR
     :: "l"(dest),reg_type(limit) : "memory"); \
 }
 
-// Group ops for integer types
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type)
+// Instantiate Functions
 
-#define __DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(type,asm_type,reg_type) \
-__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(type,asm_type,reg_type)
+// General comments:
+//  - float/double only support add
+//  - inc/dec only supported with uint32_t
+//  - int64_t does not support add
 
-// Instantiate Functions
+// floating point types
 __DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(float,".f32","f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(float,".f32","f")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(double,".f64","d")
 __DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(double,".f64","d")
 
-__DESUL_IMPL_CUDA_ASM_ATOMIC_UNSIGNED_OP(uint32_t,".u32","r")
+// uint32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(uint32_t,".u32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(uint32_t,".u32","r")
+
+// uint64_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(uint64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(uint64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(uint64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(uint64_t,".u64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(uint64_t,".u64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(uint64_t,".u64","l")
+
+// int32_t
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(int32_t,".s32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(int32_t,".s32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(int32_t,".s32","r")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(int32_t,".s32","r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(int32_t,".s32","r")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(int32_t,".s32","r")
+
+// int64_t note: add/sub are using unsigned register!
+__DESUL_IMPL_CUDA_ASM_ATOMIC_ADD(int64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_SUB(int64_t,".u64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MIN(int64_t,".s64","l")
+__DESUL_IMPL_CUDA_ASM_ATOMIC_MAX(int64_t,".s64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_INC(int64_t,".s64","l")
+//__DESUL_IMPL_CUDA_ASM_ATOMIC_DEC(int64_t,".s64","l")
 
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".u64","l")
-__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int32_t,".s32","r")
-//__DESUL_IMPL_CUDA_ASM_ATOMIC_INTEGER_OP(int64_t,".s64","l")
diff --git a/tpls/desul/src/Lock_Array_SYCL.cpp b/tpls/desul/src/Lock_Array_SYCL.cpp
index 9e84c60e41..6660c76e11 100644
--- a/tpls/desul/src/Lock_Array_SYCL.cpp
+++ b/tpls/desul/src/Lock_Array_SYCL.cpp
@@ -14,10 +14,12 @@ SPDX-License-Identifier: (BSD-3-Clause)
 
 namespace desul::Impl {
 
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
 SYCL_EXTERNAL
 sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_DEVICE;
 SYCL_EXTERNAL
 sycl_device_global<int32_t*> SYCL_SPACE_ATOMIC_LOCKS_NODE;
+#endif
 
 int32_t* SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h = nullptr;
 int32_t* SYCL_SPACE_ATOMIC_LOCKS_NODE_h = nullptr;
@@ -31,19 +33,7 @@ void init_lock_arrays_sycl<int>(sycl::queue 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;
-  });
+  copy_sycl_lock_arrays_to_device(q);
 
   q.memset(SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h,
            0,
@@ -63,7 +53,10 @@ void finalize_lock_arrays_sycl<int>(sycl::queue q) {
   sycl::free(SYCL_SPACE_ATOMIC_LOCKS_NODE_h, q);
   SYCL_SPACE_ATOMIC_LOCKS_DEVICE_h = nullptr;
   SYCL_SPACE_ATOMIC_LOCKS_NODE_h = nullptr;
+#ifdef DESUL_ATOMICS_ENABLE_SYCL_SEPARABLE_COMPILATION
+  copy_sycl_lock_arrays_to_device(q);
+#endif
 }
 
-} // namespace desul::Impl
+}  // namespace desul::Impl
 #endif
diff --git a/tpls/gtest/gtest/gtest-all.cc b/tpls/gtest/gtest/gtest-all.cc
index 9f340e0140..4a6c2e787a 100644
--- a/tpls/gtest/gtest/gtest-all.cc
+++ b/tpls/gtest/gtest/gtest-all.cc
@@ -11957,7 +11957,7 @@ static const char* GetCharWidthPrefix(unsigned char) {
   return "";
 }
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 static const char* GetCharWidthPrefix(char8_t) {
   return "u8";
 }
@@ -11981,7 +11981,7 @@ static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
   return PrintAsStringLiteralTo(ToChar32(c), os);
 }
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) {
   return PrintAsStringLiteralTo(ToChar32(c), os);
 }
@@ -12103,7 +12103,7 @@ void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
   UniversalPrintCharArray(begin, len, os);
 }
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 // Prints a (const) char8_t array of 'len' elements, starting at address
 // 'begin'.
 void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) {
@@ -12146,7 +12146,7 @@ void PrintCStringTo(const Char* s, ostream* os) {
 
 void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); }
 #endif
 
@@ -12240,7 +12240,7 @@ void PrintStringTo(const ::std::string& s, ostream* os) {
   }
 }
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
   PrintCharsAsStringTo(s.data(), s.size(), os);
 }
diff --git a/tpls/gtest/gtest/gtest.h b/tpls/gtest/gtest/gtest.h
index e7490573ac..2b34f3a606 100644
--- a/tpls/gtest/gtest/gtest.h
+++ b/tpls/gtest/gtest/gtest.h
@@ -2189,7 +2189,7 @@ inline bool IsUpper(char ch) {
 inline bool IsXDigit(char ch) {
   return isxdigit(static_cast<unsigned char>(ch)) != 0;
 }
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 inline bool IsXDigit(char8_t ch) {
   return isxdigit(static_cast<unsigned char>(ch)) != 0;
 }
@@ -4910,7 +4910,7 @@ class NeverThrown {
   class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
       : public parent_class {                                                 \
    public:                                                                    \
-    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() { (void)test_info_; }\
     ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
     GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
                                                            test_name));       \
@@ -5417,7 +5417,7 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
 #endif
@@ -5442,7 +5442,7 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
 
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
 #endif
@@ -5530,7 +5530,7 @@ GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
 inline void PrintTo(char16_t c, ::std::ostream* os) {
   PrintTo(ImplicitCast_<char32_t>(c), os);
 }
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 inline void PrintTo(char8_t c, ::std::ostream* os) {
   PrintTo(ImplicitCast_<char32_t>(c), os);
 }
@@ -5556,7 +5556,7 @@ inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
 inline void PrintTo(unsigned char* s, ::std::ostream* os) {
   PrintTo(ImplicitCast_<const void*>(s), os);
 }
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 // Overloads for u8 strings.
 GTEST_API_ void PrintTo(const char8_t* s, ::std::ostream* os);
 inline void PrintTo(char8_t* s, ::std::ostream* os) {
@@ -5608,7 +5608,7 @@ inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
 }
 
 // Overloads for ::std::u8string
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
 inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
   PrintU8StringTo(s, os);
@@ -5862,7 +5862,7 @@ void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
 GTEST_API_ void UniversalPrintArray(
     const char* begin, size_t len, ::std::ostream* os);
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 // This overload prints a (const) char8_t array compactly.
 GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
                                     ::std::ostream* os);
@@ -5951,7 +5951,7 @@ template <>
 class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
 };
 
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 template <>
 class UniversalTersePrinter<const char8_t*> {
  public:
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp b/tpls/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp
index 163ec5fa56..25389a2fa5 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/compressed_pair.hpp
@@ -1,46 +1,18 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
@@ -50,176 +22,174 @@
 #  include "no_unique_address.hpp"
 #endif
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 namespace detail {
 
 // For no unique address emulation, this is the case taken when neither are empty.
 // For real `[[no_unique_address]]`, this case is always taken.
-template <class _T, class _U, class _Enable = void> struct __compressed_pair {
-  _MDSPAN_NO_UNIQUE_ADDRESS _T __t_val;
-  _MDSPAN_NO_UNIQUE_ADDRESS _U __u_val;
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__first() noexcept { return __t_val; }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__first() const noexcept {
-    return __t_val;
+template <class _T1, class _T2, class _Enable = void> struct __compressed_pair {
+  _MDSPAN_NO_UNIQUE_ADDRESS _T1 __t1_val{};
+  _MDSPAN_NO_UNIQUE_ADDRESS _T2 __t2_val{};
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { return __t1_val; }
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
+    return __t1_val;
   }
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _U &__second() noexcept { return __u_val; }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _U const &__second() const noexcept {
-    return __u_val;
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { return __t2_val; }
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
+    return __t2_val;
   }
 
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair() noexcept = default;
+  constexpr __compressed_pair() = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair const &) noexcept = default;
+  operator=(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair &&) noexcept = default;
+  operator=(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__compressed_pair() noexcept = default;
-  template <class _TLike, class _ULike>
-  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u)
-      : __t_val((_TLike &&) __t), __u_val((_ULike &&) __u) {}
+  ~__compressed_pair() = default;
+  template <class _T1Like, class _T2Like>
+  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2)
+      : __t1_val((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {}
 };
 
 #if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
 
 // First empty.
-template <class _T, class _U>
+template <class _T1, class _T2>
 struct __compressed_pair<
-    _T, _U,
-    enable_if_t<_MDSPAN_TRAIT(is_empty, _T) && !_MDSPAN_TRAIT(is_empty, _U)>>
-    : private _T {
-  _U __u_val;
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__first() noexcept {
-    return *static_cast<_T *>(this);
+    _T1, _T2,
+    std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T1) && !_MDSPAN_TRAIT(std::is_empty, _T2)>>
+    : private _T1 {
+  _T2 __t2_val{};
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept {
+    return *static_cast<_T1 *>(this);
   }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__first() const noexcept {
-    return *static_cast<_T const *>(this);
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
+    return *static_cast<_T1 const *>(this);
   }
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _U &__second() noexcept { return __u_val; }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _U const &__second() const noexcept {
-    return __u_val;
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept { return __t2_val; }
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
+    return __t2_val;
   }
 
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair() noexcept = default;
+  constexpr __compressed_pair() = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair const &) noexcept = default;
+  operator=(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair &&) noexcept = default;
+  operator=(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__compressed_pair() noexcept = default;
-  template <class _TLike, class _ULike>
-  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u)
-      : _T((_TLike &&) __t), __u_val((_ULike &&) __u) {}
+  ~__compressed_pair() = default;
+  template <class _T1Like, class _T2Like>
+  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2)
+      : _T1((_T1Like &&) __t1), __t2_val((_T2Like &&) __t2) {}
 };
 
 // Second empty.
-template <class _T, class _U>
+template <class _T1, class _T2>
 struct __compressed_pair<
-    _T, _U,
-    enable_if_t<!_MDSPAN_TRAIT(is_empty, _T) && _MDSPAN_TRAIT(is_empty, _U)>>
-    : private _U {
-  _T __t_val;
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__first() noexcept { return __t_val; }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__first() const noexcept {
-    return __t_val;
+    _T1, _T2,
+    std::enable_if_t<!_MDSPAN_TRAIT(std::is_empty, _T1) && _MDSPAN_TRAIT(std::is_empty, _T2)>>
+    : private _T2 {
+  _T1 __t1_val{};
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept { return __t1_val; }
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
+    return __t1_val;
   }
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _U &__second() noexcept {
-    return *static_cast<_U *>(this);
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept {
+    return *static_cast<_T2 *>(this);
   }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _U const &__second() const noexcept {
-    return *static_cast<_U const *>(this);
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
+    return *static_cast<_T2 const *>(this);
   }
 
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair() noexcept = default;
+  constexpr __compressed_pair() = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair const &) noexcept = default;
+  operator=(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair &&) noexcept = default;
+  operator=(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__compressed_pair() noexcept = default;
+  ~__compressed_pair() = default;
 
-  template <class _TLike, class _ULike>
-  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u)
-      : _U((_ULike &&) __u), __t_val((_TLike &&) __t) {}
+  template <class _T1Like, class _T2Like>
+  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2)
+      : _T2((_T2Like &&) __t2), __t1_val((_T1Like &&) __t1) {}
 };
 
 // Both empty.
-template <class _T, class _U>
+template <class _T1, class _T2>
 struct __compressed_pair<
-    _T, _U,
-    enable_if_t<_MDSPAN_TRAIT(is_empty, _T) && _MDSPAN_TRAIT(is_empty, _U)>>
+    _T1, _T2,
+    std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T1) && _MDSPAN_TRAIT(std::is_empty, _T2)>>
     // We need to use the __no_unique_address_emulation wrapper here to avoid
     // base class ambiguities.
 #ifdef _MDSPAN_COMPILER_MSVC
 // MSVC doesn't allow you to access public static member functions of a type
 // when you *happen* to privately inherit from that type.
-    : protected __no_unique_address_emulation<_T, 0>,
-      protected __no_unique_address_emulation<_U, 1>
+    : protected __no_unique_address_emulation<_T1, 0>,
+      protected __no_unique_address_emulation<_T2, 1>
 #else
-    : private __no_unique_address_emulation<_T, 0>,
-      private __no_unique_address_emulation<_U, 1>
+    : private __no_unique_address_emulation<_T1, 0>,
+      private __no_unique_address_emulation<_T2, 1>
 #endif
 {
-  using __first_base_t = __no_unique_address_emulation<_T, 0>;
-  using __second_base_t = __no_unique_address_emulation<_U, 1>;
+  using __first_base_t = __no_unique_address_emulation<_T1, 0>;
+  using __second_base_t = __no_unique_address_emulation<_T2, 1>;
 
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T &__first() noexcept {
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T1 &__first() noexcept {
     return this->__first_base_t::__ref();
   }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T const &__first() const noexcept {
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T1 const &__first() const noexcept {
     return this->__first_base_t::__ref();
   }
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _U &__second() noexcept {
+  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _T2 &__second() noexcept {
     return this->__second_base_t::__ref();
   }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _U const &__second() const noexcept {
+  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T2 const &__second() const noexcept {
     return this->__second_base_t::__ref();
   }
 
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair() noexcept = default;
+  constexpr __compressed_pair() = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  constexpr __compressed_pair(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair const &) noexcept = default;
+  operator=(__compressed_pair const &) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   _MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
-  operator=(__compressed_pair &&) noexcept = default;
+  operator=(__compressed_pair &&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__compressed_pair() noexcept = default;
-  template <class _TLike, class _ULike>
-  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u) noexcept
-    : __first_base_t(_T((_TLike &&) __t)),
-      __second_base_t(_U((_ULike &&) __u))
+  ~__compressed_pair() = default;
+  template <class _T1Like, class _T2Like>
+  MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_T1Like &&__t1, _T2Like &&__t2) noexcept
+    : __first_base_t(_T1((_T1Like &&) __t1)),
+      __second_base_t(_T2((_T2Like &&) __t2))
   { }
 };
 
 #endif // !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
 
 } // end namespace detail
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/config.hpp b/tpls/mdspan/include/experimental/__p0009_bits/config.hpp
index 63cb63b9e9..24166462e7 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/config.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/config.hpp
@@ -1,46 +1,18 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #ifndef __has_include
@@ -63,10 +35,17 @@
 #define MDSPAN_CXX_STD_14 201402L
 #define MDSPAN_CXX_STD_17 201703L
 #define MDSPAN_CXX_STD_20 202002L
+// Note GCC has not updated this in version 13
+#ifdef __clang__
+#define MDSPAN_CXX_STD_23 202302L
+#else
+#define MDSPAN_CXX_STD_23 202100L
+#endif
 
 #define MDSPAN_HAS_CXX_14 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14)
 #define MDSPAN_HAS_CXX_17 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_17)
 #define MDSPAN_HAS_CXX_20 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_20)
+#define MDSPAN_HAS_CXX_23 (_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_23)
 
 static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or later.");
 
@@ -110,6 +89,12 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or
 #  endif
 #endif
 
+#ifndef _MDSPAN_HAS_SYCL
+#  if defined(SYCL_LANGUAGE_VERSION)
+#    define _MDSPAN_HAS_SYCL SYCL_LANGUAGE_VERSION
+#  endif
+#endif
+
 #ifndef __has_cpp_attribute
 #  define __has_cpp_attribute(x) 0
 #endif
@@ -143,11 +128,15 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or
 #  define _MDSPAN_NO_UNIQUE_ADDRESS
 #endif
 
+// AMDs HIP compiler seems to have issues with concepts
+// it pretends concepts exist, but doesn't ship <concept>
+#ifndef __HIPCC__
 #ifndef _MDSPAN_USE_CONCEPTS
 #  if defined(__cpp_concepts) && __cpp_concepts >= 201507L
 #    define _MDSPAN_USE_CONCEPTS 1
 #  endif
 #endif
+#endif
 
 #ifndef _MDSPAN_USE_FOLD_EXPRESSIONS
 #  if (defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603L) \
@@ -216,23 +205,13 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or
 #endif
 
 #ifndef _MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-// GCC 10's CTAD seems sufficiently broken to prevent its use.
-#  if (defined(_MDSPAN_COMPILER_CLANG) || !defined(__GNUC__) || __GNUC__ >= 11) \
-      && ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201703) \
-         || (!defined(__cpp_deduction_guides) && MDSPAN_HAS_CXX_17))
+#  if (!defined(__NVCC__) || (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10 >= 1170)) && \
+      ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201703) || \
+       (!defined(__cpp_deduction_guides) && MDSPAN_HAS_CXX_17))
 #    define _MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
 #  endif
 #endif
 
-#ifndef _MDSPAN_USE_ALIAS_TEMPLATE_ARGUMENT_DEDUCTION
-// GCC 10's CTAD seems sufficiently broken to prevent its use.
-#  if (defined(_MDSPAN_COMPILER_CLANG) || !defined(__GNUC__) || __GNUC__ >= 11) \
-      && ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201907) \
-          || (!defined(__cpp_deduction_guides) && MDSPAN_HAS_CXX_20))
-#    define _MDSPAN_USE_ALIAS_TEMPLATE_ARGUMENT_DEDUCTION 1
-#  endif
-#endif
-
 #ifndef _MDSPAN_USE_STANDARD_TRAIT_ALIASES
 #  if (defined(__cpp_lib_transformation_trait_aliases) && __cpp_lib_transformation_trait_aliases >= 201304) \
           || (!defined(__cpp_lib_transformation_trait_aliases) && MDSPAN_HAS_CXX_14)
@@ -252,7 +231,7 @@ static_assert(_MDSPAN_CPLUSPLUS >= MDSPAN_CXX_STD_14, "mdspan requires C++14 or
 #endif
 
 #ifndef MDSPAN_CONDITIONAL_EXPLICIT
-#  if MDSPAN_HAS_CXX_20 && !defined(_MDSPAN_COMPILER_MSVC)
+#  if MDSPAN_HAS_CXX_20
 #    define MDSPAN_CONDITIONAL_EXPLICIT(COND) explicit(COND)
 #  else
 #    define MDSPAN_CONDITIONAL_EXPLICIT(COND)
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/default_accessor.hpp b/tpls/mdspan/include/experimental/__p0009_bits/default_accessor.hpp
index d26a7e6dad..ea0f537b2f 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/default_accessor.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/default_accessor.hpp
@@ -1,54 +1,25 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
 
 #include <cstddef> // size_t
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 template <class ElementType>
 struct default_accessor {
@@ -63,7 +34,7 @@ struct default_accessor {
   MDSPAN_TEMPLATE_REQUIRES(
     class OtherElementType,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, OtherElementType(*)[], element_type(*)[])
+      _MDSPAN_TRAIT(std::is_convertible, OtherElementType(*)[], element_type(*)[])
     )
   )
   MDSPAN_INLINE_FUNCTION
@@ -82,5 +53,4 @@ struct default_accessor {
 
 };
 
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp b/tpls/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp
index 206540292d..2e29da13d6 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/dynamic_extent.hpp
@@ -1,73 +1,35 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
 
+#if defined(__cpp_lib_span)
+#include <span>
+#endif
+
 #include <cstddef>  // size_t
 #include <limits>   // numeric_limits
 
-namespace std {
-namespace experimental {
-
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+#if defined(__cpp_lib_span)
+using std::dynamic_extent;
+#else
 _MDSPAN_INLINE_VARIABLE constexpr auto dynamic_extent = std::numeric_limits<size_t>::max();
-
-namespace detail {
-
-template <class>
-constexpr auto __make_dynamic_extent() {
-  return dynamic_extent;
-}
-
-template <size_t>
-constexpr auto __make_dynamic_extent_integral() {
-  return dynamic_extent;
-}
-
-} // end namespace detail
-
-} // end namespace experimental
-} // namespace std
+#endif
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
 //==============================================================================================================
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/extents.hpp b/tpls/mdspan/include/experimental/__p0009_bits/extents.hpp
index ce562ed7e2..d58d37732d 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/extents.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/extents.hpp
@@ -1,543 +1,693 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
 
 #pragma once
+#include "dynamic_extent.hpp"
+#include "utility.hpp"
 
-#include "macros.hpp"
-#include "static_array.hpp"
-#include "standard_layout_static_array.hpp"
-#include "trait_backports.hpp" // integer_sequence, etc.
-
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-#  include "no_unique_address.hpp"
+#ifdef __cpp_lib_span
+#include <span>
 #endif
-
 #include <array>
-#include <cstddef>
+#include <type_traits>
 
-namespace std {
-namespace experimental {
+#include <cassert>
+#include <cinttypes>
 
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 namespace detail {
 
-template<size_t ... Extents>
-struct _count_dynamic_extents;
+// Function used to check compatibility of extents in converting constructor
+// can't be a private member function for some reason.
+template <size_t... Extents, size_t... OtherExtents>
+MDSPAN_INLINE_FUNCTION
+static constexpr std::integral_constant<bool, false> __check_compatible_extents(
+    std::integral_constant<bool, false>,
+    std::integer_sequence<size_t, Extents...>,
+    std::integer_sequence<size_t, OtherExtents...>) noexcept {
+  return {};
+}
+
+// This helper prevents ICE's on MSVC.
+template <size_t Lhs, size_t Rhs>
+struct __compare_extent_compatible : std::integral_constant<bool,
+     Lhs == dynamic_extent ||
+     Rhs == dynamic_extent ||
+     Lhs == Rhs>
+{};
 
-template<size_t E, size_t ... Extents>
-struct _count_dynamic_extents<E,Extents...> {
-  static constexpr size_t val = (E==dynamic_extent?1:0) + _count_dynamic_extents<Extents...>::val;
+template <size_t... Extents, size_t... OtherExtents>
+MDSPAN_INLINE_FUNCTION
+static constexpr std::integral_constant<
+    bool, _MDSPAN_FOLD_AND(__compare_extent_compatible<Extents, OtherExtents>::value)>
+__check_compatible_extents(
+    std::integral_constant<bool, true>,
+    std::integer_sequence<size_t, Extents...>,
+    std::integer_sequence<size_t, OtherExtents...>) noexcept {
+  return {};
+}
+
+template<class IndexType, class ... Arguments>
+MDSPAN_INLINE_FUNCTION
+static constexpr bool are_valid_indices() {
+    return
+      _MDSPAN_FOLD_AND(std::is_convertible<Arguments, IndexType>::value) &&
+      _MDSPAN_FOLD_AND(std::is_nothrow_constructible<IndexType, Arguments>::value);
+}
+
+// ------------------------------------------------------------------
+// ------------ static_array ----------------------------------------
+// ------------------------------------------------------------------
+
+// array like class which provides an array of static values with get
+// function and operator [].
+
+// Implementation of Static Array with recursive implementation of get.
+template <size_t R, class T, T... Extents> struct static_array_impl;
+
+template <size_t R, class T, T FirstExt, T... Extents>
+struct static_array_impl<R, T, FirstExt, Extents...> {
+  MDSPAN_INLINE_FUNCTION
+  constexpr static T get(size_t r) {
+    if (r == R)
+      return FirstExt;
+    else
+      return static_array_impl<R + 1, T, Extents...>::get(r);
+  }
+  template <size_t r> MDSPAN_INLINE_FUNCTION constexpr static T get() {
+#if MDSPAN_HAS_CXX_17
+    if constexpr (r == R)
+      return FirstExt;
+    else
+      return static_array_impl<R + 1, T, Extents...>::template get<r>();
+#else
+    get(r);
+#endif
+  }
 };
 
-template<>
-struct _count_dynamic_extents<> {
-  static constexpr size_t val = 0;
+// End the recursion
+template <size_t R, class T, T FirstExt>
+struct static_array_impl<R, T, FirstExt> {
+  MDSPAN_INLINE_FUNCTION
+  constexpr static T get(size_t) { return FirstExt; }
+  template <size_t> MDSPAN_INLINE_FUNCTION constexpr static T get() {
+    return FirstExt;
+  }
 };
 
-template <size_t... Extents, size_t... OtherExtents>
-static constexpr std::false_type _check_compatible_extents(
-  std::false_type, std::integer_sequence<size_t, Extents...>, std::integer_sequence<size_t, OtherExtents...>
-) noexcept { return { }; }
+// Don't start recursion if size 0
+template <class T> struct static_array_impl<0, T> {
+  MDSPAN_INLINE_FUNCTION
+  constexpr static T get(size_t) { return T(); }
+  template <size_t> MDSPAN_INLINE_FUNCTION constexpr static T get() {
+    return T();
+  }
+};
 
-template <size_t... Extents, size_t... OtherExtents>
-static std::integral_constant<
-  bool,
-  _MDSPAN_FOLD_AND(
-    (
-      Extents == dynamic_extent
-        || OtherExtents == dynamic_extent
-        || Extents == OtherExtents
-    ) /* && ... */
-  )
->
-_check_compatible_extents(
-  std::true_type, std::integer_sequence<size_t, Extents...>, std::integer_sequence<size_t, OtherExtents...>
-) noexcept { return { }; }
+// Static array, provides get<r>(), get(r) and operator[r]
+template <class T, T... Values> struct static_array:
+  public static_array_impl<0, T, Values...>  {
 
-struct __extents_tag { };
+public:
+  using value_type = T;
 
-} // end namespace detail
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t size() { return sizeof...(Values); }
+};
 
-template <class ThisIndexType, size_t... Extents>
-class extents
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-  : private detail::__no_unique_address_emulation<
-      detail::__partially_static_sizes_tagged<detail::__extents_tag, ThisIndexType , size_t, Extents...>>
-#endif
-{
-public:
 
-  using rank_type = size_t;
-  using index_type = ThisIndexType;
-  using size_type = make_unsigned_t<index_type>;
+// ------------------------------------------------------------------
+// ------------ index_sequence_scan ---------------------------------
+// ------------------------------------------------------------------
 
-// internal typedefs which for technical reasons are public
-  using __storage_t = detail::__partially_static_sizes_tagged<detail::__extents_tag, index_type, size_t, Extents...>;
+// index_sequence_scan takes compile time values and provides get(r)
+// and get<r>() which return the sum of the first r-1 values.
 
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-  _MDSPAN_NO_UNIQUE_ADDRESS __storage_t __storage_;
-#else
-  using __base_t = detail::__no_unique_address_emulation<__storage_t>;
-#endif
+// Recursive implementation for get
+template <size_t R, size_t... Values> struct index_sequence_scan_impl;
 
-// private members dealing with the way we internally store dynamic extents
- private:
+template <size_t R, size_t FirstVal, size_t... Values>
+struct index_sequence_scan_impl<R, FirstVal, Values...> {
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t get(size_t r) {
+    if (r > R)
+      return FirstVal + index_sequence_scan_impl<R + 1, Values...>::get(r);
+    else
+      return 0;
+  }
+};
 
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
-  __storage_t& __storage() noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    return __storage_;
-#else
-    return this->__base_t::__ref();
-#endif
+template <size_t R, size_t FirstVal>
+struct index_sequence_scan_impl<R, FirstVal> {
+#if defined(__NVCC__) || defined(__NVCOMPILER) ||                              \
+    defined(_MDSPAN_COMPILER_INTEL)
+  // NVCC warns about pointless comparison with 0 for R==0 and r being const
+  // evaluatable and also 0.
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t get(size_t r) {
+    return static_cast<int64_t>(R) > static_cast<int64_t>(r) ? FirstVal : 0;
   }
-  MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr __storage_t const& __storage() const noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    return __storage_;
 #else
-    return this->__base_t::__ref();
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t get(size_t r) { return R > r ? FirstVal : 0; }
 #endif
-  }
+};
+template <> struct index_sequence_scan_impl<0> {
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t get(size_t) { return 0; }
+};
 
-  template <size_t... Idxs>
-  MDSPAN_FORCE_INLINE_FUNCTION
-  static constexpr
-  std::size_t _static_extent_impl(size_t n, std::integer_sequence<size_t, Idxs...>) noexcept {
-    return _MDSPAN_FOLD_PLUS_RIGHT(((Idxs == n) ? Extents : 0), /* + ... + */ 0);
-  }
+// ------------------------------------------------------------------
+// ------------ possibly_empty_array  -------------------------------
+// ------------------------------------------------------------------
 
-  template <class, size_t...>
-  friend class extents;
+// array like class which provides get function and operator [], and
+// has a specialization for the size 0 case.
+// This is needed to make the maybe_static_array be truly empty, for
+// all static values.
 
-  template <class OtherIndexType, size_t... OtherExtents, size_t... Idxs>
+template <class T, size_t N> struct possibly_empty_array {
+  T vals[N]{};
   MDSPAN_INLINE_FUNCTION
-  constexpr bool _eq_impl(std::experimental::extents<OtherIndexType, OtherExtents...>, false_type, index_sequence<Idxs...>) const noexcept { return false; }
-  template <class OtherIndexType, size_t... OtherExtents, size_t... Idxs>
+  constexpr T &operator[](size_t r) { return vals[r]; }
   MDSPAN_INLINE_FUNCTION
-  constexpr bool _eq_impl(
-    std::experimental::extents<OtherIndexType, OtherExtents...> other,
-    true_type, index_sequence<Idxs...>
-  ) const noexcept {
-    return _MDSPAN_FOLD_AND(
-      (__storage().template __get_n<Idxs>() == other.__storage().template __get_n<Idxs>()) /* && ... */
-    );
-  }
+  constexpr const T &operator[](size_t r) const { return vals[r]; }
+};
 
-  template <class OtherIndexType, size_t... OtherExtents, size_t... Idxs>
+template <class T> struct possibly_empty_array<T, 0> {
   MDSPAN_INLINE_FUNCTION
-  constexpr bool _not_eq_impl(std::experimental::extents<OtherIndexType, OtherExtents...>, false_type, index_sequence<Idxs...>) const noexcept { return true; }
-  template <class OtherIndexType, size_t... OtherExtents, size_t... Idxs>
+  constexpr T operator[](size_t) { return T(); }
   MDSPAN_INLINE_FUNCTION
-  constexpr bool _not_eq_impl(
-    std::experimental::extents<OtherIndexType, OtherExtents...> other,
-    true_type, index_sequence<Idxs...>
-  ) const noexcept {
-    return _MDSPAN_FOLD_OR(
-      (__storage().template __get_n<Idxs>() != other.__storage().template __get_n<Idxs>()) /* || ... */
-    );
-  }
+  constexpr const T operator[](size_t) const { return T(); }
+};
 
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-  MDSPAN_INLINE_FUNCTION constexpr explicit
-  extents(__base_t&& __b) noexcept
-    : __base_t(::std::move(__b))
-  { }
-#endif
+// ------------------------------------------------------------------
+// ------------ maybe_static_array ----------------------------------
+// ------------------------------------------------------------------
+
+// array like class which has a mix of static and runtime values but
+// only stores the runtime values.
+// The type of the static and the runtime values can be different.
+// The position of a dynamic value is indicated through a tag value.
+template <class TDynamic, class TStatic, TStatic dyn_tag, TStatic... Values>
+struct maybe_static_array {
+
+  static_assert(std::is_convertible<TStatic, TDynamic>::value, "maybe_static_array: TStatic must be convertible to TDynamic");
+  static_assert(std::is_convertible<TDynamic, TStatic>::value, "maybe_static_array: TDynamic must be convertible to TStatic");
+
+private:
+  // Static values member
+  using static_vals_t = static_array<TStatic, Values...>;
+  constexpr static size_t m_size = sizeof...(Values);
+  constexpr static size_t m_size_dynamic =
+      _MDSPAN_FOLD_PLUS_RIGHT((Values == dyn_tag), 0);
+
+  // Dynamic values member
+  _MDSPAN_NO_UNIQUE_ADDRESS possibly_empty_array<TDynamic, m_size_dynamic>
+      m_dyn_vals;
+
+  // static mapping of indices to the position in the dynamic values array
+  using dyn_map_t = index_sequence_scan_impl<0, static_cast<size_t>(Values == dyn_tag)...>;
+public:
 
+  // two types for static and dynamic values
+  using value_type = TDynamic;
+  using static_value_type = TStatic;
+  // tag value indicating dynamic value
+  constexpr static static_value_type tag_value = dyn_tag;
 
-// public interface:
-public:
-  /* Defined above for use in the private code
-  using rank_type = size_t;
-  using index_type = ThisIndexType;
-  */
+  constexpr maybe_static_array() = default;
 
+  // constructor for all static values
+  // TODO: add precondition check?
+  MDSPAN_TEMPLATE_REQUIRES(class... Vals,
+                           /* requires */ ((m_size_dynamic == 0) &&
+                                           (sizeof...(Vals) > 0)))
   MDSPAN_INLINE_FUNCTION
-  static constexpr rank_type rank() noexcept { return sizeof...(Extents); }
+  constexpr maybe_static_array(Vals...) : m_dyn_vals{} {}
+
+  // constructors from dynamic values only
+  MDSPAN_TEMPLATE_REQUIRES(class... DynVals,
+                           /* requires */ (sizeof...(DynVals) ==
+                                               m_size_dynamic &&
+                                           m_size_dynamic > 0))
   MDSPAN_INLINE_FUNCTION
-  static constexpr rank_type rank_dynamic() noexcept { return _MDSPAN_FOLD_PLUS_RIGHT((rank_type(Extents == dynamic_extent)), /* + ... + */ 0); }
+  constexpr maybe_static_array(DynVals... vals)
+      : m_dyn_vals{static_cast<TDynamic>(vals)...} {}
 
-  //--------------------------------------------------------------------------------
-  // Constructors, Destructors, and Assignment
 
-  // Default constructor
-  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr extents() noexcept = default;
+  MDSPAN_TEMPLATE_REQUIRES(class T, size_t N,
+                           /* requires */ (N == m_size_dynamic && N > 0))
+  MDSPAN_INLINE_FUNCTION
+  constexpr maybe_static_array(const std::array<T, N> &vals) {
+    for (size_t r = 0; r < N; r++)
+      m_dyn_vals[r] = static_cast<TDynamic>(vals[r]);
+  }
 
-  // Converting constructor
-  MDSPAN_TEMPLATE_REQUIRES(
-    class OtherIndexType, size_t... OtherExtents,
-    /* requires */ (
-      /* multi-stage check to protect from invalid pack expansion when sizes don't match? */
-      decltype(detail::_check_compatible_extents(
-        std::integral_constant<bool, sizeof...(Extents) == sizeof...(OtherExtents)>{},
-        std::integer_sequence<size_t, Extents...>{},
-        std::integer_sequence<size_t, OtherExtents...>{}
-      ))::value
-    )
-  )
+  MDSPAN_TEMPLATE_REQUIRES(class T, size_t N,
+                           /* requires */ (N == m_size_dynamic && N == 0))
   MDSPAN_INLINE_FUNCTION
-  MDSPAN_CONDITIONAL_EXPLICIT(
-    (((Extents != dynamic_extent) && (OtherExtents == dynamic_extent)) || ...) ||
-    (std::numeric_limits<index_type>::max() < std::numeric_limits<OtherIndexType>::max()))
-  constexpr extents(const extents<OtherIndexType, OtherExtents...>& __other)
-    noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : __storage_{
-#else
-    : __base_t(__base_t{__storage_t{
-#endif
-        __other.__storage().__enable_psa_conversion()
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      }
-#else
-      }})
-#endif
-  {
-    /* TODO: precondition check
-     * other.extent(r) equals Er for each r for which Er is a static extent, and
-     * either
-     *   - sizeof...(OtherExtents) is zero, or
-     *   - other.extent(r) is a representable value of type index_type for all rank index r of other
-     */
+  constexpr maybe_static_array(const std::array<T, N> &) : m_dyn_vals{} {}
+
+#ifdef __cpp_lib_span
+  MDSPAN_TEMPLATE_REQUIRES(class T, size_t N,
+                           /* requires */ (N == m_size_dynamic && N > 0))
+  MDSPAN_INLINE_FUNCTION
+  constexpr maybe_static_array(const std::span<T, N> &vals) {
+    for (size_t r = 0; r < N; r++)
+      m_dyn_vals[r] = static_cast<TDynamic>(vals[r]);
   }
 
-#ifdef __NVCC__
-    MDSPAN_TEMPLATE_REQUIRES(
-    class... Integral,
-    /* requires */ (
-      // TODO: check whether the other version works with newest NVCC, doesn't with 11.4
-      // NVCC seems to pick up rank_dynamic from the wrong extents type???
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, Integral, index_type) /* && ... */) &&
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_nothrow_constructible, index_type, Integral) /* && ... */) &&
-      // NVCC chokes on the fold thingy here so wrote the workaround
-      ((sizeof...(Integral) == detail::_count_dynamic_extents<Extents...>::val) ||
-       (sizeof...(Integral) == sizeof...(Extents)))
-      )
-    )
-#else
-    MDSPAN_TEMPLATE_REQUIRES(
-    class... Integral,
-    /* requires */ (
-       _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, Integral, index_type) /* && ... */) &&
-       _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_nothrow_constructible, index_type, Integral) /* && ... */) &&
-       ((sizeof...(Integral) == rank_dynamic()) || (sizeof...(Integral) == rank()))
-      )
-    )
-#endif
+  MDSPAN_TEMPLATE_REQUIRES(class T, size_t N,
+                           /* requires */ (N == m_size_dynamic && N == 0))
   MDSPAN_INLINE_FUNCTION
-  explicit constexpr extents(Integral... exts) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : __storage_{
-#else
-    : __base_t(__base_t{typename __base_t::__stored_type{
+  constexpr maybe_static_array(const std::span<T, N> &) : m_dyn_vals{} {}
 #endif
-      std::conditional_t<sizeof...(Integral)==rank_dynamic(),
-        detail::__construct_psa_from_dynamic_exts_values_tag_t,
-        detail::__construct_psa_from_all_exts_values_tag_t>(),
-        static_cast<index_type>(exts)...
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+
+  // constructors from all values
+  MDSPAN_TEMPLATE_REQUIRES(class... DynVals,
+                           /* requires */ (sizeof...(DynVals) !=
+                                               m_size_dynamic &&
+                                           m_size_dynamic > 0))
+  MDSPAN_INLINE_FUNCTION
+  constexpr maybe_static_array(DynVals... vals)
+    : m_dyn_vals{} {
+    static_assert((sizeof...(DynVals) == m_size), "Invalid number of values.");
+    TDynamic values[m_size]{static_cast<TDynamic>(vals)...};
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = values[r];
+      }
+// Precondition check
+#ifdef _MDSPAN_DEBUG
+      else {
+        assert(values[r] == static_cast<TDynamic>(static_val));
       }
-#else
-      }})
 #endif
-  {
-    /* TODO: precondition check
-     * If sizeof...(IndexTypes) != rank_dynamic() is true, exts_arr[r] equals Er for each r for which Er is a static extent, and
-     * either
-     *   - sizeof...(exts) == 0 is true, or
-     *   - each element of exts is nonnegative and is a representable value of type index_type.
-     */
+    }
   }
 
-    // TODO: check whether this works with newest NVCC, doesn't with 11.4
-#ifdef __NVCC__
-  // NVCC seems to pick up rank_dynamic from the wrong extents type???
-  // NVCC chokes on the fold thingy here so wrote the workaround
   MDSPAN_TEMPLATE_REQUIRES(
-    class IndexType, size_t N,
-    /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, IndexType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, IndexType) &&
-      ((N == detail::_count_dynamic_extents<Extents...>::val) ||
-       (N == sizeof...(Extents)))
-    )
-  )
-#else
-    MDSPAN_TEMPLATE_REQUIRES(
-        class IndexType, size_t N,
-        /* requires */ (
-          _MDSPAN_TRAIT(is_convertible, IndexType, index_type) &&
-          _MDSPAN_TRAIT(is_nothrow_constructible, index_type, IndexType) &&
-          (N == rank() || N == rank_dynamic())
-    )
-  )
-#endif
-  MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic())
+      class T, size_t N,
+      /* requires */ (N != m_size_dynamic && m_size_dynamic > 0))
   MDSPAN_INLINE_FUNCTION
-  constexpr
-  extents(std::array<IndexType, N> const& exts) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : __storage_{
-#else
-    : __base_t(__base_t{typename __base_t::__stored_type{
+  constexpr maybe_static_array(const std::array<T, N> &vals) {
+    static_assert((N == m_size), "Invalid number of values.");
+// Precondition check
+#ifdef _MDSPAN_DEBUG
+    assert(N == m_size);
 #endif
-      std::conditional_t<N==rank_dynamic(),
-        detail::__construct_psa_from_dynamic_exts_array_tag_t<0>,
-        detail::__construct_psa_from_all_exts_array_tag_t>(),
-      std::array<IndexType,N>{exts}
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
+      }
+// Precondition check
+#ifdef _MDSPAN_DEBUG
+      else {
+        assert(static_cast<TDynamic>(vals[r]) ==
+               static_cast<TDynamic>(static_val));
       }
-#else
-      }})
 #endif
-  {
-    /* TODO: precondition check
-     * If N != rank_dynamic() is true, exts[r] equals Er for each r for which Er is a static extent, and
-     * either
-     *   - N is zero, or
-     *   - exts[r] is nonnegative and is a representable value of type index_type for all rank index r
-     */
+    }
   }
 
 #ifdef __cpp_lib_span
-  // TODO: check whether the below works with newest NVCC, doesn't with 11.4
-#ifdef __NVCC__
-  // NVCC seems to pick up rank_dynamic from the wrong extents type???
-  // NVCC chokes on the fold thingy here so wrote the workaround
   MDSPAN_TEMPLATE_REQUIRES(
-    class IndexType, size_t N,
-    /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, IndexType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, IndexType) &&
-      ((N == detail::_count_dynamic_extents<Extents...>::val) ||
-       (N == sizeof...(Extents)))
-    )
-  )
-#else
-    MDSPAN_TEMPLATE_REQUIRES(
-        class IndexType, size_t N,
-        /* requires */ (
-          _MDSPAN_TRAIT(is_convertible, IndexType, index_type) &&
-          _MDSPAN_TRAIT(is_nothrow_constructible, index_type, IndexType) &&
-          (N == rank() || N == rank_dynamic())
-    )
-  )
-#endif
-  MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic())
+      class T, size_t N,
+      /* requires */ (N != m_size_dynamic && m_size_dynamic > 0))
   MDSPAN_INLINE_FUNCTION
-  constexpr
-  extents(std::span<IndexType, N> exts) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : __storage_{
-#else
-    : __base_t(__base_t{typename __base_t::__stored_type{
+  constexpr maybe_static_array(const std::span<T, N> &vals) {
+    static_assert((N == m_size) || (m_size == dynamic_extent));
+#ifdef _MDSPAN_DEBUG
+    assert(N == m_size);
 #endif
-      std::conditional_t<N==rank_dynamic(),
-        detail::__construct_psa_from_dynamic_exts_array_tag_t<0>,
-        detail::__construct_psa_from_all_exts_array_tag_t>(),
-      exts
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+    for (size_t r = 0; r < m_size; r++) {
+      TStatic static_val = static_vals_t::get(r);
+      if (static_val == dyn_tag) {
+        m_dyn_vals[dyn_map_t::get(r)] = static_cast<TDynamic>(vals[r]);
+      }
+#ifdef _MDSPAN_DEBUG
+      else {
+        assert(static_cast<TDynamic>(vals[r]) ==
+               static_cast<TDynamic>(static_val));
       }
-#else
-      }})
 #endif
-  {
-    /* TODO: precondition check
-     * If N != rank_dynamic() is true, exts[r] equals Er for each r for which Er is a static extent, and
-     * either
-     *   - N is zero, or
-     *   - exts[r] is nonnegative and is a representable value of type index_type for all rank index r
-     */
+    }
   }
 #endif
 
-  // Need this constructor for some submdspan implementation stuff
-  // for the layout_stride case where I use an extents object for strides
+  // access functions
   MDSPAN_INLINE_FUNCTION
-  constexpr explicit
-  extents(__storage_t const& sto ) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : __storage_{
-#else
-    : __base_t(__base_t{
-#endif
-        sto
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      }
-#else
-      })
-#endif
-  { }
-
-  //--------------------------------------------------------------------------------
+  constexpr static TStatic static_value(size_t r) { return static_vals_t::get(r); }
 
   MDSPAN_INLINE_FUNCTION
-  static constexpr
-  size_t static_extent(size_t n) noexcept {
-    // Can't do assert here since that breaks true constexpr ness
-    // assert(n<rank());
-    return _static_extent_impl(n, std::make_integer_sequence<size_t, sizeof...(Extents)>{});
+  constexpr TDynamic value(size_t r) const {
+    TStatic static_val = static_vals_t::get(r);
+    return static_val == dyn_tag ? m_dyn_vals[dyn_map_t::get(r)]
+                                        : static_cast<TDynamic>(static_val);
   }
+  MDSPAN_INLINE_FUNCTION
+  constexpr TDynamic operator[](size_t r) const { return value(r); }
+
 
+  // observers
   MDSPAN_INLINE_FUNCTION
-  constexpr
-  index_type extent(size_t n) const noexcept {
-    // Can't do assert here since that breaks true constexpr ness
-    // assert(n<rank());
-    return __storage().__get(n);
-  }
+  constexpr static size_t size() { return m_size; }
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t size_dynamic() { return m_size_dynamic; }
+};
+
+} // namespace detail
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
-  //--------------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// ------------ extents ---------------------------------------------
+// ------------------------------------------------------------------
 
-  template<class OtherIndexType, size_t... RHS>
+// Class to describe the extents of a multi dimensional array.
+// Used by mdspan, mdarray and layout mappings.
+// See ISO C++ standard [mdspan.extents]
+
+template <class IndexType, size_t... Extents> class extents {
+public:
+  // typedefs for integral types used
+  using index_type = IndexType;
+  using size_type = std::make_unsigned_t<index_type>;
+  using rank_type = size_t;
+
+  static_assert(std::is_integral<index_type>::value && !std::is_same<index_type, bool>::value,
+                MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents::index_type must be a signed or unsigned integer type");
+private:
+  constexpr static rank_type m_rank = sizeof...(Extents);
+  constexpr static rank_type m_rank_dynamic =
+      _MDSPAN_FOLD_PLUS_RIGHT((Extents == dynamic_extent), /* + ... + */ 0);
+
+  // internal storage type using maybe_static_array
+  using vals_t =
+      detail::maybe_static_array<IndexType, size_t, dynamic_extent, Extents...>;
+  _MDSPAN_NO_UNIQUE_ADDRESS vals_t m_vals;
+
+public:
+  // [mdspan.extents.obs], observers of multidimensional index space
   MDSPAN_INLINE_FUNCTION
-  friend constexpr bool operator==(extents const& lhs, extents<OtherIndexType, RHS...> const& rhs) noexcept {
-    return lhs._eq_impl(
-      rhs, std::integral_constant<bool, (sizeof...(RHS) == rank())>{},
-      make_index_sequence<sizeof...(RHS)>{}
-    );
-  }
+  constexpr static rank_type rank() noexcept { return m_rank; }
+  MDSPAN_INLINE_FUNCTION
+  constexpr static rank_type rank_dynamic() noexcept { return m_rank_dynamic; }
 
-#if !(MDSPAN_HAS_CXX_20)
-  template<class OtherIndexType, size_t... RHS>
   MDSPAN_INLINE_FUNCTION
-  friend constexpr bool operator!=(extents const& lhs, extents<OtherIndexType, RHS...> const& rhs) noexcept {
-    return lhs._not_eq_impl(
-      rhs, std::integral_constant<bool, (sizeof...(RHS) == rank())>{},
-      make_index_sequence<sizeof...(RHS)>{}
-    );
+  constexpr index_type extent(rank_type r) const noexcept { return m_vals.value(r); }
+  MDSPAN_INLINE_FUNCTION
+  constexpr static size_t static_extent(rank_type r) noexcept {
+    return vals_t::static_value(r);
   }
-#endif
 
-  // End of public interface
+  // [mdspan.extents.cons], constructors
+  MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr extents() noexcept = default;
 
-public:  // (but not really)
+  // Construction from just dynamic or all values.
+  // Precondition check is deferred to maybe_static_array constructor
+  MDSPAN_TEMPLATE_REQUIRES(
+      class... OtherIndexTypes,
+      /* requires */ (
+          _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, OtherIndexTypes,
+                                         index_type) /* && ... */) &&
+          _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_nothrow_constructible, index_type,
+                                         OtherIndexTypes) /* && ... */) &&
+          (sizeof...(OtherIndexTypes) == m_rank ||
+           sizeof...(OtherIndexTypes) == m_rank_dynamic)))
+  MDSPAN_INLINE_FUNCTION
+  constexpr explicit extents(OtherIndexTypes... dynvals) noexcept
+      : m_vals(static_cast<index_type>(dynvals)...) {}
 
-  MDSPAN_INLINE_FUNCTION static constexpr
-  extents __make_extents_impl(detail::__partially_static_sizes<index_type, size_t,Extents...>&& __bs) noexcept {
-    // This effectively amounts to a sideways cast that can be done in a constexpr
-    // context, but we have to do it to handle the case where the extents and the
-    // strides could accidentally end up with the same types in their hierarchies
-    // somehow (which would cause layout_stride::mapping to not be standard_layout)
-    return extents(
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      __base_t{
-#endif
-        ::std::move(__bs.template __with_tag<detail::__extents_tag>())
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      }
+  MDSPAN_TEMPLATE_REQUIRES(
+      class OtherIndexType, size_t N,
+      /* requires */
+      (
+          _MDSPAN_TRAIT(std::is_convertible, const OtherIndexType&, index_type) &&
+          _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type,
+              const OtherIndexType&) &&
+          (N == m_rank || N == m_rank_dynamic)))
+  MDSPAN_INLINE_FUNCTION
+  MDSPAN_CONDITIONAL_EXPLICIT(N != m_rank_dynamic)
+  constexpr extents(const std::array<OtherIndexType, N> &exts) noexcept
+      : m_vals(std::move(exts)) {}
+
+#ifdef __cpp_lib_span
+  MDSPAN_TEMPLATE_REQUIRES(
+      class OtherIndexType, size_t N,
+      /* requires */
+      (_MDSPAN_TRAIT(std::is_convertible, const OtherIndexType&, index_type) &&
+       _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const OtherIndexType&) &&
+       (N == m_rank || N == m_rank_dynamic)))
+  MDSPAN_INLINE_FUNCTION
+  MDSPAN_CONDITIONAL_EXPLICIT(N != m_rank_dynamic)
+  constexpr extents(const std::span<OtherIndexType, N> &exts) noexcept
+      : m_vals(std::move(exts)) {}
 #endif
-    );
+
+private:
+  // Function to construct extents storage from other extents.
+  // With C++ 17 the first two variants could be collapsed using if constexpr
+  // in which case you don't need all the requires clauses.
+  // in C++ 14 mode that doesn't work due to infinite recursion
+  MDSPAN_TEMPLATE_REQUIRES(
+      size_t DynCount, size_t R, class OtherExtents, class... DynamicValues,
+      /* requires */ ((R < m_rank) && (static_extent(R) == dynamic_extent)))
+  MDSPAN_INLINE_FUNCTION
+  constexpr
+  vals_t __construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
+                                       std::integral_constant<size_t, R>,
+                                       const OtherExtents &exts,
+                                       DynamicValues... dynamic_values) noexcept {
+    return __construct_vals_from_extents(
+        std::integral_constant<size_t, DynCount + 1>(),
+        std::integral_constant<size_t, R + 1>(), exts, dynamic_values...,
+        exts.extent(R));
   }
 
-  template <size_t N>
-  MDSPAN_FORCE_INLINE_FUNCTION
+  MDSPAN_TEMPLATE_REQUIRES(
+      size_t DynCount, size_t R, class OtherExtents, class... DynamicValues,
+      /* requires */ ((R < m_rank) && (static_extent(R) != dynamic_extent)))
+  MDSPAN_INLINE_FUNCTION
   constexpr
-  index_type __extent() const noexcept {
-    return __storage().template __get_n<N>();
+  vals_t __construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
+                                       std::integral_constant<size_t, R>,
+                                       const OtherExtents &exts,
+                                       DynamicValues... dynamic_values) noexcept {
+    return __construct_vals_from_extents(
+        std::integral_constant<size_t, DynCount>(),
+        std::integral_constant<size_t, R + 1>(), exts, dynamic_values...);
   }
 
-  template <size_t N, size_t Default=dynamic_extent>
+  MDSPAN_TEMPLATE_REQUIRES(
+      size_t DynCount, size_t R, class OtherExtents, class... DynamicValues,
+      /* requires */ ((R == m_rank) && (DynCount == m_rank_dynamic)))
   MDSPAN_INLINE_FUNCTION
-  static constexpr
-  index_type __static_extent() noexcept {
-    return __storage_t::template __get_static_n<N, Default>();
+  constexpr
+  vals_t __construct_vals_from_extents(std::integral_constant<size_t, DynCount>,
+                                       std::integral_constant<size_t, R>,
+                                       const OtherExtents &,
+                                       DynamicValues... dynamic_values) noexcept {
+    return vals_t{static_cast<index_type>(dynamic_values)...};
+  }
+
+public:
+
+  // Converting constructor from other extents specializations
+    MDSPAN_TEMPLATE_REQUIRES(
+        class OtherIndexType, size_t... OtherExtents,
+        /* requires */
+        (
+            /* multi-stage check to protect from invalid pack expansion when sizes
+            don't match? */
+            decltype(detail::__check_compatible_extents(
+              // using: sizeof...(Extents) == sizeof...(OtherExtents) as the second argument fails with MSVC+NVCC with some obscure expansion error
+              // MSVC: 19.38.33133 NVCC: 12.0
+              std::integral_constant<bool, extents<int, Extents...>::rank() == extents<int, OtherExtents...>::rank()>{},
+              std::integer_sequence<size_t, Extents...>{},
+              std::integer_sequence<size_t, OtherExtents...>{}))::value
+      )
+  )
+  MDSPAN_INLINE_FUNCTION
+  MDSPAN_CONDITIONAL_EXPLICIT((((Extents != dynamic_extent) &&
+                                (OtherExtents == dynamic_extent)) ||
+                               ...) ||
+                              (std::numeric_limits<index_type>::max() <
+                               std::numeric_limits<OtherIndexType>::max()))
+  constexpr extents(const extents<OtherIndexType, OtherExtents...> &other) noexcept
+      : m_vals(__construct_vals_from_extents(
+            std::integral_constant<size_t, 0>(),
+            std::integral_constant<size_t, 0>(), other)) {}
+
+  // Comparison operator
+  template <class OtherIndexType, size_t... OtherExtents>
+  MDSPAN_INLINE_FUNCTION friend constexpr bool
+  operator==(const extents &lhs,
+             const extents<OtherIndexType, OtherExtents...> &rhs) noexcept {
+    return
+      rank() == extents<OtherIndexType, OtherExtents...>::rank() &&
+      detail::rankwise_equal(detail::with_rank<rank()>{}, rhs, lhs, detail::extent);
   }
 
+#if !(MDSPAN_HAS_CXX_20)
+  template <class OtherIndexType, size_t... OtherExtents>
+  MDSPAN_INLINE_FUNCTION friend constexpr bool
+  operator!=(extents const &lhs,
+             extents<OtherIndexType, OtherExtents...> const &rhs) noexcept {
+    return !(lhs == rhs);
+  }
+#endif
 };
 
+// Recursive helper classes to implement dextents alias for extents
 namespace detail {
 
-template <class IndexType, size_t Rank, class Extents = ::std::experimental::extents<IndexType>>
+template <class IndexType, size_t Rank,
+          class Extents = ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType>>
 struct __make_dextents;
 
 template <class IndexType, size_t Rank, size_t... ExtentsPack>
-struct __make_dextents<IndexType, Rank, ::std::experimental::extents<IndexType, ExtentsPack...>> {
-  using type = typename __make_dextents<IndexType, Rank - 1,
-    ::std::experimental::extents<IndexType, ::std::experimental::dynamic_extent, ExtentsPack...>>::type;
+struct __make_dextents<
+    IndexType, Rank, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
+{
+  using type = typename __make_dextents<
+      IndexType, Rank - 1,
+      ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType,
+                                                ::MDSPAN_IMPL_STANDARD_NAMESPACE::dynamic_extent,
+                                                ExtentsPack...>>::type;
 };
 
 template <class IndexType, size_t... ExtentsPack>
-struct __make_dextents<IndexType, 0, ::std::experimental::extents<IndexType, ExtentsPack...>> {
-  using type = ::std::experimental::extents<IndexType, ExtentsPack...>;
+struct __make_dextents<
+    IndexType, 0, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
+{
+  using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>;
 };
 
 } // end namespace detail
 
+// [mdspan.extents.dextents], alias template
 template <class IndexType, size_t Rank>
 using dextents = typename detail::__make_dextents<IndexType, Rank>::type;
 
+// Deduction guide for extents
 #if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
 template <class... IndexTypes>
 extents(IndexTypes...)
-  -> extents<size_t, detail::__make_dynamic_extent<IndexTypes>()...>;
+    -> extents<size_t,
+               ((void) sizeof(IndexTypes), ::MDSPAN_IMPL_STANDARD_NAMESPACE::dynamic_extent)...>;
 #endif
 
+// Helper type traits for identifying a class as extents.
 namespace detail {
 
-template <class T>
-struct __is_extents : ::std::false_type {};
+template <class T> struct __is_extents : ::std::false_type {};
 
 template <class IndexType, size_t... ExtentsPack>
-struct __is_extents<::std::experimental::extents<IndexType, ExtentsPack...>> : ::std::true_type {};
+struct __is_extents<::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<IndexType, ExtentsPack...>>
+    : ::std::true_type {};
 
 template <class T>
-static constexpr bool __is_extents_v = __is_extents<T>::value;
-
-
-template <typename Extents>
-struct __extents_to_partially_static_sizes;
-
-template <class IndexType, size_t... ExtentsPack>
-struct __extents_to_partially_static_sizes<::std::experimental::extents<IndexType, ExtentsPack...>> {
-  using type = detail::__partially_static_sizes<
-          typename ::std::experimental::extents<IndexType, ExtentsPack...>::index_type, size_t, 
-          ExtentsPack...>;
-};
-
-template <typename Extents>
-using __extents_to_partially_static_sizes_t = typename __extents_to_partially_static_sizes<Extents>::type;
+#if MDSPAN_HAS_CXX_17
+inline
+#else
+static
+#endif
+constexpr bool __is_extents_v = __is_extents<T>::value;
+
+template<class InputIndexType, class ExtentsIndexType>
+MDSPAN_INLINE_FUNCTION
+constexpr void
+check_lower_bound(InputIndexType user_index,
+                  ExtentsIndexType /* current_extent */,
+                  std::true_type /* is_signed */)
+{
+  (void) user_index; // prevent unused variable warning
+#ifdef _MDSPAN_DEBUG
+  assert(static_cast<ExtentsIndexType>(user_index) >= 0);
+#endif
+}
+
+template<class InputIndexType, class ExtentsIndexType>
+MDSPAN_INLINE_FUNCTION
+constexpr void
+check_lower_bound(InputIndexType /* user_index */,
+                  ExtentsIndexType /* current_extent */,
+                  std::false_type /* is_signed */)
+{}
+
+template<class InputIndexType, class ExtentsIndexType>
+MDSPAN_INLINE_FUNCTION
+constexpr void
+check_upper_bound(InputIndexType user_index,
+                  ExtentsIndexType current_extent)
+{
+  (void) user_index; // prevent unused variable warnings
+  (void) current_extent;
+#ifdef _MDSPAN_DEBUG
+  assert(static_cast<ExtentsIndexType>(user_index) < current_extent);
+#endif
+}
+
+// Returning true to use AND fold instead of comma
+// CPP14 mode doesn't like the use of void expressions
+// with the way the _MDSPAN_FOLD_AND is set up
+template<class InputIndex, class ExtentsIndexType>
+MDSPAN_INLINE_FUNCTION
+constexpr bool
+check_one_index(InputIndex user_index,
+                ExtentsIndexType current_extent)
+{
+  check_lower_bound(user_index, current_extent,
+    std::integral_constant<bool, std::is_signed<ExtentsIndexType>::value>{});
+  check_upper_bound(user_index, current_extent);
+  return true;
+}
+
+template<size_t ... RankIndices,
+         class ExtentsIndexType, size_t ... Exts,
+         class ... Indices>
+MDSPAN_INLINE_FUNCTION
+constexpr void
+check_all_indices_helper(std::index_sequence<RankIndices...>,
+                         const extents<ExtentsIndexType, Exts...>& exts,
+                         Indices... indices)
+{
+  // Suppress warning about statement has no effect
+  (void) _MDSPAN_FOLD_AND(
+    (check_one_index(indices, exts.extent(RankIndices)))
+  );
+}
+
+template<class ExtentsIndexType, size_t ... Exts,
+         class ... Indices>
+MDSPAN_INLINE_FUNCTION
+constexpr void
+check_all_indices(const extents<ExtentsIndexType, Exts...>& exts,
+                  Indices... indices)
+{
+  check_all_indices_helper(std::make_index_sequence<sizeof...(Indices)>(),
+                           exts, indices...);
+}
 
-} // end namespace detail
-} // end namespace experimental
-} // end namespace std
+} // namespace detail
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp b/tpls/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp
index e5ede0f9d5..bd4b5c6a8b 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/full_extent_t.hpp
@@ -1,56 +1,26 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 struct full_extent_t { explicit full_extent_t() = default; };
 
 _MDSPAN_INLINE_VARIABLE constexpr auto full_extent = full_extent_t{ };
 
-} // end namespace experimental
-} // namespace std
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/layout_left.hpp b/tpls/mdspan/include/experimental/__p0009_bits/layout_left.hpp
index 8cd2e14fb8..222fba7aa0 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/layout_left.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/layout_left.hpp
@@ -1,54 +1,31 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
 #include "trait_backports.hpp"
 #include "extents.hpp"
+#include "layout_stride.hpp"
+#include "utility.hpp"
+#if MDSPAN_HAS_CXX_17
+#include "../__p2642_bits/layout_padded_fwd.hpp"
+#endif
+#include <type_traits>
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 //==============================================================================
 
@@ -62,7 +39,8 @@ class layout_left::mapping {
     using layout_type = layout_left;
   private:
 
-    static_assert(detail::__is_extents_v<extents_type>, "std::experimental::layout_left::mapping must be instantiated with a specialization of std::experimental::extents.");
+    static_assert(detail::__is_extents_v<extents_type>,
+                  MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_left::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
 
     template <class>
     friend class mapping;
@@ -72,18 +50,21 @@ class layout_left::mapping {
     struct __rank_count {};
 
     template <size_t r, size_t Rank, class I, class... Indices>
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(
       __rank_count<r,Rank>, const I& i, Indices... idx) const {
       return __compute_offset(__rank_count<r+1,Rank>(), idx...) *
-                 __extents.template __extent<r>() + i;
+                 __extents.extent(r) + i;
     }
 
     template<class I>
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(
       __rank_count<extents_type::rank()-1,extents_type::rank()>, const I& i) const {
       return i;
     }
 
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; }
 
   public:
@@ -93,6 +74,7 @@ class layout_left::mapping {
     MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
     MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
 
+    _MDSPAN_HOST_DEVICE
     constexpr mapping(extents_type const& __exts) noexcept
       :__extents(__exts)
     { }
@@ -100,10 +82,10 @@ class layout_left::mapping {
     MDSPAN_TEMPLATE_REQUIRES(
       class OtherExtents,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents)
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
       )
     )
-    MDSPAN_CONDITIONAL_EXPLICIT((!is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
+    MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
     mapping(mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
       :__extents(other.extents())
@@ -117,11 +99,11 @@ class layout_left::mapping {
     MDSPAN_TEMPLATE_REQUIRES(
       class OtherExtents,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents) &&
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) &&
         (extents_type::rank() <= 1)
       )
     )
-    MDSPAN_CONDITIONAL_EXPLICIT((!is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
+    MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
     mapping(layout_right::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
       :__extents(other.extents())
@@ -132,29 +114,52 @@ class layout_left::mapping {
         */
     }
 
+#if MDSPAN_HAS_CXX_17
+    /**
+     * Converting constructor from `layout_left_padded::mapping`.
+     *
+     * This overload participates in overload resolution only if _Mapping is a layout_left_padded mapping and
+     * extents_type is constructible from _Mapping::extents_type.
+     *
+     * \note There is currently a difference from p2642r2, where this function is specified as taking
+     * `layout_left_padded< padding_value >::mapping< Extents>`. However, this makes `padding_value` non-deducible.
+     */
+    MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (
+        MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_left_padded_mapping<_Mapping>::value
+        && std::is_constructible_v<extents_type, typename _Mapping::extents_type>
+      )
+    )
+    MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v<typename _Mapping::extents_type, extents_type>))
+    mapping(const _Mapping& __other) noexcept
+      : __extents(__other.extents())
+    {
+      MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
+          check_padded_layout_converting_constructor_mandates<
+            extents_type, _Mapping>(detail::with_rank<extents_type::rank()>{});
+      MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
+          check_padded_layout_converting_constructor_preconditions<
+              extents_type>(detail::with_rank<extents_type::rank()>{}, __other);
+    }
+#endif
+
     MDSPAN_TEMPLATE_REQUIRES(
       class OtherExtents,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents)
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
       )
     )
     MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
-    mapping(layout_stride::mapping<OtherExtents> const& other) // NOLINT(google-explicit-constructor)
+    mapping(layout_stride::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
       :__extents(other.extents())
     {
        /*
         * TODO: check precondition
         * other.required_span_size() is a representable value of type index_type
         */
-       #ifndef __CUDA_ARCH__
-       size_t stride = 1;
-       for(rank_type r=0; r<__extents.rank(); r++) {
-         if(stride != other.stride(r))
-           throw std::runtime_error("Assigning layout_stride to layout_left with invalid strides.");
-         stride *= __extents.extent(r);
-       }
-       #endif
+       detail::validate_strides(detail::with_rank<extents_type::rank()>{}, layout_left{}, __extents, other);
     }
 
     MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
@@ -177,14 +182,15 @@ class layout_left::mapping {
       class... Indices,
       /* requires */ (
         (sizeof...(Indices) == extents_type::rank()) &&
-        _MDSPAN_FOLD_AND(
-           (_MDSPAN_TRAIT(is_convertible, Indices, index_type) &&
-            _MDSPAN_TRAIT(is_nothrow_constructible, index_type, Indices))
-        )
+        (detail::are_valid_indices<index_type, Indices...>())
       )
     )
+    _MDSPAN_HOST_DEVICE
     constexpr index_type operator()(Indices... idxs) const noexcept {
-      return __compute_offset(__rank_count<0, extents_type::rank()>(), idxs...);
+#if ! defined(NDEBUG)
+      detail::check_all_indices(this->extents(), idxs...);
+#endif // ! NDEBUG
+      return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast<index_type>(idxs)...);
     }
 
 
@@ -193,26 +199,36 @@ class layout_left::mapping {
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return true; }
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; }
 
-    MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return true; }
-    MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return true; }
-    MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return true; }
+    MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept { return true; }
+    MDSPAN_INLINE_FUNCTION static constexpr bool is_exhaustive() noexcept { return true; }
+    MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; }
 
     MDSPAN_INLINE_FUNCTION
-    constexpr index_type stride(rank_type i) const noexcept {
+    constexpr index_type stride(rank_type i) const noexcept
+#if MDSPAN_HAS_CXX_20
+      requires ( Extents::rank() > 0 )
+#endif
+    {
       index_type value = 1;
       for(rank_type r=0; r<i; r++) value*=__extents.extent(r);
       return value;
     }
 
-    template<class OtherExtents>
+    MDSPAN_TEMPLATE_REQUIRES(
+      class OtherExtents,
+      /* requires */ ( Extents::rank() == OtherExtents::rank())
+    )
     MDSPAN_INLINE_FUNCTION
     friend constexpr bool operator==(mapping const& lhs, mapping<OtherExtents> const& rhs) noexcept {
       return lhs.extents() == rhs.extents();
     }
 
     // In C++ 20 the not equal exists if equal is found
-#if MDSPAN_HAS_CXX_20
-    template<class OtherExtents>
+#if !(MDSPAN_HAS_CXX_20)
+    MDSPAN_TEMPLATE_REQUIRES(
+      class OtherExtents,
+      /* requires */ ( Extents::rank() == OtherExtents::rank())
+    )
     MDSPAN_INLINE_FUNCTION
     friend constexpr bool operator!=(mapping const& lhs, mapping<OtherExtents> const& rhs) noexcept {
       return lhs.extents() != rhs.extents();
@@ -221,20 +237,30 @@ class layout_left::mapping {
 
     // Not really public, but currently needed to implement fully constexpr useable submdspan:
     template<size_t N, class SizeType, size_t ... E, size_t ... Idx>
-    constexpr index_type __get_stride(std::experimental::extents<SizeType, E...>,integer_sequence<size_t, Idx...>) const {
+    constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, E...>,std::integer_sequence<size_t, Idx...>) const {
       return _MDSPAN_FOLD_TIMES_RIGHT((Idx<N? __extents.template __extent<Idx>():1),1);
     }
     template<size_t N>
     constexpr index_type __stride() const noexcept {
-      return __get_stride<N>(__extents, make_index_sequence<extents_type::rank()>());
+      return __get_stride<N>(__extents, std::make_index_sequence<extents_type::rank()>());
     }
 
 private:
    _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{};
 
+   // [mdspan.submdspan.mapping], submdspan mapping specialization
+   template<class... SliceSpecifiers>
+    MDSPAN_INLINE_FUNCTION
+    constexpr auto submdspan_mapping_impl(
+       SliceSpecifiers... slices) const;
+
+   template<class... SliceSpecifiers>
+     friend constexpr auto submdspan_mapping(
+       const mapping& src, SliceSpecifiers... slices) {
+         return src.submdspan_mapping_impl(slices...);
+     }
 };
 
 
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/layout_right.hpp b/tpls/mdspan/include/experimental/__p0009_bits/layout_right.hpp
index 118f3632c0..284569f653 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/layout_right.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/layout_right.hpp
@@ -1,56 +1,30 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
 #include "trait_backports.hpp"
 #include "extents.hpp"
-#include <stdexcept>
 #include "layout_stride.hpp"
+#include "utility.hpp"
+#if MDSPAN_HAS_CXX_17
+#include "../__p2642_bits/layout_padded_fwd.hpp"
+#endif
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 //==============================================================================
 template <class Extents>
@@ -63,7 +37,8 @@ class layout_right::mapping {
     using layout_type = layout_right;
   private:
 
-    static_assert(detail::__is_extents_v<extents_type>, "std::experimental::layout_right::mapping must be instantiated with a specialization of std::experimental::extents.");
+    static_assert(detail::__is_extents_v<extents_type>,
+                  MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_right::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
 
     template <class>
     friend class mapping;
@@ -73,21 +48,25 @@ class layout_right::mapping {
     struct __rank_count {};
 
     template <size_t r, size_t Rank, class I, class... Indices>
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(
       index_type offset, __rank_count<r,Rank>, const I& i, Indices... idx) const {
-      return __compute_offset(offset * __extents.template __extent<r>() + i,__rank_count<r+1,Rank>(),  idx...);
+      return __compute_offset(offset * __extents.extent(r) + i,__rank_count<r+1,Rank>(),  idx...);
     }
 
     template<class I, class ... Indices>
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(
       __rank_count<0,extents_type::rank()>, const I& i, Indices... idx) const {
       return __compute_offset(i,__rank_count<1,extents_type::rank()>(),idx...);
     }
 
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(size_t offset, __rank_count<extents_type::rank(), extents_type::rank()>) const {
       return static_cast<index_type>(offset);
     }
 
+    _MDSPAN_HOST_DEVICE
     constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; }
 
   public:
@@ -97,6 +76,7 @@ class layout_right::mapping {
     MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
     MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
 
+    _MDSPAN_HOST_DEVICE
     constexpr mapping(extents_type const& __exts) noexcept
       :__extents(__exts)
     { }
@@ -104,10 +84,10 @@ class layout_right::mapping {
     MDSPAN_TEMPLATE_REQUIRES(
       class OtherExtents,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents)
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
       )
     )
-    MDSPAN_CONDITIONAL_EXPLICIT((!is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
+    MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
     mapping(mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
       :__extents(other.extents())
@@ -121,11 +101,11 @@ class layout_right::mapping {
     MDSPAN_TEMPLATE_REQUIRES(
       class OtherExtents,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents) &&
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents) &&
         (extents_type::rank() <= 1)
       )
     )
-    MDSPAN_CONDITIONAL_EXPLICIT((!is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
+    MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible<OtherExtents, extents_type>::value)) // needs two () due to comma
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
     mapping(layout_left::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
       :__extents(other.extents())
@@ -136,29 +116,50 @@ class layout_right::mapping {
         */
     }
 
+    /**
+     * Converting constructor from `layout_right_padded::mapping`.
+     *
+     * This overload participates in overload resolution only if _Mapping is a layout_right_padded mapping and
+     * extents_type is constructible from _Mapping::extents_type.
+     *
+     * \note There is currently a difference from p2642r2, where this function is specified as taking
+     * `layout_right_padded< padding_value >::mapping< Extents>`. However, this makes `padding_value` non-deducible.
+     */
+#if MDSPAN_HAS_CXX_17
+    MDSPAN_TEMPLATE_REQUIRES(
+        class _Mapping,
+        /* requires */ (
+        MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::is_layout_right_padded_mapping<_Mapping>::value
+        && std::is_constructible_v<extents_type, typename _Mapping::extents_type>))
+    MDSPAN_CONDITIONAL_EXPLICIT((!std::is_convertible_v<typename _Mapping::extents_type, extents_type>))
+    mapping(const _Mapping &__other) noexcept
+        : __extents(__other.extents())
+    {
+      MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
+          check_padded_layout_converting_constructor_mandates<
+            extents_type, _Mapping>(detail::with_rank<extents_type::rank()>{});
+      MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::
+          check_padded_layout_converting_constructor_preconditions<
+            extents_type>(detail::with_rank<extents_type::rank()>{}, __other);
+    }
+#endif
+
     MDSPAN_TEMPLATE_REQUIRES(
       class OtherExtents,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents)
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents)
       )
     )
     MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
-    mapping(layout_stride::mapping<OtherExtents> const& other) // NOLINT(google-explicit-constructor)
+    mapping(layout_stride::mapping<OtherExtents> const& other) noexcept // NOLINT(google-explicit-constructor)
       :__extents(other.extents())
     {
        /*
         * TODO: check precondition
         * other.required_span_size() is a representable value of type index_type
         */
-       #ifndef __CUDA_ARCH__
-       size_t stride = 1;
-       for(rank_type r=__extents.rank(); r>0; r--) {
-         if(stride != other.stride(r-1))
-           throw std::runtime_error("Assigning layout_stride to layout_right with invalid strides.");
-         stride *= __extents.extent(r-1);
-       }
-       #endif
+       detail::validate_strides(detail::with_rank<extents_type::rank()>{}, layout_right{}, __extents, other);
     }
 
     MDSPAN_INLINE_FUNCTION_DEFAULTED _MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
@@ -178,42 +179,53 @@ class layout_right::mapping {
     //--------------------------------------------------------------------------------
 
     MDSPAN_TEMPLATE_REQUIRES(
-      class... Indices,
+      class ... Indices,
       /* requires */ (
-        (sizeof...(Indices) == extents_type::rank()) &&
-        _MDSPAN_FOLD_AND(
-           (_MDSPAN_TRAIT(is_convertible, Indices, index_type) &&
-            _MDSPAN_TRAIT(is_nothrow_constructible, index_type, Indices))
-        )
+      (sizeof...(Indices) == extents_type::rank()) &&
+      (detail::are_valid_indices<index_type, Indices...>())
       )
     )
+    _MDSPAN_HOST_DEVICE
     constexpr index_type operator()(Indices... idxs) const noexcept {
-      return __compute_offset(__rank_count<0, extents_type::rank()>(), idxs...);
+#if ! defined(NDEBUG)
+      detail::check_all_indices(this->extents(), idxs...);
+#endif // ! NDEBUG
+      return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast<index_type>(idxs)...);
     }
 
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return true; }
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; }
-    MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return true; }
-    MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return true; }
-    MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return true; }
+    MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept { return true; }
+    MDSPAN_INLINE_FUNCTION static constexpr bool is_exhaustive() noexcept { return true; }
+    MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; }
 
     MDSPAN_INLINE_FUNCTION
-    constexpr index_type stride(rank_type i) const noexcept {
+    constexpr index_type stride(rank_type i) const noexcept
+#if MDSPAN_HAS_CXX_20
+      requires ( Extents::rank() > 0 )
+#endif
+    {
       index_type value = 1;
       for(rank_type r=extents_type::rank()-1; r>i; r--) value*=__extents.extent(r);
       return value;
     }
 
-    template<class OtherExtents>
+    MDSPAN_TEMPLATE_REQUIRES(
+      class OtherExtents,
+      /* requires */ ( Extents::rank() == OtherExtents::rank())
+    )
     MDSPAN_INLINE_FUNCTION
     friend constexpr bool operator==(mapping const& lhs, mapping<OtherExtents> const& rhs) noexcept {
       return lhs.extents() == rhs.extents();
     }
 
     // In C++ 20 the not equal exists if equal is found
-#if MDSPAN_HAS_CXX_20
-    template<class OtherExtents>
+#if !(MDSPAN_HAS_CXX_20)
+    MDSPAN_TEMPLATE_REQUIRES(
+      class OtherExtents,
+      /* requires */ (Extents::rank() == OtherExtents::rank())
+    )
     MDSPAN_INLINE_FUNCTION
     friend constexpr bool operator!=(mapping const& lhs, mapping<OtherExtents> const& rhs) noexcept {
       return lhs.extents() != rhs.extents();
@@ -222,19 +234,29 @@ class layout_right::mapping {
 
     // Not really public, but currently needed to implement fully constexpr useable submdspan:
     template<size_t N, class SizeType, size_t ... E, size_t ... Idx>
-    constexpr index_type __get_stride(std::experimental::extents<SizeType, E...>,integer_sequence<size_t, Idx...>) const {
+    constexpr index_type __get_stride(MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, E...>,std::integer_sequence<size_t, Idx...>) const {
       return _MDSPAN_FOLD_TIMES_RIGHT((Idx>N? __extents.template __extent<Idx>():1),1);
     }
     template<size_t N>
     constexpr index_type __stride() const noexcept {
-      return __get_stride<N>(__extents, make_index_sequence<extents_type::rank()>());
+      return __get_stride<N>(__extents, std::make_index_sequence<extents_type::rank()>());
     }
 
 private:
    _MDSPAN_NO_UNIQUE_ADDRESS extents_type __extents{};
 
+   // [mdspan.submdspan.mapping], submdspan mapping specialization
+   template<class... SliceSpecifiers>
+   MDSPAN_INLINE_FUNCTION
+   constexpr auto submdspan_mapping_impl(
+       SliceSpecifiers... slices) const;
+
+   template<class... SliceSpecifiers>
+     friend constexpr auto submdspan_mapping(
+       const mapping& src, SliceSpecifiers... slices) {
+         return src.submdspan_mapping_impl(slices...);
+     }
 };
 
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/layout_stride.hpp b/tpls/mdspan/include/experimental/__p0009_bits/layout_stride.hpp
index c04c0c45ae..d6cdad2ab2 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/layout_stride.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/layout_stride.hpp
@@ -1,94 +1,87 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
-#include "static_array.hpp"
 #include "extents.hpp"
 #include "trait_backports.hpp"
 #include "compressed_pair.hpp"
+#include "utility.hpp"
 
 #if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
 #  include "no_unique_address.hpp"
 #endif
 
-#include <algorithm>
-#include <numeric>
 #include <array>
-#if  _MDSPAN_USE_CONCEPTS && MDSPAN_HAS_CXX_20
-#include<concepts>
+#include <type_traits>
+#include <utility>
+
+#ifdef __cpp_lib_span
+#include <span>
+#endif
+#if defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20 && defined(__cpp_lib_concepts)
+#  include <concepts>
 #endif
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 struct layout_left {
   template<class Extents>
-    class mapping;
+  class mapping;
 };
 struct layout_right {
   template<class Extents>
-    class mapping;
+  class mapping;
 };
 
 namespace detail {
   template<class Layout, class Mapping>
   constexpr bool __is_mapping_of =
-    is_same<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>::value;
+    std::is_same<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>::value;
+
+#if defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20
+#  if !defined(__cpp_lib_concepts)
+  namespace internal {
+  namespace detail {
+  template <typename _Tp, typename _Up>
+  concept __same_as = std::is_same_v<_Tp, _Up>;
+  } // namespace detail
+  template <class T, class U>
+  concept __same_as = detail::__same_as<T, U> && detail::__same_as<U, T>;
+  } // namespace internal
+#  endif
 
-#if  _MDSPAN_USE_CONCEPTS && MDSPAN_HAS_CXX_20
   template<class M>
   concept __layout_mapping_alike = requires {
     requires __is_extents<typename M::extents_type>::value;
-    { M::is_always_strided() } -> same_as<bool>;
-    { M::is_always_exhaustive() } -> same_as<bool>;
-    { M::is_always_unique() } -> same_as<bool>;
-    bool_constant<M::is_always_strided()>::value;
-    bool_constant<M::is_always_exhaustive()>::value;
-    bool_constant<M::is_always_unique()>::value;
+#if defined(__cpp_lib_concepts)
+    { M::is_always_strided() } -> std::same_as<bool>;
+    { M::is_always_exhaustive() } -> std::same_as<bool>;
+    { M::is_always_unique() } -> std::same_as<bool>;
+#else
+    { M::is_always_strided() } -> internal::__same_as<bool>;
+    { M::is_always_exhaustive() } -> internal::__same_as<bool>;
+    { M::is_always_unique() } -> internal::__same_as<bool>;
+#endif
+    std::bool_constant<M::is_always_strided()>::value;
+    std::bool_constant<M::is_always_exhaustive()>::value;
+    std::bool_constant<M::is_always_unique()>::value;
   };
 #endif
+
 } // namespace detail
 
 struct layout_stride {
@@ -98,7 +91,7 @@ struct layout_stride {
     : private detail::__no_unique_address_emulation<
         detail::__compressed_pair<
           Extents,
-          std::array<typename Extents::index_type, Extents::rank()>
+          detail::possibly_empty_array<typename Extents::index_type, Extents::rank()>
         >
       >
 #endif
@@ -111,14 +104,15 @@ struct layout_stride {
     using layout_type = layout_stride;
 
     // This could be a `requires`, but I think it's better and clearer as a `static_assert`.
-    static_assert(detail::__is_extents_v<Extents>, "std::experimental::layout_stride::mapping must be instantiated with a specialization of std::experimental::extents.");
+    static_assert(detail::__is_extents_v<Extents>,
+                  MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::layout_stride::mapping must be instantiated with a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
 
 
   private:
 
     //----------------------------------------------------------------------------
 
-    using __strides_storage_t = array<index_type, extents_type::rank()>;//::std::experimental::dextents<index_type, extents_type::rank()>;
+    using __strides_storage_t = detail::possibly_empty_array<index_type, extents_type::rank()>;
     using __member_pair_t = detail::__compressed_pair<extents_type, __strides_storage_t>;
 
 #if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
@@ -144,6 +138,12 @@ struct layout_stride {
 #endif
     }
 
+    template<class SizeType, size_t ... Ep, size_t ... Idx>
+    _MDSPAN_HOST_DEVICE
+    constexpr index_type __get_size(::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, Ep...>,std::integer_sequence<size_t, Idx...>) const {
+      return _MDSPAN_FOLD_TIMES_RIGHT( static_cast<index_type>(extents().extent(Idx)), 1 );
+    }
+
     //----------------------------------------------------------------------------
 
     template <class>
@@ -156,17 +156,21 @@ struct layout_stride {
     struct __deduction_workaround;
 
     template <size_t... Idxs>
-    struct __deduction_workaround<index_sequence<Idxs...>>
+    struct __deduction_workaround<std::index_sequence<Idxs...>>
     {
       template <class OtherExtents>
       MDSPAN_INLINE_FUNCTION
       static constexpr bool _eq_impl(mapping const& self, mapping<OtherExtents> const& other) noexcept {
-        return _MDSPAN_FOLD_AND((self.stride(Idxs) == other.stride(Idxs)) /* && ... */);
+        using common_t = std::common_type_t<index_type, typename OtherExtents::index_type>;
+        return    _MDSPAN_FOLD_AND((static_cast<common_t>(self.stride(Idxs)) == static_cast<common_t>(other.stride(Idxs))) /* && ... */)
+               && _MDSPAN_FOLD_AND((static_cast<common_t>(self.extents().extent(Idxs)) == static_cast<common_t>(other.extents().extent(Idxs))) /* || ... */);
       }
       template <class OtherExtents>
       MDSPAN_INLINE_FUNCTION
       static constexpr bool _not_eq_impl(mapping const& self, mapping<OtherExtents> const& other) noexcept {
-        return _MDSPAN_FOLD_OR((self.stride(Idxs) != other.stride(Idxs)) /* || ... */);
+        using common_t = std::common_type_t<index_type, typename OtherExtents::index_type>;
+        return    _MDSPAN_FOLD_OR((static_cast<common_t>(self.stride(Idxs)) != static_cast<common_t>(other.stride(Idxs))) /* || ... */)
+               || _MDSPAN_FOLD_OR((static_cast<common_t>(self.extents().extent(Idxs)) != static_cast<common_t>(other.extents().extent(Idxs))) /* || ... */);
       }
 
       template <class... Integral>
@@ -194,15 +198,35 @@ struct layout_stride {
 
       template<class IntegralType>
       MDSPAN_INLINE_FUNCTION
-      static constexpr const __strides_storage_t fill_strides(const array<IntegralType,extents_type::rank()>& s) {
+      static constexpr const __strides_storage_t fill_strides(const std::array<IntegralType,extents_type::rank()>& s) {
         return __strides_storage_t{static_cast<index_type>(s[Idxs])...};
       }
 
+      MDSPAN_TEMPLATE_REQUIRES(
+        class IntegralType,
+        // The is_convertible condition is added to make sfinae valid
+        // the extents_type::rank() > 0 is added to avoid use of non-standard zero length c-array
+        (std::is_convertible<IntegralType, typename extents_type::index_type>::value && (extents_type::rank() > 0))
+      )
       MDSPAN_INLINE_FUNCTION
-      static constexpr const __strides_storage_t fill_strides(
-        detail::__extents_to_partially_static_sizes_t<
-          ::std::experimental::dextents<index_type, extents_type::rank()>>&& s) {
-        return __strides_storage_t{static_cast<index_type>(s.template __get_n<Idxs>())...};
+      // despite the requirement some compilers still complain about zero length array during parsing
+      // making it length 1 now, but since the thing can't be instantiated due to requirement the actual
+      // instantiation of strides_storage will not fail despite mismatching length
+      static constexpr const __strides_storage_t fill_strides(mdspan_non_standard_tag, const IntegralType (&s)[extents_type::rank()>0?extents_type::rank():1]) {
+        return __strides_storage_t{static_cast<index_type>(s[Idxs])...};
+      }
+
+#ifdef __cpp_lib_span
+      template<class IntegralType>
+      MDSPAN_INLINE_FUNCTION
+      static constexpr const __strides_storage_t fill_strides(const std::span<IntegralType,extents_type::rank()>& s) {
+        return __strides_storage_t{static_cast<index_type>(s[Idxs])...};
+      }
+#endif
+
+      MDSPAN_INLINE_FUNCTION
+      static constexpr std::array<index_type, extents_type::rank()> return_strides(const __strides_storage_t& s) {
+        return std::array<index_type, extents_type::rank()>{s[Idxs]...};
       }
 
       template<size_t K>
@@ -216,8 +240,24 @@ struct layout_stride {
     };
 
     // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348.
-    using __impl = __deduction_workaround<make_index_sequence<Extents::rank()>>;
+    using __impl = __deduction_workaround<std::make_index_sequence<Extents::rank()>>;
+
+    static constexpr __strides_storage_t strides_storage(detail::with_rank<0>) {
+      return {};
+    }
+    template <std::size_t N>
+    static constexpr __strides_storage_t strides_storage(detail::with_rank<N>) {
+      __strides_storage_t s{};
+
+      extents_type e;
+      index_type stride = 1;
+      for(int r = static_cast<int>(extents_type::rank() - 1); r >= 0; r--) {
+        s[r] = stride;
+        stride *= e.extent(r);
+      }
 
+      return s;
+    }
 
     //----------------------------------------------------------------------------
 
@@ -229,52 +269,41 @@ struct layout_stride {
     mapping(__base_t&& __b) : __base_t(::std::move(__b)) {}
 #endif
 
-  public: // but not really
-    MDSPAN_INLINE_FUNCTION
-    static constexpr mapping
-    __make_mapping(
-      detail::__extents_to_partially_static_sizes_t<Extents>&& __exts,
-      detail::__extents_to_partially_static_sizes_t<
-        ::std::experimental::dextents<index_type, Extents::rank()>>&& __strs
-    ) noexcept {
-      // call the private constructor we created for this purpose
-      return mapping(
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        __base_t{
-#endif
-          __member_pair_t(
-            extents_type::__make_extents_impl(::std::move(__exts)),
-            __strides_storage_t{__impl::fill_strides(::std::move(__strs))}
-          )
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#endif
-      );
-    }
-    //----------------------------------------------------------------------------
-
-
   public:
 
     //--------------------------------------------------------------------------------
 
-    MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
+    MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept
+#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+      : __members{
+#else
+      : __base_t(__base_t{__member_pair_t(
+#endif
+          extents_type(),
+          __strides_storage_t(strides_storage(detail::with_rank<extents_type::rank()>{}))
+#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+        }
+#else
+        )})
+#endif
+    {}
+
     MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
 
     MDSPAN_TEMPLATE_REQUIRES(
       class IntegralTypes,
       /* requires */ (
         // MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type
-        // error C2641: cannot deduce template arguments for 'std::experimental::layout_stride::mapping'
-        _MDSPAN_TRAIT(is_convertible, const remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
-        _MDSPAN_TRAIT(is_nothrow_constructible, typename Extents::index_type, const remove_const_t<IntegralTypes>&)
+        // error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping'
+        _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
+        _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
       )
     )
     MDSPAN_INLINE_FUNCTION
     constexpr
     mapping(
       extents_type const& e,
-      array<IntegralTypes, extents_type::rank()> const& s
+      std::array<IntegralTypes, extents_type::rank()> const& s
     ) noexcept
 #if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
       : __members{
@@ -298,21 +327,63 @@ struct layout_stride {
        */
     }
 
+    MDSPAN_TEMPLATE_REQUIRES(
+      class IntegralTypes,
+      /* requires */ (
+        // MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type
+        // error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping'
+        _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
+        _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&) &&
+        (Extents::rank() > 0)
+      )
+    )
+    MDSPAN_INLINE_FUNCTION
+    constexpr
+    mapping(
+      mdspan_non_standard_tag,
+      extents_type const& e,
+      // despite the requirement some compilers still complain about zero length array during parsing
+      // making it length 1 now, but since the thing can't be instantiated due to requirement the actual
+      // instantiation of strides_storage will not fail despite mismatching length
+      IntegralTypes (&s)[extents_type::rank()>0?extents_type::rank():1]
+    ) noexcept
+#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+      : __members{
+#else
+      : __base_t(__base_t{__member_pair_t(
+#endif
+          e, __strides_storage_t(__impl::fill_strides(mdspan_non_standard, s))
+#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
+        }
+#else
+        )})
+#endif
+    {
+      /*
+       * TODO: check preconditions
+       * - s[i] > 0 is true for all i in the range [0, rank_ ).
+       * - REQUIRED-SPAN-SIZE(e, s) is a representable value of type index_type ([basic.fundamental]).
+       * - If rank_ is greater than 0, then there exists a permutation P of the integers in the
+       *   range [0, rank_), such that s[ pi ] >= s[ pi − 1 ] * e.extent( pi − 1 ) is true for
+       *   all i in the range [1, rank_ ), where pi is the ith element of P.
+       */
+    }
+
 #ifdef __cpp_lib_span
     MDSPAN_TEMPLATE_REQUIRES(
       class IntegralTypes,
       /* requires */ (
         // MSVC 19.32 does not like using index_type here, requires the typename Extents::index_type
-        // error C2641: cannot deduce template arguments for 'std::experimental::layout_stride::mapping'
-        _MDSPAN_TRAIT(is_convertible, const remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
-        _MDSPAN_TRAIT(is_nothrow_constructible, typename Extents::index_type, const remove_const_t<IntegralTypes>&)
+        // error C2641: cannot deduce template arguments for 'MDSPAN_IMPL_STANDARD_NAMESPACE::layout_stride::mapping'
+        _MDSPAN_TRAIT(std::is_convertible, const std::remove_const_t<IntegralTypes>&, typename Extents::index_type) &&
+        _MDSPAN_TRAIT(std::is_nothrow_constructible, typename Extents::index_type, const std::remove_const_t<IntegralTypes>&)
       )
     )
     MDSPAN_INLINE_FUNCTION
     constexpr
     mapping(
       extents_type const& e,
-      span<IntegralTypes, extents_type::rank()> const& s
+      std::span<IntegralTypes, extents_type::rank()> const& s
     ) noexcept
 #if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
       : __members{
@@ -337,11 +408,11 @@ struct layout_stride {
     }
 #endif // __cpp_lib_span
 
-#if !(_MDSPAN_USE_CONCEPTS && MDSPAN_HAS_CXX_20)
+#if !(defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20)
     MDSPAN_TEMPLATE_REQUIRES(
       class StridedLayoutMapping,
       /* requires */ (
-        _MDSPAN_TRAIT(is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
+        _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
         detail::__is_mapping_of<typename StridedLayoutMapping::layout_type, StridedLayoutMapping> &&
         StridedLayoutMapping::is_always_unique() &&
         StridedLayoutMapping::is_always_strided()
@@ -351,16 +422,16 @@ struct layout_stride {
     template<class StridedLayoutMapping>
     requires(
          detail::__layout_mapping_alike<StridedLayoutMapping> &&
-         _MDSPAN_TRAIT(is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
+         _MDSPAN_TRAIT(std::is_constructible, extents_type, typename StridedLayoutMapping::extents_type) &&
          StridedLayoutMapping::is_always_unique() &&
          StridedLayoutMapping::is_always_strided()
     )
 #endif
     MDSPAN_CONDITIONAL_EXPLICIT(
-      (!is_convertible<typename StridedLayoutMapping::extents_type, extents_type>::value) &&
-      (detail::__is_mapping_of<layout_left, StridedLayoutMapping> ||
-       detail::__is_mapping_of<layout_right, StridedLayoutMapping> ||
-       detail::__is_mapping_of<layout_stride, StridedLayoutMapping>)
+      !(std::is_convertible<typename StridedLayoutMapping::extents_type, extents_type>::value &&
+       (detail::__is_mapping_of<layout_left, StridedLayoutMapping> ||
+        detail::__is_mapping_of<layout_right, StridedLayoutMapping> ||
+        detail::__is_mapping_of<layout_stride, StridedLayoutMapping>))
     ) // needs two () due to comma
     MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
     mapping(StridedLayoutMapping const& other) noexcept // NOLINT(google-explicit-constructor)
@@ -398,8 +469,8 @@ struct layout_stride {
     };
 
     MDSPAN_INLINE_FUNCTION
-    constexpr array< index_type, extents_type::rank() > strides() const noexcept {
-      return __strides_storage();
+    constexpr std::array< index_type, extents_type::rank() > strides() const noexcept {
+      return __impl::return_strides(__strides_storage());
     }
 
     MDSPAN_INLINE_FUNCTION
@@ -408,7 +479,7 @@ struct layout_stride {
       for(unsigned r = 0; r < extents_type::rank(); r++) {
         // Return early if any of the extents are zero
         if(extents().extent(r)==0) return 0;
-        span_size = std::max(span_size, static_cast<index_type>(extents().extent(r) * __strides_storage()[r]));
+        span_size += ( static_cast<index_type>(extents().extent(r) - 1 ) * __strides_storage()[r]);
       }
       return span_size;
     }
@@ -418,13 +489,15 @@ struct layout_stride {
       class... Indices,
       /* requires */ (
         sizeof...(Indices) == Extents::rank() &&
-        _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, Indices, index_type) /*&& ...*/ ) &&
-        _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_nothrow_constructible, index_type, Indices) /*&& ...*/)
+        (detail::are_valid_indices<index_type, Indices...>())
       )
     )
     MDSPAN_FORCE_INLINE_FUNCTION
-    constexpr size_t operator()(Indices... idxs) const noexcept {
-      return __impl::_call_op_impl(*this, static_cast<index_type>(idxs)...);
+    constexpr index_type operator()(Indices... idxs) const noexcept {
+#if ! defined(NDEBUG)
+      detail::check_all_indices(this->extents(), idxs...);
+#endif // ! NDEBUG
+      return static_cast<index_type>(__impl::_call_op_impl(*this, static_cast<index_type>(idxs)...));
     }
 
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
@@ -434,44 +507,48 @@ struct layout_stride {
     MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; }
 
     MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept { return true; }
-    MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 bool is_exhaustive() const noexcept {
-// TODO @testing test layout_stride is_exhaustive()
-// FIXME CUDA
-#ifdef __CUDA_ARCH__
-      return false;
-#else
-      auto rem = array<size_t, Extents::rank()>{ };
-      std::iota(rem.begin(), rem.end(), size_t(0));
-      auto next_idx_iter = std::find_if(
-        rem.begin(), rem.end(),
-        [&](size_t i) { return this->stride(i) == 1;  }
-      );
-      if(next_idx_iter != rem.end()) {
-        size_t prev_stride_times_prev_extent =
-          this->extents().extent(*next_idx_iter) * this->stride(*next_idx_iter);
-        // "remove" the index
-        constexpr auto removed_index_sentinel = static_cast<size_t>(-1);
-        *next_idx_iter = removed_index_sentinel;
-        size_t found_count = 1;
-        while (found_count != Extents::rank()) {
-          next_idx_iter = std::find_if(
-            rem.begin(), rem.end(),
-            [&](size_t i) {
-              return i != removed_index_sentinel
-                && static_cast<size_t>(this->extents().extent(i)) == prev_stride_times_prev_extent;
-            }
-          );
-          if (next_idx_iter != rem.end()) {
-            // "remove" the index
-            *next_idx_iter = removed_index_sentinel;
-            ++found_count;
-            prev_stride_times_prev_extent = stride(*next_idx_iter) * this->extents().extent(*next_idx_iter);
-          } else { break; }
+
+  private:
+    constexpr bool exhaustive_for_nonzero_span_size() const
+    {
+      return required_span_size() == __get_size(extents(), std::make_index_sequence<extents_type::rank()>());
+    }
+
+    constexpr bool is_exhaustive_impl(detail::with_rank<0>) const
+    {
+      return true;
+    }
+    constexpr bool is_exhaustive_impl(detail::with_rank<1>) const
+    {
+      if (required_span_size() != static_cast<index_type>(0)) {
+        return exhaustive_for_nonzero_span_size();
+      }
+      return stride(0) == 1;
+    }
+    template <std::size_t N>
+    constexpr bool is_exhaustive_impl(detail::with_rank<N>) const
+    {
+      if (required_span_size() != static_cast<index_type>(0)) {
+        return exhaustive_for_nonzero_span_size();
+      }
+
+      rank_type r_largest = 0;
+      for (rank_type r = 1; r < extents_type::rank(); r++) {
+        if (stride(r) > stride(r_largest)) {
+          r_largest = r;
         }
-        return found_count == Extents::rank();
       }
-      return false;
-#endif
+      for (rank_type r = 0; r < extents_type::rank(); r++) {
+        if (extents().extent(r) == 0 && r != r_largest) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+  public:
+    MDSPAN_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 bool is_exhaustive() const noexcept {
+      return is_exhaustive_impl(detail::with_rank<extents_type::rank()>{});
     }
     MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; }
 
@@ -481,7 +558,7 @@ struct layout_stride {
       return __strides_storage()[r];
     }
 
-#if !(_MDSPAN_USE_CONCEPTS && MDSPAN_HAS_CXX_20)
+#if !(defined(_MDSPAN_USE_CONCEPTS) && MDSPAN_HAS_CXX_20)
     MDSPAN_TEMPLATE_REQUIRES(
       class StridedLayoutMapping,
       /* requires */ (
@@ -500,12 +577,9 @@ struct layout_stride {
 #endif
     MDSPAN_INLINE_FUNCTION
     friend constexpr bool operator==(const mapping& x, const StridedLayoutMapping& y) noexcept {
-      bool strides_match = true;
-      for(rank_type r = 0; r < extents_type::rank(); r++)
-        strides_match = strides_match && (x.stride(r) == y.stride(r));
       return (x.extents() == y.extents()) &&
-             (__impl::__OFFSET(y)== static_cast<typename StridedLayoutMapping::index_type>(0)) &&
-             strides_match;
+             (__impl::__OFFSET(y) == static_cast<typename StridedLayoutMapping::index_type>(0)) &&
+             detail::rankwise_equal(detail::with_rank<extents_type::rank()>{}, x, y, detail::stride);
     }
 
     // This one is not technically part of the proposal. Just here to make implementation a bit more optimal hopefully
@@ -531,7 +605,7 @@ struct layout_stride {
     )
     MDSPAN_INLINE_FUNCTION
     friend constexpr bool operator!=(const mapping& x, const StridedLayoutMapping& y) noexcept {
-      return not (x == y);
+      return !(x == y);
     }
 
     MDSPAN_TEMPLATE_REQUIRES(
@@ -546,8 +620,48 @@ struct layout_stride {
     }
 #endif
 
+   // [mdspan.submdspan.mapping], submdspan mapping specialization
+   template<class... SliceSpecifiers>
+   MDSPAN_INLINE_FUNCTION
+   constexpr auto submdspan_mapping_impl(
+       SliceSpecifiers... slices) const;
+
+   template<class... SliceSpecifiers>
+     friend constexpr auto submdspan_mapping(
+       const mapping& src, SliceSpecifiers... slices) {
+      return src.submdspan_mapping_impl(slices...);
+    }
   };
 };
 
-} // end namespace experimental
-} // end namespace std
+namespace detail {
+
+template <class Layout, class Extents, class Mapping>
+constexpr void validate_strides(with_rank<0>, Layout, const Extents&, const Mapping&)
+{}
+
+template <std::size_t N, class Layout, class Extents, class Mapping>
+constexpr void validate_strides(with_rank<N>, Layout, const Extents& ext, const Mapping& other)
+{
+  static_assert(std::is_same<typename Mapping::layout_type, layout_stride>::value &&
+                (std::is_same<Layout, layout_left>::value ||
+                 std::is_same<Layout, layout_right>::value)
+                , "This function is only intended to validate construction of "
+                  "a layout_left or layout_right mapping from a layout_stride mapping.");
+
+  constexpr auto is_left = std::is_same<Layout, layout_left>::value;
+
+  typename Extents::index_type expected_stride = 1;
+
+  for (std::size_t r = 0; r < N; r++) {
+    const std::size_t s = is_left ? r : N - 1 - r;
+
+    MDSPAN_IMPL_PRECONDITION(common_integral_compare(expected_stride, other.stride(s))
+                             && "invalid strides for layout_{left,right}");
+
+    expected_stride *= ext.extent(s);
+  }
+}
+
+} // namespace detail
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/macros.hpp b/tpls/mdspan/include/experimental/__p0009_bits/macros.hpp
index 848dcf91a7..b60c426177 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/macros.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/macros.hpp
@@ -1,52 +1,29 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 
 #pragma once
 
 #include "config.hpp"
 
+#include <cstdio>
+#include <cstdlib>
 #include <type_traits> // std::is_void
+#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_SYCL)
+#include "assert.h"
+#endif
 
 #ifndef _MDSPAN_HOST_DEVICE
 #  if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP)
@@ -68,6 +45,16 @@
 #  define MDSPAN_INLINE_FUNCTION inline _MDSPAN_HOST_DEVICE
 #endif
 
+#ifndef MDSPAN_FUNCTION
+#  define MDSPAN_FUNCTION _MDSPAN_HOST_DEVICE
+#endif
+
+#ifdef _MDSPAN_HAS_HIP
+#  define MDSPAN_DEDUCTION_GUIDE _MDSPAN_HOST_DEVICE
+#else
+#  define MDSPAN_DEDUCTION_GUIDE
+#endif
+
 // In CUDA defaulted functions do not need host device markup
 #ifndef MDSPAN_INLINE_FUNCTION_DEFAULTED
 #  define MDSPAN_INLINE_FUNCTION_DEFAULTED
@@ -116,6 +103,72 @@
 #define MDSPAN_PP_REMOVE_PARENS_IMPL(...) __VA_ARGS__
 #define MDSPAN_PP_REMOVE_PARENS(...) MDSPAN_PP_REMOVE_PARENS_IMPL __VA_ARGS__
 
+#define MDSPAN_IMPL_STANDARD_NAMESPACE_STRING MDSPAN_PP_STRINGIFY(MDSPAN_IMPL_STANDARD_NAMESPACE)
+#define MDSPAN_IMPL_PROPOSED_NAMESPACE_STRING MDSPAN_PP_STRINGIFY(MDSPAN_IMPL_STANDARD_NAMESPACE) "::" MDSPAN_PP_STRINGIFY(MDSPAN_IMPL_PROPOSED_NAMESPACE)
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace detail {
+
+#if defined(_MDSPAN_HAS_CUDA) || defined(_MDSPAN_HAS_HIP)
+MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line)
+{
+  printf("%s:%u: precondition failure: `%s`\n", file, line, cond);
+  assert(0);
+}
+#elif defined(_MDSPAN_HAS_SYCL)
+MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line)
+{
+  sycl::ext::oneapi::experimental::printf("%s:%u: precondition failure: `%s`\n", file, line, cond);
+  assert(0);
+}
+#else
+MDSPAN_FUNCTION inline void default_precondition_violation_handler(const char* cond, const char* file, unsigned line)
+{
+  std::fprintf(stderr, "%s:%u: precondition failure: `%s`\n", file, line, cond);
+  std::abort();
+}
+#endif
+
+} // namespace detail
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
+
+#ifndef MDSPAN_IMPL_PRECONDITION_VIOLATION_HANDLER
+#define MDSPAN_IMPL_PRECONDITION_VIOLATION_HANDLER(cond, file, line) \
+  MDSPAN_IMPL_STANDARD_NAMESPACE::detail::default_precondition_violation_handler(cond, file, line)
+#endif
+
+#ifndef MDSPAN_IMPL_CHECK_PRECONDITION
+  #ifndef NDEBUG
+    #define MDSPAN_IMPL_CHECK_PRECONDITION 0
+  #else
+    #define MDSPAN_IMPL_CHECK_PRECONDITION 1
+  #endif
+#endif
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace detail {
+
+template <bool check = MDSPAN_IMPL_CHECK_PRECONDITION>
+MDSPAN_FUNCTION constexpr void precondition(const char* cond, const char* file, unsigned line)
+{
+  if (!check) { return; }
+  // in case the macro doesn't use the arguments for custom macros
+  (void) cond;
+  (void) file;
+  (void) line;
+  MDSPAN_IMPL_PRECONDITION_VIOLATION_HANDLER(cond, file, line);
+}
+
+} // namespace detail
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
+
+#define MDSPAN_IMPL_PRECONDITION(...) \
+  do { \
+    if (!(__VA_ARGS__)) { \
+      MDSPAN_IMPL_STANDARD_NAMESPACE::detail::precondition(#__VA_ARGS__, __FILE__, __LINE__); \
+    } \
+  } while (0)
+
 // </editor-fold> end Preprocessor helpers }}}1
 //==============================================================================
 
@@ -139,8 +192,7 @@
      /**/
 #endif
 
-
-#if defined(_MDSPAN_COMPILER_MSVC)
+#if defined(_MDSPAN_COMPILER_MSVC) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL)
 #  define MDSPAN_TEMPLATE_REQUIRES(...) \
       MDSPAN_PP_CAT( \
         MDSPAN_PP_CAT(MDSPAN_TEMPLATE_REQUIRES_, MDSPAN_PP_COUNT(__VA_ARGS__))\
@@ -294,7 +346,7 @@ struct __mdspan_enable_fold_comma { };
 #  define _MDSPAN_FOLD_COMMA(...) ((__VA_ARGS__), ...)
 #else
 
-namespace std {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 namespace __fold_compatibility_impl {
 
@@ -590,22 +642,22 @@ __fold_left_assign_impl(Args&&... args) {
 
 
 template <class... Args>
-constexpr __mdspan_enable_fold_comma __fold_comma_impl(Args&&... args) noexcept { return { }; }
+constexpr __mdspan_enable_fold_comma __fold_comma_impl(Args&&...) noexcept { return { }; }
 
 template <bool... Bs>
 struct __bools;
 
 } // __fold_compatibility_impl
 
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
-#  define _MDSPAN_FOLD_AND(...) std::__fold_compatibility_impl::__fold_right_and_impl((__VA_ARGS__)...)
-#  define _MDSPAN_FOLD_OR(...) std::__fold_compatibility_impl::__fold_right_or_impl((__VA_ARGS__)...)
-#  define _MDSPAN_FOLD_ASSIGN_LEFT(INIT, ...) std::__fold_compatibility_impl::__fold_left_assign_impl(INIT, (__VA_ARGS__)...)
-#  define _MDSPAN_FOLD_ASSIGN_RIGHT(PACK, ...) std::__fold_compatibility_impl::__fold_right_assign_impl((PACK)..., __VA_ARGS__)
-#  define _MDSPAN_FOLD_TIMES_RIGHT(PACK, ...) std::__fold_compatibility_impl::__fold_right_times_impl((PACK)..., __VA_ARGS__)
-#  define _MDSPAN_FOLD_PLUS_RIGHT(PACK, ...) std::__fold_compatibility_impl::__fold_right_plus_impl((PACK)..., __VA_ARGS__)
-#  define _MDSPAN_FOLD_COMMA(...) std::__fold_compatibility_impl::__fold_comma_impl((__VA_ARGS__)...)
+#  define _MDSPAN_FOLD_AND(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_and_impl((__VA_ARGS__)...)
+#  define _MDSPAN_FOLD_OR(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_or_impl((__VA_ARGS__)...)
+#  define _MDSPAN_FOLD_ASSIGN_LEFT(INIT, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_left_assign_impl(INIT, (__VA_ARGS__)...)
+#  define _MDSPAN_FOLD_ASSIGN_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_assign_impl((PACK)..., __VA_ARGS__)
+#  define _MDSPAN_FOLD_TIMES_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_times_impl((PACK)..., __VA_ARGS__)
+#  define _MDSPAN_FOLD_PLUS_RIGHT(PACK, ...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_right_plus_impl((PACK)..., __VA_ARGS__)
+#  define _MDSPAN_FOLD_COMMA(...) MDSPAN_IMPL_STANDARD_NAMESPACE::__fold_compatibility_impl::__fold_comma_impl((__VA_ARGS__)...)
 
 #  define _MDSPAN_FOLD_AND_TEMPLATE(...) \
   _MDSPAN_TRAIT(std::is_same, __fold_compatibility_impl::__bools<(__VA_ARGS__)..., true>, __fold_compatibility_impl::__bools<true, (__VA_ARGS__)...>)
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/maybe_static_value.hpp b/tpls/mdspan/include/experimental/__p0009_bits/maybe_static_value.hpp
deleted file mode 100644
index 7abb1d5d65..0000000000
--- a/tpls/mdspan/include/experimental/__p0009_bits/maybe_static_value.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#include "macros.hpp"
-
-#include "dynamic_extent.hpp"
-
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-#  include "no_unique_address.hpp"
-#endif
-
-// This is only needed for the non-standard-layout version of partially
-// static array.
-// Needs to be after the includes above to work with the single header generator
-#if !_MDSPAN_PRESERVE_STANDARD_LAYOUT
-namespace std {
-namespace experimental {
-
-//==============================================================================
-
-namespace detail {
-
-// static case
-template <class _dynamic_t, class static_t, _static_t __v,
-          _static_t __is_dynamic_sentinal = dynamic_extent,
-          size_t __array_entry_index = 0>
-struct __maybe_static_value {
-  static constexpr _static_t __static_value = __v;
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t __value() const noexcept {
-    return static_cast<_dynamic_t>(__v);
-  }
-  template <class _U>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
-  __mdspan_enable_fold_comma
-  __set_value(_U&& /*__rhs*/) noexcept {
-    // Should we assert that the value matches the static value here?
-    return {};
-  }
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __maybe_static_value() noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __maybe_static_value(__maybe_static_value const&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __maybe_static_value(__maybe_static_value&&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __maybe_static_value& operator=(__maybe_static_value const&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __maybe_static_value& operator=(__maybe_static_value&&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__maybe_static_value() noexcept = default;
-
-  MDSPAN_INLINE_FUNCTION
-  constexpr explicit __maybe_static_value(_dynamic_t const&) noexcept {
-    // Should we assert that the value matches the static value here?
-  }
-
-  //--------------------------------------------------------------------------
-
-};
-
-// dynamic case
-template <class _dynamic_t, class _static_t, _static_t __is_dynamic_sentinal, size_t __array_entry_index>
-struct __maybe_static_value<_dynamic_t, _static_t, __is_dynamic_sentinal, __is_dynamic_sentinal,
-                            __array_entry_index>
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : __no_unique_address_emulation<_T>
-#endif
-{
-  static constexpr _static_t __static_value = __is_dynamic_sentinal;
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-  _MDSPAN_NO_UNIQUE_ADDRESS _dynamic_t __v = {};
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t __value() const noexcept {
-    return __v;
-  }
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _dynamic_t &__ref() noexcept {
-    return __v;
-  }
-  template <class _U>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
-  __mdspan_enable_fold_comma
-  __set_value(_U&& __rhs) noexcept {
-    __v = (_U &&)rhs;
-    return {};
-  }
-#else
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _dynamic_t __value() const noexcept {
-    return this->__no_unique_address_emulation<_dynamic_t>::__ref();
-  }
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 _dynamic_t &__ref() noexcept {
-    return this->__no_unique_address_emulation<_dynamic_t>::__ref();
-  }
-  template <class _U>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14
-  __mdspan_enable_fold_comma
-  __set_value(_U&& __rhs) noexcept {
-    this->__no_unique_address_emulation<_dynamic_t>::__ref() = (_U &&)__rhs;
-    return {};
-  }
-#endif
-};
-
-} // namespace detail
-
-//==============================================================================
-
-} // end namespace experimental
-} // end namespace std
-
-#endif // !_MDSPAN_PRESERVE_STANDARD_LAYOUT
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/mdspan.hpp b/tpls/mdspan/include/experimental/__p0009_bits/mdspan.hpp
index 374444c053..23114aa550 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/mdspan.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/mdspan.hpp
@@ -1,46 +1,18 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 
 #pragma once
 
@@ -50,9 +22,7 @@
 #include "trait_backports.hpp"
 #include "compressed_pair.hpp"
 
-namespace std {
-namespace experimental {
-
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 template <
   class ElementType,
   class Extents,
@@ -62,28 +32,38 @@ template <
 class mdspan
 {
 private:
-  static_assert(detail::__is_extents_v<Extents>, "std::experimental::mdspan's Extents template parameter must be a specialization of std::experimental::extents.");
+  static_assert(detail::__is_extents_v<Extents>,
+                MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::mdspan's Extents template parameter must be a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
+  static_assert(std::is_same<ElementType, typename AccessorPolicy::element_type>::value,
+                MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::mdspan's ElementType template parameter must be the same as its AccessorPolicy::element_type.");
 
   // Workaround for non-deducibility of the index sequence template parameter if it's given at the top level
   template <class>
   struct __deduction_workaround;
 
   template <size_t... Idxs>
-  struct __deduction_workaround<index_sequence<Idxs...>>
+  struct __deduction_workaround<std::index_sequence<Idxs...>>
   {
     MDSPAN_FORCE_INLINE_FUNCTION static constexpr
     size_t __size(mdspan const& __self) noexcept {
-      return _MDSPAN_FOLD_TIMES_RIGHT((__self.__mapping_ref().extents().template __extent<Idxs>()), /* * ... * */ size_t(1));
+      return _MDSPAN_FOLD_TIMES_RIGHT((__self.__mapping_ref().extents().extent(Idxs)), /* * ... * */ size_t(1));
     }
     MDSPAN_FORCE_INLINE_FUNCTION static constexpr
     bool __empty(mdspan const& __self) noexcept {
-      return (__self.rank()>0) && _MDSPAN_FOLD_OR((__self.__mapping_ref().extents().template __extent<Idxs>()==index_type(0)));
+      return (__self.rank()>0) && _MDSPAN_FOLD_OR((__self.__mapping_ref().extents().extent(Idxs)==index_type(0)));
     }
     template <class ReferenceType, class SizeType, size_t N>
     MDSPAN_FORCE_INLINE_FUNCTION static constexpr
-    ReferenceType __callop(mdspan const& __self, const array<SizeType, N>& indices) noexcept {
+    ReferenceType __callop(mdspan const& __self, const std::array<SizeType, N>& indices) noexcept {
       return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...));
     }
+#ifdef __cpp_lib_span
+    template <class ReferenceType, class SizeType, size_t N>
+    MDSPAN_FORCE_INLINE_FUNCTION static constexpr
+    ReferenceType __callop(mdspan const& __self, const std::span<SizeType, N>& indices) noexcept {
+      return __self.__accessor_ref().access(__self.__ptr_ref(), __self.__mapping_ref()(indices[Idxs]...));
+    }
+#endif
   };
 
 public:
@@ -96,7 +76,7 @@ class mdspan
   using accessor_type = AccessorPolicy;
   using mapping_type = typename layout_type::template mapping<extents_type>;
   using element_type = ElementType;
-  using value_type = remove_cv_t<element_type>;
+  using value_type = std::remove_cv_t<element_type>;
   using index_type = typename extents_type::index_type;
   using size_type = typename extents_type::size_type;
   using rank_type = typename extents_type::rank_type;
@@ -111,7 +91,7 @@ class mdspan
 private:
 
   // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348.
-  using __impl = __deduction_workaround<make_index_sequence<extents_type::rank()>>;
+  using __impl = __deduction_workaround<std::make_index_sequence<extents_type::rank()>>;
 
   using __map_acc_pair_t = detail::__compressed_pair<mapping_type, accessor_type>;
 
@@ -125,10 +105,11 @@ class mdspan
 #else
   MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan()
     requires(
-       (rank_dynamic() > 0) &&
-       _MDSPAN_TRAIT(is_default_constructible, data_handle_type) &&
-       _MDSPAN_TRAIT(is_default_constructible, mapping_type) &&
-       _MDSPAN_TRAIT(is_default_constructible, accessor_type)
+       // nvhpc has a bug where using just rank_dynamic() here doesn't work ...
+       (extents_type::rank_dynamic() > 0) &&
+       _MDSPAN_TRAIT(std::is_default_constructible, data_handle_type) &&
+       _MDSPAN_TRAIT(std::is_default_constructible, mapping_type) &&
+       _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
      ) = default;
 #endif
   MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdspan(const mdspan&) = default;
@@ -137,11 +118,10 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeTypes) /* && ... */) &&
       ((sizeof...(SizeTypes) == rank()) || (sizeof...(SizeTypes) == rank_dynamic())) &&
-      _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type) &&
-      _MDSPAN_TRAIT(is_default_constructible, accessor_type)
+      (detail::are_valid_indices<index_type, SizeTypes...>()) &&
+      _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) &&
+      _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
     )
   )
   MDSPAN_INLINE_FUNCTION
@@ -153,16 +133,16 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType, size_t N,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeType) &&
+      _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) &&
       ((N == rank()) || (N == rank_dynamic())) &&
-      _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type) &&
-      _MDSPAN_TRAIT(is_default_constructible, accessor_type)
+      _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) &&
+      _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
     )
   )
   MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic())
   MDSPAN_INLINE_FUNCTION
-  constexpr mdspan(data_handle_type p, const array<SizeType, N>& dynamic_extents)
+  constexpr mdspan(data_handle_type p, const std::array<SizeType, N>& dynamic_extents)
     : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(dynamic_extents)), accessor_type()))
   { }
 
@@ -170,16 +150,16 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType, size_t N,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeType) &&
+      _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&) &&
       ((N == rank()) || (N == rank_dynamic())) &&
-      _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type) &&
-      _MDSPAN_TRAIT(is_default_constructible, accessor_type)
+      _MDSPAN_TRAIT(std::is_constructible, mapping_type, extents_type) &&
+      _MDSPAN_TRAIT(std::is_default_constructible, accessor_type)
     )
   )
   MDSPAN_CONDITIONAL_EXPLICIT(N != rank_dynamic())
   MDSPAN_INLINE_FUNCTION
-  constexpr mdspan(data_handle_type p, span<SizeType, N> dynamic_extents)
+  constexpr mdspan(data_handle_type p, std::span<SizeType, N> dynamic_extents)
     : __members(std::move(p), __map_acc_pair_t(mapping_type(extents_type(as_const(dynamic_extents))), accessor_type()))
   { }
 #endif
@@ -187,15 +167,15 @@ class mdspan
   MDSPAN_FUNCTION_REQUIRES(
     (MDSPAN_INLINE_FUNCTION constexpr),
     mdspan, (data_handle_type p, const extents_type& exts), ,
-    /* requires */ (_MDSPAN_TRAIT(is_default_constructible, accessor_type) &&
-                    _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+    /* requires */ (_MDSPAN_TRAIT(std::is_default_constructible, accessor_type) &&
+                    _MDSPAN_TRAIT(std::is_constructible, mapping_type, const extents_type&))
   ) : __members(std::move(p), __map_acc_pair_t(mapping_type(exts), accessor_type()))
   { }
 
   MDSPAN_FUNCTION_REQUIRES(
     (MDSPAN_INLINE_FUNCTION constexpr),
     mdspan, (data_handle_type p, const mapping_type& m), ,
-    /* requires */ (_MDSPAN_TRAIT(is_default_constructible, accessor_type))
+    /* requires */ (_MDSPAN_TRAIT(std::is_default_constructible, accessor_type))
   ) : __members(std::move(p), __map_acc_pair_t(m, accessor_type()))
   { }
 
@@ -207,16 +187,20 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessor,
     /* requires */ (
-      _MDSPAN_TRAIT(is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping<OtherExtents>) &&
-      _MDSPAN_TRAIT(is_constructible, accessor_type, OtherAccessor)
+      _MDSPAN_TRAIT(std::is_constructible, mapping_type, const typename OtherLayoutPolicy::template mapping<OtherExtents>&) &&
+      _MDSPAN_TRAIT(std::is_constructible, accessor_type, const OtherAccessor&)
     )
   )
+  MDSPAN_CONDITIONAL_EXPLICIT(
+    !_MDSPAN_TRAIT(std::is_convertible, const typename OtherLayoutPolicy::template mapping<OtherExtents>&, mapping_type) ||
+    !_MDSPAN_TRAIT(std::is_convertible, const OtherAccessor&, accessor_type)
+  )
   MDSPAN_INLINE_FUNCTION
   constexpr mdspan(const mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessor>& other)
     : __members(other.__ptr_ref(), __map_acc_pair_t(other.__mapping_ref(), other.__accessor_ref()))
   {
-      static_assert(_MDSPAN_TRAIT(is_constructible, data_handle_type, typename OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction");
-      static_assert(_MDSPAN_TRAIT(is_constructible, extents_type, OtherExtents),"Incompatible extents for mdspan construction");
+      static_assert(_MDSPAN_TRAIT(std::is_constructible, data_handle_type, typename OtherAccessor::data_handle_type),"Incompatible data_handle_type for mdspan construction");
+      static_assert(_MDSPAN_TRAIT(std::is_constructible, extents_type, OtherExtents),"Incompatible extents for mdspan construction");
       /*
        * TODO: Check precondition
        * For each rank index r of extents_type, static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r) is true.
@@ -239,27 +223,27 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeTypes) /* && ... */) &&
+      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, SizeTypes, index_type) /* && ... */) &&
+      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, SizeTypes) /* && ... */) &&
       (rank() == sizeof...(SizeTypes))
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr reference operator[](SizeTypes... indices) const
   {
-    return __accessor_ref().access(__ptr_ref(), __mapping_ref()(index_type(indices)...));
+    return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast<index_type>(std::move(indices))...));
   }
   #endif
 
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeType)
+      _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr reference operator[](const array<SizeType, rank()>& indices) const
+  constexpr reference operator[](const std::array< SizeType, rank()>& indices) const
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -268,12 +252,12 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeType)
+      _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr reference operator[](span<SizeType, rank()> indices) const
+  constexpr reference operator[](std::span<SizeType, rank()> indices) const
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -283,15 +267,15 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class Index,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, Index, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, Index) &&
+      _MDSPAN_TRAIT(std::is_convertible, Index, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, Index) &&
       extents_type::rank() == 1
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr reference operator[](Index idx) const
   {
-    return __accessor_ref().access(__ptr_ref(), __mapping_ref()(index_type(idx)));
+    return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast<index_type>(std::move(idx))));
   }
   #endif
 
@@ -299,26 +283,25 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeTypes) /* && ... */) &&
-      extents_type::rank() == sizeof...(SizeTypes)
+      extents_type::rank() == sizeof...(SizeTypes) &&
+      (detail::are_valid_indices<index_type, SizeTypes...>())
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr reference operator()(SizeTypes... indices) const
   {
-    return __accessor_ref().access(__ptr_ref(), __mapping_ref()(indices...));
+    return __accessor_ref().access(__ptr_ref(), __mapping_ref()(static_cast<index_type>(std::move(indices))...));
   }
 
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeType)
+      _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr reference operator()(const array<SizeType, rank()>& indices) const
+  constexpr reference operator()(const std::array<SizeType, rank()>& indices) const
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -327,20 +310,20 @@ class mdspan
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
-      _MDSPAN_TRAIT(is_nothrow_constructible, index_type, SizeType)
+      _MDSPAN_TRAIT(std::is_convertible, const SizeType&, index_type) &&
+      _MDSPAN_TRAIT(std::is_nothrow_constructible, index_type, const SizeType&)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr reference operator()(span<SizeType, rank()> indices) const
+  constexpr reference operator()(std::span<SizeType, rank()> indices) const
   {
     return __impl::template __callop<reference>(*this, indices);
   }
   #endif // __cpp_lib_span
   #endif // MDSPAN_USE_PAREN_OPERATOR
 
-  MDSPAN_INLINE_FUNCTION constexpr size_t size() const noexcept {
-    return __impl::__size(*this);
+  MDSPAN_INLINE_FUNCTION constexpr size_type size() const noexcept {
+    return static_cast<size_type>(__impl::__size(*this));
   };
 
   MDSPAN_INLINE_FUNCTION constexpr bool empty() const noexcept {
@@ -349,9 +332,17 @@ class mdspan
 
   MDSPAN_INLINE_FUNCTION
   friend constexpr void swap(mdspan& x, mdspan& y) noexcept {
+    // can't call the std::swap inside on HIP
+    #if !defined(_MDSPAN_HAS_HIP) && !defined(_MDSPAN_HAS_CUDA)
+    using std::swap;
     swap(x.__ptr_ref(), y.__ptr_ref());
     swap(x.__mapping_ref(), y.__mapping_ref());
     swap(x.__accessor_ref(), y.__accessor_ref());
+    #else
+    mdspan tmp = y;
+    y = x;
+    x = tmp;
+    #endif
   }
 
   //--------------------------------------------------------------------------------
@@ -366,13 +357,13 @@ class mdspan
   //--------------------------------------------------------------------------------
   // [mdspan.basic.obs], mdspan observers of the mapping
 
-  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); };
-  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return mapping_type::is_always_exhaustive(); };
-  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return mapping_type::is_always_strided(); };
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() { return mapping_type::is_always_unique(); };
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() { return mapping_type::is_always_exhaustive(); };
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() { return mapping_type::is_always_strided(); };
 
-  MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return __mapping_ref().is_unique(); };
-  MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return __mapping_ref().is_exhaustive(); };
-  MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return __mapping_ref().is_strided(); };
+  MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const { return __mapping_ref().is_unique(); };
+  MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const { return __mapping_ref().is_exhaustive(); };
+  MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const { return __mapping_ref().is_strided(); };
   MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return __mapping_ref().stride(r); };
 
 private:
@@ -394,51 +385,48 @@ class mdspan
 #if defined(_MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
 MDSPAN_TEMPLATE_REQUIRES(
   class ElementType, class... SizeTypes,
-  /* requires */ _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_integral, SizeTypes) /* && ... */) &&
+  /* requires */ _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(std::is_convertible, SizeTypes, size_t) /* && ... */) &&
   (sizeof...(SizeTypes) > 0)
 )
-explicit mdspan(ElementType*, SizeTypes...)
-  -> mdspan<ElementType, ::std::experimental::dextents<size_t, sizeof...(SizeTypes)>>;
+MDSPAN_DEDUCTION_GUIDE explicit mdspan(ElementType*, SizeTypes...)
+  -> mdspan<ElementType, ::MDSPAN_IMPL_STANDARD_NAMESPACE::dextents<size_t, sizeof...(SizeTypes)>>;
 
 MDSPAN_TEMPLATE_REQUIRES(
   class Pointer,
-  (_MDSPAN_TRAIT(is_pointer, std::remove_reference_t<Pointer>))
+  (_MDSPAN_TRAIT(std::is_pointer, std::remove_reference_t<Pointer>))
 )
-mdspan(Pointer&&) -> mdspan<std::remove_pointer_t<std::remove_reference_t<Pointer>>, extents<size_t>>;
+MDSPAN_DEDUCTION_GUIDE mdspan(Pointer&&) -> mdspan<std::remove_pointer_t<std::remove_reference_t<Pointer>>, extents<size_t>>;
 
 MDSPAN_TEMPLATE_REQUIRES(
   class CArray,
-  (_MDSPAN_TRAIT(is_array, CArray) && (rank_v<CArray> == 1))
+  (_MDSPAN_TRAIT(std::is_array, CArray) && (std::rank_v<CArray> == 1))
 )
-mdspan(CArray&) -> mdspan<std::remove_all_extents_t<CArray>, extents<size_t, ::std::extent_v<CArray,0>>>;
+MDSPAN_DEDUCTION_GUIDE mdspan(CArray&) -> mdspan<std::remove_all_extents_t<CArray>, extents<size_t, ::std::extent_v<CArray,0>>>;
 
 template <class ElementType, class SizeType, size_t N>
-mdspan(ElementType*, const ::std::array<SizeType, N>&)
-  -> mdspan<ElementType, ::std::experimental::dextents<size_t, N>>;
+MDSPAN_DEDUCTION_GUIDE mdspan(ElementType*, const ::std::array<SizeType, N>&)
+  -> mdspan<ElementType, ::MDSPAN_IMPL_STANDARD_NAMESPACE::dextents<size_t, N>>;
 
 #ifdef __cpp_lib_span
 template <class ElementType, class SizeType, size_t N>
-mdspan(ElementType*, ::std::span<SizeType, N>)
-  -> mdspan<ElementType, ::std::experimental::dextents<size_t, N>>;
+MDSPAN_DEDUCTION_GUIDE mdspan(ElementType*, ::std::span<SizeType, N>)
+  -> mdspan<ElementType, ::MDSPAN_IMPL_STANDARD_NAMESPACE::dextents<size_t, N>>;
 #endif
 
 // This one is necessary because all the constructors take `data_handle_type`s, not
 // `ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which
 // seems to throw off automatic deduction guides.
 template <class ElementType, class SizeType, size_t... ExtentsPack>
-mdspan(ElementType*, const extents<SizeType, ExtentsPack...>&)
-  -> mdspan<ElementType, ::std::experimental::extents<SizeType, ExtentsPack...>>;
+MDSPAN_DEDUCTION_GUIDE mdspan(ElementType*, const extents<SizeType, ExtentsPack...>&)
+  -> mdspan<ElementType, ::MDSPAN_IMPL_STANDARD_NAMESPACE::extents<SizeType, ExtentsPack...>>;
 
 template <class ElementType, class MappingType>
-mdspan(ElementType*, const MappingType&)
+MDSPAN_DEDUCTION_GUIDE mdspan(ElementType*, const MappingType&)
   -> mdspan<ElementType, typename MappingType::extents_type, typename MappingType::layout_type>;
 
 template <class MappingType, class AccessorType>
-mdspan(const typename AccessorType::data_handle_type, const MappingType&, const AccessorType&)
+MDSPAN_DEDUCTION_GUIDE mdspan(const typename AccessorType::data_handle_type, const MappingType&, const AccessorType&)
   -> mdspan<typename AccessorType::element_type, typename MappingType::extents_type, typename MappingType::layout_type, AccessorType>;
 #endif
 
-
-
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp b/tpls/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp
index 904dd40a75..36e64ee24d 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/no_unique_address.hpp
@@ -1,53 +1,24 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #pragma once
 
 #include "macros.hpp"
 #include "trait_backports.hpp"
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 namespace detail {
 
 //==============================================================================
@@ -70,17 +41,17 @@ struct __no_unique_address_emulation {
 template <class _T, size_t _Disambiguator>
 struct __no_unique_address_emulation<
     _T, _Disambiguator,
-    enable_if_t<_MDSPAN_TRAIT(is_empty, _T) &&
+    std::enable_if_t<_MDSPAN_TRAIT(std::is_empty, _T) &&
                 // If the type isn't trivially destructible, its destructor
                 // won't be called at the right time, so don't use this
                 // specialization
-                _MDSPAN_TRAIT(is_trivially_destructible, _T)>> : 
+                _MDSPAN_TRAIT(std::is_trivially_destructible, _T)>> :
 #ifdef _MDSPAN_COMPILER_MSVC
     // MSVC doesn't allow you to access public static member functions of a type
     // when you *happen* to privately inherit from that type.
     protected
 #else
-    // But we still want this to be private if possible so that we don't accidentally 
+    // But we still want this to be private if possible so that we don't accidentally
     // access members of _T directly rather than calling __ref() first, which wouldn't
     // work if _T happens to be stateful and thus we're using the unspecialized definition
     // of __no_unique_address_emulation above.
@@ -123,5 +94,4 @@ struct __no_unique_address_emulation<
 //==============================================================================
 
 } // end namespace detail
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/standard_layout_static_array.hpp b/tpls/mdspan/include/experimental/__p0009_bits/standard_layout_static_array.hpp
deleted file mode 100644
index 1c543b0805..0000000000
--- a/tpls/mdspan/include/experimental/__p0009_bits/standard_layout_static_array.hpp
+++ /dev/null
@@ -1,685 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#pragma once
-
-#include "macros.hpp"
-#include "dynamic_extent.hpp"
-#include "trait_backports.hpp" // enable_if
-#include "compressed_pair.hpp"
-
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-#  include "no_unique_address.hpp"
-#endif
-
-#include <array>
-#ifdef __cpp_lib_span
-#include <span>
-#endif
-#include <utility> // integer_sequence
-#include <cstddef>
-
-namespace std {
-namespace experimental {
-namespace detail {
-
-//==============================================================================
-
-_MDSPAN_INLINE_VARIABLE constexpr struct
-    __construct_psa_from_dynamic_exts_values_tag_t {
-} __construct_psa_from_dynamic_exts_values_tag = {};
-
-_MDSPAN_INLINE_VARIABLE constexpr struct
-    __construct_psa_from_all_exts_values_tag_t {
-} __construct_psa_from_all_exts_values_tag = {};
-
-struct __construct_psa_from_all_exts_array_tag_t {};
-template <size_t _N = 0> struct __construct_psa_from_dynamic_exts_array_tag_t {};
-
-//==============================================================================
-
-template <size_t _I, class _T> using __repeated_with_idxs = _T;
-
-//==============================================================================
-
-#if _MDSPAN_PRESERVE_STANDARD_LAYOUT
-
-/**
- *  PSA = "partially static array"
- *
- * @tparam _T
- * @tparam _ValsSeq
- * @tparam __sentinal
- */
-template <class _Tag, class _T, class _static_t, class _ValsSeq, _static_t __sentinal = static_cast<_static_t>(dynamic_extent),
-          class _IdxsSeq = make_index_sequence<_ValsSeq::size()>>
-struct __standard_layout_psa;
-
-//==============================================================================
-// Static case
-template <class _Tag, class _T, class _static_t, _static_t __value, _static_t... __values_or_sentinals,
-          _static_t __sentinal, size_t _Idx, size_t... _Idxs>
-struct __standard_layout_psa<
-    _Tag, _T, _static_t, integer_sequence<_static_t, __value, __values_or_sentinals...>,
-    __sentinal, integer_sequence<size_t, _Idx, _Idxs...>>
-#if !defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    : private __no_unique_address_emulation<__standard_layout_psa<
-          _Tag, _T, _static_t, integer_sequence<_static_t, __values_or_sentinals...>, __sentinal,
-          integer_sequence<size_t, _Idxs...>>>
-#endif
-{
-
-  //--------------------------------------------------------------------------
-
-  using __next_t =
-      __standard_layout_psa<_Tag, _T, _static_t,
-                            integer_sequence<_static_t, __values_or_sentinals...>,
-                            __sentinal, integer_sequence<size_t, _Idxs...>>;
-
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-  _MDSPAN_NO_UNIQUE_ADDRESS __next_t __next_;
-#else
-  using __base_t = __no_unique_address_emulation<__next_t>;
-#endif
-
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 __next_t &__next() noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    return __next_;
-#else
-    return this->__base_t::__ref();
-#endif
-  }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t const &__next() const noexcept {
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-    return __next_;
-#else
-    return this->__base_t::__ref();
-#endif
-  }
-
-  static constexpr auto __size = sizeof...(_Idxs) + 1;
-  static constexpr auto __size_dynamic = __next_t::__size_dynamic;
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa() noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept =
-      default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
-  operator=(__standard_layout_psa const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
-  operator=(__standard_layout_psa &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__standard_layout_psa() noexcept = default;
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION
-  constexpr __standard_layout_psa(
-      __construct_psa_from_all_exts_values_tag_t, _T const & /*__val*/,
-      __repeated_with_idxs<_Idxs, _T> const &... __vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __construct_psa_from_all_exts_values_tag, __vals...
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  template <class... _Ts>
-  MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_values_tag_t,
-      _Ts const &... __vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __construct_psa_from_dynamic_exts_values_tag, __vals...
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  template <class _U, size_t _N>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      array<_U, _N> const &__vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __vals
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  template <class _U, size_t _NStatic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_all_exts_array_tag_t const & __tag,
-      array<_U, _NStatic> const &__vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __tag, __vals
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  template <class _U, size_t _IDynamic, size_t _NDynamic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic> __tag,
-      array<_U, _NDynamic> const &__vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __tag, __vals
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-#ifdef __cpp_lib_span
-  template <class _U, size_t _N>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      span<_U, _N> const &__vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __vals
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  template <class _U, size_t _NStatic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_all_exts_array_tag_t const & __tag,
-      span<_U, _NStatic> const &__vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __tag, __vals
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  template <class _U, size_t _IDynamic, size_t _NDynamic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic> __tag,
-      span<_U, _NDynamic> const &__vals) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __tag, __vals
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-#endif
-
-  template <class _UTag, class _U, class _static_U, class _UValsSeq, _static_U __u_sentinal,
-            class _IdxsSeq>
-  MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
-      __standard_layout_psa<_UTag, _U, _static_U, _UValsSeq, __u_sentinal, _IdxsSeq> const
-          &__rhs) noexcept
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-      : __next_{
-#else
-      : __base_t(__base_t{__next_t(
-#endif
-          __rhs.__next()
-#if defined(_MDSPAN_USE_ATTRIBUTE_NO_UNIQUE_ADDRESS)
-        }
-#else
-        )})
-#endif
-  { }
-
-  //--------------------------------------------------------------------------
-
-  // See https://godbolt.org/z/_KSDNX for a summary-by-example of why this is
-  // necessary. We're using inheritance here instead of an alias template
-  // because we have to deduce __values_or_sentinals in several places, and
-  // alias templates don't permit that in this context.
-  MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr __standard_layout_psa const &__enable_psa_conversion() const
-      noexcept {
-    return *this;
-  }
-
-  template <size_t _I, enable_if_t<_I != _Idx, int> = 0>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get_n() const noexcept {
-    return __next().template __get_n<_I>();
-  }
-  template <size_t _I, enable_if_t<_I == _Idx, int> = 1>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get_n() const noexcept {
-    return __value;
-  }
-  template <size_t _I, enable_if_t<_I != _Idx, int> = 0>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 void
-  __set_n(_T const &__rhs) noexcept {
-    __next().__set_value(__rhs);
-  }
-  template <size_t _I, enable_if_t<_I == _Idx, int> = 1>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 void
-  __set_n(_T const &) noexcept {
-    // Don't assert here because that would break constexpr. This better
-    // not change anything, though
-  }
-  template <size_t _I, enable_if_t<_I == _Idx, _static_t> = __sentinal>
-  MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
-    return __value;
-  }
-  template <size_t _I, enable_if_t<_I != _Idx, _static_t> __default = __sentinal>
-  MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
-    return __next_t::template __get_static_n<_I, __default>();
-  }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get(size_t __n) const noexcept {
-    return __value * (_T(_Idx == __n)) + __next().__get(__n);
-  }
-
-  //--------------------------------------------------------------------------
-};
-
-//==============================================================================
-
-// Dynamic case, __next_t may or may not be empty
-template <class _Tag, class _T, class _static_t, _static_t __sentinal, _static_t... __values_or_sentinals,
-          size_t _Idx, size_t... _Idxs>
-struct __standard_layout_psa<
-    _Tag, _T, _static_t, integer_sequence<_static_t, __sentinal, __values_or_sentinals...>,
-    __sentinal, integer_sequence<size_t, _Idx, _Idxs...>> {
-  //--------------------------------------------------------------------------
-
-  using __next_t =
-      __standard_layout_psa<_Tag, _T, _static_t,
-                            integer_sequence<_static_t, __values_or_sentinals...>,
-                            __sentinal, integer_sequence<size_t, _Idxs...>>;
-
-  using __value_pair_t = __compressed_pair<_T, __next_t>;
-  __value_pair_t __value_pair;
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 __next_t &__next() noexcept {
-    return __value_pair.__second();
-  }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr __next_t const &__next() const noexcept {
-    return __value_pair.__second();
-  }
-
-  static constexpr auto __size = sizeof...(_Idxs) + 1;
-  static constexpr auto __size_dynamic = 1 + __next_t::__size_dynamic;
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa() noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept =
-      default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
-  operator=(__standard_layout_psa const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
-  operator=(__standard_layout_psa &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__standard_layout_psa() noexcept = default;
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION
-  constexpr __standard_layout_psa(
-      __construct_psa_from_all_exts_values_tag_t, _T const &__val,
-      __repeated_with_idxs<_Idxs, _T> const &... __vals) noexcept
-      : __value_pair(__val,
-                     __next_t(__construct_psa_from_all_exts_values_tag,
-                              __vals...)) {}
-
-  template <class... _Ts>
-  MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_values_tag_t, _T const &__val,
-      _Ts const &... __vals) noexcept
-      : __value_pair(__val,
-                     __next_t(__construct_psa_from_dynamic_exts_values_tag,
-                              __vals...)) {}
-
-  template <class _U, size_t _N>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      array<_U, _N> const &__vals) noexcept
-      : __value_pair(::std::get<_Idx>(__vals), __vals) {}
-
-  template <class _U, size_t _NStatic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_all_exts_array_tag_t __tag,
-      array<_U, _NStatic> const &__vals) noexcept
-      : __value_pair(
-            ::std::get<_Idx>(__vals),
-            __next_t(__tag,
-                     __vals)) {}
-
-  template <class _U, size_t _IDynamic, size_t _NDynamic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
-      array<_U, _NDynamic> const &__vals) noexcept
-      : __value_pair(
-            ::std::get<_IDynamic>(__vals),
-            __next_t(__construct_psa_from_dynamic_exts_array_tag_t<_IDynamic + 1>{},
-                     __vals)) {}
-
-#ifdef __cpp_lib_span
-  template <class _U, size_t _N>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      span<_U, _N> const &__vals) noexcept
-      : __value_pair(__vals[_Idx], __vals) {}
-
-  template <class _U, size_t _NStatic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_all_exts_array_tag_t __tag,
-      span<_U, _NStatic> const &__vals) noexcept
-      : __value_pair(
-            __vals[_Idx],
-            __next_t(__tag,
-                     __vals)) {}
-
-  template <class _U, size_t _IDynamic, size_t _NDynamic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
-      span<_U, _NDynamic> const &__vals) noexcept
-      : __value_pair(
-            __vals[_IDynamic],
-            __next_t(__construct_psa_from_dynamic_exts_array_tag_t<_IDynamic + 1>{},
-                     __vals)) {}
-#endif
-
-  template <class _UTag, class _U, class _static_U, class _UValsSeq, _static_U __u_sentinal,
-            class _UIdxsSeq>
-  MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
-      __standard_layout_psa<_UTag, _U, _static_U, _UValsSeq, __u_sentinal, _UIdxsSeq> const
-          &__rhs) noexcept
-      : __value_pair(__rhs.template __get_n<_Idx>(), __rhs.__next()) {}
-
-  //--------------------------------------------------------------------------
-
-  // See comment in the previous partial specialization for why this is
-  // necessary.  Or just trust me that it's messy.
-  MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr __standard_layout_psa const &__enable_psa_conversion() const
-      noexcept {
-    return *this;
-  }
-
-  template <size_t _I, enable_if_t<_I != _Idx, int> = 0>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get_n() const noexcept {
-    return __next().template __get_n<_I>();
-  }
-  template <size_t _I, enable_if_t<_I == _Idx, int> = 1>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get_n() const noexcept {
-    return __value_pair.__first();
-  }
-  template <size_t _I, enable_if_t<_I != _Idx, int> = 0>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 void
-  __set_n(_T const &__rhs) noexcept {
-    __next().__set_value(__rhs);
-  }
-  template <size_t _I, enable_if_t<_I == _Idx, int> = 1>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 void
-  __set_n(_T const &__rhs) noexcept {
-    __value_pair.__first() = __rhs;
-  }
-  template <size_t _I, enable_if_t<_I == _Idx, _static_t> __default = __sentinal>
-  MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
-    return __default;
-  }
-  template <size_t _I, enable_if_t<_I != _Idx, _static_t> __default = __sentinal>
-  MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t __get_static_n() noexcept {
-    return __next_t::template __get_static_n<_I, __default>();
-  }
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get(size_t __n) const noexcept {
-    return __value_pair.__first() * (_T(_Idx == __n)) + __next().__get(__n);
-  }
-
-  //--------------------------------------------------------------------------
-};
-
-// empty/terminal case
-template <class _Tag, class _T, class _static_t, _static_t __sentinal>
-struct __standard_layout_psa<_Tag, _T, _static_t, integer_sequence<_static_t>, __sentinal,
-                             integer_sequence<size_t>> {
-  //--------------------------------------------------------------------------
-
-  static constexpr auto __size = 0;
-  static constexpr auto __size_dynamic = 0;
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa() noexcept
-#if defined(__clang__) || defined(_MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND)
-  // As far as I can tell, there appears to be a bug in clang that's causing
-  // this to be non-constexpr when it's defaulted.
-  { }
-#else
-   = default;
-#endif
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa(__standard_layout_psa const &) noexcept =
-      default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __standard_layout_psa(__standard_layout_psa &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
-  operator=(__standard_layout_psa const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __standard_layout_psa &
-  operator=(__standard_layout_psa &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__standard_layout_psa() noexcept = default;
-
-  MDSPAN_INLINE_FUNCTION
-  constexpr __standard_layout_psa(
-      __construct_psa_from_all_exts_values_tag_t) noexcept {}
-
-  template <class... _Ts>
-  MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_values_tag_t) noexcept {}
-
-  template <class _U, size_t _N>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      array<_U, _N> const &) noexcept {}
-
-  template <class _U, size_t _NStatic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_all_exts_array_tag_t,
-      array<_U, _NStatic> const &) noexcept {}
-
-  template <class _U, size_t _IDynamic, size_t _NDynamic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
-      array<_U, _NDynamic> const &) noexcept {}
-
-#ifdef __cpp_lib_span
-  template <class _U, size_t _N>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      span<_U, _N> const &) noexcept {}
-
-  template <class _U, size_t _NStatic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_all_exts_array_tag_t,
-      span<_U, _NStatic> const &) noexcept {}
-
-  template <class _U, size_t _IDynamic, size_t _NDynamic>
-  MDSPAN_INLINE_FUNCTION constexpr explicit __standard_layout_psa(
-      __construct_psa_from_dynamic_exts_array_tag_t<_IDynamic>,
-      span<_U, _NDynamic> const &) noexcept {}
-#endif
-
-  template <class _UTag, class _U, class _static_U, class _UValsSeq, _static_U __u_sentinal,
-            class _UIdxsSeq>
-  MDSPAN_INLINE_FUNCTION constexpr __standard_layout_psa(
-      __standard_layout_psa<_UTag, _U, _static_U, _UValsSeq, __u_sentinal, _UIdxsSeq> const&) noexcept {}
-
-  // See comment in the previous partial specialization for why this is
-  // necessary.  Or just trust me that it's messy.
-  MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr __standard_layout_psa const &__enable_psa_conversion() const
-      noexcept {
-    return *this;
-  }
-
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get(size_t /*n*/) const noexcept {
-    return 0;
-  }
-};
-
-// Same thing, but with a disambiguator so that same-base issues doesn't cause
-// a loss of standard-layout-ness.
-template <class _Tag, class T, class _static_t, _static_t... __values_or_sentinals>
-struct __partially_static_sizes_tagged
-    : __standard_layout_psa<
-          _Tag, T, _static_t,
-          integer_sequence<_static_t, __values_or_sentinals...>> {
-  using __tag_t = _Tag;
-  using __psa_impl_t = __standard_layout_psa<
-      _Tag, T, _static_t, integer_sequence<_static_t, __values_or_sentinals...>>;
-  using __psa_impl_t::__psa_impl_t;
-#ifdef _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
-  MDSPAN_INLINE_FUNCTION
-#endif
-  constexpr __partially_static_sizes_tagged() noexcept
-#ifdef _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
-    : __psa_impl_t() { }
-#else
-    = default;
-#endif
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __partially_static_sizes_tagged(
-      __partially_static_sizes_tagged const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __partially_static_sizes_tagged(
-      __partially_static_sizes_tagged &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_sizes_tagged &
-  operator=(__partially_static_sizes_tagged const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_sizes_tagged &
-  operator=(__partially_static_sizes_tagged &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__partially_static_sizes_tagged() noexcept = default;
-
-  template <class _UTag>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr explicit __partially_static_sizes_tagged(
-    __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...> const& __vals
-  ) noexcept : __psa_impl_t(__vals.__enable_psa_conversion()) { }
-};
-
-struct __no_tag {};
-template <class T, class _static_t, _static_t... __values_or_sentinals>
-struct __partially_static_sizes
-    : __partially_static_sizes_tagged<__no_tag, T, _static_t, __values_or_sentinals...> {
-private:
-  using __base_t =
-      __partially_static_sizes_tagged<__no_tag, T, _static_t, __values_or_sentinals...>;
-  template <class _UTag>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes(
-    __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...>&& __vals
-  ) noexcept : __base_t(::std::move(__vals)) { }
-public:
-  using __base_t::__base_t;
-
-#ifdef _MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
-  MDSPAN_INLINE_FUNCTION
-  constexpr __partially_static_sizes() noexcept : __base_t() { }
-#endif
-  template <class _UTag>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes_tagged<
-      _UTag, T, _static_t, __values_or_sentinals...>
-  __with_tag() const noexcept {
-    return __partially_static_sizes_tagged<_UTag, T, _static_t, __values_or_sentinals...>(*this);
-  }
-};
-
-#endif // _MDSPAN_PRESERVE_STATIC_LAYOUT
-
-} // end namespace detail
-} // end namespace experimental
-} // end namespace std
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/static_array.hpp b/tpls/mdspan/include/experimental/__p0009_bits/static_array.hpp
deleted file mode 100644
index 548bd8c8a7..0000000000
--- a/tpls/mdspan/include/experimental/__p0009_bits/static_array.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#pragma once
-
-#include "macros.hpp"
-
-#include "dynamic_extent.hpp"
-#include "trait_backports.hpp"
-#include "maybe_static_value.hpp"
-#include "standard_layout_static_array.hpp"
-#include "type_list.hpp"
-
-// Needs to be after the includes above to work with the single header generator
-#if !_MDSPAN_PRESERVE_STANDARD_LAYOUT
-#include <cstddef> // size_t
-#include <utility> // integer_sequence
-#include <array>
-
-namespace std {
-namespace experimental {
-namespace detail {
-
-//==============================================================================
-
-template <class _T, _T _Val, bool _Mask> struct __mask_element {};
-
-template <class _T, _T... _Result>
-struct __mask_sequence_assign_op {
-  template <_T _V>
-  __mask_sequence_assign_op<_T, _Result..., _V>
-  operator=(__mask_element<_T, _V, true>&&);
-  template <_T _V>
-  __mask_sequence_assign_op<_T, _Result...>
-  operator=(__mask_element<_T, _V, false>&&);
-  using __result = integer_sequence<_T, _Result...>;
-};
-
-template <class _Seq, class _Mask>
-struct __mask_sequence;
-
-template <class _T, _T... _Vals, bool... _Masks>
-struct __mask_sequence<integer_sequence<_T, _Vals...>, integer_sequence<bool, _Masks...>>
-{
-  using type = typename decltype(
-    _MDSPAN_FOLD_ASSIGN_LEFT(
-      __mask_sequence_assign_op<_T>{}, /* = ... = */ __mask_element<_T, _Vals, _Masks>{}
-    )
-  )::__result;
-};
-
-//==============================================================================
-
-template <class _T, class _static_t, class _Vals, _static_t __sentinal,
-          class _Idxs, class _IdxsDynamic, class _IdxsDynamicIdxs>
-class __partially_static_array_impl;
-
-template <
-  class _T, class _static_t,
-  _static_t... __values_or_sentinals, _static_t __sentinal,
-  size_t... _Idxs,
-  size_t... _IdxsDynamic,
-  size_t... _IdxsDynamicIdxs
->
-class __partially_static_array_impl<
-  _T,
-  _static_t,
-  integer_sequence<_static_t, __values_or_sentinals...>,
-  __sentinal,
-  integer_sequence<size_t, _Idxs...>,
-  integer_sequence<size_t, _IdxsDynamic...>,
-  integer_sequence<size_t, _IdxsDynamicIdxs...>
->
-    : private __maybe_static_value<_T, _static_t, __values_or_sentinals, __sentinal,
-                                   _Idxs>... {
-private:
-
-  template <size_t _N>
-  using __base_n = typename __type_at<_N,
-    __type_list<__maybe_static_value<_T, _static_t, __values_or_sentinals, __sentinal, _Idxs>...>
-  >::type;
-
-public:
-
-  static constexpr auto __size = sizeof...(_Idxs);
-  static constexpr auto __size_dynamic =
-    _MDSPAN_FOLD_PLUS_RIGHT(static_cast<int>((__values_or_sentinals == __sentinal)), /* + ... + */ 0);
-
-  //--------------------------------------------------------------------------
-
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __partially_static_array_impl() = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __partially_static_array_impl(
-      __partially_static_array_impl const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  constexpr __partially_static_array_impl(
-      __partially_static_array_impl &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_array_impl &
-  operator=(__partially_static_array_impl const &) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  _MDSPAN_CONSTEXPR_14_DEFAULTED __partially_static_array_impl &
-  operator=(__partially_static_array_impl &&) noexcept = default;
-  MDSPAN_INLINE_FUNCTION_DEFAULTED
-  ~__partially_static_array_impl() noexcept = default;
-
-  MDSPAN_INLINE_FUNCTION
-  constexpr __partially_static_array_impl(
-      __construct_psa_from_all_exts_values_tag_t,
-      __repeated_with_idxs<_Idxs, _T> const &... __vals) noexcept
-      : __base_n<_Idxs>(__base_n<_Idxs>{{__vals}})... {}
-
-  MDSPAN_INLINE_FUNCTION
-  constexpr __partially_static_array_impl(
-      __construct_psa_from_dynamic_exts_values_tag_t,
-      __repeated_with_idxs<_IdxsDynamicIdxs, _T> const &... __vals) noexcept
-      : __base_n<_IdxsDynamic>(__base_n<_IdxsDynamic>{{__vals}})... {}
-
-  MDSPAN_INLINE_FUNCTION constexpr explicit __partially_static_array_impl(
-    array<_T, sizeof...(_Idxs)> const& __vals) noexcept
-    : __partially_static_array_impl(
-        __construct_psa_from_all_exts_values_tag,
-        ::std::get<_Idxs>(__vals)...) {}
-
-  // clang-format off
-  MDSPAN_FUNCTION_REQUIRES(
-    (MDSPAN_INLINE_FUNCTION constexpr explicit),
-    __partially_static_array_impl,
-    (array<_T, __size_dynamic> const &__vals), noexcept,
-    /* requires */
-      (sizeof...(_Idxs) != __size_dynamic)
-  ): __partially_static_array_impl(
-       __construct_psa_from_dynamic_exts_values_tag,
-       ::std::get<_IdxsDynamicIdxs>(__vals)...) {}
-  // clang-format on
-
-  template <class _U, class _static_u, class _UValsSeq, _static_u __u_sentinal, class _UIdxsSeq,
-            class _UIdxsDynamicSeq, class _UIdxsDynamicIdxsSeq>
-  MDSPAN_INLINE_FUNCTION constexpr __partially_static_array_impl(
-    __partially_static_array_impl<
-      _U, _static_u, _UValsSeq, __u_sentinal, _UIdxsSeq,
-     _UIdxsDynamicSeq, _UIdxsDynamicIdxsSeq> const &__rhs) noexcept
-    : __partially_static_array_impl(
-        __construct_psa_from_all_exts_values_tag,
-        __rhs.template __get_n<_Idxs>()...) {}
-
-  //--------------------------------------------------------------------------
-
-  // See comment in the previous partial specialization for why this is
-  // necessary.  Or just trust me that it's messy.
-  MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr __partially_static_array_impl const &__enable_psa_conversion() const
-  noexcept {
-      return *this;
-  }
-
-  template <size_t _I>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T __get_n() const noexcept {
-    return static_cast<__base_n<_I> const*>(this)->__value();
-  }
-
-  template <class _U, size_t _I>
-  MDSPAN_FORCE_INLINE_FUNCTION _MDSPAN_CONSTEXPR_14 void __set_n(_U&& __rhs) noexcept {
-    static_cast<__base_n<_I>*>(this)->__set_value((_U&&)__rhs);
-  }
-
-  template <size_t _I, _static_t __default = __sentinal>
-  MDSPAN_FORCE_INLINE_FUNCTION static constexpr _static_t
-  __get_static_n() noexcept {
-    return __base_n<_I>::__static_value == __sentinal ?
-      __default : __base_n<_I>::__static_value;
-  }
-
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr _T
-  __get(size_t __n) const noexcept {
-    return _MDSPAN_FOLD_PLUS_RIGHT(
-      (_T(_Idxs == __n) * __get_n<_Idxs>()), /* + ... + */ _T(0)
-    );
-  }
-
-};
-
-//==============================================================================
-
-template <class _T, class _static_t, class _ValSeq, _static_t __sentinal, class _Idxs = make_index_sequence<_ValSeq::size()>>
-struct __partially_static_array_impl_maker;
-
-template <
-  class _T, class _static_t,  _static_t... _Vals, _static_t __sentinal, size_t... _Idxs
->
-struct __partially_static_array_impl_maker<
-  _T, _static_t, integer_sequence<_static_t, _Vals...>, __sentinal, integer_sequence<size_t, _Idxs...>
->
-{
-  using __dynamic_idxs = typename __mask_sequence<
-    integer_sequence<size_t, _Idxs...>,
-    integer_sequence<bool, (_Vals == __sentinal)...>
-  >::type;
-  using __impl_base =
-    __partially_static_array_impl<_T, _static_t,
-      integer_sequence<_static_t, _Vals...>,
-      __sentinal, integer_sequence<size_t, _Idxs...>,
-      __dynamic_idxs,
-      make_index_sequence<__dynamic_idxs::size()>
-    >;
-};
-
-template <class _T, class _static_t, class _ValsSeq, _static_t __sentinal = dynamic_extent>
-class __partially_static_array_with_sentinal
-  : public __partially_static_array_impl_maker<_T, _static_t, _ValsSeq, __sentinal>::__impl_base
-{
-private:
-  using __base_t = typename __partially_static_array_impl_maker<_T, _static_t, _ValsSeq, __sentinal>::__impl_base;
-public:
-  using __base_t::__base_t;
-};
-
-//==============================================================================
-
-template <class T, class _static_t, _static_t... __values_or_sentinals>
-struct __partially_static_sizes :
-  __partially_static_array_with_sentinal<
-    T, _static_t, ::std::integer_sequence<_static_t, __values_or_sentinals...>>
-{
-private:
-  using __base_t = __partially_static_array_with_sentinal<
-    T, _static_t, ::std::integer_sequence<_static_t, __values_or_sentinals...>>;
-public:
-  using __base_t::__base_t;
-  template <class _UTag>
-  MDSPAN_FORCE_INLINE_FUNCTION constexpr __partially_static_sizes<T, _static_t, __values_or_sentinals...>
-  __with_tag() const noexcept {
-    return *this;
-  }
-};
-
-// Tags are needed for the standard layout version, but not here
-template <class T, class _static_t, _static_t... __values_or_sentinals>
-using __partially_static_sizes_tagged = __partially_static_sizes<T, _static_t, __values_or_sentinals...>;
-
-} // end namespace detail
-} // end namespace experimental
-} // end namespace std
-
-#endif // !_MDSPAN_PRESERVE_STANDARD_LAYOUT
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/submdspan.hpp b/tpls/mdspan/include/experimental/__p0009_bits/submdspan.hpp
deleted file mode 100644
index dde1ab15bf..0000000000
--- a/tpls/mdspan/include/experimental/__p0009_bits/submdspan.hpp
+++ /dev/null
@@ -1,586 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-
-#pragma once
-
-#include "mdspan.hpp"
-#include "full_extent_t.hpp"
-#include "dynamic_extent.hpp"
-#include "layout_left.hpp"
-#include "layout_right.hpp"
-#include "layout_stride.hpp"
-#include "macros.hpp"
-#include "trait_backports.hpp"
-
-#include <tuple> // std::apply
-#include <utility> // std::pair
-
-namespace std {
-namespace experimental {
-
-namespace detail {
-
-template <size_t OldExtent, size_t OldStaticStride, class T>
-struct __slice_wrap {
-  T slice;
-  size_t old_extent;
-  size_t old_stride;
-};
-
-//--------------------------------------------------------------------------------
-
-template <size_t OldExtent, size_t OldStaticStride>
-MDSPAN_INLINE_FUNCTION constexpr
-__slice_wrap<OldExtent, OldStaticStride, size_t>
-__wrap_slice(size_t val, size_t ext, size_t stride) { return { val, ext, stride }; }
-
-template <size_t OldExtent, size_t OldStaticStride, class IntegerType, IntegerType Value0>
-MDSPAN_INLINE_FUNCTION constexpr
-__slice_wrap<OldExtent, OldStaticStride, std::integral_constant<IntegerType, Value0>>
-__wrap_slice(size_t val, size_t ext, std::integral_constant<IntegerType, Value0> stride)
-{
-#if MDSPAN_HAS_CXX_17
-  if constexpr (std::is_signed_v<IntegerType>) {
-    static_assert(Value0 >= IntegerType(0), "Invalid slice specifier");
-  }
-#endif // MDSPAN_HAS_CXX_17
-
-  return { val, ext, stride };
-}
-
-template <size_t OldExtent, size_t OldStaticStride>
-MDSPAN_INLINE_FUNCTION constexpr
-__slice_wrap<OldExtent, OldStaticStride, full_extent_t>
-__wrap_slice(full_extent_t val, size_t ext, size_t stride) { return { val, ext, stride }; }
-
-// TODO generalize this to anything that works with std::get<0> and std::get<1>
-template <size_t OldExtent, size_t OldStaticStride>
-MDSPAN_INLINE_FUNCTION constexpr
-__slice_wrap<OldExtent, OldStaticStride, std::tuple<size_t, size_t>>
-__wrap_slice(std::tuple<size_t, size_t> const& val, size_t ext, size_t stride)
-{
-  return { val, ext, stride };
-}
-
-template <size_t OldExtent, size_t OldStaticStride,
-	  class IntegerType0, IntegerType0 Value0,
-	  class IntegerType1, IntegerType1 Value1>
-MDSPAN_INLINE_FUNCTION constexpr
-  __slice_wrap<OldExtent, OldStaticStride,
-               std::tuple<std::integral_constant<IntegerType0, Value0>,
-                          std::integral_constant<IntegerType1, Value1>>>
-__wrap_slice(std::tuple<std::integral_constant<IntegerType0, Value0>, std::integral_constant<IntegerType1, Value1>> const& val, size_t ext, size_t stride)
-{
-  static_assert(Value1 >= Value0, "Invalid slice tuple");
-  return { val, ext, stride };
-}
-
-//--------------------------------------------------------------------------------
-
-
-// a layout right remains a layout right if it is indexed by 0 or more scalars,
-// then optionally a pair and finally 0 or more all
-template <
-  // what we encountered until now preserves the layout right
-  bool result=true,
-  // we only encountered 0 or more scalars, no pair or all
-  bool encountered_only_scalar=true
->
-struct preserve_layout_right_analysis : integral_constant<bool, result> {
-  using layout_type_if_preserved = layout_right;
-  using encounter_pair = preserve_layout_right_analysis<
-    // if we encounter a pair, the layout remains a layout right only if it was one before
-    // and that only scalars were encountered until now
-    result && encountered_only_scalar,
-    // if we encounter a pair, we didn't encounter scalars only
-    false
-  >;
-  using encounter_all = preserve_layout_right_analysis<
-    // if we encounter a all, the layout remains a layout right if it was one before
-    result,
-    // if we encounter a all, we didn't encounter scalars only
-    false
-  >;
-  using encounter_scalar = preserve_layout_right_analysis<
-    // if we encounter a scalar, the layout remains a layout right only if it was one before
-    // and that only scalars were encountered until now
-    result && encountered_only_scalar,
-    // if we encounter a scalar, the fact that we encountered scalars only doesn't change
-    encountered_only_scalar
-  >;
-};
-
-// a layout left remains a layout left if it is indexed by 0 or more all,
-// then optionally a pair and finally 0 or more scalars
-template <
-  bool result=true,
-  bool encountered_only_all=true
->
-struct preserve_layout_left_analysis : integral_constant<bool, result> {
-  using layout_type_if_preserved = layout_left;
-  using encounter_pair = preserve_layout_left_analysis<
-    // if we encounter a pair, the layout remains a layout left only if it was one before
-    // and that only all were encountered until now
-    result && encountered_only_all,
-    // if we encounter a pair, we didn't encounter all only
-    false
-  >;
-  using encounter_all = preserve_layout_left_analysis<
-    // if we encounter a all, the layout remains a layout left only if it was one before
-    // and that only all were encountered until now
-    result && encountered_only_all,
-    // if we encounter a all, the fact that we encountered scalars all doesn't change
-    encountered_only_all
-  >;
-  using encounter_scalar = preserve_layout_left_analysis<
-    // if we encounter a scalar, the layout remains a layout left if it was one before
-    result,
-    // if we encounter a scalar, we didn't encounter scalars only
-    false
-  >;
-};
-
-struct ignore_layout_preservation : std::integral_constant<bool, false> {
-  using layout_type_if_preserved = void;
-  using encounter_pair = ignore_layout_preservation;
-  using encounter_all = ignore_layout_preservation;
-  using encounter_scalar = ignore_layout_preservation;
-};
-
-template <class Layout>
-struct preserve_layout_analysis
-  : ignore_layout_preservation { };
-template <>
-struct preserve_layout_analysis<layout_right>
-  : preserve_layout_right_analysis<> { };
-template <>
-struct preserve_layout_analysis<layout_left>
-  : preserve_layout_left_analysis<> { };
-
-//--------------------------------------------------------------------------------
-
-template <
-  class _IndexT,
-  class _PreserveLayoutAnalysis,
-  class _OffsetsArray=__partially_static_sizes<_IndexT, size_t>,
-  class _ExtsArray=__partially_static_sizes<_IndexT, size_t>,
-  class _StridesArray=__partially_static_sizes<_IndexT, size_t>,
-  class = make_index_sequence<_OffsetsArray::__size>,
-  class = make_index_sequence<_ExtsArray::__size>,
-  class = make_index_sequence<_StridesArray::__size>
->
-struct __assign_op_slice_handler;
-
-/* clang-format: off */
-template <
-  class _IndexT,
-  class _PreserveLayoutAnalysis,
-  size_t... _Offsets,
-  size_t... _Exts,
-  size_t... _Strides,
-  size_t... _OffsetIdxs,
-  size_t... _ExtIdxs,
-  size_t... _StrideIdxs>
-struct __assign_op_slice_handler<
-  _IndexT,
-  _PreserveLayoutAnalysis,
-  __partially_static_sizes<_IndexT, size_t, _Offsets...>,
-  __partially_static_sizes<_IndexT, size_t, _Exts...>,
-  __partially_static_sizes<_IndexT, size_t, _Strides...>,
-  integer_sequence<size_t, _OffsetIdxs...>,
-  integer_sequence<size_t, _ExtIdxs...>,
-  integer_sequence<size_t, _StrideIdxs...>>
-{
-  // TODO remove this for better compiler performance
-  static_assert(
-    _MDSPAN_FOLD_AND((_Strides == dynamic_extent || _Strides > 0) /* && ... */),
-    " "
-  );
-  static_assert(
-    _MDSPAN_FOLD_AND((_Offsets == dynamic_extent || _Offsets >= 0) /* && ... */),
-    " "
-  );
-
-  using __offsets_storage_t = __partially_static_sizes<_IndexT, size_t, _Offsets...>;
-  using __extents_storage_t = __partially_static_sizes<_IndexT, size_t, _Exts...>;
-  using __strides_storage_t = __partially_static_sizes<_IndexT, size_t, _Strides...>;
-  __offsets_storage_t __offsets;
-  __extents_storage_t __exts;
-  __strides_storage_t __strides;
-
-#ifdef __INTEL_COMPILER
-#if __INTEL_COMPILER <= 1800
-  MDSPAN_INLINE_FUNCTION constexpr __assign_op_slice_handler(__assign_op_slice_handler&& __other) noexcept
-    : __offsets(::std::move(__other.__offsets)), __exts(::std::move(__other.__exts)), __strides(::std::move(__other.__strides))
-  { }
-  MDSPAN_INLINE_FUNCTION constexpr __assign_op_slice_handler(
-    __offsets_storage_t&& __o,
-    __extents_storage_t&& __e,
-    __strides_storage_t&& __s
-  ) noexcept
-    : __offsets(::std::move(__o)), __exts(::std::move(__e)), __strides(::std::move(__s))
-  { }
-#endif
-#endif
-
-// Don't define this unless we need it; they have a cost to compile
-#ifndef _MDSPAN_USE_RETURN_TYPE_DEDUCTION
-  using __extents_type = ::std::experimental::extents<_IndexT, _Exts...>;
-#endif
-
-  // For size_t slice, skip the extent and stride, but add an offset corresponding to the value
-  template <size_t _OldStaticExtent, size_t _OldStaticStride>
-  MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
-  _MDSPAN_CONSTEXPR_14 auto
-  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, size_t>&& __slice) noexcept
-    -> __assign_op_slice_handler<
-         _IndexT,
-         typename _PreserveLayoutAnalysis::encounter_scalar,
-         __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>,
-         __partially_static_sizes<_IndexT, size_t, _Exts...>,
-         __partially_static_sizes<_IndexT, size_t, _Strides...>/* intentional space here to work around ICC bug*/> {
-    return {
-      __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>(
-        __construct_psa_from_all_exts_values_tag,
-        __offsets.template __get_n<_OffsetIdxs>()..., __slice.slice),
-      ::std::move(__exts),
-      ::std::move(__strides)
-    };
-  }
-
-  // Treat integral_constant slice like size_t slice, but with a compile-time offset.
-  // The result's extents_type can't take advantage of that,
-  // but it might help for specialized layouts.
-  template <size_t _OldStaticExtent, size_t _OldStaticStride, class IntegerType, IntegerType Value0>
-  MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
-  _MDSPAN_CONSTEXPR_14 auto
-  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, std::integral_constant<IntegerType, Value0>>&&) noexcept
-    -> __assign_op_slice_handler<
-         _IndexT,
-         typename _PreserveLayoutAnalysis::encounter_scalar,
-         __partially_static_sizes<_IndexT, size_t, _Offsets..., Value0>,
-         __partially_static_sizes<_IndexT, size_t, _Exts...>,
-         __partially_static_sizes<_IndexT, size_t, _Strides...>/* intentional space here to work around ICC bug*/> {
-#if MDSPAN_HAS_CXX_17
-    if constexpr (std::is_signed_v<IntegerType>) {
-      static_assert(Value0 >= IntegerType(0), "Invalid slice specifier");
-    }
-#endif // MDSPAN_HAS_CXX_17
-    return {
-      __partially_static_sizes<_IndexT, size_t, _Offsets..., Value0>(
-        __construct_psa_from_all_exts_values_tag,
-        __offsets.template __get_n<_OffsetIdxs>()..., size_t(Value0)),
-      ::std::move(__exts),
-      ::std::move(__strides)
-    };
-  }
-
-  // For a std::full_extent, offset 0 and old extent
-  template <size_t _OldStaticExtent, size_t _OldStaticStride>
-  MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
-  _MDSPAN_CONSTEXPR_14 auto
-  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, full_extent_t>&& __slice) noexcept
-    -> __assign_op_slice_handler<
-         _IndexT,
-         typename _PreserveLayoutAnalysis::encounter_all,
-         __partially_static_sizes<_IndexT, size_t, _Offsets..., 0>,
-         __partially_static_sizes<_IndexT, size_t, _Exts..., _OldStaticExtent>,
-         __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> {
-    return {
-      __partially_static_sizes<_IndexT, size_t, _Offsets..., 0>(
-        __construct_psa_from_all_exts_values_tag,
-        __offsets.template __get_n<_OffsetIdxs>()..., size_t(0)),
-      __partially_static_sizes<_IndexT, size_t, _Exts..., _OldStaticExtent>(
-        __construct_psa_from_all_exts_values_tag,
-        __exts.template __get_n<_ExtIdxs>()..., __slice.old_extent),
-      __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>(
-        __construct_psa_from_all_exts_values_tag,
-        __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride)
-    };
-  }
-
-  // For a std::tuple, add an offset and add a new dynamic extent (strides still preserved)
-  template <size_t _OldStaticExtent, size_t _OldStaticStride>
-  MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
-  _MDSPAN_CONSTEXPR_14 auto
-  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, tuple<size_t, size_t>>&& __slice) noexcept
-    -> __assign_op_slice_handler<
-         _IndexT,
-         typename _PreserveLayoutAnalysis::encounter_pair,
-         __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>,
-         __partially_static_sizes<_IndexT, size_t, _Exts..., dynamic_extent>,
-         __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> {
-    return {
-      __partially_static_sizes<_IndexT, size_t, _Offsets..., dynamic_extent>(
-        __construct_psa_from_all_exts_values_tag,
-        __offsets.template __get_n<_OffsetIdxs>()..., ::std::get<0>(__slice.slice)),
-      __partially_static_sizes<_IndexT, size_t, _Exts..., dynamic_extent>(
-        __construct_psa_from_all_exts_values_tag,
-        __exts.template __get_n<_ExtIdxs>()..., ::std::get<1>(__slice.slice) - ::std::get<0>(__slice.slice)),
-      __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>(
-        __construct_psa_from_all_exts_values_tag,
-        __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride)
-    };
-  }
-
-  // For a std::tuple of two std::integral_constant, do something like
-  // we did above for a tuple of two size_t, but make sure the
-  // result's extents type make the values compile-time constants.
-  template <size_t _OldStaticExtent, size_t _OldStaticStride,
-	    class IntegerType0, IntegerType0 Value0,
-	    class IntegerType1, IntegerType1 Value1>
-  MDSPAN_FORCE_INLINE_FUNCTION // NOLINT (misc-unconventional-assign-operator)
-  _MDSPAN_CONSTEXPR_14 auto
-  operator=(__slice_wrap<_OldStaticExtent, _OldStaticStride, tuple<std::integral_constant<IntegerType0, Value0>, std::integral_constant<IntegerType1, Value1>>>&& __slice) noexcept
-    -> __assign_op_slice_handler<
-         _IndexT,
-         typename _PreserveLayoutAnalysis::encounter_pair,
-         __partially_static_sizes<_IndexT, size_t, _Offsets..., size_t(Value0)>,
-         __partially_static_sizes<_IndexT, size_t, _Exts..., size_t(Value1 - Value0)>,
-         __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>/* intentional space here to work around ICC bug*/> {
-    static_assert(Value1 >= Value0, "Invalid slice specifier");
-    return {
-      // We're still turning the template parameters Value0 and Value1
-      // into (constexpr) run-time values here.
-      __partially_static_sizes<_IndexT, size_t, _Offsets..., size_t(Value0) > (
-        __construct_psa_from_all_exts_values_tag,
-        __offsets.template __get_n<_OffsetIdxs>()..., Value0),
-      __partially_static_sizes<_IndexT, size_t, _Exts..., size_t(Value1 - Value0) > (
-        __construct_psa_from_all_exts_values_tag,
-        __exts.template __get_n<_ExtIdxs>()..., Value1 - Value0),
-      __partially_static_sizes<_IndexT, size_t, _Strides..., _OldStaticStride>(
-        __construct_psa_from_all_exts_values_tag,
-        __strides.template __get_n<_StrideIdxs>()..., __slice.old_stride)
-    };
-  }
-
-   // TODO defer instantiation of this?
-  using layout_type = typename conditional<
-    _PreserveLayoutAnalysis::value,
-    typename _PreserveLayoutAnalysis::layout_type_if_preserved,
-    layout_stride
-  >::type;
-
-  // TODO noexcept specification
-  template <class NewLayout>
-  MDSPAN_INLINE_FUNCTION
-  _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
-    (
-      _MDSPAN_CONSTEXPR_14 /* auto */
-      _make_layout_mapping_impl(NewLayout) noexcept
-    ),
-    (
-      /* not layout stride, so don't pass dynamic_strides */
-      /* return */ typename NewLayout::template mapping<::std::experimental::extents<_IndexT, _Exts...>>(
-        experimental::extents<_IndexT, _Exts...>::__make_extents_impl(::std::move(__exts))
-      ) /* ; */
-    )
-  )
-
-  MDSPAN_INLINE_FUNCTION
-  _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
-    (
-      _MDSPAN_CONSTEXPR_14 /* auto */
-      _make_layout_mapping_impl(layout_stride) noexcept
-    ),
-    (
-      /* return */ layout_stride::template mapping<::std::experimental::extents<_IndexT, _Exts...>>
-        ::__make_mapping(::std::move(__exts), ::std::move(__strides)) /* ; */
-    )
-  )
-
-  template <class OldLayoutMapping> // mostly for deferred instantiation, but maybe we'll use this in the future
-  MDSPAN_INLINE_FUNCTION
-  _MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
-    (
-      _MDSPAN_CONSTEXPR_14 /* auto */
-      make_layout_mapping(OldLayoutMapping const&) noexcept
-    ),
-    (
-      /* return */ this->_make_layout_mapping_impl(layout_type{}) /* ; */
-    )
-  )
-};
-
-//==============================================================================
-
-#if _MDSPAN_USE_RETURN_TYPE_DEDUCTION
-// Forking this because the C++11 version will be *completely* unreadable
-template <class ET, class ST, size_t... Exts, class LP, class AP, class... SliceSpecs, size_t... Idxs>
-MDSPAN_INLINE_FUNCTION
-constexpr auto _submdspan_impl(
-  integer_sequence<size_t, Idxs...>,
-  mdspan<ET, std::experimental::extents<ST, Exts...>, LP, AP> const& src,
-  SliceSpecs&&... slices
-) noexcept
-{
-  using _IndexT = ST;
-  auto _handled =
-    _MDSPAN_FOLD_ASSIGN_LEFT(
-      (
-        detail::__assign_op_slice_handler<
-          _IndexT,
-          detail::preserve_layout_analysis<LP>
-        >{
-          __partially_static_sizes<_IndexT, size_t>{},
-          __partially_static_sizes<_IndexT, size_t>{},
-          __partially_static_sizes<_IndexT, size_t>{}
-        }
-      ),
-        /* = ... = */
-      detail::__wrap_slice<
-        Exts, dynamic_extent
-      >(
-        slices, src.extents().template __extent<Idxs>(),
-        src.mapping().stride(Idxs)
-      )
-    );
-
-  size_t offset_size = src.mapping()(_handled.__offsets.template __get_n<Idxs>()...);
-  auto offset_ptr = src.accessor().offset(src.data_handle(), offset_size);
-  auto map = _handled.make_layout_mapping(src.mapping());
-  auto acc_pol = typename AP::offset_policy(src.accessor());
-  return mdspan<
-    ET, remove_const_t<remove_reference_t<decltype(map.extents())>>,
-        typename decltype(_handled)::layout_type, remove_const_t<remove_reference_t<decltype(acc_pol)>>
-  >(
-    std::move(offset_ptr), std::move(map), std::move(acc_pol)
-  );
-}
-#else
-
-template <class ET, class AP, class Src, class Handled, size_t... Idxs>
-auto _submdspan_impl_helper(Src&& src, Handled&& h, std::integer_sequence<size_t, Idxs...>)
-  -> mdspan<
-       ET, typename Handled::__extents_type, typename Handled::layout_type, typename AP::offset_policy
-     >
-{
-  return {
-    src.accessor().offset(src.data_handle(), src.mapping()(h.__offsets.template __get_n<Idxs>()...)),
-    h.make_layout_mapping(src.mapping()),
-    typename AP::offset_policy(src.accessor())
-  };
-}
-
-template <class ET, class ST, size_t... Exts, class LP, class AP, class... SliceSpecs, size_t... Idxs>
-MDSPAN_INLINE_FUNCTION
-_MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
-  (
-    constexpr /* auto */ _submdspan_impl(
-      std::integer_sequence<size_t, Idxs...> seq,
-      mdspan<ET, std::experimental::extents<ST, Exts...>, LP, AP> const& src,
-      SliceSpecs&&... slices
-    ) noexcept
-  ),
-  (
-    /* return */ _submdspan_impl_helper<ET, AP>(
-      src,
-      _MDSPAN_FOLD_ASSIGN_LEFT(
-        (
-          detail::__assign_op_slice_handler<
-            size_t,
-            detail::preserve_layout_analysis<LP>
-          >{
-            __partially_static_sizes<ST, size_t>{},
-            __partially_static_sizes<ST, size_t>{},
-            __partially_static_sizes<ST, size_t>{}
-          }
-        ),
-        /* = ... = */
-        detail::__wrap_slice<
-          Exts, dynamic_extent
-        >(
-          slices, src.extents().template __extent<Idxs>(), src.mapping().stride(Idxs)
-        )
-      ),
-      seq
-    ) /* ; */
-  )
-)
-
-#endif
-
-template <class T> struct _is_layout_stride : std::false_type { };
-template<>
-struct _is_layout_stride<
-  layout_stride
-> : std::true_type
-{ };
-
-} // namespace detail
-
-//==============================================================================
-
-MDSPAN_TEMPLATE_REQUIRES(
-  class ET, class EXT, class LP, class AP, class... SliceSpecs,
-  /* requires */ (
-    (
-      _MDSPAN_TRAIT(is_same, LP, layout_left)
-        || _MDSPAN_TRAIT(is_same, LP, layout_right)
-        || detail::_is_layout_stride<LP>::value
-    ) &&
-    _MDSPAN_FOLD_AND((
-      _MDSPAN_TRAIT(is_convertible, SliceSpecs, size_t)
-        || _MDSPAN_TRAIT(is_convertible, SliceSpecs, tuple<size_t, size_t>)
-        || _MDSPAN_TRAIT(is_convertible, SliceSpecs, full_extent_t)
-    ) /* && ... */) &&
-    sizeof...(SliceSpecs) == EXT::rank()
-  )
-)
-MDSPAN_INLINE_FUNCTION
-_MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(
-  (
-    constexpr submdspan(
-      mdspan<ET, EXT, LP, AP> const& src, SliceSpecs... slices
-    ) noexcept
-  ),
-  (
-    /* return */
-      detail::_submdspan_impl(std::make_index_sequence<sizeof...(SliceSpecs)>{}, src, slices...) /*;*/
-  )
-)
-/* clang-format: on */
-
-} // end namespace experimental
-} // namespace std
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/trait_backports.hpp b/tpls/mdspan/include/experimental/__p0009_bits/trait_backports.hpp
index a94e1a1e03..4933dd9934 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/trait_backports.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/trait_backports.hpp
@@ -1,46 +1,18 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #ifndef MDSPAN_INCLUDE_EXPERIMENTAL_BITS_TRAIT_BACKPORTS_HPP_
 #define MDSPAN_INCLUDE_EXPERIMENTAL_BITS_TRAIT_BACKPORTS_HPP_
 
@@ -56,7 +28,7 @@
 #ifdef _MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
 
 #if _MDSPAN_USE_VARIABLE_TEMPLATES
-namespace std {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 #define _MDSPAN_BACKPORT_TRAIT(TRAIT) \
   template <class... Args> _MDSPAN_INLINE_VARIABLE constexpr auto TRAIT##_v = TRAIT<Args...>::value;
@@ -72,7 +44,7 @@ _MDSPAN_BACKPORT_TRAIT(is_void)
 
 #undef _MDSPAN_BACKPORT_TRAIT
 
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
 #endif // _MDSPAN_USE_VARIABLE_TEMPLATES
 
@@ -86,16 +58,16 @@ _MDSPAN_BACKPORT_TRAIT(is_void)
 
 #if !defined(_MDSPAN_USE_INTEGER_SEQUENCE) || !_MDSPAN_USE_INTEGER_SEQUENCE
 
-namespace std {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 template <class T, T... Vals>
 struct integer_sequence {
-  static constexpr std::size_t size() noexcept { return sizeof...(Vals); }
+  static constexpr size_t size() noexcept { return sizeof...(Vals); }
   using value_type = T;
 };
 
-template <std::size_t... Vals>
-using index_sequence = std::integer_sequence<std::size_t, Vals...>;
+template <size_t... Vals>
+using index_sequence = std::integer_sequence<size_t, Vals...>;
 
 namespace __detail {
 
@@ -119,13 +91,13 @@ struct __make_int_seq_impl<
 template <class T, T N>
 using make_integer_sequence = typename __detail::__make_int_seq_impl<T, N, 0, integer_sequence<T>>::type;
 
-template <std::size_t N>
+template <size_t N>
 using make_index_sequence = typename __detail::__make_int_seq_impl<size_t, N, 0, integer_sequence<size_t>>::type;
 
 template <class... T>
 using index_sequence_for = make_index_sequence<sizeof...(T)>;
 
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
 #endif
 
@@ -137,7 +109,7 @@ using index_sequence_for = make_index_sequence<sizeof...(T)>;
 
 #if !defined(_MDSPAN_USE_STANDARD_TRAIT_ALIASES) || !_MDSPAN_USE_STANDARD_TRAIT_ALIASES
 
-namespace std {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 #define _MDSPAN_BACKPORT_TRAIT_ALIAS(TRAIT) \
   template <class... Args> using TRAIT##_t = typename TRAIT<Args...>::type;
@@ -150,7 +122,7 @@ using enable_if_t = typename enable_if<_B, _T>::type;
 
 #undef _MDSPAN_BACKPORT_TRAIT_ALIAS
 
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
 #endif
 
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/type_list.hpp b/tpls/mdspan/include/experimental/__p0009_bits/type_list.hpp
index 7de72e6537..deca7c15d0 100644
--- a/tpls/mdspan/include/experimental/__p0009_bits/type_list.hpp
+++ b/tpls/mdspan/include/experimental/__p0009_bits/type_list.hpp
@@ -1,52 +1,23 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 #include "macros.hpp"
 
 #include "trait_backports.hpp" // make_index_sequence
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
 
 //==============================================================================
 
@@ -56,7 +27,7 @@ template <class... _Ts> struct __type_list { static constexpr auto __size = size
 
 // Implementation of type_list at() that's heavily optimized for small typelists
 template <size_t, class> struct __type_at;
-template <size_t, class _Seq, class=make_index_sequence<_Seq::__size>> struct __type_at_large_impl;
+template <size_t, class _Seq, class=std::make_index_sequence<_Seq::__size>> struct __type_at_large_impl;
 
 template <size_t _I, size_t _Idx, class _T>
 struct __type_at_entry { };
@@ -76,7 +47,7 @@ struct __type_at_assign_op_impl {
 };
 
 template <size_t _I, class... _Ts, size_t... _Idxs>
-struct __type_at_large_impl<_I, __type_list<_Ts...>, integer_sequence<size_t, _Idxs...>>
+struct __type_at_large_impl<_I, __type_list<_Ts...>, std::integer_sequence<size_t, _Idxs...>>
   : decltype(
       _MDSPAN_FOLD_ASSIGN_LEFT(__type_at_assign_op_impl{}, /* = ... = */ __type_at_entry<_I, _Idxs, _Ts>{})
     )
@@ -112,6 +83,5 @@ struct __type_at<3, __type_list<_T0, _T1, _T2, _T3, _Ts...>> {
 
 //==============================================================================
 
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
 
diff --git a/tpls/mdspan/include/experimental/__p0009_bits/utility.hpp b/tpls/mdspan/include/experimental/__p0009_bits/utility.hpp
new file mode 100644
index 0000000000..e690cd6939
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p0009_bits/utility.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace detail {
+
+// type alias used for rank-based tag dispatch
+//
+// this is used to enable alternatives to constexpr if when building for C++14
+//
+template <std::size_t N>
+using with_rank = std::integral_constant<std::size_t, N>;
+
+template <class I1, class I2>
+MDSPAN_INLINE_FUNCTION
+constexpr bool common_integral_compare(I1 x, I2 y)
+{
+  static_assert(std::is_integral<I1>::value &&
+                std::is_integral<I2>::value, "");
+
+  using I = std::common_type_t<I1, I2>;
+  return static_cast<I>(x) == static_cast<I>(y);
+}
+
+template <class T1, class T2, class F>
+MDSPAN_INLINE_FUNCTION
+constexpr bool rankwise_equal(with_rank<0>, const T1&, const T2&, F)
+{
+  return true;
+}
+
+template <std::size_t N, class T1, class T2, class F>
+MDSPAN_INLINE_FUNCTION
+constexpr bool rankwise_equal(with_rank<N>, const T1& x, const T2& y, F func)
+{
+  bool match = true;
+
+  for (std::size_t r = 0; r < N; r++) {
+    match = match && common_integral_compare(func(x, r), func(y, r));
+  }
+
+  return match;
+}
+
+constexpr struct
+{
+  template <class T, class I>
+  MDSPAN_INLINE_FUNCTION
+  constexpr auto operator()(const T& x, I i) const
+  {
+    return x.extent(i);
+  }
+} extent;
+
+constexpr struct
+{
+  template <class T, class I>
+  MDSPAN_INLINE_FUNCTION
+  constexpr auto operator()(const T& x, I i) const
+  {
+    return x.stride(i);
+  }
+} stride;
+
+} // namespace detail
+
+constexpr struct mdspan_non_standard_tag {
+} mdspan_non_standard;
+
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p1684_bits/mdarray.hpp b/tpls/mdspan/include/experimental/__p1684_bits/mdarray.hpp
index b27a25c9fe..bdc5925f71 100644
--- a/tpls/mdspan/include/experimental/__p1684_bits/mdarray.hpp
+++ b/tpls/mdspan/include/experimental/__p1684_bits/mdarray.hpp
@@ -1,46 +1,18 @@
-/*
 //@HEADER
 // ************************************************************************
 //
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
 //
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// Under the terms of Contract DE-NA0003525 with NTESS,
 // the U.S. Government retains certain rights in this software.
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
 //@HEADER
-*/
-
 
 #pragma once
 
@@ -48,8 +20,8 @@
 #include <cassert>
 #include <vector>
 
-namespace std {
-namespace experimental {
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace MDSPAN_IMPL_PROPOSED_NAMESPACE {
 
 namespace {
   template<class Extents>
@@ -68,14 +40,14 @@ namespace {
 
 namespace {
   template<class C>
-  struct container_is_array : false_type {
+  struct container_is_array :  std::false_type {
     template<class M>
     static constexpr C construct(const M& m) { return C(m.required_span_size()); }
   };
   template<class T, size_t N>
-  struct container_is_array<array<T,N>> : true_type {
+  struct container_is_array<std::array<T,N>> : std::true_type {
     template<class M>
-    static constexpr array<T,N> construct(const M&) { return array<T,N>(); }
+    static constexpr std::array<T,N> construct(const M&) { return std::array<T,N>(); }
   };
 }
 
@@ -83,12 +55,12 @@ template <
   class ElementType,
   class Extents,
   class LayoutPolicy = layout_right,
-  class Container = vector<ElementType>
+  class Container = std::vector<ElementType>
 >
 class mdarray {
 private:
-  static_assert(detail::__is_extents_v<Extents>, "std::experimental::mdspan's Extents template parameter must be a specialization of std::experimental::extents.");
-
+  static_assert(::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::__is_extents_v<Extents>,
+                MDSPAN_IMPL_PROPOSED_NAMESPACE_STRING "::mdspan's Extents template parameter must be a specialization of " MDSPAN_IMPL_STANDARD_NAMESPACE_STRING "::extents.");
 
 public:
 
@@ -100,8 +72,12 @@ class mdarray {
   using container_type = Container;
   using mapping_type = typename layout_type::template mapping<extents_type>;
   using element_type = ElementType;
-  using value_type = remove_cv_t<element_type>;
+  using mdspan_type = mdspan<element_type, extents_type, layout_type>;
+  using const_mdspan_type = mdspan<const element_type, extents_type, layout_type>;
+  using value_type = std::remove_cv_t<element_type>;
   using index_type = typename Extents::index_type;
+  using size_type = typename Extents::size_type;
+  using rank_type = typename Extents::rank_type;
   using pointer = typename container_type::pointer;
   using reference = typename container_type::reference;
   using const_pointer = typename container_type::const_pointer;
@@ -127,10 +103,10 @@ class mdarray {
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      _MDSPAN_TRAIT(is_constructible, extents_type, SizeTypes...) &&
-      _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type) &&
-      (_MDSPAN_TRAIT(is_constructible, container_type, size_t) ||
+      (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::are_valid_indices<index_type, SizeTypes...>()) &&
+        _MDSPAN_TRAIT( std::is_constructible, extents_type, SizeTypes...) &&
+      _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type) &&
+      (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t) ||
        container_is_array<container_type>::value) &&
       (extents_type::rank()>0 || extents_type::rank_dynamic()==0)
     )
@@ -143,94 +119,62 @@ class mdarray {
   MDSPAN_FUNCTION_REQUIRES(
     (MDSPAN_INLINE_FUNCTION constexpr),
     mdarray, (const extents_type& exts), ,
-    /* requires */ ((_MDSPAN_TRAIT(is_constructible, container_type, size_t) ||
+    /* requires */ ((_MDSPAN_TRAIT( std::is_constructible, container_type, size_t) ||
                      container_is_array<container_type>::value) &&
-                    _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+                    _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type))
   ) : map_(exts), ctr_(container_is_array<container_type>::construct(map_))
   { }
 
   MDSPAN_FUNCTION_REQUIRES(
     (MDSPAN_INLINE_FUNCTION constexpr),
     mdarray, (const mapping_type& m), ,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, size_t) ||
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t) ||
                     container_is_array<container_type>::value)
   ) : map_(m), ctr_(container_is_array<container_type>::construct(map_))
   { }
 
-  // Constructors from container
-  MDSPAN_TEMPLATE_REQUIRES(
-    class... SizeTypes,
-    /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      _MDSPAN_TRAIT(is_constructible, extents_type, SizeTypes...) &&
-      _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type)
-    )
-  )
-  MDSPAN_INLINE_FUNCTION
-  explicit constexpr mdarray(const container_type& ctr, SizeTypes... dynamic_extents)
-    : map_(extents_type(dynamic_extents...)), ctr_(ctr)
-  { assert(ctr.size() >= static_cast<size_t>(map_.required_span_size())); }
-
-
   MDSPAN_FUNCTION_REQUIRES(
     (MDSPAN_INLINE_FUNCTION constexpr),
-    mdarray, (const container_type& ctr, const extents_type& exts), ,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+    mdarray, (const extents_type& exts, const container_type& ctr), ,
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type))
   ) : map_(exts), ctr_(ctr)
   { assert(ctr.size() >= static_cast<size_t>(map_.required_span_size())); }
 
-  constexpr mdarray(const container_type& ctr, const mapping_type& m)
+  constexpr mdarray(const mapping_type& m, const container_type& ctr)
     : map_(m), ctr_(ctr)
   { assert(ctr.size() >= static_cast<size_t>(map_.required_span_size())); }
 
-
-  // Constructors from container
-  MDSPAN_TEMPLATE_REQUIRES(
-    class... SizeTypes,
-    /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      _MDSPAN_TRAIT(is_constructible, extents_type, SizeTypes...) &&
-      _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type)
-    )
-  )
-  MDSPAN_INLINE_FUNCTION
-  explicit constexpr mdarray(container_type&& ctr, SizeTypes... dynamic_extents)
-    : map_(extents_type(dynamic_extents...)), ctr_(std::move(ctr))
-  { assert(ctr_.size() >= static_cast<size_t>(map_.required_span_size())); }
-
-
   MDSPAN_FUNCTION_REQUIRES(
     (MDSPAN_INLINE_FUNCTION constexpr),
-    mdarray, (container_type&& ctr, const extents_type& exts), ,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+    mdarray, (const extents_type& exts, container_type&& ctr), ,
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type))
   ) : map_(exts), ctr_(std::move(ctr))
   { assert(ctr_.size() >= static_cast<size_t>(map_.required_span_size())); }
 
-  constexpr mdarray(container_type&& ctr, const mapping_type& m)
+  constexpr mdarray(const mapping_type& m, container_type&& ctr)
     : map_(m), ctr_(std::move(ctr))
   { assert(ctr_.size() >= static_cast<size_t>(map_.required_span_size())); }
 
 
-
   MDSPAN_TEMPLATE_REQUIRES(
     class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherContainer,
     /* requires */ (
-      _MDSPAN_TRAIT(is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping<OtherExtents>) &&
-      _MDSPAN_TRAIT(is_constructible, container_type, OtherContainer)
+      _MDSPAN_TRAIT( std::is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping<OtherExtents>) &&
+      _MDSPAN_TRAIT( std::is_constructible, container_type, OtherContainer)
     )
   )
   MDSPAN_INLINE_FUNCTION
   constexpr mdarray(const mdarray<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherContainer>& other)
     : map_(other.mapping()), ctr_(other.container())
   {
-    static_assert(is_constructible<extents_type, OtherExtents>::value, "");
+    static_assert( std::is_constructible<extents_type, OtherExtents>::value, "");
   }
 
   // Constructors for container types constructible from a size and allocator
   MDSPAN_TEMPLATE_REQUIRES(
     class Alloc,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, size_t, Alloc) &&
-                    _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc) &&
+                    _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type))
   )
   MDSPAN_INLINE_FUNCTION
   constexpr mdarray(const extents_type& exts, const Alloc& a)
@@ -239,7 +183,7 @@ class mdarray {
 
   MDSPAN_TEMPLATE_REQUIRES(
     class Alloc,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, size_t, Alloc))
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc))
   )
   MDSPAN_INLINE_FUNCTION
   constexpr mdarray(const mapping_type& map, const Alloc& a)
@@ -249,56 +193,58 @@ class mdarray {
   // Constructors for container types constructible from a container and allocator
   MDSPAN_TEMPLATE_REQUIRES(
     class Alloc,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, container_type, Alloc) &&
-                    _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, container_type, Alloc) &&
+                    _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type))
   )
   MDSPAN_INLINE_FUNCTION
-  constexpr mdarray(const container_type& ctr, const extents_type& exts, const Alloc& a)
+  constexpr mdarray(const extents_type& exts, const container_type& ctr, const Alloc& a)
     : map_(exts), ctr_(ctr, a)
   { assert(ctr_.size() >= static_cast<size_t>(map_.required_span_size())); }
 
   MDSPAN_TEMPLATE_REQUIRES(
     class Alloc,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, size_t, Alloc))
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc))
   )
   MDSPAN_INLINE_FUNCTION
-  constexpr mdarray(const container_type& ctr, const mapping_type& map, const Alloc& a)
+  constexpr mdarray(const mapping_type& map, const container_type& ctr, const Alloc& a)
     : map_(map), ctr_(ctr, a)
   { assert(ctr_.size() >= static_cast<size_t>(map_.required_span_size())); }
 
   MDSPAN_TEMPLATE_REQUIRES(
     class Alloc,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, container_type, Alloc) &&
-                    _MDSPAN_TRAIT(is_constructible, mapping_type, extents_type))
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, container_type, Alloc) &&
+                    _MDSPAN_TRAIT( std::is_constructible, mapping_type, extents_type))
   )
   MDSPAN_INLINE_FUNCTION
-  constexpr mdarray(container_type&& ctr, const extents_type& exts, const Alloc& a)
+  constexpr mdarray(const extents_type& exts, container_type&& ctr, const Alloc& a)
     : map_(exts), ctr_(std::move(ctr), a)
   { assert(ctr_.size() >= static_cast<size_t>(map_.required_span_size())); }
 
   MDSPAN_TEMPLATE_REQUIRES(
     class Alloc,
-    /* requires */ (_MDSPAN_TRAIT(is_constructible, container_type, size_t, Alloc))
+    /* requires */ (_MDSPAN_TRAIT( std::is_constructible, container_type, size_t, Alloc))
   )
   MDSPAN_INLINE_FUNCTION
-  constexpr mdarray(container_type&& ctr, const mapping_type& map, const Alloc& a)
+  constexpr mdarray(const mapping_type& map, container_type&& ctr, const Alloc& a)
     : map_(map), ctr_(std::move(ctr), a)
   { assert(ctr_.size() >= map_.required_span_size()); }
 
   MDSPAN_TEMPLATE_REQUIRES(
     class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherContainer, class Alloc,
     /* requires */ (
-      _MDSPAN_TRAIT(is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping<OtherExtents>) &&
-      _MDSPAN_TRAIT(is_constructible, container_type, OtherContainer, Alloc)
+      _MDSPAN_TRAIT( std::is_constructible, mapping_type, typename OtherLayoutPolicy::template mapping<OtherExtents>) &&
+      _MDSPAN_TRAIT( std::is_constructible, container_type, OtherContainer, Alloc)
     )
   )
   MDSPAN_INLINE_FUNCTION
   constexpr mdarray(const mdarray<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherContainer>& other, const Alloc& a)
     : map_(other.mapping()), ctr_(other.container(), a)
   {
-    static_assert(is_constructible<extents_type, OtherExtents>::value, "");
+    static_assert( std::is_constructible<extents_type, OtherExtents>::value, "");
   }
 
+  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdarray& operator= (const mdarray&) = default;
+  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mdarray& operator= (mdarray&&) = default;
   MDSPAN_INLINE_FUNCTION_DEFAULTED
   ~mdarray() = default;
 
@@ -309,27 +255,27 @@ class mdarray {
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
+      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT( std::is_convertible, SizeTypes, index_type) /* && ... */) &&
       extents_type::rank() == sizeof...(SizeTypes)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr const_reference operator[](SizeTypes... indices) const noexcept
   {
-    return ctr_[map_(index_type(indices)...)];
+    return ctr_[map_(static_cast<index_type>(std::move(indices))...)];
   }
 
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
+      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT( std::is_convertible, SizeTypes, index_type) /* && ... */) &&
       extents_type::rank() == sizeof...(SizeTypes)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr reference operator[](SizeTypes... indices) noexcept
   {
-    return ctr_[map_(index_type(indices)...)];
+    return ctr_[map_(static_cast<index_type>(std::move(indices))...)];
   }
   #endif
 
@@ -337,12 +283,12 @@ class mdarray {
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType, size_t N,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
+      _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) &&
       N == extents_type::rank()
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr const_reference operator[](const array<SizeType, N>& indices) const noexcept
+  constexpr const_reference operator[](const std::array<SizeType, N>& indices) const noexcept
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -350,12 +296,12 @@ class mdarray {
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType, size_t N,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
+      _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) &&
       N == extents_type::rank()
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr reference operator[](const array<SizeType, N>& indices) noexcept
+  constexpr reference operator[](const std::array<SizeType, N>& indices) noexcept
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -366,38 +312,38 @@ class mdarray {
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      extents_type::rank() == sizeof...(SizeTypes)
+        (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::are_valid_indices<index_type, SizeTypes...>()) &&
+        extents_type::rank() == sizeof...(SizeTypes)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr const_reference operator()(SizeTypes... indices) const noexcept
   {
-    return ctr_[map_(index_type(indices)...)];
+    return ctr_[map_(static_cast<index_type>(std::move(indices))...)];
   }
   MDSPAN_TEMPLATE_REQUIRES(
     class... SizeTypes,
     /* requires */ (
-      _MDSPAN_FOLD_AND(_MDSPAN_TRAIT(is_convertible, SizeTypes, index_type) /* && ... */) &&
-      extents_type::rank() == sizeof...(SizeTypes)
+        (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::are_valid_indices<index_type, SizeTypes...>()) &&
+        extents_type::rank() == sizeof...(SizeTypes)
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
   constexpr reference operator()(SizeTypes... indices) noexcept
   {
-    return ctr_[map_(index_type(indices)...)];
+    return ctr_[map_(static_cast<index_type>(std::move(indices))...)];
   }
 
 #if 0
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType, size_t N,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
+      _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) &&
       N == extents_type::rank()
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr const_reference operator()(const array<SizeType, N>& indices) const noexcept
+  constexpr const_reference operator()(const std::array<SizeType, N>& indices) const noexcept
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -405,12 +351,12 @@ class mdarray {
   MDSPAN_TEMPLATE_REQUIRES(
     class SizeType, size_t N,
     /* requires */ (
-      _MDSPAN_TRAIT(is_convertible, SizeType, index_type) &&
+      _MDSPAN_TRAIT( std::is_convertible, SizeType, index_type) &&
       N == extents_type::rank()
     )
   )
   MDSPAN_FORCE_INLINE_FUNCTION
-  constexpr reference operator()(const array<SizeType, N>& indices) noexcept
+  constexpr reference operator()(const std::array<SizeType, N>& indices) noexcept
   {
     return __impl::template __callop<reference>(*this, indices);
   }
@@ -425,11 +371,11 @@ class mdarray {
   //--------------------------------------------------------------------------------
   // [mdspan.basic.domobs], mdspan observers of the domain multidimensional index space
 
-  MDSPAN_INLINE_FUNCTION static constexpr size_t rank() noexcept { return extents_type::rank(); }
-  MDSPAN_INLINE_FUNCTION static constexpr size_t rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
-  MDSPAN_INLINE_FUNCTION static constexpr index_type static_extent(size_t r) noexcept { return extents_type::static_extent(r); }
+  MDSPAN_INLINE_FUNCTION static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+  MDSPAN_INLINE_FUNCTION static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+  MDSPAN_INLINE_FUNCTION static constexpr size_t static_extent(size_t r) noexcept { return extents_type::static_extent(r); }
 
-  MDSPAN_INLINE_FUNCTION constexpr extents_type extents() const noexcept { return map_.extents(); };
+  MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept { return map_.extents(); };
   MDSPAN_INLINE_FUNCTION constexpr index_type extent(size_t r) const noexcept { return map_.extents().extent(r); };
   MDSPAN_INLINE_FUNCTION constexpr index_type size() const noexcept {
 //    return __impl::__size(*this);
@@ -444,12 +390,63 @@ class mdarray {
   MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return mapping_type::is_always_exhaustive(); };
   MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return mapping_type::is_always_strided(); };
 
-  MDSPAN_INLINE_FUNCTION constexpr mapping_type mapping() const noexcept { return map_; };
+  MDSPAN_INLINE_FUNCTION constexpr const mapping_type& mapping() const noexcept { return map_; };
   MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return map_.is_unique(); };
   MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return map_.is_exhaustive(); };
   MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return map_.is_strided(); };
   MDSPAN_INLINE_FUNCTION constexpr index_type stride(size_t r) const { return map_.stride(r); };
 
+  // Converstion to mdspan
+  MDSPAN_TEMPLATE_REQUIRES(
+    class OtherElementType, class OtherExtents,
+    class OtherLayoutType, class OtherAccessorType,
+    /* requires */ (
+      _MDSPAN_TRAIT(std::is_assignable,
+                      mdspan<OtherElementType, OtherExtents, OtherLayoutType, OtherAccessorType>,
+                      mdspan_type)
+    )
+  )
+  constexpr operator mdspan<OtherElementType, OtherExtents, OtherLayoutType, OtherAccessorType> () {
+    return mdspan_type(data(), map_);
+  }
+
+  MDSPAN_TEMPLATE_REQUIRES(
+    class OtherElementType, class OtherExtents,
+    class OtherLayoutType, class OtherAccessorType,
+    /* requires */ (
+      _MDSPAN_TRAIT(std::is_assignable,
+                      mdspan<OtherElementType, OtherExtents, OtherLayoutType, OtherAccessorType>,
+                      const_mdspan_type)
+    )
+  )
+  constexpr operator mdspan<OtherElementType, OtherExtents, OtherLayoutType, OtherAccessorType> () const {
+    return const_mdspan_type(data(), map_);
+  }
+
+  MDSPAN_TEMPLATE_REQUIRES(
+    class OtherAccessorType = default_accessor<element_type>,
+    /* requires */ (
+      _MDSPAN_TRAIT(std::is_assignable, mdspan_type,
+                      mdspan<element_type, extents_type, layout_type, OtherAccessorType>)
+    )
+  )
+  constexpr mdspan<element_type, extents_type, layout_type, OtherAccessorType>
+    to_mdspan(const OtherAccessorType& a = default_accessor<element_type>()) {
+      return mdspan<element_type, extents_type, layout_type, OtherAccessorType>(data(), map_, a);
+  }
+
+  MDSPAN_TEMPLATE_REQUIRES(
+    class OtherAccessorType = default_accessor<const element_type>,
+    /* requires */ (
+      _MDSPAN_TRAIT(std::is_assignable, const_mdspan_type,
+                      mdspan<const element_type, extents_type, layout_type, OtherAccessorType>)
+    )
+  )
+  constexpr mdspan<const element_type, extents_type, layout_type, OtherAccessorType>
+    to_mdspan(const OtherAccessorType& a = default_accessor<const element_type>()) const {
+      return mdspan<const element_type, extents_type, layout_type, OtherAccessorType>(data(), map_, a);
+  }
+
 private:
   mapping_type map_;
   container_type ctr_;
@@ -459,5 +456,5 @@ class mdarray {
 };
 
 
-} // end namespace experimental
-} // end namespace std
+} // end namespace MDSPAN_IMPL_PROPOSED_NAMESPACE
+} // end namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/core/src/decl/Kokkos_Declare_HBWSpace.hpp b/tpls/mdspan/include/experimental/__p2389_bits/dims.hpp
similarity index 59%
rename from core/src/decl/Kokkos_Declare_HBWSpace.hpp
rename to tpls/mdspan/include/experimental/__p2389_bits/dims.hpp
index 1328c93135..00045215c4 100644
--- a/core/src/decl/Kokkos_Declare_HBWSpace.hpp
+++ b/tpls/mdspan/include/experimental/__p2389_bits/dims.hpp
@@ -14,11 +14,15 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_DECLARE_HBWSPACE_HPP
-#define KOKKOS_DECLARE_HBWSPACE_HPP
+#pragma once
 
-#ifdef KOKKOS_ENABLE_HBWSPACE
-#include <Kokkos_HBWSpace.hpp>
-#endif
+// backward compatibility import into experimental
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace MDSPAN_IMPL_PROPOSED_NAMESPACE {
 
-#endif
+template< ::std::size_t Rank, class IndexType = std::size_t>
+using dims =
+  :: MDSPAN_IMPL_STANDARD_NAMESPACE :: dextents<IndexType, Rank>;
+
+} // namespace MDSPAN_IMPL_PROPOSED_NAMESPACE
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p2630_bits/strided_slice.hpp b/tpls/mdspan/include/experimental/__p2630_bits/strided_slice.hpp
new file mode 100644
index 0000000000..89ba8202fb
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p2630_bits/strided_slice.hpp
@@ -0,0 +1,48 @@
+
+//@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
+
+#pragma once
+
+#include <type_traits>
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+
+namespace {
+  template<class T>
+  struct __mdspan_is_integral_constant: std::false_type {};
+
+  template<class T, T val>
+  struct __mdspan_is_integral_constant<std::integral_constant<T,val>>: std::true_type {};
+}
+
+// Slice Specifier allowing for strides and compile time extent
+template <class OffsetType, class ExtentType, class StrideType>
+struct strided_slice {
+  using offset_type = OffsetType;
+  using extent_type = ExtentType;
+  using stride_type = StrideType;
+
+  _MDSPAN_NO_UNIQUE_ADDRESS OffsetType offset{};
+  _MDSPAN_NO_UNIQUE_ADDRESS ExtentType extent{};
+  _MDSPAN_NO_UNIQUE_ADDRESS StrideType stride{};
+
+  static_assert(std::is_integral_v<OffsetType> || __mdspan_is_integral_constant<OffsetType>::value);
+  static_assert(std::is_integral_v<ExtentType> || __mdspan_is_integral_constant<ExtentType>::value);
+  static_assert(std::is_integral_v<StrideType> || __mdspan_is_integral_constant<StrideType>::value);
+};
+
+} // MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p2630_bits/submdspan.hpp b/tpls/mdspan/include/experimental/__p2630_bits/submdspan.hpp
new file mode 100644
index 0000000000..abddd0b59d
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p2630_bits/submdspan.hpp
@@ -0,0 +1,40 @@
+//@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
+
+#pragma once
+
+#include "submdspan_extents.hpp"
+#include "submdspan_mapping.hpp"
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+template <class ElementType, class Extents, class LayoutPolicy,
+          class AccessorPolicy, class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION
+constexpr auto
+submdspan(const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy> &src,
+          SliceSpecifiers... slices) {
+  const auto sub_submdspan_mapping_result = submdspan_mapping(src.mapping(), slices...);
+  // NVCC has a problem with the deduction so lets figure out the type
+  using sub_mapping_t = std::remove_cv_t<decltype(sub_submdspan_mapping_result.mapping)>;
+  using sub_extents_t = typename sub_mapping_t::extents_type;
+  using sub_layout_t = typename sub_mapping_t::layout_type;
+  using sub_accessor_t = typename AccessorPolicy::offset_policy;
+  return mdspan<ElementType, sub_extents_t, sub_layout_t, sub_accessor_t>(
+      src.accessor().offset(src.data_handle(), sub_submdspan_mapping_result.offset),
+      sub_submdspan_mapping_result.mapping,
+      sub_accessor_t(src.accessor()));
+}
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p2630_bits/submdspan_extents.hpp b/tpls/mdspan/include/experimental/__p2630_bits/submdspan_extents.hpp
new file mode 100644
index 0000000000..c3b2f78fb9
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p2630_bits/submdspan_extents.hpp
@@ -0,0 +1,321 @@
+//@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
+
+#pragma once
+
+#include <tuple>
+
+#include "strided_slice.hpp"
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace detail {
+
+// Mapping from submapping ranks to srcmapping ranks
+// InvMapRank is an index_sequence, which we build recursively
+// to contain the mapped indices.
+// end of recursion specialization containing the final index_sequence
+template <size_t Counter, size_t... MapIdxs>
+MDSPAN_INLINE_FUNCTION
+constexpr auto inv_map_rank(std::integral_constant<size_t, Counter>, std::index_sequence<MapIdxs...>) {
+  return std::index_sequence<MapIdxs...>();
+}
+
+// specialization reducing rank by one (i.e., integral slice specifier)
+template<size_t Counter, class Slice, class... SliceSpecifiers, size_t... MapIdxs>
+MDSPAN_INLINE_FUNCTION
+constexpr auto inv_map_rank(std::integral_constant<size_t, Counter>, std::index_sequence<MapIdxs...>, Slice,
+                  SliceSpecifiers... slices) {
+  using next_idx_seq_t = std::conditional_t<std::is_convertible_v<Slice, size_t>,
+                                       std::index_sequence<MapIdxs...>,
+                                       std::index_sequence<MapIdxs..., Counter>>;
+
+  return inv_map_rank(std::integral_constant<size_t,Counter + 1>(), next_idx_seq_t(),
+                                     slices...);
+}
+
+// Helper for identifying strided_slice
+template <class T> struct is_strided_slice : std::false_type {};
+
+template <class OffsetType, class ExtentType, class StrideType>
+struct is_strided_slice<
+    strided_slice<OffsetType, ExtentType, StrideType>> : std::true_type {};
+
+// first_of(slice): getting begin of slice specifier range
+MDSPAN_TEMPLATE_REQUIRES(
+  class Integral,
+  /* requires */(std::is_convertible_v<Integral, size_t>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr Integral first_of(const Integral &i) {
+  return i;
+}
+
+MDSPAN_INLINE_FUNCTION
+constexpr std::integral_constant<size_t, 0>
+first_of(const ::MDSPAN_IMPL_STANDARD_NAMESPACE::full_extent_t &) {
+  return std::integral_constant<size_t, 0>();
+}
+
+MDSPAN_TEMPLATE_REQUIRES(
+  class Slice,
+  /* requires */(std::is_convertible_v<Slice, std::tuple<size_t, size_t>>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto first_of(const Slice &i) {
+  return std::get<0>(i);
+}
+
+template <class OffsetType, class ExtentType, class StrideType>
+MDSPAN_INLINE_FUNCTION
+constexpr OffsetType
+first_of(const strided_slice<OffsetType, ExtentType, StrideType> &r) {
+  return r.offset;
+}
+
+// last_of(slice): getting end of slice specifier range
+// We need however not just the slice but also the extents
+// of the original view and which rank from the extents.
+// This is needed in the case of slice being full_extent_t.
+MDSPAN_TEMPLATE_REQUIRES(
+  size_t k, class Extents, class Integral,
+  /* requires */(std::is_convertible_v<Integral, size_t>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr Integral
+    last_of(std::integral_constant<size_t, k>, const Extents &, const Integral &i) {
+  return i;
+}
+
+MDSPAN_TEMPLATE_REQUIRES(
+  size_t k, class Extents, class Slice,
+  /* requires */(std::is_convertible_v<Slice, std::tuple<size_t, size_t>>)
+)
+MDSPAN_INLINE_FUNCTION
+constexpr auto last_of(std::integral_constant<size_t, k>, const Extents &,
+                       const Slice &i) {
+  return std::get<1>(i);
+}
+
+// Suppress spurious warning with NVCC about no return statement.
+// This is a known issue in NVCC and NVC++
+// Depending on the CUDA and GCC version we need both the builtin
+// and the diagnostic push. I tried really hard to find something shorter
+// but no luck ...
+#if defined __NVCC__
+    #ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+        #pragma nv_diagnostic push
+        #pragma nv_diag_suppress = implicit_return_from_non_void_function
+    #else
+      #ifdef __CUDA_ARCH__
+        #pragma diagnostic push
+        #pragma diag_suppress implicit_return_from_non_void_function
+      #endif
+    #endif
+#elif defined __NVCOMPILER
+    #pragma    diagnostic push
+    #pragma    diag_suppress = implicit_return_from_non_void_function
+#endif
+template <size_t k, class Extents>
+MDSPAN_INLINE_FUNCTION
+constexpr auto last_of(std::integral_constant<size_t, k>, const Extents &ext,
+                       ::MDSPAN_IMPL_STANDARD_NAMESPACE::full_extent_t) {
+  if constexpr (Extents::static_extent(k) == dynamic_extent) {
+    return ext.extent(k);
+  } else {
+    return std::integral_constant<size_t, Extents::static_extent(k)>();
+  }
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+  // Even with CUDA_ARCH protection this thing warns about calling host function
+  __builtin_unreachable();
+#endif
+}
+#if defined __NVCC__
+    #ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+        #pragma nv_diagnostic pop
+    #else
+      #ifdef __CUDA_ARCH__
+        #pragma diagnostic pop
+      #endif
+    #endif
+#elif defined __NVCOMPILER
+    #pragma    diagnostic pop
+#endif
+
+template <size_t k, class Extents, class OffsetType, class ExtentType,
+          class StrideType>
+MDSPAN_INLINE_FUNCTION
+constexpr OffsetType
+last_of(std::integral_constant<size_t, k>, const Extents &,
+        const strided_slice<OffsetType, ExtentType, StrideType> &r) {
+  return r.extent;
+}
+
+// get stride of slices
+template <class T>
+MDSPAN_INLINE_FUNCTION
+constexpr auto stride_of(const T &) {
+  return std::integral_constant<size_t, 1>();
+}
+
+template <class OffsetType, class ExtentType, class StrideType>
+MDSPAN_INLINE_FUNCTION
+constexpr auto
+stride_of(const strided_slice<OffsetType, ExtentType, StrideType> &r) {
+  return r.stride;
+}
+
+// divide which can deal with integral constant preservation
+template <class IndexT, class T0, class T1>
+MDSPAN_INLINE_FUNCTION
+constexpr auto divide(const T0 &v0, const T1 &v1) {
+  return IndexT(v0) / IndexT(v1);
+}
+
+template <class IndexT, class T0, T0 v0, class T1, T1 v1>
+MDSPAN_INLINE_FUNCTION
+constexpr auto divide(const std::integral_constant<T0, v0> &,
+                      const std::integral_constant<T1, v1> &) {
+  // cutting short division by zero
+  // this is used for strided_slice with zero extent/stride
+  return std::integral_constant<IndexT, v0 == 0 ? 0 : v0 / v1>();
+}
+
+// multiply which can deal with integral constant preservation
+template <class IndexT, class T0, class T1>
+MDSPAN_INLINE_FUNCTION
+constexpr auto multiply(const T0 &v0, const T1 &v1) {
+  return IndexT(v0) * IndexT(v1);
+}
+
+template <class IndexT, class T0, T0 v0, class T1, T1 v1>
+MDSPAN_INLINE_FUNCTION
+constexpr auto multiply(const std::integral_constant<T0, v0> &,
+                        const std::integral_constant<T1, v1> &) {
+  return std::integral_constant<IndexT, v0 * v1>();
+}
+
+// compute new static extent from range, preserving static knowledge
+template <class Arg0, class Arg1> struct StaticExtentFromRange {
+  constexpr static size_t value = dynamic_extent;
+};
+
+template <class Integral0, Integral0 val0, class Integral1, Integral1 val1>
+struct StaticExtentFromRange<std::integral_constant<Integral0, val0>,
+                             std::integral_constant<Integral1, val1>> {
+  constexpr static size_t value = val1 - val0;
+};
+
+// compute new static extent from strided_slice, preserving static
+// knowledge
+template <class Arg0, class Arg1> struct StaticExtentFromStridedRange {
+  constexpr static size_t value = dynamic_extent;
+};
+
+template <class Integral0, Integral0 val0, class Integral1, Integral1 val1>
+struct StaticExtentFromStridedRange<std::integral_constant<Integral0, val0>,
+                                    std::integral_constant<Integral1, val1>> {
+  constexpr static size_t value = val0 > 0 ? 1 + (val0 - 1) / val1 : 0;
+};
+
+// creates new extents through recursive calls to next_extent member function
+// next_extent has different overloads for different types of stride specifiers
+template <size_t K, class Extents, size_t... NewExtents>
+struct extents_constructor {
+  MDSPAN_TEMPLATE_REQUIRES(
+    class Slice, class... SlicesAndExtents,
+    /* requires */(!std::is_convertible_v<Slice, size_t> &&
+                   !is_strided_slice<Slice>::value)
+  )
+  MDSPAN_INLINE_FUNCTION
+  constexpr static auto next_extent(const Extents &ext, const Slice &sl,
+                                    SlicesAndExtents... slices_and_extents) {
+    constexpr size_t new_static_extent = StaticExtentFromRange<
+        decltype(first_of(std::declval<Slice>())),
+        decltype(last_of(std::integral_constant<size_t, Extents::rank() - K>(),
+                         std::declval<Extents>(),
+                         std::declval<Slice>()))>::value;
+
+    using next_t =
+        extents_constructor<K - 1, Extents, NewExtents..., new_static_extent>;
+    using index_t = typename Extents::index_type;
+    return next_t::next_extent(
+        ext, slices_and_extents...,
+        index_t(last_of(std::integral_constant<size_t, Extents::rank() - K>(), ext,
+                        sl)) -
+            index_t(first_of(sl)));
+  }
+
+  MDSPAN_TEMPLATE_REQUIRES(
+    class Slice, class... SlicesAndExtents,
+    /* requires */ (std::is_convertible_v<Slice, size_t>)
+  )
+  MDSPAN_INLINE_FUNCTION
+  constexpr static auto next_extent(const Extents &ext, const Slice &,
+                                    SlicesAndExtents... slices_and_extents) {
+    using next_t = extents_constructor<K - 1, Extents, NewExtents...>;
+    return next_t::next_extent(ext, slices_and_extents...);
+  }
+
+  template <class OffsetType, class ExtentType, class StrideType,
+            class... SlicesAndExtents>
+  MDSPAN_INLINE_FUNCTION
+  constexpr static auto
+  next_extent(const Extents &ext,
+              const strided_slice<OffsetType, ExtentType, StrideType> &r,
+              SlicesAndExtents... slices_and_extents) {
+    using index_t = typename Extents::index_type;
+    using new_static_extent_t =
+        StaticExtentFromStridedRange<ExtentType, StrideType>;
+    if constexpr (new_static_extent_t::value == dynamic_extent) {
+      using next_t =
+          extents_constructor<K - 1, Extents, NewExtents..., dynamic_extent>;
+      return next_t::next_extent(
+          ext, slices_and_extents...,
+          r.extent > 0 ? 1 + divide<index_t>(r.extent - 1, r.stride) : 0);
+    } else {
+      constexpr size_t new_static_extent = new_static_extent_t::value;
+      using next_t =
+          extents_constructor<K - 1, Extents, NewExtents..., new_static_extent>;
+      return next_t::next_extent(
+          ext, slices_and_extents..., index_t(divide<index_t>(ExtentType(), StrideType())));
+    }
+  }
+};
+
+template <class Extents, size_t... NewStaticExtents>
+struct extents_constructor<0, Extents, NewStaticExtents...> {
+
+  template <class... NewExtents>
+  MDSPAN_INLINE_FUNCTION
+  constexpr static auto next_extent(const Extents &, NewExtents... new_exts) {
+    return extents<typename Extents::index_type, NewStaticExtents...>(
+        new_exts...);
+  }
+};
+
+} // namespace detail
+
+// submdspan_extents creates new extents given src extents and submdspan slice
+// specifiers
+template <class IndexType, size_t... Extents, class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION
+constexpr auto submdspan_extents(const extents<IndexType, Extents...> &src_exts,
+                                 SliceSpecifiers... slices) {
+
+  using ext_t = extents<IndexType, Extents...>;
+  return detail::extents_constructor<ext_t::rank(), ext_t>::next_extent(
+      src_exts, slices...);
+}
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
diff --git a/tpls/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp b/tpls/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp
new file mode 100644
index 0000000000..e1390fdeb5
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p2630_bits/submdspan_mapping.hpp
@@ -0,0 +1,625 @@
+//@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
+
+#pragma once
+
+#include <array>
+#include <tuple>
+#include <type_traits>
+#include <utility> // index_sequence
+
+// Suppress spurious warning with NVCC about no return statement.
+// This is a known issue in NVCC and NVC++
+// Depending on the CUDA and GCC version we need both the builtin
+// and the diagnostic push. I tried really hard to find something shorter
+// but no luck ...
+#if defined __NVCC__
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diagnostic push
+#pragma nv_diag_suppress = implicit_return_from_non_void_function
+#else
+#ifdef __CUDA_ARCH__
+#pragma diagnostic push
+#pragma diag_suppress implicit_return_from_non_void_function
+#endif
+#endif
+#elif defined __NVCOMPILER
+#pragma diagnostic push
+#pragma diag_suppress = implicit_return_from_non_void_function
+#endif
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+//******************************************
+// Return type of submdspan_mapping overloads
+//******************************************
+template <class LayoutMapping> struct submdspan_mapping_result {
+  _MDSPAN_NO_UNIQUE_ADDRESS LayoutMapping mapping{};
+  size_t offset;
+};
+
+namespace detail {
+// We use const Slice& and not Slice&& because the various
+// submdspan_mapping_impl overloads use their slices arguments
+// multiple times.  This makes perfect forwarding not useful, but we
+// still don't want to pass those (possibly of size 64 x 3 bits)
+// objects by value.
+template <class IndexType, class Slice>
+MDSPAN_INLINE_FUNCTION constexpr bool
+one_slice_out_of_bounds(const IndexType &ext, const Slice &slice) {
+  using common_t =
+      std::common_type_t<decltype(detail::first_of(slice)), IndexType>;
+  return static_cast<common_t>(detail::first_of(slice)) ==
+         static_cast<common_t>(ext);
+}
+
+template <size_t... RankIndices, class IndexType, size_t... Exts,
+          class... Slices>
+MDSPAN_INLINE_FUNCTION constexpr bool
+any_slice_out_of_bounds_helper(std::index_sequence<RankIndices...>,
+                               const extents<IndexType, Exts...> &exts,
+                               const Slices &... slices) {
+  return _MDSPAN_FOLD_OR(
+      (one_slice_out_of_bounds(exts.extent(RankIndices), slices)));
+}
+
+template <class IndexType, size_t... Exts, class... Slices>
+MDSPAN_INLINE_FUNCTION constexpr bool
+any_slice_out_of_bounds(const extents<IndexType, Exts...> &exts,
+                        const Slices &... slices) {
+  return any_slice_out_of_bounds_helper(
+      std::make_index_sequence<sizeof...(Slices)>(), exts, slices...);
+}
+
+// constructs sub strides
+template <class SrcMapping, class... slice_strides, size_t... InvMapIdxs>
+MDSPAN_INLINE_FUNCTION constexpr auto construct_sub_strides(
+    const SrcMapping &src_mapping, std::index_sequence<InvMapIdxs...>,
+    const std::tuple<slice_strides...> &slices_stride_factor) {
+  using index_type = typename SrcMapping::index_type;
+  return std::array<typename SrcMapping::index_type, sizeof...(InvMapIdxs)>{
+      (static_cast<index_type>(src_mapping.stride(InvMapIdxs)) *
+       static_cast<index_type>(std::get<InvMapIdxs>(slices_stride_factor)))...};
+}
+
+template<class SliceSpecifier, class IndexType>
+struct is_range_slice {
+  constexpr static bool value =
+    std::is_same_v<SliceSpecifier, full_extent_t> ||
+    std::is_convertible_v<SliceSpecifier,
+                          std::tuple<IndexType, IndexType>>;
+};
+
+template<class SliceSpecifier, class IndexType>
+constexpr bool is_range_slice_v = is_range_slice<SliceSpecifier, IndexType>::value;
+
+template<class SliceSpecifier, class IndexType>
+struct is_index_slice {
+  constexpr static bool value = std::is_convertible_v<SliceSpecifier, IndexType>;
+};
+
+template<class SliceSpecifier, class IndexType>
+constexpr bool is_index_slice_v = is_index_slice<SliceSpecifier, IndexType>::value;
+
+} // namespace detail
+
+//**********************************
+// layout_left submdspan_mapping
+//*********************************
+namespace detail {
+
+// Figure out whether to preserve layout_left
+template <class IndexType, size_t SubRank, class IndexSequence,
+          class... SliceSpecifiers>
+struct deduce_layout_left_submapping;
+
+template <class IndexType, size_t SubRank, size_t... Idx,
+          class... SliceSpecifiers>
+struct deduce_layout_left_submapping<
+    IndexType, SubRank, std::index_sequence<Idx...>, SliceSpecifiers...> {
+
+  using count_range = index_sequence_scan_impl<
+      0u, (is_index_slice_v<SliceSpecifiers, IndexType> ? 0u : 1u)...>;
+
+  constexpr static int gap_len =
+      (((Idx > 0 && count_range::get(Idx) == 1 &&
+         is_index_slice_v<SliceSpecifiers, IndexType>)
+            ? 1
+            : 0) +
+       ... + 0);
+
+  MDSPAN_INLINE_FUNCTION
+  constexpr static bool layout_left_value() {
+    // Use layout_left for rank 0
+    if constexpr (SubRank == 0) {
+      return true;
+    // Use layout_left for rank 1 result if leftmost slice specifier is range like
+    } else if constexpr (SubRank == 1) {
+      return ((Idx > 0 || is_range_slice_v<SliceSpecifiers, IndexType>)&&...);
+    } else {
+      // Preserve if leftmost SubRank-1 slices are full_extent_t and
+      // the slice at idx Subrank - 1 is a range and
+      // for idx > SubRank the slice is an index
+      return ((((Idx <  SubRank - 1) && std::is_same_v<SliceSpecifiers, full_extent_t>) ||
+               ((Idx == SubRank - 1) && is_range_slice_v<SliceSpecifiers, IndexType>) ||
+               ((Idx >  SubRank - 1) && is_index_slice_v<SliceSpecifiers, IndexType>)) && ...);
+    }
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+    __builtin_unreachable();
+#endif
+  }
+
+  MDSPAN_INLINE_FUNCTION
+  constexpr static bool layout_left_padded_value() {
+    // Technically could also keep layout_left_padded for SubRank==0
+    // and SubRank==1 with leftmost slice specifier being a contiguous range
+    // but we intercept these cases separately
+
+    // In all other cases:
+    // leftmost slice must be range
+    // then there can be a gap with index slices
+    // then SubRank - 2 full_extent slices
+    // then another range slice
+    // then more index slices
+    // e.g. R I I I F F F R I I for obtaining a rank-5 from a rank-10
+    return ((((Idx == 0)                                       && is_range_slice_v<SliceSpecifiers, IndexType>) ||
+             ((Idx > 0 && Idx <= gap_len)                     && is_index_slice_v<SliceSpecifiers, IndexType>) ||
+             ((Idx > gap_len && Idx < gap_len + SubRank - 1) && std::is_same_v<SliceSpecifiers, full_extent_t>) || 
+             ((Idx == gap_len + SubRank - 1)                  && is_range_slice_v<SliceSpecifiers, IndexType>) ||
+             ((Idx >  gap_len + SubRank - 1)                  && is_index_slice_v<SliceSpecifiers, IndexType>)) && ... );
+  }
+};
+
+// We are reusing the same thing for layout_left and layout_left_padded
+// For layout_left as source StaticStride is static_extent(0)
+template<class Extents, size_t NumGaps, size_t StaticStride>
+struct compute_s_static_layout_left {
+  // Neither StaticStride nor any of the provided extents can be zero.
+  // StaticStride can never be zero, the static_extents we are looking at are associated with
+  // integral slice specifiers - which wouldn't be valid for zero extent
+  template<size_t ... Idx>
+  MDSPAN_INLINE_FUNCTION
+  static constexpr size_t value(std::index_sequence<Idx...>) {
+    size_t val = ((Idx>0 && Idx<=NumGaps ? (Extents::static_extent(Idx) == dynamic_extent?0:Extents::static_extent(Idx)) : 1) * ... * (StaticStride == dynamic_extent?0:StaticStride));
+    return val == 0?dynamic_extent:val;
+  }
+};
+
+} // namespace detail
+
+// Actual submdspan mapping call
+template <class Extents>
+template <class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION constexpr auto
+layout_left::mapping<Extents>::submdspan_mapping_impl(
+    SliceSpecifiers... slices) const {
+
+  // compute sub extents
+  using src_ext_t = Extents;
+  auto dst_ext = submdspan_extents(extents(), slices...);
+  using dst_ext_t = decltype(dst_ext);
+
+  // figure out sub layout type
+  using deduce_layout = detail::deduce_layout_left_submapping<
+      typename dst_ext_t::index_type, dst_ext_t::rank(),
+      std::make_index_sequence<src_ext_t::rank()>,
+      SliceSpecifiers...>;
+
+  // Figure out if any slice's lower bound equals the corresponding extent.
+  // If so, bypass evaluating the layout mapping.  This fixes LWG Issue 4060.
+  const bool out_of_bounds =
+      detail::any_slice_out_of_bounds(this->extents(), slices...);
+  auto offset = static_cast<size_t>(
+      out_of_bounds ? this->required_span_size()
+                    : this->operator()(detail::first_of(slices)...));
+
+  if constexpr (deduce_layout::layout_left_value()) {
+    // layout_left case
+    using dst_mapping_t = typename layout_left::template mapping<dst_ext_t>;
+    return submdspan_mapping_result<dst_mapping_t>{dst_mapping_t(dst_ext),
+                                                   offset};
+  } else if constexpr (deduce_layout::layout_left_padded_value()) {
+    constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left<Extents, deduce_layout::gap_len, Extents::static_extent(0)>::value(std::make_index_sequence<Extents::rank()>());
+    using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded<S_static>::template mapping<dst_ext_t>;
+    return submdspan_mapping_result<dst_mapping_t>{
+        dst_mapping_t(dst_ext, stride(1 + deduce_layout::gap_len)), offset};
+  } else {
+    // layout_stride case
+    using dst_mapping_t = typename layout_stride::mapping<dst_ext_t>;
+    auto inv_map = detail::inv_map_rank(std::integral_constant<size_t, 0>(),
+                                        std::index_sequence<>(), slices...);
+    return submdspan_mapping_result<dst_mapping_t> {
+      dst_mapping_t(dst_ext,
+                    detail::construct_sub_strides(
+                        *this, inv_map,
+// HIP needs deduction guides to have markups so we need to be explicit
+// NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have
+// the issue But Clang-CUDA also doesn't accept the use of deduction guide so
+// disable it for CUDA altogether
+#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA)
+                        std::tuple<decltype(detail::stride_of(slices))...>{
+                            detail::stride_of(slices)...})),
+#else
+                        std::tuple{detail::stride_of(slices)...})),
+#endif
+          offset
+    };
+  }
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+  __builtin_unreachable();
+#endif
+}
+
+template <size_t PaddingValue>
+template <class Extents>
+template <class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION constexpr auto
+MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded<PaddingValue>::mapping<Extents>::submdspan_mapping_impl(
+    SliceSpecifiers... slices) const {
+
+  // compute sub extents
+  using src_ext_t = Extents;
+  auto dst_ext = submdspan_extents(extents(), slices...);
+  using dst_ext_t = decltype(dst_ext);
+
+  if constexpr (Extents::rank() == 0) { // rank-0 case
+    using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded<PaddingValue>::template mapping<Extents>;
+    return submdspan_mapping_result<dst_mapping_t>{*this, 0};
+  } else {
+    const bool out_of_bounds =
+        MDSPAN_IMPL_STANDARD_NAMESPACE::detail::any_slice_out_of_bounds(this->extents(), slices...);
+    auto offset = static_cast<size_t>(
+        out_of_bounds ? this->required_span_size()
+                    : this->operator()(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::first_of(slices)...));
+    if constexpr (dst_ext_t::rank() == 0) { // result rank-0
+      // The following for some reasons leads to compiler error later, while not using a typedef works:
+      // Compilers: CUDA 11.2 with GCC 9.1
+      //
+      // using dst_mapping_t = typename layout_left::template mapping<dst_ext_t>;
+      // return submdspan_mapping_result<dst_mapping_t>{dst_mapping_t{dst_ext}, offset};
+      //
+      // Error: submdspan_mapping.hpp:299:23: error: 'dst_mapping_t' does not name a type
+      //         299 |         using dst_mapping_t = typename layout_left::template mapping<dst_ext_t>;
+      // The same error is given (about dst_mapping_t not naming type) when a different name is used in 299:
+      //        using dst_mapping_t2 = typename layout_left::template mapping<dst_ext_t>;
+
+      return submdspan_mapping_result<typename layout_left::template mapping<dst_ext_t>>
+             {typename layout_left::template mapping<dst_ext_t>{dst_ext}, offset};
+    } else { // general case
+      // Figure out if any slice's lower bound equals the corresponding extent.
+      // If so, bypass evaluating the layout mapping.  This fixes LWG Issue 4060.
+      // figure out sub layout type
+      using deduce_layout = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::deduce_layout_left_submapping<
+        typename dst_ext_t::index_type, dst_ext_t::rank(),
+        decltype(std::make_index_sequence<src_ext_t::rank()>()),
+        SliceSpecifiers...>;
+
+      if constexpr (deduce_layout::layout_left_value() && dst_ext_t::rank() == 1) { // getting rank-1 from leftmost
+        using dst_mapping_t = typename layout_left::template mapping<dst_ext_t>;
+        return submdspan_mapping_result<dst_mapping_t>{dst_mapping_t{dst_ext}, offset};
+      } else if constexpr (deduce_layout::layout_left_padded_value()) { // can keep layout_left_padded
+        constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left<Extents, deduce_layout::gap_len, static_padding_stride>::value(std::make_index_sequence<Extents::rank()>());
+        using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_left_padded<S_static>::template mapping<dst_ext_t>;
+        return submdspan_mapping_result<dst_mapping_t>{
+        dst_mapping_t(dst_ext, stride(1 + deduce_layout::gap_len)), offset};
+      } else { // layout_stride
+    auto inv_map = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::inv_map_rank(std::integral_constant<size_t, 0>(),
+                                        std::index_sequence<>(), slices...);
+      using dst_mapping_t = typename layout_stride::template mapping<dst_ext_t>;
+    return submdspan_mapping_result<dst_mapping_t> {
+      dst_mapping_t(dst_ext,
+                    MDSPAN_IMPL_STANDARD_NAMESPACE::detail::construct_sub_strides(
+                        *this, inv_map,
+// HIP needs deduction guides to have markups so we need to be explicit
+// NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have
+// the issue But Clang-CUDA also doesn't accept the use of deduction guide so
+// disable it for CUDA alltogether
+#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA)
+                        std::tuple<decltype(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices))...>{
+                            MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices)...})),
+#else
+                        std::tuple{MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices)...})),
+#endif
+          offset
+    };
+      }
+    }
+  }
+
+
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+  __builtin_unreachable();
+#endif
+}
+
+//**********************************
+// layout_right submdspan_mapping
+//*********************************
+namespace detail {
+
+// Figure out whether to preserve layout_right
+template <class IndexType, size_t SubRank, class IndexSequence,
+          class... SliceSpecifiers>
+struct deduce_layout_right_submapping;
+
+template <class IndexType, size_t SubRank, size_t... Idx,
+          class... SliceSpecifiers>
+struct deduce_layout_right_submapping<
+    IndexType, SubRank, std::index_sequence<Idx...>, SliceSpecifiers...> {
+
+  static constexpr size_t Rank = sizeof...(Idx);
+  using count_range = index_sequence_scan_impl<
+      0u, (std::is_convertible_v<SliceSpecifiers, IndexType> ? 0u : 1u)...>;
+  //__static_partial_sums<!std::is_convertible_v<SliceSpecifiers,
+  // IndexType>...>;
+  constexpr static int gap_len =
+      (((Idx < Rank - 1 && count_range::get(Idx) == SubRank - 1 &&
+         std::is_convertible_v<SliceSpecifiers, IndexType>)
+            ? 1
+            : 0) +
+       ... + 0);
+
+  MDSPAN_INLINE_FUNCTION
+  constexpr static bool layout_right_value() {
+    // Use layout_right for rank 0
+    if constexpr (SubRank == 0) {
+      return true;
+    // Use layout_right for rank 1 result if rightmost slice specifier is range like
+    } else if constexpr (SubRank == 1) {
+      return ((Idx < Rank - 1 || is_range_slice_v<SliceSpecifiers, IndexType>)&&...);
+    } else {
+      // Preserve if rightmost SubRank-1 slices are full_extent_t and
+      // the slice at idx Rank-Subrank is a range and
+      // for idx < Rank - SubRank the slice is an index
+      return ((((Idx >= Rank - SubRank) && std::is_same_v<SliceSpecifiers, full_extent_t>) ||
+               ((Idx == Rank - SubRank) && is_range_slice_v<SliceSpecifiers, IndexType>) ||
+               ((Idx <  Rank - SubRank) && is_index_slice_v<SliceSpecifiers, IndexType>)) && ...);
+    }
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+    __builtin_unreachable();
+#endif
+  }
+
+  MDSPAN_INLINE_FUNCTION
+  constexpr static bool layout_right_padded_value() {
+    // Technically could also keep layout_right_padded for SubRank==0
+    // and SubRank==1 with rightmost slice specifier being a contiguous range
+    // but we intercept these cases separately
+
+    // In all other cases:
+    // rightmost slice must be range
+    // then there can be a gap with index slices
+    // then SubRank - 2 full_extent slices
+    // then another range slice
+    // then more index slices
+    // e.g. I I R F F F I I I R for obtaining a rank-5 from a rank-10
+    return ((((Idx == Rank - 1)                                               && is_range_slice_v<SliceSpecifiers, IndexType>) ||
+             ((Idx >= Rank - gap_len - 1 && Idx < Rank - 1)                  && is_index_slice_v<SliceSpecifiers, IndexType>) ||
+             ((Idx >  Rank - gap_len - SubRank && Idx < Rank - gap_len - 1) && std::is_same_v<SliceSpecifiers, full_extent_t>) ||
+             ((Idx == Rank - gap_len - SubRank)                              && is_range_slice_v<SliceSpecifiers, IndexType>) ||
+             ((Idx <  Rank - gap_len - SubRank)                              && is_index_slice_v<SliceSpecifiers, IndexType>)) && ... );
+  }
+};
+
+// We are reusing the same thing for layout_right and layout_right_padded
+// For layout_right as source StaticStride is static_extent(Rank-1)
+template<class Extents, size_t NumGaps, size_t StaticStride>
+struct compute_s_static_layout_right {
+  // Neither StaticStride nor any of the provided extents can be zero.
+  // StaticStride can never be zero, the static_extents we are looking at are associated with
+  // integral slice specifiers - which wouldn't be valid for zero extent
+  template<size_t ... Idx>
+  MDSPAN_INLINE_FUNCTION
+  static constexpr size_t value(std::index_sequence<Idx...>) {
+    size_t val = ((Idx >= Extents::rank() - 1 - NumGaps && Idx < Extents::rank() - 1 ? (Extents::static_extent(Idx) == dynamic_extent?0:Extents::static_extent(Idx)) : 1) * ... * (StaticStride == dynamic_extent?0:StaticStride));
+    return val == 0?dynamic_extent:val;
+  }
+};
+
+} // namespace detail
+
+// Actual submdspan mapping call
+template <class Extents>
+template <class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION constexpr auto
+layout_right::mapping<Extents>::submdspan_mapping_impl(
+    SliceSpecifiers... slices) const {
+
+  // compute sub extents
+  using src_ext_t = Extents;
+  auto dst_ext = submdspan_extents(extents(), slices...);
+  using dst_ext_t = decltype(dst_ext);
+
+  // figure out sub layout type
+  using deduce_layout = detail::deduce_layout_right_submapping<
+      typename dst_ext_t::index_type, dst_ext_t::rank(),
+      std::make_index_sequence<src_ext_t::rank()>,
+      SliceSpecifiers...>;
+
+  // Figure out if any slice's lower bound equals the corresponding extent.
+  // If so, bypass evaluating the layout mapping.  This fixes LWG Issue 4060.
+  const bool out_of_bounds =
+      detail::any_slice_out_of_bounds(this->extents(), slices...);
+  auto offset = static_cast<size_t>(
+      out_of_bounds ? this->required_span_size()
+                    : this->operator()(detail::first_of(slices)...));
+
+  if constexpr (deduce_layout::layout_right_value()) {
+    // layout_right case
+    using dst_mapping_t = typename layout_right::mapping<dst_ext_t>;
+    return submdspan_mapping_result<dst_mapping_t>{dst_mapping_t(dst_ext),
+                                                   offset};
+  } else if constexpr (deduce_layout::layout_right_padded_value()) {
+    constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_left<Extents, deduce_layout::gap_len, Extents::static_extent(Extents::rank() - 1)>::value(std::make_index_sequence<Extents::rank()>());
+    using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded<S_static>::template mapping<dst_ext_t>;
+    return submdspan_mapping_result<dst_mapping_t>{
+        dst_mapping_t(dst_ext,
+                      stride(src_ext_t::rank() - 2 - deduce_layout::gap_len)),
+        offset};
+  } else {
+    // layout_stride case
+    using dst_mapping_t = typename layout_stride::mapping<dst_ext_t>;
+    auto inv_map = detail::inv_map_rank(std::integral_constant<size_t, 0>(),
+                                        std::index_sequence<>(), slices...);
+    return submdspan_mapping_result<dst_mapping_t> {
+      dst_mapping_t(dst_ext,
+                    detail::construct_sub_strides(
+                        *this, inv_map,
+// HIP needs deduction guides to have markups so we need to be explicit
+// NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have
+// the issue But Clang-CUDA also doesn't accept the use of deduction guide so
+// disable it for CUDA altogether
+#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA)
+                        std::tuple<decltype(detail::stride_of(slices))...>{
+                            detail::stride_of(slices)...})),
+#else
+                        std::tuple{detail::stride_of(slices)...})),
+#endif
+          offset
+    };
+  }
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+  __builtin_unreachable();
+#endif
+}
+
+template <size_t PaddingValue>
+template <class Extents>
+template <class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION constexpr auto
+MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded<PaddingValue>::mapping<Extents>::submdspan_mapping_impl(
+    SliceSpecifiers... slices) const {
+
+  // compute sub extents
+  using src_ext_t = Extents;
+  auto dst_ext = submdspan_extents(extents(), slices...);
+  using dst_ext_t = decltype(dst_ext);
+
+  if constexpr (Extents::rank() == 0) { // rank-0 case
+    using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded<PaddingValue>::template mapping<Extents>;
+    return submdspan_mapping_result<dst_mapping_t>{*this, 0};
+  } else {
+    // Figure out if any slice's lower bound equals the corresponding extent.
+    // If so, bypass evaluating the layout mapping.  This fixes LWG Issue 4060.
+    // figure out sub layout type
+    const bool out_of_bounds =
+        MDSPAN_IMPL_STANDARD_NAMESPACE::detail::any_slice_out_of_bounds(this->extents(), slices...);
+    auto offset = static_cast<size_t>(
+        out_of_bounds ? this->required_span_size()
+                    : this->operator()(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::first_of(slices)...));
+    if constexpr (dst_ext_t::rank() == 0) { // result rank-0
+      // Same issue as in layout_left_padded: see comment there
+      // using dst_mapping_t = typename layout_right::template mapping<dst_ext_t>;
+      // return submdspan_mapping_result<dst_mapping_t>{dst_mapping_t{dst_ext}, offset};
+      return submdspan_mapping_result<typename layout_right::template mapping<dst_ext_t>>
+        {typename layout_right::template mapping<dst_ext_t>{dst_ext}, offset};
+    } else { // general case
+      using deduce_layout = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::deduce_layout_right_submapping<
+        typename dst_ext_t::index_type, dst_ext_t::rank(),
+        decltype(std::make_index_sequence<src_ext_t::rank()>()),
+        SliceSpecifiers...>;
+
+      if constexpr (deduce_layout::layout_right_value() && dst_ext_t::rank() == 1) { // getting rank-1 from rightmost
+        using dst_mapping_t = typename layout_right::template mapping<dst_ext_t>;
+        return submdspan_mapping_result<dst_mapping_t>{dst_mapping_t{dst_ext}, offset};
+      } else if constexpr (deduce_layout::layout_right_padded_value()) { // can keep layout_right_padded
+        constexpr size_t S_static = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::compute_s_static_layout_right<Extents, deduce_layout::gap_len, static_padding_stride>::value(std::make_index_sequence<Extents::rank()>());
+        using dst_mapping_t = typename MDSPAN_IMPL_PROPOSED_NAMESPACE::layout_right_padded<S_static>::template mapping<dst_ext_t>;
+        return submdspan_mapping_result<dst_mapping_t>{
+        dst_mapping_t(dst_ext, stride(Extents::rank() - 2 - deduce_layout::gap_len)), offset};
+      } else { // layout_stride
+    auto inv_map = MDSPAN_IMPL_STANDARD_NAMESPACE::detail::inv_map_rank(std::integral_constant<size_t, 0>(),
+                                        std::index_sequence<>(), slices...);
+      using dst_mapping_t = typename layout_stride::template mapping<dst_ext_t>;
+    return submdspan_mapping_result<dst_mapping_t> {
+      dst_mapping_t(dst_ext,
+                    MDSPAN_IMPL_STANDARD_NAMESPACE::detail::construct_sub_strides(
+                        *this, inv_map,
+// HIP needs deduction guides to have markups so we need to be explicit
+// NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have
+// the issue But Clang-CUDA also doesn't accept the use of deduction guide so
+// disable it for CUDA alltogether
+#if defined(_MDSPAN_HAS_HIP) || defined(_MDSPAN_HAS_CUDA)
+                        std::tuple<decltype(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices))...>{
+                            MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices)...})),
+#else
+                        std::tuple{MDSPAN_IMPL_STANDARD_NAMESPACE::detail::stride_of(slices)...})),
+#endif
+          offset
+    };
+      }
+    }
+  }
+
+
+#if defined(__NVCC__) && !defined(__CUDA_ARCH__) && defined(__GNUC__)
+  __builtin_unreachable();
+#endif
+}
+
+//**********************************
+// layout_stride submdspan_mapping
+//*********************************
+template <class Extents>
+template <class... SliceSpecifiers>
+MDSPAN_INLINE_FUNCTION constexpr auto
+layout_stride::mapping<Extents>::submdspan_mapping_impl(
+    SliceSpecifiers... slices) const {
+  auto dst_ext = submdspan_extents(extents(), slices...);
+  using dst_ext_t = decltype(dst_ext);
+  auto inv_map = detail::inv_map_rank(std::integral_constant<size_t, 0>(),
+                                      std::index_sequence<>(), slices...);
+  using dst_mapping_t = typename layout_stride::template mapping<dst_ext_t>;
+
+  // Figure out if any slice's lower bound equals the corresponding extent.
+  // If so, bypass evaluating the layout mapping.  This fixes LWG Issue 4060.
+  const bool out_of_bounds =
+      detail::any_slice_out_of_bounds(this->extents(), slices...);
+  auto offset = static_cast<size_t>(
+      out_of_bounds ? this->required_span_size()
+                    : this->operator()(detail::first_of(slices)...));
+
+  return submdspan_mapping_result<dst_mapping_t> {
+    dst_mapping_t(dst_ext,
+                  detail::construct_sub_strides(
+                      *this, inv_map,
+// HIP needs deduction guides to have markups so we need to be explicit
+// NVCC 11.0 has a bug with deduction guide here, tested that 11.2 does not have
+// the issue
+#if defined(_MDSPAN_HAS_HIP) ||                                                \
+    (defined(__NVCC__) &&                                                      \
+     (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__ * 10) < 1120)
+                      std::tuple<decltype(detail::stride_of(slices))...>(
+                          detail::stride_of(slices)...))),
+#else
+                      std::tuple(detail::stride_of(slices)...))),
+#endif
+        offset
+  };
+}
+
+} // namespace MDSPAN_IMPL_STANDARD_NAMESPACE
+
+#if defined __NVCC__
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diagnostic pop
+#else
+#ifdef __CUDA_ARCH__
+#pragma diagnostic pop
+#endif
+#endif
+#elif defined __NVCOMPILER
+#pragma diagnostic pop
+#endif
diff --git a/tpls/mdspan/include/experimental/__p2642_bits/layout_padded.hpp b/tpls/mdspan/include/experimental/__p2642_bits/layout_padded.hpp
new file mode 100644
index 0000000000..e5f7bee4ca
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p2642_bits/layout_padded.hpp
@@ -0,0 +1,867 @@
+//@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.
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+#pragma once
+
+#include <cassert>
+#include "layout_padded_fwd.hpp"
+#include "../__p0009_bits/dynamic_extent.hpp"
+#include "../__p0009_bits/extents.hpp"
+#include "../__p0009_bits/mdspan.hpp"
+#include "../__p0009_bits/layout_left.hpp"
+#include "../__p0009_bits/layout_right.hpp"
+#include "../__p0009_bits/layout_stride.hpp"
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace MDSPAN_IMPL_PROPOSED_NAMESPACE {
+
+namespace detail {
+template<class _T>
+MDSPAN_INLINE_FUNCTION
+constexpr _T
+find_next_multiple(_T alignment, _T offset)
+{
+  if ( alignment == 0 ) {
+    return _T(0);
+  } else {
+    return ( ( offset + alignment - 1 ) / alignment) * alignment;
+  }
+}
+
+template <class _ExtentsType, size_t _PaddingValue, size_t _ExtentToPadIdx>
+MDSPAN_INLINE_FUNCTION constexpr size_t get_actual_static_padding_value() {
+  constexpr auto rank = _ExtentsType::rank();
+
+  if constexpr (rank <= typename _ExtentsType::rank_type(1)) {
+    return 0;
+  } else if constexpr (_PaddingValue != dynamic_extent &&
+                       _ExtentsType::static_extent(_ExtentToPadIdx) !=
+                           dynamic_extent) {
+    static_assert(
+        (_PaddingValue != 0) ||
+            (_ExtentsType::static_extent(_ExtentToPadIdx) == 0),
+        "padding stride can be 0 only if "
+        "extents_type::static_extent(extent-to-pad) is 0 or dynamic_extent");
+    return find_next_multiple(_PaddingValue,
+                                _ExtentsType::static_extent(_ExtentToPadIdx));
+  } else {
+    return dynamic_extent;
+  }
+  // Missing return statement warning from NVCC and ICC
+#if defined(__NVCC__) || defined(__INTEL_COMPILER)
+  return 0;
+#endif
+}
+
+template <size_t _PaddingValue, typename _Extents, size_t _ExtentToPadIdx, size_t _Rank, typename Enabled = void>
+struct static_array_type_for_padded_extent
+{
+  static constexpr size_t padding_value = _PaddingValue;
+  using index_type = typename _Extents::index_type;
+  using extents_type = _Extents;
+  using type = ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::maybe_static_array<
+      index_type, size_t, dynamic_extent,
+      ::MDSPAN_IMPL_STANDARD_NAMESPACE::MDSPAN_IMPL_PROPOSED_NAMESPACE::detail::get_actual_static_padding_value<extents_type, _PaddingValue,
+                                                _ExtentToPadIdx>()>;
+};
+
+template <size_t _PaddingValue, typename _Extents, size_t _ExtentToPadIdx, size_t Rank>
+struct static_array_type_for_padded_extent<_PaddingValue, _Extents,
+                                             _ExtentToPadIdx, Rank, std::enable_if_t<Rank <= 1>> {
+  using index_type = typename _Extents::index_type;
+  using extents_type = _Extents;
+  using type =
+      ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::maybe_static_array<
+          index_type, size_t, dynamic_extent, 0>;
+};
+
+template <size_t _PaddingValue, typename _Extents, size_t _ExtentToPadIdx>
+struct padded_extent {
+  static constexpr size_t padding_value = _PaddingValue;
+  using index_type = typename _Extents::index_type;
+  using extents_type = _Extents;
+  using static_array_type = typename static_array_type_for_padded_extent<
+      padding_value, _Extents, _ExtentToPadIdx, _Extents::rank()>::type;
+
+  static constexpr auto static_value() { return static_array_type::static_value(0); }
+
+  MDSPAN_INLINE_FUNCTION
+  static constexpr static_array_type
+  init_padding(const _Extents &exts) {
+    if constexpr ((_Extents::rank() > 1) && (padding_value == dynamic_extent)) {
+      return {exts.extent(_ExtentToPadIdx)};
+    } else {
+      return init_padding(exts, padding_value);
+    }
+    // Missing return statement warning from NVCC and ICC
+#if defined(__NVCC__) || defined(__INTEL_COMPILER)
+    return {};
+#endif
+  }
+
+  MDSPAN_INLINE_FUNCTION static constexpr static_array_type
+  init_padding([[maybe_unused]] const _Extents &exts,
+               [[maybe_unused]] index_type pv) {
+    if constexpr (_Extents::rank() > 1) {
+      return {find_next_multiple(pv,
+                                   exts.extent(_ExtentToPadIdx))};
+    } else {
+      return {};
+    }
+    // Missing return statement warning from NVCC and ICC
+#if defined(__NVCC__) || defined(__INTEL_COMPILER)
+    return {};
+#endif
+  }
+
+  template <typename _Mapping, size_t _PaddingStrideIdx>
+  MDSPAN_INLINE_FUNCTION static constexpr static_array_type
+  init_padding([[maybe_unused]] const _Mapping &other_mapping,
+                      std::integral_constant<size_t, _PaddingStrideIdx>) {
+    if constexpr (_Extents::rank() > 1) {
+      return {other_mapping.stride(_PaddingStrideIdx)};
+    } else {
+      return {};
+    }
+    // Missing return statement warning from NVCC and ICC
+#if defined(__NVCC__) || defined(__INTEL_COMPILER)
+    return {};
+#endif
+  }
+};
+} // namespace detail
+
+template <size_t PaddingValue>
+template <class Extents>
+class layout_left_padded<PaddingValue>::mapping {
+public:
+  static constexpr size_t padding_value = PaddingValue;
+
+  using extents_type = Extents;
+  using index_type = typename extents_type::index_type;
+  using size_type = typename extents_type::size_type;
+  using rank_type = typename extents_type::rank_type;
+  using layout_type = layout_left_padded<padding_value>;
+
+#ifndef MDSPAN_INTERNAL_TEST
+private:
+#endif // MDSPAN_INTERNAL_TEST
+
+  static constexpr rank_type padded_stride_idx = detail::layout_padded_constants<layout_type, extents_type>::padded_stride_idx;
+  static constexpr rank_type extent_to_pad_idx = detail::layout_padded_constants<layout_type, extents_type>::extent_to_pad_idx;
+
+  static_assert((padding_value != 0)
+                || (extents_type::static_extent(extent_to_pad_idx) == 0)
+                || (extents_type::static_extent(extent_to_pad_idx) == dynamic_extent),
+                "out of bounds access for rank 0");
+
+  using padded_stride_type = detail::padded_extent< padding_value, extents_type, extent_to_pad_idx >;
+
+  static constexpr size_t static_padding_stride = padded_stride_type::static_value();
+
+  typename padded_stride_type::static_array_type padded_stride = {};
+  extents_type exts = {};
+
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  compute_offset(std::index_sequence<>) const {
+    return 0;
+  }
+
+  template <size_t Rank, class IndexOffset>
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  compute_offset(std::index_sequence<Rank>, IndexOffset index_offset) const {
+    return index_offset;
+  }
+
+  template <size_t... Ranks, class... IndexOffsets>
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  compute_offset(std::index_sequence<Ranks...>,
+                 IndexOffsets... index_offsets) const {
+    index_type indices[] = {static_cast<index_type>(index_offsets)...};
+    // self-recursive fold trick from
+    // https://github.com/llvm/llvm-project/blob/96e1914aa2e6d8966acbfbe2f4d184201f1aa318/libcxx/include/mdspan/layout_left.h#L144
+    index_type res = 0;
+    ((res = indices[extents_type::rank() - 1 - Ranks] +
+            ((extents_type::rank() - 1 - Ranks) == extent_to_pad_idx
+                 ? padded_stride.value(0)
+                 : exts.extent(extents_type::rank() - 1 - Ranks)) *
+                res),
+     ...);
+    return res;
+  }
+
+public:
+#if !MDSPAN_HAS_CXX_20
+  MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr mapping()
+      : mapping(extents_type{})
+  {}
+#else
+  MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr mapping()
+    requires(static_padding_stride != dynamic_extent) = default;
+
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping()
+    requires(static_padding_stride == dynamic_extent)
+      : mapping(extents_type{})
+  {}
+#endif
+
+  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(const mapping&) noexcept = default;
+  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping& operator=(const mapping&) noexcept = default;
+
+  /**
+   * Initializes the mapping with the given extents.
+   *
+   * \param ext the given extents
+   */
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const extents_type& ext)
+    : padded_stride(padded_stride_type::init_padding(ext)), exts(ext)
+  {}
+
+  /**
+   * Initializes the mapping with the given extents and the specified padding value.
+   *
+   * This overload participates in overload resolution only if `is_convertible_v<Size, index_type>`
+   * is `true` and `is_nothrow_constructible_v<index_type, Size>` is `true`
+   *
+   * \param ext the given extents
+   * \param padding_value the padding value
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+    class _Size,
+    /* requires */ (
+      std::is_convertible_v<_Size, index_type>
+      && std::is_nothrow_constructible_v<index_type, _Size>
+    )
+  )
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const extents_type &ext, _Size dynamic_padding_value)
+      : padded_stride(padded_stride_type::init_padding(ext, dynamic_padding_value)), exts(ext)
+  {
+    assert((padding_value == dynamic_extent) || (static_cast<index_type>(padding_value) == static_cast<index_type>(dynamic_padding_value)));
+  }
+
+  /**
+   * Converting constructor from `layout_left::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `is_constructible_v<extents_type, OtherExtents>` is true. If
+   * `OtherExtents::rank() > 1` then one of `padding_value`, `static_extent(0)`,
+   * or `OtherExtents::static_extent(0)` must be `dynamic_extent`; otherwise,
+   * `OtherExtents::static_extent(0)` must be equal to the least multiple of
+   * `padding_value` greater than or equal to `extents_type::static_extent(0)`
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (std::is_constructible_v<extents_type, _OtherExtents>))
+  MDSPAN_CONDITIONAL_EXPLICIT(
+      (!std::is_convertible_v<_OtherExtents, extents_type>))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const layout_left::mapping<_OtherExtents> &other_mapping)
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping,
+            std::integral_constant<size_t, padded_stride_idx>{})),
+        exts(other_mapping.extents()) {
+    static_assert(
+        (_OtherExtents::rank() > 1) ||
+        (static_padding_stride != dynamic_extent) ||
+        (_OtherExtents::static_extent(extent_to_pad_idx) != dynamic_extent) ||
+        (static_padding_stride ==
+         _OtherExtents::static_extent(extent_to_pad_idx)));
+  }
+
+  /**
+   * Converting constructor from `layout_stride::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `is_constructible_v<extents_type, OtherExtents>` is true
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (std::is_constructible_v<extents_type, _OtherExtents>))
+  MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const layout_stride::mapping<_OtherExtents> &other_mapping)
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping,
+            std::integral_constant<size_t, padded_stride_idx>{})),
+        exts(other_mapping.extents()) {}
+
+  /**
+   * Converting constructor from `layout_left_padded::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `is_constructible_v<extents_type, OtherExtents>` is true. Either
+   * `padding_value` or `OtherPaddingStride` must be `std::dynamic_extent`, or
+   * `padding_value == OtherPaddingStride`.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value
+                          &&std::is_constructible_v<
+                              extents_type, typename _Mapping::extents_type>))
+  MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 1 &&
+                               (padding_value == dynamic_extent ||
+                                _Mapping::padding_value == dynamic_extent)))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const _Mapping &other_mapping)
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping,
+            std::integral_constant<size_t, padded_stride_idx>{})),
+        exts(other_mapping.extents()) {
+    static_assert(padding_value == dynamic_extent ||
+                  _Mapping::padding_value == dynamic_extent ||
+                  padding_value == _Mapping::padding_value);
+  }
+
+  /**
+   * Converting constructor from `layout_right_padded::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `extents_type::rank()` is 0 or 1 and `is_constructible_v<extents_type,
+   * OtherExtents>` is `true`.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value
+                              &&extents_type::rank() <= 1 &&
+                      std::is_constructible_v<extents_type,
+                                              typename _Mapping::extents_type>))
+  MDSPAN_CONDITIONAL_EXPLICIT(
+      (!std::is_convertible_v<typename _Mapping::extents_type, extents_type>))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const _Mapping &other_mapping) noexcept
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping.extents(),
+            other_mapping.extents().extent(extent_to_pad_idx))),
+        exts(other_mapping.extents()) {}
+
+  MDSPAN_INLINE_FUNCTION constexpr const extents_type &
+  extents() const noexcept {
+    return exts;
+  }
+
+  MDSPAN_INLINE_FUNCTION constexpr std::array<index_type, extents_type::rank()>
+  strides() const noexcept {
+    if constexpr (extents_type::rank() == 0) {
+      return {};
+    } else if constexpr (extents_type::rank() == 1) {
+      return {1};
+    } else {
+      index_type value = 1;
+      std::array<index_type, extents_type::rank()> s{};
+      s[extent_to_pad_idx] = value;
+      value *= padded_stride.value(0);
+      for (rank_type r = extent_to_pad_idx + 1; r < extents_type::rank() - 1;
+           ++r) {
+        s[r] = value;
+        value *= exts.extent(r);
+      }
+      s[extents_type::rank() - 1] = value;
+      return s;
+    }
+  }
+
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  required_span_size() const noexcept {
+    if constexpr (extents_type::rank() == 0) {
+      return 1;
+    } else if constexpr (extents_type::rank() == 1) {
+      return exts.extent(0);
+    } else {
+      index_type value = padded_stride.value(0);
+      for (rank_type r = 1; r < extents_type::rank(); ++r) {
+        value *= exts.extent(r);
+      }
+      return value;
+    }
+  }
+
+  /**
+   * Return the mapping given the provided indices per rank.
+   *
+   * This overload participates in overload resolution only if:
+   * - `sizeof...(Indices) == extents_type::rank()`,
+   * - `(is_convertible_v<Indices, index_type> && ...) is true`, and
+   * - (is_nothrow_constructible_v<index_type, Indices> && ...) is true.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class... _Indices,
+      /* requires */ (sizeof...(_Indices) == extents_type::rank() &&
+                      (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::
+                           are_valid_indices<index_type, _Indices...>())))
+  MDSPAN_INLINE_FUNCTION constexpr size_t
+  operator()(_Indices... idxs) const noexcept {
+#if !defined(NDEBUG)
+    ::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::check_all_indices(this->extents(),
+                                                                idxs...);
+#endif // ! NDEBUG
+    return compute_offset(std::index_sequence_for<_Indices...>{}, idxs...);
+  }
+
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept {
+    return true;
+  }
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept {
+    return (extents_type::rank() <= rank_type(1)) ||
+           (extents_type::static_extent(extent_to_pad_idx) != dynamic_extent &&
+            extents_type::static_extent(extent_to_pad_idx) ==
+                padded_stride_type::static_value());
+  }
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept {
+    return true;
+  }
+
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept {
+    return true;
+  }
+  MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept {
+    return (extents_type::rank() < 2) ||
+           (exts.extent(extent_to_pad_idx) == padded_stride.value(0));
+  }
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept {
+    return true;
+  }
+
+  MDSPAN_INLINE_FUNCTION
+  constexpr index_type stride(rank_type r) const noexcept {
+    assert(r < extents_type::rank());
+    if (r == 0)
+      return index_type(1);
+
+    index_type value = padded_stride.value(0);
+    for (rank_type k = 1; k < r; k++)
+      value *= exts.extent(k);
+
+    return value;
+  }
+
+  /**
+   * Equality operator between `layout_left_padded`s
+   *
+   * This overload only participates in overload resolution if
+   * `OtherExtents::rank() == extents_type::rank()`.
+   *
+   * \note There is currently a difference from p2642r2, where this function is
+   * specified as taking `layout_left_padded< padding_value >::mapping<
+   * Extents>`. However, this makes `padding_value` non-deducible.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value &&
+                      (_Mapping::extents_type::rank() == extents_type::rank())))
+  MDSPAN_INLINE_FUNCTION friend constexpr bool
+  operator==(const mapping &left, const _Mapping &right) noexcept {
+    // Workaround for some compilers not short-circuiting properly with
+    // compile-time checks i.e. we can't access stride(_padding_stride_idx) of a
+    // rank 0 mapping
+    bool strides_equal = true;
+    if constexpr (extents_type::rank() > rank_type(1)) {
+      strides_equal =
+          left.stride(padded_stride_idx) == right.stride(padded_stride_idx);
+    }
+    return (left.extents() == right.extents()) && strides_equal;
+  }
+
+#if !MDSPAN_HAS_CXX_20
+  /**
+   * Inequality operator between `layout_left_padded`s
+   *
+   * This overload only participates in overload resolution if
+   * `OtherExtents::rank() == extents_type::rank()`.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value &&
+                      (_Mapping::extents_type::rank() == extents_type::rank())))
+  MDSPAN_INLINE_FUNCTION friend constexpr bool
+  operator!=(const mapping &left, const _Mapping &right) noexcept {
+    return !(left == right);
+  }
+#endif
+
+   // [mdspan.submdspan.mapping], submdspan mapping specialization
+   template<class... SliceSpecifiers>
+   MDSPAN_INLINE_FUNCTION
+     constexpr auto submdspan_mapping_impl(
+       SliceSpecifiers... slices) const;
+
+   template<class... SliceSpecifiers>
+   MDSPAN_INLINE_FUNCTION
+     friend constexpr auto submdspan_mapping(
+       const mapping& src, SliceSpecifiers... slices) {
+         return src.submdspan_mapping_impl(slices...);
+     }
+};
+
+template <size_t PaddingValue>
+template <class Extents>
+class layout_right_padded<PaddingValue>::mapping {
+public:
+  static constexpr size_t padding_value = PaddingValue;
+
+  using extents_type = Extents;
+  using index_type = typename extents_type::index_type;
+  using size_type = typename extents_type::size_type;
+  using rank_type = typename extents_type::rank_type;
+  using layout_type = layout_right_padded<padding_value>;
+
+#ifndef MDSPAN_INTERNAL_TEST
+  private:
+#endif // MDSPAN_INTERNAL_TEST
+
+  static constexpr rank_type padded_stride_idx = detail::layout_padded_constants<layout_type, extents_type>::padded_stride_idx;
+  static constexpr rank_type extent_to_pad_idx = detail::layout_padded_constants<layout_type, extents_type>::extent_to_pad_idx;
+
+  static_assert((padding_value != 0)
+                || (extents_type::static_extent(extent_to_pad_idx) == 0)
+                || (extents_type::static_extent(extent_to_pad_idx) == dynamic_extent),
+                "if padding stride is 0, static_extent(extent-to-pad-rank) must also be 0 or dynamic_extent");
+
+  using padded_stride_type = detail::padded_extent< padding_value, extents_type, extent_to_pad_idx >;
+  static constexpr size_t static_padding_stride = padded_stride_type::static_value();
+
+  typename padded_stride_type::static_array_type padded_stride = {};
+  extents_type exts = {};
+
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  compute_offset(std::index_sequence<>) const {
+    return 0;
+  }
+
+  template <size_t Rank, class IndexOffset>
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  compute_offset(std::index_sequence<Rank>, IndexOffset index_offset) const {
+    return index_offset;
+  }
+
+  template <size_t... Ranks, class... IndexOffsets>
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  compute_offset(std::index_sequence<Ranks...>,
+                 IndexOffsets... index_offsets) const {
+    // self-recursive fold trick from
+    // https://github.com/llvm/llvm-project/blob/4d9771741d40cc9cfcccb6b033f43689d36b705a/libcxx/include/mdspan/layout_right.h#L141
+    index_type res = 0;
+    ((res = static_cast<index_type>(index_offsets) +
+            (Ranks == extent_to_pad_idx ? padded_stride.value(0)
+                                        : exts.extent(Ranks)) *
+                res),
+     ...);
+    return res;
+  }
+
+public:
+#if !MDSPAN_HAS_CXX_20
+  MDSPAN_INLINE_FUNCTION_DEFAULTED
+      constexpr mapping()
+      : mapping(extents_type{})
+  {}
+#else
+  MDSPAN_INLINE_FUNCTION_DEFAULTED
+      constexpr mapping()
+    requires(static_padding_stride != dynamic_extent) = default;
+
+  MDSPAN_INLINE_FUNCTION
+      constexpr mapping()
+    requires(static_padding_stride == dynamic_extent)
+      : mapping(extents_type{})
+  {}
+#endif
+
+  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(const mapping&) noexcept = default;
+  MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping& operator=(const mapping&) noexcept = default;
+
+  /**
+   * Initializes the mapping with the given extents.
+   *
+   * \param ext the given extents
+   */
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const extents_type &ext)
+      : padded_stride(padded_stride_type::init_padding(ext)), exts(ext) {}
+
+  /**
+   * Initializes the mapping with the given extents and the specified padding value.
+   *
+   * This overload participates in overload resolution only if `is_convertible_v<Size, index_type>`
+   * is `true` and `is_nothrow_constructible_v<index_type, Size>` is `true`
+   *
+   * \param ext the given extents
+   * \param padding_value the padding value
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Size,
+      /* requires */ (
+          std::is_convertible_v<_Size, index_type>
+              && std::is_nothrow_constructible_v<index_type, _Size>
+          )
+      )
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const extents_type &ext, _Size dynamic_padding_value)
+      : padded_stride(padded_stride_type::init_padding(ext, static_cast<index_type>(dynamic_padding_value))),
+        exts(ext) {
+    assert((padding_value == dynamic_extent) ||
+           (static_cast<index_type>(padding_value) == static_cast<index_type>(dynamic_padding_value)));
+  }
+
+  /**
+   * Converting constructor from `layout_right::mapping`.
+   *
+   * This overload participates in overload resolution only if `is_constructible_v<extents_type, OtherExtents>` is true.
+   * If `OtherExtents::rank() > 1` then one of `padding_value`, `static_extent(0)`, or `OtherExtents::static_extent(0)` must be `dynamic_extent`;
+   * otherwise, `OtherExtents::static_extent(0)` must be equal to the least multiple of `padding_value` greater than or equal to `extents_type::static_extent(0)`
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (std::is_constructible_v<extents_type, _OtherExtents>))
+  MDSPAN_CONDITIONAL_EXPLICIT(
+      (!std::is_convertible_v<_OtherExtents, extents_type>))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const layout_right::mapping<_OtherExtents> &other_mapping)
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping,
+            std::integral_constant<size_t, padded_stride_idx>{})),
+        exts(other_mapping.extents()) {
+    static_assert(
+        (_OtherExtents::rank() > 1) ||
+        (padded_stride_type::static_value() != dynamic_extent) ||
+        (_OtherExtents::static_extent(extent_to_pad_idx) != dynamic_extent) ||
+        (padded_stride_type::static_value() ==
+         _OtherExtents::static_extent(extent_to_pad_idx)));
+  }
+
+  /**
+   * Converting constructor from `layout_stride::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `is_constructible_v<extents_type, OtherExtents>` is true
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (std::is_constructible_v<extents_type, _OtherExtents>))
+  MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const layout_stride::mapping<_OtherExtents> &other_mapping)
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping,
+            std::integral_constant<size_t, padded_stride_idx>{})),
+        exts(other_mapping.extents()) {}
+
+  /**
+   * Converting constructor from `layout_right_padded::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `is_constructible_v<extents_type, OtherExtents>` is true. Either
+   * `padding_value` or `OtherPaddingStride` must be `std::dynamic_extent`, or
+   * `padding_value == OtherPaddingStride`.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value
+                          &&std::is_constructible_v<
+                              extents_type, typename _Mapping::extents_type>))
+  MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 1 &&
+                               (padding_value == dynamic_extent ||
+                                _Mapping::padding_value == dynamic_extent)))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const _Mapping &other_mapping)
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping,
+            std::integral_constant<size_t, padded_stride_idx>{})),
+        exts(other_mapping.extents()) {
+    static_assert(padding_value == dynamic_extent ||
+                  _Mapping::padding_value == dynamic_extent ||
+                  padding_value == _Mapping::padding_value);
+  }
+
+  /**
+   * Converting constructor from `layout_left_padded::mapping`.
+   *
+   * This overload participates in overload resolution only if
+   * `extents_type::rank()` is 0 or 1 and `is_constructible_v<extents_type,
+   * OtherExtents>` is `true`.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_left_padded_mapping<_Mapping>::value
+                              &&extents_type::rank() <= 1 &&
+                      std::is_constructible_v<extents_type,
+                                              typename _Mapping::extents_type>))
+  MDSPAN_CONDITIONAL_EXPLICIT(
+      (!std::is_convertible_v<typename _Mapping::extents_type, extents_type>))
+  MDSPAN_INLINE_FUNCTION
+  constexpr mapping(const _Mapping &other_mapping) noexcept
+      : padded_stride(padded_stride_type::init_padding(
+            other_mapping.extents(),
+            other_mapping.extents().extent(extent_to_pad_idx))),
+        exts(other_mapping.extents()) {}
+
+  MDSPAN_INLINE_FUNCTION constexpr const extents_type &
+  extents() const noexcept {
+    return exts;
+  }
+
+  MDSPAN_INLINE_FUNCTION constexpr std::array<index_type, extents_type::rank()>
+  strides() const noexcept {
+    if constexpr (extents_type::rank() == 0) {
+      return {};
+    } else if constexpr (extents_type::rank() == 1) {
+      return {1};
+    } else {
+      index_type value = 1;
+      std::array<index_type, extents_type::rank()> s{};
+      s[extent_to_pad_idx] = value;
+      value *= padded_stride.value(0);
+      for (rank_type r = extent_to_pad_idx - 1; r > 0; --r) {
+        s[r] = value;
+        value *= exts.extent(r);
+      }
+      s[0] = value;
+      return s;
+    }
+  }
+
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  required_span_size() const noexcept {
+    if constexpr (extents_type::rank() == 0) {
+      return 1;
+    } else if constexpr (extents_type::rank() == 1) {
+      return exts.extent(0);
+    } else {
+      index_type value = 1;
+      for (rank_type r = 0; r < extent_to_pad_idx; ++r) {
+        value *= exts.extent(r);
+      }
+      return value * padded_stride.value(0);
+    }
+  }
+
+  /**
+   * Return the mapping given the provided indices per rank.
+   *
+   * This overload participates in overload resolution only if:
+   * - `sizeof...(Indices) == extents_type::rank()`,
+   * - `(is_convertible_v<Indices, index_type> && ...) is true`, and
+   * - (is_nothrow_constructible_v<index_type, Indices> && ...) is true.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class... _Indices,
+      /* requires */ (sizeof...(_Indices) == extents_type::rank() &&
+                      (::MDSPAN_IMPL_STANDARD_NAMESPACE::detail::
+                           are_valid_indices<index_type, _Indices...>())))
+  MDSPAN_INLINE_FUNCTION constexpr size_t
+  operator()(_Indices... idxs) const noexcept {
+    return compute_offset(std::index_sequence_for<_Indices...>{}, idxs...);
+  }
+
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept {
+    return true;
+  }
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept {
+    return (extents_type::rank() <= rank_type(1)) ||
+           (extents_type::static_extent(extent_to_pad_idx) != dynamic_extent &&
+            extents_type::static_extent(extent_to_pad_idx) ==
+                padded_stride_type::static_value());
+  }
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept {
+    return true;
+  }
+
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept {
+    return true;
+  }
+  MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept {
+    return (extents_type::rank() < 2) ||
+           (exts.extent(extent_to_pad_idx) == padded_stride.value(0));
+  }
+  MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept {
+    return true;
+  }
+
+  MDSPAN_INLINE_FUNCTION constexpr index_type
+  stride(rank_type r) const noexcept {
+    assert(r < extents_type::rank());
+    if (r == extents_type::rank() - 1)
+      return index_type(1);
+
+    index_type value = padded_stride.value(0);
+    for (rank_type k = extents_type::rank() - 2; k > r; k--)
+      value *= exts.extent(k);
+
+    return value;
+  }
+
+  /**
+   * Equality operator between `layout_right_padded`s
+   *
+   * This overload only participates in overload resolution if
+   * `OtherExtents::rank() == extents_type::rank()`.
+   *
+   * \note There is currently a difference from p2642r2, where this function is
+   * specified as taking `layout_right_padded< padding_value >::mapping<
+   * Extents>`. However, this makes `padding_value` non-deducible.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value &&
+                      (_Mapping::extents_type::rank() == extents_type::rank())))
+  MDSPAN_INLINE_FUNCTION friend constexpr bool
+  operator==(const mapping &left, const _Mapping &right) noexcept {
+    // Workaround for some compilers not short-circuiting properly with
+    // compile-time checks i.e. we can't access stride(_padding_stride_idx) of a
+    // rank 0 mapping
+    bool strides_equal = true;
+    if constexpr (extents_type::rank() > rank_type(1)) {
+      strides_equal =
+          left.stride(padded_stride_idx) == right.stride(padded_stride_idx);
+    }
+    return (left.extents() == right.extents()) && strides_equal;
+  }
+
+#if !MDSPAN_HAS_CXX_20
+  /**
+   * Inequality operator between `layout_right_padded`s
+   *
+   * This overload only participates in overload resolution if
+   * `OtherExtents::rank() == extents_type::rank()`.
+   */
+  MDSPAN_TEMPLATE_REQUIRES(
+      class _Mapping,
+      /* requires */ (detail::is_layout_right_padded_mapping<_Mapping>::value &&
+                      (_Mapping::extents_type::rank() == extents_type::rank())))
+  MDSPAN_INLINE_FUNCTION friend constexpr bool
+  operator!=(const mapping &left, const _Mapping &right) noexcept {
+    return !(left == right);
+  }
+#endif
+
+   // [mdspan.submdspan.mapping], submdspan mapping specialization
+   template<class... SliceSpecifiers>
+   MDSPAN_INLINE_FUNCTION
+     constexpr auto submdspan_mapping_impl(
+       SliceSpecifiers... slices) const;
+
+   template<class... SliceSpecifiers>
+   MDSPAN_INLINE_FUNCTION
+     friend constexpr auto submdspan_mapping(
+       const mapping& src, SliceSpecifiers... slices) {
+         return src.submdspan_mapping_impl(slices...);
+     }
+};
+}
+}
diff --git a/tpls/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp b/tpls/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp
new file mode 100644
index 0000000000..18daa28cc6
--- /dev/null
+++ b/tpls/mdspan/include/experimental/__p2642_bits/layout_padded_fwd.hpp
@@ -0,0 +1,131 @@
+//@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.
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+#pragma once
+
+#include <cassert>
+#include "../__p0009_bits/dynamic_extent.hpp"
+#include "../__p0009_bits/utility.hpp"
+
+namespace MDSPAN_IMPL_STANDARD_NAMESPACE {
+namespace MDSPAN_IMPL_PROPOSED_NAMESPACE {
+
+template <size_t padding_value = dynamic_extent>
+struct layout_left_padded {
+  template <class _Extents>
+  class mapping;
+};
+
+template <size_t padding_value = dynamic_extent>
+struct layout_right_padded {
+  template <class _Extents>
+  class mapping;
+};
+
+namespace detail {
+// The layout_padded_constants structs are only useful if rank > 1, otherwise they may wrap
+template <class _Layout, class _ExtentsType>
+struct layout_padded_constants;
+
+template <class _ExtentsType, size_t _PaddingStride>
+struct layout_padded_constants<layout_left_padded<_PaddingStride>, _ExtentsType>
+{
+  using rank_type = typename _ExtentsType::rank_type;
+  static constexpr rank_type padded_stride_idx = 1;
+  static constexpr rank_type extent_to_pad_idx = 0;
+};
+
+template <class _ExtentsType, size_t _PaddingStride>
+struct layout_padded_constants<layout_right_padded<_PaddingStride>, _ExtentsType>
+{
+  using rank_type = typename _ExtentsType::rank_type;
+  static constexpr rank_type padded_stride_idx = _ExtentsType::rank() - 2;
+  static constexpr rank_type extent_to_pad_idx = _ExtentsType::rank() - 1;
+};
+
+template <class _Layout>
+struct is_layout_left_padded : std::false_type {};
+
+template <size_t _PaddingStride>
+struct is_layout_left_padded<layout_left_padded<_PaddingStride>> : std::true_type {};
+
+template <class _Mapping, class _Enabled = void>
+struct is_layout_left_padded_mapping : std::false_type {};
+
+template <class _Mapping>
+struct is_layout_left_padded_mapping<_Mapping,
+  std::enable_if_t<std::is_same<_Mapping, typename layout_left_padded<_Mapping::padding_value>::template mapping<typename _Mapping::extents_type>>::value>>
+    : std::true_type {};
+
+template <class _Layout>
+struct is_layout_right_padded : std::false_type {};
+
+template <size_t _PaddingStride>
+struct is_layout_right_padded<layout_right_padded<_PaddingStride>> : std::true_type {};
+
+template <class _Mapping, class _Enabled = void>
+struct is_layout_right_padded_mapping : std::false_type {};
+
+template <class _Mapping>
+struct is_layout_right_padded_mapping<_Mapping,
+  std::enable_if_t<std::is_same<_Mapping, typename layout_right_padded<_Mapping::padding_value>::template mapping<typename _Mapping::extents_type>>::value>>
+    : std::true_type {};
+
+
+template <class _LayoutExtentsType, class _PaddedLayoutMappingType>
+constexpr void check_padded_layout_converting_constructor_mandates(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<0>) {}
+
+template <class _LayoutExtentsType, class _PaddedLayoutMappingType>
+constexpr void check_padded_layout_converting_constructor_mandates(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<1>) {}
+
+template <class _LayoutExtentsType, class _PaddedLayoutMappingType, std::size_t N>
+constexpr void check_padded_layout_converting_constructor_mandates(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<N>)
+{
+  using extents_type = typename _PaddedLayoutMappingType::extents_type;
+  constexpr auto padding_value = _PaddedLayoutMappingType::padding_value;
+  constexpr auto idx = layout_padded_constants<typename _PaddedLayoutMappingType::layout_type, _LayoutExtentsType >::extent_to_pad_idx;
+
+  constexpr auto statically_determinable =
+    (_LayoutExtentsType::static_extent(idx) != dynamic_extent) &&
+    (extents_type::static_extent(idx) != dynamic_extent) &&
+    (padding_value != dynamic_extent);
+
+  static_assert(!statically_determinable ||
+                (padding_value == 0
+                 ? _LayoutExtentsType::static_extent(idx) == 0
+                 : _LayoutExtentsType::static_extent(idx) % padding_value == 0),
+                "");
+}
+
+template <typename _ExtentsType, typename _OtherMapping>
+constexpr void check_padded_layout_converting_constructor_preconditions(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<0>,
+                                                                        const _OtherMapping&) {}
+template <typename _ExtentsType, typename _OtherMapping>
+constexpr void check_padded_layout_converting_constructor_preconditions(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<1>,
+                                                                        const _OtherMapping&) {}
+template <typename _ExtentsType, typename _OtherMapping, std::size_t N>
+constexpr void check_padded_layout_converting_constructor_preconditions(MDSPAN_IMPL_STANDARD_NAMESPACE::detail::with_rank<N>,
+                                                                        const _OtherMapping &other_mapping) {
+  constexpr auto padded_stride_idx =
+    layout_padded_constants<typename _OtherMapping::layout_type,
+                            _ExtentsType>::padded_stride_idx;
+  constexpr auto extent_to_pad_idx = layout_padded_constants<typename _OtherMapping::layout_type, _ExtentsType>::extent_to_pad_idx;
+  MDSPAN_IMPL_PRECONDITION(other_mapping.stride(padded_stride_idx) == other_mapping.extents().extent(extent_to_pad_idx));
+}
+
+
+}
+}
+}
diff --git a/tpls/mdspan/include/experimental/mdarray b/tpls/mdspan/include/experimental/mdarray
deleted file mode 100644
index fa710a59b6..0000000000
--- a/tpls/mdspan/include/experimental/mdarray
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#pragma once
-
-#include "mdspan"
-#include "__p1684_bits/mdarray.hpp"
-
diff --git a/tpls/mdspan/include/experimental/mdspan b/tpls/mdspan/include/experimental/mdspan
deleted file mode 100644
index ca6f6b8686..0000000000
--- a/tpls/mdspan/include/experimental/mdspan
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-//@HEADER
-// ************************************************************************
-//
-//                        Kokkos v. 2.0
-//              Copyright (2019) Sandia Corporation
-//
-// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
-// the U.S. Government retains certain rights in this software.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// 1. Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-// notice, this list of conditions and the following disclaimer in the
-// documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the Corporation nor the names of the
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
-// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
-//
-// ************************************************************************
-//@HEADER
-*/
-
-#pragma once
-
-#include "__p0009_bits/default_accessor.hpp"
-#include "__p0009_bits/full_extent_t.hpp"
-#include "__p0009_bits/mdspan.hpp"
-#include "__p0009_bits/dynamic_extent.hpp"
-#include "__p0009_bits/extents.hpp"
-#include "__p0009_bits/layout_stride.hpp"
-#include "__p0009_bits/layout_left.hpp"
-#include "__p0009_bits/layout_right.hpp"
-#include "__p0009_bits/macros.hpp"
-#include "__p0009_bits/static_array.hpp"
-#include "__p0009_bits/submdspan.hpp"
diff --git a/core/src/fwd/Kokkos_Fwd_HBWSpace.hpp b/tpls/mdspan/include/mdspan/mdarray.hpp
similarity index 64%
rename from core/src/fwd/Kokkos_Fwd_HBWSpace.hpp
rename to tpls/mdspan/include/mdspan/mdarray.hpp
index 21ba7fad01..fd8f61c52f 100644
--- a/core/src/fwd/Kokkos_Fwd_HBWSpace.hpp
+++ b/tpls/mdspan/include/mdspan/mdarray.hpp
@@ -14,16 +14,18 @@
 //
 //@HEADER
 
-#ifndef KOKKOS_HBWSPACE_FWD_HPP_
-#define KOKKOS_HBWSPACE_FWD_HPP_
+#ifndef MDARRAY_HPP_
+#define MDARRAY_HPP_
 
-#ifdef KOKKOS_ENABLE_HBWSPACE
-namespace Kokkos {
-
-namespace Experimental {
-class HBWSpace;  /// Memory space for hbw_malloc from memkind (e.g. for KNL
-                 /// processor)
-}  // namespace Experimental
-}  // namespace Kokkos
+#ifndef MDSPAN_IMPL_STANDARD_NAMESPACE
+  #define MDSPAN_IMPL_STANDARD_NAMESPACE Kokkos
 #endif
+
+#ifndef MDSPAN_IMPL_PROPOSED_NAMESPACE
+  #define MDSPAN_IMPL_PROPOSED_NAMESPACE Experimental
 #endif
+
+#include "mdspan.hpp"
+#include "../experimental/__p1684_bits/mdarray.hpp"
+
+#endif // MDARRAY_HPP_
diff --git a/tpls/mdspan/include/mdspan/mdspan.hpp b/tpls/mdspan/include/mdspan/mdspan.hpp
new file mode 100644
index 0000000000..4a0e354ffd
--- /dev/null
+++ b/tpls/mdspan/include/mdspan/mdspan.hpp
@@ -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
+
+#ifndef MDSPAN_HPP_
+#define MDSPAN_HPP_
+
+#ifndef MDSPAN_IMPL_STANDARD_NAMESPACE
+  #define MDSPAN_IMPL_STANDARD_NAMESPACE Kokkos
+#endif
+
+#ifndef MDSPAN_IMPL_PROPOSED_NAMESPACE
+  #define MDSPAN_IMPL_PROPOSED_NAMESPACE Experimental
+#endif
+
+#include "../experimental/__p0009_bits/default_accessor.hpp"
+#include "../experimental/__p0009_bits/full_extent_t.hpp"
+#include "../experimental/__p0009_bits/mdspan.hpp"
+#include "../experimental/__p0009_bits/dynamic_extent.hpp"
+#include "../experimental/__p0009_bits/extents.hpp"
+#include "../experimental/__p0009_bits/layout_stride.hpp"
+#include "../experimental/__p0009_bits/layout_left.hpp"
+#include "../experimental/__p0009_bits/layout_right.hpp"
+#include "../experimental/__p0009_bits/macros.hpp"
+#if MDSPAN_HAS_CXX_17
+#include "../experimental/__p2642_bits/layout_padded.hpp"
+#include "../experimental/__p2630_bits/submdspan.hpp"
+#endif
+#include "../experimental/__p2389_bits/dims.hpp"
+
+#endif // MDSPAN_HPP_