[SE] Use real HostPlatformDevice for testing

[jhen]

Summary

Replace uses of SimpleHostPlatformDevice in tests with
HostPlatformDevice.

streamexecutor/include/streamexecutor/platforms/host/HostPlatformDevice.h

public:
   Error synchronousCopyD2D(const void *DeviceSrcHandle, size_t SrcByteOffset,
                            const void *DeviceDstHandle, size_t DstByteOffset,
                            size_t ByteCount) override {
     std::memcpy(offset(DeviceDstHandle, DstByteOffset),
                 offset(DeviceSrcHandle, SrcByteOffset), ByteCount);
     return Error::success();
   }
 
+  /// Gets the value at the given index from a GlobalDeviceMemory<T> instance
+  /// created by this class.
+  template <typename T>
+  static T getDeviceValue(const streamexecutor::GlobalDeviceMemory<T> &Memory,
+                          size_t Index) {
+    return static_cast<const T *>(Memory.getHandle())[Index];
+  }
+
 private:
   static void *offset(const void *Base, size_t Offset) {
     return const_cast<char *>(static_cast<const char *>(Base) + Offset);
   }
 };
 
 } // namespace host
 } // namespace streamexecutor
 
 #endif // STREAMEXECUTOR_PLATFORMS_HOST_HOSTPLATFORMDEVICE_H

streamexecutor/include/streamexecutor/unittests/CoreTests/SimpleHostPlatformDevice.h

-//===-- SimpleHostPlatformDevice.h - Host device for testing ----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// The SimpleHostPlatformDevice class is a streamexecutor::PlatformDevice that
-/// is really just the host processor and memory. It is useful for testing
-/// because no extra device platform is required.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef STREAMEXECUTOR_UNITTESTS_CORETESTS_SIMPLEHOSTPLATFORMDEVICE_H
-#define STREAMEXECUTOR_UNITTESTS_CORETESTS_SIMPLEHOSTPLATFORMDEVICE_H
-
-#include <cstdlib>
-#include <cstring>
-
-#include "streamexecutor/PlatformDevice.h"
-
-namespace streamexecutor {
-namespace test {
-
-/// A streamexecutor::PlatformDevice that simply forwards all operations to the
-/// host platform.
-///
-/// The allocate and copy methods are simple wrappers for std::malloc and
-/// std::memcpy.
-class SimpleHostPlatformDevice : public streamexecutor::PlatformDevice {
-public:
-  std::string getName() const override { return "SimpleHostPlatformDevice"; }
-
-  streamexecutor::Expected<const void *> createStream() override {
-    return nullptr;
-  }
-
-  streamexecutor::Expected<void *>
-  allocateDeviceMemory(size_t ByteCount) override {
-    return std::malloc(ByteCount);
-  }
-
-  streamexecutor::Error freeDeviceMemory(const void *Handle) override {
-    std::free(const_cast<void *>(Handle));
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error registerHostMemory(void *Memory,
-                                           size_t ByteCount) override {
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error unregisterHostMemory(const void *Memory) override {
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error copyD2H(const void *StreamHandle,
-                                const void *DeviceHandleSrc,
-                                size_t SrcByteOffset, void *HostDst,
-                                size_t DstByteOffset,
-                                size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
-                static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
-                ByteCount);
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error copyH2D(const void *StreamHandle, const void *HostSrc,
-                                size_t SrcByteOffset,
-                                const void *DeviceHandleDst,
-                                size_t DstByteOffset,
-                                size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
-                    DstByteOffset,
-                static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error
-  copyD2D(const void *StreamHandle, const void *DeviceHandleSrc,
-          size_t SrcByteOffset, const void *DeviceHandleDst,
-          size_t DstByteOffset, size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
-                    DstByteOffset,
-                static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
-                ByteCount);
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error synchronousCopyD2H(const void *DeviceHandleSrc,
-                                           size_t SrcByteOffset, void *HostDst,
-                                           size_t DstByteOffset,
-                                           size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
-                static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
-                ByteCount);
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error synchronousCopyH2D(const void *HostSrc,
-                                           size_t SrcByteOffset,
-                                           const void *DeviceHandleDst,
-                                           size_t DstByteOffset,
-                                           size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
-                    DstByteOffset,
-                static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
-    return streamexecutor::Error::success();
-  }
-
-  streamexecutor::Error synchronousCopyD2D(const void *DeviceHandleSrc,
-                                           size_t SrcByteOffset,
-                                           const void *DeviceHandleDst,
-                                           size_t DstByteOffset,
-                                           size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
-                    DstByteOffset,
-                static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
-                ByteCount);
-    return streamexecutor::Error::success();
-  }
-
-  /// Gets the value at the given index from a GlobalDeviceMemory<T> instance
-  /// created by this class.
-  template <typename T>
-  static T getDeviceValue(const streamexecutor::GlobalDeviceMemory<T> &Memory,
-                          size_t Index) {
-    return static_cast<const T *>(Memory.getHandle())[Index];
-  }
-};
-
-} // namespace test
-} // namespace streamexecutor
-
-#endif // STREAMEXECUTOR_UNITTESTS_CORETESTS_SIMPLEHOSTPLATFORMDEVICE_H

streamexecutor/unittests/CoreTests/DeviceTest.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include <cstdlib>
 #include <cstring>
 
 #include "streamexecutor/Device.h"
 #include "streamexecutor/PlatformDevice.h"
-#include "streamexecutor/unittests/CoreTests/SimpleHostPlatformDevice.h"
+#include "streamexecutor/platforms/host/HostPlatformDevice.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
-const auto &getDeviceValue =
-    se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
+const auto &getDeviceValue = se::host::HostPlatformDevice::getDeviceValue<int>;
 
 /// Test fixture to hold objects used by tests.
 class DeviceTest : public ::testing::Test {
 public:
   DeviceTest()
       : Device(&PDevice), HostA5{0, 1, 2, 3, 4}, HostB5{5, 6, 7, 8, 9},
         HostA7{10, 11, 12, 13, 14, 15, 16}, HostB7{17, 18, 19, 20, 21, 22, 23},
         DeviceA5(getOrDie(Device.allocateDeviceMemory<int>(5))),
         DeviceB5(getOrDie(Device.allocateDeviceMemory<int>(5))),
         DeviceA7(getOrDie(Device.allocateDeviceMemory<int>(7))),
         DeviceB7(getOrDie(Device.allocateDeviceMemory<int>(7))),
         Host5{24, 25, 26, 27, 28}, Host7{29, 30, 31, 32, 33, 34, 35} {
     se::dieIfError(Device.synchronousCopyH2D<int>(HostA5, DeviceA5));
     se::dieIfError(Device.synchronousCopyH2D<int>(HostB5, DeviceB5));
     se::dieIfError(Device.synchronousCopyH2D<int>(HostA7, DeviceA7));
     se::dieIfError(Device.synchronousCopyH2D<int>(HostB7, DeviceB7));
   }
 
-  se::test::SimpleHostPlatformDevice PDevice;
+  se::host::HostPlatformDevice PDevice;
   se::Device Device;
 
   // Device memory is backed by host arrays.
   int HostA5[5];
   int HostB5[5];
   int HostA7[7];
   int HostB7[7];
   se::GlobalDeviceMemory<int> DeviceA5;
do {                                                                         \
     se::Error E__ = E;                                                         \
     EXPECT_TRUE(static_cast<bool>(E__));                                       \
     consumeError(std::move(E__));                                              \
   } while (false)
 
 using llvm::ArrayRef;
 using llvm::MutableArrayRef;
 
-TEST_F(DeviceTest, GetName) {
-  EXPECT_EQ(Device.getName(), "SimpleHostPlatformDevice");
-}
+TEST_F(DeviceTest, GetName) { EXPECT_EQ(Device.getName(), "host"); }
 
 TEST_F(DeviceTest, AllocateAndFreeDeviceMemory) {
   se::Expected<se::GlobalDeviceMemory<int>> MaybeMemory =
       Device.allocateDeviceMemory<int>(10);
   EXPECT_TRUE(static_cast<bool>(MaybeMemory));
 }
 
 TEST_F(DeviceTest, RegisterAndUnregisterHostMemory) {

streamexecutor/unittests/CoreTests/PackedKernelArgumentArrayTest.cpp

 /// Unit tests for kernel argument packing.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "streamexecutor/Device.h"
 #include "streamexecutor/DeviceMemory.h"
 #include "streamexecutor/PackedKernelArgumentArray.h"
 #include "streamexecutor/PlatformDevice.h"
-#include "streamexecutor/unittests/CoreTests/SimpleHostPlatformDevice.h"
+#include "streamexecutor/platforms/host/HostPlatformDevice.h"
 
 #include "llvm/ADT/Twine.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
 using Type = se::KernelArgumentType;
 
 // Test fixture class for testing argument packing.
 //
 // Basically defines a bunch of types to be packed so they don't have to be
 // defined separately in each test.
 class DeviceMemoryPackingTest : public ::testing::Test {
 public:
   DeviceMemoryPackingTest()
       : Device(&PDevice), Value(42), Handle(&Value), ByteCount(15),
         ElementCount(5),
         TypedGlobal(getOrDie(Device.allocateDeviceMemory<int>(ElementCount))),
         TypedShared(
             se::SharedDeviceMemory<int>::makeFromElementCount(ElementCount)) {}
 
-  se::test::SimpleHostPlatformDevice PDevice;
+  se::host::HostPlatformDevice PDevice;
   se::Device Device;
   int Value;
   void *Handle;
   size_t ByteCount;
   size_t ElementCount;
   se::GlobalDeviceMemory<int> TypedGlobal;
   se::SharedDeviceMemory<int> TypedShared;
 };

streamexecutor/unittests/CoreTests/StreamTest.cpp

 
 #include <cstring>
 
 #include "streamexecutor/Device.h"
 #include "streamexecutor/Kernel.h"
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/PlatformDevice.h"
 #include "streamexecutor/Stream.h"
-#include "streamexecutor/unittests/CoreTests/SimpleHostPlatformDevice.h"
+#include "streamexecutor/platforms/host/HostPlatformDevice.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
-const auto &getDeviceValue =
-    se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
+const auto &getDeviceValue = se::host::HostPlatformDevice::getDeviceValue<int>;
 
 /// Test fixture to hold objects used by tests.
 class StreamTest : public ::testing::Test {
 public:
   StreamTest()
       : DummyPlatformStream(1), Device(&PDevice),
         Stream(&PDevice, &DummyPlatformStream), HostA5{0, 1, 2, 3, 4},
         HostB5{5, 6, 7, 8, 9}, HostA7{10, 11, 12, 13, 14, 15, 16},
StreamTest()
     se::dieIfError(Device.synchronousCopyH2D<int>(HostB5, DeviceB5));
     se::dieIfError(Device.synchronousCopyH2D<int>(HostA7, DeviceA7));
     se::dieIfError(Device.synchronousCopyH2D<int>(HostB7, DeviceB7));
   }
 
 protected:
   int DummyPlatformStream; // Mimicking a platform where the platform stream
                            // handle is just a stream number.
-  se::test::SimpleHostPlatformDevice PDevice;
+  se::host::HostPlatformDevice PDevice;
   se::Device Device;
   se::Stream Stream;
 
   // Device memory is matched by host arrays.
   int HostA5[5];
   int HostB5[5];
   int HostA7[7];
   int HostB7[7];