SWDEV-240806 - Added API hipGraphAddMemcpyNode1D, hipGraphAddEmptyNode, hipGraphExecKernelNodeSetParams

Change-Id: I0d7ec8c0ea1abc3fc0f1e10fa7865f355d9cf2ad


[ROCm/clr commit: a71f54d9e9]

projects/clr/hipamd/src/hip_graph.cpp

@@ -27,13 +27,7 @@
 thread_local std::vector<hipStream_t> g_captureStreams;
 std::unordered_map<amd::Command*, hipGraphExec_t> hipGraphExec::activeGraphExec_;
 
-hipError_t ihipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
-                                  const hipGraphNode_t* pDependencies, size_t numDependencies,
-                                  const hipKernelNodeParams* pNodeParams) {
-  if (pGraphNode == nullptr || graph == nullptr ||
-      (numDependencies > 0 && pDependencies == nullptr) || pNodeParams == nullptr) {
-    return hipErrorInvalidValue;
-  }
+hipError_t ihipValidateKernelParams(const hipKernelNodeParams* pNodeParams) {
   hipFunction_t func = nullptr;
   hipError_t status =
       PlatformState::instance().getStatFunc(&func, pNodeParams->func, ihipGetDevice());
@@ -56,6 +50,24 @@ hipError_t ihipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
   if (status != hipSuccess) {
     return status;
   }
+}
+
+hipError_t ihipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
+                                  const hipGraphNode_t* pDependencies, size_t numDependencies,
+                                  const hipKernelNodeParams* pNodeParams) {
+  if (pGraphNode == nullptr || graph == nullptr ||
+      (numDependencies > 0 && pDependencies == nullptr) || pNodeParams == nullptr) {
+    return hipErrorInvalidValue;
+  }
+  hipError_t status = ihipValidateKernelParams(pNodeParams);
+  if (hipSuccess != status) {
+    return status;
+  }
+  hipFunction_t func = nullptr;
+  status = PlatformState::instance().getStatFunc(&func, pNodeParams->func, ihipGetDevice());
+  if ((status != hipSuccess) || (func == nullptr)) {
+    return hipErrorInvalidDeviceFunction;
+  }
   *pGraphNode = new hipGraphKernelNode(pNodeParams, func);
   if (numDependencies == 0) {
     graph->AddNode(*pGraphNode);
@@ -88,6 +100,26 @@ hipError_t ihipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
   return hipSuccess;
 }
 
+hipError_t ihipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,
+                                    const hipGraphNode_t* pDependencies, size_t numDependencies,
+                                    void* dst, const void* src, size_t count, hipMemcpyKind kind) {
+  if (pGraphNode == nullptr || graph == nullptr ||
+      (numDependencies > 0 && pDependencies == nullptr)) {
+    return hipErrorInvalidValue;
+  }
+  ihipMemcpy_validate(dst, src, count, kind);
+  *pGraphNode = new hipGraphMemcpyNode1D(dst, src, count, kind);
+  if (numDependencies == 0) {
+    graph->AddNode(*pGraphNode);
+  }
+  for (size_t i = 0; i < numDependencies; i++) {
+    if (graph->AddEdge(*(pDependencies + i), *pGraphNode) != hipSuccess) {
+      return hipErrorInvalidValue;
+    }
+  }
+  return hipSuccess;
+}
+
 hipError_t ihipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
                                   const hipGraphNode_t* pDependencies, size_t numDependencies,
                                   const hipMemsetParams* pMemsetParams) {
@@ -268,6 +300,7 @@ hipError_t capturehipStreamWaitEvent(hipEvent_t& event, hipStream_t& stream, uns
   ClPrint(amd::LOG_INFO, amd::LOG_API,
           "[hipGraph] current capture node StreamWaitEvent on stream : %p, Event %p", stream,
           event);
+
   hip::Stream* s = reinterpret_cast<hip::Stream*>(stream);
   hip::Event* e = reinterpret_cast<hip::Event*>(event);
 
@@ -281,7 +314,7 @@ hipError_t capturehipStreamWaitEvent(hipEvent_t& event, hipStream_t& stream, uns
   }
   s->AddCrossCapturedNode(e->GetNodesPrevToRecorded());
   g_captureStreams.push_back(stream);
-  return hipSuccess;
+  HIP_RETURN(hipSuccess);
 }
 
 hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus** pCaptureStatus) {
@@ -355,7 +388,7 @@ hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
   HIP_INIT_API(hipGraphAddKernelNode, pGraphNode, graph, pDependencies, numDependencies,
                pNodeParams);
   HIP_RETURN_DURATION(
-      ihipGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams););
+      ihipGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams));
 }
 
 hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
@@ -365,7 +398,17 @@ hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
                pCopyParams);
 
   HIP_RETURN_DURATION(
-      ihipGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams););
+      ihipGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, pCopyParams));
+}
+
+hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,
+                                   const hipGraphNode_t* pDependencies, size_t numDependencies,
+                                   void* dst, const void* src, size_t count, hipMemcpyKind kind) {
+  HIP_INIT_API(hipGraphAddMemcpyNode1D, pGraphNode, graph, pDependencies, numDependencies, dst, src,
+               count, kind);
+
+  HIP_RETURN_DURATION(ihipGraphAddMemcpyNode1D(pGraphNode, graph, pDependencies, numDependencies,
+                                               dst, src, count, kind));
 }
 
 hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
@@ -375,7 +418,26 @@ hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
                pMemsetParams);
 
   HIP_RETURN_DURATION(
-      ihipGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams););
+      ihipGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, pMemsetParams));
+}
+
+hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,
+                                const hipGraphNode_t* pDependencies, size_t numDependencies) {
+  HIP_INIT_API(hipGraphAddEmptyNode, pGraphNode, graph, pDependencies, numDependencies);
+  if (pGraphNode == nullptr || graph == nullptr ||
+      (numDependencies > 0 && pDependencies == nullptr)) {
+    return HIP_RETURN(hipErrorInvalidValue);
+  }
+  *pGraphNode = new hipGraphEmptyNode();
+  if (numDependencies == 0) {
+    graph->AddNode(*pGraphNode);
+  }
+  for (size_t i = 0; i < numDependencies; i++) {
+    if (graph->AddEdge(*(pDependencies + i), *pGraphNode) != hipSuccess) {
+      return hipErrorInvalidValue;
+    }
+  }
+  return hipSuccess;
 }
 
 hipError_t ihipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,
@@ -417,8 +479,9 @@ hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream) {
 hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t* nodes, size_t* numNodes) {
   HIP_INIT_API(hipGraphGetNodes, graph, nodes, numNodes);
   if (graph == nullptr || numNodes == nullptr) {
-    *numNodes = graph->GetNodeCount();
+    return HIP_RETURN(hipErrorInvalidValue);
   }
+  *numNodes = graph->GetNodeCount();
   if (*numNodes > 0) {
     nodes = graph->GetNodes().data();
   }
@@ -510,3 +573,12 @@ hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t* from,
   }
   HIP_RETURN(hipSuccess);
 }
+
+hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,
+                                           const hipKernelNodeParams* pNodeParams) {
+  HIP_INIT_API(hipGraphExecKernelNodeSetParams, hGraphExec, node, pNodeParams);
+  if (hGraphExec == nullptr || node == nullptr || pNodeParams == nullptr) {
+    return HIP_RETURN(hipErrorInvalidValue);
+  }
+  return reinterpret_cast<hipGraphKernelNode*>(node)->SetCommandParams(pNodeParams);
+}