diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index c4b1ab9c43f75..66c2e269852d0 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -63,7 +63,7 @@ jobs:
           fetch-depth: 1
       - name: Get subprojects that have doc changes
         id: docs-changed-subprojects
-        uses: tj-actions/changed-files@v41
+        uses: tj-actions/changed-files@v42
         with:
           files_yaml: |
             llvm:
@@ -98,7 +98,7 @@ jobs:
         with:
           fetch-depth: 1
       - name: Setup Python env
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
           cache: 'pip'
diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml
index bdec66d3750d0..d0d4a130d6f78 100644
--- a/.github/workflows/gh_pages.yml
+++ b/.github/workflows/gh_pages.yml
@@ -13,10 +13,10 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     if: github.repository == 'intel/llvm'
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         path: repo
     - name: Install deps
diff --git a/.github/workflows/libclang-abi-tests.yml b/.github/workflows/libclang-abi-tests.yml
index ccfc1e5fb8a74..92499ba8df90d 100644
--- a/.github/workflows/libclang-abi-tests.yml
+++ b/.github/workflows/libclang-abi-tests.yml
@@ -131,7 +131,7 @@ jobs:
             sed -i 's/LLVM_[0-9]\+/LLVM_NOVERSION/' $lib-${{ matrix.ref }}.abi
           done
       - name: Upload ABI file
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.name }}
           path: '*${{ matrix.ref }}.abi'
@@ -144,12 +144,12 @@ jobs:
       - abi-dump
     steps:
       - name: Download baseline
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: build-baseline
           path: build-baseline
       - name: Download latest
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: build-latest
           path: build-latest
@@ -163,7 +163,7 @@ jobs:
           done
       - name: Upload ABI Comparison
         if: always()
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: compat-report-${{ github.sha }}
           path: compat_reports/
diff --git a/.github/workflows/libcxx-build-and-test.yaml b/.github/workflows/libcxx-build-and-test.yaml
index 0cab9b841e4ee..c984cf76435bb 100644
--- a/.github/workflows/libcxx-build-and-test.yaml
+++ b/.github/workflows/libcxx-build-and-test.yaml
@@ -75,7 +75,7 @@ jobs:
           CC: ${{ matrix.cc }}
           CXX: ${{ matrix.cxx }}
           ENABLE_CLANG_TIDY: ${{ matrix.clang_tidy }}
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: ${{ matrix.config }}-${{ matrix.cxx }}-results
@@ -124,7 +124,7 @@ jobs:
           CC: ${{ matrix.cc }}
           CXX: ${{ matrix.cxx }}
           ENABLE_CLANG_TIDY: ${{ matrix.clang_tidy }}
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()  # Upload artifacts even if the build or test suite fails
         with:
           name: ${{ matrix.config }}-results
@@ -189,7 +189,7 @@ jobs:
           CC: clang-18
           CXX: clang++-18
           ENABLE_CLANG_TIDY: "OFF"
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
           name: ${{ matrix.config }}-results
diff --git a/.github/workflows/llvm-bugs.yml b/.github/workflows/llvm-bugs.yml
index f592dd6ccd903..4797eea4e3d3d 100644
--- a/.github/workflows/llvm-bugs.yml
+++ b/.github/workflows/llvm-bugs.yml
@@ -14,13 +14,13 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository == 'llvm/llvm-project'
     steps:
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: 18
           check-latest: true
       - run: npm install mailgun.js form-data
       - name: Send notification
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         env:
           MAILGUN_API_KEY: ${{ secrets.LLVM_BUGS_KEY }}
         with:
diff --git a/.github/workflows/llvm-project-tests.yml b/.github/workflows/llvm-project-tests.yml
index a1404e1f1efa9..350bfe652f7a6 100644
--- a/.github/workflows/llvm-project-tests.yml
+++ b/.github/workflows/llvm-project-tests.yml
@@ -74,7 +74,7 @@ jobs:
       # lldb.  Using this setup-python action to make 3.10 the default
       # python fixes this.
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ inputs.python_version }}
       - name: Install Ninja
diff --git a/.github/workflows/llvm-tests.yml b/.github/workflows/llvm-tests.yml
index cc9855ce182b2..01046e7c0bd28 100644
--- a/.github/workflows/llvm-tests.yml
+++ b/.github/workflows/llvm-tests.yml
@@ -147,14 +147,14 @@ jobs:
           # Remove symbol versioning from dumps, so we can compare across major versions.
           sed -i 's/LLVM_${{ matrix.llvm_version_major }}/LLVM_NOVERSION/' ${{ matrix.ref }}.abi
       - name: Upload ABI file
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.name }}
           path: ${{ matrix.ref }}.abi
 
       - name: Upload symbol list file
         if: matrix.name == 'build-baseline'
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: symbol-list
           path: llvm.symbols
@@ -167,17 +167,17 @@ jobs:
       - abi-dump
     steps:
       - name: Download baseline
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: build-baseline
           path: build-baseline
       - name: Download latest
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: build-latest
           path: build-latest
       - name: Download symbol list
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: symbol-list
           path: symbol-list
@@ -196,7 +196,7 @@ jobs:
           abi-compliance-checker "$EXTRA_ARGS" -l libLLVM.so -old build-baseline/*.abi -new build-latest/*.abi || test "${{ needs.abi-dump-setup.outputs.ABI_HEADERS }}" = "llvm-c"
       - name: Upload ABI Comparison
         if: always()
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: compat-report-${{ github.sha }}
           path: compat_reports/
diff --git a/.github/workflows/new-prs.yml b/.github/workflows/new-prs.yml
index a52e4e9436263..ee6bd46beeebb 100644
--- a/.github/workflows/new-prs.yml
+++ b/.github/workflows/new-prs.yml
@@ -68,7 +68,7 @@ jobs:
       github.event.pull_request.draft == false &&
       github.event.pull_request.commits < 10
     steps:
-      - uses: actions/labeler@v4
+      - uses: actions/labeler@v5
         with:
           configuration-path: .github/new-prs-labeler.yml
           # workaround for https://github.com/actions/labeler/issues/112
diff --git a/.github/workflows/pr-code-format.yml b/.github/workflows/pr-code-format.yml
index 99e685ab7cd17..a28d6c9f49e0d 100644
--- a/.github/workflows/pr-code-format.yml
+++ b/.github/workflows/pr-code-format.yml
@@ -22,7 +22,7 @@ jobs:
 
       - name: Get changed files
         id: changed-files
-        uses: tj-actions/changed-files@v41
+        uses: tj-actions/changed-files@v42
         with:
           separator: ","
           skip_initial_fetch: true
@@ -52,7 +52,7 @@ jobs:
           clangformat: 17.0.1
 
       - name: Setup Python env
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
           cache: 'pip'
diff --git a/.github/workflows/release-documentation.yml b/.github/workflows/release-documentation.yml
index 64572906988ba..02ffbb142a940 100644
--- a/.github/workflows/release-documentation.yml
+++ b/.github/workflows/release-documentation.yml
@@ -37,7 +37,7 @@ jobs:
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
 
       - name: Setup Python env
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           cache: 'pip'
           cache-dependency-path: './llvm/docs/requirements.txt'
@@ -59,7 +59,7 @@ jobs:
           ./llvm/utils/release/build-docs.sh -release "${{ inputs.release-version }}" -no-doxygen
 
       - name: Create Release Notes Artifact
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: release-notes
           path: docs-build/html-export/
diff --git a/.github/workflows/release-doxygen.yml b/.github/workflows/release-doxygen.yml
index 5e322849a1d09..f39822bdff387 100644
--- a/.github/workflows/release-doxygen.yml
+++ b/.github/workflows/release-doxygen.yml
@@ -39,7 +39,7 @@ jobs:
         uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
 
       - name: Setup Python env
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           cache: 'pip'
           cache-dependency-path: './llvm/docs/requirements.txt'
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
index b8e8ab26c3ffa..3bfc5a062df12 100644
--- a/.github/workflows/scorecard.yml
+++ b/.github/workflows/scorecard.yml
@@ -31,12 +31,12 @@ jobs:
 
     steps:
       - name: "Checkout code"
-        uses: actions/checkout@93ea575cb5d8a053eaa0ac8fa3b40d7e05a33cc8 # v3.1.0
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           persist-credentials: false
 
       - name: "Run analysis"
-        uses: ossf/scorecard-action@e38b1902ae4f44df626f11ba0734b14fb91f8f86 # v2.1.2
+        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
         with:
           results_file: results.sarif
           results_format: sarif
@@ -49,7 +49,7 @@ jobs:
       # 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@3cea5372237819ed00197afe530f5a7ea3e805c8 # v3.1.0
+        uses: actions/upload-artifact@26f96dfa697d77e81fd5907df203aa23a56210a8 # v4.3.0
         with:
           name: SARIF file
           path: results.sarif
@@ -57,6 +57,6 @@ jobs:
 
       # Upload the results to GitHub's code scanning dashboard.
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@17573ee1cc1b9d061760f3a006fc4aac4f944fd5 # v2.2.4
+        uses: github/codeql-action/upload-sarif@0b21cf2492b6b02c465a3e5d7c473717ad7721ba # v3.23.1
         with:
           sarif_file: results.sarif
diff --git a/.github/workflows/sycl_containers.yaml b/.github/workflows/sycl_containers.yaml
index 1115d5ef43239..011d45ee9fee5 100644
--- a/.github/workflows/sycl_containers.yaml
+++ b/.github/workflows/sycl_containers.yaml
@@ -28,7 +28,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 2
       - name: Build and Push Container
@@ -47,7 +47,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 2
       - name: Build and Push Container
@@ -70,7 +70,7 @@ jobs:
     needs: base_image_ubuntu2204
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 2
       - name: Get dependencies configuration
@@ -108,7 +108,7 @@ jobs:
     needs: base_image_ubuntu2204
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 2
       - name: Get dependencies configuration
diff --git a/.github/workflows/sycl_detect_changes.yml b/.github/workflows/sycl_detect_changes.yml
index b3de9d128d13d..0948642344190 100644
--- a/.github/workflows/sycl_detect_changes.yml
+++ b/.github/workflows/sycl_detect_changes.yml
@@ -60,7 +60,7 @@ jobs:
 
       - name: Set output
         id: result
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         with:
           script: |
             console.log("Number of files changed:");
diff --git a/.github/workflows/sycl_linux_build.yml b/.github/workflows/sycl_linux_build.yml
index 826ab445458b9..6c64e0c56c409 100644
--- a/.github/workflows/sycl_linux_build.yml
+++ b/.github/workflows/sycl_linux_build.yml
@@ -137,7 +137,7 @@ jobs:
           echo "Unsupported extension"
           exit 1
         fi
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         sparse-checkout: |
           devops/actions
@@ -227,7 +227,7 @@ jobs:
       run: tar -I '${{ steps.artifact_info.outputs.COMPRESS }}' -cf ${{ steps.artifact_info.outputs.ARCHIVE_NAME }} -C $GITHUB_WORKSPACE/build/install .
     - name: Upload toolchain
       if: ${{ always() && !cancelled() && steps.build.conclusion == 'success' }}
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: sycl_linux_${{ inputs.build_artifact_suffix }}
         path: ${{ steps.artifact_info.outputs.ARCHIVE_NAME }}
diff --git a/.github/workflows/sycl_linux_precommit_aws.yml b/.github/workflows/sycl_linux_precommit_aws.yml
index 5bb0cb908bd07..3fce40107d90e 100644
--- a/.github/workflows/sycl_linux_precommit_aws.yml
+++ b/.github/workflows/sycl_linux_precommit_aws.yml
@@ -18,7 +18,7 @@ jobs:
   create-check:
     runs-on: [Linux, build]
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           script: |
             const sha = context.payload.workflow_run.head_sha
@@ -40,7 +40,7 @@ jobs:
     runs-on: ubuntu-20.04
     environment: aws
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           sparse-checkout: devops/actions/aws-ec2
       - run: npm install ./devops/actions/aws-ec2
@@ -75,7 +75,7 @@ jobs:
     if: always()
     runs-on: [Linux, build]
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@v7
         with:
           script: |
             const sha = context.payload.workflow_run.head_sha
@@ -99,7 +99,7 @@ jobs:
     runs-on: ubuntu-20.04
     environment: aws
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           sparse-checkout: devops/actions/aws-ec2
       - run: npm install ./devops/actions/aws-ec2
diff --git a/.github/workflows/sycl_linux_run_tests.yml b/.github/workflows/sycl_linux_run_tests.yml
index fb3e027f0f959..639c788c7fbd3 100644
--- a/.github/workflows/sycl_linux_run_tests.yml
+++ b/.github/workflows/sycl_linux_run_tests.yml
@@ -145,7 +145,7 @@ jobs:
       run: |
         sudo mount -t debugfs none /sys/kernel/debug
         sudo bash -c 'echo 1 > /sys/kernel/debug/dri/0/i915_wedged'
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         ref: ${{ inputs.ref }}
         sparse-checkout: |
@@ -197,7 +197,7 @@ jobs:
         rm env_before env_after
     - name: Download SYCL toolchain
       if: inputs.sycl_toolchain_artifact != '' && github.event_name != 'workflow_run'
-      uses: actions/download-artifact@v3
+      uses: actions/download-artifact@v4
       with:
         name: ${{ inputs.sycl_toolchain_artifact }}
     - name: Debug prints [workflow_run]
@@ -207,7 +207,7 @@ jobs:
         ls
     - name: Download SYCL toolchain [workflow_run]
       if: inputs.sycl_toolchain_artifact != '' && github.event_name == 'workflow_run'
-      uses: actions/github-script@v6
+      uses: actions/github-script@v7
       with:
         script: |
           const name = '${{ inputs.sycl_toolchain_artifact }}'
diff --git a/.github/workflows/sycl_macos_build_and_test.yml b/.github/workflows/sycl_macos_build_and_test.yml
index 9fd65ce7706ba..b79fbb3fa7ad5 100644
--- a/.github/workflows/sycl_macos_build_and_test.yml
+++ b/.github/workflows/sycl_macos_build_and_test.yml
@@ -29,11 +29,11 @@ jobs:
     steps:
     - name: Install dependencies
       run: brew install ccache ninja
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         ref: ${{ inputs.build_ref }}
         path: src
-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
       with:
         path: build_cache_${{ inputs.build_cache_suffix }}
         key: sycl-${{ runner.os }}-${{ inputs.build_cache_suffix }}-${{ github.sha }}
diff --git a/.github/workflows/sycl_nightly.yml b/.github/workflows/sycl_nightly.yml
index c2b8a3cf5a5d8..e802af89a29b4 100644
--- a/.github/workflows/sycl_nightly.yml
+++ b/.github/workflows/sycl_nightly.yml
@@ -101,10 +101,10 @@ jobs:
     needs: [ubuntu2204_build, build-win]
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
         name: sycl_linux_default
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
         name: sycl_windows_default
     - name: Compute tag
@@ -133,8 +133,8 @@ jobs:
     runs-on: [Linux, build]
     needs: ubuntu2204_build
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/download-artifact@v3
+    - uses: actions/checkout@v4
+    - uses: actions/download-artifact@v4
       with:
         name: sycl_linux_default
         path: devops/
diff --git a/.github/workflows/sycl_stale_issues.yml b/.github/workflows/sycl_stale_issues.yml
index 1e199d5d08faf..a362cf1faa803 100644
--- a/.github/workflows/sycl_stale_issues.yml
+++ b/.github/workflows/sycl_stale_issues.yml
@@ -8,7 +8,7 @@ jobs:
   close-issues:
     runs-on: ubuntu-20.04
     steps:
-    - uses: actions/stale@v7
+    - uses: actions/stale@v9
       with:
         stale-issue-message: 'This issue is stale because it has been open 180 days with no activity. Remove stale label or comment or this will be automatically closed in 30 days.'
         close-issue-message: 'This issue was closed because it has been stalled for 30 days with no activity. Please, re-open if the issue still exists.'
diff --git a/.github/workflows/sycl_update_gpu_driver.yml b/.github/workflows/sycl_update_gpu_driver.yml
index 65f93f6852877..9dcb66b7d95bd 100644
--- a/.github/workflows/sycl_update_gpu_driver.yml
+++ b/.github/workflows/sycl_update_gpu_driver.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-20.04
     if: github.repository == 'intel/llvm'
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Update dependencies file
       run: |
         version="$(python3 devops/scripts/update_drivers.py linux)"
diff --git a/.github/workflows/sycl_windows_build.yml b/.github/workflows/sycl_windows_build.yml
index 4c5d7d035c12a..64e62b7ef58fd 100644
--- a/.github/workflows/sycl_windows_build.yml
+++ b/.github/workflows/sycl_windows_build.yml
@@ -60,7 +60,7 @@ jobs:
     outputs:
       build_conclusion: ${{ steps.build.conclusion }}
     steps:
-    - uses: ilammy/msvc-dev-cmd@7315a94840631165970262a99c72cfb48a65d25d
+    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756
       with:
         arch: amd64
     - name: Set env
@@ -69,7 +69,7 @@ jobs:
         git config --global core.autocrlf false
         echo "C:\Program Files\Git\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
         echo "SCCACHE_DIR=D:\github\_work\cache\${{ inputs.build_cache_suffix }}" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         path: src
         ref: ${{ inputs.build_ref || github.sha }}
@@ -143,7 +143,7 @@ jobs:
         tar -czf ${{ inputs.artifact_archive_name }} -C install .
     - name: Upload toolchain
       if: ${{ always() && !cancelled() && steps.build.conclusion == 'success' }}
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: sycl_windows_default
         path: ${{ inputs.artifact_archive_name }}
diff --git a/.github/workflows/sycl_windows_run_tests.yml b/.github/workflows/sycl_windows_run_tests.yml
index 3c22e42db7384..f5a718c6cc9c1 100644
--- a/.github/workflows/sycl_windows_run_tests.yml
+++ b/.github/workflows/sycl_windows_run_tests.yml
@@ -39,7 +39,7 @@ jobs:
     environment: WindowsCILock
     env: ${{ fromJSON(inputs.env) }}
     steps:
-    - uses: ilammy/msvc-dev-cmd@7315a94840631165970262a99c72cfb48a65d25d
+    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756
       with:
         arch: amd64
     - name: Set env
@@ -48,7 +48,7 @@ jobs:
         git config --global core.autocrlf false
         echo "C:\Program Files\Git\usr\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
     # TODO: use cached_checkout
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         persist-credentials: false
         ref: ${{ inputs.ref || github.sha }}
@@ -56,7 +56,7 @@ jobs:
     - name: Register cleanup after job is finished
       uses: ./llvm/devops/actions/cleanup
     - name: Download compiler toolchain
-      uses: actions/download-artifact@v3
+      uses: actions/download-artifact@v4
       with:
         name: ${{ inputs.sycl_toolchain_artifact }}
     - name: Extract SYCL toolchain
diff --git a/.github/workflows/sync-main.yml b/.github/workflows/sync-main.yml
index b34257e389661..54d50acd9f80b 100644
--- a/.github/workflows/sync-main.yml
+++ b/.github/workflows/sync-main.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-20.04
     if: github.repository == 'intel/llvm'
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           # persist-credentials: false allows us to use our own credentials for
           # pushing to the repository.  Otherwise, the default github actions token
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index 3be77912ab75a..3ba83811d09d4 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -6027,6 +6027,18 @@ bool clang::CodeGen::noSystemDebugInfo(const Decl *D,
                                        const CodeGenModule &CGM) {
   // Declaration is in system file
   if (CGM.getContext().getSourceManager().isInSystemHeader(D->getLocation())) {
+    // Make an exception for typedefs in system header files.  Generate debug
+    // information for these decls because these are rare (thus they will not
+    // greatly increase debug size) and a user could rely on these typedefs
+    // during debugging. For example uid_t in in "sys/types.h" can be used in
+    // the gdb command:
+    //
+    //    print ruid == (uid_t)-1
+    //
+    // This occurs in GDB test gdb.reverse/getresuid-reverse.c
+    if (isa<TypedefDecl>(D))
+      return false;
+
     // -fno-system-debug was used.  Do not generate debug info.
     if (CGM.getCodeGenOpts().NoSystemDebug)
       return true;
diff --git a/clang/test/CodeGen/debug-info-system-typedef.c b/clang/test/CodeGen/debug-info-system-typedef.c
new file mode 100644
index 0000000000000..bbea7531e3f00
--- /dev/null
+++ b/clang/test/CodeGen/debug-info-system-typedef.c
@@ -0,0 +1,37 @@
+// Ensure that debug info for typedefs in system headers is still generated
+// even if -fno-system-debug is used.  This is justified because debug size 
+// savings is small, but debugging is commonly done with types that are
+// typedef-ed in system headers.  Thus, the increased debuggability
+// is worth the small extra cost.
+
+// RUN: %clang -fno-system-debug -emit-llvm -S -g %s -o %t.ll
+
+// RUN: FileCheck %s < %t.ll
+
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "int_fast8_t",
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "int_fast16_t",
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "int_fast32_t",
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "int_fast64_t",
+
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "uint_fast8_t",
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "uint_fast16_t",
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "uint_fast32_t",
+// CHECK-DAG: !DIDerivedType(tag: DW_TAG_typedef, name: "uint_fast64_t",
+  
+#include <stdint.h>
+
+int_fast8_t   f8;
+int_fast16_t  f16;
+int_fast32_t  f32;
+int_fast64_t  f64;
+
+uint_fast8_t   uf8;
+uint_fast16_t  uf16;
+uint_fast32_t  uf32;
+uint_fast64_t  uf64;
+
+int
+main (void)
+{
+  return 0;
+}
diff --git a/clang/test/Driver/sycl-offload-amdgcn.cpp b/clang/test/Driver/sycl-offload-amdgcn.cpp
index ececd41c3b680..407dfd02c9205 100644
--- a/clang/test/Driver/sycl-offload-amdgcn.cpp
+++ b/clang/test/Driver/sycl-offload-amdgcn.cpp
@@ -1,6 +1,7 @@
 /// Tests specific to `-fsycl-targets=amdgcn-amd-amdhsa`
 
 // UNSUPPORTED: system-windows
+// REQUIRES: amdgpu-registered-target
 
 // Check that the offload arch is required
 // RUN: not %clangxx -### -std=c++11 -target x86_64-unknown-linux-gnu -fsycl \
diff --git a/clang/test/Driver/sycl-triple-dae-flags.cpp b/clang/test/Driver/sycl-triple-dae-flags.cpp
index 1fe662a7f980d..a0eb8c490dfc8 100644
--- a/clang/test/Driver/sycl-triple-dae-flags.cpp
+++ b/clang/test/Driver/sycl-triple-dae-flags.cpp
@@ -1,3 +1,5 @@
+// REQUIRES: nvptx-registered-target, amdgpu-registered-target
+
 // RUN: %clangxx -### -fsycl -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=gfx906 -fsycl-dead-args-optimization -nogpulib %s 2> %t.rocm.out
 // RUN: FileCheck %s --input-file %t.rocm.out
 // CHECK-NOT: -fenable-sycl-dae
diff --git a/clang/test/Driver/sycl-unsupported-arch.cpp b/clang/test/Driver/sycl-unsupported-arch.cpp
index e5fd47f339fd5..7d6d1bb1dac58 100644
--- a/clang/test/Driver/sycl-unsupported-arch.cpp
+++ b/clang/test/Driver/sycl-unsupported-arch.cpp
@@ -1,3 +1,5 @@
+// REQUIRES: amdgpu-registered-target
+
 /// Verify that compiler passes are correctly determined
 // RUN: %clangxx -fsycl -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend=amdgcn-amd-amdhsa --offload-arch=gfx600 -nogpulib -c -ccc-print-phases %s 2>&1 | FileCheck %s --check-prefix=CHECK-PHASES
 // CHECK-PHASES: offload, "device-sycl (amdgcn-amd-amdhsa:gfx600)"
diff --git a/libclc/ptx-nvidiacl/libspirv/atomic/atomic_cmpxchg.cl b/libclc/ptx-nvidiacl/libspirv/atomic/atomic_cmpxchg.cl
index 078eb86cdc294..fceeda0f60361 100644
--- a/libclc/ptx-nvidiacl/libspirv/atomic/atomic_cmpxchg.cl
+++ b/libclc/ptx-nvidiacl/libspirv/atomic/atomic_cmpxchg.cl
@@ -86,7 +86,7 @@ SemanticsMask4FlagES##SUBSTITUTION2##_##TYPE_MANGLED##TYPE_MANGLED(            \
       enum MemorySemanticsMask semantics2, TYPE cmp, TYPE value) {             \
     /* Semantics mask may include memory order, storage class and other info   \
 Memory order is stored in the lowest 5 bits */                                 \
-    unsigned int order = (semantics1 | semantics2) & 0x1F;                     \
+    unsigned int order = semantics1 & 0x1F;                                    \
     switch (order) {                                                           \
     case None:                                                                 \
       __CLC_NVVM_ATOMIC_CAS_IMPL_ORDER(TYPE, TYPE_NV, TYPE_MANGLED_NV, OP,     \
diff --git a/llvm/docs/requirements-hashed.txt b/llvm/docs/requirements-hashed.txt
index 19d1cfdfc572d..1f31ecb3b60b5 100644
--- a/llvm/docs/requirements-hashed.txt
+++ b/llvm/docs/requirements-hashed.txt
@@ -4,17 +4,17 @@
 #
 #    pip-compile --generate-hashes --output-file=requirements-hashed.txt requirements.txt
 #
-alabaster==0.7.13 \
-    --hash=sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3 \
-    --hash=sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2
+alabaster==0.7.16 \
+    --hash=sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65 \
+    --hash=sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92
     # via sphinx
 babel==2.14.0 \
     --hash=sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363 \
     --hash=sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287
     # via sphinx
-beautifulsoup4==4.12.2 \
-    --hash=sha256:492bbc69dca35d12daac71c4db1bfff0c876c00ef4a2ffacce226d4638eb72da \
-    --hash=sha256:bd2520ca0d9d7d12694a53d44ac482d181b4ec1888909b035a3dbf40d0f57d4a
+beautifulsoup4==4.12.3 \
+    --hash=sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051 \
+    --hash=sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed
     # via furo
 certifi==2023.11.17 \
     --hash=sha256:9b469f3a900bf28dc19b8cfbf8019bf47f7fdd1a65a1d4ffb98fc14166beb4d1 \
@@ -124,9 +124,9 @@ docutils==0.20.1 \
     #   myst-parser
     #   recommonmark
     #   sphinx
-furo==2023.8.19 \
-    --hash=sha256:12f99f87a1873b6746228cfde18f77244e6c1ffb85d7fed95e638aae70d80590 \
-    --hash=sha256:e671ee638ab3f1b472f4033b0167f502ab407830e0db0f843b1c1028119c9cd1
+furo==2023.9.10 \
+    --hash=sha256:513092538537dc5c596691da06e3c370714ec99bc438680edc1debffb73e5bfc \
+    --hash=sha256:5707530a476d2a63b8cad83b4f961f3739a69f4b058bcf38a03a39fa537195b2
     # via -r requirements.txt
 idna==3.6 \
     --hash=sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca \
@@ -136,15 +136,15 @@ imagesize==1.4.1 \
     --hash=sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b \
     --hash=sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a
     # via sphinx
-jinja2==3.1.2 \
-    --hash=sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852 \
-    --hash=sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61
+jinja2==3.1.3 \
+    --hash=sha256:7d6d50dd97d52cbc355597bd845fabfbac3f551e1f99619e39a35ce8c370b5fa \
+    --hash=sha256:ac8bd6544d4bb2c9792bf3a159e80bba8fda7f07e81bc3aed565432d5925ba90
     # via
     #   myst-parser
     #   sphinx
-markdown==3.5.1 \
-    --hash=sha256:5874b47d4ee3f0b14d764324d2c94c03ea66bee56f2d929da9f2508d65e722dc \
-    --hash=sha256:b65d7beb248dc22f2e8a31fb706d93798093c308dc1aba295aedeb9d41a813bd
+markdown==3.5.2 \
+    --hash=sha256:d43323865d89fc0cb9b20c75fc8ad313af307cc087e84b657d9eec768eddeadd \
+    --hash=sha256:e1ac7b3dc550ee80e602e71c1d168002f062e49f1b11e26a36264dafd4df2ef8
     # via sphinx-markdown-tables
 markdown-it-py==3.0.0 \
     --hash=sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1 \
@@ -152,67 +152,67 @@ markdown-it-py==3.0.0 \
     # via
     #   mdit-py-plugins
     #   myst-parser
-markupsafe==2.1.3 \
-    --hash=sha256:05fb21170423db021895e1ea1e1f3ab3adb85d1c2333cbc2310f2a26bc77272e \
-    --hash=sha256:0a4e4a1aff6c7ac4cd55792abf96c915634c2b97e3cc1c7129578aa68ebd754e \
-    --hash=sha256:10bbfe99883db80bdbaff2dcf681dfc6533a614f700da1287707e8a5d78a8431 \
-    --hash=sha256:134da1eca9ec0ae528110ccc9e48041e0828d79f24121a1a146161103c76e686 \
-    --hash=sha256:14ff806850827afd6b07a5f32bd917fb7f45b046ba40c57abdb636674a8b559c \
-    --hash=sha256:1577735524cdad32f9f694208aa75e422adba74f1baee7551620e43a3141f559 \
-    --hash=sha256:1b40069d487e7edb2676d3fbdb2b0829ffa2cd63a2ec26c4938b2d34391b4ecc \
-    --hash=sha256:1b8dd8c3fd14349433c79fa8abeb573a55fc0fdd769133baac1f5e07abf54aeb \
-    --hash=sha256:1f67c7038d560d92149c060157d623c542173016c4babc0c1913cca0564b9939 \
-    --hash=sha256:282c2cb35b5b673bbcadb33a585408104df04f14b2d9b01d4c345a3b92861c2c \
-    --hash=sha256:2c1b19b3aaacc6e57b7e25710ff571c24d6c3613a45e905b1fde04d691b98ee0 \
-    --hash=sha256:2ef12179d3a291be237280175b542c07a36e7f60718296278d8593d21ca937d4 \
-    --hash=sha256:338ae27d6b8745585f87218a3f23f1512dbf52c26c28e322dbe54bcede54ccb9 \
-    --hash=sha256:3c0fae6c3be832a0a0473ac912810b2877c8cb9d76ca48de1ed31e1c68386575 \
-    --hash=sha256:3fd4abcb888d15a94f32b75d8fd18ee162ca0c064f35b11134be77050296d6ba \
-    --hash=sha256:42de32b22b6b804f42c5d98be4f7e5e977ecdd9ee9b660fda1a3edf03b11792d \
-    --hash=sha256:47d4f1c5f80fc62fdd7777d0d40a2e9dda0a05883ab11374334f6c4de38adffd \
-    --hash=sha256:504b320cd4b7eff6f968eddf81127112db685e81f7e36e75f9f84f0df46041c3 \
-    --hash=sha256:525808b8019e36eb524b8c68acdd63a37e75714eac50e988180b169d64480a00 \
-    --hash=sha256:56d9f2ecac662ca1611d183feb03a3fa4406469dafe241673d521dd5ae92a155 \
-    --hash=sha256:5bbe06f8eeafd38e5d0a4894ffec89378b6c6a625ff57e3028921f8ff59318ac \
-    --hash=sha256:65c1a9bcdadc6c28eecee2c119465aebff8f7a584dd719facdd9e825ec61ab52 \
-    --hash=sha256:68e78619a61ecf91e76aa3e6e8e33fc4894a2bebe93410754bd28fce0a8a4f9f \
-    --hash=sha256:69c0f17e9f5a7afdf2cc9fb2d1ce6aabdb3bafb7f38017c0b77862bcec2bbad8 \
-    --hash=sha256:6b2b56950d93e41f33b4223ead100ea0fe11f8e6ee5f641eb753ce4b77a7042b \
-    --hash=sha256:715d3562f79d540f251b99ebd6d8baa547118974341db04f5ad06d5ea3eb8007 \
-    --hash=sha256:787003c0ddb00500e49a10f2844fac87aa6ce977b90b0feaaf9de23c22508b24 \
-    --hash=sha256:7ef3cb2ebbf91e330e3bb937efada0edd9003683db6b57bb108c4001f37a02ea \
-    --hash=sha256:8023faf4e01efadfa183e863fefde0046de576c6f14659e8782065bcece22198 \
-    --hash=sha256:8758846a7e80910096950b67071243da3e5a20ed2546e6392603c096778d48e0 \
-    --hash=sha256:8afafd99945ead6e075b973fefa56379c5b5c53fd8937dad92c662da5d8fd5ee \
-    --hash=sha256:8c41976a29d078bb235fea9b2ecd3da465df42a562910f9022f1a03107bd02be \
-    --hash=sha256:8e254ae696c88d98da6555f5ace2279cf7cd5b3f52be2b5cf97feafe883b58d2 \
-    --hash=sha256:8f9293864fe09b8149f0cc42ce56e3f0e54de883a9de90cd427f191c346eb2e1 \
-    --hash=sha256:9402b03f1a1b4dc4c19845e5c749e3ab82d5078d16a2a4c2cd2df62d57bb0707 \
-    --hash=sha256:962f82a3086483f5e5f64dbad880d31038b698494799b097bc59c2edf392fce6 \
-    --hash=sha256:9aad3c1755095ce347e26488214ef77e0485a3c34a50c5a5e2471dff60b9dd9c \
-    --hash=sha256:9dcdfd0eaf283af041973bff14a2e143b8bd64e069f4c383416ecd79a81aab58 \
-    --hash=sha256:aa57bd9cf8ae831a362185ee444e15a93ecb2e344c8e52e4d721ea3ab6ef1823 \
-    --hash=sha256:aa7bd130efab1c280bed0f45501b7c8795f9fdbeb02e965371bbef3523627779 \
-    --hash=sha256:ab4a0df41e7c16a1392727727e7998a467472d0ad65f3ad5e6e765015df08636 \
-    --hash=sha256:ad9e82fb8f09ade1c3e1b996a6337afac2b8b9e365f926f5a61aacc71adc5b3c \
-    --hash=sha256:af598ed32d6ae86f1b747b82783958b1a4ab8f617b06fe68795c7f026abbdcad \
-    --hash=sha256:b076b6226fb84157e3f7c971a47ff3a679d837cf338547532ab866c57930dbee \
-    --hash=sha256:b7ff0f54cb4ff66dd38bebd335a38e2c22c41a8ee45aa608efc890ac3e3931bc \
-    --hash=sha256:bfce63a9e7834b12b87c64d6b155fdd9b3b96191b6bd334bf37db7ff1fe457f2 \
-    --hash=sha256:c011a4149cfbcf9f03994ec2edffcb8b1dc2d2aede7ca243746df97a5d41ce48 \
-    --hash=sha256:c9c804664ebe8f83a211cace637506669e7890fec1b4195b505c214e50dd4eb7 \
-    --hash=sha256:ca379055a47383d02a5400cb0d110cef0a776fc644cda797db0c5696cfd7e18e \
-    --hash=sha256:cb0932dc158471523c9637e807d9bfb93e06a95cbf010f1a38b98623b929ef2b \
-    --hash=sha256:cd0f502fe016460680cd20aaa5a76d241d6f35a1c3350c474bac1273803893fa \
-    --hash=sha256:ceb01949af7121f9fc39f7d27f91be8546f3fb112c608bc4029aef0bab86a2a5 \
-    --hash=sha256:d080e0a5eb2529460b30190fcfcc4199bd7f827663f858a226a81bc27beaa97e \
-    --hash=sha256:dd15ff04ffd7e05ffcb7fe79f1b98041b8ea30ae9234aed2a9168b5797c3effb \
-    --hash=sha256:df0be2b576a7abbf737b1575f048c23fb1d769f267ec4358296f31c2479db8f9 \
-    --hash=sha256:e09031c87a1e51556fdcb46e5bd4f59dfb743061cf93c4d6831bf894f125eb57 \
-    --hash=sha256:e4dd52d80b8c83fdce44e12478ad2e85c64ea965e75d66dbeafb0a3e77308fcc \
-    --hash=sha256:f698de3fd0c4e6972b92290a45bd9b1536bffe8c6759c62471efaa8acb4c37bc \
-    --hash=sha256:fec21693218efe39aa7f8599346e90c705afa52c5b31ae019b2e57e8f6542bb2 \
-    --hash=sha256:ffcc3f7c66b5f5b7931a5aa68fc9cecc51e685ef90282f4a82f0f5e9b704ad11
+markupsafe==2.1.4 \
+    --hash=sha256:0042d6a9880b38e1dd9ff83146cc3c9c18a059b9360ceae207805567aacccc69 \
+    --hash=sha256:0c26f67b3fe27302d3a412b85ef696792c4a2386293c53ba683a89562f9399b0 \
+    --hash=sha256:0fbad3d346df8f9d72622ac71b69565e621ada2ce6572f37c2eae8dacd60385d \
+    --hash=sha256:15866d7f2dc60cfdde12ebb4e75e41be862348b4728300c36cdf405e258415ec \
+    --hash=sha256:1c98c33ffe20e9a489145d97070a435ea0679fddaabcafe19982fe9c971987d5 \
+    --hash=sha256:21e7af8091007bf4bebf4521184f4880a6acab8df0df52ef9e513d8e5db23411 \
+    --hash=sha256:23984d1bdae01bee794267424af55eef4dfc038dc5d1272860669b2aa025c9e3 \
+    --hash=sha256:31f57d64c336b8ccb1966d156932f3daa4fee74176b0fdc48ef580be774aae74 \
+    --hash=sha256:3583a3a3ab7958e354dc1d25be74aee6228938312ee875a22330c4dc2e41beb0 \
+    --hash=sha256:36d7626a8cca4d34216875aee5a1d3d654bb3dac201c1c003d182283e3205949 \
+    --hash=sha256:396549cea79e8ca4ba65525470d534e8a41070e6b3500ce2414921099cb73e8d \
+    --hash=sha256:3a66c36a3864df95e4f62f9167c734b3b1192cb0851b43d7cc08040c074c6279 \
+    --hash=sha256:3aae9af4cac263007fd6309c64c6ab4506dd2b79382d9d19a1994f9240b8db4f \
+    --hash=sha256:3ab3a886a237f6e9c9f4f7d272067e712cdb4efa774bef494dccad08f39d8ae6 \
+    --hash=sha256:47bb5f0142b8b64ed1399b6b60f700a580335c8e1c57f2f15587bd072012decc \
+    --hash=sha256:49a3b78a5af63ec10d8604180380c13dcd870aba7928c1fe04e881d5c792dc4e \
+    --hash=sha256:4df98d4a9cd6a88d6a585852f56f2155c9cdb6aec78361a19f938810aa020954 \
+    --hash=sha256:5045e892cfdaecc5b4c01822f353cf2c8feb88a6ec1c0adef2a2e705eef0f656 \
+    --hash=sha256:5244324676254697fe5c181fc762284e2c5fceeb1c4e3e7f6aca2b6f107e60dc \
+    --hash=sha256:54635102ba3cf5da26eb6f96c4b8c53af8a9c0d97b64bdcb592596a6255d8518 \
+    --hash=sha256:54a7e1380dfece8847c71bf7e33da5d084e9b889c75eca19100ef98027bd9f56 \
+    --hash=sha256:55d03fea4c4e9fd0ad75dc2e7e2b6757b80c152c032ea1d1de487461d8140efc \
+    --hash=sha256:698e84142f3f884114ea8cf83e7a67ca8f4ace8454e78fe960646c6c91c63bfa \
+    --hash=sha256:6aa5e2e7fc9bc042ae82d8b79d795b9a62bd8f15ba1e7594e3db243f158b5565 \
+    --hash=sha256:7653fa39578957bc42e5ebc15cf4361d9e0ee4b702d7d5ec96cdac860953c5b4 \
+    --hash=sha256:765f036a3d00395a326df2835d8f86b637dbaf9832f90f5d196c3b8a7a5080cb \
+    --hash=sha256:78bc995e004681246e85e28e068111a4c3f35f34e6c62da1471e844ee1446250 \
+    --hash=sha256:7a07f40ef8f0fbc5ef1000d0c78771f4d5ca03b4953fc162749772916b298fc4 \
+    --hash=sha256:8b570a1537367b52396e53325769608f2a687ec9a4363647af1cded8928af959 \
+    --hash=sha256:987d13fe1d23e12a66ca2073b8d2e2a75cec2ecb8eab43ff5624ba0ad42764bc \
+    --hash=sha256:9896fca4a8eb246defc8b2a7ac77ef7553b638e04fbf170bff78a40fa8a91474 \
+    --hash=sha256:9e9e3c4020aa2dc62d5dd6743a69e399ce3de58320522948af6140ac959ab863 \
+    --hash=sha256:a0b838c37ba596fcbfca71651a104a611543077156cb0a26fe0c475e1f152ee8 \
+    --hash=sha256:a4d176cfdfde84f732c4a53109b293d05883e952bbba68b857ae446fa3119b4f \
+    --hash=sha256:a76055d5cb1c23485d7ddae533229039b850db711c554a12ea64a0fd8a0129e2 \
+    --hash=sha256:a76cd37d229fc385738bd1ce4cba2a121cf26b53864c1772694ad0ad348e509e \
+    --hash=sha256:a7cc49ef48a3c7a0005a949f3c04f8baa5409d3f663a1b36f0eba9bfe2a0396e \
+    --hash=sha256:abf5ebbec056817057bfafc0445916bb688a255a5146f900445d081db08cbabb \
+    --hash=sha256:b0fe73bac2fed83839dbdbe6da84ae2a31c11cfc1c777a40dbd8ac8a6ed1560f \
+    --hash=sha256:b6f14a9cd50c3cb100eb94b3273131c80d102e19bb20253ac7bd7336118a673a \
+    --hash=sha256:b83041cda633871572f0d3c41dddd5582ad7d22f65a72eacd8d3d6d00291df26 \
+    --hash=sha256:b835aba863195269ea358cecc21b400276747cc977492319fd7682b8cd2c253d \
+    --hash=sha256:bf1196dcc239e608605b716e7b166eb5faf4bc192f8a44b81e85251e62584bd2 \
+    --hash=sha256:c669391319973e49a7c6230c218a1e3044710bc1ce4c8e6eb71f7e6d43a2c131 \
+    --hash=sha256:c7556bafeaa0a50e2fe7dc86e0382dea349ebcad8f010d5a7dc6ba568eaaa789 \
+    --hash=sha256:c8f253a84dbd2c63c19590fa86a032ef3d8cc18923b8049d91bcdeeb2581fbf6 \
+    --hash=sha256:d18b66fe626ac412d96c2ab536306c736c66cf2a31c243a45025156cc190dc8a \
+    --hash=sha256:d5291d98cd3ad9a562883468c690a2a238c4a6388ab3bd155b0c75dd55ece858 \
+    --hash=sha256:d5c31fe855c77cad679b302aabc42d724ed87c043b1432d457f4976add1c2c3e \
+    --hash=sha256:d6e427c7378c7f1b2bef6a344c925b8b63623d3321c09a237b7cc0e77dd98ceb \
+    --hash=sha256:dac1ebf6983148b45b5fa48593950f90ed6d1d26300604f321c74a9ca1609f8e \
+    --hash=sha256:de8153a7aae3835484ac168a9a9bdaa0c5eee4e0bc595503c95d53b942879c84 \
+    --hash=sha256:e1a0d1924a5013d4f294087e00024ad25668234569289650929ab871231668e7 \
+    --hash=sha256:e7902211afd0af05fbadcc9a312e4cf10f27b779cf1323e78d52377ae4b72bea \
+    --hash=sha256:e888ff76ceb39601c59e219f281466c6d7e66bd375b4ec1ce83bcdc68306796b \
+    --hash=sha256:f06e5a9e99b7df44640767842f414ed5d7bedaaa78cd817ce04bbd6fd86e2dd6 \
+    --hash=sha256:f6be2d708a9d0e9b0054856f07ac7070fbe1754be40ca8525d5adccdbda8f475 \
+    --hash=sha256:f9917691f410a2e0897d1ef99619fd3f7dd503647c8ff2475bf90c3cf222ad74 \
+    --hash=sha256:fc1a75aa8f11b87910ffd98de62b29d6520b6d6e8a3de69a70ca34dea85d2a8a \
+    --hash=sha256:fe8512ed897d5daf089e5bd010c3dc03bb1bdae00b35588c49b98268d4a01e00
     # via jinja2
 mdit-py-plugins==0.4.0 \
     --hash=sha256:b51b3bb70691f57f974e257e367107857a93b36f322a9e6d44ca5bf28ec2def9 \
@@ -304,9 +304,9 @@ soupsieve==2.5 \
     --hash=sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690 \
     --hash=sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7
     # via beautifulsoup4
-sphinx==7.1.2 \
-    --hash=sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f \
-    --hash=sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe
+sphinx==7.2.6 \
+    --hash=sha256:1e09160a40b956dc623c910118fa636da93bd3ca0b9876a7b3df90f07d691560 \
+    --hash=sha256:9a5160e1ea90688d5963ba09a2dcd8bdd526620edbb65c328728f1b2228d5ab5
     # via
     #   -r requirements.txt
     #   furo
@@ -334,31 +334,31 @@ sphinx-markdown-tables==0.0.17 \
     --hash=sha256:2bd0c30779653e4dd120300cbd9ca412c480738cc2241f6dea477a883f299e04 \
     --hash=sha256:6bc6d3d400eaccfeebd288446bc08dd83083367c58b85d40fe6c12d77ef592f1
     # via -r requirements.txt
-sphinxcontrib-applehelp==1.0.4 \
-    --hash=sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228 \
-    --hash=sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e
+sphinxcontrib-applehelp==1.0.8 \
+    --hash=sha256:c40a4f96f3776c4393d933412053962fac2b84f4c99a7982ba42e09576a70619 \
+    --hash=sha256:cb61eb0ec1b61f349e5cc36b2028e9e7ca765be05e49641c97241274753067b4
     # via
     #   -r requirements.txt
     #   sphinx
-sphinxcontrib-devhelp==1.0.5 \
-    --hash=sha256:63b41e0d38207ca40ebbeabcf4d8e51f76c03e78cd61abe118cf4435c73d4212 \
-    --hash=sha256:fe8009aed765188f08fcaadbb3ea0d90ce8ae2d76710b7e29ea7d047177dae2f
+sphinxcontrib-devhelp==1.0.6 \
+    --hash=sha256:6485d09629944511c893fa11355bda18b742b83a2b181f9a009f7e500595c90f \
+    --hash=sha256:9893fd3f90506bc4b97bdb977ceb8fbd823989f4316b28c3841ec128544372d3
     # via sphinx
-sphinxcontrib-htmlhelp==2.0.4 \
-    --hash=sha256:6c26a118a05b76000738429b724a0568dbde5b72391a688577da08f11891092a \
-    --hash=sha256:8001661c077a73c29beaf4a79968d0726103c5605e27db92b9ebed8bab1359e9
+sphinxcontrib-htmlhelp==2.0.5 \
+    --hash=sha256:0dc87637d5de53dd5eec3a6a01753b1ccf99494bd756aafecd74b4fa9e729015 \
+    --hash=sha256:393f04f112b4d2f53d93448d4bce35842f62b307ccdc549ec1585e950bc35e04
     # via sphinx
 sphinxcontrib-jsmath==1.0.1 \
     --hash=sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178 \
     --hash=sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8
     # via sphinx
-sphinxcontrib-qthelp==1.0.6 \
-    --hash=sha256:62b9d1a186ab7f5ee3356d906f648cacb7a6bdb94d201ee7adf26db55092982d \
-    --hash=sha256:bf76886ee7470b934e363da7a954ea2825650013d367728588732c7350f49ea4
+sphinxcontrib-qthelp==1.0.7 \
+    --hash=sha256:053dedc38823a80a7209a80860b16b722e9e0209e32fea98c90e4e6624588ed6 \
+    --hash=sha256:e2ae3b5c492d58fcbd73281fbd27e34b8393ec34a073c792642cd8e529288182
     # via sphinx
-sphinxcontrib-serializinghtml==1.1.9 \
-    --hash=sha256:0c64ff898339e1fac29abd2bf5f11078f3ec413cfe9c046d3120d7ca65530b54 \
-    --hash=sha256:9b36e503703ff04f20e9675771df105e58aa029cfcbc23b8ed716019b7416ae1
+sphinxcontrib-serializinghtml==1.1.10 \
+    --hash=sha256:326369b8df80a7d2d8d7f99aa5ac577f51ea51556ed974e7716cfd4fca3f6cb7 \
+    --hash=sha256:93f3f5dc458b91b192fe10c397e324f262cf163d79f3282c158e8436a2c4511f
     # via sphinx
 urllib3==2.1.0 \
     --hash=sha256:55901e917a5896a349ff771be919f8bd99aff50b79fe58fec595eb37bbc56bb3 \
diff --git a/llvm/docs/requirements.txt b/llvm/docs/requirements.txt
index d66569c1b3e79..697ce2e3adb6d 100644
--- a/llvm/docs/requirements.txt
+++ b/llvm/docs/requirements.txt
@@ -1,9 +1,9 @@
-sphinx==7.1.2
+sphinx==7.2.6
 docutils==0.20.1
 sphinx-markdown-tables==0.0.17
 recommonmark==0.7.1
 sphinx-automodapi==0.16.0
 sphinx-bootstrap-theme==0.8.1
-sphinxcontrib-applehelp==1.0.4
-furo==2023.8.19
+sphinxcontrib-applehelp==1.0.8
+furo==2023.9.10
 myst-parser==2.0.0
diff --git a/llvm/lib/SYCLLowerIR/CompileTimePropertiesPass.cpp b/llvm/lib/SYCLLowerIR/CompileTimePropertiesPass.cpp
index da14bc2772c61..32a476a8ac893 100644
--- a/llvm/lib/SYCLLowerIR/CompileTimePropertiesPass.cpp
+++ b/llvm/lib/SYCLLowerIR/CompileTimePropertiesPass.cpp
@@ -444,8 +444,10 @@ attributeToExecModeMetadata(const Attribute &Attr, Function &F) {
     // TODO: Remove SYCL_REGISTER_ALLOC_MODE_ATTR support in next ABI break.
     uint32_t PropVal = getAttributeAsInteger<uint32_t>(Attr);
     if (AttrKindStr == SYCL_GRF_SIZE_ATTR) {
-      assert((PropVal == 0 || PropVal == 128 || PropVal == 256) &&
-             "Unsupported GRF Size");
+      // The RegisterAllocMode metadata supports only 0, 128, and 256 for
+      // PropVal.
+      if (PropVal != 0 && PropVal != 128 && PropVal != 256)
+        return std::nullopt;
       // Map sycl-grf-size values to RegisterAllocMode values used in SPIR-V.
       static constexpr int SMALL_GRF_REGALLOCMODE_VAL = 1;
       static constexpr int LARGE_GRF_REGALLOCMODE_VAL = 2;
diff --git a/llvm/test/SYCLLowerIR/CompileTimePropertiesPass/sycl-grf-mode.ll b/llvm/test/SYCLLowerIR/CompileTimePropertiesPass/sycl-grf-mode.ll
new file mode 100644
index 0000000000000..a5d491bb54db0
--- /dev/null
+++ b/llvm/test/SYCLLowerIR/CompileTimePropertiesPass/sycl-grf-mode.ll
@@ -0,0 +1,10 @@
+; Check we don't assert for different GRF values and don't add the RegisterAllocMode metadata
+; RUN: opt -passes=compile-time-properties %s -S | FileCheck %s --implicit-check-not=RegisterAllocMode
+
+; CHECK: spir_kernel void @foo()
+define weak_odr dso_local spir_kernel void @foo() #0 {
+entry:
+  ret void
+}
+
+attributes #0 = { convergent mustprogress norecurse nounwind "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "sycl-grf-size"="16384" "sycl-module-id"="main.cpp" "sycl-optlevel"="2" "uniform-work-group-size"="true" }
diff --git a/sycl-fusion/common/include/DynArray.h b/sycl-fusion/common/include/DynArray.h
index d69e0cea26eae..818a2b5e10c4f 100644
--- a/sycl-fusion/common/include/DynArray.h
+++ b/sycl-fusion/common/include/DynArray.h
@@ -97,7 +97,7 @@ template <typename T> class DynArray {
 /// String-like class that owns its character storage.
 class DynString {
 public:
-  explicit DynString(const char *Str) : Chars{std::strlen(Str) + 1} {
+  explicit DynString(const char *Str = "") : Chars{std::strlen(Str) + 1} {
     std::copy(Str, Str + Chars.size(), Chars.begin());
   }
 
diff --git a/sycl-fusion/common/include/Kernel.h b/sycl-fusion/common/include/Kernel.h
index 9db4138e28def..c889552bf6e07 100644
--- a/sycl-fusion/common/include/Kernel.h
+++ b/sycl-fusion/common/include/Kernel.h
@@ -12,12 +12,11 @@
 #include "DynArray.h"
 
 #include <algorithm>
-#include <array>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
-#include <string>
-#include <vector>
+#include <functional>
+#include <type_traits>
 
 namespace jit_compiler {
 
@@ -131,7 +130,7 @@ using ArgUsageUT = std::underlying_type_t<ArgUsage>;
 ///
 /// Describe the list of arguments by their kind and usage.
 struct SYCLArgumentDescriptor {
-  explicit SYCLArgumentDescriptor(size_t NumArgs)
+  explicit SYCLArgumentDescriptor(size_t NumArgs = 0)
       : Kinds(NumArgs), UsageMask(NumArgs){};
 
   DynArray<ParameterKind> Kinds;
@@ -339,6 +338,8 @@ struct SYCLKernelInfo {
 
   SYCLKernelBinaryInfo BinaryInfo;
 
+  SYCLKernelInfo() = default;
+
   SYCLKernelInfo(const char *KernelName, const SYCLArgumentDescriptor &ArgDesc,
                  const NDRange &NDR, const SYCLKernelBinaryInfo &BinInfo)
       : Name{KernelName}, Args{ArgDesc}, Attributes{}, NDR{NDR},
@@ -348,33 +349,6 @@ struct SYCLKernelInfo {
       : Name{KernelName}, Args{NumArgs}, Attributes{}, NDR{}, BinaryInfo{} {}
 };
 
-///
-/// Represents a SPIR-V translation unit containing SYCL kernels by the
-/// KernelInfo for each of the contained kernels.
-class SYCLModuleInfo {
-public:
-  using KernelInfoList = std::vector<SYCLKernelInfo>;
-
-  void addKernel(SYCLKernelInfo &Kernel) { Kernels.push_back(Kernel); }
-
-  KernelInfoList &kernels() { return Kernels; }
-
-  bool hasKernelFor(const std::string &KernelName) {
-    return getKernelFor(KernelName) != nullptr;
-  }
-
-  SYCLKernelInfo *getKernelFor(const std::string &KernelName) {
-    auto It =
-        std::find_if(Kernels.begin(), Kernels.end(), [&](SYCLKernelInfo &K) {
-          return K.Name == KernelName.c_str();
-        });
-    return (It != Kernels.end()) ? &*It : nullptr;
-  }
-
-private:
-  KernelInfoList Kernels;
-};
-
 } // namespace jit_compiler
 
 #endif // SYCL_FUSION_COMMON_KERNEL_H
diff --git a/sycl-fusion/common/include/View.h b/sycl-fusion/common/include/View.h
new file mode 100644
index 0000000000000..f9592e06d7749
--- /dev/null
+++ b/sycl-fusion/common/include/View.h
@@ -0,0 +1,45 @@
+//==------------- View.h - Non-owning view to contiguous memory ------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SYCL_FUSION_COMMON_VIEW_H
+#define SYCL_FUSION_COMMON_VIEW_H
+
+#include <cstddef>
+#include <type_traits>
+
+namespace jit_compiler {
+
+/// Read-only, non-owning view of a linear sequence of \p T.
+template <typename T> class View {
+public:
+  constexpr View(const T *Ptr, size_t Size) : Ptr(Ptr), Size(Size) {}
+
+  template <template <typename...> typename C>
+  explicit constexpr View(const C<T> &Cont)
+      : Ptr(Cont.data()), Size(Cont.size()) {}
+
+  constexpr const T *begin() const { return Ptr; }
+  constexpr const T *end() const { return Ptr + Size; }
+  constexpr size_t size() const { return Size; }
+
+  template <template <typename...> typename C> auto to() const {
+    return C<T>{begin(), end()};
+  }
+
+private:
+  const T *const Ptr;
+  const size_t Size;
+};
+
+// Deduction guide
+template <template <typename...> typename C, typename T>
+View(const C<T> &) -> View<T>;
+
+} // namespace jit_compiler
+
+#endif // SYCL_FUSION_COMMON_VIEW_H
diff --git a/sycl-fusion/common/lib/ModuleInfo.h b/sycl-fusion/common/lib/ModuleInfo.h
new file mode 100644
index 0000000000000..0a5aa7b30932b
--- /dev/null
+++ b/sycl-fusion/common/lib/ModuleInfo.h
@@ -0,0 +1,49 @@
+//==------------ ModuleInfo.h - Manages kernel info for the JIT ------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SYCL_FUSION_COMMON_MODULEINFO_H
+#define SYCL_FUSION_COMMON_MODULEINFO_H
+
+#include "Kernel.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace jit_compiler {
+
+///
+/// Represents a SPIR-V translation unit containing SYCL kernels by the
+/// KernelInfo for each of the contained kernels.
+class SYCLModuleInfo {
+public:
+  using KernelInfoList = std::vector<SYCLKernelInfo>;
+
+  void addKernel(SYCLKernelInfo &Kernel) { Kernels.push_back(Kernel); }
+
+  KernelInfoList &kernels() { return Kernels; }
+
+  bool hasKernelFor(const std::string &KernelName) {
+    return getKernelFor(KernelName) != nullptr;
+  }
+
+  SYCLKernelInfo *getKernelFor(const std::string &KernelName) {
+    auto It =
+        std::find_if(Kernels.begin(), Kernels.end(), [&](SYCLKernelInfo &K) {
+          return K.Name == KernelName.c_str();
+        });
+    return (It != Kernels.end()) ? &*It : nullptr;
+  }
+
+private:
+  KernelInfoList Kernels;
+};
+
+} // namespace jit_compiler
+
+#endif // SYCL_FUSION_COMMON_MODULEINFO_H
diff --git a/sycl-fusion/jit-compiler/include/KernelFusion.h b/sycl-fusion/jit-compiler/include/KernelFusion.h
index 26166290d1348..8abe27d108790 100644
--- a/sycl-fusion/jit-compiler/include/KernelFusion.h
+++ b/sycl-fusion/jit-compiler/include/KernelFusion.h
@@ -9,59 +9,57 @@
 #ifndef SYCL_FUSION_JIT_COMPILER_KERNELFUSION_H
 #define SYCL_FUSION_JIT_COMPILER_KERNELFUSION_H
 
+#include "DynArray.h"
 #include "Kernel.h"
 #include "Options.h"
 #include "Parameter.h"
+#include "View.h"
+
 #include <cassert>
-#include <string>
-#include <variant>
-#include <vector>
 
 namespace jit_compiler {
 
 class FusionResult {
 public:
-  explicit FusionResult(std::string &&ErrorMessage)
-      : Type{FusionResultType::FAILED}, Value{std::move(ErrorMessage)} {}
+  explicit FusionResult(const char *ErrorMessage)
+      : Type{FusionResultType::FAILED}, KernelInfo{},
+        ErrorMessage{ErrorMessage} {}
 
-  explicit FusionResult(SYCLKernelInfo KernelInfo, bool Cached = false)
+  explicit FusionResult(const SYCLKernelInfo &KernelInfo, bool Cached = false)
       : Type{(Cached) ? FusionResultType::CACHED : FusionResultType::NEW},
-        Value{std::forward<SYCLKernelInfo>(KernelInfo)} {}
+        KernelInfo(KernelInfo), ErrorMessage{} {}
 
   bool failed() const { return Type == FusionResultType::FAILED; }
 
   bool cached() const { return Type == FusionResultType::CACHED; }
 
-  const std::string &getErrorMessage() const {
-    assert(failed() && std::holds_alternative<std::string>(Value) &&
-           "No error message present");
-    return std::get<std::string>(Value);
+  const char *getErrorMessage() const {
+    assert(failed() && "No error message present");
+    return ErrorMessage.c_str();
   }
 
   const SYCLKernelInfo &getKernelInfo() const {
-    assert(!failed() && std::holds_alternative<SYCLKernelInfo>(Value) &&
-           "No kernel info");
-    return std::get<SYCLKernelInfo>(Value);
+    assert(!failed() && "No kernel info");
+    return KernelInfo;
   }
 
 private:
   enum class FusionResultType { FAILED, CACHED, NEW };
-  FusionResultType Type;
 
-  std::variant<std::string, SYCLKernelInfo> Value;
+  FusionResultType Type;
+  SYCLKernelInfo KernelInfo;
+  DynString ErrorMessage;
 };
 
 class KernelFusion {
 
 public:
   static FusionResult
-  fuseKernels(const std::vector<SYCLKernelInfo> &KernelInformation,
-              const char *FusedKernelName,
-              jit_compiler::ParamIdentList &Identities,
+  fuseKernels(View<SYCLKernelInfo> KernelInformation,
+              const char *FusedKernelName, View<ParameterIdentity> Identities,
               BarrierFlags BarriersFlags,
-              const std::vector<jit_compiler::ParameterInternalization>
-                  &Internalization,
-              const std::vector<jit_compiler::JITConstant> &JITConstants);
+              View<ParameterInternalization> Internalization,
+              View<jit_compiler::JITConstant> JITConstants);
 
   /// Clear all previously set options.
   static void resetConfiguration();
diff --git a/sycl-fusion/jit-compiler/include/Parameter.h b/sycl-fusion/jit-compiler/include/Parameter.h
index 6bed029e87011..4684029d3420c 100644
--- a/sycl-fusion/jit-compiler/include/Parameter.h
+++ b/sycl-fusion/jit-compiler/include/Parameter.h
@@ -13,7 +13,6 @@
 
 #include <algorithm>
 #include <cstdint>
-#include <vector>
 
 namespace jit_compiler {
 ///
@@ -60,8 +59,6 @@ struct ParameterIdentity {
   }
 };
 
-using ParamIdentList = std::vector<ParameterIdentity>;
-
 ///
 /// Express how a parameter can be lowered using promotion to local or global
 /// memory.
diff --git a/sycl-fusion/jit-compiler/lib/KernelFusion.cpp b/sycl-fusion/jit-compiler/lib/KernelFusion.cpp
index 3f7691ed0fadf..9a8c0e58df84d 100644
--- a/sycl-fusion/jit-compiler/lib/KernelFusion.cpp
+++ b/sycl-fusion/jit-compiler/lib/KernelFusion.cpp
@@ -34,7 +34,7 @@ static FusionResult errorToFusionResult(llvm::Error &&Err,
                           // compiled without exception support.
                           ErrMsg << "\t" << StrErr.getMessage() << "\n";
                         });
-  return FusionResult{ErrMsg.str()};
+  return FusionResult{ErrMsg.str().c_str()};
 }
 
 static std::vector<jit_compiler::NDRange>
@@ -71,17 +71,16 @@ static bool isTargetFormatSupported(BinaryFormat TargetFormat) {
 }
 
 FusionResult KernelFusion::fuseKernels(
-    const std::vector<SYCLKernelInfo> &KernelInformation,
-    const char *FusedKernelName, ParamIdentList &Identities,
-    BarrierFlags BarriersFlags,
-    const std::vector<jit_compiler::ParameterInternalization> &Internalization,
-    const std::vector<jit_compiler::JITConstant> &Constants) {
+    View<SYCLKernelInfo> KernelInformation, const char *FusedKernelName,
+    View<ParameterIdentity> Identities, BarrierFlags BarriersFlags,
+    View<ParameterInternalization> Internalization,
+    View<jit_compiler::JITConstant> Constants) {
 
   std::vector<std::string> KernelsToFuse;
   llvm::transform(KernelInformation, std::back_inserter(KernelsToFuse),
                   [](const auto &KI) { return std::string{KI.Name.c_str()}; });
 
-  const auto NDRanges = gatherNDRanges(KernelInformation);
+  const auto NDRanges = gatherNDRanges(KernelInformation.to<llvm::ArrayRef>());
 
   if (!isValidCombination(NDRanges)) {
     return FusionResult{
@@ -105,10 +104,10 @@ FusionResult KernelFusion::fuseKernels(
   bool CachingEnabled = ConfigHelper::get<option::JITEnableCaching>();
   CacheKeyT CacheKey{TargetArch,
                      KernelsToFuse,
-                     Identities,
+                     Identities.to<std::vector>(),
                      BarriersFlags,
-                     Internalization,
-                     Constants,
+                     Internalization.to<std::vector>(),
+                     Constants.to<std::vector>(),
                      IsHeterogeneousList
                          ? std::optional<std::vector<NDRange>>{NDRanges}
                          : std::optional<std::vector<NDRange>>{std::nullopt}};
@@ -147,9 +146,12 @@ FusionResult KernelFusion::fuseKernels(
 
   // Add information about the kernel that should be fused as metadata into the
   // LLVM module.
-  FusedFunction FusedKernel{
-      FusedKernelName, KernelsToFuse, std::move(Identities),
-      Internalization, Constants,     NDRanges};
+  FusedFunction FusedKernel{FusedKernelName,
+                            KernelsToFuse,
+                            Identities.to<llvm::ArrayRef>(),
+                            Internalization.to<llvm::ArrayRef>(),
+                            Constants.to<llvm::ArrayRef>(),
+                            NDRanges};
   FusedFunctionList FusedKernelList;
   FusedKernelList.push_back(FusedKernel);
   llvm::Expected<std::unique_ptr<llvm::Module>> NewModOrError =
diff --git a/sycl-fusion/jit-compiler/lib/fusion/FusionHelper.h b/sycl-fusion/jit-compiler/lib/fusion/FusionHelper.h
index 4644406d41a57..4221496520998 100644
--- a/sycl-fusion/jit-compiler/lib/fusion/FusionHelper.h
+++ b/sycl-fusion/jit-compiler/lib/fusion/FusionHelper.h
@@ -27,22 +27,22 @@ class FusionHelper {
   /// Representation of a fused kernel named FusedName and fusing
   /// all the kernels listed in FusedKernels.
   struct FusedFunction {
-    FusedFunction(const std::string &FusedName,
-                  const std::vector<std::string> &FusedKernels,
-                  const jit_compiler::ParamIdentList &ParameterIdentities,
-                  llvm::ArrayRef<jit_compiler::ParameterInternalization>
-                      ParameterInternalization,
-                  llvm::ArrayRef<jit_compiler::JITConstant> Constants,
-                  llvm::ArrayRef<jit_compiler::NDRange> NDRanges)
+    FusedFunction(
+        const char *FusedName, llvm::ArrayRef<std::string> FusedKernels,
+        llvm::ArrayRef<jit_compiler::ParameterIdentity> ParameterIdentities,
+        llvm::ArrayRef<jit_compiler::ParameterInternalization>
+            ParameterInternalization,
+        llvm::ArrayRef<jit_compiler::JITConstant> Constants,
+        llvm::ArrayRef<jit_compiler::NDRange> NDRanges)
         : FusedName{FusedName}, FusedKernels{FusedKernels},
           ParameterIdentities{ParameterIdentities},
           ParameterInternalization{ParameterInternalization},
           Constants{Constants}, NDRanges{NDRanges},
           FusedNDRange{jit_compiler::combineNDRanges(NDRanges)} {}
 
-    std::string FusedName;
-    std::vector<std::string> FusedKernels;
-    jit_compiler::ParamIdentList ParameterIdentities;
+    const char *FusedName;
+    llvm::ArrayRef<std::string> FusedKernels;
+    llvm::ArrayRef<jit_compiler::ParameterIdentity> ParameterIdentities;
     llvm::ArrayRef<jit_compiler::ParameterInternalization>
         ParameterInternalization;
     llvm::ArrayRef<jit_compiler::JITConstant> Constants;
diff --git a/sycl-fusion/jit-compiler/lib/fusion/FusionPipeline.h b/sycl-fusion/jit-compiler/lib/fusion/FusionPipeline.h
index 642206025224f..61ae8e0bcb274 100644
--- a/sycl-fusion/jit-compiler/lib/fusion/FusionPipeline.h
+++ b/sycl-fusion/jit-compiler/lib/fusion/FusionPipeline.h
@@ -10,6 +10,7 @@
 #define SYCL_FUSION_JIT_COMPILER_FUSION_FUSIONPIPELINE_H
 
 #include "Kernel.h"
+#include "ModuleInfo.h"
 #include "llvm/IR/Module.h"
 
 namespace jit_compiler {
diff --git a/sycl-fusion/jit-compiler/lib/fusion/JITContext.h b/sycl-fusion/jit-compiler/lib/fusion/JITContext.h
index 01db4fac92af3..30329e000d2d0 100644
--- a/sycl-fusion/jit-compiler/lib/fusion/JITContext.h
+++ b/sycl-fusion/jit-compiler/lib/fusion/JITContext.h
@@ -29,9 +29,9 @@ class LLVMContext;
 namespace jit_compiler {
 
 using CacheKeyT =
-    std::tuple<DeviceArchitecture, std::vector<std::string>, ParamIdentList,
-               BarrierFlags, std::vector<ParameterInternalization>,
-               std::vector<JITConstant>,
+    std::tuple<DeviceArchitecture, std::vector<std::string>,
+               std::vector<ParameterIdentity>, BarrierFlags,
+               std::vector<ParameterInternalization>, std::vector<JITConstant>,
                // This field of the cache is optional because, if all of the
                // ranges are equal, we will perform no remapping, so that fused
                // kernels can be reused with different lists of equal nd-ranges.
diff --git a/sycl-fusion/passes/kernel-fusion/SYCLKernelFusion.h b/sycl-fusion/passes/kernel-fusion/SYCLKernelFusion.h
index 85a2c9ca4845a..b590ac1f5edbf 100644
--- a/sycl-fusion/passes/kernel-fusion/SYCLKernelFusion.h
+++ b/sycl-fusion/passes/kernel-fusion/SYCLKernelFusion.h
@@ -10,6 +10,7 @@
 #define SYCL_FUSION_PASSES_SYCLKERNELFUSION_H
 
 #include "Kernel.h"
+#include "ModuleInfo.h"
 #include "target/TargetFusionInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
diff --git a/sycl-fusion/passes/kernel-info/SYCLKernelInfo.h b/sycl-fusion/passes/kernel-info/SYCLKernelInfo.h
index 8baf04d76c7c3..306cd0d912004 100644
--- a/sycl-fusion/passes/kernel-info/SYCLKernelInfo.h
+++ b/sycl-fusion/passes/kernel-info/SYCLKernelInfo.h
@@ -13,6 +13,7 @@
 #include "llvm/Passes/PassPlugin.h"
 
 #include "Kernel.h"
+#include "ModuleInfo.h"
 
 ///
 /// Analysis pass to make the SYCLModuleInfo available to other
diff --git a/sycl/doc/EnvironmentVariables.md b/sycl/doc/EnvironmentVariables.md
index 52bf3cfef24a5..4df5af687075a 100644
--- a/sycl/doc/EnvironmentVariables.md
+++ b/sycl/doc/EnvironmentVariables.md
@@ -8,7 +8,6 @@ compiler and runtime.
 | Environment variable | Values | Description |
 | -------------------- | ------ | ----------- |
 | `ONEAPI_DEVICE_SELECTOR` | [See below.](#oneapi_device_selector)  | This device selection environment variable can be used to limit the choice of devices available when the SYCL-using application is run.  Useful for limiting devices to a certain type (like GPUs or accelerators) or backends (like Level Zero or OpenCL).  This device selection mechanism is replacing `SYCL_DEVICE_FILTER` .  The `ONEAPI_DEVICE_SELECTOR` syntax is shared with OpenMP and also allows sub-devices to be chosen. [See below.](#oneapi_device_selector) for a full description.   |
-| `SYCL_DEVICE_FILTER` (deprecated) | `backend:device_type:device_num` | Please use `ONEAPI_DEVICE_SELECTOR` environment variable instead. See section [`SYCL_DEVICE_FILTER`](#sycl_device_filter) below for `SYCL_DEVICE_FILTER` description. |
 | `SYCL_DEVICE_ALLOWLIST` | See [below](#sycl_device_allowlist) | Filter out devices that do not match the pattern specified. `BackendName` accepts `host`, `opencl`, `level_zero`, `native_cpu` or `cuda`. `DeviceType` accepts `host`, `cpu`, `gpu` or `acc`. `DeviceVendorId` accepts uint32_t in hex form (`0xXYZW`). `DriverVersion`, `PlatformVersion`, `DeviceName` and `PlatformName` accept regular expression. Special characters, such as parenthesis, must be escaped. DPC++ runtime will select only those devices which satisfy provided values above and regex. More than one device can be specified using the piping symbol "\|".|
 | `SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING` | Any(\*) | Disables automatic rounding-up of `parallel_for` invocation ranges. |
 | `SYCL_CACHE_DIR` | Path | Path to persistent cache root directory. Default values are `%AppData%\libsycl_cache` for Windows and `$XDG_CACHE_HOME/libsycl_cache` on Linux, if `XDG_CACHE_HOME` is not set then `$HOME/.cache/libsycl_cache`. When none of the environment variables are set SYCL persistent cache is disabled. |
@@ -110,32 +109,6 @@ A list of devices and their driver version following the pattern:
 Also may contain `PlatformVersion`, `DeviceName` and `PlatformName`. There is no
 fixed order of properties in the pattern.
 
-### `SYCL_DEVICE_FILTER`
-
-This environment variable limits the SYCL RT to use only a subset of the system's devices. Setting this environment variable affects all of the device query functions (`platform::get_devices()` and `platform::get_platforms()`) and all of the device selectors.
-
-The value of this environment variable is a comma separated list of filters, where each filter is a triple of the form "`backend`:`device_type`:`device_num`" (without the quotes). Each element of the triple is optional, but each filter must have at least one value. Possible values of `backend` are:
-- `host` (Deprecated)
-- `level_zero`
-- `opencl`
-- `cuda`
-- `hip`
-- `esimd_emulator` (Deprecated)
-- `*`
-
-Possible values of `device_type` are:
-- `host` (Deprecated)
-- `cpu`
-- `gpu`
-- `acc`
-- `*`
-
-`device_num` is an integer that indexes the enumeration of devices from the sycl-ls utility tool, where the first device in that enumeration has index zero in each backend. For example, `SYCL_DEVICE_FILTER=2` will return all devices with index '2' from all different backends. If multiple devices satisfy this device number (e.g., GPU and CPU devices can be assigned device number '2'), then default_selector will choose the device with the highest heuristic point.  When `SYCL_DEVICE_ALLOWLIST` is set, it is applied before enumerating devices and affects `device_num` values.
-
-Assuming a filter has all three elements of the triple, it selects only those devices that come from the given backend, have the specified device type, AND have the given device index. If more than one filter is specified, the RT is restricted to the union of devices selected by all filters.
-
-Note that all device selectors will throw an exception if the filtered list of devices does not include a device that satisfies the selector. For instance, `SYCL_DEVICE_FILTER=cpu` will cause `gpu_selector()` to throw an exception. `SYCL_DEVICE_FILTER` also limits loading only specified plugins into the SYCL RT. In particular, `SYCL_DEVICE_FILTER=level_zero` will cause the `cpu_selector` to throw an exception since SYCL RT will only load the `level_zero` backend which does not support any CPU devices at this time. When multiple devices satisfy the filter (e..g, `SYCL_DEVICE_FILTER=gpu`), only one of them will be selected.
-
 ## `SYCL_REDUCTION_PREFERRED_WORKGROUP_SIZE`
 
 This environment variable controls the preferred work-group size for reductions on specified device types. Setting this will affect all reductions without an explicitly specified work-group size on devices of types in the value of the environment variable.
diff --git a/sycl/doc/MultiTileCardWithLevelZero.md b/sycl/doc/MultiTileCardWithLevelZero.md
index 1b11785883781..7b5360cd66ef7 100644
--- a/sycl/doc/MultiTileCardWithLevelZero.md
+++ b/sycl/doc/MultiTileCardWithLevelZero.md
@@ -19,9 +19,9 @@ by SYCL runtime. Thus in the example above there is CPU (managed by OpenCL backe
 GPUs corresponding to the single physical GPU (managed by either OpenCL or Level-Zero backend).
 There are few ways to filter observable root-devices.
 	
-One is using environment variable SYCL_DEVICE_FILTER described in [EnvironmentVariables.md](https://github.com/intel/llvm/blob/sycl/sycl/doc/EnvironmentVariables.md)
+One is using environment variable ONEAPI_DEVICE_SELECTOR described in [EnvironmentVariables.md](https://github.com/intel/llvm/blob/sycl/sycl/doc/EnvironmentVariables.md)
 ```
-$ SYCL_DEVICE_FILTER=level_zero sycl-ls
+$ ONEAPI_DEVICE_SELECTOR=level_zero:* sycl-ls
 [level_zero:0] GPU : Intel(R) Level-Zero 1.1 [1.1.19792]
 ```
 Another way is to use similar SYCL API described in [sycl\_ext\_oneapi\_filter\_selector](extensions/supported/sycl_ext_oneapi_filter_selector.asciidoc)
@@ -33,7 +33,7 @@ On Windows these would appear as root-devices of multiple different SYCL platfor
 
 `CreateMultipleRootDevices=N NEOReadDebugKeys=1` evironment variables can be used to emulate multiple GPU cards, e.g.
 ```
-$ CreateMultipleRootDevices=2 NEOReadDebugKeys=1 SYCL_DEVICE_FILTER=level_zero sycl-ls
+$ CreateMultipleRootDevices=2 NEOReadDebugKeys=1 ONEAPI_DEVICE_SELECTOR=level_zero:* sycl-ls
 [level_zero:0] GPU : Intel(R) Level-Zero 1.1 [1.1.19792]
 [level_zero:1] GPU : Intel(R) Level-Zero 1.1 [1.1.19792]
 ```
diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_graph.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_graph.asciidoc
index 44a2d61f4910a..278a5318a9fe9 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_graph.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_graph.asciidoc
@@ -411,6 +411,9 @@ public:
   ext::oneapi::experimental::queue_state
   ext_oneapi_get_state() const;
 
+  ext::oneapi::experimental::command_graph<graph_state::modifiable> 
+  ext_oneapi_get_graph() const;
+
   /* -- graph convenience shortcuts -- */
 
   event ext_oneapi_graph(command_graph<graph_state::executable>& graph);
@@ -1026,6 +1029,22 @@ Returns: If the queue is in the default state where commands are scheduled
 immediately for execution, `queue_state::executing` is returned. Otherwise,
 `queue_state::recording` is returned where commands are redirected to a `command_graph`
 object.
+|
+[source,c++]
+----
+command_graph<graph_state::modifiable>
+queue::ext_oneapi_get_graph() const;
+----
+
+| Query the underlying command graph of a queue when recording.
+
+Returns: The graph object that the queue is recording commands into.
+
+Exceptions:
+
+* Throws synchronously with error code `invalid` if the queue is not in `queue_state::recording`
+state.
+
 |
 [source,c++]
 ----
diff --git a/sycl/doc/extensions/supported/sycl_ext_oneapi_backend_level_zero.md b/sycl/doc/extensions/supported/sycl_ext_oneapi_backend_level_zero.md
index 710bb52f8a726..4e24c7a60128a 100644
--- a/sycl/doc/extensions/supported/sycl_ext_oneapi_backend_level_zero.md
+++ b/sycl/doc/extensions/supported/sycl_ext_oneapi_backend_level_zero.md
@@ -52,7 +52,7 @@ For further details see here: <https://github.com/intel/llvm/blob/sycl/sycl/doc/
         
 There is an extension that introduces a filtering device selection to SYCL described in
 [sycl\_ext\_oneapi\_filter\_selector](../supported/sycl_ext_oneapi_filter_selector.asciidoc).
-Similar to how SYCL_DEVICE_FILTER or ONEAPI_DEVICE_SELECTOR applies filtering to the entire process this device selector can be used to
+Similar to how ONEAPI_DEVICE_SELECTOR applies filtering to the entire process this device selector can be used to
 programmatically select the Level-Zero backend.
                 
 When neither the environment variable nor the filtering device selector are used, the implementation chooses
diff --git a/sycl/doc/extensions/supported/sycl_ext_oneapi_srgb.asciidoc b/sycl/doc/extensions/supported/sycl_ext_oneapi_srgb.asciidoc
index e97e0046a7c1a..b3f8a5f53faea 100644
--- a/sycl/doc/extensions/supported/sycl_ext_oneapi_srgb.asciidoc
+++ b/sycl/doc/extensions/supported/sycl_ext_oneapi_srgb.asciidoc
@@ -130,7 +130,7 @@ And to run, be sure to select the OpenCL backend (works on both CPU and GPU devi
 
 [source]
 ----
-$ SYCL_DEVICE_FILTER=opencl:gpu ./myapp.bin
+$ ONEAPI_DEVICE_SELECTOR=opencl:gpu ./myapp.bin
 ----
 
 
diff --git a/sycl/include/sycl/bit_cast.hpp b/sycl/include/sycl/bit_cast.hpp
index 774b831feb63b..09148847eefe3 100644
--- a/sycl/include/sycl/bit_cast.hpp
+++ b/sycl/include/sycl/bit_cast.hpp
@@ -29,21 +29,22 @@
 #if __cpp_lib_bit_cast
 // first choice std::bit_cast
 #include <bit>
-#define __SYCL_BC_CONSTEXPR constexpr
+#define __SYCL_BITCAST_IS_CONSTEXPR 1
 #elif __SYCL_HAS_BUILTIN_BIT_CAST
 // second choice __builtin_bit_cast
-#define __SYCL_BC_CONSTEXPR constexpr
+#define __SYCL_BITCAST_IS_CONSTEXPR 1
 #else
 // fallback memcpy
 #include <sycl/detail/memcpy.hpp>
-#define __SYCL_BC_CONSTEXPR
 #endif
 
 namespace sycl {
 inline namespace _V1 {
 
 template <typename To, typename From>
-__SYCL_BC_CONSTEXPR
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+constexpr
+#endif
     std::enable_if_t<sizeof(To) == sizeof(From) &&
                          std::is_trivially_copyable<From>::value &&
                          std::is_trivially_copyable<To>::value,
diff --git a/sycl/include/sycl/detail/device_filter.hpp b/sycl/include/sycl/detail/device_filter.hpp
index 44e4a2d4ff3a9..f8832f11e3a11 100644
--- a/sycl/include/sycl/detail/device_filter.hpp
+++ b/sycl/include/sycl/detail/device_filter.hpp
@@ -46,6 +46,9 @@ struct ods_target {
   std::optional<unsigned> SubSubDeviceNum;
 
   bool IsNegativeTarget = false; // used to represent negative filters.
+  // used in filter selector to keep count of the number of devices with
+  // the same Backend and DeviceType.
+  int MatchesSeen = 0;
 
   ods_target(backend be) { Backend = be; };
   ods_target(){};
@@ -66,6 +69,7 @@ class ods_target_list {
 std::ostream &operator<<(std::ostream &Out, const ods_target &Target);
 std::vector<ods_target> Parse_ONEAPI_DEVICE_SELECTOR(const std::string &envStr);
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 // ---------------------------------------
 // SYCL_DEVICE_FILTER support
 
@@ -127,6 +131,7 @@ inline std::ostream &operator<<(std::ostream &Out,
   }
   return Out;
 }
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
 } // namespace detail
 } // namespace _V1
diff --git a/sycl/include/sycl/detail/generic_type_lists.hpp b/sycl/include/sycl/detail/generic_type_lists.hpp
index a18bb5fd764f9..2aca24f1b1e7f 100644
--- a/sycl/include/sycl/detail/generic_type_lists.hpp
+++ b/sycl/include/sycl/detail/generic_type_lists.hpp
@@ -12,6 +12,8 @@
 #include <sycl/detail/type_list.hpp> // for type_list, address_space_list
 #include <sycl/half_type.hpp>        // for half
 
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
 #include <cstddef>     // for byte, size_t
 #include <type_traits> // for conditional_t, is_signed_v, is_...
 
@@ -41,6 +43,28 @@ using scalar_vector_half_list = tl_append<scalar_half_list, vector_half_list>;
 using half_list =
     tl_append<scalar_half_list, vector_half_list, marray_half_list>;
 
+using scalar_bfloat16_list = type_list<sycl::ext::oneapi::bfloat16>;
+
+using vector_bfloat16_list = type_list<
+    vec<sycl::ext::oneapi::bfloat16, 1>, vec<sycl::ext::oneapi::bfloat16, 2>,
+    vec<sycl::ext::oneapi::bfloat16, 3>, vec<sycl::ext::oneapi::bfloat16, 4>,
+    vec<sycl::ext::oneapi::bfloat16, 8>, vec<sycl::ext::oneapi::bfloat16, 16>>;
+
+using marray_bfloat16_list = type_list<marray<sycl::ext::oneapi::bfloat16, 1>,
+                                       marray<sycl::ext::oneapi::bfloat16, 2>,
+                                       marray<sycl::ext::oneapi::bfloat16, 3>,
+                                       marray<sycl::ext::oneapi::bfloat16, 4>,
+                                       marray<sycl::ext::oneapi::bfloat16, 8>,
+                                       marray<sycl::ext::oneapi::bfloat16, 16>>;
+
+using scalar_vector_bfloat16_list =
+    tl_append<scalar_bfloat16_list, vector_bfloat16_list>;
+
+using bfloat16_list =
+    tl_append<scalar_bfloat16_list, vector_bfloat16_list, marray_bfloat16_list>;
+
+using half_bfloat16_list = tl_append<scalar_half_list, scalar_bfloat16_list>;
+
 using scalar_float_list = type_list<float>;
 
 using vector_float_list =
@@ -73,14 +97,22 @@ using scalar_vector_double_list =
 using double_list =
     tl_append<scalar_double_list, vector_double_list, marray_double_list>;
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+using scalar_floating_list = tl_append<scalar_float_list, scalar_double_list,
+                                       scalar_half_list, scalar_bfloat16_list>;
+#else
+// Presently, this is used only by builtins_legacy_scalar.hpp for defining math
+// funcs. bfloat16 provides its own scalar math definitions so we skip its
+// inclusion.
 using scalar_floating_list =
     tl_append<scalar_float_list, scalar_double_list, scalar_half_list>;
+#endif
 
-using vector_floating_list =
-    tl_append<vector_float_list, vector_double_list, vector_half_list>;
+using vector_floating_list = tl_append<vector_float_list, vector_double_list,
+                                       vector_half_list, vector_bfloat16_list>;
 
-using marray_floating_list =
-    tl_append<marray_float_list, marray_double_list, marray_half_list>;
+using marray_floating_list = tl_append<marray_float_list, marray_double_list,
+                                       marray_half_list, marray_bfloat16_list>;
 
 using scalar_vector_floating_list =
     tl_append<scalar_floating_list, vector_floating_list>;
diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 7e8b6a272df87..36431fcdad13a 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -56,6 +56,14 @@ inline constexpr bool is_genfloath_v = is_contained_v<T, gtl::half_list>;
 template <typename T>
 inline constexpr bool is_half_v = is_contained_v<T, gtl::scalar_half_list>;
 
+template <typename T>
+inline constexpr bool is_bfloat16_v =
+    is_contained_v<T, gtl::scalar_bfloat16_list>;
+
+template <typename T>
+inline constexpr bool is_half_or_bf16_v =
+    is_contained_v<T, gtl::half_bfloat16_list>;
+
 template <typename T>
 inline constexpr bool is_svgenfloath_v =
     is_contained_v<T, gtl::scalar_vector_half_list>;
@@ -539,12 +547,12 @@ using select_cl_scalar_t = std::conditional_t<
     std::is_integral_v<T>, select_cl_scalar_integral_t<T>,
     std::conditional_t<
         std::is_floating_point_v<T>, select_cl_scalar_float_t<T>,
-        // half is a special case: it is implemented differently on
-        // host and device and therefore, might lower to different
-        // types
-        std::conditional_t<is_half_v<T>,
-                           sycl::detail::half_impl::BIsRepresentationT,
-                           select_cl_scalar_complex_or_T_t<T>>>>;
+        // half and bfloat16 are special cases: they are implemented differently
+        // on host and device and therefore might lower to different types
+        std::conditional_t<
+            is_half_v<T>, sycl::detail::half_impl::BIsRepresentationT,
+            std::conditional_t<is_bfloat16_v<T>, T,
+                               select_cl_scalar_complex_or_T_t<T>>>>>;
 
 // select_cl_vector_or_scalar_or_ptr does cl_* type selection for element type
 // of a vector type T, pointer type substitution, and scalar type substitution.
@@ -556,7 +564,7 @@ template <typename T>
 struct select_cl_vector_or_scalar_or_ptr<
     T, typename std::enable_if_t<is_vgentype_v<T>>> {
   using type =
-      // select_cl_scalar_t returns _Float16, so, we try to instantiate vec
+      // select_cl_scalar_t may return _Float16, so, we try to instantiate vec
       // class with _Float16 DataType, which is not expected there
       // So, leave vector<half, N> as-is
       vec<std::conditional_t<is_half_v<mptr_or_vec_elem_type_t<T>>,
diff --git a/sycl/include/sycl/ext/intel/esimd/memory.hpp b/sycl/include/sycl/ext/intel/esimd/memory.hpp
index eca1dd8b30904..7af684ee99cfb 100644
--- a/sycl/include/sycl/ext/intel/esimd/memory.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/memory.hpp
@@ -341,7 +341,7 @@ gather(const T *p, simd<OffsetT, N / VS> byte_offsets, simd_mask<N / VS> mask,
   constexpr size_t Alignment =
       detail::getPropertyValue<PropertyListT, alignment_key>(sizeof(T));
   static_assert(Alignment >= sizeof(T),
-                "slm_gather() requires at least element-size alignment");
+                "gather() requires at least element-size alignment");
   constexpr auto L1Hint =
       detail::getPropertyValue<PropertyListT, cache_hint_L1_key>(
           cache_hint::none);
@@ -2538,7 +2538,6 @@ scatter_impl(AccessorTy acc, simd<T, N> vals, simd<uint32_t, N> offsets,
   }
 }
 
-#ifndef __ESIMD_FORCE_STATELESS_MEM
 template <typename T, int N, typename AccessorTy>
 __ESIMD_API std::enable_if_t<
     (std::is_same_v<detail::LocalAccessorMarker, AccessorTy> ||
@@ -2546,7 +2545,7 @@ __ESIMD_API std::enable_if_t<
     simd<T, N>>
 gather_impl(AccessorTy acc, simd<uint32_t, N> offsets, uint32_t glob_offset,
             simd_mask<N> mask) {
-  static_assert(sizeof(T) <= 4 && (N == 1 || N == 8 || N == 16 || N == 32),
+  static_assert(sizeof(T) <= 4 && detail::isPowerOf2(N, 32),
                 "Unexpected type or vector length");
 
   constexpr int TypeSizeLog2 = detail::ElemsPerAddrEncoding<sizeof(T)>();
@@ -2586,6 +2585,7 @@ gather_impl(AccessorTy acc, simd<uint32_t, N> offsets, uint32_t glob_offset,
   }
 }
 
+#ifndef __ESIMD_FORCE_STATELESS_MEM
 template <typename T, int N, int VS, cache_hint L1H, cache_hint L2H,
           lsc_data_size DS, typename OffsetT, typename AccessorT>
 __ESIMD_API std::enable_if_t<
@@ -2622,6 +2622,46 @@ gather_impl(AccessorT acc, simd<OffsetT, N / VS> byte_offsets,
 }
 #endif // __ESIMD_FORCE_STATELESS_MEM
 
+/// SLM gather implementation.
+/// Supported platforms: DG2, PVC
+/// VISA instruction: lsc_load.slm
+///
+/// Collects elements located at slm and returns them
+/// as a single \ref simd object.
+///
+/// @tparam T is element type.
+/// @tparam NElts is the number of elements to load per address.
+/// @tparam DS is the data size.
+/// @tparam N is the number of channels (platform dependent).
+/// @param offsets is the zero-based offsets for SLM buffer in bytes.
+/// @param pred is predicates.
+/// @param pass_thru values copied to the result when the corresponding
+/// element of \p pred is zero.
+/// @return is a vector of type T and size N * NElts.
+///
+template <typename T, int NElts, lsc_data_size DS, int N>
+__ESIMD_API __ESIMD_NS::simd<T, N * NElts>
+slm_gather_impl(__ESIMD_NS::simd<uint32_t, N> offsets,
+                __ESIMD_NS::simd_mask<N> pred,
+                __ESIMD_NS::simd<T, N * NElts> pass_thru) {
+  check_lsc_vector_size<NElts>();
+  check_lsc_data_size<T, DS>();
+  constexpr uint16_t AddressScale = 1;
+  constexpr int ImmOffset = 0;
+  constexpr lsc_data_size EDS = expand_data_size(finalize_data_size<T, DS>());
+  constexpr lsc_vector_size LSCVS = to_lsc_vector_size<NElts>();
+  constexpr lsc_data_order Transposed = lsc_data_order::nontranspose;
+  using MsgT = typename lsc_expand_type<T>::type;
+  __ESIMD_NS::simd<MsgT, N * NElts> PassThruExpanded =
+      lsc_format_input<MsgT>(pass_thru);
+  __ESIMD_NS::simd<MsgT, N * NElts> Result =
+      __esimd_lsc_load_merge_slm<MsgT, cache_hint::none, cache_hint::none,
+                                 AddressScale, ImmOffset, EDS, LSCVS,
+                                 Transposed, N>(pred.data(), offsets.data(),
+                                                PassThruExpanded.data());
+  return lsc_format_ret<T>(Result);
+}
+
 } // namespace detail
 
 /// @endcond ESIMD_DETAIL
@@ -2667,7 +2707,7 @@ __ESIMD_API
   return gather<T, N>(__ESIMD_DNS::accessorToPointer<T>(acc, glob_offset),
                       byte_offsets, mask);
 #else
-  if constexpr (sizeof(T) > 4 || !((N == 1 || N == 8 || N == 16 || N == 32))) {
+  if constexpr (sizeof(T) > 4 || !(detail::isPowerOf2(N, 32))) {
     // Requires DG2 or PVC.
     simd<T, N> PassThru; // Intentionally undefined
     byte_offsets += glob_offset;
@@ -2876,8 +2916,7 @@ gather(AccessorT acc, simd<OffsetT, N / VS> byte_offsets,
                 "hint is cache_level::L2 now.");
 
   if constexpr (L1Hint != cache_hint::none || L2Hint != cache_hint::none ||
-                VS > 1 || sizeof(T) > 4 ||
-                !((N == 1 || N == 8 || N == 16 || N == 32))) {
+                VS > 1 || sizeof(T) > 4 || !(detail::isPowerOf2(N, 32))) {
     simd<T, N> PassThru; // Intentionally undefined
     return detail::gather_impl<T, N, VS, L1Hint, L2Hint,
                                detail::lsc_data_size::default_size>(
@@ -2934,15 +2973,21 @@ gather(AccessorT acc, simd<OffsetT, N / VS> byte_offsets,
 /// to 1. This variant is added for convenience and let user omit the template
 /// arguments and call the function as
 /// 'gather(acc, byte_offsets, mask, pass_thru);'.
+// Dev note: the mask type was turned into template parameter `MaskT` to
+// avoid the conflicts of this prototype with the old gather() function
+// accepting a 'global_offset' parameter and avoid 'ambiguous call' errors
+// for calls like this: gather(acc, byte_offsets_simd, 0, mask);
 template <typename T, int N, typename AccessorT, typename OffsetT,
+          typename MaskT,
           typename PropertyListT =
               ext::oneapi::experimental::detail::empty_properties_t>
 __ESIMD_API std::enable_if_t<
     (detail::is_device_accessor_with_v<AccessorT,
                                        detail::accessor_mode_cap::can_read> &&
+     std::is_same_v<MaskT, simd_mask<N>> &&
      ext::oneapi::experimental::is_property_list_v<PropertyListT>),
     simd<T, N>>
-gather(AccessorT acc, simd<OffsetT, N> byte_offsets, simd_mask<N> mask,
+gather(AccessorT acc, simd<OffsetT, N> byte_offsets, MaskT mask,
        simd<T, N> pass_thru, PropertyListT props = {}) {
   return gather<T, N, 1>(acc, byte_offsets, mask, pass_thru, props);
 }
@@ -2954,6 +2999,10 @@ gather(AccessorT acc, simd<OffsetT, N> byte_offsets, simd_mask<N> mask,
 /// This function is identical to (acc-ga-2) except that vector size is fixed
 /// to 1. This variant is added for convenience and let user omit the template
 /// arguments and call the function as 'gather(acc, byte_offsets, mask);'.
+// Dev note: the mask type was turned into template parameter `MaskT` to
+// avoid the conflicts of this prototype with the old gather() function
+// accepting a 'global_offset' parameter and avoid 'ambiguous call' errors
+// for calls like this: gather(acc, byte_offsets_simd, 0);
 template <typename T, int N, typename AccessorT, typename OffsetT,
           typename MaskT,
           typename PropertyListT =
@@ -2961,8 +3010,8 @@ template <typename T, int N, typename AccessorT, typename OffsetT,
 __ESIMD_API std::enable_if_t<
     (detail::is_device_accessor_with_v<AccessorT,
                                        detail::accessor_mode_cap::can_read> &&
-     ext::oneapi::experimental::is_property_list_v<PropertyListT> &&
-     std::is_same_v<MaskT, simd_mask<N>>),
+     std::is_same_v<MaskT, simd_mask<N>> &&
+     ext::oneapi::experimental::is_property_list_v<PropertyListT>),
     simd<T, N>>
 gather(AccessorT acc, simd<OffsetT, N> byte_offsets, MaskT mask,
        PropertyListT props = {}) {
@@ -3546,42 +3595,360 @@ template <uint32_t SLMSize> __ESIMD_API void slm_init() {
 /// work-group of ESIMD kernel.
 __ESIMD_API void slm_init(uint32_t size) { __esimd_slm_init(size); }
 
-/// Gather operation over the Shared Local Memory.
-/// This API has almost the same interface as the @ref accessor_gather
-/// "accessor-based gather", except that it does not have the accessor and the
-/// global offset parameters.
-template <typename T, int N,
+/// template <typename T, int N, int VS,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N / VS> byte_offsets,
+///                   simd_mask<N / VS> mask, simd<T, N> pass_thru,
+///                   PropertyListT props = {});                   // (slm-ga-1)
+/// simd<T, N> slm_gather(simd<uint32_t, N / VS> byte_offsets,
+///                   simd_mask<N / VS> mask,
+///                   PropertyListT props = {});                   // (slm-ga-2)
+/// simd<T, N> slm_gather(simd<uint32_t, N / VS> byte_offsets,
+///                   PropertyListT props = {});                   // (slm-ga-3)
+///
+/// The next 3 functions are similar to the above and were added for
+/// convenience. They assume the VS parameter is set to 1 and do not require
+/// specifying the template parameters <T, N, VS> at function calls.
+/// template <typename T, int N,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N> byte_offsets,
+///                   simd_mask<N> mask, simd<T, N> pass_thru,
+///                   PropertyListT props = {});                   // (slm-ga-4)
+/// simd<T, N> slm_gather(simd<uint32_t, N> byte_offsets,
+///                   simd_mask<N> mask, PropertyListT props = {});// (slm-ga-5)
+/// simd<T, N> slm_gather(simd<uint32_t, N> byte_offsets,
+///                   PropertyListT props = {});                   // (slm-ga-6)
+///
+/// The next 3 functions are variations of the first 3 above (slm-ga-1,2,3)
+/// and were added only to support simd_view instead of simd for byte_offsets
+/// and/or pass_thru operands.
+/// template <typename T, int N, int VS = 1, typename OffsetObjT,
+///           typename OffsetRegionT, typename PropertyListT = empty_props_t>
+/// simd <T, N> slm_gather(simd_view<OffsetObjT, OffsetRegionT> byte_offsets,
+///             simd_mask<N / VS> mask, simd<T, N> pass_thru,
+///             PropertyListT props = {});                         // (slm-ga-7)
+/// simd <T, N> slm_gather(simd_view<OffsetObjT, OffsetRegionT> byte_offsets,
+///             simd_mask<N / VS> mask, PropertyListT props = {}); // (slm-ga-8)
+/// simd <T, N> slm_gather(simd_view<OffsetObjT, OffsetRegionT> byte_offsets,
+///             PropertyListT props = {});                         // (slm-ga-9)
+
+/// template <typename T, int N, int VS,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N / VS> byte_offsets,
+///                   simd_mask<N / VS> mask, simd<T, N> pass_thru,
+///                   PropertyListT props = {});                   // (slm-ga-1)
+#ifndef __ESIMD_GATHER_SCATTER_LLVM_IR
+/// Supported platforms: DG2, PVC only - Temporary restriction for the variant
+/// with pass_thru operand.
+#endif // __ESIMD_GATHER_SCATTER_LLVM_IR
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements. Access to any element's memory location can be disabled via the
+/// input vector of predicates \p mask. If mask[i] is unset, then the load from
+/// (byte_offsets[i]) is skipped and the corresponding i-th element from
+/// \p pass_thru operand is returned.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @tparam VS Vector size. It can also be read as the number of reads per each
+/// address. The parameter 'N' must be divisible by 'VS'. (VS > 1) is supported
+/// only on DG2 and PVC and only for 4- and 8-byte element vectors.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// If the alignment property is not passed, then it is assumed that each
+/// accessed address is aligned by element-size.
+/// @param mask The access mask, defaults to all 1s.
+/// @param pass_thru The vector pass through values.
+/// @param props The optional compile-time properties. Only 'alignment' property
+/// is used.
+/// @return A vector of elements read.
+template <typename T, int N, int VS,
           typename PropertyListT =
               ext::oneapi::experimental::detail::empty_properties_t>
 __ESIMD_API std::enable_if_t<
     ext::oneapi::experimental::is_property_list_v<PropertyListT>, simd<T, N>>
-slm_gather(simd<uint32_t, N> byte_offsets, simd_mask<N> mask,
+slm_gather(simd<uint32_t, N / VS> byte_offsets, simd_mask<N / VS> mask,
+           simd<T, N> pass_thru, PropertyListT props = {}) {
+  static_assert(N / VS >= 1 && N % VS == 0, "N must be divisible by VS");
+
+  constexpr size_t Alignment =
+      detail::getPropertyValue<PropertyListT, alignment_key>(sizeof(T));
+  static_assert(Alignment >= sizeof(T),
+                "slm_gather() requires at least element-size alignment");
+
+  // Use LSC lowering if VS > 1. Also, if masked gather is
+  // not available, then LSC is the only lowering option.
+  if constexpr (VS > 1 || !detail::isMaskedGatherScatterLLVMAvailable()) {
+    return __ESIMD_DNS::slm_gather_impl<T, VS,
+                                        detail::lsc_data_size::default_size>(
+        byte_offsets, mask, pass_thru);
+  } else {
+    using MsgT = detail::__raw_t<T>;
+    return __esimd_slm_gather_ld<MsgT, N, Alignment>(
+        byte_offsets.data(), mask.data(), pass_thru.data());
+  }
+}
+
+/// template <typename T, int N, int VS,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N / VS> byte_offsets,
+///                   simd_mask<N / VS> mask,
+///                   PropertyListT props = {});                   // (slm-ga-2)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements. Access to any element's memory location can be disabled via the
+/// input vector of predicates \p mask. If mask[i] is unset, then the load from
+/// (byte_offsets[i]) is skipped and the corresponding i-th element of the
+/// returned vector is undefined.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @tparam VS Vector size. It can also be read as the number of reads per each
+/// address. The parameter 'N' must be divisible by 'VS'. (VS > 1) is supported
+/// only on DG2 and PVC.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// @param mask The access mask, defaults to all 1s.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read. Elements in masked out lanes are
+///   undefined.
+template <typename T, int N, int VS,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    ext::oneapi::experimental::is_property_list_v<PropertyListT>, simd<T, N>>
+slm_gather(simd<uint32_t, N / VS> byte_offsets, simd_mask<N / VS> mask,
            PropertyListT props = {}) {
-  using MsgT = detail::__raw_t<T>;
   constexpr size_t Alignment =
       detail::getPropertyValue<PropertyListT, alignment_key>(sizeof(T));
   static_assert(Alignment >= sizeof(T),
                 "slm_gather() requires at least element-size alignment");
-  if constexpr (detail::isMaskedGatherScatterLLVMAvailable()) {
+
+  if constexpr (VS > 1 || (!detail::isPowerOf2(N, 32) &&
+                           !detail::isMaskedGatherScatterLLVMAvailable())) {
+    simd<T, N> PassThru; // Intentionally undefined
+    return detail::slm_gather_impl<T, VS, detail::lsc_data_size::default_size>(
+        byte_offsets, mask, PassThru);
+  } else if constexpr (detail::isMaskedGatherScatterLLVMAvailable()) {
+    using MsgT = detail::__raw_t<T>;
     simd<MsgT, N> PassThru; // it is intentionally undefined
     return __esimd_slm_gather_ld<MsgT, N, Alignment>(
         byte_offsets.data(), mask.data(), PassThru.data());
   } else {
-    static_assert(N == 1 || N == 8 || N == 16 || N == 32,
-                  "Unsupported vector length");
     detail::LocalAccessorMarker acc;
     return detail::gather_impl<T, N>(acc, byte_offsets, 0, mask);
   }
 }
 
+/// template <typename T, int N, int VS,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N / VS> byte_offsets,
+///                   PropertyListT props = {});                   // (slm-ga-3)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @tparam VS Vector size. It can also be read as the number of reads per each
+/// address. The parameter 'N' must be divisible by 'VS'. (VS > 1) is supported
+/// only on DG2 and PVC.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read.
+template <typename T, int N, int VS,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    ext::oneapi::experimental::is_property_list_v<PropertyListT>, simd<T, N>>
+slm_gather(simd<uint32_t, N / VS> byte_offsets, PropertyListT props = {}) {
+  simd_mask<N / VS> Mask = 1;
+  return slm_gather<T, N, VS>(byte_offsets, Mask, props);
+}
+
+/// template <typename T, int N,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N> byte_offsets,
+///                   simd_mask<N> mask, simd<T, N> pass_thru,
+///                   PropertyListT props = {});                   // (slm-ga-4)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements. Access to any element's memory location can be disabled via the
+/// input vector of predicates \p mask. If mask[i] is unset, then the load from
+/// (byte_offsets[i]) is skipped and the corresponding i-th element from
+/// \p pass_thru operand is returned.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// If the alignment property is not passed, then it is assumed that each
+/// accessed address is aligned by element-size.
+/// @param mask The access mask, defaults to all 1s.
+/// @param pass_thru The vector pass through values.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read.
+template <typename T, int N,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    ext::oneapi::experimental::is_property_list_v<PropertyListT>, simd<T, N>>
+slm_gather(simd<uint32_t, N> byte_offsets, simd_mask<N> mask,
+           simd<T, N> pass_thru, PropertyListT props = {}) {
+  constexpr int VS = 1;
+  return slm_gather<T, N, VS>(byte_offsets, mask, pass_thru, props);
+}
+
+/// template <typename T, int N,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N> byte_offsets,
+///                   simd_mask<N> mask, PropertyListT props = {});// (slm-ga-5)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements. Access to any element's memory location can be disabled via the
+/// input vector of predicates \p mask. If mask[i] is unset, then the load from
+/// (byte_offsets[i]) is skipped and the corresponding i-th element of the
+/// returned vector is undefined.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// @param mask The access mask, defaults to all 1s.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read. Elements in masked out lanes are
+///   undefined.
+template <typename T, int N,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    ext::oneapi::experimental::is_property_list_v<PropertyListT>, simd<T, N>>
+slm_gather(simd<uint32_t, N> byte_offsets, simd_mask<N> mask,
+           PropertyListT props = {}) {
+  constexpr int VS = 1;
+  return slm_gather<T, N, VS>(byte_offsets, mask, props);
+}
+
+/// template <typename T, int N,
+///           typename PropertyListT = empty_properties_t>
+/// simd<T, N> slm_gather(simd<uint32_t, N> byte_offsets,
+///                   PropertyListT props = {});                   // (slm-ga-6)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read.
 template <typename T, int N,
           typename PropertyListT =
               ext::oneapi::experimental::detail::empty_properties_t>
 __ESIMD_API std::enable_if_t<
     ext::oneapi::experimental::is_property_list_v<PropertyListT>, simd<T, N>>
 slm_gather(simd<uint32_t, N> byte_offsets, PropertyListT props = {}) {
-  simd_mask<N> Mask = 1;
-  return slm_gather<T, N>(byte_offsets, Mask, props);
+  constexpr int VS = 1;
+  return slm_gather<T, N, VS>(byte_offsets, props);
+}
+
+/// template <typename T, int N, int VS = 1, typename OffsetSimdViewT,
+///           typename PropertyListT = empty_props_t>
+/// simd <T, N> slm_gather(
+///             OffsetSimdViewT byte_offsets,
+///             simd_mask<N / VS> mask, simd<T, N> pass_thru,
+///             PropertyListT props = {});                         // (slm-ga-7)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements. Access to any element's memory location can be disabled via the
+/// input vector of predicates \p mask. If mask[i] is unset, then the load from
+/// (byte_offsets[i]) is skipped and the corresponding i-th element from
+/// \p pass_thru operand is returned.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @tparam VS Vector size. It can also be read as the number of reads per each
+/// address. The parameter 'N' must be divisible by 'VS'. (VS > 1) is supported
+/// only on DG2 and PVC.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// If the alignment property is not passed, then it is assumed that each
+/// accessed address is aligned by element-size.
+/// @param mask The access mask, defaults to all 1s.
+/// @param pass_thru The vector pass through values.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read.
+template <typename T, int N, int VS = 1, typename OffsetSimdViewT,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    detail::is_simd_view_type_v<OffsetSimdViewT> &&
+        ext::oneapi::experimental::is_property_list_v<PropertyListT>,
+    simd<T, N>>
+slm_gather(OffsetSimdViewT byte_offsets, simd_mask<N / VS> mask,
+           simd<T, N> pass_thru, PropertyListT props = {}) {
+  return slm_gather<T, N, VS>(byte_offsets.read(), mask, pass_thru, props);
+}
+
+/// simd <T, N> slm_gather(
+///             OffsetSimdViewT byte_offsets,
+///             simd_mask<N / VS> mask, PropertyListT props = {}); // (slm-ga-8)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements. Access to any element's memory location can be disabled via the
+/// input vector of predicates \p mask. If mask[i] is unset, then the load from
+/// (byte_offsets[i]) is skipped and the corresponding i-th element of the
+/// returned vector is undefined.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @tparam VS Vector size. It can also be read as the number of reads per each
+/// address. The parameter 'N' must be divisible by 'VS'. (VS > 1) is supported
+/// only on DG2 and PVC.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// @param mask The access mask, defaults to all 1s.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// property is used.
+/// @return A vector of elements read. Elements in masked out lanes are
+///   undefined.
+template <typename T, int N, int VS = 1, typename OffsetSimdViewT,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    detail::is_simd_view_type_v<OffsetSimdViewT> &&
+        ext::oneapi::experimental::is_property_list_v<PropertyListT>,
+    simd<T, N>>
+slm_gather(OffsetSimdViewT byte_offsets, simd_mask<N / VS> mask,
+           PropertyListT props = {}) {
+  return slm_gather<T, N, VS>(byte_offsets.read(), mask, props);
+}
+
+/// simd <T, N> slm_gather(
+///             OffsetSimdViewT byte_offsets,
+///             PropertyListT props = {});                         // (slm-ga-9)
+/// Loads ("gathers") elements of the type 'T' from Shared Local Memory
+/// locations addressed by byte offsets \p byte_offsets, and returns the loaded
+/// elements.
+/// @tparam T Element type.
+/// @tparam N Number of elements to read.
+/// @tparam VS Vector size. It can also be read as the number of reads per each
+/// address. The parameter 'N' must be divisible by 'VS'. (VS > 1) is supported
+/// only on DG2 and PVC.
+/// @param byte_offsets the vector of 32-bit offsets in bytes.
+/// For each i, (byte_offsets[i]) must be element size aligned.
+/// @param props The optional compile-time properties. Only 'alignment'
+/// and cache hint properties are used.
+/// @return A vector of elements read.
+template <typename T, int N, int VS = 1, typename OffsetSimdViewT,
+          typename PropertyListT =
+              ext::oneapi::experimental::detail::empty_properties_t>
+__ESIMD_API std::enable_if_t<
+    detail::is_simd_view_type_v<OffsetSimdViewT> &&
+        ext::oneapi::experimental::is_property_list_v<PropertyListT>,
+    simd<T, N>>
+slm_gather(OffsetSimdViewT byte_offsets, PropertyListT props = {}) {
+  return slm_gather<T, N, VS>(byte_offsets.read(), props);
 }
 
 /// Load a scalar value from the Shared Local Memory.
diff --git a/sycl/include/sycl/ext/intel/experimental/esimd/memory.hpp b/sycl/include/sycl/ext/intel/experimental/esimd/memory.hpp
index 2752dd356cef8..069898f14e747 100644
--- a/sycl/include/sycl/ext/intel/experimental/esimd/memory.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/esimd/memory.hpp
@@ -556,20 +556,8 @@ template <typename T, int NElts = 1,
 __ESIMD_API __ESIMD_NS::simd<T, N * NElts>
 lsc_slm_gather(__ESIMD_NS::simd<uint32_t, N> offsets,
                __ESIMD_NS::simd_mask<N> pred = 1) {
-  detail::check_lsc_vector_size<NElts>();
-  detail::check_lsc_data_size<T, DS>();
-  constexpr uint16_t _AddressScale = 1;
-  constexpr int _ImmOffset = 0;
-  constexpr lsc_data_size _DS =
-      detail::expand_data_size(detail::finalize_data_size<T, DS>());
-  constexpr detail::lsc_vector_size _VS = detail::to_lsc_vector_size<NElts>();
-  constexpr auto _Transposed = detail::lsc_data_order::nontranspose;
-  using MsgT = typename detail::lsc_expand_type<T>::type;
-  __ESIMD_NS::simd<MsgT, N * NElts> Tmp =
-      __esimd_lsc_load_slm<MsgT, cache_hint::none, cache_hint::none,
-                           _AddressScale, _ImmOffset, _DS, _VS, _Transposed, N>(
-          pred.data(), offsets.data());
-  return detail::lsc_format_ret<T>(Tmp);
+  __ESIMD_NS::simd<T, N * NElts> pass_thru;
+  return __ESIMD_DNS::slm_gather_impl<T, NElts, DS>(offsets, pred, pass_thru);
 }
 
 /// SLM gather.
@@ -595,24 +583,7 @@ __ESIMD_API __ESIMD_NS::simd<T, N * NElts>
 lsc_slm_gather(__ESIMD_NS::simd<uint32_t, N> offsets,
                __ESIMD_NS::simd_mask<N> pred,
                __ESIMD_NS::simd<T, N * NElts> pass_thru) {
-  detail::check_lsc_vector_size<NElts>();
-  detail::check_lsc_data_size<T, DS>();
-  constexpr uint16_t _AddressScale = 1;
-  constexpr int _ImmOffset = 0;
-  constexpr lsc_data_size _DS =
-      detail::expand_data_size(detail::finalize_data_size<T, DS>());
-  constexpr detail::lsc_vector_size _VS = detail::to_lsc_vector_size<NElts>();
-  constexpr detail::lsc_data_order _Transposed =
-      detail::lsc_data_order::nontranspose;
-  using MsgT = typename detail::lsc_expand_type<T>::type;
-  __ESIMD_NS::simd<MsgT, N * NElts> PassThruExpanded =
-      detail::lsc_format_input<MsgT>(pass_thru);
-  __ESIMD_NS::simd<MsgT, N * NElts> Result =
-      __esimd_lsc_load_merge_slm<MsgT, cache_hint::none, cache_hint::none,
-                                 _AddressScale, _ImmOffset, _DS, _VS,
-                                 _Transposed, N>(pred.data(), offsets.data(),
-                                                 PassThruExpanded.data());
-  return detail::lsc_format_ret<T>(Result);
+  return __ESIMD_DNS::slm_gather_impl<T, NElts, DS>(offsets, pred, pass_thru);
 }
 
 /// Transposed SLM gather with 1 channel.
diff --git a/sycl/include/sycl/ext/oneapi/bfloat16.hpp b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
index 5902be2613749..7ff30b9438f9d 100644
--- a/sycl/include/sycl/ext/oneapi/bfloat16.hpp
+++ b/sycl/include/sycl/ext/oneapi/bfloat16.hpp
@@ -9,7 +9,6 @@
 #pragma once
 
 #include <sycl/aliases.hpp>                   // for half
-#include <sycl/builtins.hpp>                  // for isnan
 #include <sycl/detail/defines_elementary.hpp> // for __DPCPP_SYCL_EXTERNAL
 #include <sycl/half_type.hpp>                 // for half
 
@@ -22,6 +21,13 @@ __devicelib_ConvertBF16ToFINTEL(const uint16_t &) noexcept;
 
 namespace sycl {
 inline namespace _V1 {
+
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+// forward declaration of sycl::isnan built-in.
+// extern __DPCPP_SYCL_EXTERNAL bool isnan(float a);
+bool isnan(float a);
+#endif
+
 namespace ext::oneapi {
 
 class bfloat16;
@@ -30,9 +36,31 @@ namespace detail {
 using Bfloat16StorageT = uint16_t;
 Bfloat16StorageT bfloat16ToBits(const bfloat16 &Value);
 bfloat16 bitsToBfloat16(const Bfloat16StorageT Value);
+
+// sycl::vec support
+namespace bf16 {
+#ifdef __SYCL_DEVICE_ONLY__
+using Vec2StorageT = Bfloat16StorageT __attribute__((ext_vector_type(2)));
+using Vec3StorageT = Bfloat16StorageT __attribute__((ext_vector_type(3)));
+using Vec4StorageT = Bfloat16StorageT __attribute__((ext_vector_type(4)));
+using Vec8StorageT = Bfloat16StorageT __attribute__((ext_vector_type(8)));
+using Vec16StorageT = Bfloat16StorageT __attribute__((ext_vector_type(16)));
+#else
+using Vec2StorageT = std::array<Bfloat16StorageT, 2>;
+using Vec3StorageT = std::array<Bfloat16StorageT, 3>;
+using Vec4StorageT = std::array<Bfloat16StorageT, 4>;
+using Vec8StorageT = std::array<Bfloat16StorageT, 8>;
+using Vec16StorageT = std::array<Bfloat16StorageT, 16>;
+#endif
+} // namespace bf16
+
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+inline bool float_is_nan(float x) { return x != x; }
+#endif
 } // namespace detail
 
 class bfloat16 {
+protected:
   detail::Bfloat16StorageT value;
 
   friend inline detail::Bfloat16StorageT
@@ -42,13 +70,21 @@ class bfloat16 {
 
 public:
   bfloat16() = default;
-  bfloat16(const bfloat16 &) = default;
+  constexpr bfloat16(const bfloat16 &) = default;
+  constexpr bfloat16(bfloat16 &&) = default;
+  constexpr bfloat16 &operator=(const bfloat16 &rhs) = default;
   ~bfloat16() = default;
 
 private:
   static detail::Bfloat16StorageT from_float_fallback(const float &a) {
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
     if (sycl::isnan(a))
       return 0xffc1;
+#else
+    if (detail::float_is_nan(a))
+      return 0xffc1;
+#endif
+
     union {
       uint32_t intStorage;
       float floatValue;
@@ -92,6 +128,14 @@ class bfloat16 {
 #endif
   }
 
+protected:
+  friend class sycl::vec<bfloat16, 1>;
+  friend class sycl::vec<bfloat16, 2>;
+  friend class sycl::vec<bfloat16, 3>;
+  friend class sycl::vec<bfloat16, 4>;
+  friend class sycl::vec<bfloat16, 8>;
+  friend class sycl::vec<bfloat16, 16>;
+
 public:
   // Implicit conversion from float to bfloat16
   bfloat16(const float &a) { value = from_float(a); }
@@ -128,7 +172,7 @@ class bfloat16 {
 #elif defined(__SYCL_DEVICE_ONLY__) && defined(__SPIR__)
     return bfloat16{-__devicelib_ConvertBF16ToFINTEL(lhs.value)};
 #else
-    return -to_float(lhs.value);
+    return bfloat16{-to_float(lhs.value)};
 #endif
   }
 
@@ -199,6 +243,19 @@ class bfloat16 {
 
   // Bitwise(|,&,~,^), modulo(%) and shift(<<,>>) operations are not supported
   // for floating-point types.
+
+  // Stream Operator << and >>
+  inline friend std::ostream &operator<<(std::ostream &O, bfloat16 const &rhs) {
+    O << static_cast<float>(rhs);
+    return O;
+  }
+
+  inline friend std::istream &operator>>(std::istream &I, bfloat16 &rhs) {
+    float ValFloat = 0.0f;
+    I >> ValFloat;
+    rhs = ValFloat;
+    return I;
+  }
 };
 
 namespace detail {
diff --git a/sycl/include/sycl/ext/oneapi/experimental/graph.hpp b/sycl/include/sycl/ext/oneapi/experimental/graph.hpp
index 861f37c890b65..f660960c500a0 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/graph.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/graph.hpp
@@ -342,6 +342,9 @@ class command_graph : public detail::modifiable_command_graph {
   /// @param Impl Detail implementation class to construct object with.
   command_graph(const std::shared_ptr<detail::graph_impl> &Impl)
       : modifiable_command_graph(Impl) {}
+
+  template <class T>
+  friend T sycl::detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
 };
 
 template <>
diff --git a/sycl/include/sycl/ext/oneapi/matrix/matrix-unified-utils.hpp b/sycl/include/sycl/ext/oneapi/matrix/matrix-unified-utils.hpp
index 1e982f6fc10a3..10a8cf4593e71 100644
--- a/sycl/include/sycl/ext/oneapi/matrix/matrix-unified-utils.hpp
+++ b/sycl/include/sycl/ext/oneapi/matrix/matrix-unified-utils.hpp
@@ -7,6 +7,10 @@
 // ===--------------------------------------------------------------------=== //
 
 #pragma once
+
+#include <CL/__spirv/spirv_types.hpp> // __spv namespace
+#include <optional>                   // std::optional
+
 namespace sycl {
 inline namespace _V1 {
 namespace ext {
diff --git a/sycl/include/sycl/group_algorithm.hpp b/sycl/include/sycl/group_algorithm.hpp
index d22e3196e9809..6f7f14feb6e39 100644
--- a/sycl/include/sycl/group_algorithm.hpp
+++ b/sycl/include/sycl/group_algorithm.hpp
@@ -116,14 +116,19 @@ template <typename T, typename BinaryOperation> struct is_native_op {
 // ---- is_plus
 template <typename T, typename BinaryOperation>
 using is_plus = std::integral_constant<
-    bool, std::is_same_v<BinaryOperation, sycl::plus<T>> ||
-              std::is_same_v<BinaryOperation, sycl::plus<void>>>;
+    bool,
+    std::is_same_v<BinaryOperation, sycl::plus<std::remove_const_t<T>>> ||
+        std::is_same_v<BinaryOperation, sycl::plus<std::add_const_t<T>>> ||
+        std::is_same_v<BinaryOperation, sycl::plus<void>>>;
 
 // ---- is_multiplies
 template <typename T, typename BinaryOperation>
 using is_multiplies = std::integral_constant<
-    bool, std::is_same_v<BinaryOperation, sycl::multiplies<T>> ||
-              std::is_same_v<BinaryOperation, sycl::multiplies<void>>>;
+    bool,
+    std::is_same_v<BinaryOperation, sycl::multiplies<std::remove_const_t<T>>> ||
+        std::is_same_v<BinaryOperation,
+                       sycl::multiplies<std::add_const_t<T>>> ||
+        std::is_same_v<BinaryOperation, sycl::multiplies<void>>>;
 
 // ---- is_complex
 // Use SFINAE so that the "true" branch could be implemented in
@@ -134,9 +139,9 @@ struct is_complex : public std::false_type {};
 
 // ---- is_arithmetic_or_complex
 template <typename T>
-using is_arithmetic_or_complex = std::integral_constant<
-    bool, sycl::detail::is_complex<typename std::remove_cv_t<T>>::value ||
-              sycl::detail::is_arithmetic<T>::value>;
+using is_arithmetic_or_complex =
+    std::integral_constant<bool, sycl::detail::is_complex<T>::value ||
+                                     sycl::detail::is_arithmetic<T>::value>;
 
 template <typename T>
 struct is_vector_arithmetic_or_complex
diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp
index 23008e75b80fb..4706639127022 100644
--- a/sycl/include/sycl/queue.hpp
+++ b/sycl/include/sycl/queue.hpp
@@ -34,7 +34,7 @@
 #include <sycl/ext/oneapi/bindless_images_memory.hpp>  // for image_mem_handle
 #include <sycl/ext/oneapi/device_global/device_global.hpp> // for device_global
 #include <sycl/ext/oneapi/device_global/properties.hpp> // for device_image_s...
-#include <sycl/ext/oneapi/experimental/graph.hpp>       // for graph_state
+#include <sycl/ext/oneapi/experimental/graph.hpp>       // for command_graph...
 #include <sycl/ext/oneapi/properties/properties.hpp>    // for empty_properti...
 #include <sycl/handler.hpp>                             // for handler, isDev...
 #include <sycl/id.hpp>                                  // for id
@@ -315,6 +315,11 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
   /// \return State the queue is currently in.
   ext::oneapi::experimental::queue_state ext_oneapi_get_state() const;
 
+  /// \return Graph when the queue is recording.
+  ext::oneapi::experimental::command_graph<
+      ext::oneapi::experimental::graph_state::modifiable>
+  ext_oneapi_get_graph() const;
+
   /// \return true if this queue is a SYCL host queue.
   __SYCL2020_DEPRECATED(
       "is_host() is deprecated as the host device is no longer supported.")
@@ -356,11 +361,9 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
       }
     };
 
-    auto Event = submit_impl_and_postprocess(CGF, CodeLoc, PostProcess);
-    return discard_or_return(Event);
+    return submit_impl_and_postprocess(CGF, CodeLoc, PostProcess);
 #else
-    auto Event = submit_impl(CGF, CodeLoc);
-    return discard_or_return(Event);
+    return submit_impl(CGF, CodeLoc);
 #endif // __SYCL_USE_FALLBACK_ASSERT
   }
 
@@ -395,12 +398,10 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
       }
     };
 
-    auto Event =
-        submit_impl_and_postprocess(CGF, SecondaryQueue, CodeLoc, PostProcess);
-    return discard_or_return(Event);
+    return submit_impl_and_postprocess(CGF, SecondaryQueue, CodeLoc,
+                                       PostProcess);
 #else
-    auto Event = submit_impl(CGF, SecondaryQueue, CodeLoc);
-    return discard_or_return(Event);
+    return submit_impl(CGF, SecondaryQueue, CodeLoc);
 #endif // __SYCL_USE_FALLBACK_ASSERT
   }
 
@@ -2814,6 +2815,7 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
 
   /// Checks if the event needs to be discarded and if so, discards it and
   /// returns a discarded event. Otherwise, it returns input event.
+  /// TODO: move to impl class in the next ABI Breaking window
   event discard_or_return(const event &Event);
 
   // Function to postprocess submitted command
diff --git a/sycl/include/sycl/stl_wrappers/complex b/sycl/include/sycl/stl_wrappers/complex
index 6ed159eca7c5a..281dac2aabde5 100644
--- a/sycl/include/sycl/stl_wrappers/complex
+++ b/sycl/include/sycl/stl_wrappers/complex
@@ -93,9 +93,9 @@ struct isComplex<T, std::enable_if_t<std::is_same_v<T, std::complex<float>> ||
 
 // NOTE: std::complex<long double> not yet supported by group algorithms.
 template <typename T>
-struct is_complex<T, std::enable_if_t<std::is_same_v<T, std::complex<half>> ||
-                                      std::is_same_v<T, std::complex<float>> ||
-                                      std::is_same_v<T, std::complex<double>>>>
+struct is_complex<T, std::enable_if_t<std::is_same_v<std::remove_cv_t<T>, std::complex<half>> ||
+                                      std::is_same_v<std::remove_cv_t<T>, std::complex<float>> ||
+                                      std::is_same_v<std::remove_cv_t<T>, std::complex<double>>>>
     : public std::true_type {};
 
 #ifdef __SYCL_DEVICE_ONLY__
diff --git a/sycl/include/sycl/stream.hpp b/sycl/include/sycl/stream.hpp
index dd79bd532cc62..c9083184fbb06 100644
--- a/sycl/include/sycl/stream.hpp
+++ b/sycl/include/sycl/stream.hpp
@@ -20,6 +20,7 @@
 #include <sycl/detail/export.hpp>             // for __SYCL_EXPORT
 #include <sycl/detail/item_base.hpp>          // for id, range
 #include <sycl/detail/owner_less_base.hpp>    // for OwnerLessBase
+#include <sycl/ext/oneapi/bfloat16.hpp>       // for bfloat16
 #include <sycl/group.hpp>                     // for group
 #include <sycl/h_item.hpp>                    // for h_item
 #include <sycl/half_type.hpp>                 // for half, operator-, operator<
@@ -83,10 +84,8 @@ constexpr size_t MAX_ARRAY_SIZE =
 constexpr unsigned FLUSH_BUF_OFFSET_SIZE = 2;
 
 template <class F, class T = void>
-using EnableIfFP = typename std::enable_if_t<std::is_same_v<F, float> ||
-                                                 std::is_same_v<F, double> ||
-                                                 std::is_same_v<F, half>,
-                                             T>;
+using EnableIfFP = typename std::enable_if_t<
+    detail::check_type_in_v<F, float, double, half, ext::oneapi::bfloat16>, T>;
 
 using GlobalBufAccessorT = accessor<char, 1, sycl::access::mode::read_write,
                                     sycl::access::target::device>;
@@ -334,9 +333,9 @@ checkForInfNan(char *Buf, T Val) {
     return append(Buf, "nan");
 
   // Extract the sign from the bits
-  const uint16_t Sign = reinterpret_cast<uint16_t &>(Val) & 0x8000;
+  const uint16_t Sign = sycl::bit_cast<uint16_t>(Val) & 0x8000;
   // Extract the exponent from the bits
-  const uint16_t Exp16 = (reinterpret_cast<uint16_t &>(Val) & 0x7c00) >> 10;
+  const uint16_t Exp16 = (sycl::bit_cast<uint16_t>(Val) & 0x7c00) >> 10;
 
   if (Exp16 == 0x1f) {
     if (Sign)
@@ -346,6 +345,26 @@ checkForInfNan(char *Buf, T Val) {
   return 0;
 }
 
+template <typename T>
+inline typename std::enable_if_t<std::is_same_v<T, ext::oneapi::bfloat16>,
+                                 unsigned>
+checkForInfNan(char *Buf, T Val) {
+  if (Val != Val)
+    return append(Buf, "nan");
+
+  // Extract the sign from the bits
+  const uint16_t Sign = sycl::bit_cast<uint16_t>(Val) & 0x8000;
+  // Extract the exponent from the bits
+  const uint16_t Exp16 = (sycl::bit_cast<uint16_t>(Val) & 0x7f80) >> 7;
+
+  if (Exp16 == 0x7f) {
+    if (Sign)
+      return append(Buf, "-inf");
+    return append(Buf, "inf");
+  }
+  return 0;
+}
+
 template <typename T>
 EnableIfFP<T, unsigned> floatingPointToDecStr(T AbsVal, char *Digits,
                                               int Precision, bool IsSci) {
@@ -1053,6 +1072,8 @@ class __SYCL_EXPORT __SYCL_SPECIAL_CLASS __SYCL_TYPE(stream) stream
   friend const stream &operator<<(const stream &, const float &);
   friend const stream &operator<<(const stream &, const double &);
   friend const stream &operator<<(const stream &, const half &);
+  friend const stream &operator<<(const stream &,
+                                  const ext::oneapi::bfloat16 &);
 
   friend const stream &operator<<(const stream &, const stream_manipulator);
 
@@ -1159,6 +1180,14 @@ inline const stream &operator<<(const stream &Out, const half &RHS) {
   return Out;
 }
 
+inline const stream &operator<<(const stream &Out,
+                                const ext::oneapi::bfloat16 &RHS) {
+  detail::writeFloatingPoint<ext::oneapi::bfloat16>(
+      Out.GlobalFlushBuf, Out.FlushBufferSize, Out.WIOffset, Out.get_flags(),
+      Out.get_width(), Out.get_precision(), RHS);
+  return Out;
+}
+
 // Pointer
 
 template <typename ElementType, access::address_space Space,
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 8debd52b8dfd8..a2f934a147c33 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -75,6 +75,8 @@
 #include <sycl/marray.hpp>                     // for __SYCL_BINOP, __SYCL_...
 #include <sycl/multi_ptr.hpp>                  // for multi_ptr
 
+#include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
+
 #include <array>       // for array
 #include <assert.h>    // for assert
 #include <cstddef>     // for size_t, NULL, byte
@@ -142,20 +144,61 @@ using select_apply_cl_t = std::conditional_t<
 template <typename T> struct vec_helper {
   using RetType = T;
   static constexpr RetType get(T value) { return value; }
+  static constexpr RetType set(T value) { return value; }
 };
 template <> struct vec_helper<bool> {
   using RetType = select_apply_cl_t<bool, std::int8_t, std::int16_t,
                                     std::int32_t, std::int64_t>;
   static constexpr RetType get(bool value) { return value; }
+  static constexpr RetType set(bool value) { return value; }
+};
+
+template <> struct vec_helper<sycl::ext::oneapi::bfloat16> {
+  using RetType = sycl::ext::oneapi::bfloat16;
+  using BFloat16StorageT = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  static constexpr RetType get(BFloat16StorageT value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<RetType>(value);
+#else
+    // awkward workaround. sycl::bit_cast isn't constexpr in older GCC
+    // C++20 will give us both std::bit_cast and constexpr reinterpet for void*
+    // but neither available yet.
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.storage = value;
+    return result.bf16;
+#endif
+  }
+
+  static constexpr RetType get(RetType value) { return value; }
+
+  static constexpr BFloat16StorageT set(RetType value) {
+#if defined(__SYCL_BITCAST_IS_CONSTEXPR)
+    return sycl::bit_cast<BFloat16StorageT>(value);
+#else
+    union {
+      sycl::ext::oneapi::bfloat16 bf16;
+      sycl::ext::oneapi::detail::Bfloat16StorageT storage;
+    } result = {};
+    result.bf16 = value;
+    return result.storage;
+#endif
+  }
 };
 
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
 template <> struct vec_helper<std::byte> {
   using RetType = std::uint8_t;
   static constexpr RetType get(std::byte value) { return (RetType)value; }
+  static constexpr RetType set(std::byte value) { return (RetType)value; }
   static constexpr std::byte get(std::uint8_t value) {
     return (std::byte)value;
   }
+  static constexpr std::byte set(std::uint8_t value) {
+    return (std::byte)value;
+  }
 };
 #endif
 
@@ -312,6 +355,9 @@ template <typename Type, int NumElements> class vec {
       std::is_same_v<sycl::detail::half_impl::StorageT,
                      sycl::detail::host_half_impl::half>;
 
+  static constexpr bool IsBfloat16 =
+      std::is_same_v<DataT, sycl::ext::oneapi::bfloat16>;
+
 #if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
   static constexpr size_t AdjustedNum = (NumElements == 3) ? 4 : NumElements;
@@ -325,7 +371,7 @@ template <typename Type, int NumElements> class vec {
   // of 64 for direct params. If we drop MSVC, we can have alignment the same as
   // size and use vector extensions for all sizes.
   static constexpr bool IsUsingArrayOnDevice =
-      (IsHostHalf || IsSizeGreaterThanMaxAlign);
+      (IsHostHalf || IsBfloat16 || IsSizeGreaterThanMaxAlign);
 
 #if defined(__SYCL_DEVICE_ONLY__)
   static constexpr bool NativeVec = NumElements > 1 && !IsUsingArrayOnDevice;
@@ -338,7 +384,7 @@ template <typename Type, int NumElements> class vec {
 #endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
 #if !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-  static constexpr bool IsUsingArrayOnDevice = IsHostHalf;
+  static constexpr bool IsUsingArrayOnDevice = IsHostHalf || IsBfloat16;
 #endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
   static constexpr int getNumElements() { return NumElements; }
@@ -393,11 +439,7 @@ template <typename Type, int NumElements> class vec {
   }
   template <typename DataT_, typename T>
   static constexpr auto FlattenVecArgHelper(const T &A) {
-#if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
     return std::array<DataT_, 1>{vec_data<DataT_>::get(static_cast<DataT_>(A))};
-#else
-    return std::array<DataT_, 1>{vec_data<DataT_>::get(A)};
-#endif
   }
   template <typename DataT_, typename T> struct FlattenVecArg {
     constexpr auto operator()(const T &A) const {
@@ -495,7 +537,12 @@ template <typename Type, int NumElements> class vec {
   template <size_t... Is>
   constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
                 std::index_sequence<Is...>)
-      : m_Data{vec_data_t<DataT>(static_cast<DataT>(Arr[Is]))...} {}
+      : m_Data{([&](vec_data_t<DataT> v) constexpr {
+          if constexpr (std::is_same_v<sycl::ext::oneapi::bfloat16, DataT>)
+            return v.value;
+          else
+            return vec_data_t<DataT>(static_cast<DataT>(v));
+        })(Arr[Is])...} {}
 
 public:
   using element_type = DataT;
@@ -580,7 +627,7 @@ template <typename Type, int NumElements> class vec {
   template <typename Ty = DataT>
   typename std::enable_if_t<
       std::is_fundamental_v<vec_data_t<Ty>> ||
-          std::is_same_v<typename std::remove_const_t<Ty>, half>,
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
   operator=(const EnableIfNotUsingArrayOnDevice<Ty> &Rhs) {
     m_Data = (DataType)vec_data<Ty>::get(Rhs);
@@ -596,7 +643,7 @@ template <typename Type, int NumElements> class vec {
   template <typename Ty = DataT>
   typename std::enable_if_t<
       std::is_fundamental_v<vec_data_t<Ty>> ||
-          std::is_same_v<typename std::remove_const_t<Ty>, half>,
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
   operator=(const EnableIfUsingArrayOnDevice<Ty> &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
@@ -613,7 +660,7 @@ template <typename Type, int NumElements> class vec {
   template <typename Ty = DataT>
   typename std::enable_if_t<
       std::is_fundamental_v<vec_data_t<Ty>> ||
-          std::is_same_v<typename std::remove_const_t<Ty>, half>,
+          detail::is_half_or_bf16_v<typename std::remove_const_t<Ty>>,
       vec &>
   operator=(const DataT &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
@@ -962,7 +1009,7 @@ template <typename Type, int NumElements> class vec {
   typename std::enable_if_t<                                                   \
       std::is_convertible_v<DataT, T> &&                                       \
           (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           std::is_same_v<typename std::remove_const_t<T>, half>),             \
+           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
       vec>                                                                     \
   operator BINOP(const T & Rhs) const {                                        \
     return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
@@ -995,7 +1042,7 @@ template <typename Type, int NumElements> class vec {
   typename std::enable_if_t<                                                   \
       std::is_convertible_v<DataT, T> &&                                       \
           (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           std::is_same_v<typename std::remove_const_t<T>, half>),             \
+           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
       vec>                                                                     \
   operator BINOP(const T & Rhs) const {                                        \
     return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
@@ -1025,7 +1072,7 @@ template <typename Type, int NumElements> class vec {
   typename std::enable_if_t<                                                   \
       std::is_convertible_v<DataT, T> &&                                       \
           (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           std::is_same_v<typename std::remove_const_t<T>, half>),             \
+           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
       vec>                                                                     \
   operator BINOP(const T & Rhs) const {                                        \
     return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
@@ -1098,7 +1145,7 @@ template <typename Type, int NumElements> class vec {
   template <typename T>                                                        \
   typename std::enable_if_t<std::is_convertible_v<T, DataT> &&                 \
                                 (std::is_fundamental_v<vec_data_t<T>> ||       \
-                                 std::is_same_v<T, half>),                     \
+                                 detail::is_half_or_bf16_v<T>),                \
                             vec<rel_t, NumElements>>                           \
   operator RELLOGOP(const T & Rhs) const {                                     \
     return *this RELLOGOP vec(static_cast<const DataT &>(Rhs));                \
@@ -1116,7 +1163,7 @@ template <typename Type, int NumElements> class vec {
   template <typename T>                                                        \
   typename std::enable_if_t<std::is_convertible_v<T, DataT> &&                 \
                                 (std::is_fundamental_v<vec_data_t<T>> ||       \
-                                 std::is_same_v<T, half>),                     \
+                                 detail::is_half_or_bf16_v<T>),                \
                             vec<rel_t, NumElements>>                           \
   operator RELLOGOP(const T & Rhs) const {                                     \
     return *this RELLOGOP vec(static_cast<const DataT &>(Rhs));                \
@@ -1258,17 +1305,47 @@ template <typename Type, int NumElements> class vec {
 
   // operator -
   template <typename T = vec> EnableIfNotUsingArray<T> operator-() const {
-    vec Ret{-m_Data};
-    if constexpr (std::is_same_v<Type, bool>) {
-      Ret.ConvertToDataT();
+    namespace oneapi = sycl::ext::oneapi;
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      vec Ret{};
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      vec Ret{};
+      for (size_t I = 0; I < NumElements; ++I) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+      return Ret;
+    } else {
+      vec Ret{-m_Data};
+      if constexpr (std::is_same_v<Type, bool>) {
+        Ret.ConvertToDataT();
+      }
+      return Ret;
     }
-    return Ret;
   }
 
   template <typename T = vec> EnableIfUsingArray<T> operator-() const {
+    namespace oneapi = sycl::ext::oneapi;
     vec Ret{};
-    for (size_t I = 0; I < NumElements; ++I)
-      Ret.setValue(I, vec_data<DataT>::get(-vec_data<DataT>::get(getValue(I))));
+    if constexpr (IsBfloat16 && NumElements == 1) {
+      oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(m_Data);
+      oneapi::bfloat16 w = -v;
+      Ret.m_Data = oneapi::detail::bfloat16ToBits(w);
+    } else if constexpr (IsBfloat16) {
+      for (size_t I = 0; I < NumElements; I++) {
+        oneapi::bfloat16 v = oneapi::detail::bitsToBfloat16(m_Data[I]);
+        oneapi::bfloat16 w = -v;
+        Ret.m_Data[I] = oneapi::detail::bfloat16ToBits(w);
+      }
+    } else {
+      for (size_t I = 0; I < NumElements; ++I)
+        Ret.setValue(I,
+                     vec_data<DataT>::get(-vec_data<DataT>::get(getValue(I))));
+    }
     return Ret;
   }
 #endif // defined(__INTEL_PREVIEW_BREAKING_CHANGES)
@@ -1376,8 +1453,6 @@ template <typename Type, int NumElements> class vec {
 
 #endif // !defined(__INTEL_PREVIEW_BREAKING_CHANGES)
 
-  // CP ---------------
-
   // OP is: &&, ||
   // vec<RET, NumElements> operatorOP(const vec<DataT, NumElements> &Rhs) const;
   // vec<RET, NumElements> operatorOP(const DataT &Rhs) const;
@@ -1425,13 +1500,13 @@ template <typename Type, int NumElements> class vec {
 
   // setValue and getValue should be able to operate on different underlying
   // types: enum cl_float#N , builtin vector float#N, builtin type float.
-
+  // These versions are for N > 1.
 #ifdef __SYCL_USE_EXT_VECTOR_TYPE__
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
                           int) {
-    m_Data[Index] = vec_data<DataT>::get(Value);
+    m_Data[Index] = vec_data<DataT>::set(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
@@ -1443,7 +1518,7 @@ template <typename Type, int NumElements> class vec {
   template <int Num = NumElements, typename Ty = int,
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
-    m_Data.s[Index] = vec_data<DataT>::get(Value);
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
@@ -1456,9 +1531,9 @@ template <typename Type, int NumElements> class vec {
             typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
 #if defined(__INTEL_PREVIEW_BREAKING_CHANGES)
-    m_Data[Index] = vec_data<DataT>::get(Value);
+    m_Data[Index] = vec_data<DataT>::set(Value);
 #else
-    m_Data.s[Index] = vec_data<DataT>::get(Value);
+    m_Data.s[Index] = vec_data<DataT>::set(Value);
 #endif
   }
 
@@ -1473,10 +1548,11 @@ template <typename Type, int NumElements> class vec {
   }
 #endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
+  // N==1 versions, used by host and device. Shouldn't trailing type be int?
   template <int Num = NumElements,
             typename = typename std::enable_if_t<1 == Num>>
   constexpr void setValue(int, const DataT &Value, float) {
-    m_Data = vec_data<DataT>::get(Value);
+    m_Data = vec_data<DataT>::set(Value);
   }
 
   template <int Num = NumElements,
@@ -1485,6 +1561,9 @@ template <typename Type, int NumElements> class vec {
     return vec_data<DataT>::get(m_Data);
   }
 
+  // setValue and getValue.
+  // The "api" functions used by BINOP etc.  These versions just dispatch
+  // using additional int or float arg to disambiguate vec<1> vs. vec<N>
   // Special proxies as specialization is not allowed in class scope.
   constexpr void setValue(int Index, const DataT &Value) {
     if (NumElements == 1)
@@ -1614,13 +1693,13 @@ class SwizzleOp {
   using EnableIfScalarType = typename std::enable_if_t<
       std::is_convertible_v<DataT, T> &&
       (std::is_fundamental_v<vec_data_t<T>> ||
-       std::is_same_v<typename std::remove_const_t<T>, half>)>;
+       detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
 
   template <typename T>
   using EnableIfNoScalarType = typename std::enable_if_t<
       !std::is_convertible_v<DataT, T> ||
       !(std::is_fundamental_v<vec_data_t<T>> ||
-        std::is_same_v<typename std::remove_const_t<T>, half>)>;
+        detail::is_half_or_bf16_v<typename std::remove_const_t<T>>)>;
 
   template <int... Indices>
   using Swizzle =
@@ -2196,7 +2275,7 @@ class SwizzleOp {
   template <typename T, int Num>                                               \
   typename std::enable_if_t<                                                   \
       std::is_fundamental_v<vec_data_t<T>> ||                                  \
-          std::is_same_v<typename std::remove_const_t<T>, half>,               \
+          detail::is_half_or_bf16_v<typename std::remove_const_t<T>>,          \
       vec<T, Num>>                                                             \
   operator BINOP(const T & Lhs, const vec<T, Num> &Rhs) {                      \
     return vec<T, Num>(Lhs) BINOP Rhs;                                         \
@@ -2208,7 +2287,7 @@ class SwizzleOp {
   typename std::enable_if_t<                                                   \
       std::is_convertible_v<T, T1> &&                                          \
           (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           std::is_same_v<typename std::remove_const_t<T>, half>),             \
+           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
       vec<T1, Num>>                                                            \
   operator BINOP(                                                              \
       const T & Lhs,                                                           \
@@ -2252,7 +2331,7 @@ __SYCL_BINOP(<<)
   typename std::enable_if_t<                                                   \
       std::is_convertible_v<T, DataT> &&                                       \
           (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           std::is_same_v<typename std::remove_const_t<T>, half>),             \
+           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
       vec<detail::rel_t<DataT>, Num>>                                          \
   operator RELLOGOP(const T & Lhs, const vec<DataT, Num> &Rhs) {               \
     return vec<T, Num>(static_cast<T>(Lhs)) RELLOGOP Rhs;                      \
@@ -2264,7 +2343,7 @@ __SYCL_BINOP(<<)
   typename std::enable_if_t<                                                   \
       std::is_convertible_v<T, T1> &&                                          \
           (std::is_fundamental_v<vec_data_t<T>> ||                             \
-           std::is_same_v<typename std::remove_const_t<T>, half>),             \
+           detail::is_half_or_bf16_v<typename std::remove_const_t<T>>),        \
       vec<detail::rel_t<T1>, Num>>                                             \
   operator RELLOGOP(                                                           \
       const T & Lhs,                                                           \
@@ -2440,10 +2519,11 @@ struct VecStorage<T, 1, typename std::enable_if_t<is_sugeninteger_v<T>>> {
 #endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
 
-// Single element floating-point (except half)
+// Single element floating-point (except half/bfloat16)
 template <typename T>
 struct VecStorage<
-    T, 1, typename std::enable_if_t<!is_half_v<T> && is_sgenfloat_v<T>>> {
+    T, 1,
+    typename std::enable_if_t<!is_half_or_bf16_v<T> && is_sgenfloat_v<T>>> {
   using DataType = T;
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
 #ifdef __SYCL_DEVICE_ONLY__
@@ -2451,13 +2531,14 @@ struct VecStorage<
 #endif // __SYCL_DEVICE_ONLY__
 #endif // __INTEL_PREVIEW_BREAKING_CHANGES
 };
-// Multiple elements signed/unsigned integers and floating-point (except half)
+// Multiple elements signed/unsigned integers and floating-point (except
+// half/bfloat16)
 template <typename T, int N>
 struct VecStorage<
     T, N,
     typename std::enable_if_t<isValidVectorSize(N) &&
                               (is_sgeninteger_v<T> ||
-                               (is_sgenfloat_v<T> && !is_half_v<T>))>> {
+                               (is_sgenfloat_v<T> && !is_half_or_bf16_v<T>))>> {
   using DataType =
       typename VecStorageImpl<typename VecStorage<T, 1>::DataType, N>::DataType;
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
@@ -2501,6 +2582,26 @@ __SYCL_DEFINE_HALF_VECSTORAGE(4)
 __SYCL_DEFINE_HALF_VECSTORAGE(8)
 __SYCL_DEFINE_HALF_VECSTORAGE(16)
 #undef __SYCL_DEFINE_HALF_VECSTORAGE
+
+// Single element bfloat16
+template <> struct VecStorage<sycl::ext::oneapi::bfloat16, 1, void> {
+  using DataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+  // using VectorDataType = sycl::ext::oneapi::bfloat16;
+  using VectorDataType = sycl::ext::oneapi::detail::Bfloat16StorageT;
+};
+// Multiple elements bfloat16
+#define __SYCL_DEFINE_BF16_VECSTORAGE(Num)                                     \
+  template <> struct VecStorage<sycl::ext::oneapi::bfloat16, Num, void> {      \
+    using DataType = sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;      \
+    using VectorDataType =                                                     \
+        sycl::ext::oneapi::detail::bf16::Vec##Num##StorageT;                   \
+  };
+__SYCL_DEFINE_BF16_VECSTORAGE(2)
+__SYCL_DEFINE_BF16_VECSTORAGE(3)
+__SYCL_DEFINE_BF16_VECSTORAGE(4)
+__SYCL_DEFINE_BF16_VECSTORAGE(8)
+__SYCL_DEFINE_BF16_VECSTORAGE(16)
+#undef __SYCL_DEFINE_BF16_VECSTORAGE
 } // namespace detail
 
 /// This macro must be defined to 1 when SYCL implementation allows user
diff --git a/sycl/pi_win_proxy_loader/CMakeLists.txt b/sycl/pi_win_proxy_loader/CMakeLists.txt
index 202817dde4813..297a9dcd59598 100644
--- a/sycl/pi_win_proxy_loader/CMakeLists.txt
+++ b/sycl/pi_win_proxy_loader/CMakeLists.txt
@@ -58,6 +58,10 @@ if (MSVC)
   target_compile_options(pi_win_proxy_loader PRIVATE ${WINUNLOAD_CXX_FLAGS_RELEASE})
   target_link_libraries(pi_win_proxy_loaderd PRIVATE shlwapi)
   target_link_libraries(pi_win_proxy_loader PRIVATE shlwapi)
+  # 0x2000: LOAD_LIBRARY_SAFE_CURRENT_DIRS flag. Using this flag means that loading dependency DLLs
+  # from the current directory is only allowed if it is under a directory in the Safe load list.
+  target_link_options(pi_win_proxy_loaderd PRIVATE /DEPENDENTLOADFLAG:0x2000)
+  target_link_options(pi_win_proxy_loader PRIVATE /DEPENDENTLOADFLAG:0x2000)
   install(TARGETS pi_win_proxy_loaderd
           RUNTIME DESTINATION "bin" COMPONENT pi_win_proxy_loader)
 endif()
diff --git a/sycl/pi_win_proxy_loader/pi_win_proxy_loader.cpp b/sycl/pi_win_proxy_loader/pi_win_proxy_loader.cpp
index 53f59b1b18f80..6d039e4314fa5 100644
--- a/sycl/pi_win_proxy_loader/pi_win_proxy_loader.cpp
+++ b/sycl/pi_win_proxy_loader/pi_win_proxy_loader.cpp
@@ -24,6 +24,7 @@
 
 #include <cassert>
 #include <filesystem>
+#include <system_error>
 
 #ifdef _WIN32
 
@@ -165,8 +166,24 @@ __declspec(dllexport) void *getPreloadedPlugin(
 
   MapT &dllMap = getDllMap();
 
-  auto match = dllMap.find(PluginPath); // result might be nullptr (not found),
-                                        // which is perfectly valid.
+  // All entries in the dllMap have the same parent directory.
+  // To avoid case sensivity issues, we don't want to do string comparison but
+  // just make sure that directory of the entires in the map and directory of
+  // the PluginPath are equivalent (point to the same physical location).
+  auto match = dllMap.end();
+  std::error_code ec;
+  if (!dllMap.empty() &&
+      std::filesystem::equivalent((dllMap.begin())->first.parent_path(),
+                                  PluginPath.parent_path(), ec)) {
+    // Now we can search only by filename. Result might be nullptr (not found),
+    // which is perfectly valid.
+    match =
+        std::find_if(dllMap.begin(), dllMap.end(),
+                     [&](const std::pair<std::filesystem::path, void *> &v) {
+                       return v.first.filename() == PluginPath.filename();
+                     });
+  }
+
   if (match == dllMap.end()) {
     // unit testing? return nullptr (not found) rather than risk asserting below
     if (PluginPath.string().find("unittests") != std::string::npos)
diff --git a/sycl/plugins/native_cpu/pi_native_cpu.cpp b/sycl/plugins/native_cpu/pi_native_cpu.cpp
index 7978c897e74f3..dd31b38dd0fea 100644
--- a/sycl/plugins/native_cpu/pi_native_cpu.cpp
+++ b/sycl/plugins/native_cpu/pi_native_cpu.cpp
@@ -1220,6 +1220,27 @@ pi_result piextPeerAccessGetInfo(pi_device command_device,
                                        ParamValueSizeRet);
 }
 
+pi_result piextCommandBufferMemBufferFill(
+    pi_ext_command_buffer CommandBuffer, pi_mem Buffer, const void *Pattern,
+    size_t PatternSize, size_t Offset, size_t Size,
+    pi_uint32 NumSyncPointsInWaitList,
+    const pi_ext_sync_point *SyncPointWaitList, pi_ext_sync_point *SyncPoint) {
+  return pi2ur::piextCommandBufferMemBufferFill(
+      CommandBuffer, Buffer, Pattern, PatternSize, Offset, Size,
+      NumSyncPointsInWaitList, SyncPointWaitList, SyncPoint);
+}
+
+pi_result piextCommandBufferFillUSM(pi_ext_command_buffer CommandBuffer,
+                                    void *Ptr, const void *Pattern,
+                                    size_t PatternSize, size_t Size,
+                                    pi_uint32 NumSyncPointsInWaitList,
+                                    const pi_ext_sync_point *SyncPointWaitList,
+                                    pi_ext_sync_point *SyncPoint) {
+  return pi2ur::piextCommandBufferFillUSM(
+      CommandBuffer, Ptr, Pattern, PatternSize, Size, NumSyncPointsInWaitList,
+      SyncPointWaitList, SyncPoint);
+}
+
 pi_result piextCommandBufferPrefetchUSM(
     pi_ext_command_buffer CommandBuffer, const void *Ptr, size_t Size,
     pi_usm_migration_flags Flags, pi_uint32 NumSyncPointsInWaitList,
diff --git a/sycl/source/CMakeLists.txt b/sycl/source/CMakeLists.txt
index ddaa85f1a8dcb..d5789be86bde9 100644
--- a/sycl/source/CMakeLists.txt
+++ b/sycl/source/CMakeLists.txt
@@ -75,10 +75,16 @@ function(add_sycl_rt_library LIB_NAME LIB_OBJ_NAME)
   if (WIN32)
     include_directories(${LLVM_EXTERNAL_SYCL_SOURCE_DIR}/pi_win_proxy_loader)
     if(WIN_DUPE)
-      target_link_libraries(${LIB_NAME} PUBLIC pi_win_proxy_loaderd)
-    else()
-      target_link_libraries(${LIB_NAME} PUBLIC pi_win_proxy_loader)
-    endif()
+    target_link_libraries(${LIB_NAME} PUBLIC pi_win_proxy_loaderd)
+      set(MANIFEST_FILE_NAME "sycld.manifest")
+  else()
+    target_link_libraries(${LIB_NAME} PUBLIC pi_win_proxy_loader)
+      set(MANIFEST_FILE_NAME "sycl.manifest")
+  endif()
+    # Embed manifest into the sycl.dll where pi_win_proxy_loader.dll is described as sycl.dll's private dll and will always be loaded from the same directory.
+    # 0x2000: LOAD_LIBRARY_SAFE_CURRENT_DIRS flag. Using this flag means that loading dependency DLLs (of sycl.dll)
+    # from the current directory is only allowed if it is under a directory in the Safe load list.
+    target_link_options(${LIB_NAME} PRIVATE /DEPENDENTLOADFLAG:0x2000 /MANIFEST:NO /MANIFEST:EMBED /MANIFESTINPUT:${CMAKE_CURRENT_SOURCE_DIR}/${MANIFEST_FILE_NAME})
   endif()
 
   target_compile_definitions(${LIB_OBJ_NAME} PRIVATE __SYCL_INTERNAL_API )
diff --git a/sycl/source/detail/config.cpp b/sycl/source/detail/config.cpp
index 83207b5a95873..f7760aa227168 100644
--- a/sycl/source/detail/config.cpp
+++ b/sycl/source/detail/config.cpp
@@ -161,8 +161,9 @@ void dumpConfig() {
 #undef CONFIG
 }
 
-// Array is used by SYCL_DEVICE_FILTER and SYCL_DEVICE_ALLOWLIST and
-// ONEAPI_DEVICE_SELECTOR
+// Array is used by SYCL_DEVICE_ALLOWLIST and ONEAPI_DEVICE_SELECTOR.
+// TODO: host device type will be removed once sycl_ext_oneapi_filter_selector
+// is removed.
 const std::array<std::pair<std::string, info::device_type>, 6> &
 getSyclDeviceTypeMap() {
   static const std::array<std::pair<std::string, info::device_type>, 6>
@@ -178,6 +179,8 @@ getSyclDeviceTypeMap() {
 // Array is used by SYCL_DEVICE_FILTER and SYCL_DEVICE_ALLOWLIST and
 // ONEAPI_DEVICE_SELECTOR
 // TODO: Remove esimd_emulator in the next ABI breaking window.
+// TODO: host device type will be removed once sycl_ext_oneapi_filter_selector
+// is removed.
 const std::array<std::pair<std::string, backend>, 8> &getSyclBeMap() {
   static const std::array<std::pair<std::string, backend>, 8> SyclBeMap = {
       {{"host", backend::host},
diff --git a/sycl/source/detail/config.def b/sycl/source/detail/config.def
index 33d43934c66eb..6062e59ad0490 100644
--- a/sycl/source/detail/config.def
+++ b/sycl/source/detail/config.def
@@ -19,7 +19,9 @@ CONFIG(SYCL_PARALLEL_FOR_RANGE_ROUNDING_TRACE, 16, __SYCL_PARALLEL_FOR_RANGE_ROU
 CONFIG(SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING, 16, __SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING)
 CONFIG(SYCL_PARALLEL_FOR_RANGE_ROUNDING_PARAMS, 64, __SYCL_PARALLEL_FOR_RANGE_ROUNDING_PARAMS)
 CONFIG(SYCL_DEVICELIB_NO_FALLBACK, 1, __SYCL_DEVICELIB_NO_FALLBACK)
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 CONFIG(SYCL_DEVICE_FILTER, 1024, __SYCL_DEVICE_FILTER)
+#endif
 CONFIG(SYCL_PROGRAM_LINK_OPTIONS, 64, __SYCL_PROGRAM_LINK_OPTIONS)
 CONFIG(SYCL_PROGRAM_COMPILE_OPTIONS, 64, __SYCL_PROGRAM_COMPILE_OPTIONS)
 CONFIG(SYCL_PROGRAM_APPEND_LINK_OPTIONS, 64, __SYCL_PROGRAM_APPEND_LINK_OPTIONS)
diff --git a/sycl/source/detail/config.hpp b/sycl/source/detail/config.hpp
index 92a1683643e6a..8f048e0f95f60 100644
--- a/sycl/source/detail/config.hpp
+++ b/sycl/source/detail/config.hpp
@@ -231,8 +231,7 @@ template <> class SYCLConfig<SYCL_PARALLEL_FOR_RANGE_ROUNDING_PARAMS> {
   }
 };
 
-// Array is used by SYCL_DEVICE_FILTER and SYCL_DEVICE_ALLOWLIST and
-// ONEAPI_DEVICE_SELECTOR
+// Array is used by SYCL_DEVICE_ALLOWLIST and ONEAPI_DEVICE_SELECTOR.
 const std::array<std::pair<std::string, info::device_type>, 6> &
 getSyclDeviceTypeMap();
 
@@ -265,6 +264,7 @@ template <> class SYCLConfig<ONEAPI_DEVICE_SELECTOR> {
   }
 };
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 // ---------------------------------------
 // SYCL_DEVICE_FILTER support
 
@@ -306,6 +306,7 @@ class __SYCL2020_DEPRECATED("Use SYCLConfig<ONEAPI_DEVICE_SELECTOR> instead")
     return FilterList;
   }
 };
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
 template <> class SYCLConfig<SYCL_ENABLE_DEFAULT_CONTEXTS> {
   using BaseT = SYCLConfigBase<SYCL_ENABLE_DEFAULT_CONTEXTS>;
diff --git a/sycl/source/detail/device_filter.cpp b/sycl/source/detail/device_filter.cpp
index 68ca2d54c6278..311ebeaa174b8 100644
--- a/sycl/source/detail/device_filter.cpp
+++ b/sycl/source/detail/device_filter.cpp
@@ -288,7 +288,7 @@ ods_target_list::ods_target_list(const std::string &envStr) {
   TargetList = Parse_ONEAPI_DEVICE_SELECTOR(envStr);
 }
 
-// Backend is compatible with the SYCL_DEVICE_FILTER in the following cases.
+// Backend is compatible with the ONEAPI_DEVICE_SELECTOR in the following cases.
 // 1. Filter backend is '*' which means ANY backend.
 // 2. Filter backend match exactly with the given 'Backend'
 bool ods_target_list::backendCompatible(backend Backend) {
@@ -300,6 +300,7 @@ bool ods_target_list::backendCompatible(backend Backend) {
       });
 }
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 // ---------------------------------------
 // SYCL_DEVICE_FILTER support
 
@@ -424,6 +425,7 @@ bool device_filter_list::deviceNumberCompatible(int DeviceNum) {
         return (!Filter.DeviceNum) || (Filter.DeviceNum.value() == DeviceNum);
       });
 }
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
 
 } // namespace detail
 } // namespace _V1
diff --git a/sycl/source/detail/filter_selector_impl.hpp b/sycl/source/detail/filter_selector_impl.hpp
index 560a46524a1d6..a5da10f912ab3 100644
--- a/sycl/source/detail/filter_selector_impl.hpp
+++ b/sycl/source/detail/filter_selector_impl.hpp
@@ -23,7 +23,11 @@ namespace ext {
 namespace oneapi {
 namespace detail {
 
+#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
+typedef struct sycl::detail::ods_target filter;
+#else
 typedef struct sycl::detail::device_filter filter;
+#endif
 
 class filter_selector_impl {
 public:
diff --git a/sycl/source/detail/global_handler.cpp b/sycl/source/detail/global_handler.cpp
index ee4e4ca8ac104..d0bdfb9e971f9 100644
--- a/sycl/source/detail/global_handler.cpp
+++ b/sycl/source/detail/global_handler.cpp
@@ -202,10 +202,13 @@ std::vector<PluginPtr> &GlobalHandler::getPlugins() {
   enableOnCrashStackPrinting();
   return getOrCreate(MPlugins);
 }
+
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 device_filter_list &
 GlobalHandler::getDeviceFilterList(const std::string &InitValue) {
   return getOrCreate(MDeviceFilterList, InitValue);
 }
+#endif
 
 ods_target_list &
 GlobalHandler::getOneapiDeviceSelectorTargets(const std::string &InitValue) {
diff --git a/sycl/source/detail/global_handler.hpp b/sycl/source/detail/global_handler.hpp
index 5145a64f9c310..be19141335bda 100644
--- a/sycl/source/detail/global_handler.hpp
+++ b/sycl/source/detail/global_handler.hpp
@@ -23,7 +23,9 @@ class Scheduler;
 class ProgramManager;
 class Sync;
 class plugin;
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 class device_filter_list;
+#endif
 class ods_target_list;
 class XPTIRegistry;
 class ThreadPool;
@@ -70,7 +72,9 @@ class GlobalHandler {
   std::mutex &getPlatformMapMutex();
   std::mutex &getFilterMutex();
   std::vector<PluginPtr> &getPlugins();
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   device_filter_list &getDeviceFilterList(const std::string &InitValue);
+#endif
   ods_target_list &getOneapiDeviceSelectorTargets(const std::string &InitValue);
   XPTIRegistry &getXPTIRegistry();
   ThreadPool &getHostTaskThreadPool();
@@ -121,7 +125,9 @@ class GlobalHandler {
   InstWithLock<std::mutex> MPlatformMapMutex;
   InstWithLock<std::mutex> MFilterMutex;
   InstWithLock<std::vector<PluginPtr>> MPlugins;
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   InstWithLock<device_filter_list> MDeviceFilterList;
+#endif
   InstWithLock<ods_target_list> MOneapiDeviceSelectorTargets;
   InstWithLock<XPTIRegistry> MXPTIRegistry;
   // Thread pool for host task and event callbacks execution
diff --git a/sycl/source/detail/helpers.cpp b/sycl/source/detail/helpers.cpp
index 4103653d236a7..222b06127207d 100644
--- a/sycl/source/detail/helpers.cpp
+++ b/sycl/source/detail/helpers.cpp
@@ -21,6 +21,8 @@ namespace sycl {
 inline namespace _V1 {
 using ContextImplPtr = std::shared_ptr<sycl::detail::context_impl>;
 namespace detail {
+// TODO: remove from public header files and implementation during the next ABI
+// Breaking window. Not used any more.
 std::vector<sycl::detail::pi::PiEvent>
 getOrWaitEvents(std::vector<sycl::event> DepEvents, ContextImplPtr Context) {
   std::vector<sycl::detail::pi::PiEvent> Events;
diff --git a/sycl/source/detail/jit_compiler.cpp b/sycl/source/detail/jit_compiler.cpp
index 46b907060c018..a053c57db0c34 100644
--- a/sycl/source/detail/jit_compiler.cpp
+++ b/sycl/source/detail/jit_compiler.cpp
@@ -440,7 +440,7 @@ static ParamIterator preProcessArguments(
     std::vector<::jit_compiler::ParameterInternalization> &InternalizeParams,
     std::vector<::jit_compiler::JITConstant> &JITConstants,
     ParamList &NonIdenticalParams,
-    ::jit_compiler::ParamIdentList &ParamIdentities) {
+    std::vector<::jit_compiler::ParameterIdentity> &ParamIdentities) {
 
   // Unused arguments are still in the list at this point (because we
   // need them for accessor handling), but there's not pre-processing
@@ -806,7 +806,7 @@ jit_compiler::fuseKernels(QueueImplPtr Queue,
   // can be constant-propagated by the JIT compiler.
   std::vector<::jit_compiler::ParameterInternalization> InternalizeParams;
   std::vector<::jit_compiler::JITConstant> JITConstants;
-  ::jit_compiler::ParamIdentList ParamIdentities;
+  std::vector<::jit_compiler::ParameterIdentity> ParamIdentities;
   ParamList NonIdenticalParameters;
   for (auto PI = FusedParams.begin(); PI != FusedParams.end();) {
     PI = preProcessArguments(ArgsStorage, PI, PromotedAccs, InternalizeParams,
@@ -836,9 +836,10 @@ jit_compiler::fuseKernels(QueueImplPtr Queue,
   ::jit_compiler::KernelFusion::set<::jit_compiler::option::JITTargetInfo>(
       std::move(TargetInfo));
 
+  using ::jit_compiler::View;
   auto FusionResult = ::jit_compiler::KernelFusion::fuseKernels(
-      InputKernelInfo, FusedKernelName.c_str(), ParamIdentities, BarrierFlags,
-      InternalizeParams, JITConstants);
+      View{InputKernelInfo}, FusedKernelName.c_str(), View(ParamIdentities),
+      BarrierFlags, View(InternalizeParams), View(JITConstants));
 
   if (FusionResult.failed()) {
     if (DebugEnabled) {
diff --git a/sycl/source/detail/pi.cpp b/sycl/source/detail/pi.cpp
index abc24924cb8de..92bccc2cea2b2 100644
--- a/sycl/source/detail/pi.cpp
+++ b/sycl/source/detail/pi.cpp
@@ -291,9 +291,9 @@ std::vector<std::pair<std::string, backend>> findPlugins() {
   // search is done for libpi_opencl.so/pi_opencl.dll file in LD_LIBRARY_PATH
   // env only.
   //
-
-  device_filter_list *FilterList = SYCLConfig<SYCL_DEVICE_FILTER>::get();
   ods_target_list *OdsTargetList = SYCLConfig<ONEAPI_DEVICE_SELECTOR>::get();
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
+  device_filter_list *FilterList = SYCLConfig<SYCL_DEVICE_FILTER>::get();
 
   // Will we be filtering with SYCL_DEVICE_FILTER or ONEAPI_DEVICE_SELECTOR ?
   // We do NOT attempt to support both simultaneously.
@@ -301,16 +301,8 @@ std::vector<std::pair<std::string, backend>> findPlugins() {
     throw sycl::exception(sycl::make_error_code(errc::invalid),
                           "ONEAPI_DEVICE_SELECTOR cannot be used in "
                           "conjunction with SYCL_DEVICE_FILTER");
-  } else if (!FilterList && !OdsTargetList) {
-    PluginNames.emplace_back(__SYCL_OPENCL_PLUGIN_NAME, backend::opencl);
-    PluginNames.emplace_back(__SYCL_LEVEL_ZERO_PLUGIN_NAME,
-                             backend::ext_oneapi_level_zero);
-    PluginNames.emplace_back(__SYCL_CUDA_PLUGIN_NAME, backend::ext_oneapi_cuda);
-    PluginNames.emplace_back(__SYCL_HIP_PLUGIN_NAME, backend::ext_oneapi_hip);
-    PluginNames.emplace_back(__SYCL_UR_PLUGIN_NAME, backend::all);
-    PluginNames.emplace_back(__SYCL_NATIVE_CPU_PLUGIN_NAME,
-                             backend::ext_oneapi_native_cpu);
-  } else if (FilterList) {
+  }
+  if (FilterList) {
     std::vector<device_filter> Filters = FilterList->get();
     bool OpenCLFound = false;
     bool LevelZeroFound = false;
@@ -355,6 +347,19 @@ std::vector<std::pair<std::string, backend>> findPlugins() {
       }
       PluginNames.emplace_back(__SYCL_UR_PLUGIN_NAME, backend::all);
     }
+    return PluginNames;
+  }
+#endif // __INTEL_PREVIEW_BREAKING_CHANGES
+  if (!OdsTargetList) {
+    PluginNames.emplace_back(__SYCL_OPENCL_PLUGIN_NAME, backend::opencl);
+    PluginNames.emplace_back(__SYCL_LEVEL_ZERO_PLUGIN_NAME,
+                             backend::ext_oneapi_level_zero);
+    PluginNames.emplace_back(__SYCL_CUDA_PLUGIN_NAME, backend::ext_oneapi_cuda);
+    PluginNames.emplace_back(__SYCL_HIP_PLUGIN_NAME, backend::ext_oneapi_hip);
+    PluginNames.emplace_back(__SYCL_UR_PLUGIN_NAME, backend::all);
+    PluginNames.emplace_back(__SYCL_NATIVE_CPU_PLUGIN_NAME,
+                             backend::ext_oneapi_native_cpu);
+
   } else {
     ods_target_list &list = *OdsTargetList;
     if (list.backendCompatible(backend::opencl)) {
@@ -368,10 +373,12 @@ std::vector<std::pair<std::string, backend>> findPlugins() {
       PluginNames.emplace_back(__SYCL_CUDA_PLUGIN_NAME,
                                backend::ext_oneapi_cuda);
     }
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     if (list.backendCompatible(backend::ext_intel_esimd_emulator)) {
       PluginNames.emplace_back(__SYCL_ESIMD_EMULATOR_PLUGIN_NAME,
                                backend::ext_intel_esimd_emulator);
     }
+#endif
     if (list.backendCompatible(backend::ext_oneapi_hip)) {
       PluginNames.emplace_back(__SYCL_HIP_PLUGIN_NAME, backend::ext_oneapi_hip);
     }
diff --git a/sycl/source/detail/platform_impl.cpp b/sycl/source/detail/platform_impl.cpp
index 528bc69e035f4..57b4a2f48030b 100644
--- a/sycl/source/detail/platform_impl.cpp
+++ b/sycl/source/detail/platform_impl.cpp
@@ -206,10 +206,6 @@ std::vector<platform> platform_impl::get_platforms() {
   return Platforms;
 }
 
-// Filter out the devices that are not compatible with SYCL_DEVICE_FILTER or
-// ONEAPI_DEVICE_SELECTOR This function matches devices in the order of backend,
-// device_type, and device_num. The device_filter and ods_target structs pun for
-// each other, as do device_filter_list and ods_target_list.
 // Since ONEAPI_DEVICE_SELECTOR admits negative filters, we use type traits
 // to distinguish the case where we are working with ONEAPI_DEVICE_SELECTOR
 // in the places where the functionality diverges between these two
@@ -222,9 +218,6 @@ std::vector<int> platform_impl::filterDeviceFilter(
     ListT *FilterList) const {
 
   constexpr bool is_ods_target = std::is_same_v<FilterT, ods_target>;
-  // There are some differences in implementation between SYCL_DEVICE_FILTER
-  // and ONEAPI_DEVICE_SELECTOR so we use if constexpr to select the
-  // appropriate execution path if we are dealing with the latter variable.
 
   if constexpr (is_ods_target) {
 
@@ -476,10 +469,13 @@ static std::vector<device> amendDeviceAndSubDevices(
 std::vector<device>
 platform_impl::get_devices(info::device_type DeviceType) const {
   std::vector<device> Res;
+
+  ods_target_list *OdsTargetList = SYCLConfig<ONEAPI_DEVICE_SELECTOR>::get();
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   // Will we be filtering with SYCL_DEVICE_FILTER or ONEAPI_DEVICE_SELECTOR ?
   // We do NOT attempt to support both simultaneously.
-  ods_target_list *OdsTargetList = SYCLConfig<ONEAPI_DEVICE_SELECTOR>::get();
   device_filter_list *FilterList = SYCLConfig<SYCL_DEVICE_FILTER>::get();
+#endif
 
   if (is_host() && (DeviceType == info::device_type::host ||
                     DeviceType == info::device_type::all)) {
@@ -535,21 +531,25 @@ platform_impl::get_devices(info::device_type DeviceType) const {
     applyAllowList(PiDevices, MPlatform, MPlugin);
 
   // The first step is to filter out devices that are not compatible with
-  // SYCL_DEVICE_FILTER or ONEAPI_DEVICE_SELECTOR. This is also the mechanism by
-  // which top level device ids are assigned.
+  // ONEAPI_DEVICE_SELECTOR. This is also the mechanism by which top level
+  // device ids are assigned.
   std::vector<int> PlatformDeviceIndices;
   if (OdsTargetList) {
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     if (FilterList) {
       throw sycl::exception(sycl::make_error_code(errc::invalid),
                             "ONEAPI_DEVICE_SELECTOR cannot be used in "
                             "conjunction with SYCL_DEVICE_FILTER");
     }
+#endif
     PlatformDeviceIndices = filterDeviceFilter<ods_target_list, ods_target>(
         PiDevices, OdsTargetList);
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   } else if (FilterList) {
     PlatformDeviceIndices =
         filterDeviceFilter<device_filter_list, device_filter>(PiDevices,
                                                               FilterList);
+#endif
   }
 
   // The next step is to inflate the filtered PIDevices into SYCL Device
diff --git a/sycl/source/detail/queue_impl.cpp b/sycl/source/detail/queue_impl.cpp
index b8785e12f0535..545cff3b9c5c3 100644
--- a/sycl/source/detail/queue_impl.cpp
+++ b/sycl/source/detail/queue_impl.cpp
@@ -26,9 +26,19 @@
 namespace sycl {
 inline namespace _V1 {
 namespace detail {
-
 std::atomic<unsigned long long> queue_impl::MNextAvailableQueueID = 0;
 
+static std::vector<sycl::detail::pi::PiEvent>
+getPIEvents(const std::vector<sycl::event> &DepEvents) {
+  std::vector<sycl::detail::pi::PiEvent> RetPiEvents;
+  for (const sycl::event &Event : DepEvents) {
+    const EventImplPtr &EventImpl = detail::getSyclObjImpl(Event);
+    if (EventImpl->getHandleRef() != nullptr)
+      RetPiEvents.push_back(EventImpl->getHandleRef());
+  }
+  return RetPiEvents;
+}
+
 template <>
 uint32_t queue_impl::get_info<info::queue::reference_count>() const {
   sycl::detail::pi::PiResult result = PI_SUCCESS;
@@ -63,16 +73,25 @@ static event createDiscardedEvent() {
 
 const std::vector<event> &
 queue_impl::getExtendDependencyList(const std::vector<event> &DepEvents,
-                                    std::vector<event> &MutableVec) {
-  if (isInOrder()) {
-    std::optional<event> ExternalEvent = popExternalEvent();
-    if (ExternalEvent) {
-      MutableVec = DepEvents;
-      MutableVec.push_back(*ExternalEvent);
-      return MutableVec;
-    }
-  }
-  return DepEvents;
+                                    std::vector<event> &MutableVec,
+                                    std::unique_lock<std::mutex> &QueueLock) {
+  if (!isInOrder())
+    return DepEvents;
+
+  QueueLock.lock();
+  EventImplPtr ExtraEvent =
+      MGraph.expired() ? MLastEventPtr : MGraphLastEventPtr;
+  std::optional<event> ExternalEvent = popExternalEvent();
+
+  if (!ExternalEvent && !ExtraEvent)
+    return DepEvents;
+
+  MutableVec = DepEvents;
+  if (ExternalEvent)
+    MutableVec.push_back(*ExternalEvent);
+  if (ExtraEvent)
+    MutableVec.push_back(detail::createSyclObjFromImpl<event>(ExtraEvent));
+  return MutableVec;
 }
 
 event queue_impl::memset(const std::shared_ptr<detail::queue_impl> &Self,
@@ -106,7 +125,7 @@ event queue_impl::memset(const std::shared_ptr<detail::queue_impl> &Self,
   }
 
   return submitMemOpHelper(
-      Self, DepEvents,
+      Self, DepEvents, [&](handler &CGH) { CGH.memset(Ptr, Value, Count); },
       [](const auto &...Args) { MemoryManager::fill_usm(Args...); }, Ptr, Self,
       Count, Value);
 }
@@ -152,21 +171,17 @@ event queue_impl::memcpy(const std::shared_ptr<detail::queue_impl> &Self,
 #endif
   // If we have a command graph set we need to capture the copy through normal
   // queue submission rather than execute the copy directly.
-  if (MGraph.lock()) {
-    return submit(
-        [&](handler &CGH) {
-          CGH.depends_on(DepEvents);
-          CGH.memcpy(Dest, Src, Count);
-        },
-        Self, {});
-  }
+  auto HandlerFunc = [&](handler &CGH) { CGH.memcpy(Dest, Src, Count); };
+  if (MGraph.lock())
+    return submitWithHandler(Self, DepEvents, HandlerFunc);
+
   if ((!Src || !Dest) && Count != 0) {
     report(CodeLoc);
     throw runtime_error("NULL pointer argument in memory copy operation.",
                         PI_ERROR_INVALID_VALUE);
   }
   return submitMemOpHelper(
-      Self, DepEvents,
+      Self, DepEvents, HandlerFunc,
       [](const auto &...Args) { MemoryManager::copy_usm(Args...); }, Src, Self,
       Count, Dest);
 }
@@ -177,17 +192,12 @@ event queue_impl::mem_advise(const std::shared_ptr<detail::queue_impl> &Self,
                              const std::vector<event> &DepEvents) {
   // If we have a command graph set we need to capture the advise through normal
   // queue submission.
-  if (MGraph.lock()) {
-    return submit(
-        [&](handler &CGH) {
-          CGH.depends_on(DepEvents);
-          CGH.mem_advise(Ptr, Length, Advice);
-        },
-        Self, {});
-  }
+  auto HandlerFunc = [&](handler &CGH) { CGH.mem_advise(Ptr, Length, Advice); };
+  if (MGraph.lock())
+    return submitWithHandler(Self, DepEvents, HandlerFunc);
 
   return submitMemOpHelper(
-      Self, DepEvents,
+      Self, DepEvents, HandlerFunc,
       [](const auto &...Args) { MemoryManager::advise_usm(Args...); }, Ptr,
       Self, Length, Advice);
 }
@@ -198,6 +208,10 @@ event queue_impl::memcpyToDeviceGlobal(
     const std::vector<event> &DepEvents) {
   return submitMemOpHelper(
       Self, DepEvents,
+      [&](handler &CGH) {
+        CGH.memcpyToDeviceGlobal(DeviceGlobalPtr, Src, IsDeviceImageScope,
+                                 NumBytes, Offset);
+      },
       [](const auto &...Args) {
         MemoryManager::copy_to_device_global(Args...);
       },
@@ -210,15 +224,25 @@ event queue_impl::memcpyFromDeviceGlobal(
     size_t Offset, const std::vector<event> &DepEvents) {
   return submitMemOpHelper(
       Self, DepEvents,
+      [&](handler &CGH) {
+        CGH.memcpyFromDeviceGlobal(Dest, DeviceGlobalPtr, IsDeviceImageScope,
+                                   NumBytes, Offset);
+      },
       [](const auto &...Args) {
         MemoryManager::copy_from_device_global(Args...);
       },
       DeviceGlobalPtr, IsDeviceImageScope, Self, NumBytes, Offset, Dest);
 }
 
-event queue_impl::getLastEvent() const {
-  std::lock_guard<std::mutex> Lock{MLastEventMtx};
-  return MDiscardEvents ? createDiscardedEvent() : MLastEvent;
+event queue_impl::getLastEvent() {
+  std::lock_guard<std::mutex> Lock{MMutex};
+  if (MDiscardEvents)
+    return createDiscardedEvent();
+  if (!MGraph.expired() && MGraphLastEventPtr)
+    return detail::createSyclObjFromImpl<event>(MGraphLastEventPtr);
+  if (!MLastEventPtr)
+    MLastEventPtr = std::make_shared<event_impl>(std::nullopt);
+  return detail::createSyclObjFromImpl<event>(MLastEventPtr);
 }
 
 void queue_impl::addEvent(const event &Event) {
@@ -273,55 +297,89 @@ void queue_impl::addSharedEvent(const event &Event) {
   MEventsShared.push_back(Event);
 }
 
-template <typename MemOpFuncT, typename... MemOpArgTs>
+static bool
+areEventsSafeForSchedulerBypass(const std::vector<sycl::event> &DepEvents,
+                                ContextImplPtr Context) {
+  auto CheckEvent = [&Context](const sycl::event &Event) {
+    const EventImplPtr &SyclEventImplPtr = detail::getSyclObjImpl(Event);
+    // Events that don't have an initialized context are throwaway events that
+    // don't represent actual dependencies. Calling getContextImpl() would set
+    // their context, which we wish to avoid as it is expensive.
+    if (!SyclEventImplPtr->isContextInitialized() &&
+        !SyclEventImplPtr->is_host()) {
+      return true;
+    }
+    if (SyclEventImplPtr->is_host()) {
+      return SyclEventImplPtr->isCompleted();
+    }
+    // Cross-context dependencies can't be passed to the backend directly.
+    if (SyclEventImplPtr->getContextImpl() != Context)
+      return false;
+
+    // A nullptr here means that the commmand does not produce a PI event or it
+    // hasn't been enqueued yet.
+    return SyclEventImplPtr->getHandleRef() != nullptr;
+  };
+
+  return std::all_of(
+      DepEvents.begin(), DepEvents.end(),
+      [&CheckEvent](const sycl::event &Event) { return CheckEvent(Event); });
+}
+
+template <typename HandlerFuncT>
+event queue_impl::submitWithHandler(const std::shared_ptr<queue_impl> &Self,
+                                    const std::vector<event> &DepEvents,
+                                    HandlerFuncT HandlerFunc) {
+  return submit(
+      [&](handler &CGH) {
+        CGH.depends_on(DepEvents);
+        HandlerFunc(CGH);
+      },
+      Self, {});
+}
+
+template <typename HandlerFuncT, typename MemOpFuncT, typename... MemOpArgTs>
 event queue_impl::submitMemOpHelper(const std::shared_ptr<queue_impl> &Self,
                                     const std::vector<event> &DepEvents,
+                                    HandlerFuncT HandlerFunc,
                                     MemOpFuncT MemOpFunc,
                                     MemOpArgTs... MemOpArgs) {
-  if (MHasDiscardEventsSupport) {
-    MemOpFunc(MemOpArgs..., getOrWaitEvents(DepEvents, MContext),
-              /*PiEvent*/ nullptr, /*EventImplPtr*/ nullptr);
-    return createDiscardedEvent();
-  }
-
-  event ResEvent = prepareSYCLEventAssociatedWithQueue(Self);
+  // We need to submit command and update the last event under same lock if we
+  // have in-order queue.
   {
-    // We need to submit command and update the last event under same lock if we
-    // have in-order queue.
-    auto ScopeLock = isInOrder() ? std::unique_lock<std::mutex>(MLastEventMtx)
-                                 : std::unique_lock<std::mutex>();
-    // If the last submitted command in the in-order queue is host_task then
-    // wait for it before submitting usm command.
-    if (isInOrder() && MLastCGType == CG::CGTYPE::CodeplayHostTask)
-      MLastEvent.wait();
+    std::unique_lock<std::mutex> Lock(MMutex, std::defer_lock);
 
     std::vector<event> MutableDepEvents;
     const std::vector<event> &ExpandedDepEvents =
-        getExtendDependencyList(DepEvents, MutableDepEvents);
-
-    auto EventImpl = detail::getSyclObjImpl(ResEvent);
-    MemOpFunc(MemOpArgs..., getOrWaitEvents(ExpandedDepEvents, MContext),
-              &EventImpl->getHandleRef(), EventImpl);
-
-    if (MContext->is_host())
-      return MDiscardEvents ? createDiscardedEvent() : event();
-
-    // When a queue is recorded by a graph, the dependencies are managed in the
-    // graph implementaton. Additionally, CG recorded for a graph are outside of
-    // the in-order queue execution sequence. Therefore, these CG must not
-    // update MLastEvent.
-    if (isInOrder() && (getCommandGraph() == nullptr)) {
-      MLastEvent = ResEvent;
-      // We don't create a command group for usm commands, so set it to None.
-      // This variable is used to perform explicit dependency management when
-      // required.
-      MLastCGType = CG::CGTYPE::None;
+        getExtendDependencyList(DepEvents, MutableDepEvents, Lock);
+
+    if (areEventsSafeForSchedulerBypass(ExpandedDepEvents, MContext)) {
+      if (MHasDiscardEventsSupport) {
+        MemOpFunc(MemOpArgs..., getPIEvents(ExpandedDepEvents),
+                  /*PiEvent*/ nullptr, /*EventImplPtr*/ nullptr);
+        return createDiscardedEvent();
+      }
+
+      event ResEvent = prepareSYCLEventAssociatedWithQueue(Self);
+      auto EventImpl = detail::getSyclObjImpl(ResEvent);
+      MemOpFunc(MemOpArgs..., getPIEvents(ExpandedDepEvents),
+                &EventImpl->getHandleRef(), EventImpl);
+
+      if (MContext->is_host())
+        return MDiscardEvents ? createDiscardedEvent() : event();
+
+      if (isInOrder()) {
+        auto &EventToStoreIn =
+            MGraph.lock() ? MGraphLastEventPtr : MLastEventPtr;
+        EventToStoreIn = EventImpl;
+      }
+      // Track only if we won't be able to handle it with piQueueFinish.
+      if (MEmulateOOO)
+        addSharedEvent(ResEvent);
+      return discard_or_return(ResEvent);
     }
   }
-  // Track only if we won't be able to handle it with piQueueFinish.
-  if (MEmulateOOO)
-    addSharedEvent(ResEvent);
-  return MDiscardEvents ? createDiscardedEvent() : ResEvent;
+  return submitWithHandler(Self, DepEvents, HandlerFunc);
 }
 
 void *queue_impl::instrumentationProlog(const detail::code_location &CodeLoc,
@@ -495,9 +553,10 @@ bool queue_impl::ext_oneapi_empty() const {
   // If we have in-order queue where events are not discarded then just check
   // the status of the last event.
   if (isInOrder() && !MDiscardEvents) {
-    std::lock_guard<std::mutex> Lock(MLastEventMtx);
-    return MLastEvent.get_info<info::event::command_execution_status>() ==
-           info::event_command_status::complete;
+    std::lock_guard<std::mutex> Lock(MMutex);
+    return !MLastEventPtr ||
+           MLastEventPtr->get_info<info::event::command_execution_status>() ==
+               info::event_command_status::complete;
   }
 
   // Check the status of the backend queue if this is not a host queue.
@@ -533,6 +592,12 @@ bool queue_impl::ext_oneapi_empty() const {
   return true;
 }
 
+event queue_impl::discard_or_return(const event &Event) {
+  if (!(MDiscardEvents))
+    return Event;
+  return createDiscardedEvent();
+}
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/source/detail/queue_impl.hpp b/sycl/source/detail/queue_impl.hpp
index 5aab3fe1598ff..810f991d6667f 100644
--- a/sycl/source/detail/queue_impl.hpp
+++ b/sycl/source/detail/queue_impl.hpp
@@ -211,7 +211,7 @@ class queue_impl {
 #endif
   }
 
-  event getLastEvent() const;
+  event getLastEvent();
 
 private:
   void queue_impl_interop(sycl::detail::pi::PiQueue PiQueue) {
@@ -396,12 +396,14 @@ class queue_impl {
                const std::shared_ptr<queue_impl> &SecondQueue,
                const detail::code_location &Loc,
                const SubmitPostProcessF *PostProcess = nullptr) {
+    event ResEvent;
     try {
-      return submit_impl(CGF, Self, Self, SecondQueue, Loc, PostProcess);
+      ResEvent = submit_impl(CGF, Self, Self, SecondQueue, Loc, PostProcess);
     } catch (...) {
-      return SecondQueue->submit_impl(CGF, SecondQueue, Self, SecondQueue, Loc,
-                                      PostProcess);
+      ResEvent = SecondQueue->submit_impl(CGF, SecondQueue, Self, SecondQueue,
+                                          Loc, PostProcess);
     }
+    return discard_or_return(ResEvent);
   }
 
   /// Submits a command group function object to the queue, in order to be
@@ -416,7 +418,8 @@ class queue_impl {
                const std::shared_ptr<queue_impl> &Self,
                const detail::code_location &Loc,
                const SubmitPostProcessF *PostProcess = nullptr) {
-    return submit_impl(CGF, Self, Self, nullptr, Loc, PostProcess);
+    auto ResEvent = submit_impl(CGF, Self, Self, nullptr, Loc, PostProcess);
+    return discard_or_return(ResEvent);
   }
 
   /// Performs a blocking wait for the completion of all enqueued tasks in the
@@ -707,6 +710,7 @@ class queue_impl {
       std::shared_ptr<ext::oneapi::experimental::detail::graph_impl> Graph) {
     std::lock_guard<std::mutex> Lock(MMutex);
     MGraph = Graph;
+    MGraphLastEventPtr = nullptr;
   }
 
   std::shared_ptr<ext::oneapi::experimental::detail::graph_impl>
@@ -730,39 +734,33 @@ class queue_impl {
 
   const std::vector<event> &
   getExtendDependencyList(const std::vector<event> &DepEvents,
-                          std::vector<event> &MutableVec);
+                          std::vector<event> &MutableVec,
+                          std::unique_lock<std::mutex> &QueueLock);
 
 protected:
+  event discard_or_return(const event &Event);
   // Hook to the scheduler to clean up any fusion command held on destruction.
   void cleanup_fusion_cmd();
 
   // template is needed for proper unit testing
   template <typename HandlerType = handler>
-  void finalizeHandler(HandlerType &Handler, const CG::CGTYPE &Type,
-                       event &EventRet) {
-    // When a queue is recorded by a graph, the dependencies are managed in the
-    // graph implementaton. Additionally, CG recorded for a graph are outside of
-    // the in-order queue execution sequence. Therefore, these CG must not
-    // update MLastEvent.
-    if (MIsInorder && (getCommandGraph() == nullptr)) {
-
-      auto IsExpDepManaged = [](const CG::CGTYPE &Type) {
-        return Type == CG::CGTYPE::CodeplayHostTask;
-      };
-
+  void finalizeHandler(HandlerType &Handler, event &EventRet) {
+    if (MIsInorder) {
       // Accessing and changing of an event isn't atomic operation.
-      // Hence, here is are locks for thread-safety.
-      std::lock_guard<std::mutex> LastEventLock{MLastEventMtx};
-
-      if (MLastCGType == CG::CGTYPE::None)
-        MLastCGType = Type;
-      // Also handles case when sync model changes. E.g. Last is host, new is
-      // kernel.
-      bool NeedSeparateDependencyMgmt =
-          IsExpDepManaged(Type) || IsExpDepManaged(MLastCGType);
-
-      if (NeedSeparateDependencyMgmt)
-        Handler.depends_on(MLastEvent);
+      // Hence, here is the lock for thread-safety.
+      std::lock_guard<std::mutex> Lock{MMutex};
+      // This dependency is needed for the following purposes:
+      //    - host tasks are handled by the runtime and cannot be implicitly
+      //    synchronized by the backend.
+      //    - to prevent the 2nd kernel enqueue when the 1st kernel is blocked
+      //    by a host task. This dependency allows to build the enqueue order in
+      //    the RT but will not be passed to the backend. See getPIEvents in
+      //    Command.
+      auto &EventToBuildDeps =
+          MGraph.lock() ? MGraphLastEventPtr : MLastEventPtr;
+      if (EventToBuildDeps)
+        Handler.depends_on(
+            createSyclObjFromImpl<sycl::event>(EventToBuildDeps));
 
       // If there is an external event set, add it as a dependency and clear it.
       // We do not need to hold the lock as MLastEventMtx will ensure the last
@@ -772,9 +770,7 @@ class queue_impl {
         Handler.depends_on(*ExternalEvent);
 
       EventRet = Handler.finalize();
-
-      MLastEvent = EventRet;
-      MLastCGType = Type;
+      EventToBuildDeps = getSyclObjImpl(EventRet);
     } else
       EventRet = Handler.finalize();
   }
@@ -834,30 +830,45 @@ class queue_impl {
             !(Handler.MKernel && Handler.MKernel->isInterop()) &&
             ProgramManager::getInstance().kernelUsesAssert(Handler.MKernelName);
 
-      finalizeHandler(Handler, Type, Event);
+      finalizeHandler(Handler, Event);
 
       (*PostProcess)(IsKernel, KernelUsesAssert, Event);
     } else
-      finalizeHandler(Handler, Type, Event);
+      finalizeHandler(Handler, Event);
 
     addEvent(Event);
     return Event;
   }
 
-  /// Performs direct submission of a memory operation.
+  /// Helper function for submitting a memory operation with a handler.
+  /// \param Self is a shared_ptr to this queue.
+  /// \param DepEvents is a vector of dependencies of the operation.
+  /// \param HandlerFunc is a function that submits the operation with a
+  ///        handler.
+  template <typename HandlerFuncT>
+  event submitWithHandler(const std::shared_ptr<queue_impl> &Self,
+                          const std::vector<event> &DepEvents,
+                          HandlerFuncT HandlerFunc);
+
+  /// Performs submission of a memory operation directly if scheduler can be
+  /// bypassed, or with a handler otherwise.
   ///
   /// \param Self is a shared_ptr to this queue.
   /// \param DepEvents is a vector of dependencies of the operation.
-  /// \param MemOpFunc is a function that forwards its arguments to the
+  /// \param HandlerFunc is a function that submits the operation with a
+  ///        handler.
+  /// \param MemMngrFunc is a function that forwards its arguments to the
   ///        appropriate memory manager function.
-  /// \param MemOpArgs are all the arguments that need to be passed to memory
+  /// \param MemMngrArgs are all the arguments that need to be passed to memory
   ///        manager except the last three: dependencies, PI event and
   ///        EventImplPtr are filled out by this helper.
   /// \return an event representing the submitted operation.
-  template <typename MemOpFuncT, typename... MemOpArgTs>
+  template <typename HandlerFuncT, typename MemMngrFuncT,
+            typename... MemMngrArgTs>
   event submitMemOpHelper(const std::shared_ptr<queue_impl> &Self,
                           const std::vector<event> &DepEvents,
-                          MemOpFuncT MemOpFunc, MemOpArgTs... MemOpArgs);
+                          HandlerFuncT HandlerFunc, MemMngrFuncT MemMngrFunc,
+                          MemMngrArgTs... MemOpArgs);
 
   // When instrumentation is enabled emits trace event for wait begin and
   // returns the telemetry event generated for the wait
@@ -911,13 +922,12 @@ class queue_impl {
   buffer<AssertHappened, 1> MAssertHappenedBuffer;
 
   // This event is employed for enhanced dependency tracking with in-order queue
-  // Access to the event should be guarded with MLastEventMtx
-  event MLastEvent;
-  mutable std::mutex MLastEventMtx;
-  // Used for in-order queues in pair with MLastEvent
-  // Host tasks are explicitly synchronized in RT, pi tasks - implicitly by
-  // backend. Using type to setup explicit sync between host and pi tasks.
-  CG::CGTYPE MLastCGType = CG::CGTYPE::None;
+  // Access to the event should be guarded with MMutex
+  EventImplPtr MLastEventPtr;
+  // Same as above but for graph begin-end recording cycle.
+  // Track deps within graph commands separately.
+  // Protected by common queue object mutex MMutex.
+  EventImplPtr MGraphLastEventPtr;
 
   const bool MIsInorder;
 
diff --git a/sycl/source/detail/scheduler/graph_processor.cpp b/sycl/source/detail/scheduler/graph_processor.cpp
index f22913f990e9c..5ff184be64948 100644
--- a/sycl/source/detail/scheduler/graph_processor.cpp
+++ b/sycl/source/detail/scheduler/graph_processor.cpp
@@ -53,16 +53,6 @@ bool Scheduler::GraphProcessor::handleBlockingCmd(Command *Cmd,
                                                   BlockingT Blocking) {
   if (Cmd == RootCommand || Blocking)
     return true;
-  // Async kernel enqueue depending on host task is not compatible with in order
-  // queue. If we have host_task_1, kernel_2 depending on host_task_1 and
-  // kernel_3 without explicit dependencies submitted to in order queue: host
-  // task blocks kernel_2 from being enqueued while kernel_3 has no such
-  // dependencies so in current impl it could be enqueued earlier that kernel_2.
-  // That makes it impossible to use this path with blocking users for in order
-  // queue.
-  if (QueueImplPtr Queue = RootCommand->getEvent()->getSubmittedQueue();
-      Queue && Queue->isInOrder())
-    return true;
   {
     std::lock_guard<std::mutex> Guard(Cmd->MBlockedUsersMutex);
     if (Cmd->isBlocking()) {
diff --git a/sycl/source/device.cpp b/sycl/source/device.cpp
index dd52430b4a904..73a05080c5b0d 100644
--- a/sycl/source/device.cpp
+++ b/sycl/source/device.cpp
@@ -51,18 +51,21 @@ device::device(const device_selector &deviceSelector) {
 
 std::vector<device> device::get_devices(info::device_type deviceType) {
   std::vector<device> devices;
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   detail::device_filter_list *FilterList =
       detail::SYCLConfig<detail::SYCL_DEVICE_FILTER>::get();
+#endif
   detail::ods_target_list *OdsTargetList =
       detail::SYCLConfig<detail::ONEAPI_DEVICE_SELECTOR>::get();
 
   auto thePlatforms = platform::get_platforms();
   for (const auto &plt : thePlatforms) {
-    // If SYCL_DEVICE_FILTER is set, skip platforms that is incompatible
-    // with the filter specification.
+
     backend platformBackend = plt.get_backend();
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
     if (FilterList && !FilterList->backendCompatible(platformBackend))
       continue;
+#endif
     if (OdsTargetList && !OdsTargetList->backendCompatible(platformBackend))
       continue;
 
diff --git a/sycl/source/device_selector.cpp b/sycl/source/device_selector.cpp
index 56718015de027..55ee7b1a860b9 100644
--- a/sycl/source/device_selector.cpp
+++ b/sycl/source/device_selector.cpp
@@ -29,9 +29,9 @@ inline namespace _V1 {
 
 namespace detail {
 
-// SYCL_DEVICE_FILTER doesn't need to be considered in the device preferences
-// as it filters the device list returned by device::get_devices itself, so
-// only matching devices will be scored.
+// ONEAPI_DEVICE_SELECTOR doesn't need to be considered in the device
+// preferences as it filters the device list returned by device::get_devices
+// itself, so only matching devices will be scored.
 static int getDevicePreference(const device &Device) {
   int Score = 0;
 
diff --git a/sycl/source/queue.cpp b/sycl/source/queue.cpp
index 1909b161f752a..47b6b29b89bab 100644
--- a/sycl/source/queue.cpp
+++ b/sycl/source/queue.cpp
@@ -82,6 +82,20 @@ ext::oneapi::experimental::queue_state queue::ext_oneapi_get_state() const {
              : ext::oneapi::experimental::queue_state::executing;
 }
 
+ext::oneapi::experimental::command_graph<
+    ext::oneapi::experimental::graph_state::modifiable>
+queue::ext_oneapi_get_graph() const {
+  auto Graph = impl->getCommandGraph();
+  if (!Graph)
+    throw sycl::exception(
+        make_error_code(errc::invalid),
+        "ext_oneapi_get_graph() can only be called on recording queues.");
+
+  return sycl::detail::createSyclObjFromImpl<
+      ext::oneapi::experimental::command_graph<
+          ext::oneapi::experimental::graph_state::modifiable>>(Graph);
+}
+
 bool queue::is_host() const {
   bool IsHost = impl->is_host();
   assert(!IsHost && "queue::is_host should not be called in implementation.");
diff --git a/sycl/source/sycl.manifest b/sycl/source/sycl.manifest
new file mode 100644
index 0000000000000..f9d77565f0b42
--- /dev/null
+++ b/sycl/source/sycl.manifest
@@ -0,0 +1,11 @@
+<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
+<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
+  <file name="pi_win_proxy_loader.dll"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level='asInvoker' uiAccess='false' />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+</assembly>
\ No newline at end of file
diff --git a/sycl/source/sycld.manifest b/sycl/source/sycld.manifest
new file mode 100644
index 0000000000000..c0ae8a26c2cf6
--- /dev/null
+++ b/sycl/source/sycld.manifest
@@ -0,0 +1,11 @@
+<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
+<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
+  <file name="pi_win_proxy_loaderd.dll"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level='asInvoker' uiAccess='false' />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+</assembly>
\ No newline at end of file
diff --git a/sycl/test-e2e/BFloat16/bfloat16_builtins.cpp b/sycl/test-e2e/BFloat16/bfloat16_builtins.cpp
index 24ceb887d5b91..e1cf00d5e887f 100644
--- a/sycl/test-e2e/BFloat16/bfloat16_builtins.cpp
+++ b/sycl/test-e2e/BFloat16/bfloat16_builtins.cpp
@@ -1,7 +1,22 @@
+
+// On CUDA, the test behaves differently depending on whether it is compiled for
+// sm_xx>=sm_80 or not:
+// + sm_80 and above uses some native bfloat16 math instructions
+// + below sm_80 always uses generic impls
+
 // DEFINE: %{mathflags} = %if cl_options %{/clang:-fno-fast-math%} %else %{-fno-fast-math%}
 // REQUIRES: aspect-ext_oneapi_bfloat16_math_functions
 // RUN: %clangxx -fsycl -fsycl-targets=%{sycl_triple} %if any-device-is-cuda %{ -Xsycl-target-backend --cuda-gpu-arch=sm_80 %} %s -o %t.out %{mathflags}
 // RUN: %{run} %t.out
+
+// Test "new" (ABI breaking) for all platforms ( sm_80/native if CUDA )
+// RUN:  %if preview-breaking-changes-supported %{  %clangxx -fsycl -fpreview-breaking-changes -fsycl-targets=%{sycl_triple} %if any-device-is-cuda %{ -Xsycl-target-backend --cuda-gpu-arch=sm_80 %} %s -o %t2.out %{mathflags} %}
+// RUN:  %if preview-breaking-changes-supported %{  %{run} %t2.out  %}
+
+// If CUDA, test "new" again for sm_75/generic
+// RUN:  %if any-device-is-cuda %{ %if preview-breaking-changes-supported %{  %clangxx -fsycl -fpreview-breaking-changes -fsycl-targets=%{sycl_triple}  -Xsycl-target-backend --cuda-gpu-arch=sm_75  %s -o %t3.out %{mathflags} %} %}
+// RUN:  %if any-device-is-cuda %{ %if preview-breaking-changes-supported %{  %{run} %t3.out  %} %}
+
 // Currently the feature isn't supported on FPGA.
 // UNSUPPORTED: accelerator
 #include <sycl/sycl.hpp>
diff --git a/sycl/test-e2e/BFloat16/bfloat16_vec.cpp b/sycl/test-e2e/BFloat16/bfloat16_vec.cpp
new file mode 100644
index 0000000000000..c9076e4f2bbdd
--- /dev/null
+++ b/sycl/test-e2e/BFloat16/bfloat16_vec.cpp
@@ -0,0 +1,161 @@
+//==------------ bfloat16_vec.cpp - test sycl::vec<bfloat16>----------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// TODO currently the feature isn't supported on FPGA.
+// TODO enable opaque pointers support on CPU.
+// UNSUPPORTED: cpu || accelerator
+
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+// RUN: %if preview-breaking-changes-supported %{  %{build} -fpreview-breaking-changes -o %t2.out   %}
+// RUN: %if preview-breaking-changes-supported %{ %{run} %t2.out  %}
+
+#include <sycl/sycl.hpp>
+
+constexpr unsigned N =
+    10; // init plus arithmetic + - * /   for vec<1> and vec<2>
+
+int main() {
+
+  // clang-format off
+    using T = sycl::ext::oneapi::bfloat16;
+
+    sycl::queue q;
+
+    T a0{ 2.0f };
+    T b0 { 6.0f };
+
+    T addition_ref0 = a0 + b0;
+    T subtraction_ref0 = a0 - b0;
+    T multiplication_ref0 = a0 * b0;
+    T division_ref0 = a0 / b0;
+
+    std::cout << " ===  vec<bfloat16, 1> === " << std::endl;
+    std::cout << " ---  ON HOST --- " << std::endl;
+    sycl::vec<T, 1>  init_float{ 2.0f };
+    sycl::vec<T, 1>  oneA{ a0 }, oneB{ b0 };
+    sycl::vec<T, 1>  simple_addition = oneA + oneB;
+    sycl::vec<T, 1>  simple_subtraction = oneA - oneB;
+    sycl::vec<T, 1>  simple_multiplication = oneA * oneB;
+    sycl::vec<T, 1>  simple_division = oneA / oneB;
+
+    std::cout << "iniitialization     : " << oneA[0]             << " float: " << init_float[0] << std::endl;
+    std::cout << "addition.        ref: " << addition_ref0       << " vec: " << simple_addition[0] << std::endl;
+    std::cout << "subtraction.     ref: " << subtraction_ref0    << " vec: " << simple_subtraction[0] << std::endl;
+    std::cout << "multiplication.  ref: " << multiplication_ref0 << " vec: " << simple_multiplication[0] << std::endl;
+    std::cout << "division.        ref: " << division_ref0       << " vec: " << simple_division[0] << std::endl;
+
+    assert(oneA[0] == init_float[0]);
+    assert(addition_ref0 == simple_addition[0]);
+    assert(subtraction_ref0 == simple_subtraction[0]);
+    assert(multiplication_ref0 == simple_multiplication[0]);
+    assert(division_ref0 == simple_division[0]);
+
+    std::cout << " ---  ON DEVICE --- " << std::endl;
+    sycl::range<1> r(N);
+    sycl::buffer<bool, 1> buf(r);
+
+    q.submit([&](sycl::handler &cgh) {
+        sycl::stream out(2024, 400, cgh);
+        sycl::accessor acc(buf, cgh, sycl::write_only );
+        cgh.single_task([=](){
+            sycl::vec<T, 1>  dev_float{ 2.0f };
+            sycl::vec<T, 1>  device_addition = oneA + oneB;
+            sycl::vec<T, 1>  device_subtraction = oneA - oneB;
+            sycl::vec<T, 1>  device_multiplication = oneA * oneB;
+            sycl::vec<T, 1>  device_division = oneA / oneB;
+
+            out << "iniitialization     : " << oneA[0]             << " float: " << dev_float[0] << sycl::endl;
+            out << "addition.        ref: " << addition_ref0       << " vec: " << device_addition[0] << sycl::endl;
+            out << "subtraction.     ref: " << subtraction_ref0    << " vec: " << device_subtraction[0] << sycl::endl;
+            out << "multiplication.  ref: " << multiplication_ref0 << " vec: " << device_multiplication[0] << sycl::endl;
+            out << "division.        ref: " << division_ref0       << " vec: " << device_division[0] << sycl::endl;
+
+            acc[0] = (oneA[0] == dev_float[0]);
+            acc[1] = (addition_ref0 == device_addition[0]);
+            acc[2] = (subtraction_ref0 == device_subtraction[0]);
+            acc[3] = (multiplication_ref0 == device_multiplication[0]);
+            acc[4] = (division_ref0 == device_division[0]);
+            
+        }); 
+    }).wait();
+
+
+    // second value
+    T a1 { 3.33333f };
+    T b1 { 6.66666f };
+    T addition_ref1 = a1 + b1;
+    T subtraction_ref1 = a1 - b1;
+    T multiplication_ref1 = a1 * b1;
+    T division_ref1 = a1 / b1;
+
+    std::cout << "\n ===  vec<bfloat16, 2> === " << std::endl;
+    std::cout << " ---  ON HOST --- " << std::endl;
+    sycl::vec<T, 2> twoA{ a0, a1 }, twoB{ b0, b1 };
+    sycl::vec<T, 2> double_float { 2.0f, 3.33333f };
+    sycl::vec<T, 2> double_addition = twoA + twoB;
+    sycl::vec<T, 2> double_subtraction = twoA - twoB;
+    sycl::vec<T, 2> double_multiplication = twoA * twoB;
+    sycl::vec<T, 2> double_division = twoA / twoB;
+
+    std::cout << "init ref: " << twoA[0]                << "    ref1: " << twoA[1] << std::endl;
+    std::cout << "  float0: " << double_float[0]        << "  float1: " << double_float[1] << std::endl;
+    std::cout << "+ ref0: " << addition_ref0            << "    ref1: " << addition_ref1 << std::endl;
+    std::cout << "add[0]: " << double_addition[0]       << "  add[1]: " << double_addition[1] << std::endl;
+    std::cout << "- ref0: " << subtraction_ref0         << "    ref1: " << subtraction_ref1 << std::endl;
+    std::cout << "sub[0]: " << double_subtraction[0]    << "  sub[1]: " << double_subtraction[1] << std::endl;
+    std::cout << "* ref0: " << multiplication_ref0      << "    ref1: " << multiplication_ref1 << std::endl;
+    std::cout << "mul[0]: " << double_multiplication[0] << "  mul[1]: " << double_multiplication[1] << std::endl;
+    std::cout << "/ ref0: " << division_ref0            << "    ref1: " << division_ref1 << std::endl;
+    std::cout << "div[0]: " << double_division[0]       << "  div[1]: " << double_division[1] << std::endl;
+    
+    assert(twoA[0] == double_float[0]);                      assert(twoA[1] == double_float[1]);
+    assert(addition_ref0 == double_addition[0]);             assert(addition_ref1 == double_addition[1]);
+    assert(subtraction_ref0 == double_subtraction[0]);       assert(subtraction_ref1 == double_subtraction[1]);
+    assert(multiplication_ref0 == double_multiplication[0]); assert(multiplication_ref1 == double_multiplication[1]);
+    assert(division_ref0 == double_division[0]);             assert(division_ref1 == double_division[1]);
+    
+    std::cout << " ---  ON DEVICE --- " << std::endl;
+    q.submit([&](sycl::handler &cgh) {
+        sycl::stream out(2024, 400, cgh);
+        sycl::accessor acc(buf, cgh, sycl::write_only );
+        cgh.single_task([=](){
+            sycl::vec<T, 2> device_float { 2.0f, 3.33333f };
+            sycl::vec<T, 2> device_addition = twoA + twoB;
+            sycl::vec<T, 2> device_subtraction = twoA - twoB;
+            sycl::vec<T, 2> device_multiplication = twoA * twoB;
+            sycl::vec<T, 2> device_division = twoA / twoB;
+
+            out << "init ref: " << twoA[0]                << "    ref1: " << twoA[1] << sycl::endl;
+            out << "  float0: " << device_float[0]        << "  float1: " << device_float[1] << sycl::endl;
+            out << "+ ref0: " << addition_ref0            << "    ref1: " << addition_ref1 << sycl::endl;
+            out << "add[0]: " << device_addition[0]       << "  add[1]: " << device_addition[1] << sycl::endl;
+            out << "- ref0: " << subtraction_ref0         << "    ref1: " << subtraction_ref1 << sycl::endl;
+            out << "sub[0]: " << device_subtraction[0]    << "  sub[1]: " << device_subtraction[1] << sycl::endl;
+            out << "* ref0: " << multiplication_ref0      << "    ref1: " << multiplication_ref1 << sycl::endl;
+            out << "mul[0]: " << device_multiplication[0] << "  mul[1]: " << device_multiplication[1] << sycl::endl;
+            out << "/ ref0: " << division_ref0            << "    ref1: " << division_ref1 << sycl::endl;
+            out << "div[0]: " << device_division[0]       << "  div[1]: " << device_division[1] << sycl::endl;
+
+            acc[5] = (twoA[0] == device_float[0]) && (twoA[1] == device_float[1]);
+            acc[6] = (addition_ref0 == device_addition[0]) && (addition_ref1 == device_addition[1]);
+            acc[7] = (subtraction_ref0 == device_subtraction[0]) && (subtraction_ref1 == device_subtraction[1]);
+            acc[8] = (multiplication_ref0 == device_multiplication[0]) && (multiplication_ref1 == device_multiplication[1]);
+            acc[9] = (division_ref0 == device_division[0]) && (division_ref1 == device_division[1]);
+
+        }); 
+    }).wait();
+
+    sycl::host_accessor h_acc(buf, sycl::read_only);
+    for(unsigned i = 0; i < N; i++){
+        assert(h_acc[i]);
+    }
+
+  // clang-format on
+  return 0;
+}
diff --git a/sycl/test-e2e/Basic/diagnostics/device-check.cpp b/sycl/test-e2e/Basic/diagnostics/device-check.cpp
index f6e5fff857b48..25682a723db59 100644
--- a/sycl/test-e2e/Basic/diagnostics/device-check.cpp
+++ b/sycl/test-e2e/Basic/diagnostics/device-check.cpp
@@ -1,19 +1,20 @@
 // RUN: %{build} -o %t.out
-// RUN: env SYCL_DEVICE_TYPE=cpu %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=gpu %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=acc %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=CPU %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=GPU %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=ACC %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=Cpu %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=Gpu %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=Acc %{run-unfiltered-devices} %t.out
-// RUN: env SYCL_DEVICE_TYPE=XPU %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:cpu" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:gpu" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:fpga" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:CPU" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:GPU" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:Fpga" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:Cpu" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:Gpu" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:FPGA" %{run-unfiltered-devices} %t.out
+// RUN: env ONEAPI_DEVICE_SELECTOR="*:XPU" %{run-unfiltered-devices} %t.out
 
 //==------------------- device-check.cpp --------------------------==//
 // This is a diagnostic test which ensures that
 // device types are case-insensitive.
-// It also checks for SYCL_DEVICE being set incorrectly.
+// It also checks for exception when the device in ONEAPI_DEVICE_SELECTOR
+// is set incorrectly.
 //==---------------------------------------------------------------==//
 
 #include <iostream>
@@ -29,17 +30,32 @@ int main() {
     std::cout << " Device Name: " << deviceName << std::endl;
   }
 
-  catch (runtime_error &E) {
-    if (std::string(E.what()).find("SYCL_DEVICE_TYPE is not recognized.  Must "
-                                   "be GPU, CPU, ACC or HOST.") ==
-            std::string::npos &&
-        std::string(E.what()).find("No device of requested type") ==
-            std::string::npos) {
-      std::cout << "Test failed: received error is incorrect." << std::endl;
-      return 1;
+  catch (exception const &E) {
+
+    // Exception when cpu/gpu/fpga is not available on the system.
+    if (E.code() == errc::runtime) {
+      if (std::string(E.what()).find("No device of requested type") ==
+          std::string::npos) {
+        std::cout << "Test failed: received error is incorrect." << std::endl;
+        return 1;
+      } else {
+        std::cout << "Test passed: caught the expected error." << std::endl;
+        return 0;
+      }
+    }
+    // Exception while parsing an invalid device name.
+    else if (E.code() == errc::invalid) {
+      if (std::string(E.what()).find("error parsing device number: xpu") ==
+          std::string::npos) {
+        std::cout << "Test failed: received error is incorrect." << std::endl;
+        return 1;
+      } else {
+        std::cout << "Test passed: caught the expected error." << std::endl;
+        return 0;
+      }
     } else {
-      std::cout << "Test passed: caught the expected error." << std::endl;
-      return 0;
+      std::cout << "Test failed: unexpected exception." << std::endl;
+      return 1;
     }
   }
 
diff --git a/sycl/test-e2e/Basic/get_backend.cpp b/sycl/test-e2e/Basic/get_backend.cpp
index 26f1370f989ac..33b8da7e6b3bc 100644
--- a/sycl/test-e2e/Basic/get_backend.cpp
+++ b/sycl/test-e2e/Basic/get_backend.cpp
@@ -1,5 +1,5 @@
 // Failing due to old driver
-// REQUIRES-INTEL-DRIVER: lin: 27202, win: 101.4677
+// REQUIRES-INTEL-DRIVER: lin: 27427, win: 101.4827
 // RUN: %{build} -o %t.out
 // RUN: %{run-unfiltered-devices} %t.out
 //
diff --git a/sycl/test-e2e/Complex/sycl_complex_include_order.cpp b/sycl/test-e2e/Complex/sycl_complex_include_order.cpp
index 69e6b0685c39f..245d222c65209 100644
--- a/sycl/test-e2e/Complex/sycl_complex_include_order.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_include_order.cpp
@@ -31,6 +31,11 @@ int main() {
   queue q;
   auto test = []() {
     static_assert(sycl::detail::is_complex<std::complex<float>>::value);
+    static_assert(sycl::detail::is_complex<const std::complex<half>>::value);
+    static_assert(
+        sycl::detail::is_complex<const volatile std::complex<float>>::value);
+    static_assert(
+        sycl::detail::is_complex<volatile std::complex<double>>::value);
     static_assert(sycl::detail::isComplex<std::complex<float>>::value);
 #ifdef __SYCL_DEVICE_ONLY__
     static_assert(
diff --git a/sycl/test-e2e/DeprecatedFeatures/sycl_device_filter.cpp b/sycl/test-e2e/DeprecatedFeatures/sycl_device_filter.cpp
index 8f1dd01b9eca9..046ee7de6985c 100644
--- a/sycl/test-e2e/DeprecatedFeatures/sycl_device_filter.cpp
+++ b/sycl/test-e2e/DeprecatedFeatures/sycl_device_filter.cpp
@@ -2,6 +2,7 @@
 // RUN: %if any-device-is-cpu %{ env SYCL_DEVICE_FILTER=cpu %{run-unfiltered-devices} %t.out %}
 // RUN: %if any-device-is-gpu %{ env SYCL_DEVICE_FILTER=gpu %{run-unfiltered-devices} %t.out %}
 // RUN: %if any-device-is-acc %{ env SYCL_DEVICE_FILTER=acc %{run-unfiltered-devices} %t.out %}
+// TODO: Remove this test once SYCL_DEVICE_FILTER is removed.
 
 #include <sycl/sycl.hpp>
 
diff --git a/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/gather.hpp b/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/gather.hpp
index 540548bb61ae5..03ef9bc46c483 100644
--- a/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/gather.hpp
+++ b/sycl/test-e2e/ESIMD/unified_memory_api/Inputs/gather.hpp
@@ -468,6 +468,244 @@ template <typename T, TestFeatures Features> bool testUSM(queue Q) {
   return Passed;
 }
 
+template <typename T, uint16_t N, uint16_t VS, bool UseMask, bool UsePassThru,
+          bool UseProperties, typename PropertiesT>
+bool testSLM(queue Q, uint32_t MaskStride, PropertiesT) {
+
+  static_assert(VS > 0 && N % VS == 0,
+                "Incorrect VS parameter. N must be divisible by VS.");
+  constexpr int NOffsets = N / VS;
+  static_assert(!UsePassThru || UseMask,
+                "PassThru cannot be used without using mask");
+
+  constexpr uint32_t Groups = 8;
+  constexpr uint32_t Threads = 16;
+
+  std::cout << "Running slm_gather case: T=" << esimd_test::type_name<T>()
+            << ", N=" << N << ", VS=" << VS << ", MaskStride=" << MaskStride
+            << ", Groups=" << Groups << ", Threads=" << Threads
+            << ", use_mask=" << UseMask << ", use_pass_thru=" << UsePassThru
+            << ", use_properties=" << UseProperties << std::endl;
+
+  constexpr uint16_t Size = Groups * Threads * N;
+  using Tuint = esimd_test::uint_type_t<sizeof(T)>;
+
+  sycl::range<1> GlobalRange{Groups};
+  sycl::range<1> LocalRange{Threads};
+  sycl::nd_range<1> Range{GlobalRange * LocalRange, LocalRange};
+
+  T *Out = sycl::malloc_shared<T>(Size, Q);
+  std::memset(Out, 0, Size * sizeof(T));
+
+  T *In = sycl::malloc_shared<T>(Size * 2, Q);
+  for (int I = 0; I < Size; I++)
+    In[I] = esimd_test::getRandomValue<T>();
+
+  try {
+    Q.parallel_for(Range, [=](sycl::nd_item<1> NDI) SYCL_ESIMD_KERNEL {
+       uint16_t GlobalID = NDI.get_global_id(0);
+       uint16_t LocalID = NDI.get_local_id(0);
+       uint32_t GlobalElemOffset = GlobalID * N;
+       uint32_t LocalElemOffset = LocalID * N;
+
+       // Allocate a bit more to safely initialize it with 4-element chunks.
+       constexpr uint32_t SLMSize = (Threads * N + 8) * sizeof(T);
+       slm_init<SLMSize>();
+
+       if (LocalID == 0) {
+         for (int I = 0; I < Threads * N; I += 8) {
+           simd<T, 8> InVec(In + GlobalElemOffset + I);
+           simd<uint32_t, 8> offsets(I * sizeof(T), sizeof(T));
+           slm_scatter<T>(offsets, InVec);
+         }
+       }
+       barrier();
+
+       PropertiesT Props{};
+
+       simd<uint32_t, NOffsets> ByteOffsets(LocalElemOffset * sizeof(T),
+                                            VS * sizeof(T));
+       simd_view ByteOffsetsView = ByteOffsets.template select<NOffsets, 1>();
+
+       simd_mask<NOffsets> Pred;
+       for (int I = 0; I < NOffsets; I++)
+         Pred[I] = (I % MaskStride == 0) ? 1 : 0;
+
+       using Tuint = esimd_test::uint_type_t<sizeof(T)>;
+       simd<Tuint, N> PassThruInt(GlobalElemOffset, 1);
+       simd<T, N> PassThru = PassThruInt.template bit_cast_view<T>();
+       auto PassThruView = PassThru.template select<N, 1>(0);
+
+       simd<T, N> Vals;
+       if constexpr (VS > 1) { // VS > 1 requires specifying <T, N, VS>
+         if constexpr (UsePassThru) {
+           if constexpr (UseProperties) {
+             if (GlobalID % 4 == 0) // ByteOffset - simd, PassThru - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsets, Pred, PassThru, Props);
+             else if (GlobalID % 4 == 1) // ByteOffset - simd, PassThru - view
+               Vals =
+                   slm_gather<T, N, VS>(ByteOffsets, Pred, PassThruView, Props);
+             else if (GlobalID % 4 == 2) // ByteOffset - view, PassThru - simd
+               Vals =
+                   slm_gather<T, N, VS>(ByteOffsetsView, Pred, PassThru, Props);
+             else // ByteOffset - view, PassThru - view
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView, Pred, PassThruView,
+                                           Props);
+           } else {                 // UseProperties is false
+             if (GlobalID % 4 == 0) // ByteOffset - simd, PassThru - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsets, Pred, PassThru);
+             else if (GlobalID % 4 == 1) // ByteOffset - simd, PassThru - view
+               Vals = slm_gather<T, N, VS>(ByteOffsets, Pred, PassThruView);
+             else if (GlobalID % 4 == 2) // ByteOffset - view, PassThru - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView, Pred, PassThru);
+             else // ByteOffset - view, PassThru - view
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView, Pred, PassThruView);
+           }
+         } else if constexpr (UseMask) { // UsePassThru is false
+           if constexpr (UseProperties) {
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsets, Pred, Props);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView, Pred, Props);
+           } else {                 // UseProperties is false
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsets, Pred);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView, Pred);
+           }
+         } else { // UseMask is false, UsePassThru is false
+           if constexpr (UseProperties) {
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsets, Props);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView, Props);
+           } else {                 // UseProperties is false
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T, N, VS>(ByteOffsets);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N, VS>(ByteOffsetsView);
+           }
+         }
+       } else {
+         // if (VS == 1) then <T, N, VS> can often be omitted - test it here.
+         // The variants accepting simd_view for 'PassThru' operand though
+         // still require <T, N> to be specified explicitly to help
+         // C++ FE do simd to simd_view matching.
+         if constexpr (UsePassThru) {
+           if constexpr (UseProperties) {
+             if (GlobalID % 4 == 0) // ByteOffset - simd, PassThru - simd
+               Vals = slm_gather<T>(ByteOffsets, Pred, PassThru, Props);
+             else if (GlobalID % 4 == 1) // ByteOffset - simd, PassThru - view
+               Vals = slm_gather<T, N>(ByteOffsets, Pred, PassThruView, Props);
+             else if (GlobalID % 4 == 2) // ByteOffset - view, PassThru - simd
+               Vals = slm_gather<T, N>(ByteOffsetsView, Pred, PassThru, Props);
+             else // ByteOffset - view, PassThru - view
+               Vals =
+                   slm_gather<T, N>(ByteOffsetsView, Pred, PassThruView, Props);
+           } else {                 // UseProperties is false
+             if (GlobalID % 4 == 0) // ByteOffset - simd, PassThru - simd
+               Vals = slm_gather<T>(ByteOffsets, Pred, PassThru);
+             else if (GlobalID % 4 == 1) // ByteOffset - simd, PassThru - view
+               Vals = slm_gather<T, N>(ByteOffsets, Pred, PassThruView);
+             else if (GlobalID % 4 == 2) // ByteOffset - view, PassThru - simd
+               Vals = slm_gather<T, N>(ByteOffsetsView, Pred, PassThru);
+             else // ByteOffset - view, PassThru - view
+               Vals = slm_gather<T, N>(ByteOffsetsView, Pred, PassThruView);
+           }
+         } else if constexpr (UseMask) { // UsePassThru is false
+           if constexpr (UseProperties) {
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T>(ByteOffsets, Pred, Props);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N>(ByteOffsetsView, Pred, Props);
+           } else {                 // UseProperties is false
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T>(ByteOffsets, Pred);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N>(ByteOffsetsView, Pred);
+           }
+         } else { // UsePassThru is false, UseMask is false
+           if constexpr (UseProperties) {
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T>(ByteOffsets, Props);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N>(ByteOffsetsView, Props);
+           } else {
+             if (GlobalID % 2 == 0) // ByteOffset - simd
+               Vals = slm_gather<T>(ByteOffsets);
+             else // ByteOffset - simd_view
+               Vals = slm_gather<T, N>(ByteOffsetsView);
+           }
+         }
+       } // end if (VS == 1)
+       Vals.copy_to(Out + GlobalElemOffset);
+     }).wait();
+  } catch (sycl::exception const &e) {
+    std::cout << "SYCL exception caught: " << e.what() << '\n';
+    sycl::free(In, Q);
+    sycl::free(Out, Q);
+    return false;
+  }
+
+  bool Passed = verify(In, Out, N, Size, VS, MaskStride, UseMask, UsePassThru);
+  if (!Passed)
+    std::cout << "Case FAILED" << std::endl;
+
+  sycl::free(In, Q);
+  sycl::free(Out, Q);
+  return Passed;
+}
+
+template <typename T, TestFeatures Features> bool testSLM(queue Q) {
+  constexpr bool UseMask = true;
+  constexpr bool UsePassThru = true;
+  constexpr bool UseProperties = true;
+
+  properties AlignElemProps{alignment<sizeof(T)>};
+
+  bool Passed = true;
+  Passed &= testSLM<T, 1, 1, !UseMask, !UsePassThru, !UseProperties>(
+      Q, 2, AlignElemProps);
+  Passed &= testSLM<T, 2, 1, UseMask, !UsePassThru, !UseProperties>(
+      Q, 2, AlignElemProps);
+  Passed &= testSLM<T, 4, 1, UseMask, !UsePassThru, !UseProperties>(
+      Q, 2, AlignElemProps);
+  Passed &= testSLM<T, 8, 1, UseMask, !UsePassThru, UseProperties>(
+      Q, 3, AlignElemProps);
+  // UsePassThru requires either DG2/PVC or support of llvm.masked.gather LLVM
+  // IR.
+#ifdef __ESIMD_GATHER_SCATTER_LLVM_IR
+  Passed &= testSLM<T, 16, 1, UseMask, UsePassThru, UseProperties>(
+      Q, 2, AlignElemProps);
+  Passed &= testSLM<T, 32, 1, UseMask, UsePassThru, !UseProperties>(
+      Q, 3, AlignElemProps);
+#endif
+
+  // TODO: test non-power-of-2 N
+  // Such cases were promised to be supported, but in fact they fail.
+  // Create some test cases here after the issue in GPU driver is resolved.
+
+  if constexpr (Features == TestFeatures::PVC ||
+                Features == TestFeatures::DG2) {
+
+    // Check VS > 1. GPU supports only dwords and qwords in this mode.
+    if constexpr (sizeof(T) >= 4) {
+      // TODO: This test case causes flaky fail. Enable it after the issue
+      // in GPU driver is fixed.
+      // Passed &= testUSM<T, 16, 2, UseMask, !UsePassThru, UseProperties>(
+      //    Q, 3, AlignElemProps);
+
+      Passed &= testSLM<T, 32, 2, !UseMask, !UsePassThru, UseProperties>(
+          Q, 3, AlignElemProps);
+      Passed &= testSLM<T, 32, 2, UseMask, !UsePassThru, UseProperties>(
+          Q, 3, AlignElemProps);
+      Passed &= testSLM<T, 32, 2, UseMask, UsePassThru, UseProperties>(
+          Q, 3, AlignElemProps);
+    }
+  }
+  return Passed;
+}
+
 template <typename T, TestFeatures Features> bool testACC(queue Q) {
   constexpr bool UseMask = true;
   constexpr bool UsePassThru = true;
@@ -478,12 +716,10 @@ template <typename T, TestFeatures Features> bool testACC(queue Q) {
   bool Passed = true;
   Passed &= testACC<T, 1, 1, !UseMask, !UsePassThru, !UseProperties>(
       Q, 2, AlignElemProps);
-#ifdef __ESIMD_FORCE_STATELESS_MEM
   Passed &= testACC<T, 2, 1, UseMask, !UsePassThru, !UseProperties>(
       Q, 2, AlignElemProps);
   Passed &= testACC<T, 4, 1, UseMask, !UsePassThru, !UseProperties>(
       Q, 2, AlignElemProps);
-#endif // __ESIMD_FORCE_STATELESS_MEM
   Passed &= testACC<T, 8, 1, UseMask, !UsePassThru, !UseProperties>(
       Q, 3, AlignElemProps);
   Passed &= testACC<T, 16, 1, UseMask, !UsePassThru, UseProperties>(
diff --git a/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather.cpp b/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather.cpp
new file mode 100644
index 0000000000000..2a11c981bf069
--- /dev/null
+++ b/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather.cpp
@@ -0,0 +1,34 @@
+//==------- slm_gather.cpp - DPC++ ESIMD on-device test --------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Use per-kernel compilation to have more information about failing cases.
+// RUN: %{build} -fsycl-device-code-split=per_kernel -D__ESIMD_GATHER_SCATTER_LLVM_IR -o %t.out
+// RUN: %{run} %t.out
+
+// The test verifies esimd::slm_gather() functions accepting  optional
+// compile-time esimd::properties. The slm_gather() calls in this test do not
+// use VS > 1 (number of loads per offset) to not impose using DG2/PVC features.
+
+#include "Inputs/gather.hpp"
+
+int main() {
+  auto Q = queue{gpu_selector_v};
+  esimd_test::printTestLabel(Q);
+
+  constexpr auto TestFeatures = TestFeatures::Generic;
+  bool Passed = true;
+
+  Passed &= testSLM<int8_t, TestFeatures>(Q);
+  Passed &= testSLM<int16_t, TestFeatures>(Q);
+  if (Q.get_device().has(sycl::aspect::fp16))
+    Passed &= testSLM<sycl::half, TestFeatures>(Q);
+  Passed &= testSLM<uint32_t, TestFeatures>(Q);
+  Passed &= testSLM<float, TestFeatures>(Q);
+  Passed &= testSLM<ext::intel::experimental::esimd::tfloat32, TestFeatures>(Q);
+  std::cout << (Passed ? "Passed\n" : "FAILED\n");
+  return Passed ? 0 : 1;
+}
diff --git a/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather_dg2_pvc.cpp b/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather_dg2_pvc.cpp
new file mode 100644
index 0000000000000..4ae98cfc1f41c
--- /dev/null
+++ b/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather_dg2_pvc.cpp
@@ -0,0 +1,38 @@
+//==------- slm_gather_dg2_pvc.cpp - DPC++ ESIMD on-device test ------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// REQUIRES: gpu-intel-dg2 || gpu-intel-pvc
+// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{run} %t.out
+
+// The test verifies esimd::slm_gather() functions accepting  optional
+// compile-time esimd::properties. The slm_gather() calls in this test use
+// VS > 1 (number of loads per offset) and require DG2 or PVC to run.
+
+#include "Inputs/gather.hpp"
+
+int main() {
+  auto Q = queue{gpu_selector_v};
+  esimd_test::printTestLabel(Q);
+
+  // DG2 and PVC support same gather() configurations. If some gather call
+  // has corresponding instructions in PVC and does not have it in DG2, then
+  // GPU RT emulates it for DG2.
+  constexpr auto TestFeatures = TestFeatures::DG2;
+  bool Passed = true;
+
+  Passed &= testSLM<int8_t, TestFeatures>(Q);
+  Passed &= testSLM<int16_t, TestFeatures>(Q);
+  if (Q.get_device().has(sycl::aspect::fp16))
+    Passed &= testSLM<sycl::half, TestFeatures>(Q);
+  Passed &= testSLM<uint32_t, TestFeatures>(Q);
+  Passed &= testSLM<float, TestFeatures>(Q);
+  Passed &= testSLM<ext::intel::experimental::esimd::tfloat32, TestFeatures>(Q);
+
+  std::cout << (Passed ? "Passed\n" : "FAILED\n");
+  return Passed ? 0 : 1;
+}
diff --git a/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather_legacy.cpp b/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather_legacy.cpp
new file mode 100644
index 0000000000000..65747a5947d79
--- /dev/null
+++ b/sycl/test-e2e/ESIMD/unified_memory_api/slm_gather_legacy.cpp
@@ -0,0 +1,22 @@
+//==------- slm_gather_legacy.cpp - DPC++ ESIMD on-device test -------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Use per-kernel compilation to have more information about failing cases.
+// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{run} %t.out
+
+// The test verifies esimd::slm_gather() functions accepting optional
+// compile-time esimd::properties. The slm_gather() calls in this test do not
+// use  VS > 1 (number of loads per offset) to not impose using PVC features.
+//
+// TODO: Remove this test when GPU driver issue with llvm.masked.gather is
+// resolved and ESIMD starts using llvm.masked.gather by default.
+// This "_legacy" test also does not use gather() calls accepting "pass_thru"
+// operand to avoid usage of LSC instructions when llvm.masked.gather is
+// not available. "-D__ESIMD_GATHER_SCATTER_LLVM_IR" is not used here.
+
+#include "slm_gather.cpp"
diff --git a/sycl/test-e2e/Graph/RecordReplay/dotp_in_order_pause.cpp b/sycl/test-e2e/Graph/RecordReplay/dotp_in_order_pause.cpp
new file mode 100644
index 0000000000000..be439affcdf51
--- /dev/null
+++ b/sycl/test-e2e/Graph/RecordReplay/dotp_in_order_pause.cpp
@@ -0,0 +1,96 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %t.out
+// Extra run to check for leaks in Level Zero using UR_L0_LEAKS_DEBUG
+// RUN: %if level_zero %{env UR_L0_LEAKS_DEBUG=1 %{run} %t.out 2>&1 | FileCheck %s --implicit-check-not=LEAK  %}
+
+// Tests a dotp operation using device USM and an in-order queue.
+// Recording is paused, and command is submitted eagerly.
+
+#include "../graph_common.hpp"
+
+void foo(sycl::queue Queue, size_t N, int *X, int *Y, int *Z) {
+
+  auto Graph = Queue.ext_oneapi_get_graph();
+  Graph.end_recording();
+
+  Queue
+      .submit([&](handler &CGH) {
+        CGH.parallel_for(N, [=](id<1> it) {
+          X[it] = 0;
+          Y[it] = 0;
+          Z[it] = 0;
+        });
+      })
+      .wait();
+
+  Graph.begin_recording(Queue);
+}
+
+int main() {
+  property_list Properties{
+      property::queue::in_order{},
+      sycl::ext::intel::property::queue::no_immediate_command_list{}};
+  queue Queue{Properties};
+
+  if (!are_graphs_supported(Queue)) {
+    return 0;
+  }
+
+  exp_ext::command_graph Graph{Queue.get_context(), Queue.get_device()};
+
+  int *Dotp = malloc_device<int>(1, Queue);
+  Queue.memset(Dotp, 0, sizeof(int)).wait();
+
+  const size_t N = 10;
+  int *X = malloc_device<int>(N, Queue);
+  int *Y = malloc_device<int>(N, Queue);
+  int *Z = malloc_device<int>(N, Queue);
+
+  Graph.begin_recording(Queue);
+
+  auto InitEvent = Queue.submit([&](handler &CGH) {
+    CGH.parallel_for(N, [=](id<1> it) {
+      X[it] = 1;
+      Y[it] = 2;
+      Z[it] = 3;
+    });
+  });
+
+  foo(Queue, N, X, Y, Z);
+
+  auto EventA = Queue.submit([&](handler &CGH) {
+    CGH.parallel_for(range<1>{N},
+                     [=](id<1> it) { X[it] = Alpha * X[it] + Beta * Y[it]; });
+  });
+
+  auto EventB = Queue.submit([&](handler &CGH) {
+    CGH.parallel_for(range<1>{N},
+                     [=](id<1> it) { Z[it] = Gamma * Z[it] + Beta * Y[it]; });
+  });
+
+  Queue.submit([&](handler &CGH) {
+    CGH.single_task([=]() {
+      for (size_t j = 0; j < N; j++) {
+        Dotp[0] += X[j] * Z[j];
+      }
+    });
+  });
+
+  Graph.end_recording();
+
+  auto ExecGraph = Graph.finalize();
+
+  Queue.submit([&](handler &CGH) { CGH.ext_oneapi_graph(ExecGraph); });
+
+  int Output;
+  Queue.memcpy(&Output, Dotp, sizeof(int)).wait();
+
+  assert(Output == dotp_reference_result(N));
+
+  sycl::free(Dotp, Queue);
+  sycl::free(X, Queue);
+  sycl::free(Y, Queue);
+  sycl::free(Z, Queue);
+
+  return 0;
+}
diff --git a/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memcpy.cpp b/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memcpy.cpp
index f0582477aebd6..0b4103538fdc9 100644
--- a/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memcpy.cpp
+++ b/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memcpy.cpp
@@ -57,6 +57,7 @@ int main() {
   }
 
   sycl::free(TestData, Queue);
+  sycl::free(TestDataOut, Queue);
 
   return 0;
 }
diff --git a/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memset.cpp b/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memset.cpp
index 3ec920fa81553..12352dacefa46 100644
--- a/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memset.cpp
+++ b/sycl/test-e2e/Graph/RecordReplay/in_order_queue_with_host_managed_dependencies_memset.cpp
@@ -55,6 +55,7 @@ int main() {
   }
 
   sycl::free(TestData, Queue);
+  sycl::free(TestDataOut, Queue);
 
   return 0;
 }
diff --git a/sycl/test-e2e/Matrix/SG32/element_wise_all_ops.cpp b/sycl/test-e2e/Matrix/SG32/element_wise_all_ops.cpp
index 91b36ee032e27..e2831636da0d8 100644
--- a/sycl/test-e2e/Matrix/SG32/element_wise_all_ops.cpp
+++ b/sycl/test-e2e/Matrix/SG32/element_wise_all_ops.cpp
@@ -5,21 +5,16 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-// REQUIRES: matrix
+// REQUIRES: cpu, gpu
 // REQUIRES-INTEL-DRIVER: lin: 27501, win: 101.4943
+// SG size = 32 is not currently supported for SYCL Joint Matrix by IGC on DG2
+// UNSUPPORTED: gpu-intel-dg2
 
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 
-#include <iostream>
-#include <random>
-#include <sycl/sycl.hpp>
+#include "../common.hpp"
 
-using namespace sycl;
-using namespace sycl::ext::oneapi::experimental::matrix;
-using bfloat16 = sycl::ext::oneapi::bfloat16;
-
-constexpr size_t SG_SZ = 32;
-constexpr size_t TN = 16;
+#define SG_SZ 32
 
 #include "../element_wise_all_ops_impl.hpp"
diff --git a/sycl/test-e2e/Matrix/XMX8/element_wise_all_ops.cpp b/sycl/test-e2e/Matrix/XMX8/element_wise_all_ops.cpp
deleted file mode 100644
index f1f7bf84899a4..0000000000000
--- a/sycl/test-e2e/Matrix/XMX8/element_wise_all_ops.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//==------------ element_wise_all_ops.cpp  - DPC++ joint_matrix-------------==//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// REQUIRES: matrix-xmx8
-// REQUIRES: TEMPORARY_DISBLED
-
-// RUN: %{build} -o %t.out
-// RUN: %{run} %t.out
-
-#include <iostream>
-#include <random>
-#include <sycl/sycl.hpp>
-
-using namespace sycl;
-using namespace sycl::ext::oneapi::experimental::matrix;
-using bfloat16 = sycl::ext::oneapi::bfloat16;
-
-#define SG_SZ 8
-constexpr size_t TN = 8;
-
-#include "../element_wise_all_ops_impl.hpp"
diff --git a/sycl/test-e2e/Matrix/common.hpp b/sycl/test-e2e/Matrix/common.hpp
index 675261a17f3cb..155cf012d9754 100644
--- a/sycl/test-e2e/Matrix/common.hpp
+++ b/sycl/test-e2e/Matrix/common.hpp
@@ -1,3 +1,10 @@
+//==------------------ common.hpp  - DPC++ joint_matrix---------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
 #include <cmath>
 #include <iostream>
 #include <random>
@@ -173,3 +180,27 @@ bool matrix_compare(unsigned int rows, unsigned int cols, T1 *src, T2 *ref) {
   }
   return true;
 }
+
+bool is_type_supported_by_device(queue q, matrix_type type) {
+  std::vector<combination> combinations =
+      q.get_device()
+          .get_info<sycl::ext::oneapi::experimental::info::device::
+                        matrix_combinations>();
+  for (int i = 0; i < combinations.size(); i++) {
+    if (combinations[i].atype == type) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template <typename KernelName> size_t get_sg_size(queue q) {
+  auto KernelID = get_kernel_id<KernelName>();
+  auto KB =
+      get_kernel_bundle<bundle_state::executable>(q.get_context(), {KernelID});
+  auto kernel = KB.get_kernel(KernelID);
+
+  return kernel
+      .template get_info<info::kernel_device_specific::max_sub_group_size>(
+          q.get_device());
+}
diff --git a/sycl/test-e2e/Matrix/element_wise_all_ops.cpp b/sycl/test-e2e/Matrix/element_wise_all_ops.cpp
index fd3648664a52c..4ee8383154e85 100644
--- a/sycl/test-e2e/Matrix/element_wise_all_ops.cpp
+++ b/sycl/test-e2e/Matrix/element_wise_all_ops.cpp
@@ -5,20 +5,14 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-// REQUIRES: matrix
+// REQUIRES: cpu, gpu
+// Test is flaky/timeouts on some variants of DG2 and temporary disabled. Needs
+// to be investigated.
+// UNSUPPORTED: gpu-intel-dg2
 
 // RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 
-#include <iostream>
-#include <random>
-#include <sycl/sycl.hpp>
-
-using namespace sycl;
-using namespace sycl::ext::oneapi::experimental::matrix;
-using bfloat16 = sycl::ext::oneapi::bfloat16;
-
-#define SG_SZ 16
-constexpr size_t TN = 16;
+#include "common.hpp"
 
 #include "element_wise_all_ops_impl.hpp"
diff --git a/sycl/test-e2e/Matrix/element_wise_all_ops_impl.hpp b/sycl/test-e2e/Matrix/element_wise_all_ops_impl.hpp
index b11d3093bf08d..55d1162ebd3af 100644
--- a/sycl/test-e2e/Matrix/element_wise_all_ops_impl.hpp
+++ b/sycl/test-e2e/Matrix/element_wise_all_ops_impl.hpp
@@ -5,24 +5,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-
-static float make_fp32(bfloat16 x) {
-  unsigned int y = *((int *)&x);
-  y = y << 16;
-  float *res = reinterpret_cast<float *>(&y);
-  return *res;
-}
-
-template <typename T, size_t NUM_ROWS, size_t NUM_COLS> struct big_matrix {
-public:
-  T *mat;
-
-public:
-  T *get_data() { return mat; }
-  void set_data(T *data) { mat = data; }
-  big_matrix(T *data) : mat(data) {}
-};
-
 template <typename T, size_t NUM_ROWS, size_t NUM_COLS>
 void assert_ops_ref(host_accessor<T, 2, access::mode::read> mat,
                     const float ref) {
@@ -39,7 +21,7 @@ void assert_ops_ref(host_accessor<T, 2, access::mode::read> mat,
 }
 
 template <typename T, size_t NUM_ROWS, size_t NUM_COLS, size_t SUB_ROWS,
-          size_t SUB_COLS, typename OP>
+          size_t SUB_COLS, class kernel_name, typename OP>
 void verify_op_a(const T l, const T r, const float ref, OP op) {
   T mat[NUM_ROWS][NUM_COLS];
   big_matrix<T, NUM_ROWS, NUM_COLS> big_mat((T *)&mat);
@@ -47,12 +29,17 @@ void verify_op_a(const T l, const T r, const float ref, OP op) {
   buffer<T, 2> bufMat(big_mat.get_data(), range<2>(NUM_ROWS, NUM_COLS));
 
   queue q;
+  size_t sg_size = get_sg_size<kernel_name>(q);
   q.submit([&](handler &cgh) {
      sycl::accessor accessMat{bufMat, cgh, sycl::read_write};
-     cgh.parallel_for(
-         nd_range<2>({NUM_ROWS / SUB_ROWS, NUM_COLS / SUB_COLS * SG_SZ},
-                     {1, 1 * SG_SZ}),
-         [=](nd_item<2> spmd_item) [[intel::reqd_sub_group_size(SG_SZ)]] {
+     cgh.parallel_for<kernel_name>(
+         nd_range<2>({NUM_ROWS / SUB_ROWS, NUM_COLS / SUB_COLS * sg_size},
+                     {1, 1 * sg_size}),
+         [=](nd_item<2> spmd_item)
+#ifdef SG_SZ
+             [[intel::reqd_sub_group_size(SG_SZ)]]
+#endif
+         {
            const auto global_idx = spmd_item.get_global_id(0);
            const auto global_idy = spmd_item.get_global_id(1);
            const auto sg_startx = global_idx - spmd_item.get_local_id(0);
@@ -68,7 +55,7 @@ void verify_op_a(const T l, const T r, const float ref, OP op) {
                sg, sub_mat,
                accessMat.template get_multi_ptr<access::decorated::no>() +
                    (sg_startx * SUB_ROWS) * NUM_COLS +
-                   sg_starty / SG_SZ * SUB_COLS,
+                   sg_starty / sg_size * SUB_COLS,
                NUM_COLS);
          }); // parallel for
    }).wait();
@@ -76,20 +63,24 @@ void verify_op_a(const T l, const T r, const float ref, OP op) {
 }
 
 template <typename T, size_t NUM_ROWS, size_t NUM_COLS, size_t SUB_ROWS,
-          size_t SUB_COLS, typename OP>
+          size_t SUB_COLS, class kernel_name, typename OP>
 void verify_op_c(const T l, const T r, const float ref, OP op) {
   T mat[NUM_ROWS][NUM_COLS];
   big_matrix<T, NUM_ROWS, NUM_COLS> big_mat((T *)&mat);
 
   buffer<T, 2> bufMat(big_mat.get_data(), range<2>(NUM_ROWS, NUM_COLS));
-
   queue q;
+  size_t sg_size = get_sg_size<kernel_name>(q);
   q.submit([&](handler &cgh) {
      sycl::accessor accessMat{bufMat, cgh, sycl::read_write};
-     cgh.parallel_for(
-         nd_range<2>({NUM_ROWS / SUB_ROWS, NUM_COLS / SUB_COLS * SG_SZ},
-                     {1, 1 * SG_SZ}),
-         [=](nd_item<2> spmd_item) [[intel::reqd_sub_group_size(SG_SZ)]] {
+     cgh.parallel_for<kernel_name>(
+         nd_range<2>({NUM_ROWS / SUB_ROWS, NUM_COLS / SUB_COLS * sg_size},
+                     {1, 1 * sg_size}),
+         [=](nd_item<2> spmd_item)
+#ifdef SG_SZ
+             [[intel::reqd_sub_group_size(SG_SZ)]]
+#endif
+         {
            const auto global_idx = spmd_item.get_global_id(0);
            const auto global_idy = spmd_item.get_global_id(1);
            const auto sg_startx = global_idx - spmd_item.get_local_id(0);
@@ -105,85 +96,103 @@ void verify_op_c(const T l, const T r, const float ref, OP op) {
                sg, sub_mat,
                accessMat.template get_multi_ptr<access::decorated::no>() +
                    (sg_startx * SUB_ROWS) * NUM_COLS +
-                   sg_starty / SG_SZ * SUB_COLS,
+                   sg_starty / sg_size * SUB_COLS,
                NUM_COLS, layout::row_major);
          }); // parallel for
    }).wait();
   assert_ops_ref<T, NUM_ROWS, NUM_COLS>(bufMat.get_host_access(read_only), ref);
 }
 
+// Avoid same kernel name for different types
+template <typename T, class name> class ewops_a {};
 template <typename T, size_t NROWS, size_t NCOLS, size_t SROWS, size_t SCOLS>
 void test_ewops_a() {
 
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_add>>(
       T(5.0), T(2.0), 7.0, [](auto l, auto r) { return l + r; });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_sub>>(
       T(5.0), T(2.0), 3.0, [](auto l, auto r) { return l - r; });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_mul>>(
       T(5.0), T(2.0), 10.0, [](auto l, auto r) { return l * r; });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_div>>(
       T(5.0), T(2.0), 2.5, [](auto l, auto r) { return l / r; });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_logical>>(
       T(5.0), T(5.0), 5.0, [](auto l, auto r) { return l == r ? l : T(1.0); });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_eq>>(
       T(5.0), T(4.0), 4.0, [](auto l, auto r) { return l == r ? l : r; });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_ne>>(
       T(5.0), T(5.0), 1.0, [](auto l, auto r) { return l != r ? l : T(1.0); });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_gt>>(
       T(5.0), T(2.0), 3.0,
       [](auto l, auto r) { return l > r ? T(3.0) : T(2.0); });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_lt>>(
       T(5.0), T(2.0), 2.0,
       [](auto l, auto r) { return l < r ? T(3.0) : T(2.0); });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_ge>>(
       T(5.0), T(2.0), 3.0,
       [](auto l, auto r) { return l >= r ? T(3.0) : T(2.0); });
-  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_a<T, NROWS, NCOLS, SROWS, SCOLS, ewops_a<T, class a_le>>(
       T(5.0), T(2.0), 2.0,
       [](auto l, auto r) { return l <= r ? T(3.0) : T(2.0); });
 }
-
+// Avoid same kernel name for different types and numbers of columns
+template <typename T, size_t COLS, class name> class ewops_c {};
 template <typename T, size_t NROWS, size_t NCOLS, size_t SROWS, size_t SCOLS>
 void test_ewops_c() {
 
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_add>>(
       T(5.0), T(2.0), 7.0, [](auto l, auto r) { return l + r; });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_sub>>(
       T(5.0), T(2.0), 3.0, [](auto l, auto r) { return l - r; });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_mul>>(
       T(5.0), T(2.0), 10.0, [](auto l, auto r) { return l * r; });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_div>>(
       T(5.0), T(2.0), 2.5, [](auto l, auto r) { return l / r; });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS,
+              ewops_c<T, SCOLS, class c_logical>>(
       T(5.0), T(5.0), 5.0, [](auto l, auto r) { return l == r ? l : T(1.0); });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_eq>>(
       T(5.0), T(4.0), 4.0, [](auto l, auto r) { return l == r ? l : r; });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_ne>>(
       T(5.0), T(5.0), 1.0, [](auto l, auto r) { return l != r ? l : T(1.0); });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_gt>>(
       T(5.0), T(2.0), 3.0,
       [](auto l, auto r) { return l > r ? T(3.0) : T(2.0); });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_lt>>(
       T(5.0), T(2.0), 2.0,
       [](auto l, auto r) { return l < r ? T(3.0) : T(2.0); });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_ge>>(
       T(5.0), T(2.0), 3.0,
       [](auto l, auto r) { return l >= r ? T(3.0) : T(2.0); });
-  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS>(
+  verify_op_c<T, NROWS, NCOLS, SROWS, SCOLS, ewops_c<T, SCOLS, class c_le>>(
       T(5.0), T(2.0), 2.0,
       [](auto l, auto r) { return l <= r ? T(3.0) : T(2.0); });
 }
 
 int main() {
   static constexpr size_t TM = 8;
-  static constexpr size_t TK = 16;
 
   static constexpr size_t MATRIX_M = TM * 2;
-  static constexpr size_t MATRIX_N = TN * 2;
-  static constexpr size_t MATRIX_K = TK * 2;
-
-  test_ewops_a<bfloat16, MATRIX_M, MATRIX_K, TM, TK>();
-  test_ewops_c<float, MATRIX_M, MATRIX_N, TM, TN>();
-
+  static constexpr size_t MATRIX_N = 32;
+  static constexpr size_t MATRIX_K = 32;
+  queue q;
+  std::vector<combination> combinations =
+      q.get_device()
+          .get_info<sycl::ext::oneapi::experimental::info::device::
+                        matrix_combinations>();
+  for (unsigned int i = 0; i < combinations.size(); i++) {
+    if (combinations[i].atype == matrix_type::bf16) {
+      if (combinations[i].nsize == 0 || combinations[i].nsize == 16) {
+        test_ewops_a<bfloat16, MATRIX_M, MATRIX_K, TM, 16>();
+        test_ewops_c<float, MATRIX_M, MATRIX_N, TM, 16>();
+        break;
+      }
+      if (combinations[i].nsize == 8) {
+        test_ewops_a<bfloat16, MATRIX_M, MATRIX_K, TM, 16>();
+        test_ewops_c<float, MATRIX_M, MATRIX_N, TM, 8>();
+        break;
+      }
+    }
+  }
   return 0;
 }
diff --git a/sycl/test-e2e/Plugin/level_zero_barrier_optimization.cpp b/sycl/test-e2e/Plugin/level_zero_barrier_optimization.cpp
index d46fe6c80cc33..91171d6ce0dd1 100644
--- a/sycl/test-e2e/Plugin/level_zero_barrier_optimization.cpp
+++ b/sycl/test-e2e/Plugin/level_zero_barrier_optimization.cpp
@@ -54,7 +54,7 @@ int main() {
 
     // CHECK: Test2
     // CHECK: ---> piEnqueueEventsWaitWithBarrier(
-    // CHECK: ZE ---> zeEventCreate
+    // CHECK: ZE ---> {{zeEventCreate|zeEventHostReset}}
     // CHECK: ZE ---> zeCommandListAppendWaitOnEvents
     // CHECK: ZE ---> zeCommandListAppendSignalEvent
     // CHECK: ) ---> 	pi_result : PI_SUCCESS
diff --git a/sycl/test-e2e/README.md b/sycl/test-e2e/README.md
index ce5e494f78f12..c8157d4e219ed 100644
--- a/sycl/test-e2e/README.md
+++ b/sycl/test-e2e/README.md
@@ -250,7 +250,7 @@ configure specific single test execution in the command line:
    system. It is developer / CI infra responsibility to make sure that the
    device is available in the system. Tests requiring DG1 to run must use proper
    device selector to ensure that. Use SYCL_DEVICE_ALLOWLIST or
-   SYCL_DEVICE_FILTER to get proper configuration (see
+   ONEAPI_DEVICE_SELECTOR to get proper configuration (see
    [EnvironmentVariables.md](https://github.com/intel/llvm/blob/sycl/sycl/doc/EnvironmentVariables.md));
  * **gpu-intel-dg2** - tells LIT infra that Intel GPU DG2 is present in the
    system. It is developer / CI infra responsibility to make sure that the
diff --git a/sycl/test-e2e/SubGroup/load_store.cpp b/sycl/test-e2e/SubGroup/load_store.cpp
index a42aa436235cc..b140347dc872d 100644
--- a/sycl/test-e2e/SubGroup/load_store.cpp
+++ b/sycl/test-e2e/SubGroup/load_store.cpp
@@ -244,6 +244,16 @@ int main() {
       check<aligned_half, 4>(Queue);
       check<aligned_half, 8>(Queue);
       check<aligned_half, 16>(Queue);
+
+      typedef sycl::ext::oneapi::bfloat16 aligned_bfloat16
+          __attribute__((aligned(16)));
+      check<aligned_bfloat16>(Queue);
+      check<aligned_bfloat16, 1>(Queue);
+      check<aligned_bfloat16, 2>(Queue);
+      check<aligned_bfloat16, 3>(Queue);
+      check<aligned_bfloat16, 4>(Queue);
+      check<aligned_bfloat16, 8>(Queue);
+      check<aligned_bfloat16, 16>(Queue);
     }
   }
   if (std::find(Vec.begin(), Vec.end(), "cl_intel_subgroups_long") !=
diff --git a/sycl/test/abi/sycl_symbols_linux.dump b/sycl/test/abi/sycl_symbols_linux.dump
index a42b9b6cf460a..b49c50ca0c62c 100644
--- a/sycl/test/abi/sycl_symbols_linux.dump
+++ b/sycl/test/abi/sycl_symbols_linux.dump
@@ -3935,9 +3935,9 @@ _ZN4sycl3_V16detail13MemoryManager29ext_oneapi_copyD2D_cmd_bufferESt10shared_ptr
 _ZN4sycl3_V16detail13MemoryManager29ext_oneapi_copyD2H_cmd_bufferESt10shared_ptrINS1_12context_implEEP22_pi_ext_command_bufferPNS1_11SYCLMemObjIEPvjNS0_5rangeILi3EEESC_NS0_2idILi3EEEjPcjSC_SE_jSt6vectorIjSaIjEEPj
 _ZN4sycl3_V16detail13MemoryManager29ext_oneapi_copyH2D_cmd_bufferESt10shared_ptrINS1_12context_implEEP22_pi_ext_command_bufferPNS1_11SYCLMemObjIEPcjNS0_5rangeILi3EEENS0_2idILi3EEEjPvjSC_SC_SE_jSt6vectorIjSaIjEEPj
 _ZN4sycl3_V16detail13MemoryManager30ext_oneapi_copy_usm_cmd_bufferESt10shared_ptrINS1_12context_implEEPKvP22_pi_ext_command_buffermPvSt6vectorIjSaIjEEPj
+_ZN4sycl3_V16detail13MemoryManager30ext_oneapi_fill_usm_cmd_bufferESt10shared_ptrINS1_12context_implEEP22_pi_ext_command_bufferPvmiSt6vectorIjSaIjEEPj
 _ZN4sycl3_V16detail13MemoryManager32ext_oneapi_advise_usm_cmd_bufferESt10shared_ptrINS1_12context_implEEP22_pi_ext_command_bufferPKvm14_pi_mem_adviceSt6vectorIjSaIjEEPj
 _ZN4sycl3_V16detail13MemoryManager34ext_oneapi_prefetch_usm_cmd_bufferESt10shared_ptrINS1_12context_implEEP22_pi_ext_command_bufferPvmSt6vectorIjSaIjEEPj
-_ZN4sycl3_V16detail13MemoryManager30ext_oneapi_fill_usm_cmd_bufferESt10shared_ptrINS1_12context_implEEP22_pi_ext_command_bufferPvmiSt6vectorIjSaIjEEPj
 _ZN4sycl3_V16detail13MemoryManager3mapEPNS1_11SYCLMemObjIEPvSt10shared_ptrINS1_10queue_implEENS0_6access4modeEjNS0_5rangeILi3EEESC_NS0_2idILi3EEEjSt6vectorIP9_pi_eventSaISH_EERSH_
 _ZN4sycl3_V16detail13MemoryManager4copyEPNS1_11SYCLMemObjIEPvSt10shared_ptrINS1_10queue_implEEjNS0_5rangeILi3EEESA_NS0_2idILi3EEEjS5_S8_jSA_SA_SC_jSt6vectorIP9_pi_eventSaISF_EERSF_
 _ZN4sycl3_V16detail13MemoryManager4copyEPNS1_11SYCLMemObjIEPvSt10shared_ptrINS1_10queue_implEEjNS0_5rangeILi3EEESA_NS0_2idILi3EEEjS5_S8_jSA_SA_SC_jSt6vectorIP9_pi_eventSaISF_EERSF_RKS6_INS1_10event_implEE
@@ -4273,6 +4273,7 @@ _ZNK4sycl3_V15queue12has_propertyINS0_8property5queue16enable_profilingEEEbv
 _ZNK4sycl3_V15queue12has_propertyINS0_8property5queue4cuda18use_default_streamEEEbv
 _ZNK4sycl3_V15queue12has_propertyINS0_8property5queue8in_orderEEEbv
 _ZNK4sycl3_V15queue16ext_oneapi_emptyEv
+_ZNK4sycl3_V15queue20ext_oneapi_get_graphEv
 _ZNK4sycl3_V15queue20ext_oneapi_get_stateEv
 _ZNK4sycl3_V15queue25ext_oneapi_get_last_eventEv
 _ZNK4sycl3_V15queue28ext_codeplay_supports_fusionEv
diff --git a/sycl/test/abi/sycl_symbols_windows.dump b/sycl/test/abi/sycl_symbols_windows.dump
index c397ffe390705..b5d0b3f3de707 100644
--- a/sycl/test/abi/sycl_symbols_windows.dump
+++ b/sycl/test/abi/sycl_symbols_windows.dump
@@ -1050,6 +1050,7 @@
 ?ext_oneapi_get_default_context@platform@_V1@sycl@@QEBA?AVcontext@23@XZ
 ?ext_oneapi_get_kernel@kernel_bundle_plain@detail@_V1@sycl@@QEAA?AVkernel@34@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z
 ?ext_oneapi_get_last_event@queue@_V1@sycl@@QEBA?AVevent@23@XZ
+?ext_oneapi_get_graph@queue@_V1@sycl@@QEBA?AV?$command_graph@$0A@@experimental@oneapi@ext@23@XZ
 ?ext_oneapi_get_state@queue@_V1@sycl@@QEBA?AW4queue_state@experimental@oneapi@ext@23@XZ
 ?ext_oneapi_graph@handler@_V1@sycl@@QEAAXV?$command_graph@$00@experimental@oneapi@ext@23@@Z
 ?ext_oneapi_graph@queue@_V1@sycl@@QEAA?AVevent@23@V?$command_graph@$00@experimental@oneapi@ext@23@AEBUcode_location@detail@23@@Z
diff --git a/sycl/test/basic_tests/device-selectors-exception.cpp b/sycl/test/basic_tests/device-selectors-exception.cpp
index 774832dc28492..5bddf0ed43454 100644
--- a/sycl/test/basic_tests/device-selectors-exception.cpp
+++ b/sycl/test/basic_tests/device-selectors-exception.cpp
@@ -1,5 +1,7 @@
 // RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple %s -o %t.out
 // RUN: env SYCL_DEVICE_FILTER="" %t.out
+// RUN: %if preview-breaking-changes-supported %{ %clangxx -fsycl -fsycl-targets=%sycl_triple -fpreview-breaking-changes %s -o %t.out %}
+// RUN: %if preview-breaking-changes-supported %{ env ONEAPI_DEVICE_SELECTOR="" %t.out %}
 
 #include <sycl/sycl.hpp>
 using namespace sycl;
diff --git a/sycl/test/basic_tests/generic_type_traits.cpp b/sycl/test/basic_tests/generic_type_traits.cpp
index 307dc6c4212c4..7805adec45789 100644
--- a/sycl/test/basic_tests/generic_type_traits.cpp
+++ b/sycl/test/basic_tests/generic_type_traits.cpp
@@ -63,6 +63,10 @@ int main() {
 
   static_assert(d::is_half_v<s::half>);
 
+  static_assert(d::is_bfloat16_v<sycl::ext::oneapi::bfloat16>);
+  static_assert(d::is_half_or_bf16_v<s::half>);
+  static_assert(d::is_half_or_bf16_v<sycl::ext::oneapi::bfloat16>);
+
   // TODO add checks for the following type traits
   /*
   is_doublen
diff --git a/sycl/test/basic_tests/implicit_device_copyable_types.cpp b/sycl/test/basic_tests/implicit_device_copyable_types.cpp
index dd15f80b8120e..ee368207bc24e 100644
--- a/sycl/test/basic_tests/implicit_device_copyable_types.cpp
+++ b/sycl/test/basic_tests/implicit_device_copyable_types.cpp
@@ -100,6 +100,9 @@ int main() {
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   // Extra checks
   static_assert(sycl::is_device_copyable_v<sycl::vec<int, 4>>);
+  static_assert(sycl::is_device_copyable_v<sycl::vec<sycl::half, 4>>);
+  static_assert(
+      sycl::is_device_copyable_v<sycl::vec<sycl::ext::oneapi::bfloat16, 4>>);
 
   struct S {
     sycl::vec<int, 4> v;
diff --git a/sycl/test/basic_tests/types.cpp b/sycl/test/basic_tests/types.cpp
index cc07202f393db..6aab1e433c7a7 100644
--- a/sycl/test/basic_tests/types.cpp
+++ b/sycl/test/basic_tests/types.cpp
@@ -204,6 +204,18 @@ void checkVariousVecUnaryOps() {
   checkVecUnaryOps(vd1);
   sycl::vec<double, 16> vd{0, 4, 5, -9, 0, 4, 5, -9, 0, 4, 5, -9, 0, 4, 5, -9};
   checkVecUnaryOps(vd);
+
+  sycl::vec<sycl::half, 1> vh1{1};
+  checkVecUnaryOps(vh1);
+  sycl::vec<sycl::half, 16> vh{0, 4, 5, -9, 0, 4, 5, -9,
+                               0, 4, 5, -9, 0, 4, 5, -9};
+  checkVecUnaryOps(vh);
+
+  sycl::vec<sycl::ext::oneapi::bfloat16, 1> vbf1{1};
+  checkVecUnaryOps(vbf1);
+  sycl::vec<sycl::ext::oneapi::bfloat16, 16> vbf{0, 4, 5, -9, 0, 4, 5, -9,
+                                                 0, 4, 5, -9, 0, 4, 5, -9};
+  checkVecUnaryOps(vbf);
 }
 
 int main() {
diff --git a/sycl/test/esimd/intrins_trans.cpp b/sycl/test/esimd/intrins_trans.cpp
index 89e26b04db1b2..615cbb15169a8 100644
--- a/sycl/test/esimd/intrins_trans.cpp
+++ b/sycl/test/esimd/intrins_trans.cpp
@@ -304,7 +304,7 @@ SYCL_ESIMD_FUNCTION SYCL_EXTERNAL simd<float, 16> foo() {
     // CHECK-STATEFUL: call void @llvm.genx.scatter.scaled.v8i1.v8i32.v8i32(<8 x i1> %{{[0-9a-zA-Z_.]+}}, i32 2, i16 0, i32 %[[SI4]], i32 %{{[0-9a-zA-Z_.]+}}, <8 x i32> %{{[0-9a-zA-Z_.]+}}, <8 x i32> %{{[0-9a-zA-Z_.]+}})
     // CHECK-STATELESS: call void @llvm.genx.svm.scatter.v8i1.v8i64.v8i32(<8 x i1> %{{[0-9a-zA-Z_.]+}}, i32 0, <8 x i64> %{{[0-9a-zA-Z_.]+}}, <8 x i32> %{{[0-9a-zA-Z_.]+}})
 
-    // 1-byte element gather
+    // 1-byte element gather: same code with and without mask
     simd<unsigned char, 8> v1 = gather<unsigned char, 8>(acc, offsets, 100);
     // CHECK-STATEFUL: %[[SI5_VAL:[0-9a-zA-Z_.]+]] = call spir_func noundef i32 @_Z21__spirv_ConvertPtrToU{{.*}}(ptr addrspace(1) noundef %{{[0-9a-zA-Z_.]+}})
     // CHECK-STATEFUL: store i32 %[[SI5_VAL]], ptr addrspace(4) %[[SI5_ADDR:[0-9a-zA-Z_.]+]]
@@ -312,6 +312,18 @@ SYCL_ESIMD_FUNCTION SYCL_EXTERNAL simd<float, 16> foo() {
     // CHECK-STATEFUL: call <8 x i32> @llvm.genx.gather.masked.scaled2.v8i32.v8i32.v8i1(i32 0, i16 0, i32 %[[SI5]], i32 %{{[0-9a-zA-Z_.]+}}, <8 x i32> %{{[0-9a-zA-Z_.]+}}, <8 x i1> %{{[0-9a-zA-Z_.]+}})
     // CHECK-STATELESS: call <32 x i8> @llvm.genx.svm.gather.v32i8.v8i1.v8i64(<8 x i1> %{{[0-9a-zA-Z_.]+}}, i32 0, <8 x i64> %{{[0-9a-zA-Z_.]+}}, <32 x i8> undef)
 
+    // 1-byte element gather using the mask
+    v1 = gather<unsigned char, 8>(acc, offsets, 100, pred);
+    // CHECK-STATEFUL: call <8 x i32> @llvm.genx.gather.masked.scaled2.v8i32.v8i32.v8i1(i32 0, i16 0, i32 {{[^)]+}}, i32 {{[^)]+}}, <8 x i32> {{[^)]+}}, <8 x i1> {{[^)]+}})
+    // CHECK-STATELESS: call <32 x i8> @llvm.genx.svm.gather.v32i8.v8i1.v8i64(<8 x i1> {{[^)]+}}, i32 0, <8 x i64> {{[^)]+}}, <32 x i8> undef)
+
+    // 1-byte element gather using the mask - the mask is signed, which may
+    // expose different issues/conflicts in gather API.
+    simd<int32_t, 8> ioffsets = 1;
+    v1 = gather<unsigned char, 8>(acc, ioffsets, 0, pred);
+    // CHECK-STATEFUL: call <8 x i32> @llvm.genx.gather.masked.scaled2.v8i32.v8i32.v8i1(i32 0, i16 0, i32 {{[^)]+}}, i32 {{[^)]+}}, <8 x i32> {{[^)]+}}, <8 x i1> {{[^)]+}})
+    // CHECK-STATELESS: call <32 x i8> @llvm.genx.svm.gather.v32i8.v8i1.v8i64(<8 x i1> {{[^)]+}}, i32 0, <8 x i64> {{[^)]+}}, <32 x i8> undef)
+
     // 1-byte element scatter
     scatter<unsigned char, 8>(acc, offsets, v1, 100, pred);
     // CHECK-STATEFUL: %[[SI6_VAL:[0-9a-zA-Z_.]+]] = call spir_func noundef i32 @_Z21__spirv_ConvertPtrToU{{.*}}(ptr addrspace(1) noundef %{{[0-9a-zA-Z_.]+}})
diff --git a/sycl/test/esimd/lsc.cpp b/sycl/test/esimd/lsc.cpp
index f6b1d8b47bde2..5f4028715950c 100644
--- a/sycl/test/esimd/lsc.cpp
+++ b/sycl/test/esimd/lsc.cpp
@@ -103,7 +103,7 @@ SYCL_ESIMD_FUNCTION SYCL_EXTERNAL void foo(AccType &acc) {
   // CHECK: call void @llvm.genx.lsc.store.slm.v1i1.v1i32.v4i32(<1 x i1> {{[^)]+}}, i8 4, i8 0, i8 0, i16 1, i32 0, i8 3, i8 4, i8 2, i8 0, <1 x i32> {{[^)]+}}, <4 x i32> {{[^)]+}}, i32 0)
   lsc_slm_block_store<int, VL>(surf_offset, data1);
 
-  // CHECK: call <4 x i32> @llvm.genx.lsc.load.slm.v4i32.v4i1.v4i32(<4 x i1> {{[^)]+}}, i8 0, i8 0, i8 0, i16 1, i32 0, i8 3, i8 1, i8 1, i8 0, <4 x i32> {{[^)]+}}, i32 0)
+  // CHECK: call <4 x i32> @llvm.genx.lsc.load.merge.slm.v4i32.v4i1.v4i32(<4 x i1> {{[^)]+}}, i8 0, i8 0, i8 0, i16 1, i32 0, i8 3, i8 1, i8 1, i8 0, <4 x i32> {{[^)]+}}, i32 0, <4 x i32> {{[^)]+}})
   simd<int, VL> data6 = lsc_slm_gather<int>(offsets);
 
   auto add = simd<int, VL>(5);
diff --git a/sycl/test/esimd/memory_properties.cpp b/sycl/test/esimd/memory_properties.cpp
index a2e2364b5d766..737d7b4fabfad 100644
--- a/sycl/test/esimd/memory_properties.cpp
+++ b/sycl/test/esimd/memory_properties.cpp
@@ -33,6 +33,8 @@ test_block_store(AccType &, LocalAccType &local_acc, float *, int byte_offset32,
 SYCL_ESIMD_FUNCTION SYCL_EXTERNAL void
 test_gather_scatter(AccType &, float *, int byte_offset32,
                     size_t byte_offset64);
+SYCL_ESIMD_FUNCTION SYCL_EXTERNAL void
+test_slm_gather_scatter(int byte_offset32);
 
 class EsimdFunctor {
 public:
@@ -47,6 +49,7 @@ class EsimdFunctor {
     test_atomic_update(acc, local_acc_int, ptr, byte_offset32, byte_offset64);
     test_block_store(acc, local_acc, ptr, byte_offset32, byte_offset64);
     test_gather_scatter(acc, ptr, byte_offset32, byte_offset64);
+    test_slm_gather_scatter(byte_offset32);
   }
 };
 
@@ -1149,3 +1152,95 @@ test_gather_scatter(AccType &acc, float *ptrf, int byte_offset32,
   acc_res = gather<float, 32, 2>(acc, ioffset_n16_view, mask_n16,
                                  pass_thru_view, props_align4);
 }
+
+// CHECK-LABEL: define {{.*}} @_Z23test_slm_gather_scatter{{.*}}
+SYCL_ESIMD_FUNCTION SYCL_EXTERNAL void
+test_slm_gather_scatter(int byte_offset32) {
+
+  properties props_align4{alignment<4>};
+  properties props_align8{alignment<8>};
+
+  simd<uint32_t, 32> ioffset_n32(byte_offset32, 8);
+  auto ioffset_n32_view = ioffset_n32.select<32, 1>();
+
+  simd<uint32_t, 16> ioffset_n16(byte_offset32, 8);
+  auto ioffset_n16_view = ioffset_n16.select<16, 1>();
+
+  simd_mask<32> mask_n32 = 1;
+  simd_mask<16> mask_n16 = 1;
+
+  simd<float, 32> slm;
+  simd<float, 32> pass_thru;
+  auto pass_thru_view = pass_thru.select<32, 1>();
+
+  // Test SLM gather using this plan:
+  // 1) slm_gather(offsets): offsets is simd or simd_view
+  // 2) slm_gather(offsets, mask): offsets is simd or simd_view
+  // 3) slm_gather( offsets, mask, pass_thru)
+  // 4) slm_gather(...): same as (1), (2), (3) above, but with VS > 1.
+
+  // 1) slm_gather(offsets): offsets is simd or simd_view
+  // CHECK-COUNT-2: call <32 x float> @llvm.masked.gather.v32f32.v32p3(<32 x ptr addrspace(3)> {{[^)]+}}, i32 4, <32 x i1> {{[^)]+}}, <32 x float> {{[^)]+}})
+  slm = slm_gather<float>(ioffset_n32);
+  slm = slm_gather<float, 32>(ioffset_n32_view);
+
+  // CHECK-COUNT-2: call <32 x float> @llvm.masked.gather.v32f32.v32p3(<32 x ptr addrspace(3)> {{[^)]+}}, i32 8, <32 x i1> {{[^)]+}}, <32 x float> {{[^)]+}})
+  slm = slm_gather<float>(ioffset_n32, props_align8);
+  slm = slm_gather<float, 32>(ioffset_n32_view, props_align8);
+
+  // 2) slm_gather(offsets, mask): offsets is simd or simd_view
+  // CHECK-COUNT-2: call <32 x float> @llvm.masked.gather.v32f32.v32p3(<32 x ptr addrspace(3)> {{[^)]+}}, i32 4, <32 x i1> {{[^)]+}}, <32 x float> {{[^)]+}})
+  slm = slm_gather<float>(ioffset_n32, mask_n32);
+  slm = slm_gather<float, 32>(ioffset_n32_view, mask_n32);
+
+  // CHECK-COUNT-2: call <32 x float> @llvm.masked.gather.v32f32.v32p3(<32 x ptr addrspace(3)> {{[^)]+}}, i32 8, <32 x i1> {{[^)]+}}, <32 x float> {{[^)]+}})
+  slm = slm_gather<float>(ioffset_n32, mask_n32, props_align8);
+  slm = slm_gather<float, 32>(ioffset_n32_view, mask_n32, props_align8);
+
+  // 3) slm_gather(offsets, mask, pass_thru)
+  // CHECK-COUNT-4: call <32 x float> @llvm.masked.gather.v32f32.v32p3(<32 x ptr addrspace(3)> {{[^)]+}}, i32 4, <32 x i1> {{[^)]+}}, <32 x float> {{[^)]+}})
+  slm = slm_gather<float>(ioffset_n32, mask_n32, pass_thru);
+  slm = slm_gather<float, 32>(ioffset_n32_view, mask_n32, pass_thru);
+  slm = slm_gather<float, 32>(ioffset_n32, mask_n32, pass_thru_view);
+  slm = slm_gather<float, 32>(ioffset_n32_view, mask_n32, pass_thru_view);
+
+  // CHECK-COUNT-4: call <32 x float> @llvm.masked.gather.v32f32.v32p3(<32 x ptr addrspace(3)> {{[^)]+}}, i32 8, <32 x i1> {{[^)]+}}, <32 x float> {{[^)]+}})
+  slm = slm_gather<float>(ioffset_n32, mask_n32, pass_thru, props_align8);
+  slm = slm_gather<float, 32>(ioffset_n32_view, mask_n32, pass_thru,
+                              props_align8);
+  slm = slm_gather<float, 32>(ioffset_n32, mask_n32, pass_thru_view,
+                              props_align8);
+  slm = slm_gather<float, 32>(ioffset_n32_view, mask_n32, pass_thru_view,
+                              props_align8);
+
+  // 4) slm_gather(...): same as (1), (2), (3) above, but with VS > 1.
+  // CHECK-COUNT-16: call <32 x i32> @llvm.genx.lsc.load.merge.slm.v32i32.v16i1.v16i32(<16 x i1> {{[^)]+}}, i8 0, i8 0, i8 0, i16 1, i32 0, i8 3, i8 2, i8 1, i8 0, <16 x i32> {{[^)]+}}, i32 0, <32 x i32> {{[^)]+}})
+  // 4a) check VS > 1. no 'mask' operand first.
+  slm = slm_gather<float, 32, 2>(ioffset_n16);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view);
+
+  slm = slm_gather<float, 32, 2>(ioffset_n16, props_align4);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, props_align4);
+
+  // 4b) check VS > 1. Pass the 'mask' operand this time.
+  slm = slm_gather<float, 32, 2>(ioffset_n16, mask_n16);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, mask_n16);
+
+  slm = slm_gather<float, 32, 2>(ioffset_n16, mask_n16, props_align4);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, mask_n16, props_align4);
+
+  // 4c) check VS > 1. Pass the 'mask' and 'pass_thru' operands.
+  slm = slm_gather<float, 32, 2>(ioffset_n16, mask_n16, pass_thru);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, mask_n16, pass_thru);
+  slm = slm_gather<float, 32, 2>(ioffset_n16, mask_n16, pass_thru_view);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, mask_n16, pass_thru_view);
+
+  slm =
+      slm_gather<float, 32, 2>(ioffset_n16, mask_n16, pass_thru, props_align4);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, mask_n16, pass_thru,
+                                 props_align4);
+  slm = slm_gather<float, 32, 2>(ioffset_n16, mask_n16, pass_thru_view,
+                                 props_align4);
+  slm = slm_gather<float, 32, 2>(ioffset_n16_view, mask_n16, pass_thru_view,
+                                 props_align4);
+}
diff --git a/sycl/test/invoke_simd/invoke_simd.cpp b/sycl/test/invoke_simd/invoke_simd.cpp
index 766b730552ae1..7a652f5c5b64a 100644
--- a/sycl/test/invoke_simd/invoke_simd.cpp
+++ b/sycl/test/invoke_simd/invoke_simd.cpp
@@ -46,21 +46,21 @@ ESIMD_CALLEE(float *A, esimd::simd<float, VL> b, int i) SYCL_ESIMD_FUNCTION {
 float SPMD_CALLEE(float *A, float b, int i) { return A[i] + b; }
 
 class ESIMDSelector : public device_selector {
-  // Require GPU device unless HOST is requested in SYCL_DEVICE_FILTER env
+  // Require GPU device unless HOST is requested in ONEAPI_DEVICE_SELECTOR env
   virtual int operator()(const device &device) const {
-    if (const char *dev_filter = getenv("SYCL_DEVICE_FILTER")) {
+    if (const char *dev_filter = getenv("ONEAPI_DEVICE_SELECTOR")) {
       std::string filter_string(dev_filter);
       if (filter_string.find("gpu") != std::string::npos)
         return device.is_gpu() ? 1000 : -1;
       if (filter_string.find("host") != std::string::npos)
         return device.is_host() ? 1000 : -1;
       std::cerr
-          << "Supported 'SYCL_DEVICE_FILTER' env var values are 'gpu' and "
+          << "Supported 'ONEAPI_DEVICE_SELECTOR' env var values are 'gpu' and "
              "'host', '"
           << filter_string << "' does not contain such substrings.\n";
       return -1;
     }
-    // If "SYCL_DEVICE_FILTER" not defined, only allow gpu device
+    // If "ONEAPI_DEVICE_SELECTOR" not defined, only allow gpu device
     return device.is_gpu() ? 1000 : -1;
   }
 };
diff --git a/sycl/tools/sycl-ls/CMakeLists.txt b/sycl/tools/sycl-ls/CMakeLists.txt
index 0e60776a63a36..2cb5a8c01ec84 100644
--- a/sycl/tools/sycl-ls/CMakeLists.txt
+++ b/sycl/tools/sycl-ls/CMakeLists.txt
@@ -16,5 +16,9 @@ target_link_libraries(sycl-ls
     ${sycl_lib}
     OpenCL-Headers
 )
+if (WIN32)
+  # 0x900: Search for the dependency DLLs only in the System32 directory and in the directory with sycl-ls.exe
+  target_link_options(sycl-ls PRIVATE /DEPENDENTLOADFLAG:0x900)
+endif()
 install(TARGETS sycl-ls
   RUNTIME DESTINATION "bin" COMPONENT sycl-ls)
diff --git a/sycl/tools/sycl-ls/sycl-ls.cpp b/sycl/tools/sycl-ls/sycl-ls.cpp
index 4a07d82917d67..39bced0c1c9d1 100644
--- a/sycl/tools/sycl-ls/sycl-ls.cpp
+++ b/sycl/tools/sycl-ls/sycl-ls.cpp
@@ -119,6 +119,7 @@ int main(int argc, char **argv) {
 
   bool SuppressNumberPrinting = false;
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   const char *filter = std::getenv("SYCL_DEVICE_FILTER");
   if (filter) {
     std::cerr << "Warning: SYCL_DEVICE_FILTER environment variable is set to "
@@ -128,6 +129,7 @@ int main(int argc, char **argv) {
               << std::endl;
     SuppressNumberPrinting = true;
   }
+#endif
 
   const char *ods_targets = std::getenv("ONEAPI_DEVICE_SELECTOR");
   if (ods_targets) {
diff --git a/sycl/unittests/Extensions/CommandGraph.cpp b/sycl/unittests/Extensions/CommandGraph.cpp
index b8d45404c627d..ce7bb02e278b2 100644
--- a/sycl/unittests/Extensions/CommandGraph.cpp
+++ b/sycl/unittests/Extensions/CommandGraph.cpp
@@ -1199,9 +1199,11 @@ TEST_F(CommandGraphTest, InOrderQueueHostTaskAndGraph) {
       [&](sycl::handler &cgh) { cgh.single_task<TestKernel<>>([]() {}); });
   auto EventLastImpl = sycl::detail::getSyclObjImpl(EventLast);
   auto EventLastWaitList = EventLastImpl->getWaitList();
-  // Previous task is not a host task. In Order queue dependency are managed by
-  // the backend for non-host kernels.
-  ASSERT_EQ(EventLastWaitList.size(), 0lu);
+  // Previous task is not a host task. Explicit dependency is still needed
+  // to properly handle blocked tasks (the event will be filtered out before
+  // submission to the backend).
+  ASSERT_EQ(EventLastWaitList.size(), 1lu);
+  ASSERT_EQ(EventLastWaitList[0], EventGraphImpl);
 }
 
 TEST_F(CommandGraphTest, InOrderQueueMemsetAndGraph) {
diff --git a/sycl/unittests/scheduler/AllocaLinking.cpp b/sycl/unittests/scheduler/AllocaLinking.cpp
index 0cce7dcd2ea92..a77995a203da3 100644
--- a/sycl/unittests/scheduler/AllocaLinking.cpp
+++ b/sycl/unittests/scheduler/AllocaLinking.cpp
@@ -46,6 +46,7 @@ static pi_result redefinedDeviceGetInfoAfter(pi_device Device,
 }
 
 TEST_F(SchedulerTest, AllocaLinking) {
+  HostUnifiedMemory = false;
   // This host device constructor should be placed before Mock.redefine
   // because it overrides the real implementation of get_device_info
   // which is needed when creating a host device.
diff --git a/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp b/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp
index 020a956537ddd..37bb5106d75b2 100644
--- a/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp
+++ b/sycl/unittests/scheduler/InOrderQueueHostTaskDeps.cpp
@@ -11,13 +11,14 @@
 
 #include <helpers/PiImage.hpp>
 #include <helpers/PiMock.hpp>
+#include <helpers/TestKernel.hpp>
 
 #include <detail/event_impl.hpp>
 #include <detail/queue_impl.hpp>
 
 #include <gtest/gtest.h>
 
-#include <helpers/TestKernel.hpp>
+#include <sycl/sycl.hpp>
 
 using namespace sycl;
 
@@ -32,6 +33,7 @@ inline pi_result redefinedEventsWait(pi_uint32 num_events,
 }
 
 TEST_F(SchedulerTest, InOrderQueueHostTaskDeps) {
+  GEventsWaitCounter = 0;
   sycl::unittest::PiMock Mock;
   sycl::platform Plt = Mock.getPlatform();
   Mock.redefineBefore<detail::PiApiKind::piEventsWait>(redefinedEventsWait);
@@ -39,16 +41,131 @@ TEST_F(SchedulerTest, InOrderQueueHostTaskDeps) {
   context Ctx{Plt};
   queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()};
 
+  auto buf = sycl::malloc_shared<int>(1, InOrderQueue);
+  event Evt = InOrderQueue.submit(
+      [&](sycl::handler &CGH) { CGH.memset(buf, 0, sizeof(buf[0])); });
+  InOrderQueue.submit([&](sycl::handler &CGH) { CGH.host_task([=] {}); })
+      .wait();
+
+  EXPECT_EQ(GEventsWaitCounter, 1u);
+}
+
+enum class CommandType { KERNEL = 1, MEMSET = 2 };
+std::vector<std::pair<CommandType, size_t>> ExecutedCommands;
+
+inline pi_result customEnqueueKernelLaunch(pi_queue, pi_kernel, pi_uint32,
+                                           const size_t *, const size_t *,
+                                           const size_t *,
+                                           pi_uint32 EventsCount,
+                                           const pi_event *, pi_event *) {
+  ExecutedCommands.push_back({CommandType::KERNEL, EventsCount});
+  return PI_SUCCESS;
+}
+inline pi_result customextUSMEnqueueMemset(pi_queue, void *, pi_int32, size_t,
+                                           pi_uint32 EventsCount,
+                                           const pi_event *, pi_event *) {
+  ExecutedCommands.push_back({CommandType::MEMSET, EventsCount});
+  return PI_SUCCESS;
+}
+
+TEST_F(SchedulerTest, InOrderQueueCrossDeps) {
+  ExecutedCommands.clear();
+  sycl::unittest::PiMock Mock;
+  Mock.redefineBefore<detail::PiApiKind::piEnqueueKernelLaunch>(
+      customEnqueueKernelLaunch);
+  Mock.redefineBefore<detail::PiApiKind::piextUSMEnqueueMemset>(
+      customextUSMEnqueueMemset);
+
+  sycl::platform Plt = Mock.getPlatform();
+
+  context Ctx{Plt};
+  queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()};
+
   kernel_bundle KernelBundle =
       sycl::get_kernel_bundle<sycl::bundle_state::input>(Ctx);
   auto ExecBundle = sycl::build(KernelBundle);
 
-  event Evt = InOrderQueue.submit([&](sycl::handler &CGH) {
+  std::mutex CvMutex;
+  std::condition_variable Cv;
+  bool ready = false;
+
+  InOrderQueue.submit([&](sycl::handler &CGH) {
+    CGH.host_task([&] {
+      std::unique_lock lk(CvMutex);
+      Cv.wait(lk, [&ready] { return ready; });
+    });
+  });
+
+  auto buf = sycl::malloc_shared<int>(1, InOrderQueue);
+
+  event Ev1 = InOrderQueue.submit(
+      [&](sycl::handler &CGH) { CGH.memset(buf, 0, sizeof(buf[0])); });
+
+  event Ev2 = InOrderQueue.submit([&](sycl::handler &CGH) {
     CGH.use_kernel_bundle(ExecBundle);
     CGH.single_task<TestKernel<>>([] {});
   });
-  InOrderQueue.submit([&](sycl::handler &CGH) { CGH.host_task([=] {}); })
-      .wait();
 
-  EXPECT_TRUE(GEventsWaitCounter == 1);
+  {
+    std::unique_lock lk(CvMutex);
+    ready = true;
+  }
+  Cv.notify_one();
+
+  InOrderQueue.wait();
+
+  ASSERT_EQ(ExecutedCommands.size(), 2u);
+  EXPECT_EQ(ExecutedCommands[0].first /*CommandType*/, CommandType::MEMSET);
+  EXPECT_EQ(ExecutedCommands[0].second /*EventsCount*/, 0u);
+  EXPECT_EQ(ExecutedCommands[1].first /*CommandType*/, CommandType::KERNEL);
+  EXPECT_EQ(ExecutedCommands[1].second /*EventsCount*/, 0u);
 }
+
+TEST_F(SchedulerTest, InOrderQueueCrossDepsShortcutFuncs) {
+  ExecutedCommands.clear();
+  sycl::unittest::PiMock Mock;
+  Mock.redefineBefore<detail::PiApiKind::piEnqueueKernelLaunch>(
+      customEnqueueKernelLaunch);
+  Mock.redefineBefore<detail::PiApiKind::piextUSMEnqueueMemset>(
+      customextUSMEnqueueMemset);
+
+  sycl::platform Plt = Mock.getPlatform();
+  if (Plt.is_host()) {
+    std::cout << "Not run due to host-only environment\n";
+    GTEST_SKIP();
+  }
+
+  context Ctx{Plt};
+  queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()};
+
+  std::mutex CvMutex;
+  std::condition_variable Cv;
+  bool ready = false;
+
+  InOrderQueue.submit([&](sycl::handler &CGH) {
+    CGH.host_task([&] {
+      std::unique_lock lk(CvMutex);
+      Cv.wait(lk, [&ready] { return ready; });
+    });
+  });
+
+  auto buf = sycl::malloc_shared<int>(1, InOrderQueue);
+
+  event Ev1 = InOrderQueue.memset(buf, 0, sizeof(buf[0]));
+
+  event Ev2 = InOrderQueue.single_task<TestKernel<>>([] {});
+
+  {
+    std::unique_lock lk(CvMutex);
+    ready = true;
+  }
+  Cv.notify_one();
+
+  InOrderQueue.wait();
+
+  ASSERT_EQ(ExecutedCommands.size(), 2u);
+  EXPECT_EQ(ExecutedCommands[0].first /*CommandType*/, CommandType::MEMSET);
+  EXPECT_EQ(ExecutedCommands[0].second /*EventsCount*/, 0u);
+  EXPECT_EQ(ExecutedCommands[1].first /*CommandType*/, CommandType::KERNEL);
+  EXPECT_EQ(ExecutedCommands[1].second /*EventsCount*/, 0u);
+}
\ No newline at end of file
diff --git a/sycl/unittests/scheduler/InOrderQueueSyncCheck.cpp b/sycl/unittests/scheduler/InOrderQueueSyncCheck.cpp
index ca1e7d664bf58..f88dea4b398f9 100644
--- a/sycl/unittests/scheduler/InOrderQueueSyncCheck.cpp
+++ b/sycl/unittests/scheduler/InOrderQueueSyncCheck.cpp
@@ -61,43 +61,41 @@ TEST_F(SchedulerTest, InOrderQueueSyncCheck) {
   //  host      | yes - always, separate sync management
   //  host      | yes - always, separate sync management
   //  kernel    | yes - change of sync approach
-  //  kernel    | no  - sync between pi calls must be done by backend
+  //  kernel    | yes - sync between pi calls must be done by backend, but we
+  //  still add dependency to handle the right order due to host task. This
+  //  dependency will not be sent to backend. It is checked in
+  //  SchedulerTest.InOrderQueueCrossDeps
   //  host      | yes - always, separate sync management
 
   sycl::event Event;
   // host task
   {
     LimitedHandlerSimulation MockCGH;
-    EXPECT_CALL(MockCGH, depends_on).Times(1);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::CodeplayHostTask, Event);
+    EXPECT_CALL(MockCGH, depends_on).Times(0);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
   // host task
   {
     LimitedHandlerSimulation MockCGH;
     EXPECT_CALL(MockCGH, depends_on).Times(1);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::CodeplayHostTask, Event);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
   // kernel task
   {
     LimitedHandlerSimulation MockCGH;
     EXPECT_CALL(MockCGH, depends_on).Times(1);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::Kernel, Event);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
   // kernel task
   {
     LimitedHandlerSimulation MockCGH;
-    EXPECT_CALL(MockCGH, depends_on).Times(0);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::Kernel, Event);
+    EXPECT_CALL(MockCGH, depends_on).Times(1);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
   // host task
   {
     LimitedHandlerSimulation MockCGH;
     EXPECT_CALL(MockCGH, depends_on).Times(1);
-    Queue->finalizeHandler<LimitedHandlerSimulation>(
-        MockCGH, detail::CG::CGTYPE::CodeplayHostTask, Event);
+    Queue->finalizeHandler<LimitedHandlerSimulation>(MockCGH, Event);
   }
 }