[libsycl] Add lit configuration files and basic test

libsycl/CMakeLists.txt

@@ -133,5 +133,14 @@ add_custom_target(libsycl-runtime-libraries
 )
 
 add_subdirectory(src)
-
 add_subdirectory(tools)
+
+if(LLVM_INCLUDE_TESTS)
+  add_subdirectory(test_e2e)
+endif()
+
+add_custom_target(libsycl-toolchain ALL
+  DEPENDS libsycl-runtime-libraries
+          sycl-ls
+  COMMENT "Building libsycl toolchain..."
+)

libsycl/test_e2e/CMakeLists.txt

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.20.0)
+
+message("Configuring libsycl End-to-End Tests")
+
+set(LIBSYCL_CXX_COMPILER "${LLVM_BINARY_DIR}/bin/clang++")
+set(LIBSYCL_E2E_CXX_FLAGS "" CACHE STRING
+    "Flags passed to clang++ when building SYCL end-to-end tests")
+
+configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+    ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
+    MAIN_CONFIG
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
+)
+
+list(APPEND LIBSYCL_E2E_TEST_DEPS
+    libsycl-toolchain
+    FileCheck
+    not
+)
+
+add_lit_testsuite(check-sycl-e2e
+  "Running libsycl End-to-End tests"
+  ${CMAKE_CURRENT_BINARY_DIR}
+  EXCLUDE_FROM_CHECK_ALL
+  DEPENDS ${LIBSYCL_E2E_TEST_DEPS})

libsycl/test_e2e/README.md

@@ -0,0 +1,84 @@
+## Getting Started
+
+This directory contains `libsycl` tests distributed in subdirectories based on
+testing scope. `libsycl` uses LIT to configure and run its tests.
+
+Please see the [Lit Command Guide](https://llvm.org/docs/CommandGuide/lit.html)
+for more information about LIT.
+
+## Prerequisites
+
+* Target runtime(s) to execute tests on devices.
+  TODO: add link to liboffload instruction once they add it.
+* Compiler & libsycl. Can be built following these
+  [instructions](/libsycl/docs/index.rst).
+
+## Run the tests
+
+`libsycl` is integrated via LLVM_ENABLE_RUNTIMES and is not visible as top
+level target. Same is applicable for tests. To run `check-sycl-e2e` tests you
+need to prefix `<build>/runtimes/runtimes-bins/` to the paths of all tests.
+For example, to run all the libsycl end-to-end tests you can do:
+```bash
+<build>/bin/llvm-lit <build>/runtimes/runtimes-bins/libsycl/test_e2e
+```
+
+To run individual test, use the path to it instead.
+
+If you are using `ninja` as your build system, you can run all the tests in the
+libsycl testsuite as:
+
+```bash
+ ninja -C <build>/runtimes/runtimes-bins check-sycl-e2e
+ ```
+
+
+## CMake parameters
+
+These parameters can be used to configure tests:
+
+`LIBSYCL_CXX_COMPILER` - path to compiler to use it for building tests.
+
+`LIBSYCL_E2E_CXX_FLAGS` - flags to be passed to `LIBSYCL_CXX_COMPILER` when
+    building libsycl end-to-end tests.
+
+`LLVM_LIT` - path to llvm-lit tool.
+
+## Creating or modifying tests
+
+### LIT feature checks
+
+Following features can be passed to LIT via `REQUIRES`, `UNSUPPORTED`, etc.
+filters to limit test execution to the specific environment.
+
+#### Auto-detected features
+
+The following features are automatically detected by `llvm-lit` by scanning the
+environment:
+
+* `linux` - host OS;
+* `any-device-is-gpu` - device type to be available;
+* `any-device-is-level_zero` - backend to be available;
+
+Note: `sycl-ls` tool doesn't have assigned feature since it is essential for
+tests configuration and is always available if test is executed.
+
+### llvm-lit parameters
+
+Following options can be passed to `llvm-lit` tool with `--param` option to
+configure test execution:
+
+* `libsycl_compiler` - full path to compiler to use;
+* `extra_environment` - comma-separated list of variables with values to be
+  added to test environment. Can be also set by `LIT_EXTRA_ENVIRONMENT`
+  variable in CMake.
+* `extra_system_environment` - comma-separated list of variables to be
+  propagated from the host environment to test environment. Can be also set by
+  `LIT_EXTRA_SYSTEM_ENVIRONMENT` variable in CMake.
+
+Example:
+
+```bash
+<build>/bin/llvm-lit  --param libsycl_compiler=path/to/clang++ \
+        <build>/runtimes/runtimes-bins/libsycl/test_e2e
+```

libsycl/test_e2e/basic/platform_get_devices.cpp

@@ -0,0 +1,121 @@
+// RUN: %clangxx %sycl_options %s -o %t.out
+// RUN: %t.out
+//
+// Tests platform::get_devices for each device type.
+
+#include <sycl.hpp>
+
+#include <algorithm>
+#include <iostream>
+
+std::string BackendToString(sycl::backend Backend) {
+  switch (Backend) {
+  case sycl::backend::opencl:
+    return "opencl";
+  case sycl::backend::level_zero:
+    return "level_zero";
+  case sycl::backend::cuda:
+    return "cuda";
+  case sycl::backend::hip:
+    return "hip";
+  default:
+    return "unknown";
+  }
+}
+
+std::string DeviceTypeToString(sycl::info::device_type DevType) {
+  switch (DevType) {
+  case sycl::info::device_type::all:
+    return "device_type::all";
+  case sycl::info::device_type::cpu:
+    return "device_type::cpu";
+  case sycl::info::device_type::gpu:
+    return "device_type::gpu";
+  case sycl::info::device_type::accelerator:
+    return "device_type::accelerator";
+  case sycl::info::device_type::custom:
+    return "device_type::custom";
+  case sycl::info::device_type::automatic:
+    return "device_type::automatic";
+  case sycl::info::device_type::host:
+    return "device_type::host";
+  default:
+    return "UNKNOWN";
+  }
+}
+
+std::string GenerateDeviceDescription(sycl::info::device_type DevType,
+                                      const sycl::platform &Platform) {
+  return std::string(DeviceTypeToString(DevType)) + " (" +
+         BackendToString(Platform.get_backend()) + ")";
+}
+
+template <typename T1, typename T2>
+int Check(const T1 &LHS, const T2 &RHS, std::string TestName) {
+  if (LHS != RHS) {
+    std::cerr << "Failed check " << LHS << " != " << RHS << ": " << TestName
+              << std::endl;
+    return 1;
+  }
+  return 0;
+}
+
+int CheckDeviceType(const sycl::platform &P, sycl::info::device_type DevType,
+                    std::vector<sycl::device> &AllDevices) {
+  assert(DevType != sycl::info::device_type::all);
+  int Failures = 0;
+
+  std::vector<sycl::device> Devices = P.get_devices(DevType);
+
+  if (DevType == sycl::info::device_type::automatic) {
+    if (AllDevices.empty()) {
+      Failures += Check(Devices.size(), 0,
+                        "No devices reported for device_type::all query, but "
+                        "device_type::automatic returns a device.");
+    } else {
+      Failures += Check(Devices.size(), 1,
+                        "Number of devices for device_type::automatic query.");
+      if (Devices.size())
+        Failures += Check(
+            std::count(AllDevices.begin(), AllDevices.end(), Devices[0]), 1,
+            "Device is in the set of device_type::all devices in the "
+            "platform.");
+    }
+    return Failures;
+  }
+
+  // Count devices with the type;
+  size_t DevCount = 0;
+  for (sycl::device Device : Devices)
+    DevCount += (Device.get_info<sycl::info::device::device_type>() == DevType);
+
+  Failures += Check(Devices.size(), DevCount,
+                    "Unexpected number of devices for " +
+                        GenerateDeviceDescription(DevType, P));
+
+  Failures +=
+      Check(std::all_of(Devices.begin(), Devices.end(),
+                        [&](const auto &Dev) {
+                          return std::count(AllDevices.begin(),
+                                            AllDevices.end(), Dev) == 1;
+                        }),
+            true,
+            "Not all devices for " + GenerateDeviceDescription(DevType, P) +
+                " appear in the list of all devices");
+
+  return Failures;
+}
+
+int main() {
+  int Failures = 0;
+  for (sycl::platform P : sycl::platform::get_platforms()) {
+    std::vector<sycl::device> Devices = P.get_devices();
+
+    for (sycl::info::device_type DevType :
+         {sycl::info::device_type::cpu, sycl::info::device_type::gpu,
+          sycl::info::device_type::accelerator, sycl::info::device_type::custom,
+          sycl::info::device_type::automatic, sycl::info::device_type::host})
+      Failures += CheckDeviceType(P, DevType, Devices);
+  }
+  return Failures;
+}