SWDEV-433312 - Removed duplicate test cases
Change-Id: I606ba0c36cbe5ddf29358a6a733cb3f17aaf27e6
This commit is contained in:
Ioannis Assiouras
@@ -82,18 +82,7 @@ if(HIP_PLATFORM MATCHES "amd")
|
||||
hipMemCoherencyTst.cc
|
||||
hipExtMallocWithFlags.cc
|
||||
hipMallocMngdMultiThread.cc
|
||||
hipArray.cc
|
||||
hipMemVmm.cc
|
||||
hipMemCreate.cc
|
||||
hipMemMap.cc
|
||||
hipMemGetAllocationGranularity.cc
|
||||
hipMemSetGetAccess.cc
|
||||
hipMemRetainAllocationHandle.cc
|
||||
hipMemUnmap.cc
|
||||
hipMemAddressFree.cc
|
||||
hipMemAddressReserve.cc
|
||||
hipMemRelease.cc
|
||||
hipMemGetAllocationPropertiesFromHandle.cc
|
||||
hipArray.cc
|
||||
hipMemcpyDeviceToDeviceNoCU.cc)
|
||||
if(UNIX)
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemAddressFree hipMemAddressFree
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemAddressFree (void* devPtr, size_t size)` -
|
||||
* Frees an address range reservation made via hipMemAddressReserve.
|
||||
*/
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include "hip_vmm_common.hh"
|
||||
|
||||
#define DATA_SIZE (1 << 13)
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemAddressFree.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemAddressFree_negative") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
|
||||
SECTION("nullptr to devptr") {
|
||||
REQUIRE(hipMemAddressFree(nullptr, size_mem) == hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass zero to size") {
|
||||
REQUIRE(hipMemAddressFree(ptrA, 0) == hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
@@ -1,152 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemAddressReserve hipMemAddressReserve
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemAddressReserve (void** ptr,
|
||||
* size_t size,
|
||||
* size_t alignment,
|
||||
* void* addr,
|
||||
* unsigned long long flags)` -
|
||||
* Reserves an address range.
|
||||
*/
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include "hip_vmm_common.hh"
|
||||
|
||||
#define DATA_SIZE (1 << 13)
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Verify if reserved address returned by hipMemAddressReserve
|
||||
* for different alignment values are correctly aligned.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemAddressReserve.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemAddressReserve_AlignmentTest") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
constexpr int initializer = 0;
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
size_t alignmnt = 1;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
// check for address alignment fron 2 to 1024
|
||||
for (int iter = 0; iter < 12; iter++) {
|
||||
alignmnt = alignmnt * 2;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, alignmnt, 0, 0));
|
||||
REQUIRE((reinterpret_cast<size_t>(ptrA) % alignmnt) == 0);
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
// Set access
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Make the address accessible to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemAddressReserve.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemAddressReserve_Negative") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
SECTION("Nullptr to ptr") {
|
||||
REQUIRE(hipMemAddressReserve(nullptr, size_mem, 0, 0, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass size as 0") {
|
||||
REQUIRE(hipMemAddressReserve(&ptrA, 0, 0, 0, 0) ==
|
||||
hipErrorMemoryAllocation);
|
||||
}
|
||||
#if HT_NVIDIA
|
||||
SECTION("pass non power of two for alignment") {
|
||||
REQUIRE(hipMemAddressReserve(&ptrA, size_mem, 3, 0, 0) ==
|
||||
hipErrorMemoryAllocation);
|
||||
}
|
||||
#endif
|
||||
SECTION("pass size as non multiple of host page size") {
|
||||
REQUIRE(hipMemAddressReserve(&ptrA, (size_mem - 1), 0, 0, 0) ==
|
||||
hipErrorMemoryAllocation);
|
||||
}
|
||||
}
|
||||
@@ -1,465 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 Advanced Micro Devices, Inc. All rights reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
/**
|
||||
* @addtogroup hipMemCreate hipMemCreate
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemCreate (hipMemGenericAllocationHandle_t* handle,
|
||||
* size_t size,
|
||||
* const hipMemAllocationProp* prop,
|
||||
* unsigned long long flags)` -
|
||||
* Creates a memory allocation described by the properties and size.
|
||||
*/
|
||||
#include "hip_vmm_common.hh"
|
||||
#include <hip_test_kernels.hh>
|
||||
#include <hip_test_common.hh>
|
||||
|
||||
#define THREADS_PER_BLOCK 512
|
||||
#define NUM_OF_BUFFERS 3
|
||||
#define DATA_SIZE (1 << 13)
|
||||
|
||||
/**
|
||||
Kernel to perform Square of input data.
|
||||
*/
|
||||
static __global__ void square_kernel(int* Buff) {
|
||||
int i = threadIdx.x + blockDim.x * blockIdx.x;
|
||||
int temp = Buff[i] * Buff[i];
|
||||
Buff[i] = temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Allocate physical memories for different multiples of
|
||||
* granularity and deallocate them.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemCreate_BasicAllocateDeAlloc_MultGranularity") {
|
||||
size_t granularity = 0;
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate physical memory
|
||||
for (int mul = 1; mul < 64; mul++) {
|
||||
HIP_CHECK(hipMemCreate(&handle, granularity*mul, &prop, 0));
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Allocate physical memory and map it to virtual address range.
|
||||
* After setting device permission, copy data from host to VMM memory
|
||||
* and back to host. Verify the result. Release handle at end after
|
||||
* unmapping VMM range.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemCreate_ChkDev2HstMemcpy_ReleaseHdlPostUnmap") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
// Set access
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Make the address accessible to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Allocate physical memory and map it to virtual address
|
||||
* range. After setting device permission, copy data from host
|
||||
* to VMM memory and back to host. Verify the result. Release
|
||||
* handle before the VMM range is used.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemCreate_ChkDev2HstMemcpy_ReleaseHdlPreUse") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
// Set access
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Make the address accessible to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Allocate physical memory and map it to virtual address
|
||||
* range. After setting device permission, copy data from host
|
||||
* to device, launch kernel to square the data, copy data back
|
||||
* to host. Verify the result.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
|
||||
TEST_CASE("Unit_hipMemCreate_ChkWithKerLaunch") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
// Set access
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Make the address accessible to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
std::vector<int> A_h(N), B_h(N), C_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
C_h[idx] = idx*idx;
|
||||
}
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
// Invoke kernel
|
||||
hipLaunchKernelGGL(square_kernel, dim3(N / THREADS_PER_BLOCK),
|
||||
dim3(THREADS_PER_BLOCK), 0, 0, static_cast<int*>(ptrA));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), C_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Allocate multiple non-contiguous physical memory chunks
|
||||
* and map it to contiguous virtual address range. After setting
|
||||
* device permission, copy data from host to device, launch kernel
|
||||
* to square the data, copy data back to host. Verify the result.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemCreate_MapNonContiguousChunks") {
|
||||
size_t granularity = 0;
|
||||
constexpr int numOfBuffers = NUM_OF_BUFFERS;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle[NUM_OF_BUFFERS];
|
||||
// Allocate 3 physical memory chunks
|
||||
for (int count = 0; count < numOfBuffers; count++) {
|
||||
HIP_CHECK(hipMemCreate(&handle[count], size_mem, &prop, 0));
|
||||
}
|
||||
// Allocate virtual address range for all the memory chunks
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, (numOfBuffers * size_mem), 0, 0, 0));
|
||||
for (int idx = 0; idx < numOfBuffers; idx++) {
|
||||
uint64_t uiptr = reinterpret_cast<uint64_t>(ptrA);
|
||||
uiptr = uiptr + idx * size_mem;
|
||||
HIP_CHECK(hipMemMap(reinterpret_cast<void*>(uiptr), size_mem, 0,
|
||||
handle[idx], 0));
|
||||
HIP_CHECK(hipMemRelease(handle[idx]));
|
||||
}
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Make the address accessible to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, (numOfBuffers * size_mem), &accessDesc, 1));
|
||||
std::vector<int> A_h(numOfBuffers * size_mem), B_h(numOfBuffers * size_mem),
|
||||
C_h(numOfBuffers * size_mem);
|
||||
// Fill Data
|
||||
for (size_t idx = 0; idx < (numOfBuffers * N); idx++) {
|
||||
A_h[idx] = idx;
|
||||
C_h[idx] = idx*idx;
|
||||
}
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), numOfBuffers * buffer_size));
|
||||
// Launch square kernel
|
||||
hipLaunchKernelGGL(square_kernel, dim3(N / THREADS_PER_BLOCK),
|
||||
dim3(THREADS_PER_BLOCK), 0, 0, static_cast<int*>(ptrA));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, numOfBuffers * buffer_size));
|
||||
HIP_CHECK(hipDeviceSynchronize());
|
||||
// Validate Results
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), C_h.data()));
|
||||
for (int idx = 0; idx < numOfBuffers; idx++) {
|
||||
uint64_t uiptr = reinterpret_cast<uint64_t>(ptrA);
|
||||
uiptr = uiptr + idx * size_mem;
|
||||
HIP_CHECK(hipMemUnmap(reinterpret_cast<void*>(uiptr), size_mem));
|
||||
}
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, (numOfBuffers * size_mem)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - (Check if the VMM address can be memset) Map a physical chunk
|
||||
* to the VMM address range. Memset the VMM address range with initial
|
||||
* value. Validate.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemCreate_ChkWithMemset") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
constexpr int init_val = 0;
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
// Set access
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Make the address accessible to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
std::vector<int> A_h(N);
|
||||
HIP_CHECK(hipMemset(ptrA, init_val, buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(A_h.data(), ptrA, buffer_size));
|
||||
for (int idx = 0; idx < N; idx++) {
|
||||
REQUIRE(A_h[idx] == init_val);
|
||||
}
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemCreate.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemCreate_Negative") {
|
||||
size_t granularity = 0;
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipMemAllocationProp prop = {};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Device
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
|
||||
SECTION("Nullptr to handle") {
|
||||
REQUIRE(hipMemCreate(nullptr, granularity, &prop, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("Nullptr to prop") {
|
||||
REQUIRE(hipMemCreate(&handle, granularity, nullptr, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass size as 0") {
|
||||
REQUIRE(hipMemCreate(&handle, 0, &prop, 0) == hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("Pass prop type as invalid") {
|
||||
prop.type = hipMemAllocationTypeInvalid;
|
||||
REQUIRE(hipMemCreate(&handle, granularity, &prop, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass location as invalid") {
|
||||
prop.location.type = hipMemLocationTypeInvalid;
|
||||
REQUIRE(hipMemCreate(&handle, granularity, &prop, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("non multiple of granularity") {
|
||||
REQUIRE(hipMemCreate(&handle, (granularity - 1), &prop, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass location id as -1") {
|
||||
prop.location.id = -1; // set to non existing device
|
||||
REQUIRE(hipMemCreate(&handle, granularity, &prop, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass location id as > highest device number") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
prop.location.id = numDevices; // set to non existing device
|
||||
REQUIRE(hipMemCreate(&handle, granularity, &prop, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
}
|
||||
@@ -1,179 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemGetAllocationGranularity hipMemGetAllocationGranularity
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemGetAllocationGranularity (size_t* granularity,
|
||||
* const hipMemAllocationProp* prop,
|
||||
* hipMemAllocationGranularity_flags option)` -
|
||||
* Calculates either the minimal or recommended granularity.
|
||||
*/
|
||||
|
||||
#include <hip_test_checkers.hh>
|
||||
#include <hip_test_kernels.hh>
|
||||
#include <hip_test_common.hh>
|
||||
#include "hip_vmm_common.hh"
|
||||
|
||||
/**
|
||||
local function to invoke hipMemGetAllocationGranularity.
|
||||
*/
|
||||
void getGranularity(size_t *granularity,
|
||||
hipMemAllocationGranularity_flags option,
|
||||
int device) {
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(granularity, &prop, option));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Functional Test to get granularity size for
|
||||
* hipMemAllocationGranularityMinimum option.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemGetAllocationGranularity.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemGetAllocationGranularity_MinGranularity") {
|
||||
size_t granularity = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, 0));
|
||||
checkVMMSupported(device)
|
||||
getGranularity(&granularity, hipMemAllocationGranularityMinimum, 0);
|
||||
REQUIRE(granularity > 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Functional Test to get granularity size for
|
||||
* hipMemAllocationGranularityRecommended option.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemGetAllocationGranularity.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemGetAllocationGranularity_RecommendedGranularity") {
|
||||
size_t granularity = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, 0));
|
||||
checkVMMSupported(device)
|
||||
getGranularity(&granularity, hipMemAllocationGranularityRecommended, 0);
|
||||
REQUIRE(granularity > 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Functional Test to get granularity size for
|
||||
* hipMemAllocationGranularityMinimum option for all GPUs.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemGetAllocationGranularity.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemGetAllocationGranularity_AllGPUs") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
for (int dev = 0; dev < numDevices; dev++) {
|
||||
size_t granularity = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, dev));
|
||||
checkVMMSupported(device)
|
||||
getGranularity(&granularity, hipMemAllocationGranularityRecommended,
|
||||
dev);
|
||||
REQUIRE(granularity > 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemGetAllocationGranularity.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemGetAllocationGranularity_NegativeTests") {
|
||||
size_t granularity = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, 0));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = 0; // Current Devices
|
||||
|
||||
SECTION("Granularity is nullptr") {
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(nullptr, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
}
|
||||
SECTION("Prop is nullptr") {
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(&granularity, nullptr,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
}
|
||||
#if HT_NVIDIA
|
||||
SECTION("flag is invalid") {
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
(hipMemAllocationGranularity_flags)0xff));
|
||||
}
|
||||
#endif
|
||||
SECTION("device id > highest device id") {
|
||||
int numDevices = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&numDevices));
|
||||
prop.location.id = numDevices; // set to non existing device
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
}
|
||||
SECTION("device id < lowest device id") {
|
||||
prop.location.id = -1; // set to non existing device
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
}
|
||||
SECTION("allocation type as invalid") {
|
||||
prop.type = hipMemAllocationTypeInvalid;
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
}
|
||||
SECTION("location type as invalid") {
|
||||
prop.location.type = hipMemLocationTypeInvalid;
|
||||
REQUIRE(hipErrorInvalidValue ==
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
}
|
||||
}
|
||||
@@ -1,119 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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_vmm_common.hh"
|
||||
|
||||
#define DATA_SIZE (1 << 13)
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemGetAllocationPropertiesFromHandle hipMemGetAllocationPropertiesFromHandle
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,
|
||||
* hipMemGenericAllocationHandle_t handle)` -
|
||||
* Retrieve the property structure of the given handle.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Functional test to verify the values of hipMemAllocationProp properties.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemGetAllocationPropertiesFromHandle.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemGetAllocationPropertiesFromHandle_functional") {
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, 0));
|
||||
checkVMMSupported(device)
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipMemAllocationProp prop = {};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device;
|
||||
// create a temp prop structure.
|
||||
hipMemAllocationProp prop_temp = {};
|
||||
size_t granularity = 0;
|
||||
int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
HIP_CHECK(hipMemGetAllocationGranularity
|
||||
(&granularity, &prop, hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t mem_size = ((granularity + buffer_size - 1) / granularity)
|
||||
* granularity;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, mem_size, &prop, 0));
|
||||
// verify properties has been retrived from handle
|
||||
HIP_CHECK(hipMemGetAllocationPropertiesFromHandle(&prop_temp, handle));
|
||||
REQUIRE(prop_temp.type == prop.type);
|
||||
REQUIRE(prop_temp.location.type == prop.location.type);
|
||||
REQUIRE(prop_temp.location.id == prop.location.id);
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemGetAllocationPropertiesFromHandle.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemGetAllocationPropertiesFromHandle_Negative") {
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, 0));
|
||||
checkVMMSupported(device)
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipMemAllocationProp prop = {};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device;
|
||||
// create a temp prop structure.
|
||||
hipMemAllocationProp prop_temp = {};
|
||||
size_t granularity = 0;
|
||||
int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
HIP_CHECK(hipMemGetAllocationGranularity
|
||||
(&granularity, &prop, hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t mem_size = ((granularity + buffer_size - 1) / granularity)
|
||||
* granularity;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, mem_size, &prop, 0));
|
||||
|
||||
SECTION("Nullptr as prop") {
|
||||
REQUIRE(hipMemGetAllocationPropertiesFromHandle(nullptr, handle)
|
||||
== hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("null handle") {
|
||||
prop.location.type = hipMemLocationTypeInvalid;
|
||||
REQUIRE(hipMemGetAllocationPropertiesFromHandle(&prop_temp, nullptr)
|
||||
== hipErrorInvalidValue);
|
||||
}
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
}
|
||||
@@ -1,650 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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.
|
||||
*/
|
||||
/**
|
||||
* @addtogroup hipMemMap hipMemMap
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemMap (void* ptr,
|
||||
* size_t size,
|
||||
* size_t offset,
|
||||
* hipMemGenericAllocationHandle_t handle,
|
||||
* unsigned long long flags)` -
|
||||
* Maps an allocation handle to a reserved virtual address range.
|
||||
*/
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include "hip_vmm_common.hh"
|
||||
|
||||
constexpr int N = (1 << 13);
|
||||
constexpr int num_buf = 3;
|
||||
constexpr int initializer = 0;
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if a physical chunk can be mapped/unmapped to same
|
||||
* vmm address range repeatedly. This test validates physical memory
|
||||
* euse using same vmm range.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_SameMemoryReuse") {
|
||||
constexpr int iterations = 20;
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N), C_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
C_h[idx] = idx*idx;
|
||||
}
|
||||
// Allocate a physical memory chunk
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate num_buf virtual address ranges
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
for (int i = 0; i < iterations; i++) {
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
// Set access to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
#if HT_NVIDIA
|
||||
square_kernel <<<dim3(N / threadsPerBlk), dim3(threadsPerBlk), 0, 0>>>(
|
||||
static_cast<int*>(ptrA));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
HIP_CHECK(hipStreamSynchronize(0));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), C_h.data()));
|
||||
#endif
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
}
|
||||
// Release resources
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if a physical chunk can be mapped/unmapped for multiple
|
||||
* vmm addresses. This test validates physical memory reuse using
|
||||
* different vmm ranges.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_PhysicalMemoryReuse_SingleGPU") {
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N), C_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
C_h[idx] = idx*idx;
|
||||
}
|
||||
// Allocate a physical memory chunk
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate num_buf virtual address ranges
|
||||
hipDeviceptr_t ptrA[num_buf];
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA[buf], size_mem, 0, 0, 0));
|
||||
}
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA[buf], size_mem, 0, handle, 0));
|
||||
// Set access to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA[buf], size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA[buf], A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA[buf], buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
#if HT_NVIDIA
|
||||
square_kernel <<<dim3(N / threadsPerBlk), dim3(threadsPerBlk), 0, 0>>>(
|
||||
static_cast<int*>(ptrA[buf]));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA[buf], buffer_size));
|
||||
HIP_CHECK(hipStreamSynchronize(0));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), C_h.data()));
|
||||
#endif
|
||||
HIP_CHECK(hipMemUnmap(ptrA[buf], size_mem));
|
||||
}
|
||||
// Release resources
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemAddressFree(ptrA[buf], size_mem));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if a physical chunk can be mapped to multiple
|
||||
* vmm addresses at the same time and check data values integrity
|
||||
* between different VMMs.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_PhysicalMemory_Map2MultVMMs") {
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
// Allocate a physical memory chunk
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate num_buf virtual address ranges
|
||||
hipDeviceptr_t ptrA[num_buf];
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA[buf], size_mem, 0, 0, 0));
|
||||
}
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemMap(ptrA[buf], size_mem, 0, handle, 0));
|
||||
}
|
||||
// Copy data to VMM via ptrA[0]
|
||||
HIP_CHECK(hipMemSetAccess(ptrA[0], size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA[0], A_h.data(), buffer_size));
|
||||
// Validate the data contained in VMM using ptrA[0], ptrA[1],
|
||||
// ......, ptrA[num_buf-1]
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA[buf], buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
}
|
||||
// Release resources
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemAddressFree(ptrA[buf], size_mem));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if a physical chunk can be mapped/unmapped for
|
||||
* multiple vmm addresses. This test validates physical memory
|
||||
* reuse using different vmm ranges on multiple devices.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_PhysicalMemoryReuse_MultiDev") {
|
||||
int devicecount = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&devicecount));
|
||||
if (devicecount < 2) {
|
||||
HipTest::HIP_SKIP_TEST("Machine is Single GPU. Skipping Test..");
|
||||
return;
|
||||
}
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
for (int devX = 0; devX < devicecount; devX++) {
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, devX));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
// Allocate a physical memory chunk
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate devicecount virtual address ranges
|
||||
std::vector<hipDeviceptr_t> ptrA(devicecount);
|
||||
for (int devY = 0; devY < devicecount; devY++) {
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA[devY], size_mem, 0, 0, 0));
|
||||
}
|
||||
for (int devY = 0; devY < devicecount; devY++) {
|
||||
hipDevice_t deviceToTest;
|
||||
HIP_CHECK(hipDeviceGet(&deviceToTest, devY));
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = deviceToTest;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
HIP_CHECK(hipSetDevice(devY));
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA[devY], size_mem, 0, handle, 0));
|
||||
// Set access to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA[devY], size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA[devY], A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA[devY], buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA[devY], size_mem));
|
||||
}
|
||||
HIP_CHECK(hipSetDevice(0)); // set the device back to 0.
|
||||
// Release resources
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
for (int devY = 0; devY < devicecount; devY++) {
|
||||
HIP_CHECK(hipMemAddressFree(ptrA[devY], size_mem));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if different physical chunk can be mapped/unmapped
|
||||
* for single vmm address. This test validates VMM memory reuse
|
||||
* using different physical ranges.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_VMMMemoryReuse_SingleGPU") {
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle[num_buf];
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N), C_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
C_h[idx] = idx*idx;
|
||||
}
|
||||
// Allocate a physical memory chunk
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemCreate(&handle[buf], size_mem, &prop, 0));
|
||||
}
|
||||
// Allocate num_buf virtual address ranges
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
// Map ptrA to physical chunk
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle[buf], 0));
|
||||
// Set access to GPU 0
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
#if HT_NVIDIA
|
||||
square_kernel <<<dim3(N / threadsPerBlk), dim3(threadsPerBlk), 0, 0>>>(
|
||||
static_cast<int*>(ptrA));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
HIP_CHECK(hipStreamSynchronize(0));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), C_h.data()));
|
||||
#endif
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
}
|
||||
// Release resources
|
||||
for (int buf = 0; buf < num_buf; buf++) {
|
||||
HIP_CHECK(hipMemRelease(handle[buf]));
|
||||
}
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if different physical chunk allocated in different devices
|
||||
* can be mapped/unmapped to single vmm address. This test validates VMM
|
||||
* memory reuse using different physical ranges.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_VMMMemoryReuse_MultiGPU") {
|
||||
int deviceId = 0, devicecount = 0;
|
||||
HIP_CHECK(hipGetDeviceCount(&devicecount));
|
||||
if (devicecount < 2) {
|
||||
HipTest::HIP_SKIP_TEST("Machine is Single GPU. Skipping Test..");
|
||||
return;
|
||||
}
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
std::vector<hipMemGenericAllocationHandle_t> handle(devicecount);
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
// Allocate a physical memory chunk
|
||||
for (int dev = 0; dev < devicecount; dev++) {
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, dev));
|
||||
prop.location.id = device;
|
||||
HIP_CHECK(hipMemCreate(&handle[dev], size_mem, &prop, 0));
|
||||
}
|
||||
// Allocate devicecount virtual address ranges
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
// Map ptrA to physical chunk
|
||||
SECTION("Set Access of VMM to Different GPU") {
|
||||
for (int dev = 0; dev < devicecount; dev++) {
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, dev));
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
HIP_CHECK(hipSetDevice(dev));
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle[dev], 0));
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
}
|
||||
}
|
||||
SECTION("Set Access of VMM to default GPU") {
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
for (int dev = 0; dev < devicecount; dev++) {
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle[dev], 0));
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
}
|
||||
}
|
||||
HIP_CHECK(hipSetDevice(0));
|
||||
// Release resources
|
||||
for (int dev = 0; dev < devicecount; dev++) {
|
||||
HIP_CHECK(hipMemRelease(handle[dev]));
|
||||
}
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if a partial part of a physical chunk can be mapped/unmapped
|
||||
* to a smaller vmm address.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_MapPartialPhysicalMem") {
|
||||
int deviceId = 0;
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
// Allocate a bigger physical memory chunk of twice size_mem
|
||||
HIP_CHECK(hipMemCreate(&handle, 2*size_mem, &prop, 0));
|
||||
// Allocate virtual address range of size size_mem
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
// Release resources
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Check if a partial part of a VMM range can be mapped/unmapped
|
||||
* to a physical address.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_MapPartialVMMMem") {
|
||||
int deviceId = 0;
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(
|
||||
hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
// Allocate host memory and intialize data
|
||||
std::vector<int> A_h(N), B_h(N);
|
||||
// Initialize with data
|
||||
for (size_t idx = 0; idx < N; idx++) {
|
||||
A_h[idx] = idx;
|
||||
}
|
||||
// Allocate a bigger physical memory chunk of size_mem
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range of size twice size_mem
|
||||
hipDeviceptr_t ptrA;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, 2*size_mem, 0, 0, 0));
|
||||
hipMemAccessDesc accessDesc = {};
|
||||
accessDesc.location.type = hipMemLocationTypeDevice;
|
||||
accessDesc.location.id = device;
|
||||
accessDesc.flags = hipMemAccessFlagsProtReadWrite;
|
||||
std::fill(B_h.begin(), B_h.end(), initializer);
|
||||
HIP_CHECK(hipMemMap(ptrA , size_mem, 0, handle, 0));
|
||||
HIP_CHECK(hipMemSetAccess(ptrA, size_mem, &accessDesc, 1));
|
||||
HIP_CHECK(hipMemcpyHtoD(ptrA, A_h.data(), buffer_size));
|
||||
HIP_CHECK(hipMemcpyDtoH(B_h.data(), ptrA, buffer_size));
|
||||
REQUIRE(true == std::equal(B_h.begin(), B_h.end(), A_h.data()));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
// Release resources
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, 2*size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Argument Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemMap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemMap_negative") {
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipDeviceptr_t ptrA;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
|
||||
SECTION("nullptr to ptrA") {
|
||||
REQUIRE(hipMemMap(nullptr, size_mem, 0, handle, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass zero to size") {
|
||||
REQUIRE(hipMemMap(&ptrA, 0, 0, handle, 0) == hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass negative to offset") {
|
||||
REQUIRE(hipMemMap(&ptrA, size_mem, -1, handle, 0) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemRelease hipMemRelease
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipMemRelease(hipMemGenericAllocationHandle_t handle)` -
|
||||
* Release a memory handle representing a memory allocation which was previously
|
||||
* allocated through hipMemCreate.
|
||||
*/
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemRelease.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemRelease_negative") {
|
||||
SECTION("Nullptr to handle") {
|
||||
REQUIRE(hipMemRelease(nullptr) == hipErrorInvalidValue);
|
||||
}
|
||||
}
|
||||
@@ -1,144 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 Advanced Micro Devices, Inc. All rights reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemRetainAllocationHandle hipMemRetainAllocationHandle
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t* handle,
|
||||
* void* addr)` -
|
||||
* Returns the allocation handle of the backing memory allocation given the address.
|
||||
*/
|
||||
|
||||
#include <hip_test_kernels.hh>
|
||||
#include <hip_test_common.hh>
|
||||
#include "hip_vmm_common.hh"
|
||||
|
||||
#define DATA_SIZE (1 << 13)
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Create a VM mapped to physical memory. Input addr to
|
||||
* hipMemRetainAllocationHandle and validate the handle.
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemRetainAllocationHandle.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemRetainAllocationHandle_SetGet") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipDeviceptr_t ptrA;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem,
|
||||
0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
// Test hipMemRetainAllocationHandle
|
||||
hipMemGenericAllocationHandle_t gethandle;
|
||||
// Check beginning of VMM ptr
|
||||
HIP_CHECK(hipMemRetainAllocationHandle(&gethandle,
|
||||
reinterpret_cast<void*>(ptrA)));
|
||||
REQUIRE(gethandle == handle);
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemRetainAllocationHandle.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemRetainAllocationHandle_NegTst") {
|
||||
size_t granularity = 0;
|
||||
constexpr int N = DATA_SIZE;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipDeviceptr_t ptrA;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem,
|
||||
0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
// Test hipMemRetainAllocationHandle
|
||||
hipMemGenericAllocationHandle_t gethandle;
|
||||
SECTION("nullptr handle") {
|
||||
REQUIRE(hipMemRetainAllocationHandle(nullptr,
|
||||
reinterpret_cast<void*>(ptrA)) == hipErrorInvalidValue);
|
||||
}
|
||||
SECTION("nullptr Vmm ptr") {
|
||||
REQUIRE(hipMemRetainAllocationHandle(&gethandle, nullptr) ==
|
||||
hipErrorInvalidValue);
|
||||
}
|
||||
SECTION("not mapped address") {
|
||||
hipDeviceptr_t ptrB;
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrB, size_mem, 0, 0, 0));
|
||||
REQUIRE(hipMemRetainAllocationHandle(&gethandle,
|
||||
reinterpret_cast<void*>(ptrB)) == hipErrorInvalidValue);
|
||||
HIP_CHECK(hipMemAddressFree(ptrB, size_mem));
|
||||
}
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
SECTION("unmapped address") {
|
||||
REQUIRE(hipMemRetainAllocationHandle(&gethandle,
|
||||
reinterpret_cast<void*>(ptrA)) == hipErrorInvalidValue);
|
||||
}
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,88 +0,0 @@
|
||||
/*
|
||||
Copyright (c) 2023 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup hipMemUnmap hipMemUnmap
|
||||
* @{
|
||||
* @ingroup MemoryTest
|
||||
* `hipError_t hipMemUnmap (void* ptr, size_t size)` -
|
||||
* Unmap memory allocation of a given address range.
|
||||
*/
|
||||
|
||||
|
||||
#include <hip_test_common.hh>
|
||||
#include "hip_vmm_common.hh"
|
||||
|
||||
constexpr int N = (1 << 13);
|
||||
/**
|
||||
* Test Description
|
||||
* ------------------------
|
||||
* - Negative Tests
|
||||
* ------------------------
|
||||
* - catch\unit\memory\hipMemUnmap.cc
|
||||
* Test requirements
|
||||
* ------------------------
|
||||
* - HIP_VERSION >= 6.1
|
||||
*/
|
||||
TEST_CASE("Unit_hipMemUnmap_negative") {
|
||||
size_t granularity = 0;
|
||||
size_t buffer_size = N * sizeof(int);
|
||||
int deviceId = 0;
|
||||
hipDevice_t device;
|
||||
|
||||
HIP_CHECK(hipDeviceGet(&device, deviceId));
|
||||
checkVMMSupported(device)
|
||||
|
||||
hipMemAllocationProp prop{};
|
||||
prop.type = hipMemAllocationTypePinned;
|
||||
prop.location.type = hipMemLocationTypeDevice;
|
||||
prop.location.id = device; // Current Devices
|
||||
|
||||
HIP_CHECK(hipMemGetAllocationGranularity(&granularity, &prop,
|
||||
hipMemAllocationGranularityMinimum));
|
||||
REQUIRE(granularity > 0);
|
||||
size_t size_mem =
|
||||
((granularity + buffer_size - 1) / granularity) * granularity;
|
||||
|
||||
hipMemGenericAllocationHandle_t handle;
|
||||
hipDeviceptr_t ptrA;
|
||||
// Allocate physical memory
|
||||
HIP_CHECK(hipMemCreate(&handle, size_mem, &prop, 0));
|
||||
// Allocate virtual address range
|
||||
HIP_CHECK(hipMemAddressReserve(&ptrA, size_mem, 0, 0, 0));
|
||||
HIP_CHECK(hipMemMap(ptrA, size_mem, 0, handle, 0));
|
||||
SECTION("nullptr to ptrA") {
|
||||
REQUIRE(hipMemUnmap(nullptr, size_mem) == hipErrorInvalidValue);
|
||||
}
|
||||
|
||||
SECTION("pass zero to size") {
|
||||
REQUIRE(hipMemUnmap(ptrA, 0) == hipErrorInvalidValue);
|
||||
}
|
||||
#if HT_NVIDIA
|
||||
SECTION("unmap a smaller size") {
|
||||
REQUIRE(hipMemUnmap(ptrA, (size_mem - 1)) == hipErrorInvalidValue);
|
||||
}
|
||||
#endif
|
||||
HIP_CHECK(hipMemRelease(handle));
|
||||
HIP_CHECK(hipMemUnmap(ptrA, size_mem));
|
||||
HIP_CHECK(hipMemAddressFree(ptrA, size_mem));
|
||||
}
|
||||
Reference in New Issue
Block a user