mirror of
https://github.com/intel/compute-runtime.git
synced 2026-01-10 07:08:04 +08:00
feature: treat imported host pointer as host USM
Related-To: GSD-6061, NEO-8858 Signed-off-by: Lu, Wenbin <wenbin.lu@intel.com>
This commit is contained in:
Lu, Wenbin
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
7a14db7f9b
commit
5f4ab5c1dd
@@ -28,12 +28,14 @@ inline constexpr size_t commonImmediateCommandSize = 4 * MemoryConstants::kiloBy
|
||||
|
||||
struct CpuMemCopyInfo {
|
||||
void *const dstPtr;
|
||||
const void *const srcPtr;
|
||||
void *const srcPtr;
|
||||
const size_t size;
|
||||
NEO::SvmAllocationData *dstAllocData{nullptr};
|
||||
NEO::SvmAllocationData *srcAllocData{nullptr};
|
||||
bool dstIsImportedHostPtr = false;
|
||||
bool srcIsImportedHostPtr = false;
|
||||
|
||||
CpuMemCopyInfo(void *dstPtr, const void *srcPtr, size_t size) : dstPtr(dstPtr), srcPtr(srcPtr), size(size) {}
|
||||
CpuMemCopyInfo(void *dstPtr, void *srcPtr, size_t size) : dstPtr(dstPtr), srcPtr(srcPtr), size(size) {}
|
||||
};
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
@@ -179,7 +181,7 @@ struct CommandListCoreFamilyImmediate : public CommandListCoreFamily<gfxCoreFami
|
||||
ze_result_t performCpuMemcpy(const CpuMemCopyInfo &cpuMemCopyInfo, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents);
|
||||
void *obtainLockedPtrFromDevice(NEO::SvmAllocationData *alloc, void *ptr, bool &lockingFailed);
|
||||
bool waitForEventsFromHost();
|
||||
TransferType getTransferType(NEO::SvmAllocationData *dstAlloc, NEO::SvmAllocationData *srcAlloc);
|
||||
TransferType getTransferType(const CpuMemCopyInfo &cpuMemCopyInfo);
|
||||
size_t getTransferThreshold(TransferType transferType);
|
||||
bool isBarrierRequired();
|
||||
bool isRelaxedOrderingDispatchAllowed(uint32_t numWaitEvents) const override;
|
||||
|
||||
@@ -9,15 +9,18 @@
|
||||
|
||||
#include "shared/source/assert_handler/assert_handler.h"
|
||||
#include "shared/source/command_container/command_encoder.h"
|
||||
#include "shared/source/command_container/encode_surface_state.h"
|
||||
#include "shared/source/command_stream/command_stream_receiver_hw.h"
|
||||
#include "shared/source/command_stream/scratch_space_controller.h"
|
||||
#include "shared/source/command_stream/wait_status.h"
|
||||
#include "shared/source/debugger/debugger_l0.h"
|
||||
#include "shared/source/device/device.h"
|
||||
#include "shared/source/direct_submission/relaxed_ordering_helper.h"
|
||||
#include "shared/source/helpers/api_specific_config.h"
|
||||
#include "shared/source/helpers/bindless_heaps_helper.h"
|
||||
#include "shared/source/helpers/blit_commands_helper.h"
|
||||
#include "shared/source/helpers/completion_stamp.h"
|
||||
#include "shared/source/helpers/hw_info.h"
|
||||
#include "shared/source/helpers/surface_format_info.h"
|
||||
#include "shared/source/memory_manager/internal_allocation_storage.h"
|
||||
#include "shared/source/memory_manager/unified_memory_manager.h"
|
||||
#include "shared/source/os_interface/os_context.h"
|
||||
@@ -26,8 +29,13 @@
|
||||
#include "level_zero/core/source/cmdlist/cmdlist_hw_immediate.h"
|
||||
#include "level_zero/core/source/cmdqueue/cmdqueue_hw.h"
|
||||
#include "level_zero/core/source/device/bcs_split.h"
|
||||
#include "level_zero/core/source/device/device_imp.h"
|
||||
#include "level_zero/core/source/driver/driver_handle.h"
|
||||
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
|
||||
#include "level_zero/core/source/helpers/error_code_helper_l0.h"
|
||||
#include "level_zero/core/source/helpers/in_order_cmd_helpers.h"
|
||||
#include "level_zero/core/source/image/image.h"
|
||||
#include "level_zero/core/source/kernel/kernel_imp.h"
|
||||
|
||||
#include "encode_surface_state_args.h"
|
||||
|
||||
@@ -558,7 +566,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::appendMemoryCopy(
|
||||
bool hasStallindCmds = hasStallingCmdsForRelaxedOrdering(numWaitEvents, relaxedOrderingDispatch);
|
||||
|
||||
ze_result_t ret;
|
||||
CpuMemCopyInfo cpuMemCopyInfo(dstptr, srcptr, size);
|
||||
CpuMemCopyInfo cpuMemCopyInfo(dstptr, const_cast<void *>(srcptr), size);
|
||||
this->device->getDriverHandle()->findAllocationDataForRange(const_cast<void *>(srcptr), size, cpuMemCopyInfo.srcAllocData);
|
||||
this->device->getDriverHandle()->findAllocationDataForRange(dstptr, size, cpuMemCopyInfo.dstAllocData);
|
||||
if (preferCopyThroughLockedPtr(cpuMemCopyInfo, numWaitEvents, phWaitEvents)) {
|
||||
@@ -951,7 +959,16 @@ bool CommandListCoreFamilyImmediate<gfxCoreFamily>::preferCopyThroughLockedPtr(C
|
||||
return false;
|
||||
}
|
||||
|
||||
const TransferType transferType = getTransferType(cpuMemCopyInfo.dstAllocData, cpuMemCopyInfo.srcAllocData);
|
||||
if (cpuMemCopyInfo.srcAllocData == nullptr) {
|
||||
auto hostAlloc = this->getDevice()->getDriverHandle()->findHostPointerAllocation(cpuMemCopyInfo.srcPtr, cpuMemCopyInfo.size, this->getDevice()->getRootDeviceIndex());
|
||||
cpuMemCopyInfo.srcIsImportedHostPtr = hostAlloc != nullptr;
|
||||
}
|
||||
if (cpuMemCopyInfo.dstAllocData == nullptr) {
|
||||
auto hostAlloc = this->getDevice()->getDriverHandle()->findHostPointerAllocation(cpuMemCopyInfo.dstPtr, cpuMemCopyInfo.size, this->getDevice()->getRootDeviceIndex());
|
||||
cpuMemCopyInfo.dstIsImportedHostPtr = hostAlloc != nullptr;
|
||||
}
|
||||
|
||||
const TransferType transferType = getTransferType(cpuMemCopyInfo);
|
||||
const size_t transferThreshold = getTransferThreshold(transferType);
|
||||
|
||||
bool cpuMemCopyEnabled = false;
|
||||
@@ -1109,16 +1126,16 @@ void *CommandListCoreFamilyImmediate<gfxCoreFamily>::obtainLockedPtrFromDevice(N
|
||||
}
|
||||
|
||||
template <GFXCORE_FAMILY gfxCoreFamily>
|
||||
TransferType CommandListCoreFamilyImmediate<gfxCoreFamily>::getTransferType(NEO::SvmAllocationData *dstAlloc, NEO::SvmAllocationData *srcAlloc) {
|
||||
const bool srcHostUSM = isSuitableUSMHostAlloc(srcAlloc);
|
||||
const bool srcDeviceUSM = isSuitableUSMDeviceAlloc(srcAlloc);
|
||||
const bool srcSharedUSM = isSuitableUSMSharedAlloc(srcAlloc);
|
||||
const bool srcHostNonUSM = srcAlloc == nullptr;
|
||||
TransferType CommandListCoreFamilyImmediate<gfxCoreFamily>::getTransferType(const CpuMemCopyInfo &cpuMemCopyInfo) {
|
||||
const bool srcHostUSM = isSuitableUSMHostAlloc(cpuMemCopyInfo.srcAllocData) || cpuMemCopyInfo.srcIsImportedHostPtr;
|
||||
const bool srcDeviceUSM = isSuitableUSMDeviceAlloc(cpuMemCopyInfo.srcAllocData);
|
||||
const bool srcSharedUSM = isSuitableUSMSharedAlloc(cpuMemCopyInfo.srcAllocData);
|
||||
const bool srcHostNonUSM = (cpuMemCopyInfo.srcAllocData == nullptr) && !cpuMemCopyInfo.srcIsImportedHostPtr;
|
||||
|
||||
const bool dstHostUSM = isSuitableUSMHostAlloc(dstAlloc);
|
||||
const bool dstDeviceUSM = isSuitableUSMDeviceAlloc(dstAlloc);
|
||||
const bool dstSharedUSM = isSuitableUSMSharedAlloc(dstAlloc);
|
||||
const bool dstHostNonUSM = dstAlloc == nullptr;
|
||||
const bool dstHostUSM = isSuitableUSMHostAlloc(cpuMemCopyInfo.dstAllocData) || cpuMemCopyInfo.dstIsImportedHostPtr;
|
||||
const bool dstDeviceUSM = isSuitableUSMDeviceAlloc(cpuMemCopyInfo.dstAllocData);
|
||||
const bool dstSharedUSM = isSuitableUSMSharedAlloc(cpuMemCopyInfo.dstAllocData);
|
||||
const bool dstHostNonUSM = (cpuMemCopyInfo.dstAllocData == nullptr) && !cpuMemCopyInfo.dstIsImportedHostPtr;
|
||||
|
||||
if (srcHostNonUSM && dstHostUSM) {
|
||||
return HOST_NON_USM_TO_HOST_USM;
|
||||
|
||||
@@ -7,8 +7,6 @@
|
||||
|
||||
#include "shared/source/os_interface/os_interface.h"
|
||||
#include "shared/source/os_interface/product_helper.h"
|
||||
#include "shared/source/os_interface/sys_calls_common.h"
|
||||
#include "shared/test/common/cmd_parse/hw_parse.h"
|
||||
#include "shared/test/common/helpers/unit_test_helper.h"
|
||||
#include "shared/test/common/libult/ult_command_stream_receiver.h"
|
||||
#include "shared/test/common/mocks/mock_command_stream_receiver.h"
|
||||
@@ -27,7 +25,6 @@
|
||||
#include "level_zero/core/test/unit_tests/fixtures/module_fixture.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_image.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
|
||||
#include "level_zero/core/test/unit_tests/mocks/mock_module.h"
|
||||
|
||||
@@ -1927,6 +1924,115 @@ struct AppendMemoryLockedCopyFixture : public DeviceFixture {
|
||||
|
||||
using AppendMemoryLockedCopyTest = Test<AppendMemoryLockedCopyFixture>;
|
||||
|
||||
HWTEST2_F(AppendMemoryLockedCopyTest, givenImmediateCommandListAndImportedHostPtrAsOperandThenItIsTreatedAsHostUsmPtr, IsAtLeastSkl) {
|
||||
MockCommandListImmediateHw<gfxCoreFamily> cmdList;
|
||||
cmdList.copyThroughLockedPtrEnabled = true;
|
||||
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
|
||||
|
||||
auto importedPtr = new char[sz]();
|
||||
EXPECT_NE(nullptr, importedPtr);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getDriverHandle()->importExternalPointer(importedPtr, sz));
|
||||
|
||||
std::array<size_t, 4> sizes = {1, 256, 4096, sz};
|
||||
for (size_t i = 0; i < sizes.size(); i++) {
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToHostUsm(hostPtr, devicePtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(devicePtr, sizes[i], copyInfoDeviceUsmToHostUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoDeviceUsmToHostUsm.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoDeviceUsmToHostUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoDeviceUsmToHostUsm.dstAllocData);
|
||||
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToHostImported(importedPtr, devicePtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(devicePtr, sizes[i], copyInfoDeviceUsmToHostImported.srcAllocData));
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoDeviceUsmToHostImported.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoDeviceUsmToHostImported.srcAllocData);
|
||||
EXPECT_EQ(nullptr, copyInfoDeviceUsmToHostImported.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoDeviceUsmToHostUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoDeviceUsmToHostImported, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoDeviceUsmToHostImported.dstIsImportedHostPtr);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToDeviceUsm(devicePtr, hostPtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoHostUsmToDeviceUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(devicePtr, sizes[i], copyInfoHostUsmToDeviceUsm.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToDeviceUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToDeviceUsm.dstAllocData);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToDeviceUsm(devicePtr, importedPtr, sizes[i]);
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoHostImportedToDeviceUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(devicePtr, sizes[i], copyInfoHostImportedToDeviceUsm.dstAllocData));
|
||||
EXPECT_EQ(nullptr, copyInfoHostImportedToDeviceUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoHostImportedToDeviceUsm.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoHostUsmToDeviceUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoHostImportedToDeviceUsm, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoHostImportedToDeviceUsm.srcIsImportedHostPtr);
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToHostUsm(hostPtr, sharedPtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(sharedPtr, sizes[i], copyInfoSharedUsmToHostUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoSharedUsmToHostUsm.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoSharedUsmToHostUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoSharedUsmToHostUsm.dstAllocData);
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToHostImported(importedPtr, sharedPtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(sharedPtr, sizes[i], copyInfoSharedUsmToHostImported.srcAllocData));
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoSharedUsmToHostImported.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoSharedUsmToHostImported.srcAllocData);
|
||||
EXPECT_EQ(nullptr, copyInfoSharedUsmToHostImported.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoSharedUsmToHostUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoSharedUsmToHostImported, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoSharedUsmToHostImported.dstIsImportedHostPtr);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToSharedUsm(sharedPtr, hostPtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoHostUsmToSharedUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(sharedPtr, sizes[i], copyInfoHostUsmToSharedUsm.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToSharedUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToSharedUsm.dstAllocData);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToSharedUsm(sharedPtr, importedPtr, sizes[i]);
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoHostImportedToSharedUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(sharedPtr, sizes[i], copyInfoHostImportedToSharedUsm.dstAllocData));
|
||||
EXPECT_EQ(nullptr, copyInfoHostImportedToSharedUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoHostImportedToSharedUsm.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoHostUsmToSharedUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoHostImportedToSharedUsm, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoHostImportedToSharedUsm.srcIsImportedHostPtr);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToHostUsm(hostPtr, hostPtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoHostUsmToHostUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoHostUsmToHostUsm.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToHostUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToHostUsm.dstAllocData);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToHostImported(importedPtr, hostPtr, sizes[i]);
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoHostUsmToHostImported.srcAllocData));
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoHostUsmToHostImported.dstAllocData));
|
||||
EXPECT_NE(nullptr, copyInfoHostUsmToHostImported.srcAllocData);
|
||||
EXPECT_EQ(nullptr, copyInfoHostUsmToHostImported.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoHostUsmToHostUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoHostUsmToHostImported, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoHostUsmToHostImported.dstIsImportedHostPtr);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToHostUsm(hostPtr, importedPtr, sizes[i]);
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoHostImportedToHostUsm.srcAllocData));
|
||||
EXPECT_TRUE(device->getDriverHandle()->findAllocationDataForRange(hostPtr, sizes[i], copyInfoHostImportedToHostUsm.dstAllocData));
|
||||
EXPECT_EQ(nullptr, copyInfoHostImportedToHostUsm.srcAllocData);
|
||||
EXPECT_NE(nullptr, copyInfoHostImportedToHostUsm.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoHostUsmToHostUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoHostImportedToHostUsm, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoHostImportedToHostUsm.srcIsImportedHostPtr);
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToHostImported(importedPtr, importedPtr, sizes[i]);
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoHostImportedToHostImported.srcAllocData));
|
||||
EXPECT_FALSE(device->getDriverHandle()->findAllocationDataForRange(importedPtr, sizes[i], copyInfoHostImportedToHostImported.dstAllocData));
|
||||
EXPECT_EQ(nullptr, copyInfoHostImportedToHostImported.srcAllocData);
|
||||
EXPECT_EQ(nullptr, copyInfoHostImportedToHostImported.dstAllocData);
|
||||
|
||||
EXPECT_EQ(cmdList.preferCopyThroughLockedPtr(copyInfoHostUsmToHostUsm, 0, nullptr), cmdList.preferCopyThroughLockedPtr(copyInfoHostImportedToHostImported, 0, nullptr));
|
||||
EXPECT_TRUE(copyInfoHostImportedToHostImported.srcIsImportedHostPtr);
|
||||
}
|
||||
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getDriverHandle()->releaseImportedPointer(importedPtr));
|
||||
delete[] importedPtr;
|
||||
}
|
||||
|
||||
HWTEST2_F(AppendMemoryLockedCopyTest, givenImmediateCommandListAndNonUsmHostPtrWhenPreferCopyThroughLockedPtrCalledForH2DThenReturnTrue, IsAtLeastSkl) {
|
||||
MockCommandListImmediateHw<gfxCoreFamily> cmdList;
|
||||
cmdList.copyThroughLockedPtrEnabled = true;
|
||||
@@ -2198,9 +2304,14 @@ HWTEST2_F(AppendMemoryLockedCopyTest, givenImmediateCommandListWhenGetTransferTy
|
||||
cmdList.copyThroughLockedPtrEnabled = true;
|
||||
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
|
||||
|
||||
void *hostPtr2;
|
||||
void *hostPtr2 = nullptr;
|
||||
ze_host_mem_alloc_desc_t hostDesc = {};
|
||||
context->allocHostMem(&hostDesc, sz, 1u, &hostPtr2);
|
||||
EXPECT_NE(nullptr, hostPtr2);
|
||||
|
||||
void *importedPtr = malloc(sz);
|
||||
EXPECT_NE(nullptr, importedPtr);
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getDriverHandle()->importExternalPointer(importedPtr, sz));
|
||||
|
||||
NEO::SvmAllocationData *hostUSMAllocData;
|
||||
NEO::SvmAllocationData *hostNonUSMAllocData;
|
||||
@@ -2219,29 +2330,149 @@ HWTEST2_F(AppendMemoryLockedCopyTest, givenImmediateCommandListWhenGetTransferTy
|
||||
const auto hostUSM2Found = device->getDriverHandle()->findAllocationDataForRange(hostPtr2, 1024, notSpecifiedAllocData);
|
||||
EXPECT_TRUE(hostUSM2Found);
|
||||
|
||||
notSpecifiedAllocData->memoryType = NOT_SPECIFIED;
|
||||
EXPECT_EQ(TRANSFER_TYPE_UNKNOWN, cmdList.getTransferType(notSpecifiedAllocData, hostNonUSMAllocData));
|
||||
notSpecifiedAllocData->memoryType = InternalMemoryType::NOT_SPECIFIED;
|
||||
CpuMemCopyInfo copyInfoHostNonUsmToNotSpecified(hostPtr2, nonUsmHostPtr, 1024);
|
||||
copyInfoHostNonUsmToNotSpecified.dstAllocData = notSpecifiedAllocData;
|
||||
copyInfoHostNonUsmToNotSpecified.srcAllocData = hostNonUSMAllocData;
|
||||
EXPECT_EQ(TRANSFER_TYPE_UNKNOWN, cmdList.getTransferType(copyInfoHostNonUsmToNotSpecified));
|
||||
|
||||
EXPECT_EQ(HOST_NON_USM_TO_HOST_USM, cmdList.getTransferType(hostUSMAllocData, hostNonUSMAllocData));
|
||||
EXPECT_EQ(HOST_NON_USM_TO_DEVICE_USM, cmdList.getTransferType(deviceUSMAllocData, hostNonUSMAllocData));
|
||||
EXPECT_EQ(HOST_NON_USM_TO_SHARED_USM, cmdList.getTransferType(sharedUSMAllocData, hostNonUSMAllocData));
|
||||
EXPECT_EQ(HOST_NON_USM_TO_HOST_NON_USM, cmdList.getTransferType(hostNonUSMAllocData, hostNonUSMAllocData));
|
||||
CpuMemCopyInfo copyInfoHostNonUsmToHostUsm(hostPtr, nonUsmHostPtr, 1024);
|
||||
copyInfoHostNonUsmToHostUsm.dstAllocData = hostUSMAllocData;
|
||||
copyInfoHostNonUsmToHostUsm.srcAllocData = hostNonUSMAllocData;
|
||||
EXPECT_EQ(HOST_NON_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoHostNonUsmToHostUsm));
|
||||
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_USM, cmdList.getTransferType(hostUSMAllocData, hostUSMAllocData));
|
||||
EXPECT_EQ(HOST_USM_TO_DEVICE_USM, cmdList.getTransferType(deviceUSMAllocData, hostUSMAllocData));
|
||||
EXPECT_EQ(HOST_USM_TO_SHARED_USM, cmdList.getTransferType(sharedUSMAllocData, hostUSMAllocData));
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_NON_USM, cmdList.getTransferType(hostNonUSMAllocData, hostUSMAllocData));
|
||||
CpuMemCopyInfo copyInfoHostNonUsmToDeviceUsm(devicePtr, nonUsmHostPtr, 1024);
|
||||
copyInfoHostNonUsmToDeviceUsm.dstAllocData = deviceUSMAllocData;
|
||||
copyInfoHostNonUsmToDeviceUsm.srcAllocData = hostNonUSMAllocData;
|
||||
EXPECT_EQ(HOST_NON_USM_TO_DEVICE_USM, cmdList.getTransferType(copyInfoHostNonUsmToDeviceUsm));
|
||||
|
||||
EXPECT_EQ(DEVICE_USM_TO_HOST_USM, cmdList.getTransferType(hostUSMAllocData, deviceUSMAllocData));
|
||||
EXPECT_EQ(DEVICE_USM_TO_DEVICE_USM, cmdList.getTransferType(deviceUSMAllocData, deviceUSMAllocData));
|
||||
EXPECT_EQ(DEVICE_USM_TO_SHARED_USM, cmdList.getTransferType(sharedUSMAllocData, deviceUSMAllocData));
|
||||
EXPECT_EQ(DEVICE_USM_TO_HOST_NON_USM, cmdList.getTransferType(hostNonUSMAllocData, deviceUSMAllocData));
|
||||
CpuMemCopyInfo copyInfoHostNonUsmToSharedUsm(sharedPtr, nonUsmHostPtr, 1024);
|
||||
copyInfoHostNonUsmToSharedUsm.dstAllocData = sharedUSMAllocData;
|
||||
copyInfoHostNonUsmToSharedUsm.srcAllocData = hostNonUSMAllocData;
|
||||
EXPECT_EQ(HOST_NON_USM_TO_SHARED_USM, cmdList.getTransferType(copyInfoHostNonUsmToSharedUsm));
|
||||
|
||||
EXPECT_EQ(SHARED_USM_TO_HOST_USM, cmdList.getTransferType(hostUSMAllocData, sharedUSMAllocData));
|
||||
EXPECT_EQ(SHARED_USM_TO_DEVICE_USM, cmdList.getTransferType(deviceUSMAllocData, sharedUSMAllocData));
|
||||
EXPECT_EQ(SHARED_USM_TO_SHARED_USM, cmdList.getTransferType(sharedUSMAllocData, sharedUSMAllocData));
|
||||
EXPECT_EQ(SHARED_USM_TO_HOST_NON_USM, cmdList.getTransferType(hostNonUSMAllocData, sharedUSMAllocData));
|
||||
CpuMemCopyInfo copyInfoHostNonUsmToHostNonUsm(nonUsmHostPtr, nonUsmHostPtr, 1024);
|
||||
copyInfoHostNonUsmToHostNonUsm.dstAllocData = hostNonUSMAllocData;
|
||||
copyInfoHostNonUsmToHostNonUsm.srcAllocData = hostNonUSMAllocData;
|
||||
EXPECT_EQ(HOST_NON_USM_TO_HOST_NON_USM, cmdList.getTransferType(copyInfoHostNonUsmToHostNonUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostNonUsmToHostImported(importedPtr, nonUsmHostPtr, 1024);
|
||||
copyInfoHostNonUsmToHostImported.dstIsImportedHostPtr = true;
|
||||
copyInfoHostNonUsmToHostImported.dstAllocData = nullptr;
|
||||
copyInfoHostNonUsmToHostImported.srcAllocData = hostNonUSMAllocData;
|
||||
EXPECT_EQ(HOST_NON_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoHostNonUsmToHostImported));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToHostUsm(hostPtr, importedPtr, 1024);
|
||||
copyInfoHostImportedToHostUsm.dstAllocData = hostUSMAllocData;
|
||||
copyInfoHostImportedToHostUsm.srcIsImportedHostPtr = true;
|
||||
copyInfoHostImportedToHostUsm.srcAllocData = nullptr;
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoHostImportedToHostUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToDeviceUsm(devicePtr, importedPtr, 1024);
|
||||
copyInfoHostImportedToDeviceUsm.dstAllocData = deviceUSMAllocData;
|
||||
copyInfoHostImportedToDeviceUsm.srcIsImportedHostPtr = true;
|
||||
copyInfoHostImportedToDeviceUsm.srcAllocData = nullptr;
|
||||
EXPECT_EQ(HOST_USM_TO_DEVICE_USM, cmdList.getTransferType(copyInfoHostImportedToDeviceUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToSharedUsm(sharedPtr, importedPtr, 1024);
|
||||
copyInfoHostImportedToSharedUsm.dstAllocData = sharedUSMAllocData;
|
||||
copyInfoHostImportedToSharedUsm.srcIsImportedHostPtr = true;
|
||||
copyInfoHostImportedToSharedUsm.srcAllocData = nullptr;
|
||||
EXPECT_EQ(HOST_USM_TO_SHARED_USM, cmdList.getTransferType(copyInfoHostImportedToSharedUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToHostNonUsm(nonUsmHostPtr, importedPtr, 1024);
|
||||
copyInfoHostImportedToHostNonUsm.dstAllocData = hostNonUSMAllocData;
|
||||
copyInfoHostImportedToHostNonUsm.srcIsImportedHostPtr = true;
|
||||
copyInfoHostImportedToHostNonUsm.srcAllocData = nullptr;
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_NON_USM, cmdList.getTransferType(copyInfoHostImportedToHostNonUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostImportedToHostImported(importedPtr, importedPtr, 1024);
|
||||
copyInfoHostImportedToHostImported.dstIsImportedHostPtr = true;
|
||||
copyInfoHostImportedToHostImported.dstAllocData = nullptr;
|
||||
copyInfoHostImportedToHostImported.srcIsImportedHostPtr = true;
|
||||
copyInfoHostImportedToHostImported.srcAllocData = nullptr;
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoHostImportedToHostImported));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToHostUsm(hostPtr, hostPtr, 1024);
|
||||
copyInfoHostUsmToHostUsm.dstAllocData = hostUSMAllocData;
|
||||
copyInfoHostUsmToHostUsm.srcAllocData = hostUSMAllocData;
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoHostUsmToHostUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToDeviceUsm(devicePtr, hostPtr, 1024);
|
||||
copyInfoHostUsmToDeviceUsm.dstAllocData = deviceUSMAllocData;
|
||||
copyInfoHostUsmToDeviceUsm.srcAllocData = hostUSMAllocData;
|
||||
EXPECT_EQ(HOST_USM_TO_DEVICE_USM, cmdList.getTransferType(copyInfoHostUsmToDeviceUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToSharedUsm(sharedPtr, hostPtr, 1024);
|
||||
copyInfoHostUsmToSharedUsm.dstAllocData = sharedUSMAllocData;
|
||||
copyInfoHostUsmToSharedUsm.srcAllocData = hostUSMAllocData;
|
||||
EXPECT_EQ(HOST_USM_TO_SHARED_USM, cmdList.getTransferType(copyInfoHostUsmToSharedUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToHostNonUsm(nonUsmHostPtr, hostPtr, 1024);
|
||||
copyInfoHostUsmToHostNonUsm.dstAllocData = hostNonUSMAllocData;
|
||||
copyInfoHostUsmToHostNonUsm.srcAllocData = hostUSMAllocData;
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_NON_USM, cmdList.getTransferType(copyInfoHostUsmToHostNonUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoHostUsmToHostImported(importedPtr, hostPtr, 1024);
|
||||
copyInfoHostUsmToHostImported.dstIsImportedHostPtr = true;
|
||||
copyInfoHostUsmToHostImported.dstAllocData = nullptr;
|
||||
copyInfoHostUsmToHostImported.srcAllocData = hostUSMAllocData;
|
||||
EXPECT_EQ(HOST_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoHostUsmToHostImported));
|
||||
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToHostUsm(hostPtr, devicePtr, 1024);
|
||||
copyInfoDeviceUsmToHostUsm.dstAllocData = hostUSMAllocData;
|
||||
copyInfoDeviceUsmToHostUsm.srcAllocData = deviceUSMAllocData;
|
||||
EXPECT_EQ(DEVICE_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoDeviceUsmToHostUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToDeviceUsm(devicePtr, devicePtr, 1024);
|
||||
copyInfoDeviceUsmToDeviceUsm.dstAllocData = deviceUSMAllocData;
|
||||
copyInfoDeviceUsmToDeviceUsm.srcAllocData = deviceUSMAllocData;
|
||||
EXPECT_EQ(DEVICE_USM_TO_DEVICE_USM, cmdList.getTransferType(copyInfoDeviceUsmToDeviceUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToSharedUsm(sharedPtr, devicePtr, 1024);
|
||||
copyInfoDeviceUsmToSharedUsm.dstAllocData = sharedUSMAllocData;
|
||||
copyInfoDeviceUsmToSharedUsm.srcAllocData = deviceUSMAllocData;
|
||||
EXPECT_EQ(DEVICE_USM_TO_SHARED_USM, cmdList.getTransferType(copyInfoDeviceUsmToSharedUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToHostNonUsm(nonUsmHostPtr, devicePtr, 1024);
|
||||
copyInfoDeviceUsmToHostNonUsm.dstAllocData = hostNonUSMAllocData;
|
||||
copyInfoDeviceUsmToHostNonUsm.srcAllocData = deviceUSMAllocData;
|
||||
EXPECT_EQ(DEVICE_USM_TO_HOST_NON_USM, cmdList.getTransferType(copyInfoDeviceUsmToHostNonUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoDeviceUsmToHostImported(importedPtr, devicePtr, 1024);
|
||||
copyInfoDeviceUsmToHostImported.dstIsImportedHostPtr = true;
|
||||
copyInfoDeviceUsmToHostImported.dstAllocData = nullptr;
|
||||
copyInfoDeviceUsmToHostImported.srcAllocData = deviceUSMAllocData;
|
||||
EXPECT_EQ(DEVICE_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoDeviceUsmToHostImported));
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToHostUsm(hostPtr, sharedPtr, 1024);
|
||||
copyInfoSharedUsmToHostUsm.dstAllocData = hostUSMAllocData;
|
||||
copyInfoSharedUsmToHostUsm.srcAllocData = sharedUSMAllocData;
|
||||
EXPECT_EQ(SHARED_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoSharedUsmToHostUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToDeviceUsm(devicePtr, sharedPtr, 1024);
|
||||
copyInfoSharedUsmToDeviceUsm.dstAllocData = deviceUSMAllocData;
|
||||
copyInfoSharedUsmToDeviceUsm.srcAllocData = sharedUSMAllocData;
|
||||
EXPECT_EQ(SHARED_USM_TO_DEVICE_USM, cmdList.getTransferType(copyInfoSharedUsmToDeviceUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToSharedUsm(sharedPtr, sharedPtr, 1024);
|
||||
copyInfoSharedUsmToSharedUsm.dstAllocData = sharedUSMAllocData;
|
||||
copyInfoSharedUsmToSharedUsm.srcAllocData = sharedUSMAllocData;
|
||||
EXPECT_EQ(SHARED_USM_TO_SHARED_USM, cmdList.getTransferType(copyInfoSharedUsmToSharedUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToHostNonUsm(nonUsmHostPtr, sharedPtr, 1024);
|
||||
copyInfoSharedUsmToHostNonUsm.dstAllocData = hostNonUSMAllocData;
|
||||
copyInfoSharedUsmToHostNonUsm.srcAllocData = sharedUSMAllocData;
|
||||
EXPECT_EQ(SHARED_USM_TO_HOST_NON_USM, cmdList.getTransferType(copyInfoSharedUsmToHostNonUsm));
|
||||
|
||||
CpuMemCopyInfo copyInfoSharedUsmToHostImported(importedPtr, sharedPtr, 1024);
|
||||
copyInfoSharedUsmToHostImported.dstIsImportedHostPtr = true;
|
||||
copyInfoSharedUsmToHostImported.dstAllocData = nullptr;
|
||||
copyInfoSharedUsmToHostImported.srcAllocData = sharedUSMAllocData;
|
||||
EXPECT_EQ(SHARED_USM_TO_HOST_USM, cmdList.getTransferType(copyInfoSharedUsmToHostImported));
|
||||
|
||||
EXPECT_EQ(ZE_RESULT_SUCCESS, device->getDriverHandle()->releaseImportedPointer(importedPtr));
|
||||
free(importedPtr);
|
||||
context->freeMem(hostPtr2);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user