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/hipGraphExecMemcpyNodeSetParamsFromSymbol_old.cc
+69 -131
View File
@@ -34,9 +34,9 @@ Negative
5) Pass count as zero, api expected to return error code.
6) Pass offset+count greater than allocated size, api expected to return error code.
7) Pass same symbol pointer as source ptr and destination ptr, api expected to return error code.
8) Pass Pass both dstn ptr and source ptr as 2 different symbol ptr, api expected to return error code.
9) Copy from device ptr to host ptr but pass kind as different, api expected to return error code.
10) Check with other graph node but pass same graphExec, api expected to return error code.
8) Pass Pass both dstn ptr and source ptr as 2 different symbol ptr, api expected to return error
code. 9) Copy from device ptr to host ptr but pass kind as different, api expected to return error
code. 10) Check with other graph node but pass same graphExec, api expected to return error code.
*/
#include <hip_test_common.hh>
@@ -55,8 +55,7 @@ TEST_CASE("Unit_hipGraphExecMemcpyNodeSetParamsFromSymbol_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);
hipError_t ret;
hipGraph_t graph;
@@ -66,134 +65,95 @@ TEST_CASE("Unit_hipGraphExecMemcpyNodeSetParamsFromSymbol_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,
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_h,
HIP_SYMBOL(globalConst),
Nbytes, 0,
hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphMemcpyNodeSetParamsFromSymbol(memcpyFromSymbolNode,
B_d,
HIP_SYMBOL(globalIn),
Nbytes, 0,
hipMemcpyDeviceToDevice));
HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
dependencies.size(), B_h, HIP_SYMBOL(globalConst),
Nbytes, 0, hipMemcpyDeviceToHost));
HIP_CHECK(hipGraphMemcpyNodeSetParamsFromSymbol(memcpyFromSymbolNode, B_d, HIP_SYMBOL(globalIn),
Nbytes, 0, hipMemcpyDeviceToDevice));
// Instantiate the graph
HIP_CHECK(hipGraphInstantiate(&graphExec, graph, nullptr, nullptr, 0));
SECTION("Pass hGraphExec as nullptr") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(nullptr,
memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(nullptr, memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst), Nbytes, 0,
hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Pass GraphNode as nullptr") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
nullptr, B_d,
HIP_SYMBOL(globalConst),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(
graphExec, nullptr, B_d, HIP_SYMBOL(globalConst), Nbytes, 0, hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Pass destination ptr as nullptr") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode, nullptr,
HIP_SYMBOL(globalConst),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, nullptr,
HIP_SYMBOL(globalConst), Nbytes, 0,
hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Pass symbol ptr as nullptr") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode, B_d,
nullptr,
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, B_d, nullptr,
Nbytes, 0, hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidSymbol == ret);
}
SECTION("Pass count as zero") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst),
0, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst), 0, 0,
hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Pass offset+count greater than allocated size") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst),
Nbytes, 10,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst), Nbytes, 10,
hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Pass same symbol pointer as source and destination ptr") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode,
HIP_SYMBOL(globalIn),
HIP_SYMBOL(globalIn),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode,
HIP_SYMBOL(globalIn), HIP_SYMBOL(globalIn),
Nbytes, 0, hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Pass both dstn ptr and source ptr as 2 different symbol ptr") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode,
HIP_SYMBOL(globalIn),
HIP_SYMBOL(globalOut),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode,
HIP_SYMBOL(globalIn), HIP_SYMBOL(globalOut),
Nbytes, 0, hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
SECTION("Copy from device ptr to host ptr but pass kind as different") {
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode,
B_h,
HIP_SYMBOL(globalOut),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, B_h,
HIP_SYMBOL(globalOut), Nbytes, 0,
hipMemcpyDeviceToDevice);
REQUIRE(hipSuccess != ret);
}
SECTION("Check with other graph node") {
hipGraphNode_t memcpyFromSymbolNode1{};
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode1,
B_d,
HIP_SYMBOL(globalOut),
Nbytes, 0,
hipMemcpyDeviceToDevice);
ret = hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode1, B_d,
HIP_SYMBOL(globalOut), Nbytes, 0,
hipMemcpyDeviceToDevice);
REQUIRE(hipErrorInvalidValue == ret);
}
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));
}
static
void hipGraphExecMemcpyNodeSetParamsFromSymbol_GlobalMem(bool useConstVar) {
static void hipGraphExecMemcpyNodeSetParamsFromSymbol_GlobalMem(bool useConstVar) {
constexpr size_t Nbytes = SIZE * sizeof(int);
hipGraphNode_t memcpyD2H_B;
int *A_d{nullptr}, *B_d{nullptr}, *C_d{nullptr};
int *A_h{nullptr}, *B_h{nullptr};
HipTest::initArrays<int>(&A_d, &B_d, &C_d,
&A_h, &B_h, nullptr, SIZE, false);
HipTest::initArrays<int>(&A_d, &B_d, &C_d, &A_h, &B_h, nullptr, SIZE, false);
hipGraph_t graph;
hipGraphExec_t graphExec;
@@ -202,71 +162,50 @@ void hipGraphExecMemcpyNodeSetParamsFromSymbol_GlobalMem(bool useConstVar) {
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);
if (useConstVar) {
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);
if (useConstVar) {
HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
dependencies.data(),
dependencies.size(),
C_d,
HIP_SYMBOL(globalConst),
Nbytes, 0,
hipMemcpyDeviceToDevice));
HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
dependencies.size(), C_d, HIP_SYMBOL(globalConst),
Nbytes, 0, hipMemcpyDeviceToDevice));
} else {
HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph,
dependencies.data(),
dependencies.size(),
C_d,
HIP_SYMBOL(globalIn),
Nbytes, 0,
hipMemcpyDeviceToDevice));
HIP_CHECK(hipGraphAddMemcpyNodeFromSymbol(&memcpyFromSymbolNode, graph, dependencies.data(),
dependencies.size(), C_d, HIP_SYMBOL(globalIn),
Nbytes, 0, hipMemcpyDeviceToDevice));
}
dependencies.clear();
dependencies.push_back(memcpyFromSymbolNode);
// 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));
// Update the node with B_d destination pointer from C_d
if (useConstVar) {
HIP_CHECK(hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode,
B_d,
HIP_SYMBOL(globalConst),
Nbytes, 0,
hipMemcpyDeviceToDevice));
HIP_CHECK(hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalConst), Nbytes, 0,
hipMemcpyDeviceToDevice));
} else {
HIP_CHECK(hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec,
memcpyFromSymbolNode,
B_d,
HIP_SYMBOL(globalIn),
Nbytes, 0,
hipMemcpyDeviceToDevice));
HIP_CHECK(hipGraphExecMemcpyNodeSetParamsFromSymbol(graphExec, memcpyFromSymbolNode, B_d,
HIP_SYMBOL(globalIn), Nbytes, 0,
hipMemcpyDeviceToDevice));
}
HIP_CHECK(hipGraphLaunch(graphExec, 0));
@@ -275,13 +214,12 @@ void hipGraphExecMemcpyNodeSetParamsFromSymbol_GlobalMem(bool useConstVar) {
// 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, C_d,
A_h, B_h, nullptr, false);
HipTest::freeArrays<int>(A_d, B_d, C_d, A_h, B_h, nullptr, false);
HIP_CHECK(hipGraphExecDestroy(graphExec));
HIP_CHECK(hipGraphDestroy(graph));
}