SWDEV-470698 - fix formatting, add format check workflow (#657)

2025-08-20 16:28:06 +02:00
parent 5840940caa
commit f7338717ae
1574 changed files with 162972 additions and 199346 deletions
@@ -41,7 +41,7 @@ Negative :
 4) Pass invalid numDependencies
 5) Pass nullptr to dst
 6) Pass nullptr to symbol
-7) Pass invalid count 
+7) Pass invalid count
 8) Pass offset+count greater than allocated size
 9) Pass unintialized graph
 */
@@ -62,7 +62,7 @@ __device__ int globalOut[SIZE];
 __device__ __constant__ int globalConst[SIZE];

 __global__ void MemcpyFromSymbolKernel(int* B_d) {
-  for (int i = 0 ; i < SIZE; i++) {
+  for (int i = 0; i < SIZE; i++) {
    globalIn[i] = B_d[i];
  }
 }
@@ -73,8 +73,7 @@ TEST_CASE("Unit_hipGraphAddMemcpyNodeFromSymbol_Negative") {
  constexpr size_t Nbytes = SIZE * sizeof(int);
  int *A_d{nullptr}, *B_d{nullptr};
  int *A_h{nullptr}, *B_h{nullptr};
-  HipTest::initArrays<int>(&A_d, &B_d, nullptr,
-                           &A_h, &B_h, nullptr, SIZE, false);
+  HipTest::initArrays<int>(&A_d, &B_d, nullptr, &A_h, &B_h, nullptr, SIZE, false);

  hipGraph_t graph;
  hipGraphNode_t memcpyToSymbolNode, memcpyH2D_A;
@@ -82,123 +81,77 @@ TEST_CASE("Unit_hipGraphAddMemcpyNodeFromSymbol_Negative") {
  HIP_CHECK(hipGraphCreate(&graph, 0));

  // Adding MemcpyNode
-  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h,
-                                    Nbytes, hipMemcpyHostToDevice));
+  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h, Nbytes,
+                                    hipMemcpyHostToDevice));
  dependencies.push_back(memcpyH2D_A);

  // Adding MemcpyNodeToSymbol
-  HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph,
-                                            dependencies.data(),
-                                            dependencies.size(),
-                                            HIP_SYMBOL(globalIn),
-                                            A_d, Nbytes, 0,
-                                            hipMemcpyDeviceToDevice));
+  HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph, dependencies.data(),
+                                          dependencies.size(), HIP_SYMBOL(globalIn), A_d, Nbytes, 0,
+                                          hipMemcpyDeviceToDevice));
  dependencies.clear();
  dependencies.push_back(memcpyToSymbolNode);

 #if HT_NVIDIA
  hipGraphNode_t memcpyFromSymbolNode;
  SECTION("Passing nullptr to graph") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, nullptr,
-                                            dependencies.data(),
-                                            dependencies.size(),
-                                            B_d,
-                                            HIP_SYMBOL(globalIn),
-                                            Nbytes, 0,
-                                            hipMemcpyDeviceToDevice)
-                                            == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, nullptr, dependencies.data(),
+                                            dependencies.size(), B_d, HIP_SYMBOL(globalIn), Nbytes,
+                                            0, hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Passing nullptr to graph node") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(nullptr, graph,
-                                          dependencies.data(),
-                                          dependencies.size(),
-                                          B_d,
-                                          HIP_SYMBOL(globalIn),
-                                          Nbytes, 0,
-                                          hipMemcpyDeviceToDevice)
-                                          == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(nullptr, graph, dependencies.data(),
+                                            dependencies.size(), B_d, HIP_SYMBOL(globalIn), Nbytes,
+                                            0, hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Passing size > 1 and dependencies as nullptr") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                          nullptr,
-                                          1,
-                                          B_d,
-                                          HIP_SYMBOL(globalIn),
-                                          Nbytes, 0,
-                                          hipMemcpyDeviceToDevice)
-                                          == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, nullptr, 1, B_d,
+                                            HIP_SYMBOL(globalIn), Nbytes, 0,
+                                            hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Passing invalid dependencies size") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                          dependencies.data(),
-                                          10,
-                                          B_d,
-                                          HIP_SYMBOL(globalIn),
-                                          Nbytes, 0,
-                                          hipMemcpyDeviceToDevice)
-                                          == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(), 10,
+                                            B_d, HIP_SYMBOL(globalIn), Nbytes, 0,
+                                            hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Passing nullptr to dst") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                          dependencies.data(),
-                                          dependencies.size(),
-                                          nullptr,
-                                          HIP_SYMBOL(globalIn), Nbytes, 0,
-                                          hipMemcpyDeviceToDevice)
-                                          == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(
+                &memcpyFromSymbolNode, graph, dependencies.data(), dependencies.size(), nullptr,
+                HIP_SYMBOL(globalIn), Nbytes, 0, hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Passing nullptr to source") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                          dependencies.data(),
-                                          dependencies.size(),
-                                          B_d,
-                                          nullptr, Nbytes, 0,
-                                          hipMemcpyDeviceToDevice)
-                                          == hipErrorInvalidSymbol);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
+                                            dependencies.size(), B_d, nullptr, Nbytes, 0,
+                                            hipMemcpyDeviceToDevice) == hipErrorInvalidSymbol);
  }

  SECTION("Passing offset+size > max size") {
-    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                          dependencies.data(),
-                                          dependencies.size(),
-                                          B_d,
-                                          HIP_SYMBOL(globalIn),
-                                          Nbytes, 10,
-                                          hipMemcpyDeviceToDevice)
-                                          == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
+                                            dependencies.size(), B_d, HIP_SYMBOL(globalIn), Nbytes,
+                                            10, hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Passing Max count") {
-  REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                        dependencies.data(),
-                                        dependencies.size(),
-                                        B_d,
-                                        HIP_SYMBOL(globalIn),
-                                        std::numeric_limits<int>::max(), 0,
-                                        hipMemcpyDeviceToDevice)
-                                        == hipErrorInvalidValue);
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
+                                            dependencies.size(), B_d, HIP_SYMBOL(globalIn),
+                                            std::numeric_limits<int>::max(), 0,
+                                            hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }

  SECTION("Pass Unintialized graph") {
-  hipGraph_t unint_graph;
-  REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, unint_graph,
-                                        dependencies.data(),
-                                        dependencies.size(),
-                                        B_d,
-                                        HIP_SYMBOL(globalIn),
-                                        Nbytes, 0,
-                                        hipMemcpyDeviceToDevice)
-                                        == hipErrorInvalidValue);
+    hipGraph_t unint_graph;
+    REQUIRE(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, unint_graph, dependencies.data(),
+                                            dependencies.size(), B_d, HIP_SYMBOL(globalIn), Nbytes,
+                                            0, hipMemcpyDeviceToDevice) == hipErrorInvalidValue);
  }
 #endif

-  HipTest::freeArrays<int>(A_d, B_d, nullptr,
-                      A_h, B_h, nullptr, false);
+  HipTest::freeArrays<int>(A_d, B_d, nullptr, A_h, B_h, nullptr, false);
  HIP_CHECK(hipGraphDestroy(graph));
 }
 /*
@@ -212,13 +165,11 @@ This function is used to verify the following scenarios
 */

 void hipGraphAddMemcpyNodeFromSymbol_GlobalMemory(bool device_ctxchg = false,
-                                                  bool const_device_var =
-                                                  false) {
+                                                  bool const_device_var = false) {
  constexpr size_t Nbytes = SIZE * sizeof(int);
-  int *A_d{nullptr};
+  int* A_d{nullptr};
  int *A_h{nullptr}, *B_h{nullptr};
-  HipTest::initArrays<int>(&A_d, nullptr, nullptr,
-                           &A_h, &B_h, nullptr, SIZE, false);
+  HipTest::initArrays<int>(&A_d, nullptr, nullptr, &A_h, &B_h, nullptr, SIZE, false);

  hipGraph_t graph;
  hipGraphExec_t graphExec;
@@ -231,26 +182,20 @@ void hipGraphAddMemcpyNodeFromSymbol_GlobalMemory(bool device_ctxchg = false,
    HIP_CHECK(hipDeviceEnablePeerAccess(0, 0));
  }
  // Adding MemcpyNode
-  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h,
-                                    Nbytes, hipMemcpyHostToDevice));
+  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h, Nbytes,
+                                    hipMemcpyHostToDevice));
  dependencies.push_back(memcpyH2D_A);

  // Adding MemcpyNodeToSymbol
  if (const_device_var) {
-    HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph,
-          dependencies.data(),
-          dependencies.size(),
-          HIP_SYMBOL(globalConst),
-          A_d, Nbytes, 0,
-          hipMemcpyDeviceToDevice));
+    HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph, dependencies.data(),
+                                            dependencies.size(), HIP_SYMBOL(globalConst), A_d,
+                                            Nbytes, 0, hipMemcpyDeviceToDevice));

  } else {
-    HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph,
-          dependencies.data(),
-          dependencies.size(),
-          HIP_SYMBOL(globalIn),
-          A_d, Nbytes, 0,
-          hipMemcpyDeviceToDevice));
+    HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph, dependencies.data(),
+                                            dependencies.size(), HIP_SYMBOL(globalIn), A_d, Nbytes,
+                                            0, hipMemcpyDeviceToDevice));
  }
  dependencies.clear();
  dependencies.push_back(memcpyToSymbolNode);
@@ -258,21 +203,13 @@ void hipGraphAddMemcpyNodeFromSymbol_GlobalMemory(bool device_ctxchg = false,

  // Adding MemcpyNodeFromSymbol
  if (const_device_var) {
-    HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-          dependencies.data(),
-          dependencies.size(),
-          B_h,
-          HIP_SYMBOL(globalConst),
-          Nbytes, 0,
-          hipMemcpyDeviceToHost));
+    HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
+                                              dependencies.size(), B_h, HIP_SYMBOL(globalConst),
+                                              Nbytes, 0, hipMemcpyDeviceToHost));
  } else {
-    HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-          dependencies.data(),
-          dependencies.size(),
-          B_h,
-          HIP_SYMBOL(globalIn),
-          Nbytes, 0,
-          hipMemcpyDeviceToHost));
+    HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
+                                              dependencies.size(), B_h, HIP_SYMBOL(globalIn),
+                                              Nbytes, 0, hipMemcpyDeviceToHost));
  }


@@ -284,13 +221,12 @@ void hipGraphAddMemcpyNodeFromSymbol_GlobalMemory(bool device_ctxchg = false,
  // Validating the result
  for (int i = 0; i < SIZE; i++) {
    if (B_h[i] != A_h[i]) {
-       WARN("Validation failed B_h[i] " << B_h[i] << "A_h[i] " << A_h[i]);
-       REQUIRE(false);
+      WARN("Validation failed B_h[i] " << B_h[i] << "A_h[i] " << A_h[i]);
+      REQUIRE(false);
    }
  }

-  HipTest::freeArrays<int>(A_d, nullptr, nullptr,
-                      A_h, B_h, nullptr, false);
+  HipTest::freeArrays<int>(A_d, nullptr, nullptr, A_h, B_h, nullptr, false);
  HIP_CHECK(hipGraphExecDestroy(graphExec));
  HIP_CHECK(hipGraphDestroy(graph));
 }
@@ -369,8 +305,7 @@ TEST_CASE("Unit_hipGraphAddMemcpyNodeFromSymbol_GlobalMemoryWithKernel") {
  hipKernelNodeParams kernelNodeParams{};
  int *A_d{nullptr}, *B_d{nullptr};
  int *A_h{nullptr}, *B_h{nullptr};
-  HipTest::initArrays<int>(&A_d, &B_d, nullptr,
-                           &A_h, &B_h, nullptr, SIZE, false);
+  HipTest::initArrays<int>(&A_d, &B_d, nullptr, &A_h, &B_h, nullptr, SIZE, false);

  hipGraph_t graph;
  hipGraphExec_t graphExec;
@@ -379,49 +314,39 @@ TEST_CASE("Unit_hipGraphAddMemcpyNodeFromSymbol_GlobalMemoryWithKernel") {
  HIP_CHECK(hipGraphCreate(&graph, 0));

  // Adding MemcpyNode
-  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h,
-                                    Nbytes, hipMemcpyHostToDevice));
+  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h, Nbytes,
+                                    hipMemcpyHostToDevice));
  dependencies.push_back(memcpyH2D_A);

-  HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph,
-          dependencies.data(),
-          dependencies.size(),
-          HIP_SYMBOL(globalIn),
-          A_d, Nbytes, 0,
-          hipMemcpyDeviceToDevice));
+  HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&memcpyToSymbolNode, graph, dependencies.data(),
+                                          dependencies.size(), HIP_SYMBOL(globalIn), A_d, Nbytes, 0,
+                                          hipMemcpyDeviceToDevice));
  dependencies.clear();
  dependencies.push_back(memcpyToSymbolNode);


-  HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
-                                            dependencies.data(),
-                                            dependencies.size(),
-                                            B_d,
-                                            HIP_SYMBOL(globalIn),
-                                            Nbytes, 0,
-                                            hipMemcpyDeviceToDevice));
+  HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
+                                            dependencies.size(), B_d, HIP_SYMBOL(globalIn), Nbytes,
+                                            0, hipMemcpyDeviceToDevice));
  dependencies.clear();
  dependencies.push_back(memcpyFromSymbolNode);

  // Adding Kernel node
  void* kernelArgs1[] = {&B_d};
-  kernelNodeParams.func =
-                       reinterpret_cast<void *>(MemcpyFromSymbolKernel);
+  kernelNodeParams.func = reinterpret_cast<void*>(MemcpyFromSymbolKernel);
  kernelNodeParams.gridDim = dim3(blocks);
  kernelNodeParams.blockDim = dim3(threadsPerBlock);
  kernelNodeParams.sharedMemBytes = 0;
  kernelNodeParams.kernelParams = reinterpret_cast<void**>(kernelArgs1);
  kernelNodeParams.extra = nullptr;
-  HIP_CHECK(hipGraphAddKernelNode(&memcpyfromsymbolkernel, graph,
-                                  dependencies.data(), dependencies.size(),
-                                  &kernelNodeParams));
+  HIP_CHECK(hipGraphAddKernelNode(&memcpyfromsymbolkernel, graph, dependencies.data(),
+                                  dependencies.size(), &kernelNodeParams));
  dependencies.clear();
  dependencies.push_back(memcpyfromsymbolkernel);

  // Adding MemcpyNode
-  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyD2H_B, graph, dependencies.data(),
-                                    dependencies.size(), B_h, B_d,
-                                    Nbytes, hipMemcpyDeviceToHost));
+  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyD2H_B, graph, dependencies.data(), dependencies.size(),
+                                    B_h, B_d, Nbytes, hipMemcpyDeviceToHost));

  // Instantiate and launch the graph
  HIP_CHECK(hipGraphInstantiate(&graphExec, graph, nullptr, nullptr, 0));
@@ -431,13 +356,12 @@ TEST_CASE("Unit_hipGraphAddMemcpyNodeFromSymbol_GlobalMemoryWithKernel") {
  // Validating the result
  for (int i = 0; i < SIZE; i++) {
    if (B_h[i] != A_h[i]) {
-       WARN("Validation failed B_h[i] " << B_h[i] << "A_h[i] " << A_h[i]);
-       REQUIRE(false);
+      WARN("Validation failed B_h[i] " << B_h[i] << "A_h[i] " << A_h[i]);
+      REQUIRE(false);
    }
  }

-  HipTest::freeArrays<int>(A_d, B_d, nullptr,
-                           A_h, B_h, nullptr, false);
+  HipTest::freeArrays<int>(A_d, B_d, nullptr, A_h, B_h, nullptr, false);
  HIP_CHECK(hipGraphExecDestroy(graphExec));
  HIP_CHECK(hipGraphDestroy(graph));
 }