graph_exec.h

#pragma once
#include <muda/graph/graph_base.h>
#include <muda/graph/kernel_node.h>
#include <muda/graph/memory_node.h>
#include <muda/graph/event_node.h>
#include <muda/graph/graph_viewer.h>

namespace muda
{
class GraphExec
{
    template <typename T>
    using S = std::shared_ptr<T>;
    template <typename T>
    using U = std::unique_ptr<T>;
    cudaGraphExec_t                m_handle;
    Flags<GraphInstantiateFlagBit> m_flags;

  public:
    friend class Graph;

    GraphExec();

    // delete copy
    GraphExec(const GraphExec&)            = delete;
    GraphExec& operator=(const GraphExec&) = delete;

    // move
    GraphExec(GraphExec&& other);
    GraphExec& operator=(GraphExec&& other);

    void upload(cudaStream_t stream = nullptr);

    void launch(cudaStream_t stream = nullptr);

    template <typename T>
    void set_kernel_node_parms(S<KernelNode> node, const S<KernelNodeParms<T>>& new_parms);


    void set_memcpy_node_parms(S<MemcpyNode>  node,
                               void*          dst,
                               const void*    src,
                               size_t         size_bytes,
                               cudaMemcpyKind kind);
    void set_memcpy_node_parms(S<MemcpyNode> node, const cudaMemcpy3DParms& parms);
    void set_memset_node_parms(S<MemsetNode> node, const cudaMemsetParams& parms);


    void set_event_record_node_parms(S<EventRecordNode> node, cudaEvent_t event);
    void set_event_wait_node_parms(S<EventWaitNode> node, cudaEvent_t event);

    ~GraphExec();

    cudaGraphExec_t handle() const { return m_handle; }

    GraphViewer viewer() const;
  private:
    // keep the ref count > 0 for those whose data should be kept alive for the graph life.
    std::list<S<NodeParms>> m_cached;
};
}  // namespace muda

#include "details/graph_exec.inl"