intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix dependency resolve in level zero black box tests

Browse Source 
Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2023-02-20 12:51:01 +00:00
committed by Compute-Runtime-Automation
parent ac5d719e25
commit b4544f6f78
10 changed files with 105 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
level_zero/core/source/event/event.cpp
View File

@@ -97,8 +97,9 @@ ze_result_t EventPool::initialize(DriverHandle *driver, Context *context, uint32
this->isHostVisibleEventPoolAllocation = !(isEventPoolDeviceAllocationFlagSet());
auto neoDevice = devices[0]->getNEODevice();
if (this->isDeviceEventPoolAllocation) {
NEO::AllocationProperties allocationProperties{*rootDeviceIndices.begin(), this->eventPoolSize, allocationType, devices[0]->getNEODevice()->getDeviceBitfield()};
NEO::AllocationProperties allocationProperties{*rootDeviceIndices.begin(), this->eventPoolSize, allocationType, neoDevice->getDeviceBitfield()};
allocationProperties.alignment = eventAlignment;
auto memoryManager = driver->getMemoryManager();
@@ -111,7 +112,6 @@ ze_result_t EventPool::initialize(DriverHandle *driver, Context *context, uint32
this->isShareableEventMemory = (graphicsAllocation->peekInternalHandle(memoryManager, handle) == 0);
}
}
} else {
NEO::AllocationProperties allocationProperties{*rootDeviceIndices.begin(), this->eventPoolSize, allocationType, systemMemoryBitfield};
allocationProperties.alignment = eventAlignment;
@@ -119,17 +119,18 @@ ze_result_t EventPool::initialize(DriverHandle *driver, Context *context, uint32
eventPoolPtr = driver->getMemoryManager()->createMultiGraphicsAllocationInSystemMemoryPool(rootDeviceIndices,
allocationProperties,
*eventPoolAllocations);
if (eventPoolFlags & ZE_EVENT_POOL_FLAG_IPC) {
this->isShareableEventMemory = eventPoolAllocations->getDefaultGraphicsAllocation()->isShareableHostMemory;
}
allocatedMemory = (nullptr != eventPoolPtr);
}
if (!allocatedMemory) {
return ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;
}
if (neoDevice->getDefaultEngine().commandStreamReceiver->isTbxMode()) {
eventPoolAllocations->getDefaultGraphicsAllocation()->setWriteMemoryOnly(true);
}
return ZE_RESULT_SUCCESS;
}
@@ -289,6 +290,10 @@ ze_result_t EventPool::openEventPoolIpcHandle(const ze_ipc_event_pool_handle_t &
return ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY;
}
if (neoDevice->getDefaultEngine().commandStreamReceiver->isTbxMode()) {
alloc->setWriteMemoryOnly(true);
}
eventPool->context = context;
eventPool->eventPoolAllocations =
std::make_unique<NEO::MultiGraphicsAllocation>(static_cast<uint32_t>(context->rootDeviceIndices.size()));

20
level_zero/core/source/event/event_impl.inl
View File

@@ -240,16 +240,6 @@ template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::hostEventSetValue(TagSizeT eventVal) {
UNRECOVERABLE_IF(hostAddress == nullptr);
if (this->downloadAllocationRequired) {
auto eventAllocation = &this->getAllocation(device);
auto memoryIface = this->device->getNEODevice()->getRootDeviceEnvironment().memoryOperationsInterface.get();
if (NEO::MemoryOperationsStatus::SUCCESS != memoryIface->isResident(nullptr, *eventAllocation)) {
ArrayRef<NEO::GraphicsAllocation *> allocationArray(&eventAllocation, 1);
memoryIface->makeResident(nullptr, allocationArray);
}
}
if (isEventTimestampFlagSet()) {
return hostEventSetValueTimestamps(eventVal);
}
@@ -271,6 +261,16 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValue(TagSizeT eventVal) {
setRemainingPackets(eventVal, packetHostAddr, packets);
}
if (this->downloadAllocationRequired) {
auto memoryIface = this->device->getNEODevice()->getRootDeviceEnvironment().memoryOperationsInterface.get();
auto eventAllocation = &this->getAllocation(device);
ArrayRef<NEO::GraphicsAllocation *> allocationArray(&eventAllocation, 1);
memoryIface->makeResident(nullptr, allocationArray);
constexpr uint32_t allBanks = std::numeric_limits<uint32_t>::max();
eventAllocation->setTbxWritable(true, allBanks);
}
return ZE_RESULT_SUCCESS;
}

4
level_zero/core/test/black_box_tests/zello_commandlist_immediate.cpp
View File

@@ -69,7 +69,9 @@ void testAppendMemoryCopy(ze_context_handle_t &context, ze_device_handle_t &devi
useSyncCmdQ ? nullptr : event, 0, nullptr));
// Copy from device-allocated memory to stack
SUCCESS_OR_TERMINATE(zeCommandListAppendMemoryCopy(cmdList, stackBuffer, zeBuffer, allocSize,
useSyncCmdQ ? nullptr : event2, 0, nullptr));
useSyncCmdQ ? nullptr : event2,
useSyncCmdQ ? 0 : 1,
useSyncCmdQ ? nullptr : &event));
if (!useSyncCmdQ) {
// If Async mode, use event for syncing copies

1
level_zero/core/test/black_box_tests/zello_copy_fence.cpp
View File

@@ -64,6 +64,7 @@ void testAppendMemoryCopy(ze_context_handle_t &context, ze_device_handle_t &devi
// Copy from heap to device-allocated memory
SUCCESS_OR_TERMINATE(zeCommandListAppendMemoryCopy(cmdList, zeBuffer, heapBuffer, allocSize,
nullptr, 0, nullptr));
SUCCESS_OR_TERMINATE(zeCommandListAppendBarrier(cmdList, nullptr, 0, nullptr));
// Copy from device-allocated memory to stack
SUCCESS_OR_TERMINATE(zeCommandListAppendMemoryCopy(cmdList, stackBuffer, zeBuffer, allocSize,
nullptr, 0, nullptr));

28
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@@ -2771,24 +2771,38 @@ HWTEST_F(EventTests, GivenCsrTbxModeWhenEventCreatedAndSignaledThenEventAllocati
auto &ultCsr = neoDevice->getUltCommandStreamReceiver<FamilyType>();
ultCsr.commandStreamReceiverType = CommandStreamReceiverType::CSR_TBX;
ze_result_t result = ZE_RESULT_SUCCESS;
eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, result));
auto event = whiteboxCast(getHelper<L0GfxCoreHelper>().createEvent(eventPool.get(), &eventDesc, device));
auto eventAllocation = &event->getAllocation(device);
EXPECT_TRUE(eventAllocation->getAubInfo().writeMemoryOnly);
auto eventAllocItor = std::find(mockMemIface->gfxAllocationsForMakeResident.begin(),
mockMemIface->gfxAllocationsForMakeResident.end(),
&event->getAllocation(device));
EXPECT_NE(mockMemIface->gfxAllocationsForMakeResident.end(), eventAllocItor);
EXPECT_EQ(1u, mockMemIface->isResidentCalledCount);
eventAllocation);
EXPECT_EQ(mockMemIface->gfxAllocationsForMakeResident.end(), eventAllocItor);
EXPECT_EQ(1, mockMemIface->makeResidentCalledCount);
constexpr uint32_t expectedBanks = std::numeric_limits<uint32_t>::max();
eventAllocation->setTbxWritable(false, expectedBanks);
auto status = event->hostSignal();
EXPECT_EQ(ZE_RESULT_SUCCESS, status);
EXPECT_EQ(2, mockMemIface->makeResidentCalledCount);
EXPECT_EQ(2u, mockMemIface->isResidentCalledCount);
EXPECT_EQ(1, mockMemIface->makeResidentCalledCount);
EXPECT_TRUE(eventAllocation->isTbxWritable(expectedBanks));
std::bitset<32> singleBitMask;
for (uint32_t i = 0; i < 32; i++) {
singleBitMask.reset();
singleBitMask.set(i, true);
uint32_t bit = static_cast<uint32_t>(singleBitMask.to_ulong());
EXPECT_TRUE(eventAllocation->isTbxWritable(bit));
}
event->reset();
EXPECT_EQ(3u, mockMemIface->isResidentCalledCount);
EXPECT_EQ(1, mockMemIface->makeResidentCalledCount);
EXPECT_EQ(3, mockMemIface->makeResidentCalledCount);
size_t offset = event->getCompletionFieldOffset();
void *completionAddress = ptrOffset(event->hostAddress, offset);

4
shared/source/memory_manager/graphics_allocation.h
View File

@@ -42,6 +42,7 @@ struct AubInfo {
bool allocDumpable = false;
bool bcsDumpOnly = false;
bool memObjectsAllocationWithWritableFlags = false;
bool writeMemoryOnly = false;
};
class GraphicsAllocation : public IDNode<GraphicsAllocation> {
@@ -129,6 +130,9 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
aubInfo.allocDumpable = dumpable;
aubInfo.bcsDumpOnly = bcsDumpOnly;
}
void setWriteMemoryOnly(bool writeMemoryOnly) {
aubInfo.writeMemoryOnly = writeMemoryOnly;
}
bool isAllocDumpable() const { return aubInfo.allocDumpable; }
bool isMemObjectsAllocationWithWritableFlags() const { return aubInfo.memObjectsAllocationWithWritableFlags; }
void setMemObjectsAllocationWithWritableFlags(bool newValue) { aubInfo.memObjectsAllocationWithWritableFlags = newValue; }

6
shared/source/os_interface/aub_memory_operations_handler.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -44,7 +44,9 @@ MemoryOperationsStatus AubMemoryOperationsHandler::makeResident(Device *device,
}
aubManager->writeMemory2(params);
residentAllocations.push_back(allocation);
if (!allocation->getAubInfo().writeMemoryOnly) {
residentAllocations.push_back(allocation);
}
}
return MemoryOperationsStatus::SUCCESS;
}

6
shared/test/common/mocks/mock_memory_operations_handler.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -44,7 +44,9 @@ class MockMemoryOperations : public MemoryOperationsHandler {
makeResidentCalledCount++;
if (captureGfxAllocationsForMakeResident) {
for (auto &gfxAllocation : gfxAllocations) {
gfxAllocationsForMakeResident.push_back(gfxAllocation);
if (!gfxAllocation->getAubInfo().writeMemoryOnly) {
gfxAllocationsForMakeResident.push_back(gfxAllocation);
}
}
}
return MemoryOperationsStatus::SUCCESS;

41
shared/test/unit_test/os_interface/aub_memory_operations_handler_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -25,6 +25,45 @@ TEST_F(AubMemoryOperationsHandlerTests, givenAubManagerWhenMakeResidentCalledThe
auto result = memoryOperationsInterface->makeResident(nullptr, ArrayRef<GraphicsAllocation *>(&allocPtr, 1));
EXPECT_EQ(result, MemoryOperationsStatus::SUCCESS);
EXPECT_TRUE(aubManager.writeMemory2Called);
auto itor = std::find(memoryOperationsInterface->residentAllocations.begin(), memoryOperationsInterface->residentAllocations.end(), allocPtr);
EXPECT_NE(memoryOperationsInterface->residentAllocations.end(), itor);
EXPECT_EQ(1u, memoryOperationsInterface->residentAllocations.size());
aubManager.writeMemory2Called = false;
result = memoryOperationsInterface->makeResident(nullptr, ArrayRef<GraphicsAllocation *>(&allocPtr, 1));
EXPECT_EQ(result, MemoryOperationsStatus::SUCCESS);
EXPECT_TRUE(aubManager.writeMemory2Called);
itor = std::find(memoryOperationsInterface->residentAllocations.begin(), memoryOperationsInterface->residentAllocations.end(), allocPtr);
EXPECT_NE(memoryOperationsInterface->residentAllocations.end(), itor);
EXPECT_EQ(2u, memoryOperationsInterface->residentAllocations.size());
}
TEST_F(AubMemoryOperationsHandlerTests, givenAubManagerWhenMakeResidentCalledOnWriteOnlyAllocationThenTrueReturnedAndWriteCalled) {
MockAubManager aubManager;
getMemoryOperationsHandler()->setAubManager(&aubManager);
auto memoryOperationsInterface = getMemoryOperationsHandler();
allocPtr->setWriteMemoryOnly(true);
auto result = memoryOperationsInterface->makeResident(nullptr, ArrayRef<GraphicsAllocation *>(&allocPtr, 1));
EXPECT_EQ(result, MemoryOperationsStatus::SUCCESS);
EXPECT_TRUE(aubManager.writeMemory2Called);
auto itor = std::find(memoryOperationsInterface->residentAllocations.begin(), memoryOperationsInterface->residentAllocations.end(), allocPtr);
EXPECT_EQ(memoryOperationsInterface->residentAllocations.end(), itor);
EXPECT_EQ(0u, memoryOperationsInterface->residentAllocations.size());
aubManager.writeMemory2Called = false;
result = memoryOperationsInterface->makeResident(nullptr, ArrayRef<GraphicsAllocation *>(&allocPtr, 1));
EXPECT_EQ(result, MemoryOperationsStatus::SUCCESS);
EXPECT_TRUE(aubManager.writeMemory2Called);
itor = std::find(memoryOperationsInterface->residentAllocations.begin(), memoryOperationsInterface->residentAllocations.end(), allocPtr);
EXPECT_EQ(memoryOperationsInterface->residentAllocations.end(), itor);
EXPECT_EQ(0u, memoryOperationsInterface->residentAllocations.size());
}
TEST_F(AubMemoryOperationsHandlerTests, givenAubManagerWhenMakeResidentCalledOnCompressedAllocationThenPassCorrectParams) {

13
shared/test/unit_test/os_interface/aub_memory_operations_handler_tests.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -17,21 +17,26 @@
using namespace NEO;
struct MockAubMemoryOperationsHandler : public AubMemoryOperationsHandler {
using AubMemoryOperationsHandler::AubMemoryOperationsHandler;
using AubMemoryOperationsHandler::residentAllocations;
};
class AubMemoryOperationsHandlerTests : public ::testing::Test {
public:
void SetUp() override {
DebugManager.flags.SetCommandStreamReceiver.set(2);
residencyHandler = std::unique_ptr<AubMemoryOperationsHandler>(new AubMemoryOperationsHandler(nullptr));
residencyHandler = std::unique_ptr<MockAubMemoryOperationsHandler>(new MockAubMemoryOperationsHandler(nullptr));
allocPtr = &allocation;
}
AubMemoryOperationsHandler *getMemoryOperationsHandler() {
MockAubMemoryOperationsHandler *getMemoryOperationsHandler() {
return residencyHandler.get();
}
MockGraphicsAllocation allocation;
GraphicsAllocation *allocPtr;
DebugManagerStateRestore dbgRestore;
std::unique_ptr<AubMemoryOperationsHandler> residencyHandler;
std::unique_ptr<MockAubMemoryOperationsHandler> residencyHandler;
};