[Offload] Add check-offload-unit for liboffload unittests (#137312)

Adds a `check-offload-unit` target for running the liboffload unit test
suite. This unit test binary runs the tests for every available device.
This can optionally filtered to devices from a single platform, but the
check target runs on everything.

The target is not part of `check-offload` and does not get propagated to
the top level build. I'm not sure if either of these things are
desirable, but I'm happy to look into it if we want.

Also remove the `offload/unittests/Plugins` test as it's dead code and
doesn't build.

Author: callumfare

offload/liboffload/src/OffloadImpl.cpp

@@ -142,6 +142,9 @@ void initPlugins() {
 
   // Preemptively initialize all devices in the plugin
   for (auto &Platform : Platforms()) {
+    // Do not use the host plugin - it isn't supported.
+    if (Platform.BackendType == OL_PLATFORM_BACKEND_UNKNOWN)
+      continue;
     auto Err = Platform.Plugin->init();
     [[maybe_unused]] std::string InfoMsg = toString(std::move(Err));
     for (auto DevNum = 0; DevNum < Platform.Plugin->number_of_devices();

offload/test/CMakeLists.txt

@@ -63,3 +63,15 @@ add_offload_testsuite(check-offload
   EXCLUDE_FROM_CHECK_ALL
   DEPENDS llvm-offload-device-info omptarget ${OMP_DEPEND} ${LIBOMPTARGET_TESTED_PLUGINS}
   ARGS ${LIBOMPTARGET_LIT_ARG_LIST})
+
+# Add liboffload unit tests - the test binary will run on all available devices
+configure_lit_site_cfg(
+  ${CMAKE_CURRENT_SOURCE_DIR}/unit/lit.site.cfg.in
+  ${CMAKE_CURRENT_BINARY_DIR}/unit/lit.site.cfg
+  MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/unit/lit.cfg.py)
+
+add_lit_testsuite(check-offload-unit "Running offload unittest suites"
+  ${CMAKE_CURRENT_BINARY_DIR}/unit
+  EXCLUDE_FROM_CHECK_ALL
+  DEPENDS LLVMOffload OffloadUnitTests)

offload/test/lit.cfg

@@ -69,7 +69,7 @@ config.name = 'libomptarget :: ' + config.libomptarget_current_target
 config.suffixes = ['.c', '.cpp', '.cc', '.f90', '.cu', '.td']
 
 # excludes: A list of directories to exclude from the testuites.
-config.excludes = ['Inputs']
+config.excludes = ['Inputs', 'unit']
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)

offload/test/unit/lit.cfg.py

@@ -0,0 +1,22 @@
+# -*- Python -*-
+
+# Configuration file for the 'lit' test runner.
+
+import os
+import subprocess
+
+import lit.formats
+
+# name: The name of this test suite.
+config.name = "Offload-Unit"
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = []
+
+# test_source_root: The root path where tests are located.
+# test_exec_root: The root path where tests should be run.
+config.test_exec_root = os.path.join(config.library_dir, "unittests")
+config.test_source_root = config.test_exec_root
+
+# testFormat: The test format to use to interpret tests.
+config.test_format = lit.formats.GoogleTest(config.llvm_build_mode, ".unittests")

offload/test/unit/lit.site.cfg.in

@@ -0,0 +1,8 @@
+@AUTO_GEN_COMMENT@
+
+config.library_dir = "@LIBOMPTARGET_LIBRARY_DIR@"
+config.llvm_build_mode = lit_config.substitute("@LLVM_BUILD_MODE@")
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/unit/lit.cfg.py")
+

offload/unittests/CMakeLists.txt

@@ -1,9 +1,8 @@
-add_custom_target(LibomptUnitTests)
-set_target_properties(LibomptUnitTests PROPERTIES FOLDER "Tests/UnitTests")
+add_custom_target(OffloadUnitTests)
+set_target_properties(OffloadUnitTests PROPERTIES FOLDER "Tests/UnitTests")
 
-function(add_libompt_unittest test_dirname)
-  add_unittest(LibomptUnitTests ${test_dirname} ${ARGN})
+function(add_offload_unittest test_dirname)
+  add_unittest(OffloadUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
-# add_subdirectory(Plugins)
 add_subdirectory(OffloadAPI)

offload/unittests/OffloadAPI/CMakeLists.txt

@@ -4,7 +4,7 @@ set(PLUGINS_TEST_INCLUDE ${LIBOMPTARGET_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}
 add_subdirectory(device_code)
 message(${OFFLOAD_TEST_DEVICE_CODE_PATH})
 
-add_libompt_unittest("offload.unittests"
+add_offload_unittest("offload.unittests"
     ${CMAKE_CURRENT_SOURCE_DIR}/common/Environment.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/platform/olGetPlatformInfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/platform/olGetPlatformInfoSize.cpp
@@ -22,7 +22,7 @@ add_libompt_unittest("offload.unittests"
     ${CMAKE_CURRENT_SOURCE_DIR}/kernel/olGetKernel.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/kernel/olLaunchKernel.cpp
     )
-add_dependencies("offload.unittests" ${PLUGINS_TEST_COMMON} LibomptUnitTestsDeviceBins)
+add_dependencies("offload.unittests" ${PLUGINS_TEST_COMMON} OffloadUnitTestsDeviceBins)
 target_compile_definitions("offload.unittests" PRIVATE DEVICE_CODE_PATH="${OFFLOAD_TEST_DEVICE_CODE_PATH}")
 target_link_libraries("offload.unittests" PRIVATE ${PLUGINS_TEST_COMMON})
 target_include_directories("offload.unittests" PRIVATE ${PLUGINS_TEST_INCLUDE})

offload/unittests/OffloadAPI/common/Environment.cpp

@@ -37,6 +37,15 @@ raw_ostream &operator<<(raw_ostream &Out,
   return Out;
 }
 
+raw_ostream &operator<<(raw_ostream &Out, const ol_device_handle_t &Device) {
+  size_t Size;
+  olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size);
+  std::vector<char> Name(Size);
+  olGetDeviceInfo(Device, OL_DEVICE_INFO_NAME, Size, Name.data());
+  Out << Name.data();
+  return Out;
+}
+
 void printPlatforms() {
   SmallDenseSet<ol_platform_handle_t> Platforms;
   using DeviceVecT = SmallVector<ol_device_handle_t, 8>;
@@ -61,48 +70,64 @@ void printPlatforms() {
   }
 }
 
-ol_device_handle_t TestEnvironment::getDevice() {
-  static ol_device_handle_t Device = nullptr;
+const std::vector<TestEnvironment::Device> &TestEnvironment::getDevices() {
+  static std::vector<TestEnvironment::Device> Devices{};
+  if (Devices.empty()) {
+    // If a specific platform is requested, filter to devices belonging to it.
+    if (const char *EnvStr = getenv("OFFLOAD_UNITTEST_PLATFORM")) {
+      if (SelectedPlatform != "")
+        errs() << "Warning: --platform argument ignored as "
+                  "OFFLOAD_UNITTEST_PLATFORM env var overrides it.\n";
+      SelectedPlatform = EnvStr;
+    }
 
-  if (!Device) {
     if (SelectedPlatform != "") {
       olIterateDevices(
           [](ol_device_handle_t D, void *Data) {
             ol_platform_handle_t Platform;
             olGetDeviceInfo(D, OL_DEVICE_INFO_PLATFORM, sizeof(Platform),
                             &Platform);
-
+            ol_platform_backend_t Backend;
+            olGetPlatformInfo(Platform, OL_PLATFORM_INFO_BACKEND,
+                              sizeof(Backend), &Backend);
             std::string PlatformName;
             raw_string_ostream S(PlatformName);
             S << Platform;
-
-            if (PlatformName == SelectedPlatform) {
-              *(static_cast<ol_device_handle_t *>(Data)) = D;
-              return false;
+            if (PlatformName == SelectedPlatform &&
+                Backend != OL_PLATFORM_BACKEND_HOST) {
+              std::string Name;
+              raw_string_ostream NameStr(Name);
+              NameStr << PlatformName << "_" << D;
+              static_cast<std::vector<TestEnvironment::Device> *>(Data)
+                  ->push_back({D, Name});
             }
-
             return true;
           },
-          &Device);
-
-      if (Device == nullptr) {
-        errs() << "No device found with the platform \"" << SelectedPlatform
-               << "\". Choose from:"
-               << "\n";
-        printPlatforms();
-        std::exit(1);
-      }
+          &Devices);
     } else {
+      // No platform specified, discover every device that isn't the host.
       olIterateDevices(
           [](ol_device_handle_t D, void *Data) {
-            *(static_cast<ol_device_handle_t *>(Data)) = D;
-            return false;
+            ol_platform_handle_t Platform;
+            olGetDeviceInfo(D, OL_DEVICE_INFO_PLATFORM, sizeof(Platform),
+                            &Platform);
+            ol_platform_backend_t Backend;
+            olGetPlatformInfo(Platform, OL_PLATFORM_INFO_BACKEND,
+                              sizeof(Backend), &Backend);
+            if (Backend != OL_PLATFORM_BACKEND_HOST) {
+              std::string Name;
+              raw_string_ostream NameStr(Name);
+              NameStr << Platform << "_" << D;
+              static_cast<std::vector<TestEnvironment::Device> *>(Data)
+                  ->push_back({D, Name});
+            }
+            return true;
           },
-          &Device);
+          &Devices);
     }
   }
 
-  return Device;
+  return Devices;
 }
 
 ol_device_handle_t TestEnvironment::getHostDevice() {

offload/unittests/OffloadAPI/common/Environment.hpp

@@ -13,7 +13,13 @@
 #include <gtest/gtest.h>
 
 namespace TestEnvironment {
-ol_device_handle_t getDevice();
+
+struct Device {
+  ol_device_handle_t Handle;
+  std::string Name;
+};
+
+const std::vector<Device> &getDevices();
 ol_device_handle_t getHostDevice();
 bool loadDeviceBinary(const std::string &BinaryName, ol_device_handle_t Device,
                       std::unique_ptr<llvm::MemoryBuffer> &BinaryOut);

offload/unittests/OffloadAPI/common/Fixtures.hpp

@@ -42,15 +42,26 @@
   }                                                                            \
   (void)0
 
+inline std::string SanitizeString(const std::string &Str) {
+  auto NewStr = Str;
+  std::replace_if(
+      NewStr.begin(), NewStr.end(), [](char C) { return !std::isalnum(C); },
+      '_');
+  return NewStr;
+}
+
 struct OffloadTest : ::testing::Test {
   ol_device_handle_t Host = TestEnvironment::getHostDevice();
 };
 
-struct OffloadDeviceTest : OffloadTest {
+struct OffloadDeviceTest
+    : OffloadTest,
+      ::testing::WithParamInterface<TestEnvironment::Device> {
   void SetUp() override {
     RETURN_ON_FATAL_FAILURE(OffloadTest::SetUp());
 
-    Device = TestEnvironment::getDevice();
+    auto DeviceParam = GetParam();
+    Device = DeviceParam.Handle;
     if (Device == nullptr)
       GTEST_SKIP() << "No available devices.";
   }
@@ -120,3 +131,10 @@ struct OffloadQueueTest : OffloadDeviceTest {
 
   ol_queue_handle_t Queue = nullptr;
 };
+
+#define OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(FIXTURE)                      \
+  INSTANTIATE_TEST_SUITE_P(                                                    \
+      , FIXTURE, ::testing::ValuesIn(TestEnvironment::getDevices()),           \
+      [](const ::testing::TestParamInfo<TestEnvironment::Device> &info) {      \
+        return SanitizeString(info.param.Name);                                \
+      })