[StreamExecutor] Rename StreamExecutor to Executor

Summary: No functional changes just renaming this class for better readability.

Reviewers: jlebar

Subscribers: jprice, parallel_libs-commits

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

llvm-svn: 278833

parallel-libs/streamexecutor/include/streamexecutor/StreamExecutor.h → parallel-libs/streamexecutor/include/streamexecutor/Executor.h

@@ -1,4 +1,4 @@
-//===-- StreamExecutor.h - The StreamExecutor class -------------*- C++ -*-===//
+//===-- Executor.h - The Executor class -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,27 +8,26 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// The StreamExecutor class which represents a single device of a specific
-/// platform.
+/// The Executor class which represents a single device of a specific platform.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef STREAMEXECUTOR_STREAMEXECUTOR_H
-#define STREAMEXECUTOR_STREAMEXECUTOR_H
+#ifndef STREAMEXECUTOR_EXECUTOR_H
+#define STREAMEXECUTOR_EXECUTOR_H
 
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/Utils/Error.h"
 
 namespace streamexecutor {
 
 class KernelInterface;
-class PlatformStreamExecutor;
+class PlatformExecutor;
 class Stream;
 
-class StreamExecutor {
+class Executor {
 public:
-  explicit StreamExecutor(PlatformStreamExecutor *PlatformExecutor);
-  virtual ~StreamExecutor();
+  explicit Executor(PlatformExecutor *PExecutor);
+  virtual ~Executor();
 
   /// Gets the kernel implementation for the underlying platform.
   virtual Expected<std::unique_ptr<KernelInterface>>
@@ -40,9 +39,9 @@ class StreamExecutor {
   Expected<std::unique_ptr<Stream>> createStream();
 
 private:
-  PlatformStreamExecutor *PlatformExecutor;
+  PlatformExecutor *PExecutor;
 };
 
 } // namespace streamexecutor
 
-#endif // STREAMEXECUTOR_STREAMEXECUTOR_H
+#endif // STREAMEXECUTOR_EXECUTOR_H

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

@@ -84,8 +84,8 @@
 
 namespace streamexecutor {
 
+class Executor;
 class KernelInterface;
-class StreamExecutor;
 
 /// The base class for device kernel functions.
 ///
@@ -100,13 +100,13 @@ class KernelBase {
   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; }
@@ -116,11 +116,11 @@ class KernelBase {
   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;
@@ -136,7 +136,7 @@ template <typename... ParameterTs> class TypedKernel : public KernelBase {
   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) {

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

@@ -31,7 +31,7 @@
 
 namespace streamexecutor {
 
-class PlatformStreamExecutor;
+class PlatformExecutor;
 
 /// Methods supported by device kernel function objects on all platforms.
 class KernelInterface {
@@ -41,27 +41,27 @@ class KernelInterface {
 /// 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;
 

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

@@ -12,17 +12,17 @@
 /// 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.
 ///
@@ -94,17 +94,17 @@ class Stream {
                      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) {
@@ -116,9 +116,8 @@ class Stream {
       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;
   }
 
@@ -134,8 +133,8 @@ class Stream {
   /// 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) {
@@ -147,9 +146,8 @@ class Stream {
                ", 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;
   }
 
@@ -175,9 +173,8 @@ class Stream {
                ", 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;
   }
 
@@ -194,7 +191,7 @@ class Stream {
   ///
   /// 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;
@@ -221,8 +218,8 @@ class Stream {
       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;

parallel-libs/streamexecutor/lib/CMakeLists.txt

@@ -6,12 +6,12 @@ add_library(
 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)

parallel-libs/streamexecutor/lib/StreamExecutor.cpp → parallel-libs/streamexecutor/lib/Executor.cpp

@@ -1,4 +1,4 @@
-//===-- StreamExecutor.cpp - StreamExecutor implementation ----------------===//
+//===-- Executor.cpp - Executor implementation ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,11 +8,11 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// Implementation of StreamExecutor class internals.
+/// Implementation of Executor class internals.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "streamexecutor/StreamExecutor.h"
+#include "streamexecutor/Executor.h"
 
 #include <cassert>
 
@@ -23,18 +23,17 @@
 
 namespace streamexecutor {
 
-StreamExecutor::StreamExecutor(PlatformStreamExecutor *PlatformExecutor)
-    : PlatformExecutor(PlatformExecutor) {}
+Executor::Executor(PlatformExecutor *PExecutor) : PExecutor(PExecutor) {}
 
-StreamExecutor::~StreamExecutor() = default;
+Executor::~Executor() = default;
 
-Expected<std::unique_ptr<Stream>> StreamExecutor::createStream() {
+Expected<std::unique_ptr<Stream>> Executor::createStream() {
   Expected<std::unique_ptr<PlatformStreamHandle>> MaybePlatformStream =
-      PlatformExecutor->createStream();
+      PExecutor->createStream();
   if (!MaybePlatformStream) {
     return MaybePlatformStream.takeError();
   }
-  assert((*MaybePlatformStream)->getExecutor() == PlatformExecutor &&
+  assert((*MaybePlatformStream)->getExecutor() == PExecutor &&
          "an executor created a stream with a different stored executor");
   return llvm::make_unique<Stream>(std::move(*MaybePlatformStream));
 }

parallel-libs/streamexecutor/lib/Kernel.cpp

@@ -13,22 +13,22 @@
 //===----------------------------------------------------------------------===//
 
 #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) {

parallel-libs/streamexecutor/lib/PlatformInterfaces.cpp

@@ -18,6 +18,6 @@ namespace streamexecutor {
 
 PlatformStreamHandle::~PlatformStreamHandle() = default;
 
-PlatformStreamExecutor::~PlatformStreamExecutor() = default;
+PlatformExecutor::~PlatformExecutor() = default;
 
 } // namespace streamexecutor

parallel-libs/streamexecutor/lib/Stream.cpp

@@ -17,8 +17,8 @@
 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;