Add Offload API unittests

offload/new-api/src/offload_impl.cpp

@@ -25,6 +25,7 @@ using namespace llvm::omp::target::plugin;
 struct offload_device_handle_t_ {
   int DeviceNum;
   GenericDeviceTy &Device;
+  offload_platform_handle_t Platform;
 };
 
 struct offload_platform_handle_t_ {
@@ -59,7 +60,7 @@ void initPlugins() {
          DevNum++) {
       if (Platform.Plugin->init_device(DevNum) == OFFLOAD_SUCCESS) {
         Platform.Devices.emplace_back(offload_device_handle_t_{
-            DevNum, Platform.Plugin->getDevice(DevNum)});
+            DevNum, Platform.Plugin->getDevice(DevNum), &Platform});
       }
     }
   }
@@ -173,6 +174,8 @@ offload_result_t offloadDeviceGetInfo_impl(offload_device_handle_t hDevice,
   };
 
   switch (propName) {
+  case OFFLOAD_DEVICE_INFO_PLATFORM:
+    return ReturnValue(hDevice->Platform);
   case OFFLOAD_DEVICE_INFO_TYPE:
     return ReturnValue(OFFLOAD_DEVICE_TYPE_GPU);
   case OFFLOAD_DEVICE_INFO_NAME:
@@ -183,7 +186,7 @@ offload_result_t offloadDeviceGetInfo_impl(offload_device_handle_t hDevice,
     return ReturnValue(
         GetInfo({"CUDA Driver Version", "HSA Runtime Version"}).c_str());
   default:
-    return OFFLOAD_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+    return OFFLOAD_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
   return OFFLOAD_RESULT_SUCCESS;

offload/unittests/CMakeLists.txt

@@ -5,4 +5,5 @@ function(add_libompt_unittest test_dirname)
   add_unittest(LibomptUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
-add_subdirectory(Plugins)
+# add_subdirectory(Plugins)
+add_subdirectory(OffloadAPI)

offload/unittests/OffloadAPI/CMakeLists.txt

@@ -0,0 +1,12 @@
+set(PLUGINS_TEST_COMMON offload_new)
+set(PLUGINS_TEST_INCLUDE ${LIBOMPTARGET_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/common)
+
+add_libompt_unittest("offload.unittests"
+    ${CMAKE_CURRENT_SOURCE_DIR}/common/environment.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/platform/offloadPlatformGet.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/platform/offloadPlatformGetInfo.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/device/offloadDeviceGet.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/device/offloadDeviceGetInfo.cpp)
+add_dependencies("offload.unittests" ${PLUGINS_TEST_COMMON})
+target_link_libraries("offload.unittests" PRIVATE ${PLUGINS_TEST_COMMON})
+target_include_directories("offload.unittests" PRIVATE ${PLUGINS_TEST_INCLUDE})

offload/unittests/OffloadAPI/common/environment.cpp

@@ -0,0 +1,92 @@
+//===------- Offload API tests - gtest environment ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "environment.hpp"
+#include "fixtures.hpp"
+#include "llvm/Support/CommandLine.h"
+#include <offload_api.h>
+
+using namespace llvm;
+
+static cl::opt<std::string>
+    SelectedPlatform("platform", cl::desc("Only test the specified platform"),
+                     cl::value_desc("platform"));
+
+std::ostream &operator<<(std::ostream &Out,
+                         const offload_platform_handle_t &Platform) {
+  size_t Size;
+  offloadPlatformGetInfo(Platform, OFFLOAD_PLATFORM_INFO_NAME, 0, nullptr,
+                         &Size);
+  std::vector<char> Name(Size);
+  offloadPlatformGetInfo(Platform, OFFLOAD_PLATFORM_INFO_NAME, Size,
+                         Name.data(), nullptr);
+  Out << Name.data();
+  return Out;
+}
+
+std::ostream &
+operator<<(std::ostream &Out,
+           const std::vector<offload_platform_handle_t> &Platforms) {
+  for (auto Platform : Platforms) {
+    Out << "\n  * \"" << Platform << "\"";
+  }
+  return Out;
+}
+
+const std::vector<offload_platform_handle_t> &TestEnvironment::getPlatforms() {
+  static std::vector<offload_platform_handle_t> Platforms{};
+
+  if (Platforms.empty()) {
+    uint32_t PlatformCount = 0;
+    offloadPlatformGet(0, nullptr, &PlatformCount);
+    if (PlatformCount > 0) {
+      Platforms.resize(PlatformCount);
+      offloadPlatformGet(PlatformCount, Platforms.data(), nullptr);
+    }
+  }
+
+  return Platforms;
+}
+
+// Get a single platform, which may be selected by the user.
+offload_platform_handle_t TestEnvironment::getPlatform() {
+  static offload_platform_handle_t Platform = nullptr;
+  const auto &Platforms = getPlatforms();
+
+  if (!Platform) {
+    if (SelectedPlatform != "") {
+      for (const auto CandidatePlatform : Platforms) {
+        std::stringstream PlatformName;
+        PlatformName << CandidatePlatform;
+        if (SelectedPlatform == PlatformName.str()) {
+          Platform = CandidatePlatform;
+          return Platform;
+        }
+      }
+      std::cout << "No platform found with the name \"" << SelectedPlatform
+                << "\". Choose from:" << Platforms << "\n";
+      std::exit(1);
+    } else {
+      // Pick a single platform. We prefer one that has available devices, but
+      // just pick the first initially in case none have any devices.
+      Platform = Platforms[0];
+      for (auto CandidatePlatform : Platforms) {
+        uint32_t NumDevices = 0;
+        if (offloadDeviceGet(CandidatePlatform, OFFLOAD_DEVICE_TYPE_ALL, 0,
+                             nullptr, &NumDevices) == OFFLOAD_RESULT_SUCCESS) {
+          if (NumDevices > 0) {
+            Platform = CandidatePlatform;
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  return Platform;
+}

offload/unittests/OffloadAPI/common/environment.hpp

@@ -0,0 +1,17 @@
+//===------- Offload API tests - gtest environment ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <offload_api.h>
+
+namespace TestEnvironment {
+const std::vector<offload_platform_handle_t> &getPlatforms();
+offload_platform_handle_t getPlatform();
+} // namespace TestEnvironment

offload/unittests/OffloadAPI/common/fixtures.hpp

@@ -0,0 +1,54 @@
+//===------- Offload API tests - gtest fixtures --==-----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <gtest/gtest.h>
+#include <offload_api.h>
+#include <offload_print.hpp>
+
+#include "environment.hpp"
+
+#pragma once
+
+#ifndef ASSERT_SUCCESS
+#define ASSERT_SUCCESS(ACTUAL) ASSERT_EQ(OFFLOAD_RESULT_SUCCESS, ACTUAL)
+#endif
+
+#define RETURN_ON_FATAL_FAILURE(...)                                           \
+  __VA_ARGS__;                                                                 \
+  if (this->HasFatalFailure() || this->IsSkipped()) {                          \
+    return;                                                                    \
+  }                                                                            \
+  (void)0
+
+struct offloadPlatformTest : ::testing::Test {
+  void SetUp() override {
+    RETURN_ON_FATAL_FAILURE(::testing::Test::SetUp());
+
+    Platform = TestEnvironment::getPlatform();
+    ASSERT_NE(Platform, nullptr);
+  }
+
+  offload_platform_handle_t Platform;
+};
+
+struct offloadDeviceTest : offloadPlatformTest {
+  void SetUp() override {
+    RETURN_ON_FATAL_FAILURE(offloadPlatformTest::SetUp());
+
+    uint32_t NumDevices;
+    ASSERT_SUCCESS(offloadDeviceGet(Platform, OFFLOAD_DEVICE_TYPE_ALL, 0,
+                                    nullptr, &NumDevices));
+    if (NumDevices == 0) {
+      GTEST_SKIP() << "No available devices on this platform.";
+    }
+    ASSERT_SUCCESS(offloadDeviceGet(Platform, OFFLOAD_DEVICE_TYPE_ALL, 1,
+                                    &Device, nullptr));
+  }
+
+  offload_device_handle_t Device;
+};

offload/unittests/OffloadAPI/device/offloadDeviceGet.cpp

@@ -0,0 +1,41 @@
+//===------- Offload API tests - offloadDeviceGet -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../common/fixtures.hpp"
+#include <gtest/gtest.h>
+#include <offload_api.h>
+
+using offloadDeviceGetTest = offloadPlatformTest;
+
+TEST_F(offloadDeviceGetTest, Success) {
+  uint32_t Count = 0;
+  ASSERT_SUCCESS(
+      offloadDeviceGet(Platform, OFFLOAD_DEVICE_TYPE_ALL, 0, nullptr, &Count));
+  ASSERT_NE(Count, 0lu);
+  std::vector<offload_device_handle_t> Devices(Count);
+  ASSERT_SUCCESS(offloadDeviceGet(Platform, OFFLOAD_DEVICE_TYPE_ALL, Count,
+                                  Devices.data(), nullptr));
+  for (auto Device : Devices) {
+    ASSERT_NE(nullptr, Device);
+  }
+}
+
+TEST_F(offloadDeviceGetTest, SuccessSubsetOfDevices) {
+  uint32_t Count;
+  ASSERT_SUCCESS(
+      offloadDeviceGet(Platform, OFFLOAD_DEVICE_TYPE_ALL, 0, nullptr, &Count));
+  if (Count < 2) {
+    GTEST_SKIP() << "Only one device is available on this platform.";
+  }
+  std::vector<offload_device_handle_t> Devices(Count - 1);
+  ASSERT_SUCCESS(offloadDeviceGet(Platform, OFFLOAD_DEVICE_TYPE_ALL, Count - 1,
+                                  Devices.data(), nullptr));
+  for (auto Device : Devices) {
+    ASSERT_NE(nullptr, Device);
+  }
+}

offload/unittests/OffloadAPI/device/offloadDeviceGetInfo.cpp

@@ -0,0 +1,102 @@
+//===------- Offload API tests - offloadDeviceGetInfo ---------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../common/fixtures.hpp"
+#include <gtest/gtest.h>
+#include <offload_api.h>
+
+struct offloadDeviceGetInfoTest
+    : offloadDeviceTest,
+      ::testing::WithParamInterface<offload_device_info_t> {
+
+  void SetUp() override { RETURN_ON_FATAL_FAILURE(offloadDeviceTest::SetUp()); }
+};
+
+// TODO: We could autogenerate the list of enum values
+INSTANTIATE_TEST_SUITE_P(
+    , offloadDeviceGetInfoTest,
+    ::testing::Values(OFFLOAD_DEVICE_INFO_TYPE, OFFLOAD_DEVICE_INFO_PLATFORM,
+                      OFFLOAD_DEVICE_INFO_NAME, OFFLOAD_DEVICE_INFO_VENDOR,
+                      OFFLOAD_DEVICE_INFO_DRIVER_VERSION),
+    [](const ::testing::TestParamInfo<offload_device_info_t> &info) {
+      std::stringstream ss;
+      ss << info.param;
+      return ss.str();
+    });
+
+// TODO: We could autogenerate this
+std::unordered_map<offload_device_info_t, size_t> DeviceInfoSizeMap = {
+    {OFFLOAD_DEVICE_INFO_TYPE, sizeof(offload_device_type_t)},
+    {OFFLOAD_DEVICE_INFO_PLATFORM, sizeof(offload_platform_handle_t)},
+};
+
+TEST_P(offloadDeviceGetInfoTest, Success) {
+  offload_device_info_t InfoType = GetParam();
+  size_t Size = 0;
+
+  ASSERT_SUCCESS(offloadDeviceGetInfo(Device, InfoType, 0, nullptr, &Size));
+  auto ExpectedSize = DeviceInfoSizeMap.find(InfoType);
+  if (ExpectedSize != DeviceInfoSizeMap.end()) {
+    ASSERT_EQ(Size, ExpectedSize->second);
+  } else {
+    ASSERT_NE(Size, 0lu);
+  }
+
+  std::vector<char> InfoData(Size);
+  ASSERT_SUCCESS(
+      offloadDeviceGetInfo(Device, InfoType, Size, InfoData.data(), nullptr));
+
+  if (InfoType == OFFLOAD_DEVICE_INFO_PLATFORM) {
+    auto *ReturnedPlatform =
+        reinterpret_cast<offload_platform_handle_t *>(InfoData.data());
+    ASSERT_EQ(Platform, *ReturnedPlatform);
+  }
+}
+
+TEST_F(offloadDeviceGetInfoTest, InvalidNullHandleDevice) {
+  offload_device_type_t DeviceType;
+  ASSERT_EQ(OFFLOAD_RESULT_ERROR_INVALID_NULL_HANDLE,
+            offloadDeviceGetInfo(nullptr, OFFLOAD_DEVICE_INFO_TYPE,
+                                 sizeof(offload_device_type_t), &DeviceType,
+                                 nullptr));
+}
+
+TEST_F(offloadDeviceGetInfoTest, InvalidEnumerationInfoType) {
+  offload_device_type_t DeviceType;
+  ASSERT_EQ(OFFLOAD_RESULT_ERROR_INVALID_ENUMERATION,
+            offloadDeviceGetInfo(Device, OFFLOAD_DEVICE_INFO_FORCE_UINT32,
+                                 sizeof(offload_device_type_t), &DeviceType,
+                                 nullptr));
+}
+
+TEST_F(offloadDeviceGetInfoTest, InvalidSizePropSize) {
+  offload_device_type_t DeviceType;
+  ASSERT_EQ(OFFLOAD_RESULT_ERROR_INVALID_SIZE,
+            offloadDeviceGetInfo(Device, OFFLOAD_DEVICE_INFO_TYPE, 0,
+                                 &DeviceType, nullptr));
+}
+
+TEST_F(offloadDeviceGetInfoTest, InvalidSizePropSizeSmall) {
+  offload_device_type_t DeviceType;
+  ASSERT_EQ(OFFLOAD_RESULT_ERROR_INVALID_SIZE,
+            offloadDeviceGetInfo(Device, OFFLOAD_DEVICE_INFO_TYPE,
+                                 sizeof(DeviceType) - 1, &DeviceType, nullptr));
+}
+
+TEST_F(offloadDeviceGetInfoTest, InvalidNullPointerPropValue) {
+  offload_device_type_t DeviceType;
+  ASSERT_EQ(OFFLOAD_RESULT_ERROR_INVALID_NULL_POINTER,
+            offloadDeviceGetInfo(Device, OFFLOAD_DEVICE_INFO_TYPE,
+                                 sizeof(DeviceType), nullptr, nullptr));
+}
+
+TEST_F(offloadDeviceGetInfoTest, InvalidNullPointerPropSizeRet) {
+  ASSERT_EQ(OFFLOAD_RESULT_ERROR_INVALID_NULL_POINTER,
+            offloadDeviceGetInfo(Device, OFFLOAD_DEVICE_INFO_TYPE, 0, nullptr,
+                                 nullptr));
+}

offload/unittests/OffloadAPI/platform/offloadPlatformGet.cpp

@@ -0,0 +1,28 @@
+//===------- Offload API tests - offloadPlatformGet -----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <gtest/gtest.h>
+#include <offload_api.h>
+#include "../common/fixtures.hpp"
+
+using offloadPlatformGetTest = ::testing::Test;
+
+TEST_F(offloadPlatformGetTest, Success) {
+  uint32_t PlatformCount;
+  ASSERT_SUCCESS(offloadPlatformGet(0, nullptr, &PlatformCount));
+  std::vector<offload_platform_handle_t> Platforms(PlatformCount);
+  ASSERT_SUCCESS(offloadPlatformGet(PlatformCount, Platforms.data(), nullptr));
+}
+
+TEST_F(offloadPlatformGetTest, InvalidNumEntries) {
+  uint32_t PlatformCount;
+  ASSERT_SUCCESS(offloadPlatformGet(0, nullptr, &PlatformCount));
+  std::vector<offload_platform_handle_t> Platforms(PlatformCount);
+  ASSERT_EQ(offloadPlatformGet(0, Platforms.data(), nullptr),
+            OFFLOAD_RESULT_ERROR_INVALID_SIZE);
+}