TheRock/rocm-systems/projects/hip-tests/catch/unit/graph/hipGraphAddMemcpyNode1D_old.cc

/*
 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
 *
 * SPDX-License-Identifier: MIT
 */

/**
Testcase Scenarios :
Functional -
1) Add 1D memcpy node to graph and verify memcpy operation is success for all memcpy kinds(H2D, D2H
and D2D). Memcpy nodes are added and assigned to default device. 2) Allocate memory on default
device(Dev 0), Perform memcpy operation for 1D arrays on Peer device(Dev 1) and verify the results.
3) Create two host pointers, copy the data between them by the api hipGraphAddMemcpyNode1D with data
transfer kind hipMemcpyHostToHost. Validate the output.

Negative -
1) Pass pGraphNode as nullptr and check if api returns error.
2) When graph is un-initialized argument(skipping graph creation), api should return error code.
3) Passing pDependencies as nullptr, api should return success.
4) When numDependencies is max(size_t) and pDependencies is not valid ptr, api expected to return
error code. 5) When pDependencies is nullptr, but numDependencies is non-zero, api expected to
return error. 6) When destination ptr  is nullptr, api expected to return error code. 7) When source
ptr is nullptr, api expected to return error code. 8) If count is more than allocated size for
source and destination ptr, error code is returned. 9) If count is less than or equal to allocated
size of source and destination ptr, api should return success.
*/

#include <hip_test_common.hh>
#include <hip_test_checkers.hh>
#include <vector>
#include <numeric>

static void validateMemcpyNode1DArray(bool peerAccess,
                                      hipMemcpyKind d2d_type = hipMemcpyDeviceToDevice) {
  constexpr int SIZE{32};
  int harray1D[SIZE]{};
  int harray1Dres[SIZE]{};
  hipGraph_t graph;
  hipArray_t devArray1, devArray2;
  hipGraphNode_t memcpyH2D, memcpyD2H, memcpyD2D;
  constexpr int numBytes{SIZE * sizeof(int)};
  hipStream_t streamForGraph;
  hipGraphExec_t graphExec;

  HIP_CHECK(hipSetDevice(0));
  HIP_CHECK(hipStreamCreate(&streamForGraph));
  HIP_CHECK(hipMalloc(&devArray1, numBytes));
  HIP_CHECK(hipMalloc(&devArray2, numBytes));

  // Initialize 1D object
  for (int i = 0; i < SIZE; i++) {
    harray1D[i] = i + 1;
  }

  HIP_CHECK(hipGraphCreate(&graph, 0));

  // For peer access test, Memory is allocated on device(0)
  // while memcpy nodes are allocated and assigned to peer device(1)
  if (peerAccess) {
    HIP_CHECK(hipSetDevice(1));
  }

  // Host to Device (harray1D -> devArray1)
  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D, graph, nullptr, 0, devArray1, harray1D, numBytes,
                                    hipMemcpyHostToDevice));

  // Device to Device (devArray1 -> devArray2)
  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyD2D, graph, &memcpyH2D, 1, devArray2, devArray1,
                                    numBytes, d2d_type));

  // Device to host (devArray2 -> harray1Dres)
  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyD2H, graph, &memcpyD2D, 1, harray1Dres, devArray2,
                                    numBytes, hipMemcpyDeviceToHost));

  // Instantiate and launch the graph
  hipError_t graphInstStatus = hipGraphInstantiate(&graphExec, graph, nullptr, nullptr, 0);
  if (peerAccess && graphInstStatus == hipErrorNotSupported) {
    HIP_CHECK(hipSetDevice(0));
    hipGraphDestroy(graph);
    hipStreamDestroy(streamForGraph);
    hipFree(devArray1);
    hipFree(devArray2);
    SKIP("Multi-device graph instantiation not supported (hipErrorNotSupported)");
  }
  HIP_CHECK(graphInstStatus);
  HIP_CHECK(hipGraphLaunch(graphExec, streamForGraph));
  HIP_CHECK(hipStreamSynchronize(streamForGraph));

  // Validate result
  for (int i = 0; i < SIZE; i++) {
    if (harray1D[i] != harray1Dres[i]) {
      INFO("harray1D: " << harray1D[i] << " harray1Dres: " << harray1Dres[i]
                        << " mismatch at : " << i);
      REQUIRE(false);
    }
  }
  HIP_CHECK(hipGraphExecDestroy(graphExec));
  HIP_CHECK(hipGraphDestroy(graph));
  HIP_CHECK(hipStreamDestroy(streamForGraph));
  HIP_CHECK(hipFree(devArray1));
  HIP_CHECK(hipFree(devArray2));
}


/**
 * Functional Tests adds memcpy 1D nodes of types H2D, D2D and D2H to graph
 * and verifies execution sequence by launching graph.
 *
 * For Default device test: Memory allocations and memory operations
 * are performed from device(0).
 * For Peer device test: Memory allocations happen on device(0) and memcpy operations
 * are performed from device(1).
 */
HIP_TEST_CASE(Unit_hipGraphAddMemcpyNode1D_Functional) {
  SECTION("Memcpy with 1D array on default device") { validateMemcpyNode1DArray(false); }
  SECTION("Memcpy with 1D array using DeviceToDeviceNoCU") {
    validateMemcpyNode1DArray(false, hipMemcpyDeviceToDeviceNoCU);
  }
  SECTION("Memcpy with 1D array on peer device") {
    int numDevices{}, peerAccess{};
    HIP_CHECK(hipGetDeviceCount(&numDevices));
    if (numDevices > 1) {
      HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 1, 0));
    }

    if (!peerAccess) {
      WARN("Skipping peer memcpy section: peer access is not available between devices.");
      return;
    }
    validateMemcpyNode1DArray(true);
  }
}


/**
 * Negative Test for API hipGraphAddMemcpyNode1D
 */
HIP_TEST_CASE(Unit_hipGraphAddMemcpyNode1D_Negative) {
  constexpr size_t N = 1024;
  constexpr size_t Nbytes = N * sizeof(int);
  int *A_d, *A_h;
  hipGraph_t graph;
  hipGraphNode_t memcpyNode{};
  hipError_t ret;

  HIP_CHECK(hipMalloc(&A_d, Nbytes));
  HIP_CHECK(hipMalloc(&A_h, Nbytes));
  HIP_CHECK(hipGraphCreate(&graph, 0));

  SECTION("Pass pGraphNode as nullptr") {
    ret = hipGraphAddMemcpyNode1D(nullptr, graph, nullptr, 0, A_d, A_h, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass graph as nullptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, nullptr, nullptr, 0, A_d, A_h, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass pDependencies as nullptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, 0, A_d, A_h, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipSuccess == ret);
  }
  SECTION("Pass numDependencies is max and pDependencies is not valid ptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, INT_MAX, A_d, A_h, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass pDependencies as nullptr, but numDependencies is non-zero") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, 9, A_d, A_h, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass destination ptr as nullptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, 0, nullptr, A_h, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass source ptr as nullptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, 0, A_d, nullptr, Nbytes,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass count as more than allocated size for source ptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, 0, A_d, A_h, Nbytes + 10,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipErrorInvalidValue == ret);
  }
  SECTION("Pass count as less than allocated size for destination ptr") {
    ret = hipGraphAddMemcpyNode1D(&memcpyNode, graph, nullptr, 0, A_d, A_h, Nbytes - 10,
                                  hipMemcpyHostToDevice);
    REQUIRE(hipSuccess == ret);
  }
  HIP_CHECK(hipFree(A_d));
  HIP_CHECK(hipFree(A_h));
  HIP_CHECK(hipGraphDestroy(graph));
}
/*
 * Create two host pointers, copy the data between them by the api
 * hipGraphAddMemcpyNode1D with data transfer kind hipMemcpyHostToHost.
 * Validate the output.
 */
HIP_TEST_CASE(Unit_hipGraphAddMemcpyNode1D_HostToHost) {
  constexpr size_t size = 1024;
  size_t numBytes{size * sizeof(int)};

  // Host Vectors
  std::vector<int> A_h(size);
  std::vector<int> B_h(size);
  // Initialization
  std::iota(A_h.begin(), A_h.end(), 0);
  std::fill_n(B_h.begin(), size, 0);

  hipGraph_t graph;
  hipStream_t streamForGraph;
  hipGraphExec_t graphExec;
  hipGraphNode_t memcpyH2H;
  HIP_CHECK(hipGraphCreate(&graph, 0));
  HIP_CHECK(hipStreamCreate(&streamForGraph));

  // Host to Host
  HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2H, graph, nullptr, 0, B_h.data(), A_h.data(), numBytes,
                                    hipMemcpyHostToHost));

  // Instantiate and launch the graph
  HIP_CHECK(hipGraphInstantiate(&graphExec, graph, nullptr, nullptr, 0));
  HIP_CHECK(hipGraphLaunch(graphExec, streamForGraph));
  HIP_CHECK(hipStreamSynchronize(streamForGraph));

  HIP_CHECK(hipGraphExecDestroy(graphExec));
  HIP_CHECK(hipGraphDestroy(graph));
  HIP_CHECK(hipStreamDestroy(streamForGraph));

  // Validation
  REQUIRE(std::equal(A_h.begin(), A_h.end(), B_h.begin(), B_h.end()));
}