amilanov-amd
6125 خطوط
216 KiB
C++
6125 خطوط
216 KiB
C++
/*
|
|
Copyright (c) 2024 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 WARRANNTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNNESS 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 INN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR INN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
*/
|
|
|
|
#include <hip_test_common.hh>
|
|
#include <hip_test_helper.hh>
|
|
#include <utils.hh>
|
|
#include "hipMallocManagedCommon.hh"
|
|
#include "../device/hipGetProcAddressHelpers.hh"
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Allocation and free) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMallocFree") {
|
|
void* hipMalloc_ptr = nullptr;
|
|
void* hipFree_ptr = nullptr;
|
|
void* hipExtMallocWithFlags_ptr = nullptr;
|
|
void* hipMallocHost_ptr = nullptr;
|
|
void* hipMemAllocHost_ptr = nullptr;
|
|
void* hipHostMalloc_ptr = nullptr;
|
|
void* hipHostAlloc_ptr = nullptr;
|
|
void* hipHostGetDevicePointer_ptr = nullptr;
|
|
void* hipHostGetFlags_ptr = nullptr;
|
|
void* hipMallocPitch_ptr = nullptr;
|
|
void* hipMemAllocPitch_ptr = nullptr;
|
|
void* hipFreeHost_ptr = nullptr;
|
|
void* hipHostFree_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMalloc", &hipMalloc_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipFree", &hipFree_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipExtMallocWithFlags", &hipExtMallocWithFlags_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMallocHost", &hipMallocHost_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemAllocHost", &hipMemAllocHost_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipHostMalloc", &hipHostMalloc_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipHostAlloc", &hipHostAlloc_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipHostGetDevicePointer", &hipHostGetDevicePointer_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipHostGetFlags", &hipHostGetFlags_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMallocPitch", &hipMallocPitch_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemAllocPitch", &hipMemAllocPitch_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipFreeHost", &hipFreeHost_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipHostFree", &hipHostFree_ptr, currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMalloc_ptr)(void**, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t)>(hipMalloc_ptr);
|
|
hipError_t (*dyn_hipFree_ptr)(void*) = reinterpret_cast<hipError_t (*)(void*)>(hipFree_ptr);
|
|
hipError_t (*dyn_hipExtMallocWithFlags_ptr)(void**, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t, unsigned int)>(hipExtMallocWithFlags_ptr);
|
|
hipError_t (*dyn_hipMallocHost_ptr)(void**, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t)>(hipMallocHost_ptr);
|
|
hipError_t (*dyn_hipMemAllocHost_ptr)(void**, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t)>(hipMemAllocHost_ptr);
|
|
hipError_t (*dyn_hipHostMalloc_ptr)(void**, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t, unsigned int)>(hipHostMalloc_ptr);
|
|
hipError_t (*dyn_hipHostAlloc_ptr)(void**, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t, unsigned int)>(hipHostAlloc_ptr);
|
|
hipError_t (*dyn_hipHostGetDevicePointer_ptr)(void**, void*, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(void**, void*, unsigned int)>(hipHostGetDevicePointer_ptr);
|
|
hipError_t (*dyn_hipHostGetFlags_ptr)(unsigned int*, void*) =
|
|
reinterpret_cast<hipError_t (*)(unsigned int*, void*)>(hipHostGetFlags_ptr);
|
|
hipError_t (*dyn_hipMallocPitch_ptr)(void**, size_t*, size_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t*, size_t, size_t)>(hipMallocPitch_ptr);
|
|
hipError_t (*dyn_hipMemAllocPitch_ptr)(hipDeviceptr_t*, size_t*, size_t, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t*, size_t*, size_t, size_t, unsigned int)>(
|
|
hipMemAllocPitch_ptr);
|
|
hipError_t (*dyn_hipFreeHost_ptr)(void*) =
|
|
reinterpret_cast<hipError_t (*)(void*)>(hipFreeHost_ptr);
|
|
hipError_t (*dyn_hipHostFree_ptr)(void*) =
|
|
reinterpret_cast<hipError_t (*)(void*)>(hipHostFree_ptr);
|
|
|
|
// Validating hipMalloc and hipFree APIs
|
|
{
|
|
void* d_ptr = nullptr;
|
|
HIP_CHECK(dyn_hipMalloc_ptr(&d_ptr, 256));
|
|
|
|
REQUIRE(d_ptr != nullptr);
|
|
size_t d_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(d_ptr, &d_ptr_size));
|
|
REQUIRE(d_ptr_size == 256);
|
|
|
|
HIP_CHECK(dyn_hipFree_ptr(d_ptr));
|
|
REQUIRE(hipMemPtrGetInfo(d_ptr, &d_ptr_size) == hipErrorInvalidValue);
|
|
}
|
|
|
|
// Validating hipExtMallocWithFlags API
|
|
{
|
|
void* ext_d_ptr = nullptr;
|
|
size_t ext_d_ptr_size;
|
|
|
|
::std::vector<unsigned int> ext_mlc_flags;
|
|
ext_mlc_flags.push_back(hipDeviceMallocDefault);
|
|
ext_mlc_flags.push_back(hipDeviceMallocUncached);
|
|
ext_mlc_flags.push_back(hipMallocSignalMemory);
|
|
|
|
if (DeviceAttributesSupport(0, hipDeviceAttributeFineGrainSupport)) {
|
|
ext_mlc_flags.push_back(hipDeviceMallocFinegrained);
|
|
}
|
|
|
|
for (unsigned int flag : ext_mlc_flags) {
|
|
ext_d_ptr = nullptr;
|
|
HIP_CHECK(dyn_hipExtMallocWithFlags_ptr(&ext_d_ptr, 8, flag));
|
|
REQUIRE(ext_d_ptr != nullptr);
|
|
|
|
ext_d_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(ext_d_ptr, &ext_d_ptr_size));
|
|
REQUIRE(ext_d_ptr_size == 8);
|
|
HIP_CHECK(hipFree(ext_d_ptr));
|
|
}
|
|
}
|
|
|
|
// Validating hipMallocHost API
|
|
{
|
|
void* h_ptr = nullptr;
|
|
HIP_CHECK(dyn_hipMallocHost_ptr(&h_ptr, 128));
|
|
REQUIRE(h_ptr != nullptr);
|
|
size_t h_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(h_ptr, &h_ptr_size));
|
|
REQUIRE(h_ptr_size == 128);
|
|
HIP_CHECK(hipFree(h_ptr));
|
|
}
|
|
|
|
// Validating hipMemAllocHost API
|
|
{
|
|
void* h_ptr = nullptr;
|
|
HIP_CHECK(dyn_hipMemAllocHost_ptr(&h_ptr, 256));
|
|
REQUIRE(h_ptr != nullptr);
|
|
size_t h_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(h_ptr, &h_ptr_size));
|
|
REQUIRE(h_ptr_size == 256);
|
|
HIP_CHECK(hipFree(h_ptr));
|
|
}
|
|
|
|
// Validating hipHostMalloc API
|
|
{
|
|
void* h_ptr = nullptr;
|
|
size_t h_ptr_size = -1;
|
|
|
|
unsigned int h3_flags[] = {hipHostMallocCoherent, hipHostMallocNonCoherent, hipHostMallocMapped,
|
|
hipHostMallocNumaUser};
|
|
|
|
for (unsigned int flag : h3_flags) {
|
|
h_ptr = nullptr;
|
|
|
|
HIP_CHECK(dyn_hipHostMalloc_ptr(&h_ptr, 256, flag));
|
|
REQUIRE(h_ptr != nullptr);
|
|
|
|
h_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(h_ptr, &h_ptr_size));
|
|
REQUIRE(h_ptr_size == 256);
|
|
HIP_CHECK(hipFree(h_ptr));
|
|
}
|
|
}
|
|
|
|
// Validating hipHostAlloc API
|
|
{
|
|
void* h_ptr = nullptr;
|
|
size_t h_ptr_size = -1;
|
|
|
|
HIP_CHECK(dyn_hipHostAlloc_ptr(&h_ptr, 256, 0));
|
|
REQUIRE(h_ptr != nullptr);
|
|
|
|
h_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(h_ptr, &h_ptr_size));
|
|
REQUIRE(h_ptr_size == 256);
|
|
HIP_CHECK(hipFree(h_ptr));
|
|
}
|
|
|
|
// Validating hipHostGetDevicePointer API
|
|
{
|
|
void* hostPtr = nullptr;
|
|
void* devicePtrForhostPtr = nullptr;
|
|
void* devicePtrForhostPtrWithFuncPtr = nullptr;
|
|
size_t hostPtr_size = -1;
|
|
size_t hostPtr_ptr_size = -1;
|
|
|
|
unsigned int flags[] = {hipHostMallocCoherent, hipHostMallocNonCoherent, hipHostMallocMapped,
|
|
hipHostMallocNumaUser};
|
|
|
|
for (unsigned int flag : flags) {
|
|
hostPtr = nullptr;
|
|
|
|
HIP_CHECK(hipHostMalloc(&hostPtr, 1024, flag));
|
|
REQUIRE(hostPtr != nullptr);
|
|
|
|
devicePtrForhostPtr = nullptr;
|
|
devicePtrForhostPtrWithFuncPtr = nullptr;
|
|
|
|
HIP_CHECK(hipHostGetDevicePointer(&devicePtrForhostPtr, hostPtr, 0));
|
|
HIP_CHECK(dyn_hipHostGetDevicePointer_ptr(&devicePtrForhostPtrWithFuncPtr, hostPtr, 0));
|
|
|
|
REQUIRE(devicePtrForhostPtr != nullptr);
|
|
REQUIRE(devicePtrForhostPtrWithFuncPtr != nullptr);
|
|
|
|
REQUIRE(devicePtrForhostPtrWithFuncPtr == devicePtrForhostPtr);
|
|
|
|
hostPtr_size = -1;
|
|
hostPtr_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(devicePtrForhostPtr, &hostPtr_size));
|
|
REQUIRE(hostPtr_size == 1024);
|
|
HIP_CHECK(hipMemPtrGetInfo(devicePtrForhostPtrWithFuncPtr, &hostPtr_ptr_size));
|
|
REQUIRE(hostPtr_ptr_size == 1024);
|
|
REQUIRE(hostPtr_size == hostPtr_ptr_size);
|
|
|
|
HIP_CHECK(hipFree(hostPtr));
|
|
}
|
|
}
|
|
|
|
// Validating hipHostGetFlags API
|
|
{
|
|
void* h = nullptr;
|
|
unsigned int expect_flags = -1;
|
|
unsigned int expect_flags_with_ptr = -1;
|
|
|
|
unsigned int flags[] = {hipHostMallocCoherent, hipHostMallocNonCoherent, hipHostMallocMapped,
|
|
hipHostMallocNumaUser};
|
|
|
|
for (unsigned int flag : flags) {
|
|
h = nullptr;
|
|
HIP_CHECK(hipHostMalloc(&h, 512, flag));
|
|
REQUIRE(h != nullptr);
|
|
|
|
expect_flags = -1;
|
|
expect_flags_with_ptr = -1;
|
|
HIP_CHECK(hipHostGetFlags(&expect_flags, h));
|
|
HIP_CHECK(dyn_hipHostGetFlags_ptr(&expect_flags_with_ptr, h));
|
|
REQUIRE(expect_flags == flag);
|
|
REQUIRE(expect_flags_with_ptr == flag);
|
|
|
|
REQUIRE(expect_flags_with_ptr == expect_flags);
|
|
|
|
HIP_CHECK(hipFree(h));
|
|
}
|
|
}
|
|
|
|
// Validating hipMallocPitch API
|
|
{
|
|
void* pitchedMem_ptr = nullptr;
|
|
size_t pitch_ptr = -1;
|
|
int width1 = 260;
|
|
int height1 = 2;
|
|
|
|
HIP_CHECK(dyn_hipMallocPitch_ptr(&pitchedMem_ptr, &pitch_ptr, width1, height1));
|
|
|
|
size_t pitchedMem_sizeptr = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(pitchedMem_ptr, &pitchedMem_sizeptr));
|
|
REQUIRE(pitchedMem_sizeptr == 1024);
|
|
|
|
HIP_CHECK(hipFree(pitchedMem_ptr));
|
|
}
|
|
|
|
// Validating hipMemAllocPitch API
|
|
{
|
|
hipDeviceptr_t pitchedMem_ptr = nullptr;
|
|
size_t pitch_ptr = -1;
|
|
int width = 260;
|
|
int height = 2;
|
|
unsigned int groupOfElementSizeBytes[] = {4, 8, 16};
|
|
size_t pitchedMem_sizeptr = -1;
|
|
|
|
for (auto elementSizeBytes : groupOfElementSizeBytes) {
|
|
pitchedMem_ptr = nullptr;
|
|
pitch_ptr = -1;
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemAllocPitch_ptr(&pitchedMem_ptr, &pitch_ptr, width, height, elementSizeBytes));
|
|
|
|
REQUIRE(pitch_ptr == 512);
|
|
pitchedMem_sizeptr = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(pitchedMem_ptr, &pitchedMem_sizeptr));
|
|
REQUIRE(pitchedMem_sizeptr == 1024);
|
|
|
|
HIP_CHECK(hipFree(pitchedMem_ptr));
|
|
}
|
|
}
|
|
|
|
// Validating hipFreeHost API
|
|
{
|
|
void* h_ptr = nullptr;
|
|
HIP_CHECK(hipMallocHost(&h_ptr, 128));
|
|
REQUIRE(h_ptr != nullptr);
|
|
|
|
size_t h_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(h_ptr, &h_ptr_size));
|
|
HIP_CHECK(dyn_hipFreeHost_ptr(h_ptr));
|
|
REQUIRE(hipMemPtrGetInfo(h_ptr, &h_ptr_size) == hipErrorInvalidValue);
|
|
}
|
|
|
|
// Validating hipHostFree API
|
|
{
|
|
void* h_ptr = nullptr;
|
|
HIP_CHECK(hipMallocHost(&h_ptr, 128));
|
|
REQUIRE(h_ptr != nullptr);
|
|
|
|
size_t h_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(h_ptr, &h_ptr_size));
|
|
HIP_CHECK(dyn_hipHostFree_ptr(h_ptr));
|
|
REQUIRE(hipMemPtrGetInfo(h_ptr, &h_ptr_size) == hipErrorInvalidValue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Register and unregister) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisRegisterUnReg") {
|
|
void* hipHostRegister_ptr = nullptr;
|
|
void* hipHostUnregister_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipHostRegister", &hipHostRegister_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipHostUnregister", &hipHostUnregister_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
|
|
hipError_t (*dyn_hipHostRegister_ptr)(void*, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, unsigned int)>(hipHostRegister_ptr);
|
|
|
|
hipError_t (*dyn_hipHostUnregister_ptr)(void*) =
|
|
reinterpret_cast<hipError_t (*)(void*)>(hipHostUnregister_ptr);
|
|
|
|
// Validating hipHostRegister API
|
|
void* reg_h_ptr = nullptr;
|
|
reg_h_ptr = malloc(1024);
|
|
REQUIRE(reg_h_ptr != nullptr);
|
|
|
|
unsigned int reg_flags = hipHostRegisterDefault;
|
|
HIP_CHECK(dyn_hipHostRegister_ptr(reg_h_ptr, 1024, reg_flags));
|
|
|
|
void* devicePtrReg_ptr = nullptr;
|
|
HIP_CHECK(hipHostGetDevicePointer(&devicePtrReg_ptr, reg_h_ptr, 0));
|
|
REQUIRE(devicePtrReg_ptr != nullptr);
|
|
|
|
size_t reg_ptr_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(devicePtrReg_ptr, ®_ptr_size));
|
|
REQUIRE(reg_ptr_size == 1024);
|
|
|
|
// Validating hipHostUnregister API
|
|
HIP_CHECK(dyn_hipHostUnregister_ptr(reg_h_ptr));
|
|
|
|
REQUIRE(hipHostGetDevicePointer(&devicePtrReg_ptr, reg_h_ptr, 0) == hipErrorInvalidValue);
|
|
free(reg_h_ptr);
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Arrays) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisArrayRelated") {
|
|
CHECK_IMAGE_SUPPORT
|
|
|
|
void* hipMallocArray_ptr = nullptr;
|
|
void* hipArrayCreate_ptr = nullptr;
|
|
void* hipFreeArray_ptr = nullptr;
|
|
void* hipArrayDestroy_ptr = nullptr;
|
|
void* hipArrayGetInfo_ptr = nullptr;
|
|
void* hipArray3DCreate_ptr = nullptr;
|
|
void* hipArrayGetDescriptor_ptr = nullptr;
|
|
void* hipArray3DGetDescriptor_ptr = nullptr;
|
|
void* hipMalloc3DArray_ptr = nullptr;
|
|
void* hipMalloc3D_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMallocArray", &hipMallocArray_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipArrayCreate", &hipArrayCreate_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipFreeArray", &hipFreeArray_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipArrayDestroy", &hipArrayDestroy_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipArrayGetInfo", &hipArrayGetInfo_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipArray3DCreate", &hipArray3DCreate_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipArrayGetDescriptor", &hipArrayGetDescriptor_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipArray3DGetDescriptor", &hipArray3DGetDescriptor_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMalloc3DArray", &hipMalloc3DArray_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMalloc3D", &hipMalloc3D_ptr, currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMallocArray_ptr)(hipArray_t*, const hipChannelFormatDesc*, size_t, size_t,
|
|
unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t*, const hipChannelFormatDesc*, size_t, size_t,
|
|
unsigned int)>(hipMallocArray_ptr);
|
|
|
|
hipError_t (*dyn_hipArrayCreate_ptr)(hipArray_t*, const HIP_ARRAY_DESCRIPTOR*) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t*, const HIP_ARRAY_DESCRIPTOR*)>(
|
|
hipArrayCreate_ptr);
|
|
|
|
hipError_t (*dyn_hipFreeArray_ptr)(hipArray_t) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t)>(hipFreeArray_ptr);
|
|
|
|
hipError_t (*dyn_hipArrayDestroy_ptr)(hipArray_t) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t)>(hipArrayDestroy_ptr);
|
|
|
|
hipError_t (*dyn_hipArrayGetInfo_ptr)(hipChannelFormatDesc*, hipExtent*, unsigned int*,
|
|
hipArray_t) =
|
|
reinterpret_cast<hipError_t (*)(hipChannelFormatDesc*, hipExtent*, unsigned int*,
|
|
hipArray_t)>(hipArrayGetInfo_ptr);
|
|
|
|
hipError_t (*dyn_hipArray3DCreate_ptr)(hipArray_t*, const HIP_ARRAY3D_DESCRIPTOR*) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t*, const HIP_ARRAY3D_DESCRIPTOR*)>(
|
|
hipArray3DCreate_ptr);
|
|
|
|
hipError_t (*dyn_hipArrayGetDescriptor_ptr)(HIP_ARRAY_DESCRIPTOR*, hipArray_t) =
|
|
reinterpret_cast<hipError_t (*)(HIP_ARRAY_DESCRIPTOR*, hipArray_t)>(
|
|
hipArrayGetDescriptor_ptr);
|
|
|
|
hipError_t (*dyn_hipArray3DGetDescriptor_ptr)(HIP_ARRAY3D_DESCRIPTOR*, hipArray_t) =
|
|
reinterpret_cast<hipError_t (*)(HIP_ARRAY3D_DESCRIPTOR*, hipArray_t)>(
|
|
hipArray3DGetDescriptor_ptr);
|
|
|
|
hipError_t (*dyn_hipMalloc3DArray_ptr)(hipArray_t*, const struct hipChannelFormatDesc*,
|
|
struct hipExtent, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t*, const struct hipChannelFormatDesc*,
|
|
struct hipExtent, unsigned int)>(hipMalloc3DArray_ptr);
|
|
|
|
hipError_t (*dyn_hipMalloc3D_ptr)(hipPitchedPtr*, hipExtent) =
|
|
reinterpret_cast<hipError_t (*)(hipPitchedPtr*, hipExtent)>(hipMalloc3D_ptr);
|
|
|
|
// Validating hipMallocArray API
|
|
hipArray_t m_array = nullptr;
|
|
hipArray_t m_array_ptr = nullptr;
|
|
hipChannelFormatDesc m_desc = hipCreateChannelDesc<float>();
|
|
size_t m_width = 16;
|
|
size_t m_height = 16;
|
|
unsigned int m_flags = hipArrayDefault;
|
|
|
|
HIP_CHECK(hipMallocArray(&m_array, &m_desc, m_width, m_height, m_flags));
|
|
HIP_CHECK(dyn_hipMallocArray_ptr(&m_array_ptr, &m_desc, m_width, m_height, m_flags));
|
|
|
|
REQUIRE(m_array != nullptr);
|
|
REQUIRE(m_array_ptr != nullptr);
|
|
|
|
HIP_ARRAY_DESCRIPTOR m_array_desc;
|
|
HIP_CHECK(hipArrayGetDescriptor(&m_array_desc, m_array));
|
|
REQUIRE(m_array_desc.Width == m_width);
|
|
REQUIRE(m_array_desc.Height == m_height);
|
|
|
|
HIP_ARRAY_DESCRIPTOR m_array_ptr_desc;
|
|
HIP_CHECK(hipArrayGetDescriptor(&m_array_ptr_desc, m_array_ptr));
|
|
REQUIRE(m_array_ptr_desc.Width == m_width);
|
|
REQUIRE(m_array_ptr_desc.Height == m_height);
|
|
|
|
REQUIRE(m_array_ptr_desc.Width == m_array_desc.Width);
|
|
REQUIRE(m_array_ptr_desc.Height == m_array_desc.Height);
|
|
|
|
HIP_CHECK(hipFreeArray(m_array));
|
|
HIP_CHECK(hipFreeArray(m_array_ptr));
|
|
|
|
// Validating hipArrayCreate API
|
|
hipArray_t array = nullptr;
|
|
hipArray_t array_ptr = nullptr;
|
|
|
|
HIP_ARRAY_DESCRIPTOR desc;
|
|
desc.Format = HIP_AD_FORMAT_FLOAT;
|
|
desc.NumChannels = 1;
|
|
desc.Width = 8;
|
|
desc.Height = 8;
|
|
|
|
HIP_CHECK(hipArrayCreate(&array, &desc));
|
|
HIP_CHECK(dyn_hipArrayCreate_ptr(&array_ptr, &desc));
|
|
|
|
REQUIRE(array != nullptr);
|
|
REQUIRE(array_ptr != nullptr);
|
|
|
|
HIP_ARRAY_DESCRIPTOR array_desc;
|
|
HIP_CHECK(hipArrayGetDescriptor(&array_desc, array));
|
|
REQUIRE(array_desc.Width == desc.Width);
|
|
REQUIRE(array_desc.Height == desc.Height);
|
|
|
|
HIP_ARRAY_DESCRIPTOR array_ptr_desc;
|
|
HIP_CHECK(hipArrayGetDescriptor(&array_ptr_desc, array_ptr));
|
|
REQUIRE(array_ptr_desc.Width == desc.Width);
|
|
REQUIRE(array_ptr_desc.Height == desc.Height);
|
|
|
|
REQUIRE(array_ptr_desc.Width == array_desc.Width);
|
|
REQUIRE(array_ptr_desc.Height == array_desc.Height);
|
|
|
|
HIP_CHECK(hipFreeArray(array));
|
|
HIP_CHECK(hipFreeArray(array_ptr));
|
|
|
|
// Validating hipFreeArray API
|
|
hipArray_t f_array = nullptr;
|
|
hipArray_t f_array_ptr = nullptr;
|
|
|
|
HIP_CHECK(hipArrayCreate(&f_array, &desc));
|
|
HIP_CHECK(hipArrayCreate(&f_array_ptr, &desc));
|
|
|
|
REQUIRE(f_array != nullptr);
|
|
REQUIRE(f_array_ptr != nullptr);
|
|
|
|
HIP_CHECK(hipFreeArray(f_array));
|
|
HIP_CHECK(dyn_hipFreeArray_ptr(f_array_ptr));
|
|
|
|
HIP_ARRAY_DESCRIPTOR f_array_desc;
|
|
REQUIRE(hipArrayGetDescriptor(&f_array_desc, f_array) == hipErrorInvalidHandle);
|
|
REQUIRE(hipArrayGetDescriptor(&f_array_desc, f_array_ptr) == hipErrorInvalidHandle);
|
|
|
|
// Validating hipArrayDestroy API
|
|
hipArray_t d_array = nullptr;
|
|
hipArray_t d_array_ptr = nullptr;
|
|
|
|
HIP_CHECK(hipArrayCreate(&d_array, &desc));
|
|
HIP_CHECK(hipArrayCreate(&d_array_ptr, &desc));
|
|
|
|
REQUIRE(d_array != nullptr);
|
|
REQUIRE(d_array_ptr != nullptr);
|
|
|
|
HIP_CHECK(hipArrayDestroy(d_array));
|
|
HIP_CHECK(dyn_hipArrayDestroy_ptr(d_array_ptr));
|
|
|
|
HIP_ARRAY_DESCRIPTOR d_array_desc;
|
|
REQUIRE(hipArrayGetDescriptor(&d_array_desc, d_array) == hipErrorInvalidHandle);
|
|
REQUIRE(hipArrayGetDescriptor(&d_array_desc, d_array_ptr) == hipErrorInvalidHandle);
|
|
|
|
// Validating hipArrayGetInfo API
|
|
hipArray_t gi_array = nullptr;
|
|
hipArray_t gi_array_ptr = nullptr;
|
|
|
|
HIP_ARRAY_DESCRIPTOR gi_desc;
|
|
gi_desc.Format = HIP_AD_FORMAT_FLOAT;
|
|
gi_desc.NumChannels = 1;
|
|
gi_desc.Width = 64;
|
|
gi_desc.Height = 64;
|
|
|
|
HIP_CHECK(hipArrayCreate(&gi_array, &gi_desc));
|
|
HIP_CHECK(hipArrayCreate(&gi_array_ptr, &gi_desc));
|
|
|
|
REQUIRE(gi_array != nullptr);
|
|
REQUIRE(gi_array_ptr != nullptr);
|
|
|
|
hipChannelFormatDesc gi_array_desc;
|
|
hipExtent gi_array_extent;
|
|
unsigned int gi_array_flags;
|
|
HIP_CHECK(hipArrayGetInfo(&gi_array_desc, &gi_array_extent, &gi_array_flags, gi_array));
|
|
REQUIRE(gi_array_desc.x == 32);
|
|
REQUIRE(gi_array_desc.y == 0);
|
|
REQUIRE(gi_array_desc.z == 0);
|
|
REQUIRE(gi_array_desc.w == 0);
|
|
REQUIRE(gi_array_desc.f == hipChannelFormatKindFloat);
|
|
REQUIRE(gi_array_extent.width == 64);
|
|
REQUIRE(gi_array_extent.height == 64);
|
|
REQUIRE(gi_array_extent.depth == 0);
|
|
REQUIRE(gi_array_flags == 0);
|
|
|
|
hipChannelFormatDesc gi_array_desc_ptr;
|
|
hipExtent gi_array_extent_ptr;
|
|
unsigned int gi_array_flags_ptr;
|
|
HIP_CHECK(dyn_hipArrayGetInfo_ptr(&gi_array_desc_ptr, &gi_array_extent_ptr, &gi_array_flags_ptr,
|
|
gi_array_ptr));
|
|
REQUIRE(gi_array_desc_ptr.x == 32);
|
|
REQUIRE(gi_array_desc_ptr.y == 0);
|
|
REQUIRE(gi_array_desc_ptr.z == 0);
|
|
REQUIRE(gi_array_desc_ptr.w == 0);
|
|
REQUIRE(gi_array_desc_ptr.f == hipChannelFormatKindFloat);
|
|
REQUIRE(gi_array_extent_ptr.width == 64);
|
|
REQUIRE(gi_array_extent_ptr.height == 64);
|
|
REQUIRE(gi_array_extent_ptr.depth == 0);
|
|
REQUIRE(gi_array_flags_ptr == 0);
|
|
|
|
REQUIRE(gi_array_desc_ptr.x == gi_array_desc.x);
|
|
REQUIRE(gi_array_desc_ptr.y == gi_array_desc.y);
|
|
REQUIRE(gi_array_desc_ptr.z == gi_array_desc.z);
|
|
REQUIRE(gi_array_desc_ptr.w == gi_array_desc.w);
|
|
REQUIRE(gi_array_desc_ptr.f == gi_array_desc.f);
|
|
REQUIRE(gi_array_extent_ptr.width == gi_array_extent.width);
|
|
REQUIRE(gi_array_extent_ptr.height == gi_array_extent.height);
|
|
REQUIRE(gi_array_extent_ptr.depth == gi_array_extent.depth);
|
|
REQUIRE(gi_array_flags_ptr == gi_array_flags);
|
|
|
|
HIP_CHECK(hipFreeArray(gi_array));
|
|
HIP_CHECK(hipFreeArray(gi_array_ptr));
|
|
|
|
// Validating hipArrayGetDescriptor API
|
|
hipArray_t gd_array = nullptr;
|
|
hipArray_t gd_array_ptr = nullptr;
|
|
|
|
HIP_ARRAY_DESCRIPTOR gd_desc;
|
|
gd_desc.Format = HIP_AD_FORMAT_FLOAT;
|
|
gd_desc.NumChannels = 1;
|
|
gd_desc.Width = 32;
|
|
gd_desc.Height = 32;
|
|
|
|
HIP_CHECK(hipArrayCreate(&gd_array, &gd_desc));
|
|
HIP_CHECK(hipArrayCreate(&gd_array_ptr, &gd_desc));
|
|
|
|
REQUIRE(gd_array != nullptr);
|
|
REQUIRE(gd_array_ptr != nullptr);
|
|
|
|
HIP_ARRAY_DESCRIPTOR gd_array_desc;
|
|
HIP_CHECK(hipArrayGetDescriptor(&gd_array_desc, gd_array));
|
|
REQUIRE(gd_array_desc.Format == HIP_AD_FORMAT_FLOAT);
|
|
REQUIRE(gd_array_desc.NumChannels == 1);
|
|
REQUIRE(gd_array_desc.Width == 32);
|
|
REQUIRE(gd_array_desc.Height == 32);
|
|
|
|
HIP_ARRAY_DESCRIPTOR gd_array_desc_ptr;
|
|
HIP_CHECK(dyn_hipArrayGetDescriptor_ptr(&gd_array_desc_ptr, gd_array_ptr));
|
|
REQUIRE(gd_array_desc_ptr.Format == HIP_AD_FORMAT_FLOAT);
|
|
REQUIRE(gd_array_desc_ptr.NumChannels == 1);
|
|
REQUIRE(gd_array_desc_ptr.Width == 32);
|
|
REQUIRE(gd_array_desc_ptr.Height == 32);
|
|
|
|
REQUIRE(gd_array_desc_ptr.Format == gd_array_desc.Format);
|
|
REQUIRE(gd_array_desc_ptr.NumChannels == gd_array_desc.NumChannels);
|
|
REQUIRE(gd_array_desc_ptr.Width == gd_array_desc.Width);
|
|
REQUIRE(gd_array_desc_ptr.Height == gd_array_desc.Height);
|
|
|
|
HIP_CHECK(hipFreeArray(gd_array));
|
|
HIP_CHECK(hipFreeArray(gd_array_ptr));
|
|
|
|
// Validating hipArray3DCreate API
|
|
hipArray_t array3d = nullptr;
|
|
hipArray_t array3d_ptr = nullptr;
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR desc3d;
|
|
desc3d.Format = HIP_AD_FORMAT_FLOAT;
|
|
desc3d.NumChannels = 1;
|
|
desc3d.Width = 8;
|
|
desc3d.Height = 4;
|
|
desc3d.Depth = 2;
|
|
|
|
HIP_CHECK(hipArray3DCreate(&array3d, &desc3d));
|
|
HIP_CHECK(dyn_hipArray3DCreate_ptr(&array3d_ptr, &desc3d));
|
|
|
|
REQUIRE(array3d != nullptr);
|
|
REQUIRE(array3d_ptr != nullptr);
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR array_desc3d;
|
|
HIP_CHECK(hipArray3DGetDescriptor(&array_desc3d, array3d));
|
|
REQUIRE(array_desc3d.Width == desc3d.Width);
|
|
REQUIRE(array_desc3d.Height == desc3d.Height);
|
|
REQUIRE(array_desc3d.Depth == desc3d.Depth);
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR array_ptr_desc3d;
|
|
HIP_CHECK(hipArray3DGetDescriptor(&array_ptr_desc3d, array3d_ptr));
|
|
REQUIRE(array_ptr_desc3d.Width == desc3d.Width);
|
|
REQUIRE(array_ptr_desc3d.Height == desc3d.Height);
|
|
REQUIRE(array_ptr_desc3d.Depth == desc3d.Depth);
|
|
|
|
REQUIRE(array_ptr_desc3d.Width == array_desc3d.Width);
|
|
REQUIRE(array_ptr_desc3d.Height == array_desc3d.Height);
|
|
REQUIRE(array_ptr_desc3d.Depth == array_desc3d.Depth);
|
|
|
|
HIP_CHECK(hipArrayDestroy(array3d));
|
|
HIP_CHECK(hipArrayDestroy(array3d_ptr));
|
|
|
|
// Validating hipArray3DGetDescriptor API
|
|
hipArray_t gd_array3d = nullptr;
|
|
hipArray_t gd_array3d_ptr = nullptr;
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR gd_desc3d;
|
|
gd_desc3d.Format = HIP_AD_FORMAT_FLOAT;
|
|
gd_desc3d.NumChannels = 1;
|
|
gd_desc3d.Width = 16;
|
|
gd_desc3d.Height = 4;
|
|
gd_desc3d.Depth = 8;
|
|
|
|
HIP_CHECK(hipArray3DCreate(&gd_array3d, &gd_desc3d));
|
|
HIP_CHECK(hipArray3DCreate(&gd_array3d_ptr, &gd_desc3d));
|
|
|
|
REQUIRE(gd_array3d != nullptr);
|
|
REQUIRE(gd_array3d_ptr != nullptr);
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR gd_array_desc3d;
|
|
HIP_CHECK(hipArray3DGetDescriptor(&gd_array_desc3d, gd_array3d));
|
|
REQUIRE(gd_array_desc3d.Width == gd_desc3d.Width);
|
|
REQUIRE(gd_array_desc3d.Height == gd_desc3d.Height);
|
|
REQUIRE(gd_array_desc3d.Depth == gd_desc3d.Depth);
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR gd_array_ptr_desc3d;
|
|
HIP_CHECK(dyn_hipArray3DGetDescriptor_ptr(&gd_array_ptr_desc3d, gd_array3d_ptr));
|
|
REQUIRE(gd_array_ptr_desc3d.Width == gd_desc3d.Width);
|
|
REQUIRE(gd_array_ptr_desc3d.Height == gd_desc3d.Height);
|
|
REQUIRE(gd_array_ptr_desc3d.Depth == gd_desc3d.Depth);
|
|
|
|
REQUIRE(gd_array_ptr_desc3d.Width == gd_array_desc3d.Width);
|
|
REQUIRE(gd_array_ptr_desc3d.Height == gd_array_desc3d.Height);
|
|
REQUIRE(gd_array_ptr_desc3d.Depth == gd_array_desc3d.Depth);
|
|
|
|
HIP_CHECK(hipArrayDestroy(gd_array3d));
|
|
HIP_CHECK(hipArrayDestroy(gd_array3d_ptr));
|
|
|
|
// Validating hipMalloc3DArray API
|
|
hipArray_t m_array3d = nullptr;
|
|
hipArray_t m_array3d_ptr = nullptr;
|
|
|
|
hipChannelFormatDesc m_desc3d = hipCreateChannelDesc<float>();
|
|
hipExtent m_extent3d{12, 16, 8};
|
|
unsigned int m_flags3d = hipArrayDefault;
|
|
|
|
HIP_CHECK(hipMalloc3DArray(&m_array3d, &m_desc3d, m_extent3d, m_flags3d));
|
|
HIP_CHECK(dyn_hipMalloc3DArray_ptr(&m_array3d_ptr, &m_desc3d, m_extent3d, m_flags3d));
|
|
|
|
REQUIRE(m_array3d != nullptr);
|
|
REQUIRE(m_array3d_ptr != nullptr);
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR m_array_desc3d;
|
|
HIP_CHECK(hipArray3DGetDescriptor(&m_array_desc3d, m_array3d));
|
|
REQUIRE(m_array_desc3d.Width == 12);
|
|
REQUIRE(m_array_desc3d.Height == 16);
|
|
REQUIRE(m_array_desc3d.Depth == 8);
|
|
|
|
HIP_ARRAY3D_DESCRIPTOR m_array_ptr_desc3d;
|
|
HIP_CHECK(hipArray3DGetDescriptor(&m_array_ptr_desc3d, m_array3d_ptr));
|
|
REQUIRE(m_array_ptr_desc3d.Width == 12);
|
|
REQUIRE(m_array_ptr_desc3d.Height == 16);
|
|
REQUIRE(m_array_ptr_desc3d.Depth == 8);
|
|
|
|
REQUIRE(m_array_ptr_desc3d.Width == m_array_desc3d.Width);
|
|
REQUIRE(m_array_ptr_desc3d.Height == m_array_desc3d.Height);
|
|
REQUIRE(m_array_ptr_desc3d.Depth == m_array_desc3d.Depth);
|
|
|
|
HIP_CHECK(hipFreeArray(m_array3d));
|
|
HIP_CHECK(hipFreeArray(m_array3d_ptr));
|
|
|
|
// Validating hipMalloc3D API
|
|
hipPitchedPtr p_array3d;
|
|
hipPitchedPtr p_array3d_ptr;
|
|
|
|
hipExtent p_extent3d{260, 16, 8};
|
|
HIP_CHECK(hipMalloc3D(&p_array3d, p_extent3d));
|
|
HIP_CHECK(dyn_hipMalloc3D_ptr(&p_array3d_ptr, p_extent3d));
|
|
|
|
REQUIRE(p_array3d.ptr != nullptr);
|
|
size_t p_size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(p_array3d.ptr, &p_size));
|
|
REQUIRE(p_size == 65536);
|
|
REQUIRE(p_array3d.pitch == 512);
|
|
REQUIRE(p_array3d.xsize == 260);
|
|
REQUIRE(p_array3d.ysize == 16);
|
|
|
|
REQUIRE(p_array3d_ptr.ptr != nullptr);
|
|
size_t p_size_ptr = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(p_array3d_ptr.ptr, &p_size_ptr));
|
|
REQUIRE(p_size_ptr == 65536);
|
|
REQUIRE(p_array3d_ptr.pitch == 512);
|
|
REQUIRE(p_array3d_ptr.xsize == 260);
|
|
REQUIRE(p_array3d_ptr.ysize == 16);
|
|
|
|
REQUIRE(p_size_ptr == p_size);
|
|
REQUIRE(p_array3d_ptr.pitch == p_array3d.pitch);
|
|
REQUIRE(p_array3d_ptr.xsize == p_array3d.xsize);
|
|
REQUIRE(p_array3d_ptr.ysize == p_array3d.ysize);
|
|
|
|
HIP_CHECK(hipFree(p_array3d.ptr));
|
|
HIP_CHECK(hipFree(p_array3d_ptr.ptr));
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Set and Get Attributes) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisSetAndGetAttributes") {
|
|
void* hipPointerGetAttribute_ptr = nullptr;
|
|
void* hipPointerGetAttributes_ptr = nullptr;
|
|
void* hipDrvPointerGetAttributes_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipPointerGetAttribute", &hipPointerGetAttribute_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipPointerGetAttributes", &hipPointerGetAttributes_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipDrvPointerGetAttributes", &hipDrvPointerGetAttributes_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipPointerGetAttribute_ptr)(void*, hipPointer_attribute, hipDeviceptr_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, hipPointer_attribute, hipDeviceptr_t)>(
|
|
hipPointerGetAttribute_ptr);
|
|
hipError_t (*dyn_hipPointerGetAttributes_ptr)(hipPointerAttribute_t*, const void*) =
|
|
reinterpret_cast<hipError_t (*)(hipPointerAttribute_t*, const void*)>(
|
|
hipPointerGetAttributes_ptr);
|
|
hipError_t (*dyn_hipDrvPointerGetAttributes_ptr)(unsigned int, hipPointer_attribute*, void**,
|
|
hipDeviceptr_t) =
|
|
reinterpret_cast<hipError_t (*)(unsigned int, hipPointer_attribute*, void**, hipDeviceptr_t)>(
|
|
hipDrvPointerGetAttributes_ptr);
|
|
|
|
#if __linux__
|
|
// Validating hipPointerSetAttribute API
|
|
{
|
|
void* hipPointerSetAttribute_ptr = nullptr;
|
|
HIP_CHECK(hipGetProcAddress("hipPointerSetAttribute", &hipPointerSetAttribute_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipPointerSetAttribute_ptr)(const void*, hipPointer_attribute,
|
|
hipDeviceptr_t) =
|
|
reinterpret_cast<hipError_t (*)(const void*, hipPointer_attribute, hipDeviceptr_t)>(
|
|
hipPointerSetAttribute_ptr);
|
|
|
|
void* devPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&devPtr, 1024));
|
|
REQUIRE(devPtr != nullptr);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_CONTEXT
|
|
int attrDataContext = 10;
|
|
if (hipPointerSetAttribute(&attrDataContext, HIP_POINTER_ATTRIBUTE_CONTEXT,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataContext, HIP_POINTER_ATTRIBUTE_CONTEXT,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_MEMORY_TYPE
|
|
int attrDataMemoryType = 1;
|
|
if (hipPointerSetAttribute(&attrDataMemoryType, HIP_POINTER_ATTRIBUTE_MEMORY_TYPE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataMemoryType,
|
|
HIP_POINTER_ATTRIBUTE_MEMORY_TYPE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_DEVICE_POINTER
|
|
uint64_t attrDataDevicePointerUl = (uint64_t)devPtr;
|
|
if (hipPointerSetAttribute(&attrDataDevicePointerUl, HIP_POINTER_ATTRIBUTE_DEVICE_POINTER,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataDevicePointerUl,
|
|
HIP_POINTER_ATTRIBUTE_DEVICE_POINTER,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_HOST_POINTER
|
|
uint64_t attrDataHostPointer = (uint64_t)devPtr;
|
|
if (hipPointerSetAttribute(&attrDataHostPointer, HIP_POINTER_ATTRIBUTE_HOST_POINTER,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataHostPointer,
|
|
HIP_POINTER_ATTRIBUTE_HOST_POINTER,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_P2P_TOKENS
|
|
int attrDataP2pTokens = 1;
|
|
if (hipPointerSetAttribute(&attrDataP2pTokens, HIP_POINTER_ATTRIBUTE_P2P_TOKENS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataP2pTokens, HIP_POINTER_ATTRIBUTE_P2P_TOKENS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS
|
|
int attrDataSyncMemops = 1;
|
|
if (hipPointerSetAttribute(&attrDataSyncMemops, HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataSyncMemops,
|
|
HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_BUFFER_ID
|
|
int attrDataBufferId = 1;
|
|
if (hipPointerSetAttribute(&attrDataBufferId, HIP_POINTER_ATTRIBUTE_BUFFER_ID,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataBufferId, HIP_POINTER_ATTRIBUTE_BUFFER_ID,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_IS_MANAGED
|
|
int attrDataIsManaged = 1;
|
|
if (hipPointerSetAttribute(&attrDataIsManaged, HIP_POINTER_ATTRIBUTE_IS_MANAGED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataIsManaged, HIP_POINTER_ATTRIBUTE_IS_MANAGED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL
|
|
int attrDataDeviceOrdinal = 1;
|
|
if (hipPointerSetAttribute(&attrDataDeviceOrdinal, HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataDeviceOrdinal,
|
|
HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE
|
|
int attrDataIsLegacyHipIpcCapable = 1;
|
|
if (hipPointerSetAttribute(&attrDataIsLegacyHipIpcCapable,
|
|
HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataIsLegacyHipIpcCapable,
|
|
HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR
|
|
uint64_t attrDataRangeStartAddrUl = (uint64_t)devPtr;
|
|
if (hipPointerSetAttribute(&attrDataRangeStartAddrUl, HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataRangeStartAddrUl,
|
|
HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_RANGE_SIZE
|
|
int attrDataRangeSize = 1024;
|
|
if (hipPointerSetAttribute(&attrDataRangeSize, HIP_POINTER_ATTRIBUTE_RANGE_SIZE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataRangeSize, HIP_POINTER_ATTRIBUTE_RANGE_SIZE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_MAPPED
|
|
int attributeDataMapped = 1;
|
|
if (hipPointerSetAttribute(&attributeDataMapped, HIP_POINTER_ATTRIBUTE_MAPPED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attributeDataMapped, HIP_POINTER_ATTRIBUTE_MAPPED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES
|
|
int attrDataAllowedHandleTypes = 1;
|
|
if (hipPointerSetAttribute(&attrDataAllowedHandleTypes,
|
|
HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataAllowedHandleTypes,
|
|
HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE
|
|
int attrDataIsGpuDirectRdmaCapable = 1;
|
|
if (hipPointerSetAttribute(&attrDataIsGpuDirectRdmaCapable,
|
|
HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataIsGpuDirectRdmaCapable,
|
|
HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS
|
|
int attrDataAccessFlags = 1;
|
|
if (hipPointerSetAttribute(&attrDataAccessFlags, HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataAccessFlags,
|
|
HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
// HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE
|
|
int attrDataMempoolHandle = 1;
|
|
if (hipPointerSetAttribute(&attrDataMempoolHandle, HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)) == hipSuccess) {
|
|
HIP_CHECK(dyn_hipPointerSetAttribute_ptr(&attrDataMempoolHandle,
|
|
HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr)));
|
|
}
|
|
HIP_CHECK(hipFree(devPtr));
|
|
}
|
|
#endif
|
|
|
|
// Validating hipPointerGetAttribute API
|
|
{
|
|
void* devPtr1 = nullptr;
|
|
HIP_CHECK(hipMalloc(&devPtr1, 1024));
|
|
REQUIRE(devPtr1 != nullptr);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_MEMORY_TYPE
|
|
hipMemoryType memType;
|
|
HIP_CHECK(hipPointerGetAttribute(&memType, HIP_POINTER_ATTRIBUTE_MEMORY_TYPE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
hipMemoryType memTypeWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&memTypeWithPtr, HIP_POINTER_ATTRIBUTE_MEMORY_TYPE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(memTypeWithPtr == memType);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_DEVICE_POINTER
|
|
hipDeviceptr_t devPointer = nullptr;
|
|
HIP_CHECK(hipPointerGetAttribute(&devPointer, HIP_POINTER_ATTRIBUTE_DEVICE_POINTER,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
hipDeviceptr_t devPointerWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&devPointerWithPtr,
|
|
HIP_POINTER_ATTRIBUTE_DEVICE_POINTER,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(devPointerWithPtr == devPointer);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS
|
|
bool syncMemOps;
|
|
HIP_CHECK(hipPointerGetAttribute(&syncMemOps, HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
bool syncMemOpsWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&syncMemOpsWithPtr, HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(syncMemOpsWithPtr == syncMemOps);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_BUFFER_ID
|
|
int bufferId;
|
|
HIP_CHECK(hipPointerGetAttribute(&bufferId, HIP_POINTER_ATTRIBUTE_BUFFER_ID,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
int bufferIdWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&bufferIdWithPtr, HIP_POINTER_ATTRIBUTE_BUFFER_ID,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(bufferIdWithPtr == bufferId);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_IS_MANAGED
|
|
bool isManaged;
|
|
HIP_CHECK(hipPointerGetAttribute(&isManaged, HIP_POINTER_ATTRIBUTE_IS_MANAGED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
bool isManagedWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&isManagedWithPtr, HIP_POINTER_ATTRIBUTE_IS_MANAGED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(isManagedWithPtr == isManaged);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL
|
|
int deviceOrdinal;
|
|
HIP_CHECK(hipPointerGetAttribute(&deviceOrdinal, HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
int deviceOrdinalWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&deviceOrdinalWithPtr,
|
|
HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(deviceOrdinalWithPtr == deviceOrdinal);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR
|
|
hipDeviceptr_t startAddr = nullptr;
|
|
HIP_CHECK(hipPointerGetAttribute(&startAddr, HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
hipDeviceptr_t startAddrWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&startAddrWithPtr,
|
|
HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(startAddrWithPtr == startAddr);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_RANGE_SIZE
|
|
int rangeSizeVal;
|
|
HIP_CHECK(hipPointerGetAttribute(&rangeSizeVal, HIP_POINTER_ATTRIBUTE_RANGE_SIZE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
int rangeSizeValWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&rangeSizeValWithPtr, HIP_POINTER_ATTRIBUTE_RANGE_SIZE,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(rangeSizeValWithPtr == rangeSizeVal);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_MAPPED
|
|
bool isMapped;
|
|
HIP_CHECK(hipPointerGetAttribute(&isMapped, HIP_POINTER_ATTRIBUTE_MAPPED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
bool isMappedWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&isMappedWithPtr, HIP_POINTER_ATTRIBUTE_MAPPED,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(isMappedWithPtr == isMapped);
|
|
|
|
// HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS
|
|
int accessFlags;
|
|
HIP_CHECK(hipPointerGetAttribute(&accessFlags, HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
int accessFlagsWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttribute_ptr(&accessFlagsWithPtr,
|
|
HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS,
|
|
reinterpret_cast<hipDeviceptr_t>(devPtr1)));
|
|
REQUIRE(accessFlagsWithPtr == accessFlags);
|
|
|
|
HIP_CHECK(hipFree(devPtr1));
|
|
}
|
|
|
|
// Validating hipPointerGetAttributes API
|
|
{
|
|
void* devPtr2 = nullptr;
|
|
HIP_CHECK(hipMalloc(&devPtr2, 1024));
|
|
REQUIRE(devPtr2 != nullptr);
|
|
|
|
hipPointerAttribute_t allAttributesData;
|
|
HIP_CHECK(hipPointerGetAttributes(&allAttributesData, devPtr2));
|
|
|
|
hipPointerAttribute_t allAttributesDataWithPtr;
|
|
HIP_CHECK(dyn_hipPointerGetAttributes_ptr(&allAttributesDataWithPtr, devPtr2));
|
|
|
|
REQUIRE(allAttributesDataWithPtr.type == allAttributesData.type);
|
|
REQUIRE(allAttributesDataWithPtr.device == allAttributesData.device);
|
|
REQUIRE(allAttributesDataWithPtr.devicePointer == allAttributesData.devicePointer);
|
|
REQUIRE(allAttributesDataWithPtr.hostPointer == allAttributesData.hostPointer);
|
|
REQUIRE(allAttributesDataWithPtr.isManaged == allAttributesData.isManaged);
|
|
REQUIRE(allAttributesDataWithPtr.allocationFlags == allAttributesData.allocationFlags);
|
|
HIP_CHECK(hipFree(devPtr2));
|
|
}
|
|
|
|
// Validating hipDrvPointerGetAttributes API
|
|
{
|
|
void* devPtr3 = nullptr;
|
|
HIP_CHECK(hipMalloc(&devPtr3, 1024));
|
|
REQUIRE(devPtr3 != nullptr);
|
|
|
|
hipPointer_attribute requiredAttributes[] = {
|
|
HIP_POINTER_ATTRIBUTE_MEMORY_TYPE, HIP_POINTER_ATTRIBUTE_DEVICE_POINTER,
|
|
HIP_POINTER_ATTRIBUTE_RANGE_SIZE, HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR};
|
|
|
|
unsigned int memoryType = -1;
|
|
void* devicePointer = nullptr;
|
|
unsigned int rangeSize = -1;
|
|
void* startAddress = nullptr;
|
|
void* requiredData[] = {&memoryType, &devicePointer, &rangeSize, &startAddress};
|
|
|
|
HIP_CHECK(hipDrvPointerGetAttributes(4, requiredAttributes, requiredData, devPtr3));
|
|
|
|
unsigned int memoryTypeWithPtr = -1;
|
|
void* devicePointerWithPtr = nullptr;
|
|
unsigned int rangeSizeWithPtr = -1;
|
|
void* startAddressWithPtr = nullptr;
|
|
void* requiredDataWithPtr[] = {&memoryTypeWithPtr, &devicePointerWithPtr, &rangeSizeWithPtr,
|
|
&startAddressWithPtr};
|
|
|
|
HIP_CHECK(
|
|
dyn_hipDrvPointerGetAttributes_ptr(4, requiredAttributes, requiredDataWithPtr, devPtr3));
|
|
|
|
REQUIRE(memoryTypeWithPtr == memoryType);
|
|
REQUIRE(devicePointerWithPtr == devicePointer);
|
|
REQUIRE(rangeSizeWithPtr == rangeSize);
|
|
REQUIRE(startAddressWithPtr == startAddress);
|
|
|
|
HIP_CHECK(hipFree(devPtr3));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memory copy) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMemCopy") {
|
|
void* hipMemcpyHtoD_ptr = nullptr;
|
|
void* hipMemcpyDtoH_ptr = nullptr;
|
|
void* hipMemcpyDtoD_ptr = nullptr;
|
|
void* hipMemcpy_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyHtoD", &hipMemcpyHtoD_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyDtoH", &hipMemcpyDtoH_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyDtoD", &hipMemcpyDtoD_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy", &hipMemcpy_ptr, currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMemcpyHtoD_ptr)(hipDeviceptr_t, void*, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, void*, size_t)>(hipMemcpyHtoD_ptr);
|
|
hipError_t (*dyn_hipMemcpyDtoH_ptr)(void*, hipDeviceptr_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, hipDeviceptr_t, size_t)>(hipMemcpyDtoH_ptr);
|
|
hipError_t (*dyn_hipMemcpyDtoD_ptr)(hipDeviceptr_t, hipDeviceptr_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, hipDeviceptr_t, size_t)>(hipMemcpyDtoD_ptr);
|
|
hipError_t (*dyn_hipMemcpy_ptr)(void*, const void*, size_t, hipMemcpyKind) =
|
|
reinterpret_cast<hipError_t (*)(void*, const void*, size_t, hipMemcpyKind)>(hipMemcpy_ptr);
|
|
int N = 128;
|
|
int Nbytes = N * sizeof(int);
|
|
int value = 15;
|
|
|
|
// Validating hipMemcpyHtoD API
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpyHtoD_ptr(devMem, hostMem, Nbytes));
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemcpyDtoH API
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpyDtoH_ptr(hostMem, devMem, Nbytes));
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemcpyDtoD API
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpyDtoD_ptr(dstDevMem, devMem, Nbytes));
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
|
|
// Validating hipMemcpy API
|
|
{
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* dstHostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(dstHostMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(dstHostMem, hostMem, Nbytes, hipMemcpyHostToHost));
|
|
REQUIRE(validateHostArray(dstHostMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(dstHostMem);
|
|
}
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(devMem, hostMem, Nbytes, hipMemcpyHostToDevice));
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(dstDevMem, devMem, Nbytes, hipMemcpyDeviceToDevice));
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(dstDevMem, devMem, Nbytes, hipMemcpyDeviceToDeviceNoCU));
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* dstHostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(dstHostMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(dstHostMem, hostMem, Nbytes, hipMemcpyDefault));
|
|
REQUIRE(validateHostArray(dstHostMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(dstHostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(devMem, hostMem, Nbytes, hipMemcpyDefault));
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(hostMem, devMem, Nbytes, hipMemcpyDefault));
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpy_ptr(dstDevMem, devMem, Nbytes, hipMemcpyDefault));
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memory copy with stream) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMemCopyWithStreams") {
|
|
void* hipMemcpyHtoDAsync_ptr = nullptr;
|
|
void* hipMemcpyDtoHAsync_ptr = nullptr;
|
|
void* hipMemcpyDtoDAsync_ptr = nullptr;
|
|
void* hipMemcpyAsync_ptr = nullptr;
|
|
void* hipMemcpyWithStream_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyHtoDAsync", &hipMemcpyHtoDAsync_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyDtoHAsync", &hipMemcpyDtoHAsync_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyDtoDAsync", &hipMemcpyDtoDAsync_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemcpyAsync", &hipMemcpyAsync_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyWithStream", &hipMemcpyWithStream_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
|
|
hipError_t (*dyn_hipMemcpyHtoDAsync_ptr)(hipDeviceptr_t, void*, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, void*, size_t, hipStream_t)>(
|
|
hipMemcpyHtoDAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpyDtoHAsync_ptr)(void*, hipDeviceptr_t, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, hipDeviceptr_t, size_t, hipStream_t)>(
|
|
hipMemcpyDtoHAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpyDtoDAsync_ptr)(hipDeviceptr_t, hipDeviceptr_t, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, hipDeviceptr_t, size_t, hipStream_t)>(
|
|
hipMemcpyDtoDAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpyAsync_ptr)(void*, const void*, size_t, hipMemcpyKind, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, const void*, size_t, hipMemcpyKind, hipStream_t)>(
|
|
hipMemcpyAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpyWithStream_ptr)(void*, const void*, size_t, hipMemcpyKind,
|
|
hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, const void*, size_t, hipMemcpyKind, hipStream_t)>(
|
|
hipMemcpyWithStream_ptr);
|
|
int N = 4096;
|
|
const int Ns = 4;
|
|
int Nbytes = N * sizeof(int);
|
|
int value = 2;
|
|
// Validating hipMemcpyHtoDAsync API
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyHtoDAsync_ptr(devMem + startIndex, hostMem + startIndex, (Nbytes / Ns),
|
|
stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// Validating hipMemcpyDtoHAsync API
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyDtoHAsync_ptr(hostMem + startIndex, devMem + startIndex, (Nbytes / Ns),
|
|
stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemcpyDtoDAsync API
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyDtoDAsync_ptr(dstDevMem + startIndex, devMem + startIndex,
|
|
(Nbytes / Ns), stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
|
|
// Validating hipMemcpyAsync API
|
|
{
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstHostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(dstHostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(dstHostMem + startIndex, hostMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyHostToHost, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(dstHostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
free(hostMem);
|
|
free(dstHostMem);
|
|
}
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(devMem + startIndex, hostMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyHostToDevice, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(hostMem + startIndex, devMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyDeviceToHost, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(dstDevMem + startIndex, devMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyDeviceToDevice, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(dstDevMem + startIndex, devMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyDeviceToDeviceNoCU, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstHostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(dstHostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(dstHostMem + startIndex, hostMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(dstHostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
free(hostMem);
|
|
free(dstHostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(devMem + startIndex, hostMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(hostMem + startIndex, devMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyAsync_ptr(dstDevMem + startIndex, devMem + startIndex, (Nbytes / Ns),
|
|
hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpyWithStream API
|
|
{
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstHostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(dstHostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(dstHostMem + startIndex, hostMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyHostToHost, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(dstHostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
free(hostMem);
|
|
free(dstHostMem);
|
|
}
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(devMem + startIndex, hostMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyHostToDevice, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(hostMem + startIndex, devMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDeviceToHost, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(dstDevMem + startIndex, devMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDeviceToDevice, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(dstDevMem + startIndex, devMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDeviceToDeviceNoCU,
|
|
stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstHostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(dstHostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(dstHostMem + startIndex, hostMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(dstHostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
free(hostMem);
|
|
free(dstHostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(devMem + startIndex, hostMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(hostMem + startIndex, devMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
int* dstDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevMem, Nbytes));
|
|
REQUIRE(dstDevMem != nullptr);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemcpyWithStream_ptr(dstDevMem + startIndex, devMem + startIndex,
|
|
(Nbytes / Ns), hipMemcpyDefault, stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
REQUIRE(validateDeviceArray(dstDevMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
HIP_CHECK(hipFree(dstDevMem));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memset) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMemset") {
|
|
void* hipMemsetD8_ptr = nullptr;
|
|
void* hipMemsetD16_ptr = nullptr;
|
|
void* hipMemsetD32_ptr = nullptr;
|
|
void* hipMemsetD8Async_ptr = nullptr;
|
|
void* hipMemsetD16Async_ptr = nullptr;
|
|
void* hipMemsetD32Async_ptr = nullptr;
|
|
void* hipMemset_ptr = nullptr;
|
|
void* hipMemsetAsync_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemsetD8", &hipMemsetD8_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemsetD16", &hipMemsetD16_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemsetD32", &hipMemsetD32_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemsetD8Async", &hipMemsetD8Async_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemsetD16Async", &hipMemsetD16Async_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemsetD32Async", &hipMemsetD32Async_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemset", &hipMemset_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemsetAsync", &hipMemsetAsync_ptr, currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMemsetD8_ptr)(hipDeviceptr_t, unsigned char, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, unsigned char, size_t)>(hipMemsetD8_ptr);
|
|
hipError_t (*dyn_hipMemsetD16_ptr)(hipDeviceptr_t, uint16_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, uint16_t, size_t)>(hipMemsetD16_ptr);
|
|
hipError_t (*dyn_hipMemsetD32_ptr)(hipDeviceptr_t, int, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, int, size_t)>(hipMemsetD32_ptr);
|
|
hipError_t (*dyn_hipMemsetD8Async_ptr)(hipDeviceptr_t, unsigned char, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, unsigned char, size_t, hipStream_t)>(
|
|
hipMemsetD8Async_ptr);
|
|
hipError_t (*dyn_hipMemsetD16Async_ptr)(hipDeviceptr_t, uint16_t, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, uint16_t, size_t, hipStream_t)>(
|
|
hipMemsetD16Async_ptr);
|
|
hipError_t (*dyn_hipMemsetD32Async_ptr)(hipDeviceptr_t, int, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t, int, size_t, hipStream_t)>(
|
|
hipMemsetD32Async_ptr);
|
|
hipError_t (*dyn_hipMemset_ptr)(void*, int, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, int, size_t)>(hipMemset_ptr);
|
|
hipError_t (*dyn_hipMemsetAsync_ptr)(void*, int, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, int, size_t, hipStream_t)>(hipMemsetAsync_ptr);
|
|
|
|
// Validating hipMemsetD8 API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(char);
|
|
unsigned char value = 255;
|
|
|
|
void* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemsetD8_ptr(devMem, value, N));
|
|
|
|
unsigned char* hostMem = (unsigned char*)malloc(Nbytes);
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<unsigned char>(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// Validating hipMemsetD16 API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(uint16_t);
|
|
uint16_t value = 65535;
|
|
|
|
void* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemsetD16_ptr(devMem, value, N));
|
|
|
|
uint16_t* hostMem = reinterpret_cast<uint16_t*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<uint16_t>(hostMem, N, value) == true);
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// Validating hipMemsetD32 API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(int);
|
|
int value = 2147483647;
|
|
|
|
void* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemsetD32_ptr(devMem, value, N));
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<int>(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
// Validating hipMemsetD8Async API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(char);
|
|
unsigned char value = 255;
|
|
const int Ns = 4;
|
|
|
|
unsigned char* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemsetD8Async_ptr(devMem + startIndex, value, N / Ns, stream[s]));
|
|
}
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
unsigned char* hostMem = (unsigned char*)malloc(Nbytes);
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<unsigned char>(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemsetD16Async API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(uint16_t);
|
|
uint16_t value = 65535;
|
|
const int Ns = 4;
|
|
|
|
uint16_t* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemsetD16Async_ptr(devMem + startIndex, value, N / Ns, stream[s]));
|
|
}
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
uint16_t* hostMem = reinterpret_cast<uint16_t*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<uint16_t>(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemsetD32Async API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(int);
|
|
int value = 2147483647;
|
|
const int Ns = 4;
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemsetD32Async_ptr(devMem + startIndex, value, N / Ns, stream[s]));
|
|
}
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<int>(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemset API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(char);
|
|
int value = 10;
|
|
|
|
void* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(dyn_hipMemset_ptr(devMem, value, Nbytes));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<char>(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemsetAsync API
|
|
{
|
|
int N = 16;
|
|
int Nbytes = N * sizeof(char);
|
|
int value = 126;
|
|
const int Ns = 4;
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, Nbytes));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
HIP_CHECK(dyn_hipMemsetAsync_ptr(devMem + startIndex, value, N / Ns, stream[s]));
|
|
}
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(Nbytes));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy(hostMem, devMem, Nbytes, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<char>(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memset 2D and 3D) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMemset2D3D") {
|
|
CHECK_IMAGE_SUPPORT
|
|
|
|
void* hipMemset2D_ptr = nullptr;
|
|
void* hipMemset2DAsync_ptr = nullptr;
|
|
void* hipMemset3D_ptr = nullptr;
|
|
void* hipMemset3DAsync_ptr = nullptr;
|
|
hipDriverProcAddressQueryResult symbolStatus = HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemset2D", &hipMemset2D_ptr, currentHipVersion, 0, &symbolStatus));
|
|
REQUIRE(symbolStatus == HIP_GET_PROC_ADDRESS_SUCCESS);
|
|
HIP_CHECK(hipGetProcAddress("hipMemset2DAsync", &hipMemset2DAsync_ptr, currentHipVersion, 0,
|
|
&symbolStatus));
|
|
REQUIRE(symbolStatus == HIP_GET_PROC_ADDRESS_SUCCESS);
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemset3D", &hipMemset3D_ptr, currentHipVersion, 0, &symbolStatus));
|
|
REQUIRE(symbolStatus == HIP_GET_PROC_ADDRESS_SUCCESS);
|
|
HIP_CHECK(hipGetProcAddress("hipMemset3DAsync", &hipMemset3DAsync_ptr, currentHipVersion, 0,
|
|
&symbolStatus));
|
|
REQUIRE(symbolStatus == HIP_GET_PROC_ADDRESS_SUCCESS);
|
|
|
|
hipError_t (*dyn_hipMemset2D_ptr)(void*, size_t, int, size_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, int, size_t, size_t)>(hipMemset2D_ptr);
|
|
hipError_t (*dyn_hipMemset2DAsync_ptr)(void*, size_t, int, size_t, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, int, size_t, size_t, hipStream_t)>(
|
|
hipMemset2DAsync_ptr);
|
|
hipError_t (*dyn_hipMemset3D_ptr)(hipPitchedPtr, int, hipExtent) =
|
|
reinterpret_cast<hipError_t (*)(hipPitchedPtr, int, hipExtent)>(hipMemset3D_ptr);
|
|
hipError_t (*dyn_hipMemset3DAsync_ptr)(hipPitchedPtr, int, hipExtent, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipPitchedPtr, int, hipExtent, hipStream_t)>(
|
|
hipMemset3DAsync_ptr);
|
|
size_t width = 1024;
|
|
size_t height = 1024;
|
|
size_t depth = 1024;
|
|
int value = 10;
|
|
const int Ns = 4;
|
|
size_t pitch;
|
|
|
|
// Validating hipMemset2D API
|
|
{
|
|
const int N = width * height;
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemset2D_ptr(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy2D(hostMem, width, devMem, pitch, width, height, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<char>(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemset2DAsync API
|
|
{
|
|
const int N = width * height;
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
// set the whole matrix first to something different than 'value'
|
|
HIP_CHECK(dyn_hipMemset2DAsync_ptr(devMem, pitch, 5, width, height, 0));
|
|
HIP_CHECK(hipStreamSynchronize(0));
|
|
|
|
hipStream_t stream[Ns];
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamCreate(&stream[s]));
|
|
}
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
int startIndex = s * (N / Ns);
|
|
int row = startIndex / width;
|
|
HIP_CHECK(dyn_hipMemset2DAsync_ptr(devMem + row * pitch, pitch, value, width, height / Ns,
|
|
stream[s]));
|
|
}
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamSynchronize(stream[s]));
|
|
}
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
HIP_CHECK(hipMemcpy2D(hostMem, width, devMem, pitch, width, height, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateArrayT<char>(hostMem, N, value) == true);
|
|
|
|
for (int s = 0; s < Ns; s++) {
|
|
HIP_CHECK(hipStreamDestroy(stream[s]));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemset3D API
|
|
{
|
|
const int N = width * height * depth;
|
|
|
|
hipPitchedPtr devMem;
|
|
hipExtent extent3d{width, height, depth};
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemset3D_ptr(devMem, value, extent3d));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.srcPtr = devMem;
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToHost;
|
|
HIP_CHECK(hipMemcpy3D(&myparms));
|
|
|
|
REQUIRE(validateArrayT<char>(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Validating hipMemset3DAsync API
|
|
{
|
|
size_t width = 64;
|
|
size_t height = 64;
|
|
size_t depth = 64;
|
|
const int N = width * height * depth;
|
|
int value = 10;
|
|
|
|
hipPitchedPtr devMem;
|
|
hipExtent extent3d{width, height, depth};
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemset3DAsync_ptr(devMem, value, extent3d, NULL));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.srcPtr = devMem;
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToHost;
|
|
HIP_CHECK(hipMemcpy3D(&myparms));
|
|
|
|
REQUIRE(validateArrayT<char>(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memory Info) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisGetMemInfoRelated") {
|
|
void* hipMemGetInfo_ptr = nullptr;
|
|
void* hipMemPtrGetInfo_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemGetInfo", &hipMemGetInfo_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemPtrGetInfo", &hipMemPtrGetInfo_ptr, currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMemGetInfo_ptr)(size_t*, size_t*) =
|
|
reinterpret_cast<hipError_t (*)(size_t*, size_t*)>(hipMemGetInfo_ptr);
|
|
hipError_t (*dyn_hipMemPtrGetInfo_ptr)(void*, size_t*) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t*)>(hipMemPtrGetInfo_ptr);
|
|
|
|
// Validating hipMemGetInfo API
|
|
size_t freeMem = 0, totalMem = 0, freeMemWithPtr = 0, totalMemWithPtr = 0;
|
|
|
|
HIP_CHECK(hipMemGetInfo(&freeMem, &totalMem));
|
|
HIP_CHECK(dyn_hipMemGetInfo_ptr(&freeMemWithPtr, &totalMemWithPtr));
|
|
|
|
REQUIRE(freeMemWithPtr == freeMem);
|
|
REQUIRE(totalMemWithPtr == totalMem);
|
|
|
|
// Validating hipMemPtrGetInfo API
|
|
void* devPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&devPtr, 128));
|
|
REQUIRE(devPtr != nullptr);
|
|
|
|
size_t devMemsize = -1;
|
|
HIP_CHECK(dyn_hipMemPtrGetInfo_ptr(devPtr, &devMemsize));
|
|
REQUIRE(devMemsize == 128);
|
|
|
|
HIP_CHECK(hipFree(devPtr));
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memory copy 2D) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMemcpy2DRelated", "[multigpu]") {
|
|
CHECK_IMAGE_SUPPORT
|
|
|
|
void* hipMemcpy2D_ptr = nullptr;
|
|
void* hipMemcpy2DAsync_ptr = nullptr;
|
|
void* hipMemcpyParam2D_ptr = nullptr;
|
|
void* hipMemcpyParam2DAsync_ptr = nullptr;
|
|
void* hipMemcpy2DToArray_ptr = nullptr;
|
|
void* hipMemcpy2DToArrayAsync_ptr = nullptr;
|
|
void* hipMemcpy2DFromArray_ptr = nullptr;
|
|
void* hipMemcpy2DFromArrayAsync_ptr = nullptr;
|
|
void* hipMemcpyToArray_ptr = nullptr;
|
|
void* hipMemcpyFromArray_ptr = nullptr;
|
|
void* hipMemcpyAtoH_ptr = nullptr;
|
|
void* hipMemcpyHtoA_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy2D", &hipMemcpy2D_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemcpy2DAsync", &hipMemcpy2DAsync_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemcpyParam2D", &hipMemcpyParam2D_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyParam2DAsync", &hipMemcpyParam2DAsync_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy2DToArray", &hipMemcpy2DToArray_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy2DToArrayAsync", &hipMemcpy2DToArrayAsync_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy2DFromArray", &hipMemcpy2DFromArray_ptr, currentHipVersion,
|
|
0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy2DFromArrayAsync", &hipMemcpy2DFromArrayAsync_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemcpyToArray", &hipMemcpyToArray_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyFromArray", &hipMemcpyFromArray_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyAtoH", &hipMemcpyAtoH_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyHtoA", &hipMemcpyHtoA_ptr, currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMemcpy2D_ptr)(void*, size_t, const void*, size_t, size_t, size_t,
|
|
hipMemcpyKind) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, const void*, size_t, size_t, size_t,
|
|
hipMemcpyKind)>(hipMemcpy2D_ptr);
|
|
hipError_t (*dyn_hipMemcpy2DAsync_ptr)(void*, size_t, const void*, size_t, size_t, size_t,
|
|
hipMemcpyKind, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, const void*, size_t, size_t, size_t,
|
|
hipMemcpyKind, hipStream_t)>(hipMemcpy2DAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpyParam2D_ptr)(const hip_Memcpy2D*) =
|
|
reinterpret_cast<hipError_t (*)(const hip_Memcpy2D*)>(hipMemcpyParam2D_ptr);
|
|
hipError_t (*dyn_hipMemcpyParam2DAsync_ptr)(const hip_Memcpy2D*, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(const hip_Memcpy2D*, hipStream_t)>(hipMemcpyParam2DAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpy2DToArray_ptr)(hipArray_t, size_t, size_t, const void* src, size_t,
|
|
size_t, size_t, hipMemcpyKind) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t, size_t, size_t, const void* src, size_t, size_t,
|
|
size_t, hipMemcpyKind)>(hipMemcpy2DToArray_ptr);
|
|
hipError_t (*dyn_hipMemcpy2DToArrayAsync_ptr)(hipArray_t, size_t, size_t, const void* src, size_t,
|
|
size_t, size_t, hipMemcpyKind, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t, size_t, size_t, const void* src, size_t, size_t,
|
|
size_t, hipMemcpyKind, hipStream_t)>(
|
|
hipMemcpy2DToArrayAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpy2DFromArray_ptr)(void*, size_t, hipArray_const_t, size_t, size_t,
|
|
size_t, size_t, hipMemcpyKind) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, hipArray_const_t, size_t, size_t, size_t,
|
|
size_t, hipMemcpyKind)>(hipMemcpy2DFromArray_ptr);
|
|
hipError_t (*dyn_hipMemcpy2DFromArrayAsync_ptr)(void*, size_t, hipArray_const_t, size_t, size_t,
|
|
size_t, size_t, hipMemcpyKind, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, hipArray_const_t, size_t, size_t, size_t,
|
|
size_t, hipMemcpyKind, hipStream_t)>(
|
|
hipMemcpy2DFromArrayAsync_ptr);
|
|
hipError_t (*dyn_hipMemcpyToArray_ptr)(hipArray_t, size_t, size_t, const void*, size_t,
|
|
hipMemcpyKind) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t, size_t, size_t, const void*, size_t,
|
|
hipMemcpyKind)>(hipMemcpyToArray_ptr);
|
|
hipError_t (*dyn_hipMemcpyFromArray_ptr)(void*, hipArray_const_t, size_t, size_t, size_t,
|
|
hipMemcpyKind) =
|
|
reinterpret_cast<hipError_t (*)(void*, hipArray_const_t, size_t, size_t, size_t,
|
|
hipMemcpyKind)>(hipMemcpyFromArray_ptr);
|
|
hipError_t (*dyn_hipMemcpyAtoH_ptr)(void*, hipArray_t, size_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, hipArray_t, size_t, size_t)>(hipMemcpyAtoH_ptr);
|
|
hipError_t (*dyn_hipMemcpyHtoA_ptr)(hipArray_t, size_t, const void*, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipArray_t, size_t, const void*, size_t)>(hipMemcpyHtoA_ptr);
|
|
|
|
// Validating hipMemcpy2D API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
size_t pitch;
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2D_ptr(dHostMem, width, sHostMem, width, width, height,
|
|
hipMemcpyHostToHost));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2D_ptr(devMem, pitch, hostMem, pitch, width, height, hipMemcpyHostToDevice));
|
|
|
|
REQUIRE(validateCharDeviceArray(devMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2D_ptr(hostMem, width, devMem, pitch, width, height, hipMemcpyDeviceToHost));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2D_ptr(dDevMem, dPitch, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDevice));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2D_ptr(dDevMem, dPitch, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDeviceNoCU));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2D_ptr(dHostMem, width, sHostMem, width, width, height, hipMemcpyDefault));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2D_ptr(devMem, pitch, hostMem, pitch, width, height, hipMemcpyDefault));
|
|
|
|
REQUIRE(validateCharDeviceArray(devMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2D_ptr(hostMem, width, devMem, pitch, width, height, hipMemcpyDefault));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2D_ptr(dDevMem, dPitch, sDevMem, sPitch, width, height, hipMemcpyDefault));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpy2DAsync API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
size_t pitch;
|
|
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(dHostMem, width, sHostMem, width, width, height,
|
|
hipMemcpyHostToHost, NULL));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(devMem, pitch, hostMem, pitch, width, height,
|
|
hipMemcpyHostToDevice, NULL));
|
|
|
|
REQUIRE(validateCharDeviceArray(devMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(hostMem, width, devMem, pitch, width, height,
|
|
hipMemcpyDeviceToHost, NULL));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(dDevMem, dPitch, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDevice, NULL));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(dDevMem, dPitch, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDeviceNoCU, NULL));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(dHostMem, width, sHostMem, width, width, height,
|
|
hipMemcpyDefault, NULL));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(devMem, pitch, hostMem, pitch, width, height,
|
|
hipMemcpyDefault, NULL));
|
|
|
|
REQUIRE(validateCharDeviceArray(devMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(hostMem, width, devMem, pitch, width, height,
|
|
hipMemcpyDefault, NULL));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DAsync_ptr(dDevMem, dPitch, sDevMem, sPitch, width, height,
|
|
hipMemcpyDefault, NULL));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpyParam2D API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
size_t pitch;
|
|
|
|
// Host to Host
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = sHostMem;
|
|
desc.srcPitch = width;
|
|
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = dHostMem;
|
|
desc.dstPitch = width;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2D_ptr(&desc));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
// Host to Device
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = hostMem;
|
|
desc.srcPitch = width;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = hipDeviceptr_t(devMem);
|
|
desc.dstPitch = pitch;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2D_ptr(&desc));
|
|
|
|
REQUIRE(validateCharDeviceArray(devMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// Device To Host
|
|
{
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = (hipDeviceptr_t)devMem;
|
|
desc.srcPitch = width;
|
|
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = hostMem;
|
|
desc.dstPitch = width;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2D_ptr(&desc));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Device To Device - single GPU
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = hipDeviceptr_t(sDevMem);
|
|
desc.srcPitch = sPitch;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = hipDeviceptr_t(dDevMem);
|
|
desc.dstPitch = dPitch;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2D_ptr(&desc));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
|
|
// Device To Device - Two GPU's
|
|
{
|
|
int deviceCount = 0;
|
|
HIP_CHECK(hipGetDeviceCount(&deviceCount));
|
|
|
|
if (deviceCount > 1) {
|
|
HIP_CHECK(hipSetDevice(0));
|
|
int can_access_peer = 0;
|
|
HIP_CHECK(hipDeviceCanAccessPeer(&can_access_peer, 0, 1));
|
|
if (can_access_peer) {
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
HIP_CHECK(hipSetDevice(1));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = hipDeviceptr_t(sDevMem);
|
|
desc.srcPitch = sPitch;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = hipDeviceptr_t(dDevMem);
|
|
desc.dstPitch = dPitch;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
HIP_CHECK(dyn_hipMemcpyParam2D_ptr(&desc));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpyParam2DAsync API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
size_t pitch;
|
|
|
|
// Host to Host
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = sHostMem;
|
|
desc.srcPitch = width;
|
|
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = dHostMem;
|
|
desc.dstPitch = width;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2DAsync_ptr(&desc, stream));
|
|
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// Host to Device
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = hostMem;
|
|
desc.srcPitch = width;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = hipDeviceptr_t(devMem);
|
|
desc.dstPitch = pitch;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(devMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// Device To Host
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* devMem = nullptr;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&devMem), &pitch, width, height));
|
|
REQUIRE(devMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(devMem, pitch, value, width, height));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = (hipDeviceptr_t)devMem;
|
|
desc.srcPitch = width;
|
|
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = hostMem;
|
|
desc.dstPitch = width;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(devMem));
|
|
free(hostMem);
|
|
}
|
|
|
|
// Device To Device - single GPU
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = hipDeviceptr_t(sDevMem);
|
|
desc.srcPitch = sPitch;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = hipDeviceptr_t(dDevMem);
|
|
desc.dstPitch = dPitch;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
|
|
HIP_CHECK(dyn_hipMemcpyParam2DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
|
|
// Device To Device - Two GPU's
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
int deviceCount = 0;
|
|
HIP_CHECK(hipGetDeviceCount(&deviceCount));
|
|
|
|
if (deviceCount > 1) {
|
|
HIP_CHECK(hipSetDevice(0));
|
|
int can_access_peer = 0;
|
|
HIP_CHECK(hipDeviceCanAccessPeer(&can_access_peer, 0, 1));
|
|
if (can_access_peer) {
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
HIP_CHECK(hipSetDevice(1));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
hip_Memcpy2D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = hipDeviceptr_t(sDevMem);
|
|
desc.srcPitch = sPitch;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = hipDeviceptr_t(dDevMem);
|
|
desc.dstPitch = dPitch;
|
|
desc.WidthInBytes = width * sizeof(char);
|
|
desc.Height = height;
|
|
HIP_CHECK(dyn_hipMemcpyParam2DAsync_ptr(&desc, stream));
|
|
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpy2DToArray API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArray_ptr(array, 0, 0, hostMem, width, width, height,
|
|
hipMemcpyHostToDevice));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArray_ptr(array, 0, 0, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDevice));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArray_ptr(array, 0, 0, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDeviceNoCU));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpy2DToArray_ptr(array, 0, 0, hostMem, width, width, height, hipMemcpyDefault));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArray_ptr(array, 0, 0, sDevMem, sPitch, width, height,
|
|
hipMemcpyDefault));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpy2DToArrayAsync API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
|
|
// With flags hipMemcpyHostToDevice
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArrayAsync_ptr(array, 0, 0, hostMem, width, width, height,
|
|
hipMemcpyHostToDevice, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flags hipMemcpyDeviceToDevice
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArrayAsync_ptr(array, 0, 0, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDevice, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flags hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArrayAsync_ptr(array, 0, 0, sDevMem, sPitch, width, height,
|
|
hipMemcpyDeviceToDeviceNoCU, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flags hipMemcpyDefault - Host To Device
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArrayAsync_ptr(array, 0, 0, hostMem, width, width, height,
|
|
hipMemcpyDefault, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flags hipMemcpyDefault - Device To Device
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DToArrayAsync_ptr(array, 0, 0, sDevMem, sPitch, width, height,
|
|
hipMemcpyDefault, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpy2DFromArray(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpy2DFromArray API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, hostMem, width, width, height, hipMemcpyHostToDevice));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArray_ptr(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, sDevMem, sPitch, width, height, hipMemcpyDeviceToDevice));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArray_ptr(dDevMem, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToDevice));
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, sDevMem, sPitch, width, height, hipMemcpyDeviceToDevice));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArray_ptr(dDevMem, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToDeviceNoCU));
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, hostMem, width, width, height, hipMemcpyHostToDevice));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArray_ptr(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDefault));
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, sDevMem, sPitch, width, height, hipMemcpyDeviceToDevice));
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArray_ptr(dDevMem, width, array, 0, 0, width, height,
|
|
hipMemcpyDefault));
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpy2DFromArrayAsync API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, hostMem, width, width, height, hipMemcpyHostToDevice));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArrayAsync_ptr(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToHost, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, sDevMem, sPitch, width, height, hipMemcpyDeviceToDevice));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArrayAsync_ptr(dDevMem, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToDevice, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, sDevMem, sPitch, width, height, hipMemcpyDeviceToDevice));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArrayAsync_ptr(dDevMem, width, array, 0, 0, width, height,
|
|
hipMemcpyDeviceToDeviceNoCU, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, hostMem, width, width, height, hipMemcpyHostToDevice));
|
|
|
|
char* hostMemory = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArrayAsync_ptr(hostMemory, width, array, 0, 0, width, height,
|
|
hipMemcpyDefault, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
char* sDevMem = nullptr;
|
|
size_t sPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&sDevMem), &sPitch, width, height));
|
|
REQUIRE(sDevMem != nullptr);
|
|
HIP_CHECK(hipMemset2D(sDevMem, sPitch, value, width, height));
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<char>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
HIP_CHECK(
|
|
hipMemcpy2DToArray(array, 0, 0, sDevMem, sPitch, width, height, hipMemcpyDeviceToDevice));
|
|
|
|
char* dDevMem = nullptr;
|
|
size_t dPitch;
|
|
HIP_CHECK(hipMallocPitch(reinterpret_cast<void**>(&dDevMem), &dPitch, width, height));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpy2DFromArrayAsync_ptr(dDevMem, width, array, 0, 0, width, height,
|
|
hipMemcpyDefault, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpyToArray API
|
|
{
|
|
size_t width = 64;
|
|
size_t height = 1;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpyToArray_ptr(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyHostToDevice));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
hipMemcpyFromArray(hostMemory, array, 0, 0, N * sizeof(int), hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
int* sDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&sDevMem, N * sizeof(int)));
|
|
REQUIRE(sDevMem != nullptr);
|
|
fillDeviceArray(sDevMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpyToArray_ptr(array, 0, 0, sDevMem, N * sizeof(int), hipMemcpyDeviceToDevice));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
hipMemcpyFromArray(hostMemory, array, 0, 0, N * sizeof(int), hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
int* sDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&sDevMem, N * sizeof(int)));
|
|
REQUIRE(sDevMem != nullptr);
|
|
fillDeviceArray(sDevMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyToArray_ptr(array, 0, 0, sDevMem, N * sizeof(int),
|
|
hipMemcpyDeviceToDeviceNoCU));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
hipMemcpyFromArray(hostMemory, array, 0, 0, N * sizeof(int), hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyToArray_ptr(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyDefault));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
hipMemcpyFromArray(hostMemory, array, 0, 0, N * sizeof(int), hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
int* sDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&sDevMem, N * sizeof(int)));
|
|
REQUIRE(sDevMem != nullptr);
|
|
fillDeviceArray(sDevMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyToArray_ptr(array, 0, 0, sDevMem, N * sizeof(int), hipMemcpyDefault));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
hipMemcpyFromArray(hostMemory, array, 0, 0, N * sizeof(int), hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpyFromArray API
|
|
{
|
|
size_t width = 64;
|
|
size_t height = 1;
|
|
const int N = width * height;
|
|
int value = 10;
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpyToArray(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyHostToDevice));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyFromArray_ptr(hostMemory, array, 0, 0, N * sizeof(int),
|
|
hipMemcpyDeviceToHost));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpyToArray(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyHostToDevice));
|
|
|
|
int* deviceMemory = nullptr;
|
|
HIP_CHECK(hipMalloc(&deviceMemory, N * sizeof(int)));
|
|
REQUIRE(deviceMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyFromArray_ptr(deviceMemory, array, 0, 0, N * sizeof(int),
|
|
hipMemcpyDeviceToDevice));
|
|
REQUIRE(validateDeviceArray(deviceMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(deviceMemory));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpyToArray(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyHostToDevice));
|
|
|
|
int* deviceMemory = nullptr;
|
|
HIP_CHECK(hipMalloc(&deviceMemory, N * sizeof(int)));
|
|
REQUIRE(deviceMemory != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyFromArray_ptr(deviceMemory, array, 0, 0, N * sizeof(int),
|
|
hipMemcpyDeviceToDeviceNoCU));
|
|
REQUIRE(validateDeviceArray(deviceMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(deviceMemory));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpyToArray(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyHostToDevice));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpyFromArray_ptr(hostMemory, array, 0, 0, N * sizeof(int), hipMemcpyDefault));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
|
|
HIP_CHECK(hipMemcpyToArray(array, 0, 0, hostMem, N * sizeof(int), hipMemcpyHostToDevice));
|
|
|
|
int* deviceMemory = nullptr;
|
|
HIP_CHECK(hipMalloc(&deviceMemory, N * sizeof(int)));
|
|
REQUIRE(deviceMemory != nullptr);
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpyFromArray_ptr(deviceMemory, array, 0, 0, N * sizeof(int), hipMemcpyDefault));
|
|
REQUIRE(validateDeviceArray(deviceMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(deviceMemory));
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpyAtoH & hipMemcpyHtoA API's
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 1;
|
|
const int N = width * height;
|
|
hipArray_t array = nullptr;
|
|
hipChannelFormatDesc desc = hipCreateChannelDesc<int>();
|
|
unsigned int flags = hipArrayDefault;
|
|
HIP_CHECK(hipMallocArray(&array, &desc, width, height, flags));
|
|
REQUIRE(array != nullptr);
|
|
int value = 10;
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
HIP_CHECK(dyn_hipMemcpyHtoA_ptr(array, 0, hostMem, N * sizeof(int)));
|
|
|
|
int* hostMemory = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMemory != nullptr);
|
|
HIP_CHECK(dyn_hipMemcpyAtoH_ptr(hostMemory, array, 0, N * sizeof(int)));
|
|
REQUIRE(validateHostArray(hostMemory, N, value) == true);
|
|
|
|
free(hostMem);
|
|
free(hostMemory);
|
|
HIP_CHECK(hipFreeArray(array));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (Memory copy 3D) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisMemcpy3DRelated") {
|
|
CHECK_IMAGE_SUPPORT
|
|
|
|
void* hipMemcpy3D_ptr = nullptr;
|
|
void* hipMemcpy3DAsync_ptr = nullptr;
|
|
void* hipDrvMemcpy3D_ptr = nullptr;
|
|
void* hipDrvMemcpy3DAsync_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpy3D", &hipMemcpy3D_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemcpy3DAsync", &hipMemcpy3DAsync_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipDrvMemcpy3D", &hipDrvMemcpy3D_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipDrvMemcpy3DAsync", &hipDrvMemcpy3DAsync_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
|
|
hipError_t (*dyn_hipMemcpy3D_ptr)(const struct hipMemcpy3DParms*) =
|
|
reinterpret_cast<hipError_t (*)(const struct hipMemcpy3DParms*)>(hipMemcpy3D_ptr);
|
|
hipError_t (*dyn_hipMemcpy3DAsync_ptr)(const struct hipMemcpy3DParms*, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(const struct hipMemcpy3DParms*, hipStream_t)>(
|
|
hipMemcpy3DAsync_ptr);
|
|
hipError_t (*dyn_hipDrvMemcpy3D_ptr)(const HIP_MEMCPY3D*) =
|
|
reinterpret_cast<hipError_t (*)(const HIP_MEMCPY3D*)>(hipDrvMemcpy3D_ptr);
|
|
hipError_t (*dyn_hipDrvMemcpy3DAsync_ptr)(const HIP_MEMCPY3D*, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(const HIP_MEMCPY3D*, hipStream_t)>(hipDrvMemcpy3DAsync_ptr);
|
|
|
|
// Validating hipMemcpy3D API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
size_t depth = 256;
|
|
const int N = width * height * depth;
|
|
int value = 10;
|
|
hipExtent extent3d{width, height, depth};
|
|
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(sHostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(dHostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyHostToHost;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = devMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyHostToDevice;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(devMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(devMem, value, extent3d));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = devMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToHost;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
hipPitchedPtr sDevMem;
|
|
HIP_CHECK(hipMalloc3D(&sDevMem, extent3d));
|
|
REQUIRE(sDevMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(sDevMem, value, extent3d));
|
|
|
|
hipPitchedPtr dDevMem;
|
|
HIP_CHECK(hipMalloc3D(&dDevMem, extent3d));
|
|
REQUIRE(dDevMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = sDevMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = dDevMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToDevice;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(dDevMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem.ptr));
|
|
HIP_CHECK(hipFree(dDevMem.ptr));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
hipPitchedPtr sDevMem;
|
|
HIP_CHECK(hipMalloc3D(&sDevMem, extent3d));
|
|
REQUIRE(sDevMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(sDevMem, value, extent3d));
|
|
|
|
hipPitchedPtr dDevMem;
|
|
HIP_CHECK(hipMalloc3D(&dDevMem, extent3d));
|
|
REQUIRE(dDevMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = sDevMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = dDevMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToDeviceNoCU;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(dDevMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem.ptr));
|
|
HIP_CHECK(hipFree(dDevMem.ptr));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(sHostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(dHostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = devMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(devMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(devMem, value, extent3d));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = devMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
hipPitchedPtr sDevMem;
|
|
HIP_CHECK(hipMalloc3D(&sDevMem, extent3d));
|
|
REQUIRE(sDevMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(sDevMem, value, extent3d));
|
|
|
|
hipPitchedPtr dDevMem;
|
|
HIP_CHECK(hipMalloc3D(&dDevMem, extent3d));
|
|
REQUIRE(dDevMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = sDevMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = dDevMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
HIP_CHECK(dyn_hipMemcpy3D_ptr(&myparms));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(dDevMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem.ptr));
|
|
HIP_CHECK(hipFree(dDevMem.ptr));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemcpy3DAsync API
|
|
{
|
|
size_t width = 256;
|
|
size_t height = 256;
|
|
size_t depth = 256;
|
|
const int N = width * height * depth;
|
|
int value = 10;
|
|
hipExtent extent3d{width, height, depth};
|
|
|
|
// With flag hipMemcpyHostToHost
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(sHostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(dHostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyHostToHost;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyHostToDevice
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = devMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyHostToDevice;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(devMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToHost
|
|
{
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(devMem, value, extent3d));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = devMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToHost;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDevice
|
|
{
|
|
hipPitchedPtr sDevMem;
|
|
HIP_CHECK(hipMalloc3D(&sDevMem, extent3d));
|
|
REQUIRE(sDevMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(sDevMem, value, extent3d));
|
|
|
|
hipPitchedPtr dDevMem;
|
|
HIP_CHECK(hipMalloc3D(&dDevMem, extent3d));
|
|
REQUIRE(dDevMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = sDevMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = dDevMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToDevice;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(dDevMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem.ptr));
|
|
HIP_CHECK(hipFree(dDevMem.ptr));
|
|
}
|
|
|
|
// With flag hipMemcpyDeviceToDeviceNoCU
|
|
{
|
|
hipPitchedPtr sDevMem;
|
|
HIP_CHECK(hipMalloc3D(&sDevMem, extent3d));
|
|
REQUIRE(sDevMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(sDevMem, value, extent3d));
|
|
|
|
hipPitchedPtr dDevMem;
|
|
HIP_CHECK(hipMalloc3D(&dDevMem, extent3d));
|
|
REQUIRE(dDevMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = sDevMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = dDevMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDeviceToDeviceNoCU;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(dDevMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem.ptr));
|
|
HIP_CHECK(hipFree(dDevMem.ptr));
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Host To Host
|
|
{
|
|
char* sHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillCharHostArray(sHostMem, N, value);
|
|
|
|
char* dHostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(sHostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(dHostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(dHostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Host To Device
|
|
{
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillCharHostArray(hostMem, N, value);
|
|
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = devMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(devMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Host
|
|
{
|
|
hipPitchedPtr devMem;
|
|
HIP_CHECK(hipMalloc3D(&devMem, extent3d));
|
|
REQUIRE(devMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(devMem, value, extent3d));
|
|
|
|
char* hostMem = reinterpret_cast<char*>(malloc(N * sizeof(char)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = devMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = make_hipPitchedPtr(hostMem, width, height, depth);
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(devMem.ptr));
|
|
free(hostMem);
|
|
}
|
|
|
|
// With flag hipMemcpyDefault - Device To Device
|
|
{
|
|
hipPitchedPtr sDevMem;
|
|
HIP_CHECK(hipMalloc3D(&sDevMem, extent3d));
|
|
REQUIRE(sDevMem.ptr != nullptr);
|
|
HIP_CHECK(hipMemset3D(sDevMem, value, extent3d));
|
|
|
|
hipPitchedPtr dDevMem;
|
|
HIP_CHECK(hipMalloc3D(&dDevMem, extent3d));
|
|
REQUIRE(dDevMem.ptr != nullptr);
|
|
|
|
hipMemcpy3DParms myparms{};
|
|
myparms.srcPtr = sDevMem;
|
|
myparms.srcPos = make_hipPos(0, 0, 0);
|
|
myparms.dstPtr = dDevMem;
|
|
myparms.dstPos = make_hipPos(0, 0, 0);
|
|
myparms.extent = extent3d;
|
|
myparms.kind = hipMemcpyDefault;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipMemcpy3DAsync_ptr(&myparms, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateCharDeviceArray(reinterpret_cast<char*>(dDevMem.ptr), N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem.ptr));
|
|
HIP_CHECK(hipFree(dDevMem.ptr));
|
|
}
|
|
}
|
|
|
|
// Validating hipDrvMemcpy3D API
|
|
{
|
|
size_t width = 16;
|
|
size_t height = 16;
|
|
size_t depth = 16;
|
|
const int N = width * height * depth;
|
|
int value = 10;
|
|
|
|
// Host to Host
|
|
{
|
|
int* sHostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillHostArray(sHostMem, N, value);
|
|
|
|
int* dHostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = sHostMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = dHostMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3D_ptr(&desc));
|
|
|
|
REQUIRE(validateHostArray(dHostMem, N, value) == true);
|
|
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// Host to Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, N * sizeof(int)));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = hostMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = (hipDeviceptr_t)devMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3D_ptr(&desc));
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// Device To Host
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, N * sizeof(int)));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = (hipDeviceptr_t)devMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = hostMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3D_ptr(&desc));
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// Device To Device
|
|
{
|
|
int* sDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&sDevMem, N * sizeof(int)));
|
|
REQUIRE(sDevMem != nullptr);
|
|
fillDeviceArray(sDevMem, N, value);
|
|
|
|
int* dDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dDevMem, N * sizeof(int)));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = (hipDeviceptr_t)sDevMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = (hipDeviceptr_t)dDevMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3D_ptr(&desc));
|
|
|
|
REQUIRE(validateDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
}
|
|
|
|
// Validating hipDrvMemcpy3DAsync API
|
|
{
|
|
size_t width = 16;
|
|
size_t height = 16;
|
|
size_t depth = 16;
|
|
const int N = width * height * depth;
|
|
int value = 10;
|
|
|
|
// Host to Host
|
|
{
|
|
int* sHostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(sHostMem != nullptr);
|
|
fillHostArray(sHostMem, N, value);
|
|
|
|
int* dHostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(dHostMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = sHostMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = dHostMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateHostArray(dHostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(sHostMem);
|
|
free(dHostMem);
|
|
}
|
|
|
|
// Host to Device
|
|
{
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
fillHostArray(hostMem, N, value);
|
|
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, N * sizeof(int)));
|
|
REQUIRE(devMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeHost;
|
|
desc.srcHost = hostMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = (hipDeviceptr_t)devMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateDeviceArray(devMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// Device To Host
|
|
{
|
|
int* devMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&devMem, N * sizeof(int)));
|
|
REQUIRE(devMem != nullptr);
|
|
fillDeviceArray(devMem, N, value);
|
|
|
|
int* hostMem = reinterpret_cast<int*>(malloc(N * sizeof(int)));
|
|
REQUIRE(hostMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = (hipDeviceptr_t)devMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeHost;
|
|
desc.dstHost = hostMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateHostArray(hostMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
free(hostMem);
|
|
HIP_CHECK(hipFree(devMem));
|
|
}
|
|
|
|
// Device To Device
|
|
{
|
|
int* sDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&sDevMem, N * sizeof(int)));
|
|
REQUIRE(sDevMem != nullptr);
|
|
fillDeviceArray(sDevMem, N, value);
|
|
|
|
int* dDevMem = nullptr;
|
|
HIP_CHECK(hipMalloc(&dDevMem, N * sizeof(int)));
|
|
REQUIRE(dDevMem != nullptr);
|
|
|
|
HIP_MEMCPY3D desc = {};
|
|
desc.srcMemoryType = hipMemoryTypeDevice;
|
|
desc.srcDevice = (hipDeviceptr_t)sDevMem;
|
|
desc.srcPitch = width * sizeof(int);
|
|
desc.srcHeight = height;
|
|
desc.dstMemoryType = hipMemoryTypeDevice;
|
|
desc.dstDevice = (hipDeviceptr_t)dDevMem;
|
|
desc.dstPitch = width * sizeof(int);
|
|
desc.dstHeight = height;
|
|
desc.WidthInBytes = width * sizeof(int);
|
|
desc.Height = height;
|
|
desc.Depth = depth;
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipDrvMemcpy3DAsync_ptr(&desc, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(validateDeviceArray(dDevMem, N, value) == true);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(sDevMem));
|
|
HIP_CHECK(hipFree(dDevMem));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Memory management
|
|
* - (API address) related APIs from the hipGetProcAddress API
|
|
* - and then validates the basic functionality of that particular API
|
|
* - using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisAddressRelated") {
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
void* hipGetProcAddress_ptr = nullptr;
|
|
HIP_CHECK(hipGetProcAddress("hipGetProcAddress", &hipGetProcAddress_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
|
|
hipError_t (*dyn_hipGetProcAddress_ptr)(const char*, void**, int, uint64_t,
|
|
hipDriverProcAddressQueryResult*) =
|
|
reinterpret_cast<hipError_t (*)(const char*, void**, int, uint64_t,
|
|
hipDriverProcAddressQueryResult*)>(hipGetProcAddress_ptr);
|
|
|
|
// Validating hipGetProcAddress API
|
|
{
|
|
void* hipMallocPtrWithFunction = nullptr;
|
|
void* hipMallocPtrWithFunctionPtr = nullptr;
|
|
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMalloc", &hipMallocPtrWithFunction, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(dyn_hipGetProcAddress_ptr("hipMalloc", &hipMallocPtrWithFunctionPtr,
|
|
currentHipVersion, 0, nullptr));
|
|
|
|
REQUIRE(hipMallocPtrWithFunction != nullptr);
|
|
REQUIRE(hipMallocPtrWithFunctionPtr != nullptr);
|
|
REQUIRE(hipMallocPtrWithFunctionPtr == hipMallocPtrWithFunction);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Managed Memory
|
|
* - APIs from the hipGetProcAddress API and then validates the basic
|
|
* - functionality of that particular API using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisManagedMemory") {
|
|
if (HmmAttrPrint() != 1) {
|
|
HipTest::HIP_SKIP_TEST("Skipping test since managed memory not supported");
|
|
return;
|
|
}
|
|
|
|
void* hipMallocManaged_ptr = nullptr;
|
|
void* hipMemPrefetchAsync_ptr = nullptr;
|
|
void* hipMemAdvise_ptr = nullptr;
|
|
void* hipMemRangeGetAttribute_ptr = nullptr;
|
|
void* hipMemRangeGetAttributes_ptr = nullptr;
|
|
void* hipStreamAttachMemAsync_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMallocManaged", &hipMallocManaged_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemPrefetchAsync", &hipMemPrefetchAsync_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemAdvise", &hipMemAdvise_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemRangeGetAttribute", &hipMemRangeGetAttribute_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemRangeGetAttributes", &hipMemRangeGetAttributes_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipStreamAttachMemAsync", &hipStreamAttachMemAsync_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMallocManaged_ptr)(void**, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t, unsigned int)>(hipMallocManaged_ptr);
|
|
hipError_t (*dyn_hipMemPrefetchAsync_ptr)(const void*, size_t, int, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(const void*, size_t, int, hipStream_t)>(
|
|
hipMemPrefetchAsync_ptr);
|
|
hipError_t (*dyn_hipMemAdvise_ptr)(const void*, size_t, hipMemoryAdvise, int) =
|
|
reinterpret_cast<hipError_t (*)(const void*, size_t, hipMemoryAdvise, int)>(hipMemAdvise_ptr);
|
|
hipError_t (*dyn_hipMemRangeGetAttribute_ptr)(void*, size_t, hipMemRangeAttribute, const void*,
|
|
size_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, size_t, hipMemRangeAttribute, const void*, size_t)>(
|
|
hipMemRangeGetAttribute_ptr);
|
|
hipError_t (*dyn_hipMemRangeGetAttributes_ptr)(void**, size_t*, hipMemRangeAttribute*, size_t,
|
|
const void*, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t*, hipMemRangeAttribute*, size_t, const void*,
|
|
size_t)>(hipMemRangeGetAttributes_ptr);
|
|
hipError_t (*dyn_hipStreamAttachMemAsync_ptr)(hipStream_t, void*, size_t, unsigned int) =
|
|
reinterpret_cast<hipError_t (*)(hipStream_t, void*, size_t, unsigned int)>(
|
|
hipStreamAttachMemAsync_ptr);
|
|
|
|
const int N = 16;
|
|
const int Nbytes = N * sizeof(int);
|
|
int value = 10;
|
|
|
|
// Validating hipMallocManaged API
|
|
{
|
|
int* memPtr = nullptr;
|
|
size_t size;
|
|
unsigned int flags[] = {hipMemAttachGlobal, hipMemAttachHost};
|
|
|
|
for (unsigned int flag : flags) {
|
|
memPtr = nullptr;
|
|
size = -1;
|
|
|
|
HIP_CHECK(dyn_hipMallocManaged_ptr(reinterpret_cast<void**>(&memPtr), Nbytes, flag));
|
|
REQUIRE(memPtr != nullptr);
|
|
|
|
HIP_CHECK(hipMemPtrGetInfo(memPtr, &size));
|
|
REQUIRE(size == Nbytes);
|
|
|
|
fillDeviceArray(memPtr, N, value);
|
|
validateHostArray(memPtr, N, value);
|
|
|
|
fillHostArray(memPtr, N, value + 1);
|
|
validateHostArray(memPtr, N, value + 1);
|
|
|
|
HIP_CHECK(hipFree(memPtr));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemPrefetchAsync API
|
|
{
|
|
hipDevice_t device = hipCpuDeviceId;
|
|
|
|
HIP_CHECK(hipSetDevice(0));
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
int* memPtr = nullptr;
|
|
HIP_CHECK(hipMallocManaged(&memPtr, Nbytes, hipMemAttachGlobal));
|
|
REQUIRE(memPtr != nullptr);
|
|
|
|
fillDeviceArray(memPtr, N, value);
|
|
|
|
HIP_CHECK(dyn_hipMemPrefetchAsync_ptr(memPtr, Nbytes, device, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
fillHostArray(memPtr, N, value + 1);
|
|
validateHostArray(memPtr, N, value + 1);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(memPtr));
|
|
}
|
|
|
|
// Validating hipMemAdvise and hipMemRangeGetAttribute APIs
|
|
{
|
|
HIP_CHECK(hipSetDevice(0));
|
|
|
|
int attrData;
|
|
int* memPtr = nullptr;
|
|
HIP_CHECK(hipMallocManaged(&memPtr, Nbytes, hipMemAttachGlobal));
|
|
REQUIRE(memPtr != nullptr);
|
|
|
|
// With flag hipMemAdviseSetReadMostly
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetReadMostly, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(&attrData, sizeof(int),
|
|
hipMemRangeAttributeReadMostly, memPtr, Nbytes));
|
|
REQUIRE(attrData == 1);
|
|
|
|
// With flag hipMemAdviseUnsetReadMostly
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseUnsetReadMostly, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(&attrData, sizeof(int),
|
|
hipMemRangeAttributeReadMostly, memPtr, Nbytes));
|
|
REQUIRE(attrData == 0);
|
|
|
|
// With flag hipMemAdviseSetPreferredLocation
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetPreferredLocation, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(
|
|
&attrData, sizeof(int), hipMemRangeAttributePreferredLocation, memPtr, Nbytes));
|
|
REQUIRE(attrData == 0);
|
|
|
|
// With flag hipMemAdviseUnsetPreferredLocation
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseUnsetPreferredLocation, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(
|
|
&attrData, sizeof(int), hipMemRangeAttributePreferredLocation, memPtr, Nbytes));
|
|
REQUIRE(attrData != 0);
|
|
|
|
// With flag hipMemAdviseSetAccessedBy
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetAccessedBy, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(&attrData, sizeof(int),
|
|
hipMemRangeAttributeAccessedBy, memPtr, Nbytes));
|
|
REQUIRE(attrData == 0);
|
|
|
|
// With flag hipMemAdviseUnsetAccessedBy
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseUnsetAccessedBy, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(&attrData, sizeof(int),
|
|
hipMemRangeAttributeAccessedBy, memPtr, Nbytes));
|
|
REQUIRE(attrData != 0);
|
|
|
|
// With flag hipMemAdviseSetCoarseGrain
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetCoarseGrain, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(&attrData, sizeof(int),
|
|
hipMemRangeAttributeCoherencyMode, memPtr, Nbytes));
|
|
REQUIRE(attrData == hipMemRangeCoherencyModeCoarseGrain);
|
|
|
|
// With flag hipMemAdviseUnsetCoarseGrain
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseUnsetCoarseGrain, 0));
|
|
attrData = -2;
|
|
HIP_CHECK(dyn_hipMemRangeGetAttribute_ptr(&attrData, sizeof(int),
|
|
hipMemRangeAttributeCoherencyMode, memPtr, Nbytes));
|
|
REQUIRE(attrData == hipMemRangeCoherencyModeFineGrain);
|
|
|
|
// With flag hipMemRangeAttributeLastPrefetchLocation
|
|
// Prefetch the location and get the prefetched location
|
|
hipDevice_t device = hipCpuDeviceId;
|
|
HIP_CHECK(hipMemPrefetchAsync(memPtr, Nbytes, device, NULL));
|
|
|
|
attrData = -2;
|
|
HIP_CHECK(hipMemRangeGetAttribute(&attrData, sizeof(int),
|
|
hipMemRangeAttributeLastPrefetchLocation, memPtr, Nbytes));
|
|
REQUIRE(attrData == device);
|
|
|
|
HIP_CHECK(hipFree(memPtr));
|
|
}
|
|
|
|
// Validating hipMemRangeGetAttributes API
|
|
{
|
|
int devCount = 0;
|
|
HIP_CHECK(hipGetDeviceCount(&devCount));
|
|
|
|
HIP_CHECK(hipSetDevice(0));
|
|
|
|
int* memPtr = nullptr;
|
|
HIP_CHECK(hipMallocManaged(&memPtr, Nbytes, hipMemAttachGlobal));
|
|
REQUIRE(memPtr != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetReadMostly, 0));
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetPreferredLocation, 0));
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetAccessedBy, 0));
|
|
HIP_CHECK(dyn_hipMemAdvise_ptr(memPtr, Nbytes, hipMemAdviseSetCoarseGrain, 0));
|
|
|
|
const size_t num_attributes = 5;
|
|
|
|
int* data[num_attributes];
|
|
data[0] = new int;
|
|
data[1] = new int;
|
|
data[2] = new int[devCount];
|
|
data[3] = new int;
|
|
data[4] = new int;
|
|
|
|
int* dataWithFuncPtr[num_attributes];
|
|
dataWithFuncPtr[0] = new int;
|
|
dataWithFuncPtr[1] = new int;
|
|
dataWithFuncPtr[2] = new int[devCount];
|
|
dataWithFuncPtr[3] = new int;
|
|
dataWithFuncPtr[4] = new int;
|
|
|
|
size_t data_sizes[num_attributes] = {sizeof(int), sizeof(int), (devCount * sizeof(int)),
|
|
sizeof(int), sizeof(int)};
|
|
|
|
hipMemRangeAttribute attributes[num_attributes] = {
|
|
hipMemRangeAttributeReadMostly, hipMemRangeAttributePreferredLocation,
|
|
hipMemRangeAttributeAccessedBy, hipMemRangeAttributeLastPrefetchLocation,
|
|
hipMemRangeAttributeCoherencyMode};
|
|
|
|
HIP_CHECK(hipMemRangeGetAttributes(reinterpret_cast<void**>(data),
|
|
reinterpret_cast<size_t*>(data_sizes), attributes,
|
|
num_attributes, memPtr, Nbytes));
|
|
HIP_CHECK(dyn_hipMemRangeGetAttributes_ptr(reinterpret_cast<void**>(dataWithFuncPtr),
|
|
reinterpret_cast<size_t*>(data_sizes), attributes,
|
|
num_attributes, memPtr, Nbytes));
|
|
|
|
for (int i = 0; i < num_attributes; i++) {
|
|
if (i != 2) {
|
|
REQUIRE(*(dataWithFuncPtr[i]) == *(data[i]));
|
|
} else {
|
|
for (int dev = 0; dev < devCount; dev++) {
|
|
REQUIRE(dataWithFuncPtr[i][dev] == data[i][dev]);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < num_attributes; i++) {
|
|
delete data[i];
|
|
delete dataWithFuncPtr[i];
|
|
}
|
|
|
|
HIP_CHECK(hipFree(memPtr));
|
|
}
|
|
|
|
// Validating hipStreamAttachMemAsync API
|
|
{
|
|
HIP_CHECK(hipSetDevice(0));
|
|
|
|
int* memPtr = nullptr;
|
|
HIP_CHECK(hipMallocManaged(&memPtr, Nbytes, hipMemAttachGlobal));
|
|
REQUIRE(memPtr != nullptr);
|
|
|
|
unsigned int flags[] = {hipMemAttachGlobal, hipMemAttachHost, hipMemAttachSingle};
|
|
|
|
for (unsigned int flag : flags) {
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(dyn_hipStreamAttachMemAsync_ptr(stream, memPtr, Nbytes, flag));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
}
|
|
|
|
HIP_CHECK(hipFree(memPtr));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different stream ordered
|
|
* - Memory APIs from the hipGetProcAddress API and then validates the basic
|
|
* - functionality of that particular API using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisStreamOrderedMemory") {
|
|
HIP_CHECK(hipSetDevice(0));
|
|
int mem_pool_support = 0;
|
|
|
|
HIP_CHECK(hipDeviceGetAttribute(&mem_pool_support, hipDeviceAttributeMemoryPoolsSupported, 0));
|
|
|
|
if (mem_pool_support != 1) {
|
|
HipTest::HIP_SKIP_TEST("Skipping test since Memory Pool is not supported");
|
|
return;
|
|
}
|
|
|
|
void* hipMallocAsync_ptr = nullptr;
|
|
void* hipFreeAsync_ptr = nullptr;
|
|
void* hipMemPoolCreate_ptr = nullptr;
|
|
void* hipMallocFromPoolAsync_ptr = nullptr;
|
|
void* hipMemPoolDestroy_ptr = nullptr;
|
|
void* hipMemPoolTrimTo_ptr = nullptr;
|
|
void* hipMemPoolSetAccess_ptr = nullptr;
|
|
void* hipMemPoolGetAccess_ptr = nullptr;
|
|
void* hipMemPoolSetAttribute_ptr = nullptr;
|
|
void* hipMemPoolGetAttribute_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMallocAsync", &hipMallocAsync_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipFreeAsync", &hipFreeAsync_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemPoolCreate", &hipMemPoolCreate_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMallocFromPoolAsync", &hipMallocFromPoolAsync_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemPoolDestroy", &hipMemPoolDestroy_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(
|
|
hipGetProcAddress("hipMemPoolTrimTo", &hipMemPoolTrimTo_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemPoolSetAccess", &hipMemPoolSetAccess_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemPoolGetAccess", &hipMemPoolGetAccess_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemPoolSetAttribute", &hipMemPoolSetAttribute_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemPoolGetAttribute", &hipMemPoolGetAttribute_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
|
|
hipError_t (*dyn_hipMallocAsync_ptr)(void**, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t, hipStream_t)>(hipMallocAsync_ptr);
|
|
hipError_t (*dyn_hipFreeAsync_ptr)(void*, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, hipStream_t)>(hipFreeAsync_ptr);
|
|
hipError_t (*dyn_hipMemPoolCreate_ptr)(hipMemPool_t*, const hipMemPoolProps*) =
|
|
reinterpret_cast<hipError_t (*)(hipMemPool_t*, const hipMemPoolProps*)>(hipMemPoolCreate_ptr);
|
|
hipError_t (*dyn_hipMallocFromPoolAsync_ptr)(void**, size_t, hipMemPool_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void**, size_t, hipMemPool_t, hipStream_t)>(
|
|
hipMallocFromPoolAsync_ptr);
|
|
hipError_t (*dyn_hipMemPoolDestroy_ptr)(hipMemPool_t) =
|
|
reinterpret_cast<hipError_t (*)(hipMemPool_t)>(hipMemPoolDestroy_ptr);
|
|
hipError_t (*dyn_hipMemPoolTrimTo_ptr)(hipMemPool_t, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipMemPool_t, size_t)>(hipMemPoolTrimTo_ptr);
|
|
hipError_t (*dyn_hipMemPoolSetAccess_ptr)(hipMemPool_t, const hipMemAccessDesc*, size_t) =
|
|
reinterpret_cast<hipError_t (*)(hipMemPool_t, const hipMemAccessDesc*, size_t)>(
|
|
hipMemPoolSetAccess_ptr);
|
|
hipError_t (*dyn_hipMemPoolGetAccess_ptr)(hipMemAccessFlags*, hipMemPool_t, hipMemLocation*) =
|
|
reinterpret_cast<hipError_t (*)(hipMemAccessFlags*, hipMemPool_t, hipMemLocation*)>(
|
|
hipMemPoolGetAccess_ptr);
|
|
hipError_t (*dyn_hipMemPoolSetAttribute_ptr)(hipMemPool_t, hipMemPoolAttr, void*) =
|
|
reinterpret_cast<hipError_t (*)(hipMemPool_t, hipMemPoolAttr, void*)>(
|
|
hipMemPoolSetAttribute_ptr);
|
|
hipError_t (*dyn_hipMemPoolGetAttribute_ptr)(hipMemPool_t, hipMemPoolAttr, void*) =
|
|
reinterpret_cast<hipError_t (*)(hipMemPool_t, hipMemPoolAttr, void*)>(
|
|
hipMemPoolGetAttribute_ptr);
|
|
|
|
// Validating hipMallocAsync, hipFreeAsync API's
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
void* dPtr = nullptr;
|
|
HIP_CHECK(dyn_hipMallocAsync_ptr(&dPtr, 256, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
REQUIRE(dPtr != nullptr);
|
|
|
|
size_t size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(dPtr, &size));
|
|
REQUIRE(size == 256);
|
|
|
|
HIP_CHECK(dyn_hipFreeAsync_ptr(dPtr, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
REQUIRE(hipMemPtrGetInfo(dPtr, &size) == hipErrorInvalidValue);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
}
|
|
|
|
// Validating hipMemPoolCreate , hipMallocFromPoolAsync API's
|
|
{
|
|
// hipMemPoolCreate
|
|
hipMemPoolProps pool_props;
|
|
pool_props.allocType = hipMemAllocationTypePinned;
|
|
pool_props.handleTypes = hipMemHandleTypeNone;
|
|
pool_props.location.type = hipMemLocationTypeDevice;
|
|
pool_props.location.id = 0;
|
|
pool_props.win32SecurityAttributes = nullptr;
|
|
pool_props.maxSize = 1024;
|
|
|
|
hipMemPool_t mem_pool = nullptr;
|
|
HIP_CHECK(dyn_hipMemPoolCreate_ptr(&mem_pool, &pool_props));
|
|
REQUIRE(mem_pool != nullptr);
|
|
|
|
// hipMallocFromPoolAsync
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
void* dPtr = nullptr;
|
|
HIP_CHECK(dyn_hipMallocFromPoolAsync_ptr(&dPtr, 1024, mem_pool, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
REQUIRE(dPtr != nullptr);
|
|
size_t size = -1;
|
|
HIP_CHECK(hipMemPtrGetInfo(dPtr, &size));
|
|
REQUIRE(size == 1024);
|
|
void* dPtr2 = nullptr;
|
|
REQUIRE(dyn_hipMallocFromPoolAsync_ptr(&dPtr2, 1, mem_pool, stream) == hipErrorOutOfMemory);
|
|
|
|
HIP_CHECK(dyn_hipFreeAsync_ptr(dPtr, stream));
|
|
HIP_CHECK(hipMemPoolDestroy(mem_pool));
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
}
|
|
|
|
// Validating hipMemPoolDestroy API
|
|
{
|
|
hipMemPoolProps pool_props;
|
|
pool_props.allocType = hipMemAllocationTypePinned;
|
|
pool_props.handleTypes = hipMemHandleTypeNone;
|
|
pool_props.location.type = hipMemLocationTypeDevice;
|
|
pool_props.location.id = 0;
|
|
pool_props.win32SecurityAttributes = nullptr;
|
|
pool_props.maxSize = 1024;
|
|
hipMemPool_t mem_pool = nullptr;
|
|
HIP_CHECK(hipMemPoolCreate(&mem_pool, &pool_props));
|
|
REQUIRE(mem_pool != nullptr);
|
|
|
|
REQUIRE(dyn_hipMemPoolDestroy_ptr(mem_pool) == hipSuccess);
|
|
REQUIRE(dyn_hipMemPoolDestroy_ptr(mem_pool) == hipErrorInvalidValue);
|
|
}
|
|
|
|
// Validating hipMemPoolTrimTo API
|
|
{
|
|
hipMemPoolProps pool_props;
|
|
pool_props.allocType = hipMemAllocationTypePinned;
|
|
pool_props.handleTypes = hipMemHandleTypeNone;
|
|
pool_props.location.type = hipMemLocationTypeDevice;
|
|
pool_props.location.id = 0;
|
|
pool_props.win32SecurityAttributes = nullptr;
|
|
pool_props.maxSize = 1024 * 1024;
|
|
|
|
hipMemPool_t mem_pool = nullptr;
|
|
HIP_CHECK(hipMemPoolCreate(&mem_pool, &pool_props));
|
|
REQUIRE(mem_pool != nullptr);
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
void* dPtr1 = nullptr;
|
|
HIP_CHECK(hipMallocFromPoolAsync(&dPtr1, 1024 * 1024, mem_pool, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
REQUIRE(dPtr1 != nullptr);
|
|
|
|
HIP_CHECK(hipFreeAsync(dPtr1, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
HIP_CHECK(dyn_hipMemPoolTrimTo_ptr(mem_pool, 1024));
|
|
|
|
void* dPtr2 = nullptr;
|
|
REQUIRE(hipMallocFromPoolAsync(&dPtr2, 1024 * 1024, mem_pool, stream) == hipErrorOutOfMemory);
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
REQUIRE(dPtr2 == nullptr);
|
|
|
|
HIP_CHECK(hipMemPoolDestroy(mem_pool));
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
}
|
|
|
|
// Validating hipMemPoolSetAccess, hipMemPoolGetAccess API's
|
|
{
|
|
int deviceCount = 0;
|
|
HIP_CHECK(hipGetDeviceCount(&deviceCount));
|
|
|
|
if (deviceCount > 1) {
|
|
HIP_CHECK(hipSetDevice(0));
|
|
|
|
hipMemPoolProps pool_props;
|
|
|
|
pool_props.allocType = hipMemAllocationTypePinned;
|
|
pool_props.handleTypes = hipMemHandleTypeNone;
|
|
pool_props.location.type = hipMemLocationTypeDevice;
|
|
pool_props.location.id = 0;
|
|
pool_props.win32SecurityAttributes = nullptr;
|
|
pool_props.maxSize = 1024;
|
|
|
|
hipMemPool_t mem_pool = nullptr;
|
|
HIP_CHECK(hipMemPoolCreate(&mem_pool, &pool_props));
|
|
REQUIRE(mem_pool != nullptr);
|
|
|
|
hipMemAccessFlags flagsList[] = {hipMemAccessFlagsProtRead, hipMemAccessFlagsProtReadWrite};
|
|
|
|
for (hipMemAccessFlags flag : flagsList) {
|
|
hipMemAccessDesc desc;
|
|
hipMemLocation location = {hipMemLocationTypeDevice, 1};
|
|
desc.location = location;
|
|
desc.flags = flag;
|
|
HIP_CHECK(dyn_hipMemPoolSetAccess_ptr(mem_pool, &desc, 1));
|
|
|
|
hipMemAccessFlags flags;
|
|
HIP_CHECK(dyn_hipMemPoolGetAccess_ptr(&flags, mem_pool, &location));
|
|
REQUIRE(flags == flag);
|
|
}
|
|
HIP_CHECK(hipMemPoolDestroy(mem_pool));
|
|
}
|
|
}
|
|
|
|
// Validating hipMemPoolSetAttribute, hipMemPoolGetAttribute API's
|
|
{
|
|
HIP_CHECK(hipSetDevice(0));
|
|
|
|
hipMemPoolProps pool_props{};
|
|
pool_props.allocType = hipMemAllocationTypePinned;
|
|
pool_props.handleTypes = hipMemHandleTypeNone;
|
|
pool_props.location.type = hipMemLocationTypeDevice;
|
|
pool_props.location.id = 0;
|
|
pool_props.win32SecurityAttributes = nullptr;
|
|
pool_props.maxSize = 1024 * 1024;
|
|
hipMemPool_t mem_pool = nullptr;
|
|
HIP_CHECK(hipMemPoolCreate(&mem_pool, &pool_props));
|
|
REQUIRE(mem_pool != nullptr);
|
|
|
|
// Attribute - hipMemPoolReuseFollowEventDependencies
|
|
{
|
|
hipMemPoolAttr attr = hipMemPoolReuseFollowEventDependencies;
|
|
|
|
int valueToSet = 0;
|
|
HIP_CHECK(dyn_hipMemPoolSetAttribute_ptr(mem_pool, attr, &valueToSet));
|
|
|
|
int value;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, attr, &value));
|
|
REQUIRE(value == 0);
|
|
}
|
|
|
|
// Attribute - hipMemPoolReuseAllowOpportunistic
|
|
{
|
|
hipMemPoolAttr attr = hipMemPoolReuseAllowOpportunistic;
|
|
|
|
int valueToSet = 0;
|
|
HIP_CHECK(dyn_hipMemPoolSetAttribute_ptr(mem_pool, attr, &valueToSet));
|
|
|
|
int value;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, attr, &value));
|
|
REQUIRE(value == 0);
|
|
}
|
|
|
|
// Attribute - hipMemPoolReuseAllowInternalDependencies
|
|
{
|
|
hipMemPoolAttr attr = hipMemPoolReuseAllowInternalDependencies;
|
|
|
|
int valueToSet = 0;
|
|
HIP_CHECK(dyn_hipMemPoolSetAttribute_ptr(mem_pool, attr, &valueToSet));
|
|
|
|
int value;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, attr, &value));
|
|
REQUIRE(value == 0);
|
|
}
|
|
|
|
// Attribute - hipMemPoolAttrReleaseThreshold
|
|
{
|
|
hipMemPoolAttr attr = hipMemPoolAttrReleaseThreshold;
|
|
|
|
uint64_t valueToSet = 1024;
|
|
HIP_CHECK(dyn_hipMemPoolSetAttribute_ptr(mem_pool, attr, &valueToSet));
|
|
|
|
uint64_t value;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, attr, &value));
|
|
REQUIRE(value == 1024);
|
|
}
|
|
/*
|
|
Attribute's are,
|
|
hipMemPoolAttrReservedMemCurrent
|
|
hipMemPoolAttrReservedMemHigh
|
|
hipMemPoolAttrUsedMemCurrent
|
|
hipMemPoolAttrUsedMemHigh
|
|
*/
|
|
{
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
void* dPtr1 = nullptr;
|
|
HIP_CHECK(hipMallocFromPoolAsync(&dPtr1, 1024, mem_pool, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
REQUIRE(dPtr1 != nullptr);
|
|
|
|
uint64_t value = 0;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, hipMemPoolAttrReservedMemCurrent, &value));
|
|
REQUIRE(value >= 1024);
|
|
|
|
value = 0;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, hipMemPoolAttrReservedMemHigh, &value));
|
|
REQUIRE(value >= 1024);
|
|
|
|
value = 0;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, hipMemPoolAttrUsedMemCurrent, &value));
|
|
REQUIRE(value >= 1024);
|
|
|
|
value = 0;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, hipMemPoolAttrUsedMemHigh, &value));
|
|
REQUIRE(value >= 1024);
|
|
|
|
HIP_CHECK(hipFreeAsync(dPtr1, stream));
|
|
|
|
uint64_t valueToSet = 0;
|
|
HIP_CHECK(
|
|
dyn_hipMemPoolSetAttribute_ptr(mem_pool, hipMemPoolAttrReservedMemHigh, &valueToSet));
|
|
HIP_CHECK(dyn_hipMemPoolSetAttribute_ptr(mem_pool, hipMemPoolAttrUsedMemHigh, &valueToSet));
|
|
|
|
value = -1;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, hipMemPoolAttrReservedMemHigh, &value));
|
|
REQUIRE(value == 0);
|
|
|
|
value = -1;
|
|
HIP_CHECK(dyn_hipMemPoolGetAttribute_ptr(mem_pool, hipMemPoolAttrUsedMemHigh, &value));
|
|
REQUIRE(value == 0);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
}
|
|
HIP_CHECK(hipMemPoolDestroy(mem_pool));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test Description
|
|
* ------------------------
|
|
* - This test will get the function pointer of different Peer to peer Memory
|
|
* - APIs from the hipGetProcAddress API and then validates the basic
|
|
* - functionality of that particular API using the funtion pointer.
|
|
* Test source
|
|
* ------------------------
|
|
* - unit/memory/hipGetProcAddress_Memory_APIs.cc
|
|
* Test requirements
|
|
* ------------------------
|
|
* - HIP_VERSION >= 6.2
|
|
*/
|
|
TEST_CASE("Unit_hipGetProcAddress_MemoryApisPeerToPeer", "[multigpu]") {
|
|
int deviceCount = 0;
|
|
HIP_CHECK(hipGetDeviceCount(&deviceCount));
|
|
|
|
if (deviceCount < 2) {
|
|
HipTest::HIP_SKIP_TEST("Skipping because this machine has total GPUs < 2");
|
|
return;
|
|
}
|
|
|
|
void* hipMemGetAddressRange_ptr = nullptr;
|
|
void* hipMemcpyPeer_ptr = nullptr;
|
|
void* hipMemcpyPeerAsync_ptr = nullptr;
|
|
|
|
int currentHipVersion = 0;
|
|
HIP_CHECK(hipRuntimeGetVersion(¤tHipVersion));
|
|
|
|
HIP_CHECK(hipGetProcAddress("hipMemGetAddressRange", &hipMemGetAddressRange_ptr,
|
|
currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyPeer", &hipMemcpyPeer_ptr, currentHipVersion, 0, nullptr));
|
|
HIP_CHECK(hipGetProcAddress("hipMemcpyPeerAsync", &hipMemcpyPeerAsync_ptr, currentHipVersion, 0,
|
|
nullptr));
|
|
|
|
hipError_t (*dyn_hipMemGetAddressRange_ptr)(hipDeviceptr_t*, size_t*, hipDeviceptr_t) =
|
|
reinterpret_cast<hipError_t (*)(hipDeviceptr_t*, size_t*, hipDeviceptr_t)>(
|
|
hipMemGetAddressRange_ptr);
|
|
hipError_t (*dyn_hipMemcpyPeer_ptr)(void*, int, const void*, int, size_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, int, const void*, int, size_t)>(hipMemcpyPeer_ptr);
|
|
hipError_t (*dyn_hipMemcpyPeerAsync_ptr)(void*, int, const void*, int, size_t, hipStream_t) =
|
|
reinterpret_cast<hipError_t (*)(void*, int, const void*, int, size_t, hipStream_t)>(
|
|
hipMemcpyPeerAsync_ptr);
|
|
|
|
int deviceId = 0;
|
|
int peerDeviceId = 1;
|
|
|
|
int canAccessPeer = 0;
|
|
HIP_CHECK(hipDeviceCanAccessPeer(&canAccessPeer, deviceId, peerDeviceId));
|
|
if (!canAccessPeer) {
|
|
std::string msg = "Skipped as peer access cannot be enabled between devices " +
|
|
std::to_string(deviceId) + " " + std::to_string(peerDeviceId);
|
|
HipTest::HIP_SKIP_TEST(msg.c_str());
|
|
return;
|
|
}
|
|
|
|
const int N = 16;
|
|
const int Nbytes = N * sizeof(int);
|
|
int value = 10;
|
|
|
|
// Validating hipMemGetAddressRange API
|
|
{
|
|
int* devPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&devPtr, 4 * sizeof(int)));
|
|
REQUIRE(devPtr != nullptr);
|
|
|
|
size_t size = -1;
|
|
hipDeviceptr_t basePtr = nullptr;
|
|
|
|
HIP_CHECK(dyn_hipMemGetAddressRange_ptr(&basePtr, &size, devPtr + 3));
|
|
|
|
REQUIRE(basePtr == devPtr);
|
|
REQUIRE(size == (4 * sizeof(int)));
|
|
}
|
|
|
|
// Validating hipMemcpyPeer API
|
|
{
|
|
HIP_CHECK(hipSetDevice(deviceId));
|
|
|
|
int* srcDevPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&srcDevPtr, Nbytes));
|
|
REQUIRE(srcDevPtr != nullptr);
|
|
fillDeviceArray(srcDevPtr, N, value);
|
|
|
|
HIP_CHECK(hipSetDevice(peerDeviceId));
|
|
|
|
int* dstDevPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevPtr, Nbytes));
|
|
REQUIRE(dstDevPtr != nullptr);
|
|
|
|
HIP_CHECK(dyn_hipMemcpyPeer_ptr(dstDevPtr, peerDeviceId, srcDevPtr, deviceId, Nbytes));
|
|
|
|
validateHostArray(dstDevPtr, N, value);
|
|
|
|
HIP_CHECK(hipFree(srcDevPtr));
|
|
HIP_CHECK(hipFree(dstDevPtr));
|
|
}
|
|
|
|
// Validating hipMemcpyPeerAsync API
|
|
{
|
|
HIP_CHECK(hipSetDevice(deviceId));
|
|
|
|
int* srcDevPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&srcDevPtr, Nbytes));
|
|
REQUIRE(srcDevPtr != nullptr);
|
|
fillDeviceArray(srcDevPtr, N, value);
|
|
|
|
HIP_CHECK(hipSetDevice(peerDeviceId));
|
|
|
|
int* dstDevPtr = nullptr;
|
|
HIP_CHECK(hipMalloc(&dstDevPtr, Nbytes));
|
|
REQUIRE(dstDevPtr != nullptr);
|
|
|
|
hipStream_t stream;
|
|
HIP_CHECK(hipStreamCreate(&stream));
|
|
|
|
HIP_CHECK(
|
|
dyn_hipMemcpyPeerAsync_ptr(dstDevPtr, peerDeviceId, srcDevPtr, deviceId, Nbytes, stream));
|
|
HIP_CHECK(hipStreamSynchronize(stream));
|
|
|
|
validateHostArray(dstDevPtr, N, value);
|
|
|
|
HIP_CHECK(hipStreamDestroy(stream));
|
|
HIP_CHECK(hipFree(srcDevPtr));
|
|
HIP_CHECK(hipFree(dstDevPtr));
|
|
}
|
|
}
|