AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Danylo Lytovchenko
2025-08-20 16:28:06 +02:00
committed by GitHub
parent 5840940caa
commit f7338717ae
1574 changed files with 162972 additions and 199346 deletions
Download Patch File Download Diff File Expand all files Collapse all files
projects/hip-tests/catch/unit/graph/hipGraphInstantiateWithFlags.cc
+116 -148
View File
@@ -18,19 +18,13 @@ THE SOFTWARE.
*/
/*
hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph, unsigned long long flags);
Testcase Scenarios of hipGraphInstantiateWithFlags API:
Negative:
1) Pass nullptr to pGraphExec
2) Pass nullptr to graph
4) Pass invalid flag
Functional:
1) Create dependencies graph and instantiate the graph
2) Create graph in one GPU device and instantiate, launch in peer GPU device
3) Create stream capture graph and instantite the graph
4) Create stream capture graph in one GPU device and instantite the graph launch
in peer GPU device
Mapping is missing for NVIDIA platform hence skipping the testcases
hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph, unsigned long long
flags); Testcase Scenarios of hipGraphInstantiateWithFlags API: Negative: 1) Pass nullptr to
pGraphExec 2) Pass nullptr to graph 4) Pass invalid flag Functional: 1) Create dependencies graph
and instantiate the graph 2) Create graph in one GPU device and instantiate, launch in peer GPU
device 3) Create stream capture graph and instantite the graph 4) Create stream capture graph in one
GPU device and instantite the graph launch in peer GPU device Mapping is missing for NVIDIA
platform hence skipping the testcases
*/
#include <hip_test_common.hh>
@@ -50,7 +44,7 @@ static constexpr size_t NBYTES = SIZE * sizeof(int);
/**
* In fillKernel, all elements of the array filled with given value
*/
static __global__ void fillKernel(int *arr, int size, int value) {
static __global__ void fillKernel(int* arr, int size, int value) {
int offset = blockDim.x * blockIdx.x + threadIdx.x;
int stride = blockDim.x * gridDim.x;
for (int i = offset; i < size; i += stride) {
@@ -61,7 +55,7 @@ static __global__ void fillKernel(int *arr, int size, int value) {
/**
* In doubleKernel, all elements of the array doubled with its value
*/
static __global__ void doubleKernel(int *arr, int size) {
static __global__ void doubleKernel(int* arr, int size) {
int offset = blockDim.x * blockIdx.x + threadIdx.x;
int stride = blockDim.x * gridDim.x;
for (int i = offset; i < size; i += stride) {
@@ -75,14 +69,12 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_Negative") {
SECTION("Passing nullptr pGraphExec") {
hipGraph_t graph;
HIP_CHECK(hipGraphCreate(&graph, 0));
REQUIRE(hipGraphInstantiateWithFlags(nullptr,
graph, 0) == hipErrorInvalidValue);
REQUIRE(hipGraphInstantiateWithFlags(nullptr, graph, 0) == hipErrorInvalidValue);
}
SECTION("Passing nullptr to graph") {
hipGraphExec_t graphExec;
REQUIRE(hipGraphInstantiateWithFlags(&graphExec,
nullptr, 0) == hipErrorInvalidValue);
REQUIRE(hipGraphInstantiateWithFlags(&graphExec, nullptr, 0) == hipErrorInvalidValue);
}
SECTION("Passing Invalid flag") {
@@ -126,8 +118,7 @@ void GraphInstantiateWithFlags_DependencyGraph(bool ctxt_change = false) {
memsetParams.elementSize = sizeof(char);
memsetParams.width = Nbytes;
memsetParams.height = 1;
HIP_CHECK(hipGraphAddMemsetNode(&memset_A, graph, nullptr, 0,
&memsetParams));
HIP_CHECK(hipGraphAddMemsetNode(&memset_A, graph, nullptr, 0, &memsetParams));
memset(&memsetParams, 0, sizeof(memsetParams));
memsetParams.dst = reinterpret_cast<void*>(B_d);
@@ -136,37 +127,33 @@ void GraphInstantiateWithFlags_DependencyGraph(bool ctxt_change = false) {
memsetParams.elementSize = sizeof(char);
memsetParams.width = Nbytes;
memsetParams.height = 1;
HIP_CHECK(hipGraphAddMemsetNode(&memset_B, graph, nullptr, 0,
&memsetParams));
HIP_CHECK(hipGraphAddMemsetNode(&memset_B, graph, nullptr, 0, &memsetParams));
void* kernelArgs1[] = {&C_d, &memsetVal, reinterpret_cast<void *>(&NElem)};
kernelNodeParams.func =
reinterpret_cast<void *>(HipTest::memsetReverse<int>);
void* kernelArgs1[] = {&C_d, &memsetVal, reinterpret_cast<void*>(&NElem)};
kernelNodeParams.func = reinterpret_cast<void*>(HipTest::memsetReverse<int>);
kernelNodeParams.gridDim = dim3(blocks);
kernelNodeParams.blockDim = dim3(threadsPerBlock);
kernelNodeParams.sharedMemBytes = 0;
kernelNodeParams.kernelParams = reinterpret_cast<void**>(kernelArgs1);
kernelNodeParams.extra = nullptr;
HIP_CHECK(hipGraphAddKernelNode(&memsetKer_C, graph, nullptr, 0,
&kernelNodeParams));
HIP_CHECK(hipGraphAddKernelNode(&memsetKer_C, graph, nullptr, 0, &kernelNodeParams));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h,
Nbytes, hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_B, graph, nullptr, 0, B_d, B_h,
Nbytes, hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_A, graph, nullptr, 0, A_d, A_h, Nbytes,
hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyH2D_B, graph, nullptr, 0, B_d, B_h, Nbytes,
hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyD2H_C, graph, nullptr, 0, C_h, C_d,
Nbytes, hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyD2H_C, graph, nullptr, 0, C_h, C_d, Nbytes,
hipMemcpyDeviceToHost));
void* kernelArgs2[] = {&A_d, &B_d, &C_d, reinterpret_cast<void *>(&NElem)};
kernelNodeParams.func = reinterpret_cast<void *>(HipTest::vectorADD<int>);
void* kernelArgs2[] = {&A_d, &B_d, &C_d, reinterpret_cast<void*>(&NElem)};
kernelNodeParams.func = reinterpret_cast<void*>(HipTest::vectorADD<int>);
kernelNodeParams.gridDim = dim3(blocks);
kernelNodeParams.blockDim = dim3(threadsPerBlock);
kernelNodeParams.sharedMemBytes = 0;
kernelNodeParams.kernelParams = reinterpret_cast<void**>(kernelArgs2);
kernelNodeParams.extra = nullptr;
HIP_CHECK(hipGraphAddKernelNode(&kernel_vecAdd, graph, nullptr, 0,
&kernelNodeParams));
HIP_CHECK(hipGraphAddKernelNode(&kernel_vecAdd, graph, nullptr, 0, &kernelNodeParams));
// Create dependencies
HIP_CHECK(hipGraphAddDependencies(graph, &memset_A, &memcpyH2D_A, 1));
@@ -212,7 +199,7 @@ void GraphInstantiateWithFlags_StreamCapture(bool deviceContextChg = false) {
// Fill with Phi + i
for (size_t i = 0; i < N; i++) {
A_h[i] = 1.618f + i;
A_h[i] = 1.618f + i;
}
HIP_CHECK(hipMalloc(&A_d, Nbytes));
HIP_CHECK(hipMalloc(&C_d, Nbytes));
@@ -229,8 +216,8 @@ void GraphInstantiateWithFlags_StreamCapture(bool deviceContextChg = false) {
HIP_CHECK(hipMemcpyAsync(A_d, A_h, Nbytes, hipMemcpyHostToDevice, stream));
HIP_CHECK(hipMemsetAsync(C_d, 0, Nbytes, stream));
hipLaunchKernelGGL(HipTest::vector_square, dim3(blocks),
dim3(threadsPerBlock), 0, stream, A_d, C_d, N);
hipLaunchKernelGGL(HipTest::vector_square, dim3(blocks), dim3(threadsPerBlock), 0, stream, A_d,
C_d, N);
HIP_CHECK(hipMemcpyAsync(C_h, C_d, Nbytes, hipMemcpyDeviceToHost, stream));
HIP_CHECK(hipStreamEndCapture(stream, &graph));
@@ -366,14 +353,13 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_FlagAutoFreeOnLaunch_check") {
allocParam.poolProps.location.id = 0;
allocParam.poolProps.location.type = hipMemLocationTypeDevice;
HIP_CHECK(hipGraphAddMemAllocNode(&allocNodeA, graph, nullptr,
0, &allocParam));
HIP_CHECK(hipGraphAddMemAllocNode(&allocNodeA, graph, nullptr, 0, &allocParam));
REQUIRE(allocParam.dptr != nullptr);
int *A_d = reinterpret_cast<int *>(allocParam.dptr);
int* A_d = reinterpret_cast<int*>(allocParam.dptr);
// Instantiate with Flag and launch the graph
HIP_CHECK(hipGraphInstantiateWithFlags(&graphExec, graph,
hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(
hipGraphInstantiateWithFlags(&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(hipGraphLaunch(graphExec, stream));
HIP_CHECK(hipStreamSynchronize(stream));
@@ -425,7 +411,7 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_FlagAutoFreeOnLaunch_check") {
TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchInLoop") {
constexpr size_t NBytes = 1024 * 1024 * 1024;
void *devMem = nullptr;
void* devMem = nullptr;
hipStream_t stream;
HIP_CHECK(hipStreamCreate(&stream));
@@ -442,13 +428,12 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchInLoop") {
memAllocNodeParams.poolProps.location.id = 0;
memAllocNodeParams.bytesize = NBytes;
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0,
&memAllocNodeParams));
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0, &memAllocNodeParams));
devMem = memAllocNodeParams.dptr;
hipGraphExec_t graphExec;
HIP_CHECK(hipGraphInstantiateWithFlags(
&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(
hipGraphInstantiateWithFlags(&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
// Launch the graph in a loop
for (int i = 0; i < 100; i++) {
@@ -457,11 +442,11 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchInLoop") {
REQUIRE(devMem != nullptr);
#if HT_AMD
#if HT_AMD
size_t sizeToCheck = -1;
HIP_CHECK(hipMemPtrGetInfo(devMem, &sizeToCheck));
REQUIRE(sizeToCheck == NBytes);
#endif
#endif
}
HIP_CHECK(hipFree(devMem));
@@ -488,11 +473,11 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchInLoop") {
TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchFillKernel") {
int value = 100;
int *hostMemDst = new int[SIZE];
int* hostMemDst = new int[SIZE];
REQUIRE(hostMemDst != nullptr);
std::fill(hostMemDst, hostMemDst + SIZE, 0);
int *devMem = nullptr;
int* devMem = nullptr;
hipStream_t stream;
HIP_CHECK(hipStreamCreate(&stream));
@@ -509,49 +494,45 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchFillKernel") {
memAllocNodeParams.poolProps.location.id = 0;
memAllocNodeParams.bytesize = NBYTES;
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0,
&memAllocNodeParams));
devMem = reinterpret_cast<int *>(memAllocNodeParams.dptr);
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0, &memAllocNodeParams));
devMem = reinterpret_cast<int*>(memAllocNodeParams.dptr);
REQUIRE(devMem != nullptr);
::std::vector<hipGraphNode_t> kernelNodeDependencies;
kernelNodeDependencies.push_back(memAllocNode);
hipKernelNodeParams kernelNodeParams{};
kernelNodeParams.func = reinterpret_cast<void *>(fillKernel);
kernelNodeParams.func = reinterpret_cast<void*>(fillKernel);
kernelNodeParams.gridDim = dim3(1, 1, 1);
kernelNodeParams.blockDim = dim3(1, 1, 1);
kernelNodeParams.sharedMemBytes = 0;
int size = SIZE;
void *kernelArgs[3] = {reinterpret_cast<void *>(&devMem),
reinterpret_cast<void *>(&size),
reinterpret_cast<void *>(&value)};
void* kernelArgs[3] = {reinterpret_cast<void*>(&devMem), reinterpret_cast<void*>(&size),
reinterpret_cast<void*>(&value)};
kernelNodeParams.kernelParams = kernelArgs;
kernelNodeParams.extra = nullptr;
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph,
kernelNodeDependencies.data(), kernelNodeDependencies.size(),
&kernelNodeParams));
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph, kernelNodeDependencies.data(),
kernelNodeDependencies.size(), &kernelNodeParams));
::std::vector<hipGraphNode_t> memcpyNodeD2HDependencies;
memcpyNodeD2HDependencies.push_back(kernelNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph,
memcpyNodeD2HDependencies.data(), memcpyNodeD2HDependencies.size(),
hostMemDst, devMem, NBYTES, hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph, memcpyNodeD2HDependencies.data(),
memcpyNodeD2HDependencies.size(), hostMemDst, devMem, NBYTES,
hipMemcpyDeviceToHost));
hipGraphExec_t graphExec;
HIP_CHECK(hipGraphInstantiateWithFlags(
&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(
hipGraphInstantiateWithFlags(&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
for (int launch = 1; launch <= 10; launch++) {
HIP_CHECK(hipGraphLaunch(graphExec, stream));
HIP_CHECK(hipStreamSynchronize(stream));
for (int idx = 0; idx < SIZE; idx++) {
INFO("For Launch : " << launch << ", At index : " << idx <<
", Got value : " << hostMemDst[idx] <<
", Expected value : " << value << "\n");
INFO("For Launch : " << launch << ", At index : " << idx << ", Got value : "
<< hostMemDst[idx] << ", Expected value : " << value << "\n");
REQUIRE(hostMemDst[idx] == value);
}
}
@@ -583,13 +564,13 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchFillKernel") {
* - unit/graph/hipGraphInstantiateWithFlags.cc
*/
TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchDoubleKernel") {
int *hostMemSrc = new int[SIZE];
int* hostMemSrc = new int[SIZE];
REQUIRE(hostMemSrc != nullptr);
int *hostMemDst = new int[SIZE];
int* hostMemDst = new int[SIZE];
REQUIRE(hostMemDst != nullptr);
int *devMem = nullptr;
int* devMem = nullptr;
hipStream_t stream;
HIP_CHECK(hipStreamCreate(&stream));
@@ -606,47 +587,43 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchDoubleKernel") {
memAllocNodeParams.poolProps.location.id = 0;
memAllocNodeParams.bytesize = NBYTES;
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0,
&memAllocNodeParams));
devMem = reinterpret_cast<int *>(memAllocNodeParams.dptr);
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0, &memAllocNodeParams));
devMem = reinterpret_cast<int*>(memAllocNodeParams.dptr);
REQUIRE(devMem != nullptr);
::std::vector<hipGraphNode_t> memcpyNodeH2DDependencies;
memcpyNodeH2DDependencies.push_back(memAllocNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2D, graph,
memcpyNodeH2DDependencies.data(), memcpyNodeH2DDependencies.size(),
devMem, hostMemSrc, NBYTES, hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2D, graph, memcpyNodeH2DDependencies.data(),
memcpyNodeH2DDependencies.size(), devMem, hostMemSrc, NBYTES,
hipMemcpyHostToDevice));
::std::vector<hipGraphNode_t> kernelNodeDependencies;
kernelNodeDependencies.push_back(memcpyNodeH2D);
hipKernelNodeParams kernelNodeParams{};
kernelNodeParams.func = reinterpret_cast<void *>(doubleKernel);
kernelNodeParams.func = reinterpret_cast<void*>(doubleKernel);
kernelNodeParams.gridDim = dim3(1, 1, 1);
kernelNodeParams.blockDim = dim3(1, 1, 1);
kernelNodeParams.sharedMemBytes = 0;
int size = SIZE;
void *kernelArgs[2] = {reinterpret_cast<void *>(&devMem),
reinterpret_cast<void *>(&size)};
void* kernelArgs[2] = {reinterpret_cast<void*>(&devMem), reinterpret_cast<void*>(&size)};
kernelNodeParams.kernelParams = kernelArgs;
kernelNodeParams.extra = nullptr;
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph,
kernelNodeDependencies.data(), kernelNodeDependencies.size(),
&kernelNodeParams));
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph, kernelNodeDependencies.data(),
kernelNodeDependencies.size(), &kernelNodeParams));
::std::vector<hipGraphNode_t> memcpyNodeD2HDependencies;
memcpyNodeD2HDependencies.push_back(kernelNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(
&memcpyNodeD2H, graph, memcpyNodeD2HDependencies.data(),
memcpyNodeD2HDependencies.size(), hostMemDst, devMem, NBYTES,
hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph, memcpyNodeD2HDependencies.data(),
memcpyNodeD2HDependencies.size(), hostMemDst, devMem, NBYTES,
hipMemcpyDeviceToHost));
hipGraphExec_t graphExec;
HIP_CHECK(hipGraphInstantiateWithFlags(&graphExec, graph,
hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(
hipGraphInstantiateWithFlags(&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
for (int launch = 1; launch <= 10; launch++) {
std::fill(hostMemSrc, hostMemSrc + SIZE, launch);
@@ -656,10 +633,10 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchDoubleKernel") {
HIP_CHECK(hipStreamSynchronize(stream));
for (int idx = 0; idx < SIZE; idx++) {
INFO("For Launch : " << launch << ", At index : " << idx <<
", Got value : " << hostMemDst[idx] <<
", Expected value : " << (launch+launch) << "\n");
REQUIRE(hostMemDst[idx] == (launch+launch));
INFO("For Launch : " << launch << ", At index : " << idx
<< ", Got value : " << hostMemDst[idx]
<< ", Expected value : " << (launch + launch) << "\n");
REQUIRE(hostMemDst[idx] == (launch + launch));
}
}
@@ -693,7 +670,7 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchDoubleKernel") {
*/
TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchMultiProcess") {
int shmid = shmget(IPC_PRIVATE, NBYTES, 0666);
int *shared_mem = reinterpret_cast<int *>(shmat(shmid, NULL, 0));
int* shared_mem = reinterpret_cast<int*>(shmat(shmid, NULL, 0));
REQUIRE(shared_mem != nullptr);
std::fill(shared_mem, shared_mem + SIZE, 10);
@@ -704,8 +681,8 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchMultiProcess") {
REQUIRE(wait(NULL) >= 0);
for (int idx = 0; idx < SIZE; idx++) {
INFO("At index : " << idx << ", Got value : " << shared_mem[idx] <<
", Expected value : 20" << "\n");
INFO("At index : " << idx << ", Got value : " << shared_mem[idx] << ", Expected value : 20"
<< "\n");
REQUIRE(shared_mem[idx] == 20);
}
} else { // child process
@@ -718,7 +695,7 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchMultiProcess") {
HIP_CHECK(hipStreamCreate(&stream));
REQUIRE(stream != nullptr);
int *devMem = nullptr;
int* devMem = nullptr;
hipGraphNode_t memAllocNode, memcpyNodeH2D, kernelNode, memcpyNodeD2H;
@@ -729,48 +706,43 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchMultiProcess") {
memAllocNodeParams.poolProps.location.id = 0;
memAllocNodeParams.bytesize = NBYTES;
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0,
&memAllocNodeParams));
devMem = reinterpret_cast<int *>(memAllocNodeParams.dptr);
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph, nullptr, 0, &memAllocNodeParams));
devMem = reinterpret_cast<int*>(memAllocNodeParams.dptr);
REQUIRE(devMem != nullptr);
::std::vector<hipGraphNode_t> memcpyNodeH2DDependencies;
memcpyNodeH2DDependencies.push_back(memAllocNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2D, graph,
memcpyNodeH2DDependencies.data(),
memcpyNodeH2DDependencies.size(),
devMem, shared_mem, NBYTES, hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2D, graph, memcpyNodeH2DDependencies.data(),
memcpyNodeH2DDependencies.size(), devMem, shared_mem, NBYTES,
hipMemcpyHostToDevice));
::std::vector<hipGraphNode_t> kernelNodeDependencies;
kernelNodeDependencies.push_back(memcpyNodeH2D);
hipKernelNodeParams kernelNodeParams{};
kernelNodeParams.func = reinterpret_cast<void *>(doubleKernel);
kernelNodeParams.func = reinterpret_cast<void*>(doubleKernel);
kernelNodeParams.gridDim = dim3(1, 1, 1);
kernelNodeParams.blockDim = dim3(1, 1, 1);
kernelNodeParams.sharedMemBytes = 0;
int size = SIZE;
void *kernelArgs[2] = {reinterpret_cast<void *>(&devMem),
reinterpret_cast<void *>(&size)};
void* kernelArgs[2] = {reinterpret_cast<void*>(&devMem), reinterpret_cast<void*>(&size)};
kernelNodeParams.kernelParams = kernelArgs;
kernelNodeParams.extra = nullptr;
HIP_CHECK(hipGraphAddKernelNode(
&kernelNode, graph, kernelNodeDependencies.data(),
kernelNodeDependencies.size(), &kernelNodeParams));
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph, kernelNodeDependencies.data(),
kernelNodeDependencies.size(), &kernelNodeParams));
::std::vector<hipGraphNode_t> memcpyNodeD2HDependencies;
memcpyNodeD2HDependencies.push_back(kernelNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph,
memcpyNodeD2HDependencies.data(),
memcpyNodeD2HDependencies.size(),
shared_mem, devMem, NBYTES, hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph, memcpyNodeD2HDependencies.data(),
memcpyNodeD2HDependencies.size(), shared_mem, devMem, NBYTES,
hipMemcpyDeviceToHost));
hipGraphExec_t graphExec;
HIP_CHECK(hipGraphInstantiateWithFlags(
&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(
hipGraphInstantiateWithFlags(&graphExec, graph, hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(hipGraphLaunch(graphExec, stream));
HIP_CHECK(hipStreamSynchronize(stream));
@@ -808,13 +780,13 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_AutoFreeOnLaunchMultiProcess") {
* - unit/graph/hipGraphInstantiateWithFlags.cc
*/
TEST_CASE("Unit_hipGraphInstantiateWithFlags_WithDefaultAndAutoFreeOnLaunch") {
int *hostMem1 = new int[SIZE];
int* hostMem1 = new int[SIZE];
REQUIRE(hostMem1 != nullptr);
int *hostMem2 = new int[SIZE];
int* hostMem2 = new int[SIZE];
REQUIRE(hostMem2 != nullptr);
int *hostMem3 = new int[SIZE];
int* hostMem3 = new int[SIZE];
REQUIRE(hostMem3 != nullptr);
int *devMem = nullptr;
int* devMem = nullptr;
hipStream_t stream1, stream2;
HIP_CHECK(hipStreamCreate(&stream1));
@@ -826,8 +798,8 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_WithDefaultAndAutoFreeOnLaunch") {
// Prepare graph1, graphExec1
hipGraphNode_t memcpyNodeH2H;
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2H, graph1, nullptr, 0,
hostMem2, hostMem1, NBYTES, hipMemcpyHostToHost));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2H, graph1, nullptr, 0, hostMem2, hostMem1, NBYTES,
hipMemcpyHostToHost));
hipGraphExec_t graphExec1;
HIP_CHECK(hipGraphInstantiateWithFlags(&graphExec1, graph1, 0));
@@ -841,46 +813,43 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_WithDefaultAndAutoFreeOnLaunch") {
memAllocNodeParams.poolProps.location.id = 0;
memAllocNodeParams.bytesize = NBYTES;
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph2, nullptr, 0,
&memAllocNodeParams));
devMem = reinterpret_cast<int *>(memAllocNodeParams.dptr);
HIP_CHECK(hipGraphAddMemAllocNode(&memAllocNode, graph2, nullptr, 0, &memAllocNodeParams));
devMem = reinterpret_cast<int*>(memAllocNodeParams.dptr);
REQUIRE(devMem != nullptr);
::std::vector<hipGraphNode_t> memcpyNodeH2DDependencies;
memcpyNodeH2DDependencies.push_back(memAllocNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2D, graph2,
memcpyNodeH2DDependencies.data(), memcpyNodeH2DDependencies.size(),
devMem, hostMem2, NBYTES, hipMemcpyHostToDevice));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeH2D, graph2, memcpyNodeH2DDependencies.data(),
memcpyNodeH2DDependencies.size(), devMem, hostMem2, NBYTES,
hipMemcpyHostToDevice));
::std::vector<hipGraphNode_t> kernelNodeDependencies;
kernelNodeDependencies.push_back(memcpyNodeH2D);
hipKernelNodeParams kernelNodeParams{};
kernelNodeParams.func = reinterpret_cast<void *>(doubleKernel);
kernelNodeParams.func = reinterpret_cast<void*>(doubleKernel);
kernelNodeParams.gridDim = dim3(1, 1, 1);
kernelNodeParams.blockDim = dim3(1, 1, 1);
kernelNodeParams.sharedMemBytes = 0;
int size = SIZE;
void *kernelArgs[2] = {reinterpret_cast<void *>(&devMem),
reinterpret_cast<void *>(&size)};
void* kernelArgs[2] = {reinterpret_cast<void*>(&devMem), reinterpret_cast<void*>(&size)};
kernelNodeParams.kernelParams = kernelArgs;
kernelNodeParams.extra = nullptr;
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph2,
kernelNodeDependencies.data(), kernelNodeDependencies.size(),
&kernelNodeParams));
HIP_CHECK(hipGraphAddKernelNode(&kernelNode, graph2, kernelNodeDependencies.data(),
kernelNodeDependencies.size(), &kernelNodeParams));
::std::vector<hipGraphNode_t> memcpyNodeD2HDependencies;
memcpyNodeD2HDependencies.push_back(kernelNode);
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph2,
memcpyNodeD2HDependencies.data(), memcpyNodeD2HDependencies.size(),
hostMem3, devMem, NBYTES, hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphAddMemcpyNode1D(&memcpyNodeD2H, graph2, memcpyNodeD2HDependencies.data(),
memcpyNodeD2HDependencies.size(), hostMem3, devMem, NBYTES,
hipMemcpyDeviceToHost));
hipGraphExec_t graphExec2;
HIP_CHECK(hipGraphInstantiateWithFlags(&graphExec2, graph2,
hipGraphInstantiateFlagAutoFreeOnLaunch));
HIP_CHECK(
hipGraphInstantiateWithFlags(&graphExec2, graph2, hipGraphInstantiateFlagAutoFreeOnLaunch));
for (int launch = 1; launch <= 10; launch++) {
std::fill(hostMem1, hostMem1 + SIZE, launch);
@@ -894,10 +863,9 @@ TEST_CASE("Unit_hipGraphInstantiateWithFlags_WithDefaultAndAutoFreeOnLaunch") {
HIP_CHECK(hipStreamSynchronize(stream2));
for (int idx = 0; idx < SIZE; idx++) {
INFO("For Launch : " << launch << ", At index : " << idx <<
", Got value : " << hostMem3[idx] <<
", Expected value : " << (launch+launch) << "\n");
REQUIRE(hostMem3[idx] == (launch+launch));
INFO("For Launch : " << launch << ", At index : " << idx << ", Got value : " << hostMem3[idx]
<< ", Expected value : " << (launch + launch) << "\n");
REQUIRE(hostMem3[idx] == (launch + launch));
}
}