[Offload] Add check-offload-unit for liboffload unittests

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);                                \
+      })