Merge pull request #683 from hvdijk/refsi-issues

Address several refsi issues.

Author: hvdijk

README.md

@@ -56,11 +56,16 @@ Examples are provided to get started, but for more control over the compilation
 
 The oneAPI Construction Kit can be compiled for two reference targets; `host` and `refsi` (`riscv`). In SYCL programming, the host target refers to the system where the SYCL program is compiled and executed, while the refsi (Reference System Implementation) target refers to the target platform for which the program is being developed. The refsi target is a hardware-specific implementation of the SYCL specification, enabling the program to run on a specific target platform. SYCL implementations such as DPC++ provide various refsi targets for CPUs, GPUs, FPGAs, and accelerators, which can be selected during compilation using specific flags and code.
 
+#### Compiling oneAPI Construction Kit for host
+
 To compile oneAPI Construction Kit for the host, please refer to the [developer guide](doc/developer-guide.md#compiling-oneapi-construction-kit).
 
-#### Compiling oneAPI Construction Kit for RISC-V
+#### Compiling oneAPI Construction Kit for simulated RISC-V
+
 This target aims to provide a flexible way of communicating with various customer RISC-V targets with different configurations. It supports multiple variants using an abstract class and can configure targets and execute commands. However, the current version has only been tested on an x86_64 host CPU.
 
+This target is not intended for running oneAPI Construction Kit directly on RISC-V hardware. For that, the host target should be used.
+
 The available targets in the current implementation are based on Codeplay's reference architecture, called RefSi, with two variations: `G` and `M1`. The `riscv` target is designed to support the `G` variant, while the `M1` variant has additional features like DMA. More information on `riscv` can be found [here](doc/modules/riscv.rst). To build in-tree, run the following:
 
 ```sh

modules/compiler/riscv/CMakeLists.txt

@@ -46,6 +46,13 @@ if (LLVMRISCVCODEGEN)
       $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
     )
 
+    if(NOT TARGET compiler-linker-utils)
+      set(error "compiler-riscv-utils requires compiler-linker-utils")
+      if(NOT EXISTS "${CA_LLVM_INSTALL_DIR}/lib/cmake/lld/LLDConfig.cmake")
+        string(APPEND error " which requires liblld")
+      endif()
+      message(FATAL_ERROR "${error}")
+    endif()
     target_link_libraries(compiler-riscv-utils PUBLIC
       compiler-base
       hal_common      

modules/mux/targets/riscv/source/kernel.cpp

@@ -36,11 +36,11 @@ cargo::expected<riscv::kernel_s *, mux_result_t> kernel_s::create(
   auto *hal_device_info = static_cast<const riscv::hal_device_info_riscv_t *>(
       device->hal_device->get_info());
 
-  const unsigned real_vscale = hal_device_info->vlen / 64;
-  auto assert_scalable_supported = [hal_device_info]() {
+  auto real_vscale = [vlen = hal_device_info->vlen]() {
     assert(
-        hal_device_info->vlen &&
+        vlen &&
         "vlen must be known at runtime to calculate scalable subgroup width");
+    return vlen / 64;
   };
 
   cargo::small_vector<mux::hal::kernel_variant_s, 4> variants;
@@ -52,18 +52,15 @@ cargo::expected<riscv::kernel_s *, mux_result_t> kernel_s::create(
     variant.variant_name = meta.kernel_name;
     variant.sub_group_size = meta.sub_group_size.getKnownMinValue();
     if (meta.sub_group_size.isScalable()) {
-      assert_scalable_supported();
-      variant.sub_group_size *= real_vscale;
+      variant.sub_group_size *= real_vscale();
     }
     variant.min_work_width = meta.min_work_item_factor.getKnownMinValue();
     if (meta.min_work_item_factor.isScalable()) {
-      assert_scalable_supported();
-      variant.min_work_width *= real_vscale;
+      variant.min_work_width *= real_vscale();
     }
     variant.pref_work_width = meta.pref_work_item_factor.getKnownMinValue();
     if (meta.pref_work_item_factor.isScalable()) {
-      assert_scalable_supported();
-      variant.pref_work_width *= real_vscale;
+      variant.pref_work_width *= real_vscale();
     }
     if (cargo::success != variants.push_back(std::move(variant))) {
       return cargo::make_unexpected(mux_error_out_of_memory);