updated cuda

Author: twhuang-utah

taskflow/cuda/flow_builder.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "task.hpp"
+
+namespace tf {
+
+class cudaFlow {
+
+  public:
+    
+    cudaFlow(cudaGraph&);
+
+    template <typename F, typename... ArgsT>
+    cudaTask kernel(dim3 grid, dim3 block, size_t shm, F&& func, ArgsT&&... args);
+
+    cudaTask copy(void* tgt, void* src, size_t num, size_t size);
+
+  private:
+
+    cudaGraph& _graph;
+};
+
+// Constructor
+inline cudaFlow::cudaFlow(cudaGraph& g) : _graph {g} {
+}
+
+// Function: kernel
+template <typename F, typename... ArgsT>
+cudaTask cudaFlow::kernel(dim3 grid, dim3 block, size_t shm, F&& func, ArgsT&&... args) {
+
+  void* arguments[sizeof...(ArgsT)] = { &args... };
+
+  auto node = _graph.emplace_back();
+
+  auto& param = node->_handle.emplace<cudaNode::Kernel>().param;
+
+  param.func = (void*)func;
+  param.gridDim = grid;
+  param.blockDim = block;
+  param.sharedMemBytes = shm;
+  param.kernelParams = arguments;
+  param.extra = nullptr;
+  
+  TF_CHECK_CUDA(
+    ::cudaGraphAddKernelNode(&node->_node, _graph._handle, nullptr, 0, &param),
+    "failed to create a cudaKernel node"
+  );
+  
+  return cudaTask(node);
+}
+
+// Function: copy
+inline cudaTask cudaFlow::copy(void* tgt, void* src, size_t num, size_t size) {
+
+  auto node = _graph.emplace_back();
+  auto& param = node->_handle.emplace<cudaNode::Copy>().param;
+
+  param.srcArray = nullptr;
+  param.srcPos = ::make_cudaPos(0, 0, 0);
+  param.srcPtr = ::make_cudaPitchedPtr(src, num*size, num, 1);
+  param.dstArray = nullptr;
+  param.dstPos = ::make_cudaPos(0, 0, 0);
+  param.dstPtr = ::make_cudaPitchedPtr(tgt, num*size, num, 1);
+  param.extent = ::make_cudaExtent(num*size, 1, 1);
+  param.kind = cudaMemcpyDefault;
+
+  TF_CHECK_CUDA(
+    cudaGraphAddMemcpyNode(&node->_node, _graph._handle, nullptr, 0, &param),
+    "failed to create a cudaCopy node"
+  );
+
+  return cudaTask(node);
+}
+
+}  // end of namespace tf -----------------------------------------------------

taskflow/cuda/task.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "graph.hpp"
+
+namespace tf {
+
+/**
+@class Task
+
+@brief task handle to a node in a cudaGraph
+*/
+class cudaTask {
+
+  friend class cudaFlow;
+
+  public:
+    
+    /**
+    @brief constructs an empty cudaTask
+    */
+    cudaTask() = default;
+
+    /**
+    @brief copy-constructs a cudaTask
+    */
+    cudaTask(const cudaTask&) = default;
+
+    /**
+    @brief copy-assigns a cudaTask
+    */
+    cudaTask& operator = (const cudaTask&) = default;
+
+    /**
+    @brief adds precedence links from this to other tasks
+
+    @tparam Ts... parameter pack
+
+    @param tasks one or multiple tasks
+
+    @return @c *this
+    */
+    template <typename... Ts>
+    cudaTask& precede(Ts&&... tasks);
+    
+    /**
+    @brief assigns a name to the task
+
+    @param name a @std_string acceptable string
+
+    @return @c *this
+    */
+    cudaTask& name(const std::string& name);
+    
+    /**
+    @brief queries the name of the task
+    */
+    const std::string& name() const;
+
+  private:
+    
+    cudaTask(cudaNode*);
+
+    cudaNode* _node {nullptr};
+
+    template <typename T>
+    void _precede(T&&);
+
+    template <typename T, typename... Ts>
+    void _precede(T&&, Ts&&...);
+};
+
+// Constructor
+inline cudaTask::cudaTask(cudaNode* node) : _node {node} {
+}
+
+// Function: precede
+template <typename... Ts>
+cudaTask& cudaTask::precede(Ts&&... tasks) {
+  _precede(std::forward<Ts>(tasks)...);
+  return *this;
+}
+
+// Procedure: precede
+template <typename T>
+void cudaTask::_precede(T&& other) {
+  _node->_precede(other._node);
+}
+
+// Procedure: _precede
+template <typename T, typename... Ts>
+void cudaTask::_precede(T&& task, Ts&&... others) {
+  _precede(std::forward<T>(task));
+  _precede(std::forward<Ts>(others)...);
+}
+
+// Function: name
+inline cudaTask& cudaTask::name(const std::string& name) {
+  _node->_name = name;
+  return *this;
+}
+
+// Function: name
+inline const std::string& cudaTask::name() const {
+  return _node->_name;
+}
+
+}  // end of namespace tf -----------------------------------------------------