[StreamExecutor] Rename StreamExecutor to Executor

[jhen]

Summary

No functional changes just renaming this class for better readability.

[jlebar]

I like it.

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/Utils/Error.h"
+
+namespace streamexecutor {
+
+class KernelInterface;
+class PlatformExecutor;
+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();
+
+private:
+  PlatformExecutor *PExecutor;
+};
+
+} // namespace streamexecutor
+
+#endif // STREAMEXECUTOR_EXECUTOR_H

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

 
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/Utils/Error.h"
 
 #include <memory>
 
 namespace streamexecutor {
 
+class Executor;
 class KernelInterface;
-class StreamExecutor;
 
 /// 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 a StreamExecutor and a MultiKernelLoaderSpec.
+  /// Creates a kernel object from an Executor and a MultiKernelLoaderSpec.
   ///
-  /// The StreamExecutor knows which platform it belongs to and the
+  /// The Executor 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(StreamExecutor *ParentExecutor,
+  static Expected<KernelBase> create(Executor *ParentExecutor,
                                      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(StreamExecutor *ParentExecutor, const std::string &Name,
+  KernelBase(Executor *ParentExecutor, const std::string &Name,
              const std::string &DemangledName,
              std::unique_ptr<KernelInterface> Implementation);
 
-  StreamExecutor *ParentExecutor;
+  Executor *ParentExecutor;
   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(StreamExecutor *ParentExecutor,
+  static Expected<TypedKernel> create(Executor *ParentExecutor,
                                       const MultiKernelLoaderSpec &Spec) {
     auto MaybeBase = KernelBase::create(ParentExecutor, Spec);
     if (!MaybeBase) {
       return MaybeBase.takeError();
     }
     TypedKernel Instance(std::move(*MaybeBase));
     return std::move(Instance);
   }

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 PlatformStreamExecutor;
+class PlatformExecutor;
 
 /// 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(PlatformStreamExecutor *Executor)
-      : Executor(Executor) {}
+  explicit PlatformStreamHandle(PlatformExecutor *PExecutor)
+      : PExecutor(PExecutor) {}
 
   virtual ~PlatformStreamHandle();
 
-  PlatformStreamExecutor *getExecutor() { return Executor; }
+  PlatformExecutor *getExecutor() { return PExecutor; }
 
 private:
-  PlatformStreamExecutor *Executor;
+  PlatformExecutor *PExecutor;
 };
 
 /// 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 StreamExecutor and Stream classes have the type-safe versions of
-/// the functions in this interface.
-class PlatformStreamExecutor {
+/// The public Executor and Stream classes have the type-safe versions of the
+/// functions in this interface.
+class PlatformExecutor {
 public:
-  virtual ~PlatformStreamExecutor();
+  virtual ~PlatformExecutor();
 
   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 StreamExecutor instance for a
-/// given device and then use that StreamExecutor to create a Stream instance.
+/// 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
-/// StreamExecutor that created it.
+/// Executor that created it.
 ///
 /// The various "then" methods of the Stream object, such as thenMemcpyH2D 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 StreamExecutor. This
+/// 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.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef STREAMEXECUTOR_STREAM_H
 #define STREAMEXECUTOR_STREAM_H
 
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(PlatformExecutor->launch(ThePlatformStream.get(), BlockSize,
-                                      GridSize, Kernel, ArgumentArray));
+    setError(PExecutor->launch(ThePlatformStream.get(), BlockSize, GridSize,
+                               Kernel, ArgumentArray));
     return *this;
   }
 
   /// Entrain onto the stream a memcpy of a given number of elements from a
   /// device source to a host destination.
   ///
   /// HostDst must be a pointer to host memory allocated by
-  /// StreamExecutor::allocateHostMemory or otherwise allocated and then
-  /// registered with StreamExecutor::registerHostMemory.
+  /// Executor::allocateHostMemory or otherwise allocated and then
+  /// registered with Executor::registerHostMemory.
   template <typename T>
   Stream &thenMemcpyD2H(const GlobalDeviceMemory<T> &DeviceSrc,
                         llvm::MutableArrayRef<T> HostDst, size_t ElementCount) {
     if (ElementCount > DeviceSrc.getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", from device memory array of size " +
                llvm::Twine(DeviceSrc.getElementCount()));
     else if (ElementCount > HostDst.size())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", to host array of size " + llvm::Twine(HostDst.size()));
     else
-      setError(PlatformExecutor->memcpyD2H(ThePlatformStream.get(), DeviceSrc,
-                                           HostDst.data(),
-                                           ElementCount * sizeof(T)));
+      setError(PExecutor->memcpyD2H(ThePlatformStream.get(), DeviceSrc,
+                                    HostDst.data(), ElementCount * sizeof(T)));
     return *this;
   }
 
   /// Same as thenMemcpyD2H above, but copies the entire source to the
   /// destination.
   template <typename T>
   Stream &thenMemcpyD2H(const GlobalDeviceMemory<T> &DeviceSrc,
                         llvm::MutableArrayRef<T> HostDst) {
     return thenMemcpyD2H(DeviceSrc, HostDst, DeviceSrc.getElementCount());
   }
 
   /// Entrain onto the stream a memcpy of a given number of elements from a host
   /// source to a device destination.
   ///
   /// HostSrc must be a pointer to host memory allocated by
-  /// StreamExecutor::allocateHostMemory or otherwise allocated and then
-  /// registered with StreamExecutor::registerHostMemory.
+  /// Executor::allocateHostMemory or otherwise allocated and then
+  /// registered with Executor::registerHostMemory.
   template <typename T>
   Stream &thenMemcpyH2D(llvm::ArrayRef<T> HostSrc,
                         GlobalDeviceMemory<T> *DeviceDst, size_t ElementCount) {
     if (ElementCount > HostSrc.size())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", from host array of size " + llvm::Twine(HostSrc.size()));
     else if (ElementCount > DeviceDst->getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", to device memory array of size " +
                llvm::Twine(DeviceDst->getElementCount()));
     else
-      setError(PlatformExecutor->memcpyH2D(ThePlatformStream.get(),
-                                           HostSrc.data(), DeviceDst,
-                                           ElementCount * sizeof(T)));
+      setError(PExecutor->memcpyH2D(ThePlatformStream.get(), HostSrc.data(),
+                                    DeviceDst, ElementCount * sizeof(T)));
     return *this;
   }
 
   /// Same as thenMemcpyH2D above, but copies the entire source to the
   /// destination.
   template <typename T>
   Stream &thenMemcpyH2D(llvm::ArrayRef<T> HostSrc,
                         GlobalDeviceMemory<T> *DeviceDst) {
if (ElementCount > DeviceSrc.getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", from device memory array of size " +
                llvm::Twine(DeviceSrc.getElementCount()));
     else if (ElementCount > DeviceDst->getElementCount())
       setError("copying too many elements, " + llvm::Twine(ElementCount) +
                ", to device memory array of size " +
                llvm::Twine(DeviceDst->getElementCount()));
     else
-      setError(PlatformExecutor->memcpyD2D(ThePlatformStream.get(), DeviceSrc,
-                                           DeviceDst,
-                                           ElementCount * sizeof(T)));
+      setError(PExecutor->memcpyD2D(ThePlatformStream.get(), DeviceSrc,
+                                    DeviceDst, ElementCount * sizeof(T)));
     return *this;
   }
 
   /// Same as thenMemcpyD2D above, but copies the entire source to the
   /// destination.
   template <typename T>
   Stream &thenMemcpyD2D(const GlobalDeviceMemory<T> &DeviceSrc,
                         GlobalDeviceMemory<T> *DeviceDst) {
     return thenMemcpyD2D(DeviceSrc, DeviceDst, DeviceSrc.getElementCount());
   }
 
   /// Blocks the host code, waiting for the operations entrained on the stream
   /// (enqueued up to this point in program execution) to complete.
   ///
   /// Returns true if there are no errors on the stream.
   bool blockHostUntilDone() {
-    Error E = PlatformExecutor->blockHostUntilDone(ThePlatformStream.get());
+    Error E = PExecutor->blockHostUntilDone(ThePlatformStream.get());
     bool returnValue = static_cast<bool>(E);
     setError(std::move(E));
     return returnValue;
   }
 
 private:
   /// Sets the error state from an Error object.
   ///
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 PlatformStreamExecutor that supports the operations of this stream.
-  PlatformStreamExecutor *PlatformExecutor;
+  /// The PlatformExecutor that supports the operations of this stream.
+  PlatformExecutor *PExecutor;
 
   /// 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/include/streamexecutor/StreamExecutor.h

-//===-- StreamExecutor.h - The StreamExecutor 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 StreamExecutor class which represents a single device of a specific
-/// platform.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef STREAMEXECUTOR_STREAMEXECUTOR_H
-#define STREAMEXECUTOR_STREAMEXECUTOR_H
-
-#include "streamexecutor/KernelSpec.h"
-#include "streamexecutor/Utils/Error.h"
-
-namespace streamexecutor {
-
-class KernelInterface;
-class PlatformStreamExecutor;
-class Stream;
-
-class StreamExecutor {
-public:
-  explicit StreamExecutor(PlatformStreamExecutor *PlatformExecutor);
-  virtual ~StreamExecutor();
-
-  /// 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();
-
-private:
-  PlatformStreamExecutor *PlatformExecutor;
-};
-
-} // namespace streamexecutor
-
-#endif // STREAMEXECUTOR_STREAMEXECUTOR_H

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

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

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/PlatformInterfaces.h"
-#include "streamexecutor/StreamExecutor.h"
 
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 
 namespace streamexecutor {
 
-KernelBase::KernelBase(StreamExecutor *ParentExecutor, const std::string &Name,
+KernelBase::KernelBase(Executor *ParentExecutor, const std::string &Name,
                        const std::string &DemangledName,
                        std::unique_ptr<KernelInterface> Implementation)
     : ParentExecutor(ParentExecutor), Name(Name), DemangledName(DemangledName),
       Implementation(std::move(Implementation)) {}
 
 KernelBase::~KernelBase() = default;
 
-Expected<KernelBase> KernelBase::create(StreamExecutor *ParentExecutor,
+Expected<KernelBase> KernelBase::create(Executor *ParentExecutor,
                                         const MultiKernelLoaderSpec &Spec) {
   auto MaybeImplementation = ParentExecutor->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,
                       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;
 
-PlatformStreamExecutor::~PlatformStreamExecutor() = default;
+PlatformExecutor::~PlatformExecutor() = default;
 
 } // namespace streamexecutor

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

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

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

-//===-- StreamExecutor.cpp - StreamExecutor 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 StreamExecutor class internals.
-///
-//===----------------------------------------------------------------------===//
-
-#include "streamexecutor/StreamExecutor.h"
-
-#include <cassert>
-
-#include "streamexecutor/PlatformInterfaces.h"
-#include "streamexecutor/Stream.h"
-
-#include "llvm/ADT/STLExtras.h"
-
-namespace streamexecutor {
-
-StreamExecutor::StreamExecutor(PlatformStreamExecutor *PlatformExecutor)
-    : PlatformExecutor(PlatformExecutor) {}
-
-StreamExecutor::~StreamExecutor() = default;
-
-Expected<std::unique_ptr<Stream>> StreamExecutor::createStream() {
-  Expected<std::unique_ptr<PlatformStreamHandle>> MaybePlatformStream =
-      PlatformExecutor->createStream();
-  if (!MaybePlatformStream) {
-    return MaybePlatformStream.takeError();
-  }
-  assert((*MaybePlatformStream)->getExecutor() == PlatformExecutor &&
-         "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/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/Kernel.h"
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/PlatformInterfaces.h"
-#include "streamexecutor/StreamExecutor.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
-// A StreamExecutor that returns a dummy KernelInterface.
+// An Executor 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 MockStreamExecutor : public se::StreamExecutor {
+class MockExecutor : public se::Executor {
 public:
-  MockStreamExecutor()
-      : se::StreamExecutor(nullptr),
-        Unique(llvm::make_unique<se::KernelInterface>()), Raw(Unique.get()) {}
+  MockExecutor()
+      : se::Executor(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 && "MockStreamExecutor getKernelImplementation should not be "
+    assert(Unique && "MockExecutor 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
-// StreamExecutor objects.
+// Executor objects.
 TYPED_TEST(GetImplementationTest, SetImplementationDuringCreate) {
   se::MultiKernelLoaderSpec Spec;
-  MockStreamExecutor MockExecutor;
+  MockExecutor MockExecutor;
 
   auto MaybeKernel = TypeParam::create(&MockExecutor, Spec);
   EXPECT_TRUE(static_cast<bool>(MaybeKernel));
   se::KernelInterface *Implementation = MaybeKernel->getImplementation();
   EXPECT_EQ(MockExecutor.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/Kernel.h"
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/PlatformInterfaces.h"
 #include "streamexecutor/Stream.h"
-#include "streamexecutor/StreamExecutor.h"
 
 #include "gtest/gtest.h"
 
 namespace {
 
 namespace se = ::streamexecutor;
 
-/// Mock PlatformStreamExecutor that performs asynchronous memcpy operations by
+/// Mock PlatformExecutor that performs asynchronous memcpy operations by
 /// ignoring the stream argument and calling std::memcpy on device memory
 /// handles.
-class MockPlatformStreamExecutor : public se::PlatformStreamExecutor {
+class MockPlatformExecutor : public se::PlatformExecutor {
 public:
-  ~MockPlatformStreamExecutor() override {}
+  ~MockPlatformExecutor() override {}
 
-  std::string getName() const override { return "MockPlatformStreamExecutor"; }
+  std::string getName() const override { return "MockPlatformExecutor"; }
 
   se::Expected<std::unique_ptr<se::PlatformStreamHandle>>
   createStream() override {
     return nullptr;
   }
 
   se::Error memcpyD2H(se::PlatformStreamHandle *,
                       const se::GlobalDeviceMemoryBase &DeviceSrc,

 };
 
 /// Test fixture to hold objects used by tests.
 class StreamTest : public ::testing::Test {
 public:
   StreamTest()
       : DeviceA(se::GlobalDeviceMemory<int>::makeFromElementCount(HostA, 10)),
         DeviceB(se::GlobalDeviceMemory<int>::makeFromElementCount(HostB, 10)),
-        Stream(llvm::make_unique<se::PlatformStreamHandle>(&PlatformExecutor)) {
-  }
+        Stream(llvm::make_unique<se::PlatformStreamHandle>(&PExecutor)) {}
 
 protected:
   // Device memory is backed by host arrays.
   int HostA[10];
   se::GlobalDeviceMemory<int> DeviceA;
   int HostB[10];
   se::GlobalDeviceMemory<int> DeviceB;
 
   // Host memory to be used as actual host memory.
   int Host[10];
 
-  MockPlatformStreamExecutor PlatformExecutor;
+  MockPlatformExecutor PExecutor;
   se::Stream Stream;
 };
 
 TEST_F(StreamTest, MemcpyCorrectSize) {
   Stream.thenMemcpyH2D(llvm::ArrayRef<int>(Host), &DeviceA);
   EXPECT_TRUE(Stream.isOK());
 
   Stream.thenMemcpyD2H(DeviceA, llvm::MutableArrayRef<int>(Host));