Merge branch 'sycl' into refactorcache

Author: sergey-semenov

.github/workflows/sycl-linux-precommit.yml

@@ -81,7 +81,7 @@ jobs:
 
   compat_read_exclude:
     name: Read compatibility testing exclude list
-    runs-on: [Linux, build]
+    runs-on: [Linux, aux-tasks]
     outputs:
       FILTER_6_2: ${{ steps.result.outputs.FILTER_6_2 }}
       FILTER_6_3: ${{ steps.result.outputs.FILTER_6_3 }}

devops/scripts/benchmarks/PERFORMANCE_TUNING.md

@@ -0,0 +1,176 @@
+# System Performance Tuning Guide
+
+This guide provides recommendations for optimizing system performance when running SYCL and Unified Runtime benchmarks.
+For framework-specific information, see [README.md](README.md) and [CONTRIB.md](CONTRIB.md).
+
+## Table of Contents
+
+- [Overview](#overview)
+- [System Configuration](#system-configuration)
+- [CPU Tuning](#cpu-tuning)
+- [GPU Configuration](#gpu-configuration)
+- [Perf Configuration](#perf-configuration)
+- [Environment Variables](#environment-variables)
+
+## Overview
+
+Performance benchmarking requires a stable and optimized system environment to produce reliable and reproducible results. This guide covers essential system tuning steps for reducing run-to-run variance in benchmark results.
+
+## System Configuration
+
+### Kernel Parameters
+
+Add the following to `/etc/default/grub` in `GRUB_CMDLINE_LINUX`:
+```
+# Disable CPU frequency scaling
+# intel_pstate=disable
+
+# Isolate CPUs for benchmark workloads (example: reserve cores 2-7), preventing other processes
+# from using them.
+# isolcpus=2-7
+
+GRUB_CMDLINE_LINUX="intel_pstate=disable isolcpus=2-7 <other_options>"
+```
+
+Update GRUB and reboot:
+```bash
+sudo update-grub
+sudo reboot
+```
+
+## CPU Tuning
+
+### CPU Frequency Scaling
+
+The performance governor ensures that the CPU runs at maximum frequency.
+```bash
+# Set performance governor for all CPUs
+sudo cpupower frequency-set --governor performance
+# Apply changes to system
+sudo sysctl --system
+
+# Check current governor
+sudo cpupower frequency-info
+```
+
+To preserve these settings after reboot, create a systemd service which runs the above commands at startup:
+```bash
+# Create a systemd service file
+sudo vim /etc/systemd/system/cpupower_governor.service
+```
+Add the following content:
+```
+[Unit]
+Description=Set CPU governor to Performance
+After=multi-user.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/cpupower frequency-set --governor performance && sysctl --system
+
+[Install]
+WantedBy=multi-user.target
+```
+Enable and start the service:
+```bash
+sudo systemctl enable cpupower_governor.service
+sudo systemctl start cpupower_governor.service
+```
+
+### CPU Affinity
+
+Bind benchmark processes to specific CPU cores to reduce context switching and improve cache locality.
+Make sure that isolated CPUs are located on the same NUMA node as the GPU being used.
+```bash
+# Run benchmark on specific CPU cores
+taskset -c 2-7 ./main.py ~/benchmarks_workdir/ --sycl ~/llvm/build/
+```
+
+## GPU Configuration
+
+### GPU Frequency Control
+Setting the GPU to run at maximum frequency can significantly improve benchmark performance and stability.
+
+First, find which card relates to the GPU you want to tune (e.g., card1). List of known Device IDs for
+Intel GPU cards can be found at https://dgpu-docs.intel.com/devices/hardware-table.html#gpus-with-supported-drivers.
+```bash
+# Print card1 Device ID
+cat /sys/class/drm/card1/device/vendor  # Should be 0x8086 for Intel
+cat /sys/class/drm/card1/device/device  # Device ID
+```
+
+Verify the max frequency is set to the true max. For Arc B580, the maximum frequency is 2850 MHz. To see this value, run “cat /sys/class/drm/card1/device/tile0/gt0/freq0/max_freq”. If the above value is not equal to the max frequency, set it as such:
+```bash
+# Arc B580 (Battlemage)
+echo 2850 > /sys/class/drm/card1/device/tile0/gt0/freq0/max_freq
+
+# Set the min frequency to the max frequency, so it is fixed
+echo 2850 > /sys/class/drm/card1/device/tile0/gt0/freq0/min_freq
+```
+
+```bash
+# Check GPU frequencies for GPU Max 1100 (Ponte Vecchio)
+cat /sys/class/drm/card1/gt_max_freq_mhz
+cat /sys/class/drm/card1/gt_min_freq_mhz
+
+# Set maximum GPU frequency
+max_freq=$(cat /sys/class/drm/card1/gt_max_freq_mhz)
+echo $max_freq | sudo tee /sys/class/drm/card1/gt_min_freq_mhz
+```
+
+The result can be verified using tools such as oneprof or unitrace to track frequency over time for some arbitrary benchmark (many iterations of a small problem size is recommended). The frequency should remain fixed assuming thermal throttling does not occur.
+
+## Driver version
+Make sure you are using the latest driver (Ubuntu)
+```bash
+sudo apt update && sudo apt upgrade
+```
+
+## Perf Configuration
+
+Some benchmarks (e.g., ur_submit_kernel) require `perf` to have proper permissions to sample hardware counters. This section covers the necessary setup steps.
+
+### Installing Perf
+
+First, ensure `perf` is installed for your kernel version. On Ubuntu/Debian:
+```bash
+sudo apt install linux-tools-$(uname -r) linux-tools-common
+```
+
+### Configuring Perf Permissions
+
+By default, `perf` requires root privileges to access hardware performance counters.
+Make the setting persistent across reboots by adding it to sysctl configuration:
+```bash
+echo 'kernel.perf_event_paranoid = -1' | sudo tee -a /etc/sysctl.d/99-perf.conf
+
+# Apply immediately
+sudo sysctl -p
+```
+
+### Verifying Perf Setup
+Test that `perf` is working correctly:
+```bash
+perf record -e cycles sleep 1
+perf report
+
+# Test hardware counter access
+perf stat -e cycles,instructions ls
+```
+
+**Note:** You may see warnings about kernel address maps being restricted or symbol resolution issues. These warnings don't prevent `perf` from collecting performance data - they only affect the quality of symbol resolution in kernel space. For user-space profiling (which covers most benchmark scenarios), `perf` will work correctly despite these warnings.
+
+## Environment Variables
+
+### Level Zero Environment Variables
+Use GPU affinity to bind benchmarks to a specific GPU. Use CPUs from the same NUMA node as the GPU to reduce latency.
+```bash
+export ZE_AFFINITY_MASK=0
+```
+
+### SYCL Runtime Variables
+For consistency, limit available devices to a specific gpu runtime. For Level Zero, it is recommended to use v2 version of the runtime library.
+```bash
+export ONEAPI_DEVICE_SELECTOR="level_zero:gpu"
+export SYCL_UR_USE_LEVEL_ZERO_V2=1
+```

devops/scripts/benchmarks/README.md

@@ -143,6 +143,11 @@ IGC (Ubuntu):
 `$ sudo apt-get install flex bison libz-dev cmake libc6 libstdc++6 python3-pip`
 
 
+## Performance Tuning
+
+For stable benchmark results and system configuration recommendations, see the
+[Performance Tuning Guide](PERFORMANCE_TUNING.md).
+
 ## Contribution
 
 The requirements and instructions above are for building the project from source

llvm/lib/SYCLLowerIR/LowerWGLocalMemory.cpp

@@ -184,11 +184,40 @@ lowerDynamicLocalMemCallDirect(CallInst *CI, Triple TT,
 
 static void lowerLocalMemCall(Function *LocalMemAllocFunc,
                               std::function<void(CallInst *CI)> TransformCall) {
+  static SmallPtrSet<Function *, 16> FuncsCache;
   SmallVector<CallInst *, 4> DelCalls;
   for (User *U : LocalMemAllocFunc->users()) {
     auto *CI = cast<CallInst>(U);
     TransformCall(CI);
     DelCalls.push_back(CI);
+    // Now, take each kernel that calls the builtins that allocate local memory,
+    // either directly or through a series of function calls that eventually end
+    // up in a direct call to the builtin, and attach the
+    // work-group-memory-static attribute to the kernel if not already attached.
+    // This is needed because free function kernels do not have the attribute
+    // added by the library as is the case with other types of kernels.
+    if (!FuncsCache.insert(CI->getFunction()).second)
+      continue; // We have already traversed call graph from this function.
+
+    SmallVector<Function *, 8> WorkList;
+    WorkList.push_back(CI->getFunction());
+    while (!WorkList.empty()) {
+      Function *F = WorkList.back();
+      WorkList.pop_back();
+
+      // Mark kernel as using scratch memory if it isn't marked already.
+      if (F->getCallingConv() == CallingConv::SPIR_KERNEL &&
+          !F->hasFnAttribute(WORK_GROUP_STATIC_ATTR))
+        F->addFnAttr(WORK_GROUP_STATIC_ATTR);
+
+      for (auto *FU : F->users()) {
+        if (auto *UCI = dyn_cast<CallInst>(FU)) {
+          if (FuncsCache.insert(UCI->getFunction()).second)
+            WorkList.push_back(UCI->getFunction());
+        } // Even though there could be other uses of a Function, we don't
+          // care about them because we are only concerned about call graph.
+      }
+    }
   }
 
   for (auto *CI : DelCalls) {

llvm/test/SYCLLowerIR/work_group_static.ll

@@ -22,9 +22,29 @@ entry:
   ret void
 }
 
+; Function Attrs: convergent norecurse
+; CHECK: @__sycl_kernel_B{{.*}} #[[ATTRS:[0-9]+]]
+define weak_odr dso_local spir_kernel void @__sycl_kernel_B(ptr addrspace(1) %0) local_unnamed_addr #1 !kernel_arg_addr_space !5 {
+entry:
+  %1 = tail call spir_func ptr addrspace(3) @__sycl_dynamicLocalMemoryPlaceholder(i64 128) #1
+  ret void
+}
+
+; Function Attrs: convergent norecurse
+; CHECK: @__sycl_kernel_C{{.*}} #[[ATTRS]]
+define weak_odr dso_local spir_kernel void @__sycl_kernel_C(ptr addrspace(1) %0) local_unnamed_addr #1 !kernel_arg_addr_space !5 {
+entry:
+  %1 = tail call spir_func ptr addrspace(3) @__sycl_allocateLocalMemory(i64 128, i64 4) #1
+  ret void
+}
+
+; Function Attrs: convergent
+declare dso_local spir_func ptr addrspace(3) @__sycl_allocateLocalMemory(i64, i64) local_unnamed_addr #1
+
 ; Function Attrs: convergent
 declare dso_local spir_func ptr addrspace(3) @__sycl_dynamicLocalMemoryPlaceholder(i64) local_unnamed_addr #1
 
+; CHECK: #[[ATTRS]] = {{.*}} "sycl-work-group-static"
 attributes #0 = { convergent norecurse "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "uniform-work-group-size"="true" "unsafe-fp-math"="false" "use-soft-float"="false" "sycl-work-group-static"="1" }
 attributes #1 = { convergent norecurse }
 

sycl/include/sycl/properties/accessor_properties.hpp

@@ -188,8 +188,8 @@ struct is_property<ext::intel::property::buffer_location> : std::true_type {};
 
 template <typename T>
 struct is_property_of<property::noinit, T>
-    : std::bool_constant<detail::acc_properties::is_accessor<T>::value ||
-                         detail::acc_properties::is_host_accessor<T>::value> {};
+    : std::bool_constant<detail::acc_properties::is_accessor_v<T> ||
+                         detail::acc_properties::is_host_accessor_v<T>> {};
 
 template <typename T>
 struct is_property_of<property::no_init, T>
@@ -201,15 +201,15 @@ struct is_property_of<property::no_init, T>
 
 template <typename T>
 struct is_property_of<ext::oneapi::property::no_offset, T>
-    : std::bool_constant<detail::acc_properties::is_accessor<T>::value> {};
+    : std::bool_constant<detail::acc_properties::is_accessor_v<T>> {};
 
 template <typename T>
 struct is_property_of<ext::oneapi::property::no_alias, T>
-    : std::bool_constant<detail::acc_properties::is_accessor<T>::value> {};
+    : std::bool_constant<detail::acc_properties::is_accessor_v<T>> {};
 
 template <typename T>
 struct is_property_of<ext::intel::property::buffer_location, T>
-    : std::bool_constant<detail::acc_properties::is_accessor<T>::value> {};
+    : std::bool_constant<detail::acc_properties::is_accessor_v<T>> {};
 
 namespace detail {
 template <int I>