[StreamExecutor] Read dev array directly in test

Summary:
Step 2 of getting GlobalDeviceMemory to own its handle.

Use the SimpleHostPlatformDevice allocate methods to create device
arrays for tests, and check for successful copies by dereferncing the
device array handle directly because we know it is really a host
pointer.

Reviewers: jlebar

Subscribers: jprice, parallel_libs-commits

Differential Revision: https://reviews.llvm.org/D24148

llvm-svn: 280428

1 files changed, 37 insertions, 30 deletions

diff --git a/parallel-libs/streamexecutor/lib/unittests/DeviceTest.cpp b/parallel-libs/streamexecutor/lib/unittests/DeviceTest.cpp
index 93d378fff5a..6e55aa51207 100644
--- a/parallel-libs/streamexecutor/lib/unittests/DeviceTest.cpp
+++ b/parallel-libs/streamexecutor/lib/unittests/DeviceTest.cpp
@@ -25,18 +25,28 @@ namespace {
 
 namespace se = ::streamexecutor;
 
+const auto &getDeviceValue =
+    se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
+
 /// Test fixture to hold objects used by tests.
 class DeviceTest : public ::testing::Test {
 public:
   DeviceTest()
-      : HostA5{0, 1, 2, 3, 4}, HostB5{5, 6, 7, 8, 9},
+      : 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(se::GlobalDeviceMemory<int>::makeFromElementCount(HostA5, 5)),
-        DeviceB5(se::GlobalDeviceMemory<int>::makeFromElementCount(HostB5, 5)),
-        DeviceA7(se::GlobalDeviceMemory<int>::makeFromElementCount(HostA7, 7)),
-        DeviceB7(se::GlobalDeviceMemory<int>::makeFromElementCount(HostB7, 7)),
-        Host5{24, 25, 26, 27, 28}, Host7{29, 30, 31, 32, 33, 34, 35},
-        Device(&PDevice) {}
+        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::Device Device;
 
   // Device memory is backed by host arrays.
   int HostA5[5];
@@ -51,9 +61,6 @@ public:
   // Host memory to be used as actual host memory.
   int Host5[5];
   int Host7[7];
-
-  SimpleHostPlatformDevice PDevice;
-  se::Device Device;
 };
 
 #define EXPECT_NO_ERROR(E) EXPECT_FALSE(static_cast<bool>(E))
@@ -186,12 +193,12 @@ TEST_F(DeviceTest, SyncCopyD2HSliceToPointer) {
 TEST_F(DeviceTest, SyncCopyH2DToArrayRefByCount) {
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
   }
 
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2));
   for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostB5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
   }
 
   EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7));
@@ -204,7 +211,7 @@ TEST_F(DeviceTest, SyncCopyH2DToArrayRefByCount) {
 TEST_F(DeviceTest, SyncCopyH2DToArrayRef) {
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
   }
 
   EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7));
@@ -215,7 +222,7 @@ TEST_F(DeviceTest, SyncCopyH2DToArrayRef) {
 TEST_F(DeviceTest, SyncCopyH2DToPointer) {
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5, 5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
   }
 
   EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5, 7));
@@ -225,13 +232,13 @@ TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRefByCount) {
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(
       ArrayRef<int>(Host5 + 1, 4), DeviceA5.asSlice().drop_front(1), 4));
   for (int I = 1; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
   }
 
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(
       ArrayRef<int>(Host5), DeviceB5.asSlice().drop_back(1), 2));
   for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostB5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
   }
 
   EXPECT_ERROR(
@@ -248,7 +255,7 @@ TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRef) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice()));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
   }
 
   EXPECT_ERROR(
@@ -261,7 +268,7 @@ TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRef) {
 TEST_F(DeviceTest, SyncCopyH2DSliceToPointer) {
   EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5.asSlice(), 5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
   }
 
   EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7));
@@ -272,12 +279,12 @@ TEST_F(DeviceTest, SyncCopyH2DSliceToPointer) {
 TEST_F(DeviceTest, SyncCopyD2DByCount) {
   EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
   }
 
   EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB7, 2));
   for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
   }
 
   EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 7));
@@ -290,7 +297,7 @@ TEST_F(DeviceTest, SyncCopyD2DByCount) {
 TEST_F(DeviceTest, SyncCopyD2D) {
   EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
   }
 
   EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5));
@@ -302,13 +309,13 @@ TEST_F(DeviceTest, SyncCopySliceD2DByCount) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4));
   for (int I = 0; I < 4; ++I) {
-    EXPECT_EQ(HostA5[I + 1], HostB5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
   }
 
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2));
   for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
   }
 
   EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5, 7));
@@ -322,7 +329,7 @@ TEST_F(DeviceTest, SyncCopySliceD2D) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA7[I], HostB5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
   }
 
   EXPECT_ERROR(
@@ -336,13 +343,13 @@ TEST_F(DeviceTest, SyncCopyD2DSliceByCount) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB7[I + 2]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
   }
 
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA7, DeviceB7.asSlice().drop_back(3), 2));
   for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
   }
 
   EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5.asSlice(), 7));
@@ -356,7 +363,7 @@ TEST_F(DeviceTest, SyncCopyD2DSlice) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_back(2)));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB7[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I));
   }
 
   EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice()));
@@ -368,13 +375,13 @@ TEST_F(DeviceTest, SyncCopySliceD2DSliceByCount) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 5));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
   }
 
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2));
   for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
   }
 
   EXPECT_ERROR(
@@ -391,7 +398,7 @@ TEST_F(DeviceTest, SyncCopySliceD2DSlice) {
   EXPECT_NO_ERROR(
       Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice()));
   for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
+    EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
   }
 
   EXPECT_ERROR(