[SE] Make Kernel movable

[jhen]

Summary

Kernel is basically just a smart pointer to the underlying
implementation, so making it movable prevents having to store a
std::unique_ptr to it.

streamexecutor/examples/Example.cpp

 /// in documentation. Taking these examples from a real source file guarantees
 /// that the examples will always compile.
 ///
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
-#include <memory>
 #include <vector>
 
 #include "streamexecutor/StreamExecutor.h"
 
 /// [Example saxpy compiler-generated]
 // Code in this namespace is generated by the compiler (e.g. clang).
 //
 // The name of this namespace may depend on the compiler that generated it, so
int main() {
   se::Platform *Platform =
       getOrDie(se::PlatformManager::getPlatformByName("CUDA"));
   if (Platform->getDeviceCount() == 0) {
     return EXIT_FAILURE;
   }
   se::Device *Device = getOrDie(Platform->getDevice(0));
 
   // Load the kernel onto the device.
-  std::unique_ptr<cg::SaxpyKernel> Kernel =
+  cg::SaxpyKernel Kernel =
       getOrDie(Device->createKernel<cg::SaxpyKernel>(cg::SaxpyLoaderSpec));
 
   // Allocate memory on the device.
   se::GlobalDeviceMemory<float> X =
       getOrDie(Device->allocateDeviceMemory<float>(ArraySize));
   se::GlobalDeviceMemory<float> Y =
       getOrDie(Device->allocateDeviceMemory<float>(ArraySize));
 
   // Run operations on a stream.
   se::Stream Stream = getOrDie(Device->createStream());
   Stream.thenCopyH2D<float>(HostX, X)
       .thenCopyH2D<float>(HostY, Y)
-      .thenLaunch(ArraySize, 1, *Kernel, A, X, Y)
+      .thenLaunch(ArraySize, 1, Kernel, A, X, Y)
       .thenCopyD2H<float>(X, HostX);
   // Wait for the stream to complete.
   se::dieIfError(Stream.blockHostUntilDone());
 
   // Process output data in HostX.
   std::vector<float> ExpectedX = {4, 47, 90, 133};
   for (size_t I = 0; I < ArraySize; ++I) {
     assert(HostX[I] == ExpectedX[I]);
   }
 
   // Free device memory.
   se::dieIfError(Device->freeDeviceMemory(X));
   se::dieIfError(Device->freeDeviceMemory(Y));
   /// [Example saxpy host main]
 }

streamexecutor/include/streamexecutor/Device.h

 
 class Device {
 public:
   explicit Device(PlatformDevice *PDevice);
   virtual ~Device();
 
   /// Creates a kernel object for this device.
   ///
-  /// If the return value is not an error, the returned pointer will never be
-  /// null.
-  ///
   /// See \ref CompilerGeneratedKernelExample "Kernel.h" for an example of how
   /// this method is used.
   template <typename KernelT>
-  Expected<std::unique_ptr<typename std::enable_if<
-      std::is_base_of<KernelBase, KernelT>::value, KernelT>::type>>
+  Expected<typename std::enable_if<std::is_base_of<KernelBase, KernelT>::value,
+                                   KernelT>::type>
   createKernel(const MultiKernelLoaderSpec &Spec) {
     Expected<std::unique_ptr<PlatformKernelHandle>> MaybeKernelHandle =
         PDevice->createKernel(Spec);
     if (!MaybeKernelHandle) {
       return MaybeKernelHandle.takeError();
     }
-    return llvm::make_unique<KernelT>(Spec.getKernelName(),
-                                      std::move(*MaybeKernelHandle));
+    return KernelT(Spec.getKernelName(), std::move(*MaybeKernelHandle));
   }
 
   /// Creates a stream object for this device.
   Expected<Stream> createStream();
 
   /// Allocates an array of ElementCount entries of type T in device memory.
   template <typename T>
   Expected<GlobalDeviceMemory<T>> allocateDeviceMemory(size_t ElementCount) {

streamexecutor/include/streamexecutor/Kernel.h

 //===-- Kernel.h - StreamExecutor kernel types ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Types to represent device kernels (code compiled to run on GPU or other
 /// accelerator).
 ///
-/// With the kernel parameter types recorded in the Kernel template parameters,
-/// type-safe kernel launch functions can be written with signatures like the
-/// following:
-/// \code
-///     template <typename... ParameterTs>
-///     void Launch(
-///       const Kernel<ParameterTs...> &Kernel, ParamterTs... Arguments);
-/// \endcode
-/// and the compiler will check that the user passes in arguments with types
-/// matching the corresponding kernel parameters.
-///
-/// A problem is that a Kernel template specialization with the right parameter
-/// types must be passed as the first argument to the Launch function, and it's
-/// just as hard to get the types right in that template specialization as it is
-/// to get them right for the kernel arguments.
-///
-/// With this problem in mind, it is not recommended for users to specialize the
-/// Kernel template class themselves, but instead to let the compiler do it for
-/// them. When the compiler encounters a device kernel function, it can create a
-/// Kernel template specialization in the host code that has the right parameter
-/// types for that kernel and which has a type name based on the name of the
-/// kernel function.
-///
-/// \anchor CompilerGeneratedKernelExample
-/// For example, if a CUDA device kernel function with the following signature
-/// has been defined:
-/// \code
-///     void Saxpy(float A, float *X, float *Y);
-/// \endcode
-/// the compiler can insert the following declaration in the host code:
-/// \code
-///     namespace compiler_cuda_namespace {
-///     namespace se = streamexecutor;
-///     using SaxpyKernel =
-///         se::Kernel<
-///             float,
-///             se::GlobalDeviceMemory<float>,
-///             se::GlobalDeviceMemory<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;
-///     using KernelPtr = std::unique_ptr<ccn::SaxpyKernel>;
-///     // 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<KernelPtr> MaybeKernel =
-///         Device->createKernel<ccn::SaxpyKernel>(ccn::SaxpyKernelLoaderSpec);
-///     if (!MaybeKernel) { /* Handle error */ }
-///     KernelPtr SaxpyKernel = std::move(*MaybeKernel);
-///     Launch(*SaxpyKernel, A, X, Y);
-/// \endcode
-///
-/// With the compiler's help in specializing Kernel 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.
+/// See the \ref index "main page" for an example of how a compiler-generated
+/// specialization of the Kernel class template can be used along with the
+/// streamexecutor::Stream::thenLaunch method to create a typesafe interface for
+/// kernel launches.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef STREAMEXECUTOR_KERNEL_H
 #define STREAMEXECUTOR_KERNEL_H
 
 #include "streamexecutor/KernelSpec.h"
 #include "streamexecutor/Utils/Error.h"

 ///
 /// The template parameters are the types of the parameters to the kernel
 /// function.
 template <typename... ParameterTs> class Kernel : public KernelBase {
 public:
   Kernel(llvm::StringRef Name, std::unique_ptr<PlatformKernelHandle> PHandle)
       : KernelBase(Name), PHandle(std::move(PHandle)) {}
 
+  Kernel(Kernel &&Other) = default;
+  Kernel &operator=(Kernel &&Other) = default;
+
   /// Gets the underlying platform-specific handle for this kernel.
   PlatformKernelHandle *getPlatformHandle() const { return PHandle.get(); }
 
 private:
   std::unique_ptr<PlatformKernelHandle> PHandle;
 };
 
 } // namespace streamexecutor
 
 #endif // STREAMEXECUTOR_KERNEL_H