intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-08 22:12:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Enable flush task for immediate command lists"

Browse Source 
This reverts commit 95c3ef28fc.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2022-10-29 14:53:38 +02:00
committed by Compute-Runtime-Automation
parent 0a7166d10e
commit 33d9c5979a
7 changed files with 18 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -144,11 +144,11 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::initialize(Device *device, NEO
if (this->isFlushTaskSubmissionEnabled) {
commandContainer.setFlushTaskUsedForImmediate(this->isFlushTaskSubmissionEnabled);
commandContainer.setNumIddPerBlock(1);
}
if (this->immediateCmdListHeapSharing) {
commandContainer.enableHeapSharing();
commandContainer.setNumIddPerBlock(1);
}
commandContainer.setReservedSshSize(getReserveSshSize());

1
level_zero/core/source/cmdlist/cmdlist_imp.cpp
View File

@@ -138,7 +138,6 @@ CommandList *CommandList::createImmediate(uint32_t productFamily, Device *device
if (NEO::DebugManager.flags.EnableFlushTaskSubmission.get() != -1) {
commandList->isFlushTaskSubmissionEnabled = !!NEO::DebugManager.flags.EnableFlushTaskSubmission.get();
}
PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Flush Task for Immediate command list : %s\n", commandList->isFlushTaskSubmissionEnabled ? "Enabled" : "Disabled");
commandList->immediateCmdListHeapSharing = L0HwHelper::enableImmediateCmdListHeapSharing(hwInfo, commandList->isFlushTaskSubmissionEnabled);
}
returnValue = commandList->initialize(device, engineGroupType, desc->flags);

132
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@@ -1093,15 +1093,16 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnExecutingCommandListsWhenCreatingImme
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::GpuHang;
Mock<CommandQueue> mockCommandQueue(device, &mockCommandStreamReceiver, &desc);
mockCommandQueue.executeCommandListsResult = ZE_RESULT_ERROR_DEVICE_LOST;
const auto oldCsr = commandList->csr;
commandList->csr = &mockCommandStreamReceiver;
auto oldCommandQueue = commandList->cmdQImmediate;
commandList->cmdQImmediate = &mockCommandQueue;
returnValue = commandList->appendWaitOnEvents(1, &event);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue);
commandList->csr = oldCsr;
commandList->cmdQImmediate = oldCommandQueue;
}
TEST_F(CommandListCreate, givenImmediateCommandListWhenThereIsNoEnoughSpaceForImmediateCommandThenNextCommandBufferIsUsed) {
@@ -1131,105 +1132,6 @@ TEST_F(CommandListCreate, givenImmediateCommandListWhenThereIsNoEnoughSpaceForIm
}
HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCommandListAndWaitingOnEventsThenDeviceLostIsReturned, IsSKL) {
DebugManagerStateRestore restorer;
ze_command_queue_desc_t desc = {};
desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue));
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandList);
EXPECT_EQ(device, commandList->device);
EXPECT_EQ(CommandList::CommandListType::TYPE_IMMEDIATE, commandList->cmdListType);
EXPECT_NE(nullptr, commandList->cmdQImmediate);
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
ze_event_handle_t event = nullptr;
std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, eventPool);
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<L0::Event> eventObject(L0::Event::fromHandle(event));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
mockCommandStreamReceiver.waitForCompletionWithTimeoutReturnValue = WaitStatus::GpuHang;
const auto oldCsr = commandList->csr;
commandList->csr = &mockCommandStreamReceiver;
returnValue = commandList->appendWaitOnEvents(1, &event);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue);
commandList->csr = oldCsr;
}
HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCommandListWithoutFlushTaskAndWaitingOnEventsThenDeviceLostIsReturnedFromExecute, IsSKL) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableFlushTaskSubmission.set(0);
ze_command_queue_desc_t desc = {};
desc.mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS;
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue));
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandList);
EXPECT_EQ(device, commandList->device);
EXPECT_EQ(CommandList::CommandListType::TYPE_IMMEDIATE, commandList->cmdListType);
EXPECT_NE(nullptr, commandList->cmdQImmediate);
ze_event_pool_desc_t eventPoolDesc = {};
eventPoolDesc.count = 1;
eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
ze_event_desc_t eventDesc = {};
eventDesc.index = 0;
eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
ze_event_handle_t event = nullptr;
std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, returnValue));
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, eventPool);
eventPool->createEvent(&eventDesc, &event);
std::unique_ptr<L0::Event> eventObject(L0::Event::fromHandle(event));
ASSERT_NE(nullptr, eventObject->csr);
ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, eventObject->csr);
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
Mock<CommandQueue> mockCommandQueue(device, &mockCommandStreamReceiver, &desc);
mockCommandQueue.executeCommandListsResult = ZE_RESULT_ERROR_DEVICE_LOST;
auto oldCommandQueue = commandList->cmdQImmediate;
commandList->cmdQImmediate = &mockCommandQueue;
returnValue = commandList->appendWaitOnEvents(1, &event);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue);
commandList->cmdQImmediate = oldCommandQueue;
}
HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCommandListWithoutFlushTaskAndWaitingOnEventsThenDeviceLostIsReturnedFromSynchronize, IsSKL) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableFlushTaskSubmission.set(0);
ze_command_queue_desc_t desc = {};
desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
@@ -1267,11 +1169,13 @@ HWTEST2_F(CommandListCreate, GivenGpuHangOnSynchronizingWhenCreatingImmediateCom
MockCommandStreamReceiver mockCommandStreamReceiver(*neoDevice->executionEnvironment, neoDevice->getRootDeviceIndex(), neoDevice->getDeviceBitfield());
Mock<CommandQueue> mockCommandQueue(device, &mockCommandStreamReceiver, &desc);
mockCommandQueue.synchronizeResult = ZE_RESULT_ERROR_DEVICE_LOST;
auto oldCommandQueue = commandList->cmdQImmediate;
commandList->cmdQImmediate = &mockCommandQueue;
returnValue = commandList->appendWaitOnEvents(1, &event);
EXPECT_EQ(ZE_RESULT_ERROR_DEVICE_LOST, returnValue);
commandList->cmdQImmediate = oldCommandQueue;
}
@@ -1338,28 +1242,6 @@ HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppen
commandList->csr = oldCsr;
}
HWTEST_F(CommandListCreate, GivenImmediateCommandListWithFlushTaskCreatedThenNumIddPerBlockIsOne) {
DebugManagerStateRestore restorer;
DebugManager.flags.EnableFlushTaskSubmission.set(1);
ze_command_queue_desc_t desc = {};
desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue));
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
ASSERT_NE(nullptr, commandList);
EXPECT_EQ(device, commandList->device);
EXPECT_EQ(CommandList::CommandListType::TYPE_IMMEDIATE, commandList->cmdListType);
EXPECT_NE(nullptr, commandList->cmdQImmediate);
auto &commandContainer = commandList->commandContainer;
EXPECT_EQ(1u, commandContainer.getNumIddPerBlock());
}
HWTEST_F(CommandListCreate, GivenGpuHangAndEnabledFlushTaskSubmissionFlagWhenCreatingImmediateCommandListAndAppendingWaitOnEventsThenDeviceLostIsReturned) {
DebugManagerStateRestore restorer;
NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);

4
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp
View File

@@ -262,7 +262,7 @@ HWTEST2_F(CommandListImmediateFlushTaskComputeTests, givenXeHPCommandListIsIniti
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::Compute, returnValue));
EXPECT_EQ(true, commandList->isFlushTaskSubmissionEnabled);
EXPECT_EQ(false, commandList->isFlushTaskSubmissionEnabled);
}
using MatchXeHpc = IsGfxCore<IGFX_XE_HPC_CORE>;
@@ -279,7 +279,7 @@ HWTEST2_F(CommandListImmediateFlushTaskComputeTests, givenCommandListIsInititali
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::Compute, returnValue));
EXPECT_EQ(true, commandList->isFlushTaskSubmissionEnabled);
EXPECT_EQ(false, commandList->isFlushTaskSubmissionEnabled);
}
HWTEST_F(CommandListImmediateFlushTaskComputeTests, givenFlushTaskSubmissionDisabledWhenCommandListIsInititalizedThenFlushTaskIsSetToFalse) {

4
opencl/test/unit_test/helpers/hw_helper_tests.cpp
View File

@@ -1412,9 +1412,9 @@ HWTEST2_F(HwHelperTest, givenPvcHwHelperWhenGettingIsPlatformFlushTaskEnabledThe
EXPECT_TRUE(hwHelper.isPlatformFlushTaskEnabled(*defaultHwInfo));
}
HWTEST2_F(HwHelperTest, givenAtMostGen12lpHwHelperWhenGettingIsPlatformFlushTaskEnabledThenTrueIsReturned, IsAtMostGen12lp) {
HWTEST2_F(HwHelperTest, givenAtMostGen12lpHwHelperWhenGettingIsPlatformFlushTaskEnabledThenFalseIsReturned, IsAtMostGen12lp) {
auto &hwHelper = NEO::HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily);
EXPECT_TRUE(hwHelper.isPlatformFlushTaskEnabled(*defaultHwInfo));
EXPECT_FALSE(hwHelper.isPlatformFlushTaskEnabled(*defaultHwInfo));
}
struct CoherentWANotNeeded {

2
shared/source/os_interface/hw_info_config.inl
View File

@@ -342,7 +342,7 @@ bool HwInfoConfigHw<gfxProduct>::getUuid(Device *device, std::array<uint8_t, HwI
template <PRODUCT_FAMILY gfxProduct>
bool HwInfoConfigHw<gfxProduct>::isFlushTaskAllowed() const {
return true;
return false;
}
template <PRODUCT_FAMILY gfxProduct>

5
shared/source/xe_hp_core/linux/hw_info_config_xe_hp_sdv.cpp
View File

@@ -79,5 +79,10 @@ uint32_t HwInfoConfigHw<gfxProduct>::getDeviceMemoryMaxClkRate(const HardwareInf
return 2800u;
}
template <>
bool HwInfoConfigHw<gfxProduct>::isFlushTaskAllowed() const {
return false;
}
template class HwInfoConfigHw<gfxProduct>;
} // namespace NEO