[StreamExecutor] Rename Executor to Device

[jhen]

Summary

This more clearly describes what the class is.

[jlebar]

streamexecutor/lib/unittests/DeviceTest.cpp

476 ↗

(On Diff #69163)

Looks like the file rename from ExecutorTest to DeviceTest was lost.

[jhen]

Explicitly rename ExecutorTest

[jhen]

streamexecutor/lib/unittests/DeviceTest.cpp

476 ↗

(On Diff #69169)

I actually tried to fix this by redoing things with "git mv" to try to clue git in about the change, but it is still showing up as a separate deletion and addition. A little Googling suggests that this will happen if there are too many changes after the move because "git mv" is just an alias for "git rm && git add", so I think that's what happened here.

[jlebar]

streamexecutor/lib/unittests/DeviceTest.cpp

476 ↗

(On Diff #69169)

Oh, I was hoping that git-svn would have something that would let you explicitly say "foo was renamed to bar". But it sounds like not:

Renamed and copied directories are not detected by Git and hence not tracked when committing to SVN. I do not plan on adding support for this as it’s quite difficult and time-consuming to get working for all the possible corner cases (Git doesn’t do it, either). Committing renamed and copied files is fully supported if they’re similar enough for Git to detect them.

https://git-scm.com/docs/git-svn

Oh well, not a big deal.

parallel-libs/trunk/streamexecutor/include/streamexecutor/Device.h

+//===-- Device.h - The Device class -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// The Device class which represents a single device of a specific platform.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef STREAMEXECUTOR_DEVICE_H
+#define STREAMEXECUTOR_DEVICE_H
+
+#include "streamexecutor/KernelSpec.h"
+#include "streamexecutor/PlatformInterfaces.h"
+#include "streamexecutor/Utils/Error.h"
+
+namespace streamexecutor {
+
+class KernelInterface;
+class Stream;
+
+class Device {
+public:
+  explicit Device(PlatformDevice *PDevice);
+  virtual ~Device();
+
+  /// Gets the kernel implementation for the underlying platform.
+  virtual Expected<std::unique_ptr<KernelInterface>>
+  getKernelImplementation(const MultiKernelLoaderSpec &Spec) {
+    // TODO(jhen): Implement this.
+    return nullptr;
+  }
+
+  Expected<std::unique_ptr<Stream>> createStream();
+
+  /// Allocates an array of ElementCount entries of type T in device memory.
+  template <typename T>
+  Expected<GlobalDeviceMemory<T>> allocateDeviceMemory(size_t ElementCount) {
+    Expected<GlobalDeviceMemoryBase> MaybeBase =
+        PDevice->allocateDeviceMemory(ElementCount * sizeof(T));
+    if (!MaybeBase)
+      return MaybeBase.takeError();
+    return GlobalDeviceMemory<T>(*MaybeBase);
+  }
+
+  /// Frees memory previously allocated with allocateDeviceMemory.
+  template <typename T> Error freeDeviceMemory(GlobalDeviceMemory<T> Memory) {
+    return PDevice->freeDeviceMemory(Memory);
+  }
+
+  /// Allocates an array of ElementCount entries of type T in host memory.
+  ///
+  /// Host memory allocated by this function can be used for asynchronous memory
+  /// copies on streams. See Stream::thenCopyD2H and Stream::thenCopyH2D.
+  template <typename T> Expected<T *> allocateHostMemory(size_t ElementCount) {
+    Expected<void *> MaybeMemory =
+        PDevice->allocateHostMemory(ElementCount * sizeof(T));
+    if (!MaybeMemory)
+      return MaybeMemory.takeError();
+    return static_cast<T *>(*MaybeMemory);
+  }
+
+  /// Frees memory previously allocated with allocateHostMemory.
+  template <typename T> Error freeHostMemory(T *Memory) {
+    return PDevice->freeHostMemory(Memory);
+  }
+
+  /// Registers a previously allocated host array of type T for asynchronous
+  /// memory operations.
+  ///
+  /// Host memory registered by this function can be used for asynchronous
+  /// memory copies on streams. See Stream::thenCopyD2H and Stream::thenCopyH2D.
+  template <typename T>
+  Error registerHostMemory(T *Memory, size_t ElementCount) {
+    return PDevice->registerHostMemory(Memory, ElementCount * sizeof(T));
+  }
+
+  /// Unregisters host memory previously registered by registerHostMemory.
+  template <typename T> Error unregisterHostMemory(T *Memory) {
+    return PDevice->unregisterHostMemory(Memory);
+  }
+
+  /// \anchor DeviceHostSyncCopyGroup
+  /// \name Host-synchronous device memory copying functions
+  ///
+  /// These methods block the calling host thread while copying data to or from
+  /// device memory. On the device side, these methods do not block any ongoing
+  /// device calls.
+  ///
+  /// There are no restrictions on the host memory that is used as a source or
+  /// destination in these copy methods, so there is no need to allocate that
+  /// host memory using allocateHostMemory or register it with
+  /// registerHostMemory.
+  ///
+  /// Each of these methods has a single template parameter, T, that specifies
+  /// the type of data being copied. The ElementCount arguments specify the
+  /// number of objects of type T to be copied.
+  ///
+  /// For ease of use, each of the methods is overloaded to take either a
+  /// GlobalDeviceMemorySlice or a GlobalDeviceMemory argument in the device
+  /// memory argument slots, and the GlobalDeviceMemory arguments are just
+  /// converted to GlobalDeviceMemorySlice arguments internally by using
+  /// GlobalDeviceMemory::asSlice.
+  ///
+  /// These methods perform bounds checking to make sure that the ElementCount
+  /// is not too large for the source or destination. For methods that do not
+  /// take an ElementCount argument, an error is returned if the source size
+  /// does not exactly match the destination size.
+  ///@{
+
+  template <typename T>
+  Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src,
+                           llvm::MutableArrayRef<T> Dst, size_t ElementCount) {
+    if (ElementCount > Src.getElementCount())
+      return make_error("copying too many elements, " +
+                        llvm::Twine(ElementCount) +
+                        ", from a device array of element count " +
+                        llvm::Twine(Src.getElementCount()));
+    if (ElementCount > Dst.size())
+      return make_error(
+          "copying too many elements, " + llvm::Twine(ElementCount) +
+          ", to a host array of element count " + llvm::Twine(Dst.size()));
+    return PDevice->synchronousCopyD2H(Src.getBaseMemory(),
+                                       Src.getElementOffset() * sizeof(T),
+                                       Dst.data(), 0, ElementCount * sizeof(T));
+  }
+
+  template <typename T>
+  Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src,
+                           llvm::MutableArrayRef<T> Dst) {
+    if (Src.getElementCount() != Dst.size())
+      return make_error(
+          "array size mismatch for D2H, device source has element count " +
+          llvm::Twine(Src.getElementCount()) +
+          " but host destination has element count " + llvm::Twine(Dst.size()));
+    return synchronousCopyD2H(Src, Dst, Src.getElementCount());
+  }
+
+  template <typename T>
+  Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src, T *Dst,
+                           size_t ElementCount) {
+    return synchronousCopyD2H(Src, llvm::MutableArrayRef<T>(Dst, ElementCount),
+                              ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2H(GlobalDeviceMemory<T> Src,
+                           llvm::MutableArrayRef<T> Dst, size_t ElementCount) {
+    return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2H(GlobalDeviceMemory<T> Src,
+                           llvm::MutableArrayRef<T> Dst) {
+    return synchronousCopyD2H(Src.asSlice(), Dst);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2H(GlobalDeviceMemory<T> Src, T *Dst,
+                           size_t ElementCount) {
+    return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyH2D(llvm::ArrayRef<T> Src,
+                           GlobalDeviceMemorySlice<T> Dst,
+                           size_t ElementCount) {
+    if (ElementCount > Src.size())
+      return make_error(
+          "copying too many elements, " + llvm::Twine(ElementCount) +
+          ", from a host array of element count " + llvm::Twine(Src.size()));
+    if (ElementCount > Dst.getElementCount())
+      return make_error("copying too many elements, " +
+                        llvm::Twine(ElementCount) +
+                        ", to a device array of element count " +
+                        llvm::Twine(Dst.getElementCount()));
+    return PDevice->synchronousCopyH2D(Src.data(), 0, Dst.getBaseMemory(),
+                                       Dst.getElementOffset() * sizeof(T),
+                                       ElementCount * sizeof(T));
+  }
+
+  template <typename T>
+  Error synchronousCopyH2D(llvm::ArrayRef<T> Src,
+                           GlobalDeviceMemorySlice<T> Dst) {
+    if (Src.size() != Dst.getElementCount())
+      return make_error(
+          "array size mismatch for H2D, host source has element count " +
+          llvm::Twine(Src.size()) +
+          " but device destination has element count " +
+          llvm::Twine(Dst.getElementCount()));
+    return synchronousCopyH2D(Src, Dst, Dst.getElementCount());
+  }
+
+  template <typename T>
+  Error synchronousCopyH2D(T *Src, GlobalDeviceMemorySlice<T> Dst,
+                           size_t ElementCount) {
+    return synchronousCopyH2D(llvm::ArrayRef<T>(Src, ElementCount), Dst,
+                              ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst,
+                           size_t ElementCount) {
+    return synchronousCopyH2D(Src, Dst.asSlice(), ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst) {
+    return synchronousCopyH2D(Src, Dst.asSlice());
+  }
+
+  template <typename T>
+  Error synchronousCopyH2D(T *Src, GlobalDeviceMemory<T> Dst,
+                           size_t ElementCount) {
+    return synchronousCopyH2D(Src, Dst.asSlice(), ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
+                           GlobalDeviceMemorySlice<T> Dst,
+                           size_t ElementCount) {
+    if (ElementCount > Src.getElementCount())
+      return make_error("copying too many elements, " +
+                        llvm::Twine(ElementCount) +
+                        ", from a device array of element count " +
+                        llvm::Twine(Src.getElementCount()));
+    if (ElementCount > Dst.getElementCount())
+      return make_error("copying too many elements, " +
+                        llvm::Twine(ElementCount) +
+                        ", to a device array of element count " +
+                        llvm::Twine(Dst.getElementCount()));
+    return PDevice->synchronousCopyD2D(
+        Src.getBaseMemory(), Src.getElementOffset() * sizeof(T),
+        Dst.getBaseMemory(), Dst.getElementOffset() * sizeof(T),
+        ElementCount * sizeof(T));
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
+                           GlobalDeviceMemorySlice<T> Dst) {
+    if (Src.getElementCount() != Dst.getElementCount())
+      return make_error(
+          "array size mismatch for D2D, device source has element count " +
+          llvm::Twine(Src.getElementCount()) +
+          " but device destination has element count " +
+          llvm::Twine(Dst.getElementCount()));
+    return synchronousCopyD2D(Src, Dst, Src.getElementCount());
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src,
+                           GlobalDeviceMemorySlice<T> Dst,
+                           size_t ElementCount) {
+    return synchronousCopyD2D(Src.asSlice(), Dst, ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src,
+                           GlobalDeviceMemorySlice<T> Dst) {
+    return synchronousCopyD2D(Src.asSlice(), Dst);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
+                           GlobalDeviceMemory<T> Dst, size_t ElementCount) {
+    return synchronousCopyD2D(Src, Dst.asSlice(), ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
+                           GlobalDeviceMemory<T> Dst) {
+    return synchronousCopyD2D(Src, Dst.asSlice());
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src, GlobalDeviceMemory<T> Dst,
+                           size_t ElementCount) {
+    return synchronousCopyD2D(Src.asSlice(), Dst.asSlice(), ElementCount);
+  }
+
+  template <typename T>
+  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src,
+                           GlobalDeviceMemory<T> Dst) {
+    return synchronousCopyD2D(Src.asSlice(), Dst.asSlice());
+  }
+
+  ///@} End host-synchronous device memory copying functions
+
+private:
+  PlatformDevice *PDevice;
+};
+
+} // namespace streamexecutor
+
+#endif // STREAMEXECUTOR_DEVICE_H

parallel-libs/trunk/streamexecutor/include/streamexecutor/Executor.h

-//===-- Executor.h - The Executor class -------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// The Executor class which represents a single device of a specific platform.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef STREAMEXECUTOR_EXECUTOR_H
-#define STREAMEXECUTOR_EXECUTOR_H
-
-#include "streamexecutor/KernelSpec.h"
-#include "streamexecutor/PlatformInterfaces.h"
-#include "streamexecutor/Utils/Error.h"
-
-namespace streamexecutor {
-
-class KernelInterface;
-class Stream;
-
-class Executor {
-public:
-  explicit Executor(PlatformExecutor *PExecutor);
-  virtual ~Executor();
-
-  /// Gets the kernel implementation for the underlying platform.
-  virtual Expected<std::unique_ptr<KernelInterface>>
-  getKernelImplementation(const MultiKernelLoaderSpec &Spec) {
-    // TODO(jhen): Implement this.
-    return nullptr;
-  }
-
-  Expected<std::unique_ptr<Stream>> createStream();
-
-  /// Allocates an array of ElementCount entries of type T in device memory.
-  template <typename T>
-  Expected<GlobalDeviceMemory<T>> allocateDeviceMemory(size_t ElementCount) {
-    Expected<GlobalDeviceMemoryBase> MaybeBase =
-        PExecutor->allocateDeviceMemory(ElementCount * sizeof(T));
-    if (!MaybeBase)
-      return MaybeBase.takeError();
-    return GlobalDeviceMemory<T>(*MaybeBase);
-  }
-
-  /// Frees memory previously allocated with allocateDeviceMemory.
-  template <typename T> Error freeDeviceMemory(GlobalDeviceMemory<T> Memory) {
-    return PExecutor->freeDeviceMemory(Memory);
-  }
-
-  /// Allocates an array of ElementCount entries of type T in host memory.
-  ///
-  /// Host memory allocated by this function can be used for asynchronous memory
-  /// copies on streams. See Stream::thenCopyD2H and Stream::thenCopyH2D.
-  template <typename T> Expected<T *> allocateHostMemory(size_t ElementCount) {
-    Expected<void *> MaybeMemory =
-        PExecutor->allocateHostMemory(ElementCount * sizeof(T));
-    if (!MaybeMemory)
-      return MaybeMemory.takeError();
-    return static_cast<T *>(*MaybeMemory);
-  }
-
-  /// Frees memory previously allocated with allocateHostMemory.
-  template <typename T> Error freeHostMemory(T *Memory) {
-    return PExecutor->freeHostMemory(Memory);
-  }
-
-  /// Registers a previously allocated host array of type T for asynchronous
-  /// memory operations.
-  ///
-  /// Host memory registered by this function can be used for asynchronous
-  /// memory copies on streams. See Stream::thenCopyD2H and Stream::thenCopyH2D.
-  template <typename T>
-  Error registerHostMemory(T *Memory, size_t ElementCount) {
-    return PExecutor->registerHostMemory(Memory, ElementCount * sizeof(T));
-  }
-
-  /// Unregisters host memory previously registered by registerHostMemory.
-  template <typename T> Error unregisterHostMemory(T *Memory) {
-    return PExecutor->unregisterHostMemory(Memory);
-  }
-
-  /// \anchor ExecutorHostSyncCopyGroup
-  /// \name Host-synchronous device memory copying functions
-  ///
-  /// These methods block the calling host thread while copying data to or from
-  /// device memory. On the device side, these methods do not block any ongoing
-  /// device calls.
-  ///
-  /// There are no restrictions on the host memory that is used as a source or
-  /// destination in these copy methods, so there is no need to allocate that
-  /// host memory using allocateHostMemory or register it with
-  /// registerHostMemory.
-  ///
-  /// Each of these methods has a single template parameter, T, that specifies
-  /// the type of data being copied. The ElementCount arguments specify the
-  /// number of objects of type T to be copied.
-  ///
-  /// For ease of use, each of the methods is overloaded to take either a
-  /// GlobalDeviceMemorySlice or a GlobalDeviceMemory argument in the device
-  /// memory argument slots, and the GlobalDeviceMemory arguments are just
-  /// converted to GlobalDeviceMemorySlice arguments internally by using
-  /// GlobalDeviceMemory::asSlice.
-  ///
-  /// These methods perform bounds checking to make sure that the ElementCount
-  /// is not too large for the source or destination. For methods that do not
-  /// take an ElementCount argument, an error is returned if the source size
-  /// does not exactly match the destination size.
-  ///@{
-
-  template <typename T>
-  Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src,
-                           llvm::MutableArrayRef<T> Dst, size_t ElementCount) {
-    if (ElementCount > Src.getElementCount())
-      return make_error("copying too many elements, " +
-                        llvm::Twine(ElementCount) +
-                        ", from a device array of element count " +
-                        llvm::Twine(Src.getElementCount()));
-    if (ElementCount > Dst.size())
-      return make_error(
-          "copying too many elements, " + llvm::Twine(ElementCount) +
-          ", to a host array of element count " + llvm::Twine(Dst.size()));
-    return PExecutor->synchronousCopyD2H(
-        Src.getBaseMemory(), Src.getElementOffset() * sizeof(T), Dst.data(), 0,
-        ElementCount * sizeof(T));
-  }
-
-  template <typename T>
-  Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src,
-                           llvm::MutableArrayRef<T> Dst) {
-    if (Src.getElementCount() != Dst.size())
-      return make_error(
-          "array size mismatch for D2H, device source has element count " +
-          llvm::Twine(Src.getElementCount()) +
-          " but host destination has element count " + llvm::Twine(Dst.size()));
-    return synchronousCopyD2H(Src, Dst, Src.getElementCount());
-  }
-
-  template <typename T>
-  Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src, T *Dst,
-                           size_t ElementCount) {
-    return synchronousCopyD2H(Src, llvm::MutableArrayRef<T>(Dst, ElementCount),
-                              ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2H(GlobalDeviceMemory<T> Src,
-                           llvm::MutableArrayRef<T> Dst, size_t ElementCount) {
-    return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2H(GlobalDeviceMemory<T> Src,
-                           llvm::MutableArrayRef<T> Dst) {
-    return synchronousCopyD2H(Src.asSlice(), Dst);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2H(GlobalDeviceMemory<T> Src, T *Dst,
-                           size_t ElementCount) {
-    return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyH2D(llvm::ArrayRef<T> Src,
-                           GlobalDeviceMemorySlice<T> Dst,
-                           size_t ElementCount) {
-    if (ElementCount > Src.size())
-      return make_error(
-          "copying too many elements, " + llvm::Twine(ElementCount) +
-          ", from a host array of element count " + llvm::Twine(Src.size()));
-    if (ElementCount > Dst.getElementCount())
-      return make_error("copying too many elements, " +
-                        llvm::Twine(ElementCount) +
-                        ", to a device array of element count " +
-                        llvm::Twine(Dst.getElementCount()));
-    return PExecutor->synchronousCopyH2D(Src.data(), 0, Dst.getBaseMemory(),
-                                         Dst.getElementOffset() * sizeof(T),
-                                         ElementCount * sizeof(T));
-  }
-
-  template <typename T>
-  Error synchronousCopyH2D(llvm::ArrayRef<T> Src,
-                           GlobalDeviceMemorySlice<T> Dst) {
-    if (Src.size() != Dst.getElementCount())
-      return make_error(
-          "array size mismatch for H2D, host source has element count " +
-          llvm::Twine(Src.size()) +
-          " but device destination has element count " +
-          llvm::Twine(Dst.getElementCount()));
-    return synchronousCopyH2D(Src, Dst, Dst.getElementCount());
-  }
-
-  template <typename T>
-  Error synchronousCopyH2D(T *Src, GlobalDeviceMemorySlice<T> Dst,
-                           size_t ElementCount) {
-    return synchronousCopyH2D(llvm::ArrayRef<T>(Src, ElementCount), Dst,
-                              ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst,
-                           size_t ElementCount) {
-    return synchronousCopyH2D(Src, Dst.asSlice(), ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst) {
-    return synchronousCopyH2D(Src, Dst.asSlice());
-  }
-
-  template <typename T>
-  Error synchronousCopyH2D(T *Src, GlobalDeviceMemory<T> Dst,
-                           size_t ElementCount) {
-    return synchronousCopyH2D(Src, Dst.asSlice(), ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
-                           GlobalDeviceMemorySlice<T> Dst,
-                           size_t ElementCount) {
-    if (ElementCount > Src.getElementCount())
-      return make_error("copying too many elements, " +
-                        llvm::Twine(ElementCount) +
-                        ", from a device array of element count " +
-                        llvm::Twine(Src.getElementCount()));
-    if (ElementCount > Dst.getElementCount())
-      return make_error("copying too many elements, " +
-                        llvm::Twine(ElementCount) +
-                        ", to a device array of element count " +
-                        llvm::Twine(Dst.getElementCount()));
-    return PExecutor->synchronousCopyD2D(
-        Src.getBaseMemory(), Src.getElementOffset() * sizeof(T),
-        Dst.getBaseMemory(), Dst.getElementOffset() * sizeof(T),
-        ElementCount * sizeof(T));
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
-                           GlobalDeviceMemorySlice<T> Dst) {
-    if (Src.getElementCount() != Dst.getElementCount())
-      return make_error(
-          "array size mismatch for D2D, device source has element count " +
-          llvm::Twine(Src.getElementCount()) +
-          " but device destination has element count " +
-          llvm::Twine(Dst.getElementCount()));
-    return synchronousCopyD2D(Src, Dst, Src.getElementCount());
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src,
-                           GlobalDeviceMemorySlice<T> Dst,
-                           size_t ElementCount) {
-    return synchronousCopyD2D(Src.asSlice(), Dst, ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src,
-                           GlobalDeviceMemorySlice<T> Dst) {
-    return synchronousCopyD2D(Src.asSlice(), Dst);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
-                           GlobalDeviceMemory<T> Dst, size_t ElementCount) {
-    return synchronousCopyD2D(Src, Dst.asSlice(), ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
-                           GlobalDeviceMemory<T> Dst) {
-    return synchronousCopyD2D(Src, Dst.asSlice());
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src, GlobalDeviceMemory<T> Dst,
-                           size_t ElementCount) {
-    return synchronousCopyD2D(Src.asSlice(), Dst.asSlice(), ElementCount);
-  }
-
-  template <typename T>
-  Error synchronousCopyD2D(GlobalDeviceMemory<T> Src,
-                           GlobalDeviceMemory<T> Dst) {
-    return synchronousCopyD2D(Src.asSlice(), Dst.asSlice());
-  }
-
-  ///@} End host-synchronous device memory copying functions
-
-private:
-  PlatformExecutor *PExecutor;
-};
-
-} // namespace streamexecutor
-
-#endif // STREAMEXECUTOR_EXECUTOR_H

parallel-libs/trunk/streamexecutor/include/streamexecutor/Kernel.h

 ///     using SaxpyKernel =
 ///         streamexecutor::TypedKernel<float *, float *, float *>;
 ///     } // namespace compiler_cuda_namespace
 /// \endcode
 /// and then the user can launch the kernel by calling the StreamExecutor launch
 /// function as follows:
 /// \code
 ///     namespace ccn = compiler_cuda_namespace;
-///     // Assumes Executor is a pointer to the StreamExecutor on which to
-///     // launch the kernel.
+///     // Assumes Device is a pointer to the Device on which to launch the
+///     // kernel.
 ///     //
 ///     // See KernelSpec.h for details on how the compiler can create a
 ///     // MultiKernelLoaderSpec instance like SaxpyKernelLoaderSpec below.
 ///     Expected<ccn::SaxpyKernel> MaybeKernel =
-///         ccn::SaxpyKernel::create(Executor, ccn::SaxpyKernelLoaderSpec);
+///         ccn::SaxpyKernel::create(Device, ccn::SaxpyKernelLoaderSpec);
 ///     if (!MaybeKernel) { /* Handle error */ }
 ///     ccn::SaxpyKernel SaxpyKernel = *MaybeKernel;
 ///     Launch(SaxpyKernel, A, X, Y);
 /// \endcode
 ///
 /// With the compiler's help in specializing TypedKernel for each device kernel
 /// function (and generating a MultiKernelLoaderSpec instance for each kernel),
 /// the user can safely launch the device kernel from the host and get an error
 /// message at compile time if the argument types don't match the kernel
 /// parameter types.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef STREAMEXECUTOR_KERNEL_H
 #define STREAMEXECUTOR_KERNEL_H
 
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/Utils/Error.h"
 
 #include <memory>
 
 namespace streamexecutor {
 
-class Executor;
+class Device;
 class KernelInterface;
 
 /// The base class for device kernel functions.
 ///
 /// This class has no information about the types of the parameters taken by the
 /// kernel, so it is analogous to a void* pointer to a device function.
 ///
 /// See the TypedKernel class below for the subclass which does have information
 /// about parameter types.
 class KernelBase {
 public:
   KernelBase(KernelBase &&) = default;
   KernelBase &operator=(KernelBase &&) = default;
   ~KernelBase();
 
-  /// Creates a kernel object from an Executor and a MultiKernelLoaderSpec.
+  /// Creates a kernel object from a Device and a MultiKernelLoaderSpec.
   ///
-  /// The Executor knows which platform it belongs to and the
+  /// The Device knows which platform it belongs to and the
   /// MultiKernelLoaderSpec knows how to find the kernel code for different
   /// platforms, so the combined information is enough to get the kernel code
   /// for the appropriate platform.
-  static Expected<KernelBase> create(Executor *ParentExecutor,
+  static Expected<KernelBase> create(Device *Dev,
                                      const MultiKernelLoaderSpec &Spec);
 
   const std::string &getName() const { return Name; }
   const std::string &getDemangledName() const { return DemangledName; }
 
   /// Gets a pointer to the platform-specific implementation of this kernel.
   KernelInterface *getImplementation() { return Implementation.get(); }
 
 private:
-  KernelBase(Executor *ParentExecutor, const std::string &Name,
+  KernelBase(Device *Dev, const std::string &Name,
              const std::string &DemangledName,
              std::unique_ptr<KernelInterface> Implementation);
 
-  Executor *ParentExecutor;
+  Device *TheDevice;
   std::string Name;
   std::string DemangledName;
   std::unique_ptr<KernelInterface> Implementation;
 
   KernelBase(const KernelBase &) = delete;
   KernelBase &operator=(const KernelBase &) = delete;
 };
 
 /// A device kernel function with specified parameter types.
 template <typename... ParameterTs> class TypedKernel : public KernelBase {
 public:
   TypedKernel(TypedKernel &&) = default;
   TypedKernel &operator=(TypedKernel &&) = default;
 
   /// Parameters here have the same meaning as in KernelBase::create.
-  static Expected<TypedKernel> create(Executor *ParentExecutor,
+  static Expected<TypedKernel> create(Device *Dev,
                                       const MultiKernelLoaderSpec &Spec) {
-    auto MaybeBase = KernelBase::create(ParentExecutor, Spec);
+    auto MaybeBase = KernelBase::create(Dev, Spec);
     if (!MaybeBase) {
       return MaybeBase.takeError();
     }
     TypedKernel Instance(std::move(*MaybeBase));
     return std::move(Instance);
   }
 
 private:

parallel-libs/trunk/streamexecutor/include/streamexecutor/PlatformInterfaces.h

 #include "streamexecutor/DeviceMemory.h"
 #include "streamexecutor/Kernel.h"
 #include "streamexecutor/LaunchDimensions.h"
 #include "streamexecutor/PackedKernelArgumentArray.h"
 #include "streamexecutor/Utils/Error.h"
 
 namespace streamexecutor {
 
-class PlatformExecutor;
+class PlatformDevice;
 
 /// Methods supported by device kernel function objects on all platforms.
 class KernelInterface {
   // TODO(jhen): Add methods.
 };
 
 /// Platform-specific stream handle.
 class PlatformStreamHandle {
 public:
-  explicit PlatformStreamHandle(PlatformExecutor *PExecutor)
-      : PExecutor(PExecutor) {}
+  explicit PlatformStreamHandle(PlatformDevice *PDevice) : PDevice(PDevice) {}
 
   virtual ~PlatformStreamHandle();
 
-  PlatformExecutor *getExecutor() { return PExecutor; }
+  PlatformDevice *getDevice() { return PDevice; }
 
 private:
-  PlatformExecutor *PExecutor;
+  PlatformDevice *PDevice;
 };
 
 /// Raw executor methods that must be implemented by each platform.
 ///
 /// This class defines the platform interface that supports executing work on a
 /// device.
 ///
-/// The public Executor and Stream classes have the type-safe versions of the
+/// The public Device and Stream classes have the type-safe versions of the
 /// functions in this interface.
-class PlatformExecutor {
+class PlatformDevice {
 public:
-  virtual ~PlatformExecutor();
+  virtual ~PlatformDevice();
 
   virtual std::string getName() const = 0;
 
   /// Creates a platform-specific stream.
   virtual Expected<std::unique_ptr<PlatformStreamHandle>> createStream() = 0;
 
   /// Launches a kernel on the given stream.
   virtual Error launch(PlatformStreamHandle *S, BlockDimensions BlockSize,

parallel-libs/trunk/streamexecutor/include/streamexecutor/Stream.h

 //===-- Stream.h - A stream of execution ------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
 /// A Stream instance represents a queue of sequential, host-asynchronous work
 /// to be performed on a device.
 ///
-/// To enqueue work on a device, first create a Executor instance for a
-/// given device and then use that Executor to create a Stream instance.
-/// The Stream instance will perform its work on the device managed by the
-/// Executor that created it.
+/// To enqueue work on a device, first create a Device instance then use that
+/// Device to create a Stream instance. The Stream instance will perform its
+/// work on the device managed by the Device object that created it.
 ///
 /// The various "then" methods of the Stream object, such as thenCopyH2D and
 /// thenLaunch, may be used to enqueue work on the Stream, and the
 /// blockHostUntilDone() method may be used to block the host code until the
 /// Stream has completed all its work.
 ///
-/// Multiple Stream instances can be created for the same Executor. This
-/// allows several independent streams of computation to be performed
-/// simultaneously on a single device.
+/// Multiple Stream instances can be created for the same Device. This allows
+/// several independent streams of computation to be performed simultaneously on
+/// a single device.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef STREAMEXECUTOR_STREAM_H
 #define STREAMEXECUTOR_STREAM_H
 
 #include <cassert>
 #include <memory>
public:
   /// allowable argument types are determined by the template parameters to the
   /// TypedKernel argument.
   template <typename... ParameterTs>
   Stream &thenLaunch(BlockDimensions BlockSize, GridDimensions GridSize,
                      const TypedKernel<ParameterTs...> &Kernel,
                      const ParameterTs &... Arguments) {
     auto ArgumentArray =
         make_kernel_argument_pack<ParameterTs...>(Arguments...);
-    setError(PExecutor->launch(ThePlatformStream.get(), BlockSize, GridSize,
-                               Kernel, ArgumentArray));
+    setError(PDevice->launch(ThePlatformStream.get(), BlockSize, GridSize,
     return *this;
   }
 
   /// \name Device memory copying functions
   ///
   /// These methods enqueue a device memory copy operation on the stream and
   /// return without waiting for the operation to complete.
   ///
   /// Any host memory used as a source or destination for one of these
-  /// operations must be allocated with Executor::allocateHostMemory or
-  /// registered with Executor::registerHostMemory. Otherwise, the enqueuing
-  /// operation may block until the copy operation is fully complete.
+  /// operations must be allocated with Device::allocateHostMemory or registered
+  /// with Device::registerHostMemory. Otherwise, the enqueuing operation may
+  /// block until the copy operation is fully complete.
   ///
   /// The arguments and bounds checking for these methods match the API of the
-  /// \ref ExecutorHostSyncCopyGroup
-  /// "host-synchronous device memory copying functions" of Executor.
+  /// \ref DeviceHostSyncCopyGroup
+  /// "host-synchronous device memory copying functions" of Device.
   ///@{
 
   template <typename T>
   Stream &thenCopyD2H(GlobalDeviceMemorySlice<T> Src,
                       llvm::MutableArrayRef<T> Dst, size_t ElementCount) {
     if (ElementCount > Src.getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", from a device array of element count " +
                llvm::Twine(Src.getElementCount()));
     else if (ElementCount > Dst.size())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", to a host array of element count " + llvm::Twine(Dst.size()));
     else
-      setError(PExecutor->copyD2H(ThePlatformStream.get(), Src.getBaseMemory(),
-                                  Src.getElementOffset() * sizeof(T),
-                                  Dst.data(), 0, ElementCount * sizeof(T)));
+      setError(PDevice->copyD2H(ThePlatformStream.get(), Src.getBaseMemory(),
+                                Src.getElementOffset() * sizeof(T), Dst.data(),
+                                0, ElementCount * sizeof(T)));
     return *this;
   }
 
   template <typename T>
   Stream &thenCopyD2H(GlobalDeviceMemorySlice<T> Src,
                       llvm::MutableArrayRef<T> Dst) {
     if (Src.getElementCount() != Dst.size())
       setError("array size mismatch for D2H, device source has element count " +
if (ElementCount > Src.size())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", from a host array of element count " +
                llvm::Twine(Src.size()));
     else if (ElementCount > Dst.getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", to a device array of element count " +
                llvm::Twine(Dst.getElementCount()));
     else
-      setError(PExecutor->copyH2D(
+      setError(PDevice->copyH2D(
           ThePlatformStream.get(), Src.data(), 0, Dst.getBaseMemory(),
           Dst.getElementOffset() * sizeof(T), ElementCount * sizeof(T)));
     return *this;
   }
 
   template <typename T>
   Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemorySlice<T> Dst) {
     if (Src.size() != Dst.getElementCount())
if (ElementCount > Src.getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", from a device array of element count " +
                llvm::Twine(Src.getElementCount()));
     else if (ElementCount > Dst.getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", to a device array of element count " +
                llvm::Twine(Dst.getElementCount()));
     else
-      setError(PExecutor->copyD2D(
+      setError(PDevice->copyD2D(
           ThePlatformStream.get(), Src.getBaseMemory(),
           Src.getElementOffset() * sizeof(T), Dst.getBaseMemory(),
           Dst.getElementOffset() * sizeof(T), ElementCount * sizeof(T)));
     return *this;
   }
 
   template <typename T>
   Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src,
private:
   ///
   /// Does not overwrite the error if it is already set.
   void setError(llvm::Twine Message) {
     llvm::sys::ScopedWriter WriterLock(ErrorMessageMutex);
     if (!ErrorMessage)
       ErrorMessage = Message.str();
   }
 
-  /// The PlatformExecutor that supports the operations of this stream.
-  PlatformExecutor *PExecutor;
+  /// The PlatformDevice that supports the operations of this stream.
+  PlatformDevice *PDevice;
 
   /// The platform-specific stream handle for this instance.
   std::unique_ptr<PlatformStreamHandle> ThePlatformStream;
 
   /// Mutex that guards the error state flags.
   ///
   /// Mutable so that it can be obtained via const reader lock.
   mutable llvm::sys::RWMutex ErrorMessageMutex;

parallel-libs/trunk/streamexecutor/lib/CMakeLists.txt

 add_library(
     utils
     OBJECT
     Utils/Error.cpp)
 
 add_library(
     streamexecutor
     $<TARGET_OBJECTS:utils>
-    Executor.cpp
+    Device.cpp
     Kernel.cpp
     KernelSpec.cpp
     PackedKernelArgumentArray.cpp
     PlatformInterfaces.cpp
     Stream.cpp)
 target_link_libraries(streamexecutor ${llvm_libs})
 
 if(STREAM_EXECUTOR_UNIT_TESTS)
     add_subdirectory(unittests)
 endif()

parallel-libs/trunk/streamexecutor/lib/Device.cpp

+//===-- Device.cpp - Device implementation --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Implementation of Device class internals.
+///
+//===----------------------------------------------------------------------===//
+
+#include "streamexecutor/Device.h"
+
+#include <cassert>
+
+#include "streamexecutor/PlatformInterfaces.h"
+#include "streamexecutor/Stream.h"
+
+#include "llvm/ADT/STLExtras.h"
+
+namespace streamexecutor {
+
+Device::Device(PlatformDevice *PDevice) : PDevice(PDevice) {}
+
+Device::~Device() = default;
+
+Expected<std::unique_ptr<Stream>> Device::createStream() {
+  Expected<std::unique_ptr<PlatformStreamHandle>> MaybePlatformStream =
+      PDevice->createStream();
+  if (!MaybePlatformStream) {
+    return MaybePlatformStream.takeError();
+  }
+  assert((*MaybePlatformStream)->getDevice() == PDevice &&
+         "an executor created a stream with a different stored executor");
+  return llvm::make_unique<Stream>(std::move(*MaybePlatformStream));
+}
+
+} // namespace streamexecutor

parallel-libs/trunk/streamexecutor/lib/Executor.cpp

-//===-- Executor.cpp - Executor implementation ----------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// Implementation of Executor class internals.
-///
-//===----------------------------------------------------------------------===//
-
-#include "streamexecutor/Executor.h"
-
-#include <cassert>
-
-#include "streamexecutor/PlatformInterfaces.h"
-#include "streamexecutor/Stream.h"
-
-#include "llvm/ADT/STLExtras.h"
-
-namespace streamexecutor {
-
-Executor::Executor(PlatformExecutor *PExecutor) : PExecutor(PExecutor) {}
-
-Executor::~Executor() = default;
-
-Expected<std::unique_ptr<Stream>> Executor::createStream() {
-  Expected<std::unique_ptr<PlatformStreamHandle>> MaybePlatformStream =
-      PExecutor->createStream();
-  if (!MaybePlatformStream) {
-    return MaybePlatformStream.takeError();
-  }
-  assert((*MaybePlatformStream)->getExecutor() == PExecutor &&
-         "an executor created a stream with a different stored executor");
-  return llvm::make_unique<Stream>(std::move(*MaybePlatformStream));
-}
-
-} // namespace streamexecutor

parallel-libs/trunk/streamexecutor/lib/Kernel.cpp

 //===-- Kernel.cpp - General kernel implementation ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains the implementation details for kernel types.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "streamexecutor/Kernel.h"
-#include "streamexecutor/Executor.h"
+#include "streamexecutor/Device.h"
 #include "streamexecutor/PlatformInterfaces.h"
 
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 
 namespace streamexecutor {
 
-KernelBase::KernelBase(Executor *ParentExecutor, const std::string &Name,
+KernelBase::KernelBase(Device *Dev, const std::string &Name,
                        const std::string &DemangledName,
                        std::unique_ptr<KernelInterface> Implementation)
-    : ParentExecutor(ParentExecutor), Name(Name), DemangledName(DemangledName),
+    : TheDevice(Dev), Name(Name), DemangledName(DemangledName),
       Implementation(std::move(Implementation)) {}
 
 KernelBase::~KernelBase() = default;
 
-Expected<KernelBase> KernelBase::create(Executor *ParentExecutor,
+Expected<KernelBase> KernelBase::create(Device *Dev,
                                         const MultiKernelLoaderSpec &Spec) {
-  auto MaybeImplementation = ParentExecutor->getKernelImplementation(Spec);
+  auto MaybeImplementation = Dev->getKernelImplementation(Spec);
   if (!MaybeImplementation) {
     return MaybeImplementation.takeError();
   }
   std::string Name = Spec.getKernelName();
   std::string DemangledName =
       llvm::symbolize::LLVMSymbolizer::DemangleName(Name, nullptr);
-  KernelBase Instance(ParentExecutor, Name, DemangledName,
+  KernelBase Instance(Dev, Name, DemangledName,
                       std::move(*MaybeImplementation));
   return std::move(Instance);
 }
 
 } // namespace streamexecutor

parallel-libs/trunk/streamexecutor/lib/PlatformInterfaces.cpp

 //===----------------------------------------------------------------------===//
 
 #include "streamexecutor/PlatformInterfaces.h"
 
 namespace streamexecutor {
 
 PlatformStreamHandle::~PlatformStreamHandle() = default;
 
-PlatformExecutor::~PlatformExecutor() = default;
+PlatformDevice::~PlatformDevice() = default;
 
 } // namespace streamexecutor

parallel-libs/trunk/streamexecutor/lib/Stream.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "streamexecutor/Stream.h"
 
 namespace streamexecutor {
 
 Stream::Stream(std::unique_ptr<PlatformStreamHandle> PStream)
-    : PExecutor(PStream->getExecutor()), ThePlatformStream(std::move(PStream)) {
-}
+    : PDevice(PStream->getDevice()), ThePlatformStream(std::move(PStream)) {}
 
 Stream::~Stream() = default;
 
 } // namespace streamexecutor

parallel-libs/trunk/streamexecutor/lib/unittests/CMakeLists.txt

 add_executable(
-    executor_test
-    ExecutorTest.cpp)
+    device_test
+    DeviceTest.cpp)
 target_link_libraries(
-    executor_test
+    device_test
     streamexecutor
     ${GTEST_BOTH_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT})
-add_test(ExecutorTest executor_test)
+add_test(DeviceTest device_test)
 
 add_executable(
     kernel_test
     KernelTest.cpp)
 target_link_libraries(
     kernel_test
     streamexecutor
     ${GTEST_BOTH_LIBRARIES}

parallel-libs/trunk/streamexecutor/lib/unittests/DeviceTest.cpp

+//===-- DeviceTest.cpp - Tests for Device ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the unit tests for Device code.
+///
+//===----------------------------------------------------------------------===//
+
+#include <cstdlib>
+#include <cstring>
+
+#include "streamexecutor/Device.h"
+#include "streamexecutor/PlatformInterfaces.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+namespace se = ::streamexecutor;
+
+class MockPlatformDevice : public se::PlatformDevice {
+public:
+  ~MockPlatformDevice() override {}
+
+  std::string getName() const override { return "MockPlatformDevice"; }
+
+  se::Expected<std::unique_ptr<se::PlatformStreamHandle>>
+  createStream() override {
+    return se::make_error("not implemented");
+  }
+
+  se::Expected<se::GlobalDeviceMemoryBase>
+  allocateDeviceMemory(size_t ByteCount) override {
+    return se::GlobalDeviceMemoryBase(std::malloc(ByteCount));
+  }
+
+  se::Error freeDeviceMemory(se::GlobalDeviceMemoryBase Memory) override {
+    std::free(const_cast<void *>(Memory.getHandle()));
+    return se::Error::success();
+  }
+
+  se::Expected<void *> allocateHostMemory(size_t ByteCount) override {
+    return std::malloc(ByteCount);
+  }
+
+  se::Error freeHostMemory(void *Memory) override {
+    std::free(Memory);
+    return se::Error::success();
+  }
+
+  se::Error registerHostMemory(void *, size_t) override {
+    return se::Error::success();
+  }
+
+  se::Error unregisterHostMemory(void *) override {
+    return se::Error::success();
+  }
+
+  se::Error synchronousCopyD2H(const se::GlobalDeviceMemoryBase &DeviceSrc,
+                               size_t SrcByteOffset, void *HostDst,
+                               size_t DstByteOffset,
+                               size_t ByteCount) override {
+    std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
+                static_cast<const char *>(DeviceSrc.getHandle()) +
+                    SrcByteOffset,
+                ByteCount);
+    return se::Error::success();
+  }
+
+  se::Error synchronousCopyH2D(const void *HostSrc, size_t SrcByteOffset,
+                               se::GlobalDeviceMemoryBase DeviceDst,
+                               size_t DstByteOffset,
+                               size_t ByteCount) override {
+    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceDst.getHandle())) +
+                    DstByteOffset,
+                static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
+    return se::Error::success();
+  }
+
+  se::Error synchronousCopyD2D(se::GlobalDeviceMemoryBase DeviceDst,
+                               size_t DstByteOffset,
+                               const se::GlobalDeviceMemoryBase &DeviceSrc,
+                               size_t SrcByteOffset,
+                               size_t ByteCount) override {
+    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceDst.getHandle())) +
+                    DstByteOffset,
+                static_cast<const char *>(DeviceSrc.getHandle()) +
+                    SrcByteOffset,
+                ByteCount);
+    return se::Error::success();
+  }
+};
+
+/// 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},
+        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) {}
+
+  // Device memory is backed by host arrays.
+  int HostA5[5];
+  int HostB5[5];
+  int HostA7[7];
+  int HostB7[7];
+  se::GlobalDeviceMemory<int> DeviceA5;
+  se::GlobalDeviceMemory<int> DeviceB5;
+  se::GlobalDeviceMemory<int> DeviceA7;
+  se::GlobalDeviceMemory<int> DeviceB7;
+
+  // Host memory to be used as actual host memory.
+  int Host5[5];
+  int Host7[7];
+
+  MockPlatformDevice PDevice;
+  se::Device Device;
+};
+
+#define EXPECT_NO_ERROR(E) EXPECT_FALSE(static_cast<bool>(E))
+#define EXPECT_ERROR(E)                                                        \
+  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, AllocateAndFreeDeviceMemory) {
+  se::Expected<se::GlobalDeviceMemory<int>> MaybeMemory =
+      Device.allocateDeviceMemory<int>(10);
+  EXPECT_TRUE(static_cast<bool>(MaybeMemory));
+  EXPECT_NO_ERROR(Device.freeDeviceMemory(*MaybeMemory));
+}
+
+TEST_F(DeviceTest, AllocateAndFreeHostMemory) {
+  se::Expected<int *> MaybeMemory = Device.allocateHostMemory<int>(10);
+  EXPECT_TRUE(static_cast<bool>(MaybeMemory));
+  EXPECT_NO_ERROR(Device.freeHostMemory(*MaybeMemory));
+}
+
+TEST_F(DeviceTest, RegisterAndUnregisterHostMemory) {
+  std::vector<int> Data(10);
+  EXPECT_NO_ERROR(Device.registerHostMemory(Data.data(), 10));
+  EXPECT_NO_ERROR(Device.unregisterHostMemory(Data.data()));
+}
+
+// D2H tests
+
+TEST_F(DeviceTest, SyncCopyD2HToMutableArrayRefByCount) {
+  EXPECT_NO_ERROR(
+      Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 5));
+  for (int I = 0; I < 5; ++I) {
+    EXPECT_EQ(HostA5[I], Host5[I]);
+  }
+
+  EXPECT_NO_ERROR(
+      Device.synchronousCopyD2H(DeviceB5, MutableArrayRef<int>(Host5), 2));
+  for (int I = 0; I < 2; ++I) {
+    EXPECT_EQ(HostB5[I], Host5[I]);
+  }
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5), 7));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7), 7));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 7));
+}
+
+TEST_F(DeviceTest, SyncCopyD2HToMutableArrayRef) {
+  EXPECT_NO_ERROR(
+      Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5)));
+  for (int I = 0; I < 5; ++I) {
+    EXPECT_EQ(HostA5[I], Host5[I]);
+  }
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5)));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7)));
+}
+
+TEST_F(DeviceTest, SyncCopyD2HToPointer) {
+  EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA5, Host5, 5));
+  for (int I = 0; I < 5; ++I) {
+    EXPECT_EQ(HostA5[I], Host5[I]);
+  }
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5, Host7, 7));
+}
+
+TEST_F(DeviceTest, SyncCopyD2HSliceToMutableArrayRefByCount) {
+  EXPECT_NO_ERROR(Device.synchronousCopyD2H(
+      DeviceA5.asSlice().drop_front(1), MutableArrayRef<int>(Host5 + 1, 4), 4));
+  for (int I = 1; I < 5; ++I) {
+    EXPECT_EQ(HostA5[I], Host5[I]);
+  }
+
+  EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceB5.asSlice().drop_back(1),
+                                            MutableArrayRef<int>(Host5), 2));
+  for (int I = 0; I < 2; ++I) {
+    EXPECT_EQ(HostB5[I], Host5[I]);
+  }
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice(),
+                                         MutableArrayRef<int>(Host5), 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
+                                         MutableArrayRef<int>(Host7), 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
+                                         MutableArrayRef<int>(Host5), 7));
+}
+
+TEST_F(DeviceTest, SyncCopyD2HSliceToMutableArrayRef) {
+  EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice().slice(1, 5),
+                                            MutableArrayRef<int>(Host5)));
+  for (int I = 0; I < 5; ++I) {
+    EXPECT_EQ(HostA7[I + 1], Host5[I]);
+  }
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice().drop_back(1),
+                                         MutableArrayRef<int>(Host5)));
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
+                                         MutableArrayRef<int>(Host7)));
+}
+
+TEST_F(DeviceTest, SyncCopyD2HSliceToPointer) {
+  EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice().drop_front(1),
+                                            Host5 + 1, 4));
+  for (int I = 1; I < 5; ++I) {
+    EXPECT_EQ(HostA5[I], Host5[I]);
+  }
+
+  EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(), Host7, 7));
+}
+
+// H2D tests
+
+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_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2));
+  for (int I = 0; I < 2; ++I) {
+    EXPECT_EQ(HostB5[I], Host5[I]);
+  }
+
+  EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7));
+
+  EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7, 7));
+
+  EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 7));
+}
+
+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_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7));
+
+  EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5));
+}
+
+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_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5, 7));
+}
+
+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_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_ERROR(
+      Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice(), 7));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice(), 7));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice(), 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_ERROR(
+      Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice()));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice()));
+}
+
+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_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7));
+}
+
+// D2D tests
+
+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_NO_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB7, 2));
+  for (int I = 0; I < 2; ++I) {
+    EXPECT_EQ(HostA7[I], HostB7[I]);
+  }
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5, 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7, 7));
+}
+
+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_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7));
+}
+
+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_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_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5, 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5, 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7, 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_ERROR(
+      Device.synchronousCopyD2D(DeviceA7.asSlice().drop_front(1), DeviceB5));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7));
+}
+
+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_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_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5.asSlice(), 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice(), 7));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice(), 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_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice()));
+
+  EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice()));
+}
+
+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_NO_ERROR(
+      Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2));
+  for (int I = 0; I < 2; ++I) {
+    EXPECT_EQ(HostA7[I], HostB7[I]);
+  }
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 7));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice(), 7));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice(), 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_ERROR(
+      Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice()));
+
+  EXPECT_ERROR(
+      Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice()));
+}
+
+} // namespace

parallel-libs/trunk/streamexecutor/lib/unittests/ExecutorTest.cpp

-//===-- ExecutorTest.cpp - Tests for Executor -----------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file contains the unit tests for Executor code.
-///
-//===----------------------------------------------------------------------===//
-
-#include <cstdlib>
-#include <cstring>
-
-#include "streamexecutor/Executor.h"
-#include "streamexecutor/PlatformInterfaces.h"
-
-#include "gtest/gtest.h"
-
-namespace {
-
-namespace se = ::streamexecutor;
-
-class MockPlatformExecutor : public se::PlatformExecutor {
-public:
-  ~MockPlatformExecutor() override {}
-
-  std::string getName() const override { return "MockPlatformExecutor"; }
-
-  se::Expected<std::unique_ptr<se::PlatformStreamHandle>>
-  createStream() override {
-    return se::make_error("not implemented");
-  }
-
-  se::Expected<se::GlobalDeviceMemoryBase>
-  allocateDeviceMemory(size_t ByteCount) override {
-    return se::GlobalDeviceMemoryBase(std::malloc(ByteCount));
-  }
-
-  se::Error freeDeviceMemory(se::GlobalDeviceMemoryBase Memory) override {
-    std::free(const_cast<void *>(Memory.getHandle()));
-    return se::Error::success();
-  }
-
-  se::Expected<void *> allocateHostMemory(size_t ByteCount) override {
-    return std::malloc(ByteCount);
-  }
-
-  se::Error freeHostMemory(void *Memory) override {
-    std::free(Memory);
-    return se::Error::success();
-  }
-
-  se::Error registerHostMemory(void *, size_t) override {
-    return se::Error::success();
-  }
-
-  se::Error unregisterHostMemory(void *) override {
-    return se::Error::success();
-  }
-
-  se::Error synchronousCopyD2H(const se::GlobalDeviceMemoryBase &DeviceSrc,
-                               size_t SrcByteOffset, void *HostDst,
-                               size_t DstByteOffset,
-                               size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
-                static_cast<const char *>(DeviceSrc.getHandle()) +
-                    SrcByteOffset,
-                ByteCount);
-    return se::Error::success();
-  }
-
-  se::Error synchronousCopyH2D(const void *HostSrc, size_t SrcByteOffset,
-                               se::GlobalDeviceMemoryBase DeviceDst,
-                               size_t DstByteOffset,
-                               size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceDst.getHandle())) +
-                    DstByteOffset,
-                static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
-    return se::Error::success();
-  }
-
-  se::Error synchronousCopyD2D(se::GlobalDeviceMemoryBase DeviceDst,
-                               size_t DstByteOffset,
-                               const se::GlobalDeviceMemoryBase &DeviceSrc,
-                               size_t SrcByteOffset,
-                               size_t ByteCount) override {
-    std::memcpy(static_cast<char *>(const_cast<void *>(DeviceDst.getHandle())) +
-                    DstByteOffset,
-                static_cast<const char *>(DeviceSrc.getHandle()) +
-                    SrcByteOffset,
-                ByteCount);
-    return se::Error::success();
-  }
-};
-
-/// Test fixture to hold objects used by tests.
-class ExecutorTest : public ::testing::Test {
-public:
-  ExecutorTest()
-      : 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},
-        Executor(&PExecutor) {}
-
-  // Device memory is backed by host arrays.
-  int HostA5[5];
-  int HostB5[5];
-  int HostA7[7];
-  int HostB7[7];
-  se::GlobalDeviceMemory<int> DeviceA5;
-  se::GlobalDeviceMemory<int> DeviceB5;
-  se::GlobalDeviceMemory<int> DeviceA7;
-  se::GlobalDeviceMemory<int> DeviceB7;
-
-  // Host memory to be used as actual host memory.
-  int Host5[5];
-  int Host7[7];
-
-  MockPlatformExecutor PExecutor;
-  se::Executor Executor;
-};
-
-#define EXPECT_NO_ERROR(E) EXPECT_FALSE(static_cast<bool>(E))
-#define EXPECT_ERROR(E)                                                        \
-  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(ExecutorTest, AllocateAndFreeDeviceMemory) {
-  se::Expected<se::GlobalDeviceMemory<int>> MaybeMemory =
-      Executor.allocateDeviceMemory<int>(10);
-  EXPECT_TRUE(static_cast<bool>(MaybeMemory));
-  EXPECT_NO_ERROR(Executor.freeDeviceMemory(*MaybeMemory));
-}
-
-TEST_F(ExecutorTest, AllocateAndFreeHostMemory) {
-  se::Expected<int *> MaybeMemory = Executor.allocateHostMemory<int>(10);
-  EXPECT_TRUE(static_cast<bool>(MaybeMemory));
-  EXPECT_NO_ERROR(Executor.freeHostMemory(*MaybeMemory));
-}
-
-TEST_F(ExecutorTest, RegisterAndUnregisterHostMemory) {
-  std::vector<int> Data(10);
-  EXPECT_NO_ERROR(Executor.registerHostMemory(Data.data(), 10));
-  EXPECT_NO_ERROR(Executor.unregisterHostMemory(Data.data()));
-}
-
-// D2H tests
-
-TEST_F(ExecutorTest, SyncCopyD2HToMutableArrayRefByCount) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2H(DeviceB5, MutableArrayRef<int>(Host5), 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostB5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5), 7));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7), 7));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2HToMutableArrayRef) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5)));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5)));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7)));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2HToPointer) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2H(DeviceA5, Host5, 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA5, Host7, 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2HSliceToMutableArrayRefByCount) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2H(
-      DeviceA5.asSlice().drop_front(1), MutableArrayRef<int>(Host5 + 1, 4), 4));
-  for (int I = 1; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2H(DeviceB5.asSlice().drop_back(1),
-                                              MutableArrayRef<int>(Host5), 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostB5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA7.asSlice(),
-                                           MutableArrayRef<int>(Host5), 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA5.asSlice(),
-                                           MutableArrayRef<int>(Host7), 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA5.asSlice(),
-                                           MutableArrayRef<int>(Host5), 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2HSliceToMutableArrayRef) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2H(DeviceA7.asSlice().slice(1, 5),
-                                              MutableArrayRef<int>(Host5)));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA7[I + 1], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA7.asSlice().drop_back(1),
-                                           MutableArrayRef<int>(Host5)));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA5.asSlice(),
-                                           MutableArrayRef<int>(Host7)));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2HSliceToPointer) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2H(DeviceA5.asSlice().drop_front(1),
-                                              Host5 + 1, 4));
-  for (int I = 1; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2H(DeviceA5.asSlice(), Host7, 7));
-}
-
-// H2D tests
-
-TEST_F(ExecutorTest, SyncCopyH2DToArrayRefByCount) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostB5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7, 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyH2DToArrayRef) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7));
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5));
-}
-
-TEST_F(ExecutorTest, SyncCopyH2DToPointer) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyH2D(Host5, DeviceA5, 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(Host7, DeviceA5, 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyH2DSliceToArrayRefByCount) {
-  EXPECT_NO_ERROR(Executor.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_NO_ERROR(Executor.synchronousCopyH2D(
-      ArrayRef<int>(Host5), DeviceB5.asSlice().drop_back(1), 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostB5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice(), 7));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice(), 7));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice(), 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyH2DSliceToArrayRef) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice()));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice()));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice()));
-}
-
-TEST_F(ExecutorTest, SyncCopyH2DSliceToPointer) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyH2D(Host5, DeviceA5.asSlice(), 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], Host5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7));
-}
-
-// D2D tests
-
-TEST_F(ExecutorTest, SyncCopyD2DByCount) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB5, 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
-  }
-
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(DeviceA7, DeviceB7, 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB5, 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA7, DeviceB5, 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB7, 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2D) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA7, DeviceB5));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB7));
-}
-
-TEST_F(ExecutorTest, SyncCopySliceD2DByCount) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(DeviceA5.asSlice().drop_front(1),
-                                              DeviceB5, 4));
-  for (int I = 0; I < 4; ++I) {
-    EXPECT_EQ(HostA5[I + 1], HostB5[I]);
-  }
-
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(DeviceA7.asSlice().drop_back(1),
-                                              DeviceB7, 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5, 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5, 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7, 7));
-}
-
-TEST_F(ExecutorTest, SyncCopySliceD2D) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA7[I], HostB5[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA7.asSlice().drop_front(1), DeviceB5));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2DSliceByCount) {
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(
-      DeviceA5, DeviceB7.asSlice().drop_front(2), 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB7[I + 2]);
-  }
-
-  EXPECT_NO_ERROR(Executor.synchronousCopyD2D(
-      DeviceA7, DeviceB7.asSlice().drop_back(3), 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB5.asSlice(), 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice(), 7));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice(), 7));
-}
-
-TEST_F(ExecutorTest, SyncCopyD2DSlice) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_back(2)));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB7[I]);
-  }
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice()));
-
-  EXPECT_ERROR(Executor.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice()));
-}
-
-TEST_F(ExecutorTest, SyncCopySliceD2DSliceByCount) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 5));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
-  }
-
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2));
-  for (int I = 0; I < 2; ++I) {
-    EXPECT_EQ(HostA7[I], HostB7[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 7));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice(), 7));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice(), 7));
-}
-
-TEST_F(ExecutorTest, SyncCopySliceD2DSlice) {
-  EXPECT_NO_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice()));
-  for (int I = 0; I < 5; ++I) {
-    EXPECT_EQ(HostA5[I], HostB5[I]);
-  }
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice()));
-
-  EXPECT_ERROR(
-      Executor.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice()));
-}
-
-} // namespace

parallel-libs/trunk/streamexecutor/lib/unittests/KernelTest.cpp

 //===-- KernelTest.cpp - Tests for Kernel objects -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains the unit tests for the code in Kernel.
 ///
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 
-#include "streamexecutor/Executor.h"
+#include "streamexecutor/Device.h"
 #include "streamexecutor/Kernel.h"
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/PlatformInterfaces.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
-// An Executor that returns a dummy KernelInterface.
+// A Device that returns a dummy KernelInterface.
 //
 // During construction it creates a unique_ptr to a dummy KernelInterface and it
 // also stores a separate copy of the raw pointer that is stored by that
 // unique_ptr.
 //
 // The expectation is that the code being tested will call the
 // getKernelImplementation method and will thereby take ownership of the
 // unique_ptr, but the copy of the raw pointer will stay behind in this mock
 // object. The raw pointer copy can then be used to identify the unique_ptr in
 // its new location (by comparing the raw pointer with unique_ptr::get), to
 // verify that the unique_ptr ended up where it was supposed to be.
-class MockExecutor : public se::Executor {
+class MockDevice : public se::Device {
 public:
-  MockExecutor()
-      : se::Executor(nullptr), Unique(llvm::make_unique<se::KernelInterface>()),
+  MockDevice()
+      : se::Device(nullptr), Unique(llvm::make_unique<se::KernelInterface>()),
         Raw(Unique.get()) {}
 
   // Moves the unique pointer into the returned se::Expected instance.
   //
   // Asserts that it is not called again after the unique pointer has been moved
   // out.
   se::Expected<std::unique_ptr<se::KernelInterface>>
   getKernelImplementation(const se::MultiKernelLoaderSpec &) override {
-    assert(Unique && "MockExecutor getKernelImplementation should not be "
+    assert(Unique && "MockDevice getKernelImplementation should not be "
                      "called more than once");
     return std::move(Unique);
   }
 
   // Gets the copy of the raw pointer from the original unique pointer.
   const se::KernelInterface *getRaw() const { return Raw; }
 
 private:

 typedef ::testing::Types<se::KernelBase, se::TypedKernel<>,
                          se::TypedKernel<int>>
     GetImplementationTypes;
 
 TYPED_TEST_CASE(GetImplementationTest, GetImplementationTypes);
 
 // Tests that the kernel create functions properly fetch the implementation
 // pointers for the kernel objects they construct from the passed-in
-// Executor objects.
+// Device objects.
 TYPED_TEST(GetImplementationTest, SetImplementationDuringCreate) {
   se::MultiKernelLoaderSpec Spec;
-  MockExecutor MockExecutor;
+  MockDevice Dev;
 
-  auto MaybeKernel = TypeParam::create(&MockExecutor, Spec);
+  auto MaybeKernel = TypeParam::create(&Dev, Spec);
   EXPECT_TRUE(static_cast<bool>(MaybeKernel));
   se::KernelInterface *Implementation = MaybeKernel->getImplementation();
-  EXPECT_EQ(MockExecutor.getRaw(), Implementation);
+  EXPECT_EQ(Dev.getRaw(), Implementation);
 }
 
 } // namespace

parallel-libs/trunk/streamexecutor/lib/unittests/StreamTest.cpp

 //===-- StreamTest.cpp - Tests for Stream ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains the unit tests for Stream code.
 ///
 //===----------------------------------------------------------------------===//
 
 #include <cstring>
 
-#include "streamexecutor/Executor.h"
+#include "streamexecutor/Device.h"
 #include "streamexecutor/Kernel.h"
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/PlatformInterfaces.h"
 #include "streamexecutor/Stream.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
-/// Mock PlatformExecutor that performs asynchronous memcpy operations by
+/// Mock PlatformDevice that performs asynchronous memcpy operations by
 /// ignoring the stream argument and calling std::memcpy on device memory
 /// handles.
-class MockPlatformExecutor : public se::PlatformExecutor {
+class MockPlatformDevice : public se::PlatformDevice {
 public:
-  ~MockPlatformExecutor() override {}
+  ~MockPlatformDevice() override {}
 
-  std::string getName() const override { return "MockPlatformExecutor"; }
+  std::string getName() const override { return "MockPlatformDevice"; }
 
   se::Expected<std::unique_ptr<se::PlatformStreamHandle>>
   createStream() override {
     return nullptr;
   }
 
   se::Error copyD2H(se::PlatformStreamHandle *S,
                     const se::GlobalDeviceMemoryBase &DeviceSrc,
public:
   StreamTest()
       : 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},
-        Stream(llvm::make_unique<se::PlatformStreamHandle>(&PExecutor)) {}
+        Stream(llvm::make_unique<se::PlatformStreamHandle>(&PDevice)) {}
 
 protected:
   // Device memory is backed by host arrays.
   int HostA5[5];
   int HostB5[5];
   int HostA7[7];
   int HostB7[7];
   se::GlobalDeviceMemory<int> DeviceA5;
   se::GlobalDeviceMemory<int> DeviceB5;
   se::GlobalDeviceMemory<int> DeviceA7;
   se::GlobalDeviceMemory<int> DeviceB7;
 
   // Host memory to be used as actual host memory.
   int Host5[5];
   int Host7[7];
 
-  MockPlatformExecutor PExecutor;
+  MockPlatformDevice PDevice;
   se::Stream Stream;
 };
 
 using llvm::ArrayRef;
 using llvm::MutableArrayRef;
 
 // D2H tests