EXSWHTEC-98 - Implement tests for hipMemcpy3D APIs (#55)
- Implement tests for hipMemcpy3D APIs
- Implement basic behavior checks in all copy directions
- Implement synchronization behavior checks for expected behavior based on cuda docs
- Implement positive tests for zero sized width and/or height copies, where no copy is expected to happen
- Implement negative parameter tests
- Implement all of the above for hipMemcpy3D and hipMemcpy3DAsync.
- Disable failing tests on AMD.
- Fix copyright disclaimer.
[ROCm/hip-tests commit: 113a36c0eb]
This commit is contained in:
Mirza Halilčević
GitHub
@@ -29,7 +29,9 @@ set(TEST_SRC
|
||||
hipMemcpy2DToArrayAsync.cc
|
||||
hipMemcpy2DToArrayAsync_old.cc
|
||||
hipMemcpy3D.cc
|
||||
hipMemcpy3D_old.cc
|
||||
hipMemcpy3DAsync.cc
|
||||
hipMemcpy3DAsync_old.cc
|
||||
hipMemcpyParam2D.cc
|
||||
hipMemcpyParam2DAsync.cc
|
||||
hipMemcpy2D.cc
|
||||
|
||||
@@ -1,13 +1,16 @@
|
||||
/*
|
||||
Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
|
||||
Copyright (c) 2022 Advanced Micro Devices, Inc. All rights reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
@@ -17,611 +20,209 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This testfile verifies the following scenarios of hipMemcpy3D API
|
||||
*
|
||||
* 1. Verifying hipMemcpy3D API for H2D,D2D and D2H scenarios for
|
||||
different datatypes and sizes.
|
||||
* 2. Verifying Negative Scenarios
|
||||
* 3. Verifying Extent validation scenarios by passing 0
|
||||
* 4. Verifying hipMemcpy3D API by allocating Memory in
|
||||
* one GPU and trigger hipMemcpy3D from peer GPU
|
||||
*
|
||||
*/
|
||||
#include <memcpy1d_tests_common.hh>
|
||||
#include <memcpy3d_tests_common.hh>
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include <hip_test_checkers.hh>
|
||||
#include <hip/hip_runtime_api.h>
|
||||
#include <resource_guards.hh>
|
||||
#include <utils.hh>
|
||||
|
||||
static constexpr auto width{10};
|
||||
static constexpr auto height{10};
|
||||
static constexpr auto depth{10};
|
||||
TEST_CASE("Unit_hipMemcpy3D_Positive_Basic") {
|
||||
constexpr bool async = false;
|
||||
|
||||
template <typename T>
|
||||
class Memcpy3D {
|
||||
int width, height, depth;
|
||||
unsigned int size;
|
||||
hipArray *arr, *arr1;
|
||||
hipChannelFormatKind formatKind;
|
||||
hipMemcpy3DParms myparms;
|
||||
T* hData;
|
||||
public:
|
||||
Memcpy3D(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format);
|
||||
void simple_Memcpy3D();
|
||||
void Extent_Validation();
|
||||
void NegativeTests();
|
||||
void AllocateMemory();
|
||||
void DeAllocateMemory();
|
||||
void SetDefaultData();
|
||||
void D2D_DeviceMem_OnDiffDevice();
|
||||
void D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
};
|
||||
SECTION("Device to Host") { Memcpy3DDeviceToHostShell<async>(Memcpy3DWrapper<>); }
|
||||
|
||||
/*
|
||||
* This API sets the default values of hipMemcpy3DParms structure
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::SetDefaultData() {
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
}
|
||||
|
||||
/*
|
||||
* Constructor initalized width,depth and height
|
||||
*/
|
||||
template <typename T>
|
||||
Memcpy3D<T>::Memcpy3D(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format) {
|
||||
width = l_width;
|
||||
height = l_height;
|
||||
depth = l_depth;
|
||||
formatKind = l_format;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocating Memory and initalizing data for both
|
||||
* device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::AllocateMemory() {
|
||||
size = width * height * depth * sizeof(T);
|
||||
hData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hData, 0, size);
|
||||
for (int i = 0; i < depth; i++) {
|
||||
for (int j = 0; j < height; j++) {
|
||||
for (int k = 0; k < width; k++) {
|
||||
hData[i*width*height + j*width +k] = i*width*height + j*width + k;
|
||||
}
|
||||
SECTION("Device to Device") {
|
||||
SECTION("Peer access disabled") {
|
||||
Memcpy3DDeviceToDeviceShell<async, false>(Memcpy3DWrapper<>);
|
||||
}
|
||||
SECTION("Peer access enabled") { Memcpy3DDeviceToDeviceShell<async, true>(Memcpy3DWrapper<>); }
|
||||
}
|
||||
hipChannelFormatDesc channelDesc = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
HIP_CHECK(hipMalloc3DArray(&arr1, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
|
||||
SECTION("Host to Device") { Memcpy3DHostToDeviceShell<async>(Memcpy3DWrapper<>); }
|
||||
|
||||
SECTION("Host to Host") { Memcpy3DHostToHostShell<async>(Memcpy3DWrapper<>); }
|
||||
}
|
||||
|
||||
/*
|
||||
* DeAllocates the Memory of device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::DeAllocateMemory() {
|
||||
HIP_CHECK(hipFreeArray(arr));
|
||||
HIP_CHECK(hipFreeArray(arr1));
|
||||
free(hData);
|
||||
TEST_CASE("Unit_hipMemcpy3D_Positive_Synchronization_Behavior") {
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
SECTION("Host to Device") { Memcpy3DHtoDSyncBehavior(Memcpy3DWrapper<>, true); }
|
||||
|
||||
SECTION("Device to Pageable Host") { Memcpy3DDtoHPageableSyncBehavior(Memcpy3DWrapper<>, true); }
|
||||
|
||||
SECTION("Device to Pinned Host") { Memcpy3DDtoHPinnedSyncBehavior(Memcpy3DWrapper<>, true); }
|
||||
|
||||
SECTION("Device to Device") {
|
||||
#if HT_NVIDIA
|
||||
Memcpy3DDtoDSyncBehavior(Memcpy3DWrapper<>, false);
|
||||
#else
|
||||
Memcpy3DDtoDSyncBehavior(Memcpy3DWrapper<>, true);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-232
|
||||
SECTION("Host to Host") { Memcpy3DHtoHSyncBehavior(Memcpy3DWrapper<>, true); }
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both H2D & D2H functionalities of hipMemcpy3D API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3D API
|
||||
* from another GPU.
|
||||
* H2D case:
|
||||
* Input : "hData" is initialized with the respective offset value
|
||||
* Output: Destination array "arr" variable.
|
||||
*
|
||||
* D2H case:
|
||||
* Input: "arr" array variable from the above output
|
||||
* Output: "hOutputData" variable data is copied from "arr" variable
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::D2H_H2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 1, 0));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
// Memory is allocated on device 0 and Memcpy3DAsync triggered from device 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
|
||||
// H2D Scenario
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access\n");
|
||||
}
|
||||
}
|
||||
/*
|
||||
* This API verifies both D2D functionalities of hipMemcpy3D API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3D API
|
||||
* from another GPU.
|
||||
*
|
||||
* D2D case:
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr2" variable in GPU-0
|
||||
*
|
||||
* hipMemcpy3D API is triggered from GPU-1
|
||||
* The "arr2" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::D2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 0, 1));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to device copy
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
|
||||
// Allocating Mem on GPU device 0 and trigger hipMemcpy3D from GPU 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
|
||||
// D2D Scenario
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
// For validating the D2D copy copying it again to hOutputData and
|
||||
// verifying it with iniital data hData
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
|
||||
// Device to host
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// DeAllocating Memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access\n");
|
||||
}
|
||||
}
|
||||
/*
|
||||
* This API verifies all the negative scenarios of hipMemcpy3D API
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::NegativeTests() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
|
||||
// Initialization of data
|
||||
memset(&myparms, 0, sizeof(myparms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
|
||||
SECTION("Nullptr to destination array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = nullptr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Nullptr to source array") {
|
||||
myparms.srcArray = nullptr;
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both Source ptr and array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both destination ptr and array") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcArray = arr1;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Max value to extent") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.extent = make_hipExtent(std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max());
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Source pitchedPtr as nullptr") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Dst pitchedPtr as nullptr") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing width > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width+1 , height, depth);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing hgt > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height+1, depth);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing depth > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst width pos > max allocated width") {
|
||||
myparms.dstPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst height pos > max allocated hgt") {
|
||||
myparms.dstPos = make_hipPos(0, height+1, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst depth pos > max allocated depth") {
|
||||
myparms.dstPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src width pos > max allocated width") {
|
||||
myparms.srcPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, height+1, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src array size > dst array size") {
|
||||
// Passing src array size greater than destination array size
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(3, 3
|
||||
, 3), hipArrayDefault));
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
// DeAllocation of memory
|
||||
DeAllocateMemory();
|
||||
TEST_CASE("Unit_hipMemcpy3D_Positive_Parameters") {
|
||||
constexpr bool async = false;
|
||||
Memcpy3DZeroWidthHeightDepth<async>(Memcpy3DWrapper<async>);
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies the Extent validation Scenarios
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::Extent_Validation() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
TEST_CASE("Unit_hipMemcpy3D_Positive_Array") {
|
||||
constexpr bool async = false;
|
||||
SECTION("Array from/to Host") { Memcpy3DArrayHostShell<async>(Memcpy3DWrapper<async>); }
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-238
|
||||
SECTION("Array from/to Device") { Memcpy3DArrayDeviceShell<async>(Memcpy3DWrapper<async>); }
|
||||
#endif
|
||||
SECTION("Passing Extent as 0") {
|
||||
myparms.extent = make_hipExtent(0 , 0, 0);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Width 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(0 , height, depth);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Height 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , 0, depth);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Depth 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , height, 0);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Depth 0 in Extent") {
|
||||
REQUIRE(hipMemcpy3D(nullptr) != hipSuccess);
|
||||
}
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies H2H-D2D-D2H functionalities of hipMemcpy3D API
|
||||
*
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr1" variable in GPU-0
|
||||
*
|
||||
* The "arr1" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_Negative_Parameters") {
|
||||
constexpr hipExtent extent{128 * sizeof(int), 128, 8};
|
||||
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::simple_Memcpy3D() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
|
||||
// Host to Device
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
|
||||
// Array to Array
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T), width, height);
|
||||
myparms.srcArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// DeAllocating the Memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
}
|
||||
/*
|
||||
This testcase performs hipMemcpy3D API validation for
|
||||
different datatypes and different sizes
|
||||
*/
|
||||
TEMPLATE_TEST_CASE("Unit_hipMemcpy3D_Basic", "[hipMemcpy3D]",
|
||||
int, unsigned int, float) {
|
||||
int device = -1;
|
||||
HIP_CHECK(hipGetDevice(&device));
|
||||
hipDeviceProp_t prop;
|
||||
HIP_CHECK(hipGetDeviceProperties(&prop,device));
|
||||
auto i = GENERATE_COPY(10, 100, 1024, prop.maxTexture3D[0]);
|
||||
auto j = GENERATE(10, 100);
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
if (std::is_same<TestType, float>::value) {
|
||||
Memcpy3D<TestType> memcpy3d_obj(i, j, j, hipChannelFormatKindFloat);
|
||||
memcpy3d_obj.simple_Memcpy3D();
|
||||
} else if (std::is_same<TestType, unsigned int>::value) {
|
||||
Memcpy3D<TestType> memcpy3d_obj(i, j, j, hipChannelFormatKindUnsigned);
|
||||
memcpy3d_obj.simple_Memcpy3D();
|
||||
} else if (std::is_same<TestType, int>::value) {
|
||||
Memcpy3D<TestType> memcpy3d_obj(i, j, j, hipChannelFormatKindSigned);
|
||||
memcpy3d_obj.simple_Memcpy3D();
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the extent validation scenarios of
|
||||
hipMemcpy3D API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_ExtentValidation") {
|
||||
Memcpy3D<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.Extent_Validation();
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the negative scenarios of
|
||||
hipMemcpy3D API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_multiDevice-Negative") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
Memcpy3D<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.NegativeTests();
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the D2H,H2D and D2D on peer
|
||||
GPU device
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_multiDevice-OnPeerDevice") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
SECTION("D2H & H2D On DiffDevice") {
|
||||
Memcpy3D<float> memcpy3d_d2h_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2h_obj.D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
constexpr auto NegativeTests = [](hipPitchedPtr dst_ptr, hipPos dst_pos, hipPitchedPtr src_ptr,
|
||||
hipPos src_pos, hipExtent extent, hipMemcpyKind kind) {
|
||||
SECTION("dst_ptr.ptr == nullptr") {
|
||||
hipPitchedPtr invalid_ptr = dst_ptr;
|
||||
invalid_ptr.ptr = nullptr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(invalid_ptr, dst_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("D2D On DiffDevice") {
|
||||
Memcpy3D<float> memcpy3d_d2d_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2d_obj.D2D_DeviceMem_OnDiffDevice();
|
||||
SECTION("src_ptr.ptr == nullptr") {
|
||||
hipPitchedPtr invalid_ptr = src_ptr;
|
||||
invalid_ptr.ptr = nullptr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, invalid_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-239
|
||||
SECTION("dst_ptr.pitch < width") {
|
||||
hipPitchedPtr invalid_ptr = dst_ptr;
|
||||
invalid_ptr.pitch = extent.width - 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(invalid_ptr, dst_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidPitchValue);
|
||||
}
|
||||
|
||||
SECTION("src_ptr.pitch < width") {
|
||||
hipPitchedPtr invalid_ptr = src_ptr;
|
||||
invalid_ptr.pitch = extent.width - 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, invalid_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidPitchValue);
|
||||
}
|
||||
#endif
|
||||
|
||||
SECTION("dst_ptr.pitch > max pitch") {
|
||||
int attr = 0;
|
||||
HIP_CHECK(hipDeviceGetAttribute(&attr, hipDeviceAttributeMaxPitch, 0));
|
||||
hipPitchedPtr invalid_ptr = dst_ptr;
|
||||
invalid_ptr.pitch = attr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(invalid_ptr, dst_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("src_ptr.pitch > max pitch") {
|
||||
int attr = 0;
|
||||
HIP_CHECK(hipDeviceGetAttribute(&attr, hipDeviceAttributeMaxPitch, 0));
|
||||
hipPitchedPtr invalid_ptr = src_ptr;
|
||||
invalid_ptr.pitch = attr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, invalid_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-237
|
||||
SECTION("extent.width + dst_pos.x > dst_ptr.pitch") {
|
||||
hipPos invalid_pos = dst_pos;
|
||||
invalid_pos.x = dst_ptr.pitch - extent.width + 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, invalid_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("extent.width + src_pos.x > src_ptr.pitch") {
|
||||
hipPos invalid_pos = src_pos;
|
||||
invalid_pos.x = src_ptr.pitch - extent.width + 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, src_ptr, invalid_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("dst_pos.y out of bounds") {
|
||||
hipPos invalid_pos = dst_pos;
|
||||
invalid_pos.y = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, invalid_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("src_pos.y out of bounds") {
|
||||
hipPos invalid_pos = src_pos;
|
||||
invalid_pos.y = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, src_ptr, invalid_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("dst_pos.z out of bounds") {
|
||||
hipPos invalid_pos = dst_pos;
|
||||
invalid_pos.z = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, invalid_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("src_pos.z out of bounds") {
|
||||
hipPos invalid_pos = src_pos;
|
||||
invalid_pos.z = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, src_ptr, invalid_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if HT_NVIDIA // Disable on AMD due to defect - EXSWHTEC-234
|
||||
SECTION("Invalid MemcpyKind") {
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper(dst_ptr, dst_pos, src_ptr, src_pos, extent,
|
||||
static_cast<hipMemcpyKind>(-1)),
|
||||
hipErrorInvalidMemcpyDirection);
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
SECTION("Host to Device") {
|
||||
LinearAllocGuard3D<int> device_alloc(extent);
|
||||
LinearAllocGuard<int> host_alloc(
|
||||
LinearAllocs::hipHostMalloc,
|
||||
device_alloc.pitch() * device_alloc.height() * device_alloc.depth());
|
||||
NegativeTests(device_alloc.pitched_ptr(), make_hipPos(0, 0, 0),
|
||||
make_hipPitchedPtr(host_alloc.ptr(), device_alloc.pitch(), device_alloc.width(),
|
||||
device_alloc.height()),
|
||||
make_hipPos(0, 0, 0), extent, hipMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
SECTION("Device to Host") {
|
||||
LinearAllocGuard3D<int> device_alloc(extent);
|
||||
LinearAllocGuard<int> host_alloc(
|
||||
LinearAllocs::hipHostMalloc,
|
||||
device_alloc.pitch() * device_alloc.height() * device_alloc.depth());
|
||||
NegativeTests(make_hipPitchedPtr(host_alloc.ptr(), device_alloc.pitch(), device_alloc.width(),
|
||||
device_alloc.height()),
|
||||
make_hipPos(0, 0, 0), device_alloc.pitched_ptr(), make_hipPos(0, 0, 0), extent,
|
||||
hipMemcpyDeviceToHost);
|
||||
}
|
||||
|
||||
SECTION("Host to Host") {
|
||||
LinearAllocGuard<int> src_alloc(LinearAllocs::hipHostMalloc,
|
||||
extent.width * extent.height * extent.depth);
|
||||
LinearAllocGuard<int> dst_alloc(LinearAllocs::hipHostMalloc,
|
||||
extent.width * extent.height * extent.depth);
|
||||
NegativeTests(make_hipPitchedPtr(dst_alloc.ptr(), extent.width, extent.width, extent.height),
|
||||
make_hipPos(0, 0, 0),
|
||||
make_hipPitchedPtr(src_alloc.ptr(), extent.width, extent.width, extent.height),
|
||||
make_hipPos(0, 0, 0), extent, hipMemcpyHostToHost);
|
||||
}
|
||||
|
||||
SECTION("Device to Device") {
|
||||
LinearAllocGuard3D<int> src_alloc(extent);
|
||||
LinearAllocGuard3D<int> dst_alloc(extent);
|
||||
NegativeTests(dst_alloc.pitched_ptr(), make_hipPos(0, 0, 0), src_alloc.pitched_ptr(),
|
||||
make_hipPos(0, 0, 0), extent, hipMemcpyDeviceToDevice);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,13 +1,16 @@
|
||||
/*
|
||||
Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
|
||||
Copyright (c) 2022 Advanced Micro Devices, Inc. All rights reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
@@ -17,739 +20,228 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This testfile verifies the following Scenarios of hipMemcpy3DAsync API
|
||||
|
||||
* 1. Verifying hipMemcpy3DAsync API for H2D,D2D and D2H scenarios
|
||||
* 2. Verifying Negative Scenarios
|
||||
* 3. Verifying Extent validation scenarios by passing 0
|
||||
* 4. Verifying hipMemcpy3DAsync API by allocating Memory in
|
||||
* one GPU and trigger hipMemcpy3D from peer GPU
|
||||
* 5. D2D where src and dst memory on GPU-0 and stream on GPU-1
|
||||
*/
|
||||
#include <memcpy1d_tests_common.hh>
|
||||
#include <memcpy3d_tests_common.hh>
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include <hip_test_checkers.hh>
|
||||
#include <hip/hip_runtime_api.h>
|
||||
#include <resource_guards.hh>
|
||||
#include <utils.hh>
|
||||
|
||||
static constexpr auto width{10};
|
||||
static constexpr auto height{10};
|
||||
static constexpr auto depth{10};
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_Positive_Basic") {
|
||||
constexpr bool async = true;
|
||||
|
||||
template <typename T>
|
||||
class Memcpy3DAsync {
|
||||
int width, height, depth;
|
||||
unsigned int size;
|
||||
hipArray *arr, *arr1;
|
||||
hipChannelFormatKind formatKind;
|
||||
hipMemcpy3DParms myparms;
|
||||
T* hData;
|
||||
hipStream_t stream;
|
||||
public:
|
||||
Memcpy3DAsync(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format);
|
||||
void simple_Memcpy3DAsync();
|
||||
void Extent_Validation();
|
||||
void NegativeTests();
|
||||
void AllocateMemory();
|
||||
void DeAllocateMemory();
|
||||
void SetDefaultData();
|
||||
void D2D_SameDeviceMem_StreamDiffDevice();
|
||||
void D2D_DeviceMem_OnDiffDevice();
|
||||
void D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
};
|
||||
const auto stream_type = GENERATE(Streams::nullstream, Streams::perThread, Streams::created);
|
||||
const StreamGuard stream_guard(stream_type);
|
||||
const hipStream_t stream = stream_guard.stream();
|
||||
|
||||
/*
|
||||
* This API sets the default values of hipMemcpy3DParms structure
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::SetDefaultData() {
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
}
|
||||
SECTION("Device to Host") { Memcpy3DDeviceToHostShell<async>(Memcpy3DWrapper<async>, stream); }
|
||||
|
||||
/*
|
||||
* Constructor initalized width,depth and height
|
||||
*/
|
||||
template <typename T>
|
||||
Memcpy3DAsync<T>::Memcpy3DAsync(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format) {
|
||||
width = l_width;
|
||||
height = l_height;
|
||||
depth = l_depth;
|
||||
formatKind = l_format;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocating Memory and initalizing data for both
|
||||
* device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::AllocateMemory() {
|
||||
size = width * height * depth * sizeof(T);
|
||||
hData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hData, 0, size);
|
||||
for (int i = 0; i < depth; i++) {
|
||||
for (int j = 0; j < height; j++) {
|
||||
for (int k = 0; k < width; k++) {
|
||||
hData[i*width*height + j*width +k] = i*width*height + j*width + k;
|
||||
}
|
||||
SECTION("Device to Device") {
|
||||
SECTION("Peer access disabled") {
|
||||
Memcpy3DDeviceToDeviceShell<async, false>(Memcpy3DWrapper<async>, stream);
|
||||
}
|
||||
SECTION("Peer access enabled") {
|
||||
Memcpy3DDeviceToDeviceShell<async, true>(Memcpy3DWrapper<async>, stream);
|
||||
}
|
||||
}
|
||||
hipChannelFormatDesc channelDesc = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
HIP_CHECK(hipMalloc3DArray(&arr1, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
|
||||
SECTION("Host to Device") { Memcpy3DHostToDeviceShell<async>(Memcpy3DWrapper<async>, stream); }
|
||||
|
||||
SECTION("Host to Host") { Memcpy3DHostToHostShell<async>(Memcpy3DWrapper<async>, stream); }
|
||||
}
|
||||
|
||||
/*
|
||||
* DeAllocates the Memory of device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::DeAllocateMemory() {
|
||||
HIP_CHECK(hipFreeArray(arr));
|
||||
HIP_CHECK(hipFreeArray(arr1));
|
||||
free(hData);
|
||||
HIP_CHECK(hipStreamDestroy(stream));
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_Positive_Synchronization_Behavior") {
|
||||
constexpr bool async = true;
|
||||
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
SECTION("Host to Device") { Memcpy3DHtoDSyncBehavior(Memcpy3DWrapper<async>, false); }
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-233
|
||||
SECTION("Device to Pageable Host") {
|
||||
Memcpy3DDtoHPageableSyncBehavior(Memcpy3DWrapper<async>, true);
|
||||
}
|
||||
#endif
|
||||
|
||||
SECTION("Device to Pinned Host") {
|
||||
Memcpy3DDtoHPinnedSyncBehavior(Memcpy3DWrapper<async>, false);
|
||||
}
|
||||
|
||||
SECTION("Device to Device") { Memcpy3DDtoDSyncBehavior(Memcpy3DWrapper<async>, false); }
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-233
|
||||
SECTION("Host to Host") { Memcpy3DHtoHSyncBehavior(Memcpy3DWrapper<async>, true); }
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both H2D & D2H functionalities of hipMemcpy3DAsync API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3DAsync API
|
||||
* from another GPU.
|
||||
* H2D case:
|
||||
* Input : "hData" is initialized with the respective offset value
|
||||
* Output: Destination array "arr" variable.
|
||||
*
|
||||
* D2H case:
|
||||
* Input: "arr" array variable from the above output
|
||||
* Output: "hOutputData" variable data is copied from "arr" variable
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::D2H_H2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 1, 0));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
|
||||
// Memory is allocated on device 0 and Memcpy3DAsyncAsync
|
||||
// triggered from device 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
|
||||
// Device to host
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
free(hOutputData);
|
||||
|
||||
// DeAllocating the Memory
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access");
|
||||
}
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_Positive_Parameters") {
|
||||
constexpr bool async = true;
|
||||
Memcpy3DZeroWidthHeightDepth<async>(Memcpy3DWrapper<async>);
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both D2D functionalities of hipMemcpy3DAsync API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3DAsync API
|
||||
* from another GPU.
|
||||
*
|
||||
* D2D case:
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr2" variable in GPU-0
|
||||
*
|
||||
* hipMemcpy3DAsync API is triggered from GPU-1
|
||||
* The "arr2" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::D2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 0, 1));
|
||||
if (peerAccess) {
|
||||
// Allocating Memory and setting default data
|
||||
AllocateMemory();
|
||||
hipStream_t stream1;
|
||||
HIP_CHECK(hipStreamCreate(&stream1));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device Scenario
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_Positive_Array") {
|
||||
constexpr bool async = true;
|
||||
SECTION("Array from/to Host") { Memcpy3DArrayHostShell<async>(Memcpy3DWrapper<async>); }
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-238
|
||||
SECTION("Array from/to Device") { Memcpy3DArrayDeviceShell<async>(Memcpy3DWrapper<async>); }
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream1) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream1));
|
||||
|
||||
// Allocating Mem on GPU device 0 and trigger hipMemcpy3DAsync from GPU 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Device to Device
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// For validating the D2D copy copying it again to hOutputData and
|
||||
// verifying it with iniital data hData
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
|
||||
// Device to host
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream)== hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// Deleting the memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies all the negative scenarios of hipMemcpy3D API
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::NegativeTests() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_Negative_Parameters") {
|
||||
constexpr bool async = true;
|
||||
constexpr hipExtent extent{128 * sizeof(int), 128, 8};
|
||||
|
||||
// Initialization of data
|
||||
memset(&myparms, 0, sizeof(myparms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
|
||||
SECTION("Nullptr to destination array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = nullptr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Nullptr to source array") {
|
||||
myparms.srcArray = nullptr;
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both Source ptr and array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both destination ptr and array") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcArray = arr1;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Max value to extent") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.extent = make_hipExtent(std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max());
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Source pitchedPtr as nullptr") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Dst pitchedPtr as nullptr") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing width > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width+1 , height, depth);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing hgt > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height+1, depth);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing depth > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst width pos > max allocated width") {
|
||||
myparms.dstPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst height pos > max allocated hgt") {
|
||||
myparms.dstPos = make_hipPos(0, height+1, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst depth pos > max allocated depth") {
|
||||
myparms.dstPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src width pos > max allocated width") {
|
||||
myparms.srcPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, height+1, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src array size > dst array size") {
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(3, 3
|
||||
, 3), hipArrayDefault));
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing nullptr to hipMemcpy3DAsync") {
|
||||
REQUIRE(hipMemcpy3DAsync(nullptr, stream) != hipSuccess);
|
||||
}
|
||||
// DeAllocating of memory
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both D2D functionalities of hipMemcpy3DAsync API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3DAsync API
|
||||
* from another GPU.
|
||||
*
|
||||
* D2D case:
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr1" variable in GPU-0
|
||||
*
|
||||
* Stream on GPU-1
|
||||
* The "arr2" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::D2D_SameDeviceMem_StreamDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
// Allocating the Memory
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 0, 1));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Array to Array
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T), width, height);
|
||||
myparms.srcArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// Deallocating the memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies the Extent validation Scenarios
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::Extent_Validation() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
// Passing extent as 0
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
SECTION("Passing Extent as 0") {
|
||||
myparms.extent = make_hipExtent(0 , 0, 0);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Width 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(0 , height, depth);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Height 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , 0, depth);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Depth 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , height, 0);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies H2H-D2D-D2H functionalities of hipMemcpy3DAsync API
|
||||
*
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr1" variable in GPU-0
|
||||
*
|
||||
* The "arr1" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::simple_Memcpy3DAsync() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
|
||||
// Allocating the Memory
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
SECTION("Calling hipMemcpy3DAsync() using user declared stream obj") {
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
}
|
||||
SECTION("Calling hipMemcpy3DAsync() using hipStreamPerThread") {
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, hipStreamPerThread) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(hipStreamPerThread));
|
||||
}
|
||||
|
||||
// Array to Array
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T), width, height);
|
||||
myparms.srcArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// DeAllocating the memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
}
|
||||
/*
|
||||
This testcase verifies hipMemcpyAsync for different datatypes
|
||||
and different sizes
|
||||
*/
|
||||
TEMPLATE_TEST_CASE("Unit_hipMemcpy3DAsync_Basic",
|
||||
"[hipMemcpy3DAsync]",
|
||||
int, unsigned int, float) {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
int device = -1;
|
||||
HIP_CHECK(hipGetDevice(&device));
|
||||
hipDeviceProp_t prop;
|
||||
HIP_CHECK(hipGetDeviceProperties(&prop,device));
|
||||
auto i = GENERATE_COPY(10, 100, 1024, prop.maxTexture3D[0]);
|
||||
auto j = GENERATE(10, 100);
|
||||
if (numDevices > 1) {
|
||||
if (std::is_same<TestType, int>::value) {
|
||||
Memcpy3DAsync<TestType> memcpy3d_obj(i, j, j,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d_obj.simple_Memcpy3DAsync();
|
||||
} else if (std::is_same<TestType, unsigned int>::value) {
|
||||
Memcpy3DAsync<TestType> memcpy3d_obj(i, j, j,
|
||||
hipChannelFormatKindUnsigned);
|
||||
memcpy3d_obj.simple_Memcpy3DAsync();
|
||||
} else if (std::is_same<TestType, float>::value) {
|
||||
Memcpy3DAsync<TestType> memcpy3d_obj(i, j, j,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_obj.simple_Memcpy3DAsync();
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the extent validation scenarios of
|
||||
hipMemcpy3D API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_ExtentValidation") {
|
||||
Memcpy3DAsync<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.Extent_Validation();
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the negative scenarios of
|
||||
hipMemcpy3DAsync API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_multiDevice-Negative") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
Memcpy3DAsync<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.NegativeTests();
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the D2H,H2D and D2D on peer
|
||||
GPU device
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_multiDevice-D2D") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
SECTION("D2D on different Device") {
|
||||
Memcpy3DAsync<float> memcpy3d_d2d_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2d_obj.D2D_DeviceMem_OnDiffDevice();
|
||||
constexpr auto NegativeTests = [](hipPitchedPtr dst_ptr, hipPos dst_pos, hipPitchedPtr src_ptr,
|
||||
hipPos src_pos, hipExtent extent, hipMemcpyKind kind) {
|
||||
SECTION("dst_ptr.ptr == nullptr") {
|
||||
hipPitchedPtr invalid_ptr = dst_ptr;
|
||||
invalid_ptr.ptr = nullptr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(invalid_ptr, dst_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("D2H and H2D on different device") {
|
||||
Memcpy3DAsync<float> memcpy3d_d2h_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2h_obj.D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
SECTION("src_ptr.ptr == nullptr") {
|
||||
hipPitchedPtr invalid_ptr = src_ptr;
|
||||
invalid_ptr.ptr = nullptr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, invalid_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase checks hipMemcpy3DAsync API by
|
||||
allocating memory in one GPU and creating stream
|
||||
in another GPU
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_multiDevice-DiffStream") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
Memcpy3DAsync<float> memcpy3dAsync(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3dAsync.D2D_SameDeviceMem_StreamDiffDevice();
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-239
|
||||
SECTION("dst_ptr.pitch < width") {
|
||||
hipPitchedPtr invalid_ptr = dst_ptr;
|
||||
invalid_ptr.pitch = extent.width - 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(invalid_ptr, dst_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidPitchValue);
|
||||
}
|
||||
|
||||
SECTION("src_ptr.pitch < width") {
|
||||
hipPitchedPtr invalid_ptr = src_ptr;
|
||||
invalid_ptr.pitch = extent.width - 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, invalid_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidPitchValue);
|
||||
}
|
||||
#endif
|
||||
|
||||
SECTION("dst_ptr.pitch > max pitch") {
|
||||
int attr = 0;
|
||||
HIP_CHECK(hipDeviceGetAttribute(&attr, hipDeviceAttributeMaxPitch, 0));
|
||||
hipPitchedPtr invalid_ptr = dst_ptr;
|
||||
invalid_ptr.pitch = attr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(invalid_ptr, dst_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("src_ptr.pitch > max pitch") {
|
||||
int attr = 0;
|
||||
HIP_CHECK(hipDeviceGetAttribute(&attr, hipDeviceAttributeMaxPitch, 0));
|
||||
hipPitchedPtr invalid_ptr = src_ptr;
|
||||
invalid_ptr.pitch = attr;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, invalid_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-237
|
||||
SECTION("extent.width + dst_pos.x > dst_ptr.pitch") {
|
||||
hipPos invalid_pos = dst_pos;
|
||||
invalid_pos.x = dst_ptr.pitch - extent.width + 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, invalid_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("extent.width + src_pos.x > src_ptr.pitch") {
|
||||
hipPos invalid_pos = src_pos;
|
||||
invalid_pos.x = src_ptr.pitch - extent.width + 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, src_ptr, invalid_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("dst_pos.y out of bounds") {
|
||||
hipPos invalid_pos = dst_pos;
|
||||
invalid_pos.y = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, invalid_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("src_pos.y out of bounds") {
|
||||
hipPos invalid_pos = src_pos;
|
||||
invalid_pos.y = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, src_ptr, invalid_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("dst_pos.z out of bounds") {
|
||||
hipPos invalid_pos = dst_pos;
|
||||
invalid_pos.z = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, invalid_pos, src_ptr, src_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("src_pos.z out of bounds") {
|
||||
hipPos invalid_pos = src_pos;
|
||||
invalid_pos.z = 1;
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, src_ptr, invalid_pos, extent, kind),
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-234
|
||||
SECTION("Invalid MemcpyKind") {
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, src_ptr, src_pos, extent,
|
||||
static_cast<hipMemcpyKind>(-1)),
|
||||
hipErrorInvalidMemcpyDirection);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if HT_NVIDIA // Disabled on AMD due to defect - EXSWHTEC-235
|
||||
SECTION("Invalid stream") {
|
||||
StreamGuard stream_guard(Streams::created);
|
||||
HIP_CHECK(hipStreamDestroy(stream_guard.stream()));
|
||||
HIP_CHECK_ERROR(Memcpy3DWrapper<async>(dst_ptr, dst_pos, src_ptr, src_pos, extent, kind,
|
||||
stream_guard.stream()),
|
||||
hipErrorContextIsDestroyed);
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
SECTION("Host to Device") {
|
||||
LinearAllocGuard3D<int> device_alloc(extent);
|
||||
LinearAllocGuard<int> host_alloc(
|
||||
LinearAllocs::hipHostMalloc,
|
||||
device_alloc.pitch() * device_alloc.height() * device_alloc.depth());
|
||||
NegativeTests(device_alloc.pitched_ptr(), make_hipPos(0, 0, 0),
|
||||
make_hipPitchedPtr(host_alloc.ptr(), device_alloc.pitch(), device_alloc.width(),
|
||||
device_alloc.height()),
|
||||
make_hipPos(0, 0, 0), extent, hipMemcpyHostToDevice);
|
||||
}
|
||||
|
||||
SECTION("Device to Host") {
|
||||
LinearAllocGuard3D<int> device_alloc(extent);
|
||||
LinearAllocGuard<int> host_alloc(
|
||||
LinearAllocs::hipHostMalloc,
|
||||
device_alloc.pitch() * device_alloc.height() * device_alloc.depth());
|
||||
NegativeTests(make_hipPitchedPtr(host_alloc.ptr(), device_alloc.pitch(), device_alloc.width(),
|
||||
device_alloc.height()),
|
||||
make_hipPos(0, 0, 0), device_alloc.pitched_ptr(), make_hipPos(0, 0, 0), extent,
|
||||
hipMemcpyDeviceToHost);
|
||||
}
|
||||
|
||||
SECTION("Host to Host") {
|
||||
LinearAllocGuard<int> src_alloc(LinearAllocs::hipHostMalloc,
|
||||
extent.width * extent.height * extent.depth);
|
||||
LinearAllocGuard<int> dst_alloc(LinearAllocs::hipHostMalloc,
|
||||
extent.width * extent.height * extent.depth);
|
||||
NegativeTests(make_hipPitchedPtr(dst_alloc.ptr(), extent.width, extent.width, extent.height),
|
||||
make_hipPos(0, 0, 0),
|
||||
make_hipPitchedPtr(src_alloc.ptr(), extent.width, extent.width, extent.height),
|
||||
make_hipPos(0, 0, 0), extent, hipMemcpyHostToHost);
|
||||
}
|
||||
|
||||
SECTION("Device to Device") {
|
||||
LinearAllocGuard3D<int> src_alloc(extent);
|
||||
LinearAllocGuard3D<int> dst_alloc(extent);
|
||||
NegativeTests(dst_alloc.pitched_ptr(), make_hipPos(0, 0, 0), src_alloc.pitched_ptr(),
|
||||
make_hipPos(0, 0, 0), extent, hipMemcpyDeviceToDevice);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,755 @@
|
||||
/*
|
||||
Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This testfile verifies the following Scenarios of hipMemcpy3DAsync API
|
||||
|
||||
* 1. Verifying hipMemcpy3DAsync API for H2D,D2D and D2H scenarios
|
||||
* 2. Verifying Negative Scenarios
|
||||
* 3. Verifying Extent validation scenarios by passing 0
|
||||
* 4. Verifying hipMemcpy3DAsync API by allocating Memory in
|
||||
* one GPU and trigger hipMemcpy3D from peer GPU
|
||||
* 5. D2D where src and dst memory on GPU-0 and stream on GPU-1
|
||||
*/
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include <hip_test_checkers.hh>
|
||||
|
||||
static constexpr auto width{10};
|
||||
static constexpr auto height{10};
|
||||
static constexpr auto depth{10};
|
||||
|
||||
template <typename T>
|
||||
class Memcpy3DAsync {
|
||||
int width, height, depth;
|
||||
unsigned int size;
|
||||
hipArray *arr, *arr1;
|
||||
hipChannelFormatKind formatKind;
|
||||
hipMemcpy3DParms myparms;
|
||||
T* hData;
|
||||
hipStream_t stream;
|
||||
public:
|
||||
Memcpy3DAsync(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format);
|
||||
void simple_Memcpy3DAsync();
|
||||
void Extent_Validation();
|
||||
void NegativeTests();
|
||||
void AllocateMemory();
|
||||
void DeAllocateMemory();
|
||||
void SetDefaultData();
|
||||
void D2D_SameDeviceMem_StreamDiffDevice();
|
||||
void D2D_DeviceMem_OnDiffDevice();
|
||||
void D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
};
|
||||
|
||||
/*
|
||||
* This API sets the default values of hipMemcpy3DParms structure
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::SetDefaultData() {
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
}
|
||||
|
||||
/*
|
||||
* Constructor initalized width,depth and height
|
||||
*/
|
||||
template <typename T>
|
||||
Memcpy3DAsync<T>::Memcpy3DAsync(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format) {
|
||||
width = l_width;
|
||||
height = l_height;
|
||||
depth = l_depth;
|
||||
formatKind = l_format;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocating Memory and initalizing data for both
|
||||
* device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::AllocateMemory() {
|
||||
size = width * height * depth * sizeof(T);
|
||||
hData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hData, 0, size);
|
||||
for (int i = 0; i < depth; i++) {
|
||||
for (int j = 0; j < height; j++) {
|
||||
for (int k = 0; k < width; k++) {
|
||||
hData[i*width*height + j*width +k] = i*width*height + j*width + k;
|
||||
}
|
||||
}
|
||||
}
|
||||
hipChannelFormatDesc channelDesc = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
HIP_CHECK(hipMalloc3DArray(&arr1, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
}
|
||||
|
||||
/*
|
||||
* DeAllocates the Memory of device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::DeAllocateMemory() {
|
||||
HIP_CHECK(hipFreeArray(arr));
|
||||
HIP_CHECK(hipFreeArray(arr1));
|
||||
free(hData);
|
||||
HIP_CHECK(hipStreamDestroy(stream));
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both H2D & D2H functionalities of hipMemcpy3DAsync API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3DAsync API
|
||||
* from another GPU.
|
||||
* H2D case:
|
||||
* Input : "hData" is initialized with the respective offset value
|
||||
* Output: Destination array "arr" variable.
|
||||
*
|
||||
* D2H case:
|
||||
* Input: "arr" array variable from the above output
|
||||
* Output: "hOutputData" variable data is copied from "arr" variable
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::D2H_H2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 1, 0));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
|
||||
// Memory is allocated on device 0 and Memcpy3DAsyncAsync
|
||||
// triggered from device 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
|
||||
// Device to host
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
free(hOutputData);
|
||||
|
||||
// DeAllocating the Memory
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both D2D functionalities of hipMemcpy3DAsync API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3DAsync API
|
||||
* from another GPU.
|
||||
*
|
||||
* D2D case:
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr2" variable in GPU-0
|
||||
*
|
||||
* hipMemcpy3DAsync API is triggered from GPU-1
|
||||
* The "arr2" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::D2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 0, 1));
|
||||
if (peerAccess) {
|
||||
// Allocating Memory and setting default data
|
||||
AllocateMemory();
|
||||
hipStream_t stream1;
|
||||
HIP_CHECK(hipStreamCreate(&stream1));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device Scenario
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream1) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream1));
|
||||
|
||||
// Allocating Mem on GPU device 0 and trigger hipMemcpy3DAsync from GPU 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Device to Device
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// For validating the D2D copy copying it again to hOutputData and
|
||||
// verifying it with iniital data hData
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
|
||||
// Device to host
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream)== hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// Deleting the memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies all the negative scenarios of hipMemcpy3D API
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::NegativeTests() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
|
||||
// Initialization of data
|
||||
memset(&myparms, 0, sizeof(myparms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
|
||||
SECTION("Nullptr to destination array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = nullptr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Nullptr to source array") {
|
||||
myparms.srcArray = nullptr;
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both Source ptr and array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both destination ptr and array") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcArray = arr1;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Max value to extent") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.extent = make_hipExtent(std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max());
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Source pitchedPtr as nullptr") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Dst pitchedPtr as nullptr") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing width > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width+1 , height, depth);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing hgt > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height+1, depth);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing depth > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst width pos > max allocated width") {
|
||||
myparms.dstPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst height pos > max allocated hgt") {
|
||||
myparms.dstPos = make_hipPos(0, height+1, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst depth pos > max allocated depth") {
|
||||
myparms.dstPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src width pos > max allocated width") {
|
||||
myparms.srcPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, height+1, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src array size > dst array size") {
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(3, 3
|
||||
, 3), hipArrayDefault));
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing nullptr to hipMemcpy3DAsync") {
|
||||
REQUIRE(hipMemcpy3DAsync(nullptr, stream) != hipSuccess);
|
||||
}
|
||||
// DeAllocating of memory
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both D2D functionalities of hipMemcpy3DAsync API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3DAsync API
|
||||
* from another GPU.
|
||||
*
|
||||
* D2D case:
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr1" variable in GPU-0
|
||||
*
|
||||
* Stream on GPU-1
|
||||
* The "arr2" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::D2D_SameDeviceMem_StreamDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
// Allocating the Memory
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 0, 1));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Array to Array
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T), width, height);
|
||||
myparms.srcArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// Deallocating the memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies the Extent validation Scenarios
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::Extent_Validation() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
// Passing extent as 0
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
SECTION("Passing Extent as 0") {
|
||||
myparms.extent = make_hipExtent(0 , 0, 0);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Width 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(0 , height, depth);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Height 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , 0, depth);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Depth 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , height, 0);
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
}
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies H2H-D2D-D2H functionalities of hipMemcpy3DAsync API
|
||||
*
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr1" variable in GPU-0
|
||||
*
|
||||
* The "arr1" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3DAsync<T>::simple_Memcpy3DAsync() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
|
||||
// Allocating the Memory
|
||||
AllocateMemory();
|
||||
HIP_CHECK(hipStreamCreate(&stream));
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to Device
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
SECTION("Calling hipMemcpy3DAsync() using user declared stream obj") {
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
}
|
||||
SECTION("Calling hipMemcpy3DAsync() using hipStreamPerThread") {
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, hipStreamPerThread) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(hipStreamPerThread));
|
||||
}
|
||||
|
||||
// Array to Array
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T), width, height);
|
||||
myparms.srcArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3DAsync(&myparms, stream) == hipSuccess);
|
||||
HIP_CHECK(hipStreamSynchronize(stream));
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// DeAllocating the memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
}
|
||||
/*
|
||||
This testcase verifies hipMemcpyAsync for different datatypes
|
||||
and different sizes
|
||||
*/
|
||||
TEMPLATE_TEST_CASE("Unit_hipMemcpy3DAsync_Basic",
|
||||
"[hipMemcpy3DAsync]",
|
||||
int, unsigned int, float) {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
int device = -1;
|
||||
HIP_CHECK(hipGetDevice(&device));
|
||||
hipDeviceProp_t prop;
|
||||
HIP_CHECK(hipGetDeviceProperties(&prop,device));
|
||||
auto i = GENERATE_COPY(10, 100, 1024, prop.maxTexture3D[0]);
|
||||
auto j = GENERATE(10, 100);
|
||||
if (numDevices > 1) {
|
||||
if (std::is_same<TestType, int>::value) {
|
||||
Memcpy3DAsync<TestType> memcpy3d_obj(i, j, j,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d_obj.simple_Memcpy3DAsync();
|
||||
} else if (std::is_same<TestType, unsigned int>::value) {
|
||||
Memcpy3DAsync<TestType> memcpy3d_obj(i, j, j,
|
||||
hipChannelFormatKindUnsigned);
|
||||
memcpy3d_obj.simple_Memcpy3DAsync();
|
||||
} else if (std::is_same<TestType, float>::value) {
|
||||
Memcpy3DAsync<TestType> memcpy3d_obj(i, j, j,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_obj.simple_Memcpy3DAsync();
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the extent validation scenarios of
|
||||
hipMemcpy3D API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_ExtentValidation") {
|
||||
Memcpy3DAsync<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.Extent_Validation();
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the negative scenarios of
|
||||
hipMemcpy3DAsync API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_multiDevice-Negative") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
Memcpy3DAsync<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.NegativeTests();
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the D2H,H2D and D2D on peer
|
||||
GPU device
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_multiDevice-D2D") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
SECTION("D2D on different Device") {
|
||||
Memcpy3DAsync<float> memcpy3d_d2d_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2d_obj.D2D_DeviceMem_OnDiffDevice();
|
||||
}
|
||||
|
||||
SECTION("D2H and H2D on different device") {
|
||||
Memcpy3DAsync<float> memcpy3d_d2h_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2h_obj.D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase checks hipMemcpy3DAsync API by
|
||||
allocating memory in one GPU and creating stream
|
||||
in another GPU
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3DAsync_multiDevice-DiffStream") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
Memcpy3DAsync<float> memcpy3dAsync(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3dAsync.D2D_SameDeviceMem_StreamDiffDevice();
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,627 @@
|
||||
/*
|
||||
Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved.
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This testfile verifies the following scenarios of hipMemcpy3D API
|
||||
*
|
||||
* 1. Verifying hipMemcpy3D API for H2D,D2D and D2H scenarios for
|
||||
different datatypes and sizes.
|
||||
* 2. Verifying Negative Scenarios
|
||||
* 3. Verifying Extent validation scenarios by passing 0
|
||||
* 4. Verifying hipMemcpy3D API by allocating Memory in
|
||||
* one GPU and trigger hipMemcpy3D from peer GPU
|
||||
*
|
||||
*/
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include <hip_test_checkers.hh>
|
||||
|
||||
static constexpr auto width{10};
|
||||
static constexpr auto height{10};
|
||||
static constexpr auto depth{10};
|
||||
|
||||
template <typename T>
|
||||
class Memcpy3D {
|
||||
int width, height, depth;
|
||||
unsigned int size;
|
||||
hipArray *arr, *arr1;
|
||||
hipChannelFormatKind formatKind;
|
||||
hipMemcpy3DParms myparms;
|
||||
T* hData;
|
||||
public:
|
||||
Memcpy3D(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format);
|
||||
void simple_Memcpy3D();
|
||||
void Extent_Validation();
|
||||
void NegativeTests();
|
||||
void AllocateMemory();
|
||||
void DeAllocateMemory();
|
||||
void SetDefaultData();
|
||||
void D2D_DeviceMem_OnDiffDevice();
|
||||
void D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
};
|
||||
|
||||
/*
|
||||
* This API sets the default values of hipMemcpy3DParms structure
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::SetDefaultData() {
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
}
|
||||
|
||||
/*
|
||||
* Constructor initalized width,depth and height
|
||||
*/
|
||||
template <typename T>
|
||||
Memcpy3D<T>::Memcpy3D(int l_width, int l_height, int l_depth,
|
||||
hipChannelFormatKind l_format) {
|
||||
width = l_width;
|
||||
height = l_height;
|
||||
depth = l_depth;
|
||||
formatKind = l_format;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocating Memory and initalizing data for both
|
||||
* device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::AllocateMemory() {
|
||||
size = width * height * depth * sizeof(T);
|
||||
hData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hData, 0, size);
|
||||
for (int i = 0; i < depth; i++) {
|
||||
for (int j = 0; j < height; j++) {
|
||||
for (int k = 0; k < width; k++) {
|
||||
hData[i*width*height + j*width +k] = i*width*height + j*width + k;
|
||||
}
|
||||
}
|
||||
}
|
||||
hipChannelFormatDesc channelDesc = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
HIP_CHECK(hipMalloc3DArray(&arr1, &channelDesc, make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
}
|
||||
|
||||
/*
|
||||
* DeAllocates the Memory of device and host variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::DeAllocateMemory() {
|
||||
HIP_CHECK(hipFreeArray(arr));
|
||||
HIP_CHECK(hipFreeArray(arr1));
|
||||
free(hData);
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies both H2D & D2H functionalities of hipMemcpy3D API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3D API
|
||||
* from another GPU.
|
||||
* H2D case:
|
||||
* Input : "hData" is initialized with the respective offset value
|
||||
* Output: Destination array "arr" variable.
|
||||
*
|
||||
* D2H case:
|
||||
* Input: "arr" array variable from the above output
|
||||
* Output: "hOutputData" variable data is copied from "arr" variable
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::D2H_H2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 1, 0));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
// Memory is allocated on device 0 and Memcpy3DAsync triggered from device 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
|
||||
// H2D Scenario
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access\n");
|
||||
}
|
||||
}
|
||||
/*
|
||||
* This API verifies both D2D functionalities of hipMemcpy3D API
|
||||
* by allocating memory in one GPU and calling the hipMemcpy3D API
|
||||
* from another GPU.
|
||||
*
|
||||
* D2D case:
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr2" variable in GPU-0
|
||||
*
|
||||
* hipMemcpy3D API is triggered from GPU-1
|
||||
* The "arr2" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::D2D_DeviceMem_OnDiffDevice() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
int peerAccess = 0;
|
||||
HIP_CHECK(hipDeviceCanAccessPeer(&peerAccess, 0, 1));
|
||||
if (peerAccess) {
|
||||
AllocateMemory();
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
|
||||
// Host to device copy
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(width, height,
|
||||
depth), hipArrayDefault));
|
||||
|
||||
// Allocating Mem on GPU device 0 and trigger hipMemcpy3D from GPU 1
|
||||
HIP_CHECK(hipSetDevice(1));
|
||||
|
||||
// D2D Scenario
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
|
||||
// For validating the D2D copy copying it again to hOutputData and
|
||||
// verifying it with iniital data hData
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
SetDefaultData();
|
||||
|
||||
// Device to host
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// DeAllocating Memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
} else {
|
||||
SUCCEED("Skipped the test as there is no peer access\n");
|
||||
}
|
||||
}
|
||||
/*
|
||||
* This API verifies all the negative scenarios of hipMemcpy3D API
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::NegativeTests() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
|
||||
// Initialization of data
|
||||
memset(&myparms, 0, sizeof(myparms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.extent = make_hipExtent(width , height, depth);
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
|
||||
SECTION("Nullptr to destination array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = nullptr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Nullptr to source array") {
|
||||
myparms.srcArray = nullptr;
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both Source ptr and array") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing both destination ptr and array") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcArray = arr1;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Max value to extent") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
myparms.extent = make_hipExtent(std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max(),
|
||||
std::numeric_limits<int>::max());
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Source pitchedPtr as nullptr") {
|
||||
myparms.srcPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing Dst pitchedPtr as nullptr") {
|
||||
myparms.dstPtr = make_hipPitchedPtr(nullptr, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.srcArray = arr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing width > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width+1 , height, depth);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing hgt > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height+1, depth);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing depth > max width size in extent") {
|
||||
myparms.extent = make_hipExtent(width , height, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst width pos > max allocated width") {
|
||||
myparms.dstPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst height pos > max allocated hgt") {
|
||||
myparms.dstPos = make_hipPos(0, height+1, 0);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing dst depth pos > max allocated depth") {
|
||||
myparms.dstPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.dstArray = arr;
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src width pos > max allocated width") {
|
||||
myparms.srcPos = make_hipPos(width+1, 0, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, height+1, 0);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src height pos > max allocated hgt") {
|
||||
myparms.srcPos = make_hipPos(0, 0, depth+1);
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
SECTION("Passing src array size > dst array size") {
|
||||
// Passing src array size greater than destination array size
|
||||
hipArray *arr2;
|
||||
hipChannelFormatDesc channelDesc1 = hipCreateChannelDesc(sizeof(T)*8,
|
||||
0, 0, 0, formatKind);
|
||||
HIP_CHECK(hipMalloc3DArray(&arr2, &channelDesc1,
|
||||
make_hipExtent(3, 3
|
||||
, 3), hipArrayDefault));
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr2;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) != hipSuccess);
|
||||
}
|
||||
|
||||
// DeAllocation of memory
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies the Extent validation Scenarios
|
||||
*/
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::Extent_Validation() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
myparms.srcPos = make_hipPos(0, 0, 0);
|
||||
myparms.dstPos = make_hipPos(0, 0, 0);
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
SECTION("Passing Extent as 0") {
|
||||
myparms.extent = make_hipExtent(0 , 0, 0);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Width 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(0 , height, depth);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Height 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , 0, depth);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Depth 0 in Extent") {
|
||||
myparms.extent = make_hipExtent(width , height, 0);
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
}
|
||||
SECTION("Passing Depth 0 in Extent") {
|
||||
REQUIRE(hipMemcpy3D(nullptr) != hipSuccess);
|
||||
}
|
||||
DeAllocateMemory();
|
||||
}
|
||||
|
||||
/*
|
||||
* This API verifies H2H-D2D-D2H functionalities of hipMemcpy3D API
|
||||
*
|
||||
* Input : "arr" variable is initialized with the "hData" variable in GPU-0
|
||||
* Output: "arr1" variable in GPU-0
|
||||
*
|
||||
* The "arr1" variable is then copied to "hOutputData" for validating
|
||||
* the result
|
||||
*
|
||||
* Validating the result by comparing "hData" and "hOutputData" variables
|
||||
*/
|
||||
|
||||
template <typename T>
|
||||
void Memcpy3D<T>::simple_Memcpy3D() {
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
AllocateMemory();
|
||||
|
||||
// Host to Device
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T),
|
||||
width, height);
|
||||
myparms.dstArray = arr;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyHostToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyHostToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
|
||||
// Array to Array
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.srcArray = arr;
|
||||
myparms.dstArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToDevice;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToDevice;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
T *hOutputData = reinterpret_cast<T*>(malloc(size));
|
||||
memset(hOutputData, 0, size);
|
||||
|
||||
// Device to host
|
||||
memset(&myparms, 0x0, sizeof(hipMemcpy3DParms));
|
||||
SetDefaultData();
|
||||
myparms.dstPtr = make_hipPitchedPtr(hOutputData,
|
||||
width * sizeof(T), width, height);
|
||||
myparms.srcArray = arr1;
|
||||
#ifdef __HIP_PLATFORM_NVCC__
|
||||
myparms.kind = cudaMemcpyDeviceToHost;
|
||||
#else
|
||||
myparms.kind = hipMemcpyDeviceToHost;
|
||||
#endif
|
||||
REQUIRE(hipMemcpy3D(&myparms) == hipSuccess);
|
||||
|
||||
// Validating the result
|
||||
HipTest::checkArray(hData, hOutputData, width, height, depth);
|
||||
|
||||
// DeAllocating the Memory
|
||||
free(hOutputData);
|
||||
DeAllocateMemory();
|
||||
}
|
||||
/*
|
||||
This testcase performs hipMemcpy3D API validation for
|
||||
different datatypes and different sizes
|
||||
*/
|
||||
TEMPLATE_TEST_CASE("Unit_hipMemcpy3D_Basic", "[hipMemcpy3D]",
|
||||
int, unsigned int, float) {
|
||||
int device = -1;
|
||||
HIP_CHECK(hipGetDevice(&device));
|
||||
hipDeviceProp_t prop;
|
||||
HIP_CHECK(hipGetDeviceProperties(&prop,device));
|
||||
auto i = GENERATE_COPY(10, 100, 1024, prop.maxTexture3D[0]);
|
||||
auto j = GENERATE(10, 100);
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
if (std::is_same<TestType, float>::value) {
|
||||
Memcpy3D<TestType> memcpy3d_obj(i, j, j, hipChannelFormatKindFloat);
|
||||
memcpy3d_obj.simple_Memcpy3D();
|
||||
} else if (std::is_same<TestType, unsigned int>::value) {
|
||||
Memcpy3D<TestType> memcpy3d_obj(i, j, j, hipChannelFormatKindUnsigned);
|
||||
memcpy3d_obj.simple_Memcpy3D();
|
||||
} else if (std::is_same<TestType, int>::value) {
|
||||
Memcpy3D<TestType> memcpy3d_obj(i, j, j, hipChannelFormatKindSigned);
|
||||
memcpy3d_obj.simple_Memcpy3D();
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the extent validation scenarios of
|
||||
hipMemcpy3D API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_ExtentValidation") {
|
||||
Memcpy3D<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.Extent_Validation();
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the negative scenarios of
|
||||
hipMemcpy3D API
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_multiDevice-Negative") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
Memcpy3D<int> memcpy3d(width, height, depth,
|
||||
hipChannelFormatKindSigned);
|
||||
memcpy3d.NegativeTests();
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
This testcase performs the D2H,H2D and D2D on peer
|
||||
GPU device
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemcpy3D_multiDevice-OnPeerDevice") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
if (numDevices > 1) {
|
||||
SECTION("D2H & H2D On DiffDevice") {
|
||||
Memcpy3D<float> memcpy3d_d2h_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2h_obj.D2H_H2D_DeviceMem_OnDiffDevice();
|
||||
}
|
||||
|
||||
SECTION("D2D On DiffDevice") {
|
||||
Memcpy3D<float> memcpy3d_d2d_obj(width, height, depth,
|
||||
hipChannelFormatKindFloat);
|
||||
memcpy3d_d2d_obj.D2D_DeviceMem_OnDiffDevice();
|
||||
}
|
||||
} else {
|
||||
SUCCEED("skipping the testcases as numDevices < 2");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user