Add support for SimSYCL as a SYCL implementation

CMakeLists.txt

@@ -1,7 +1,12 @@
 cmake_minimum_required(VERSION 3.15)
 project(sycl_cts LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 17)
+if(SYCL_IMPLEMENTATION STREQUAL SimSYCL)
+    set(CMAKE_CXX_STANDARD 20)
+else()
+    set(CMAKE_CXX_STANDARD 17)
+endif()
+
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS ON) # Required for hex floats in C++11 mode on gcc 6+
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")

README.md

@@ -24,7 +24,7 @@ To compile the CTS, the following dependencies are required:
 - Python 3.7 or higher
 - CMake 3.15 or higher
 - A SYCL implementation
-  - The CTS currently supports DPC++ and AdaptiveCpp
+  - The CTS currently supports DPC++, AdaptiveCpp and SimSYCL
   - See the [AddSYCLExecutable.cmake](cmake/AddSYCLExecutable.cmake) module on
     how to add support for additional SYCL implementations
 
@@ -35,7 +35,7 @@ cloning this repository and its submodules:
 
 Then enter the `SYCL-CTS` folder and configure the build using CMake:
 
-`cmake -S . -B build -DSYCL_IMPLEMENTATION=<DPCPP|AdaptiveCpp>`
+`cmake -S . -B build -DSYCL_IMPLEMENTATION=<DPCPP|AdaptiveCpp|SimSYCL>`
 
 See [CMake Configuration Options](#cmake-configuration-options) for additional
 configuration options that can be passed here.
@@ -52,7 +52,7 @@ placed in the `build/bin` directory.
 The CTS can be configured using the following CMake configuration options:
 
 `SYCL_IMPLEMENTATION` (default: None)
- `DPCPP` or `AdaptiveCpp`.
+ `DPCPP`, `AdaptiveCpp` or `SimSYCL`.
 
 `SYCL_CTS_EXCLUDE_TEST_CATEGORIES` (default: None)
  Optional file specifying a list of test categories to be excluded from the build.

ci/generate_exclude_filter.py

@@ -42,7 +42,7 @@ def parse_arguments():
         configuration-time test category filters for all failing targets.""")
 
     parser.add_argument('sycl_implementation', metavar="SYCL-Implementation",
-                        choices=['DPCPP', 'AdaptiveCpp'], type=str,
+                        choices=['DPCPP', 'AdaptiveCpp', 'SimSYCL'], type=str,
                         help="The SYCL implementation to use")
     parser.add_argument('--cmake-args', type=str,
                         help="Arguments to pass on to CMake during configuration")

ci/simsycl.filter

@@ -0,0 +1,15 @@
+accessor_legacy
+atomic
+atomic_ref_stress
+exception_handling
+image
+image_accessor
+kernel
+kernel_args
+kernel_bundle
+math_builtin_api
+multi_ptr
+reduction
+sampler
+spec_constants
+stream

cmake/AdaptSimSYCL.cmake

@@ -0,0 +1,40 @@
+add_library(SYCL::SYCL INTERFACE IMPORTED GLOBAL)
+target_link_libraries(SYCL::SYCL INTERFACE SimSYCL::simsycl)
+# add_sycl_executable_implementation function
+# Builds a SYCL program, compiling multiple SYCL test case source files into a
+# test executable, invoking a single-source/device compiler
+# Parameters are:
+#   - NAME             Name of the test executable
+#   - OBJECT_LIBRARY   Name of the object library of all the compiled test cases
+#   - TESTS            List of SYCL test case source files to be built into the
+# test executable
+function(add_sycl_executable_implementation)
+    cmake_parse_arguments(args "" "NAME;OBJECT_LIBRARY" "TESTS" ${ARGN})
+    set(exe_name            ${args_NAME})
+    set(object_lib_name     ${args_OBJECT_LIBRARY})
+    set(test_cases_list     ${args_TESTS})
+
+    add_library(${object_lib_name} OBJECT ${test_cases_list})
+    add_executable(${exe_name} $<TARGET_OBJECTS:${object_lib_name}>)
+
+    set_target_properties(${object_lib_name} PROPERTIES
+        INCLUDE_DIRECTORIES $<TARGET_PROPERTY:${exe_name},INCLUDE_DIRECTORIES>
+        COMPILE_DEFINITIONS $<TARGET_PROPERTY:${exe_name},COMPILE_DEFINITIONS>
+        COMPILE_OPTIONS     $<TARGET_PROPERTY:${exe_name},COMPILE_OPTIONS>
+        COMPILE_FEATURES    $<TARGET_PROPERTY:${exe_name},COMPILE_FEATURES>
+        POSITION_INDEPENDENT_CODE ON)
+endfunction()
+
+function(add_sycl_to_target)
+    set(options)
+    set(one_value_keywords TARGET)
+    set(multi_value_keywords SOURCES)
+    cmake_parse_arguments(ADD_SYCL
+      "${options}"
+      "${one_value_keywords}"
+      "${multi_value_keywords}"
+      ${ARGN}
+    )
+
+    target_link_libraries(${ADD_SYCL_TARGET} PUBLIC SimSYCL::simsycl)
+endfunction()

cmake/AddSYCLExecutable.cmake

@@ -1,8 +1,8 @@
-set (KNOWN_SYCL_IMPLEMENTATIONS "DPCPP;AdaptiveCpp")
+set (KNOWN_SYCL_IMPLEMENTATIONS "DPCPP;AdaptiveCpp;SimSYCL")
 if ("${SYCL_IMPLEMENTATION}" STREQUAL "" OR NOT ${SYCL_IMPLEMENTATION} IN_LIST KNOWN_SYCL_IMPLEMENTATIONS)
     message(FATAL_ERROR
         "The SYCL CTS requires specifying a SYCL implementation with "
-        "-DSYCL_IMPLEMENTATION=[DPCPP;AdaptiveCpp]")
+        "-DSYCL_IMPLEMENTATION=[${KNOWN_SYCL_IMPLEMENTATIONS}]")
 endif()
 
 if(NOT TARGET OpenCL_Proxy)

docs/README.adoc

@@ -341,7 +341,7 @@ The CTS currently provides the following macros for compile-time disabling test
 * `DISABLED_FOR_TEST_CASE(<impls...>)(<description>, <tags>)(<body>)`
 * `DISABLED_FOR_TEMPLATE_TEST_CASE_SIG(<impls...>)(<description>, <tags>, <signature>, <types...>)(<body>)`
 
-where `<impls...>` is a comma-separated list of `AdaptiveCpp` and/or `DPCPP`.
+where `<impls...>` is a comma-separated list out of `AdaptiveCpp`, `DPCPP`, and `SimSYCL`.
 
 NOTE: #**TODO:** Custom matchers.#
 

tests/buffer/buffer_api_common.h

@@ -393,6 +393,7 @@ void test_buffer(util::logger& log, sycl::range<dims>& r, sycl::id<dims>& i) {
       allocator.deallocate(ptr, 1);
     }
 
+#if !SYCL_CTS_COMPILING_WITH_SIMSYCL
     /* check is_sub_buffer() */
     {
       sycl::buffer<T, dims> buf(r);
@@ -405,6 +406,9 @@ void test_buffer(util::logger& log, sycl::range<dims>& r, sycl::id<dims>& i) {
       CHECK(isSubBuffer);
       CHECK_FALSE(isOrigSubBuffer);
     }
+#else
+    FAIL_CHECK("SimSYCL does not implement sub-buffers yet");
+#endif
 
     /* check buffer properties */
     {
@@ -540,10 +544,14 @@ class check_buffer_api_for_type {
     test_buffer<T, size * size, 2, alloc>(log, range2d, id2d);
     test_buffer<T, size * size * size, 3, alloc>(log, range3d, id3d);
 
+#if !SYCL_CTS_COMPILING_WITH_SIMSYCL
     /* check reinterpret() */
     test_type_reinterpret<T, 1>(log);
     test_type_reinterpret<T, 2>(log);
     test_type_reinterpret<T, 3>(log);
+#else
+    FAIL("SimSYCL does not implement buffer::reinterpret() yet")
+#endif
   }
 
  public:

tests/buffer/buffer_constructors_common.h

@@ -235,6 +235,7 @@ class buffer_ctors {
       CHECK(check_buffer_constructor(buf_iter1, r_exp, data_verify));
     }
 
+#if !SYCL_CTS_COMPILING_WITH_SIMSYCL
     {
       INFO("Check subBuffer (buffer, id, range) constructor");
       auto r_sub = r;
@@ -244,6 +245,10 @@ class buffer_ctors {
       CHECK(buf_sub.is_sub_buffer());
       CHECK(check_buffer_constructor(buf_sub, r_sub));
     }
+#else
+    FAIL_CHECK("SimSYCL does not implement sub-buffers yet");
+#endif
+
     /* Check range constructor */
     {
       sycl::buffer<T, dims, std::allocator<T>> buf(r, propList);
@@ -312,6 +317,7 @@ class buffer_ctors {
       CHECK(check_buffer_constructor(buf_iter1, r_exp, data_verify));
     }
 
+#if !SYCL_CTS_COMPILING_WITH_SIMSYCL
     {
       INFO(
           "Check subBuffer (buffer, id, range) constructor with allocator "
@@ -323,6 +329,9 @@ class buffer_ctors {
       CHECK(buf_sub.is_sub_buffer());
       CHECK(check_buffer_constructor(buf_sub, r_sub));
     }
+#else
+    FAIL_CHECK("SimSYCL does not implement sub-buffers yet");
+#endif
 
     {
       INFO("Check (range, allocator) constructor");

tests/common/common.h

@@ -286,7 +286,7 @@ bool check_equal_values(const T& lhs, const T& rhs) {
 }
 
 /**
- * @brief Instantiation for vectors with the same API as for scalar values. 
+ * @brief Instantiation for vectors with the same API as for scalar values.
  * Deprecated. Use \c value_operations::are_equal instead
  */
 template <typename T, int numElements>
@@ -416,8 +416,8 @@ namespace pixel_tag {
   struct upper: generic {};
 };
 
-// AdaptiveCpp does not yet support images
-#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
+// AdaptiveCpp and SimSYCL do not yet support images
+#if !SYCL_CTS_COMPILING_WITH_ADAPTIVECPP && !SYCL_CTS_COMPILING_WITH_SIMSYCL
 
 /**
  * @brief Helps with retrieving the right access type for reading/writing

tests/common/disabled_for_test_case.h

@@ -23,7 +23,7 @@
  * currently does not compile for a given implementation, while other test cases
  * in the same translation unit would otherwise compile.
  *
- * The following implementations can be specified: DPCPP, AdaptiveCpp.
+ * The following implementations can be specified: DPCPP, AdaptiveCpp, SimSYCL.
  * A disabled test case will fail automatically at runtime.
  *
  * Usage example:
@@ -53,6 +53,8 @@
 #define INTERNAL_CTS_SYCL_IMPL_DPCPP ()
 #elif SYCL_CTS_COMPILING_WITH_ADAPTIVECPP
 #define INTERNAL_CTS_SYCL_IMPL_AdaptiveCpp ()
+#elif SYCL_CTS_COMPILING_WITH_SIMSYCL
+#define INTERNAL_CTS_SYCL_IMPL_SimSYCL ()
 #else
 #error Unknown SYCL implementation
 #endif

tests/device/device_api.cpp

@@ -123,6 +123,7 @@ class TEST_NAME : public util::test_base {
                                 "device::has(sycl::aspect)");
       }
 
+#if !SYCL_CTS_COMPILING_WITH_SIMSYCL
       /** check
        * create_sub_devices<info::partition_property::partition_equally>(size_t)
        * member function
@@ -180,6 +181,9 @@ class TEST_NAME : public util::test_base {
           }
         }
       }
+#else
+      FAIL_CHECK("SimSYCL does not implement sub-devices yet");
+#endif
 
       /** check get_devices() static member function
        */

tests/device/device_info.cpp

@@ -232,6 +232,8 @@ TEST_CASE("device info", "[device]") {
     check_get_info_param<sycl::info::device::printf_buffer_size, size_t>(dev);
     check_get_info_param<sycl::info::device::preferred_interop_user_sync, bool>(
         dev);
+
+#if !SYCL_CTS_COMPILING_WITH_SIMSYCL
     auto SupportedProperties =
         dev.get_info<sycl::info::device::partition_properties>();
     if (std::find(SupportedProperties.begin(), SupportedProperties.end(),
@@ -243,6 +245,10 @@ TEST_CASE("device info", "[device]") {
       check_get_info_param<sycl::info::device::parent_device, sycl::device>(
           sub_device_partition_equal[0]);
     }
+#else
+    FAIL_CHECK("SimSYCL does not implement sub-devices yet");
+#endif
+
     check_get_info_param<sycl::info::device::partition_max_sub_devices,
                          uint32_t>(dev);
     check_get_info_param<sycl::info::device::partition_properties,

tests/event/event.cpp

@@ -74,6 +74,10 @@ TEST_CASE("event::get_backend returns the associated backend", "[event]") {
 
 TEST_CASE("event::get_wait_list returns a list of all direct dependencies",
           "[event]") {
+#if SYCL_CTS_COMPILING_WITH_SIMSYCL
+  SKIP("SimSYCL does not implement asynchronous execution.");
+#endif
+
   resolvable_host_event e_a;
   resolvable_host_event e_b{{e_a.get_sycl_event()}};
   resolvable_host_event e_c;
@@ -122,6 +126,10 @@ class delayed_host_event : public resolvable_host_event {
 };
 
 TEST_CASE("event can be waited upon", "[event]") {
+#if SYCL_CTS_COMPILING_WITH_SIMSYCL
+  SKIP("SimSYCL does not implement asynchronous execution.");
+#endif
+
   // Give main thread some time to fail the did_resolve check
   delayed_host_event dhe{std::chrono::milliseconds(100)};
 
@@ -143,6 +151,10 @@ TEST_CASE("event can be waited upon", "[event]") {
 }
 
 TEST_CASE("multiple events can be waited upon simultaneously", "[event]") {
+#if SYCL_CTS_COMPILING_WITH_SIMSYCL
+  SKIP("SimSYCL does not implement asynchronous execution.");
+#endif
+
   // Give main thread some time to fail the did_resolve check
   delayed_host_event dhe1{std::chrono::milliseconds(100)};
   delayed_host_event dhe2{std::chrono::milliseconds(100)};
@@ -307,6 +319,10 @@ TEST_CASE("event::get_info returns correct command execution status",
                        sycl::info::event_command_status>(make_device_event());
 
   SECTION("for host_task event") {
+#if SYCL_CTS_COMPILING_WITH_SIMSYCL
+    SKIP("SimSYCL does not implement asynchronous execution.");
+#endif
+
     resolvable_host_event rhe;
     auto& event = rhe.get_sycl_event();
 

tests/event/event_semantics.cpp

@@ -43,6 +43,10 @@ TEST_CASE("event common reference semantics", "[event]") {
 }
 
 TEST_CASE("event common reference semantics, mutation", "[event]") {
+#if SYCL_CTS_COMPILING_WITH_SIMSYCL
+  SKIP("SimSYCL does not implement asynchronous execution.");
+#endif
+
   resolvable_host_event dependent_event;
   resolvable_host_event rhe_t0{{dependent_event.get_sycl_event()}};
 

tests/handler/handler_copy_core.cpp

@@ -6,6 +6,7 @@
 //
 *******************************************************************************/
 
+#include "../common/disabled_for_test_case.h"
 #include "../common/string_makers.h"
 #include "../common/type_coverage.h"
 #include "catch2/catch_test_macros.hpp"
@@ -14,7 +15,10 @@
 namespace handler_copy_core {
 using namespace handler_copy_common;
 
-TEST_CASE("Tests the API for sycl::handler::copy", "[handler]") {
+// Disabled: SimSYCL does not implement copies between accessors of different
+// dimensionality
+DISABLED_FOR_TEST_CASE(SimSYCL)
+("Tests the API for sycl::handler::copy", "[handler]")({
   auto queue = util::get_cts_object::queue();
 
   log_helper lh;
@@ -33,12 +37,14 @@ TEST_CASE("Tests the API for sycl::handler::copy", "[handler]") {
   test_all_variants<sycl::long8>(lh, queue);
   test_all_variants<sycl::float8>(lh, queue);
 #endif
-}
+});
 
-TEST_CASE(
-    "Check exception on copy(accessor, accessor) in case of invalid "
-    "destination accessor size",
-    "[handler]") {
+// Disabled: SimSYCL does not implement copies between accessors of different
+// dimensionality
+DISABLED_FOR_TEST_CASE(SimSYCL)
+("Check exception on copy(accessor, accessor) in case of invalid "
+ "destination accessor size",
+ "[handler]")({
   auto queue = util::get_cts_object::queue();
 
   const auto types =
@@ -72,6 +78,6 @@ TEST_CASE(
 
   for_all_combinations<CheckCopyAccToAccException>(types, dims, dims, src_modes,
                                                    dst_modes, queue);
-}
+});
 
 }  // namespace handler_copy_core