Skip to content

Commit a7455b5

Browse files
zzdanowiczCompute-Runtime-Automation
zzdanowicz
authored and
Compute-Runtime-Automation
committed
Add tweaks and control flags to linux completion fence
Related-To: NEO-6575 Signed-off-by: Zbigniew Zdanowicz <[email protected]>
1 parent fdef257 commit a7455b5

26 files changed

+407
-34
lines changed

‎opencl/test/unit_test/os_interface/linux/CMakeLists.txt

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
#
2-
# Copyright (C) 2018-2021 Intel Corporation
2+
# Copyright (C) 2018-2022 Intel Corporation
33
#
44
# SPDX-License-Identifier: MIT
55
#
@@ -65,6 +65,12 @@ if("${BRANCH_TYPE}" STREQUAL "")
6565
)
6666
endif()
6767

68+
if(TESTS_XEHP_AND_LATER)
69+
list(APPEND IGDRCL_SRCS_tests_os_interface_linux
70+
${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream_xehp_and_later_tests.cpp
71+
)
72+
endif()
73+
6874
if(UNIX)
6975
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_os_interface_linux})
7076
endif()

‎opencl/test/unit_test/os_interface/linux/drm_command_stream_mm_tests.cpp

Lines changed: 74 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -95,8 +95,10 @@ HWTEST_F(DrmCommandStreamMMTest, givenExecutionEnvironmentWithMoreThanOneRootDev
9595
}
9696
}
9797

98-
HWTEST_TEMPLATED_F(DrmCommandStreamMemExecTest, GivenDrmSupportsCompletionFenceWhenCallingCsrExecThenTagAllocationIsPassed) {
98+
HWTEST_TEMPLATED_F(DrmCommandStreamMemExecTest, GivenDrmSupportsVmBindAndCompletionFenceWhenCallingCsrExecThenTagAllocationIsPassed) {
9999
mock->completionFenceSupported = true;
100+
mock->isVmBindAvailableCall.callParent = false;
101+
mock->isVmBindAvailableCall.returnValue = true;
100102

101103
TestedBufferObject bo(mock, 128);
102104
MockDrmAllocation cmdBuffer(GraphicsAllocation::AllocationType::COMMAND_BUFFER, MemoryPool::System4KBPages);
@@ -118,11 +120,81 @@ HWTEST_TEMPLATED_F(DrmCommandStreamMemExecTest, GivenDrmSupportsCompletionFenceW
118120
auto *testCsr = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr);
119121
testCsr->latestSentTaskCount = 2;
120122

121-
int ret = testCsr->exec(batchBuffer, 1, 2);
123+
int ret = testCsr->exec(batchBuffer, 1, 2, 0);
122124
EXPECT_EQ(0, ret);
123125

124126
EXPECT_EQ(expectedCompletionGpuAddress, bo.receivedCompletionGpuAddress);
125127
EXPECT_EQ(testCsr->latestSentTaskCount, bo.receivedCompletionValue);
126128

127129
mm->freeGraphicsMemory(allocation);
128130
}
131+
132+
HWTEST_TEMPLATED_F(DrmCommandStreamMemExecTest, GivenDrmSupportsVmBindAndNotCompletionFenceWhenCallingCsrExecThenTagAllocationIsNotPassed) {
133+
mock->completionFenceSupported = false;
134+
mock->isVmBindAvailableCall.callParent = false;
135+
mock->isVmBindAvailableCall.returnValue = true;
136+
137+
TestedBufferObject bo(mock, 128);
138+
MockDrmAllocation cmdBuffer(GraphicsAllocation::AllocationType::COMMAND_BUFFER, MemoryPool::System4KBPages);
139+
cmdBuffer.bufferObjects[0] = &bo;
140+
uint8_t buff[128];
141+
142+
LinearStream cs(&cmdBuffer, buff, 128);
143+
CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
144+
EncodeNoop<FamilyType>::alignToCacheLine(cs);
145+
146+
BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr, false};
147+
148+
auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
149+
csr->makeResident(cmdBuffer);
150+
csr->makeResident(*allocation);
151+
csr->makeResident(*csr->getTagAllocation());
152+
153+
constexpr uint64_t expectedCompletionGpuAddress = 0;
154+
constexpr uint32_t expectedCompletionValue = 0;
155+
auto *testCsr = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr);
156+
testCsr->latestSentTaskCount = 2;
157+
158+
int ret = testCsr->exec(batchBuffer, 1, 2, 0);
159+
EXPECT_EQ(0, ret);
160+
161+
EXPECT_EQ(expectedCompletionGpuAddress, bo.receivedCompletionGpuAddress);
162+
EXPECT_EQ(expectedCompletionValue, bo.receivedCompletionValue);
163+
164+
mm->freeGraphicsMemory(allocation);
165+
}
166+
167+
HWTEST_TEMPLATED_F(DrmCommandStreamMemExecTest, GivenDrmSupportsCompletionFenceAndNotVmBindWhenCallingCsrExecThenTagAllocationIsNotPassed) {
168+
mock->completionFenceSupported = true;
169+
mock->isVmBindAvailableCall.callParent = false;
170+
mock->isVmBindAvailableCall.returnValue = false;
171+
172+
TestedBufferObject bo(mock, 128);
173+
MockDrmAllocation cmdBuffer(GraphicsAllocation::AllocationType::COMMAND_BUFFER, MemoryPool::System4KBPages);
174+
cmdBuffer.bufferObjects[0] = &bo;
175+
uint8_t buff[128];
176+
177+
LinearStream cs(&cmdBuffer, buff, 128);
178+
CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
179+
EncodeNoop<FamilyType>::alignToCacheLine(cs);
180+
181+
BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr, false};
182+
183+
auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
184+
csr->makeResident(cmdBuffer);
185+
csr->makeResident(*allocation);
186+
csr->makeResident(*csr->getTagAllocation());
187+
188+
constexpr uint64_t expectedCompletionGpuAddress = 0;
189+
constexpr uint32_t expectedCompletionValue = 0;
190+
auto *testCsr = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr);
191+
testCsr->latestSentTaskCount = 2;
192+
193+
int ret = testCsr->exec(batchBuffer, 1, 2, 0);
194+
EXPECT_EQ(0, ret);
195+
196+
EXPECT_EQ(expectedCompletionGpuAddress, bo.receivedCompletionGpuAddress);
197+
EXPECT_EQ(expectedCompletionValue, bo.receivedCompletionValue);
198+
199+
mm->freeGraphicsMemory(allocation);
200+
}

‎opencl/test/unit_test/os_interface/linux/drm_command_stream_xehp_and_later_tests.cpp

Lines changed: 182 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,182 @@
1+
/*
2+
* Copyright (C) 2022 Intel Corporation
3+
*
4+
* SPDX-License-Identifier: MIT
5+
*
6+
*/
7+
8+
#include "shared/source/execution_environment/root_device_environment.h"
9+
#include "shared/source/os_interface/linux/drm_command_stream.h"
10+
#include "shared/source/os_interface/linux/drm_memory_manager.h"
11+
#include "shared/source/os_interface/linux/drm_memory_operations_handler.h"
12+
#include "shared/source/os_interface/linux/os_context_linux.h"
13+
#include "shared/source/os_interface/os_interface.h"
14+
#include "shared/test/common/helpers/debug_manager_state_restore.h"
15+
#include "shared/test/common/helpers/engine_descriptor_helper.h"
16+
#include "shared/test/common/helpers/variable_backup.h"
17+
#include "shared/test/common/libult/linux/drm_mock.h"
18+
#include "shared/test/common/mocks/linux/mock_drm_allocation.h"
19+
#include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
20+
#include "shared/test/common/mocks/mock_allocation_properties.h"
21+
#include "shared/test/common/mocks/mock_execution_environment.h"
22+
#include "shared/test/common/os_interface/linux/device_command_stream_fixture.h"
23+
#include "shared/test/common/os_interface/linux/drm_buffer_object_fixture.h"
24+
#include "shared/test/common/test_macros/test.h"
25+
26+
#include "opencl/test/unit_test/os_interface/linux/drm_command_stream_fixture.h"
27+
28+
using namespace NEO;
29+
30+
struct DrmCommandStreamMultiTileMemExecFixture {
31+
void SetUp() {
32+
DebugManager.flags.CreateMultipleSubDevices.set(2u);
33+
DebugManager.flags.EnableImplicitScaling.set(1);
34+
DebugManager.flags.EnableForcePin.set(false);
35+
osLocalMemoryBackup = std::make_unique<VariableBackup<bool>>(&OSInterface::osEnableLocalMemory, true);
36+
37+
executionEnvironment = new MockExecutionEnvironment();
38+
executionEnvironment->incRefInternal();
39+
executionEnvironment->initGmm();
40+
41+
mock = new DrmMockCustom(*executionEnvironment->rootDeviceEnvironments[0]);
42+
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
43+
executionEnvironment->rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
44+
executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock, 0);
45+
46+
memoryManager = new DrmMemoryManager(gemCloseWorkerMode::gemCloseWorkerInactive,
47+
DebugManager.flags.EnableForcePin.get(),
48+
true,
49+
*executionEnvironment);
50+
executionEnvironment->memoryManager.reset(memoryManager);
51+
executionEnvironment->prepareRootDeviceEnvironments(1u);
52+
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(NEO::defaultHwInfo.get());
53+
executionEnvironment->initializeMemoryManager();
54+
device.reset(MockDevice::create<MockDevice>(executionEnvironment, 0));
55+
56+
osContext = std::make_unique<OsContextLinux>(*mock, 0u, EngineDescriptorHelper::getDefaultDescriptor(device->getDeviceBitfield()));
57+
osContext->ensureContextInitialized();
58+
}
59+
60+
void TearDown() {
61+
executionEnvironment->decRefInternal();
62+
}
63+
64+
DebugManagerStateRestore dbgRestore;
65+
std::unique_ptr<VariableBackup<bool>> osLocalMemoryBackup;
66+
std::unique_ptr<MockDevice> device;
67+
std::unique_ptr<OsContext> osContext;
68+
MockExecutionEnvironment *executionEnvironment = nullptr;
69+
DrmMockCustom *mock = nullptr;
70+
DrmMemoryManager *memoryManager = nullptr;
71+
};
72+
73+
using DrmCommandStreamMultiTileMemExecTest = Test<DrmCommandStreamMultiTileMemExecFixture>;
74+
75+
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmCommandStreamMultiTileMemExecTest, GivenDrmSupportsCompletionFenceAndVmBindWhenCallingCsrExecThenMultipleTagAllocationIsPassed) {
76+
auto *testCsr = new TestedDrmCommandStreamReceiver<FamilyType>(*executionEnvironment, 0, device->getDeviceBitfield());
77+
device->resetCommandStreamReceiver(testCsr);
78+
EXPECT_EQ(2u, testCsr->activePartitions);
79+
testCsr->setupContext(*osContext.get());
80+
81+
mock->completionFenceSupported = true;
82+
mock->isVmBindAvailableCall.callParent = false;
83+
mock->isVmBindAvailableCall.returnValue = true;
84+
85+
TestedBufferObject bo(mock, 128);
86+
MockDrmAllocation cmdBuffer(GraphicsAllocation::AllocationType::COMMAND_BUFFER, MemoryPool::System4KBPages);
87+
cmdBuffer.bufferObjects[0] = &bo;
88+
uint8_t buff[128];
89+
90+
LinearStream cs(&cmdBuffer, buff, 128);
91+
CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
92+
EncodeNoop<FamilyType>::alignToCacheLine(cs);
93+
94+
BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr, false};
95+
96+
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{testCsr->getRootDeviceIndex(), MemoryConstants::pageSize});
97+
testCsr->makeResident(cmdBuffer);
98+
testCsr->makeResident(*allocation);
99+
testCsr->makeResident(*testCsr->getTagAllocation());
100+
101+
testCsr->latestSentTaskCount = 2;
102+
testCsr->postSyncWriteOffset = 16;
103+
104+
uint64_t expectedCompletionGpuAddress = testCsr->getTagAllocation()->getGpuAddress() + Drm::completionFenceOffset + testCsr->postSyncWriteOffset;
105+
106+
int ret = testCsr->flushInternal(batchBuffer, testCsr->getResidencyAllocations());
107+
EXPECT_EQ(0, ret);
108+
109+
EXPECT_EQ(expectedCompletionGpuAddress, bo.receivedCompletionGpuAddress);
110+
EXPECT_EQ(testCsr->latestSentTaskCount, bo.receivedCompletionValue);
111+
EXPECT_EQ(2u, bo.execCalled);
112+
113+
memoryManager->freeGraphicsMemory(allocation);
114+
}
115+
116+
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmCommandStreamMultiTileMemExecTest, GivenDrmSupportsCompletionFenceAndVmBindWhenHandlingCompletionThenExpectMultipleWaitCalls) {
117+
EngineControl &defaultEngine = device->getDefaultEngine();
118+
EXPECT_EQ(2u, defaultEngine.commandStreamReceiver->getActivePartitions());
119+
120+
uint32_t postSyncOffset = defaultEngine.commandStreamReceiver->getPostSyncWriteOffset();
121+
EXPECT_NE(0u, postSyncOffset);
122+
123+
mock->completionFenceSupported = true;
124+
mock->isVmBindAvailableCall.callParent = false;
125+
mock->isVmBindAvailableCall.returnValue = true;
126+
127+
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{0, 1024, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
128+
allocation->updateTaskCount(2, defaultEngine.osContext->getContextId());
129+
130+
volatile uint32_t *completionAddress = defaultEngine.commandStreamReceiver->getTagAddress();
131+
completionAddress += (Drm::completionFenceOffset / sizeof(uint32_t));
132+
*completionAddress = 1;
133+
completionAddress += (postSyncOffset / sizeof(uint32_t));
134+
*completionAddress = 1;
135+
136+
memoryManager->handleFenceCompletion(allocation);
137+
138+
uint64_t expectedAddress = castToUint64(const_cast<uint32_t *>(defaultEngine.commandStreamReceiver->getTagAddress())) +
139+
Drm::completionFenceOffset +
140+
postSyncOffset;
141+
constexpr uint64_t expectedValue = 2;
142+
143+
EXPECT_EQ(2u, mock->waitUserFenceCall.called);
144+
EXPECT_EQ(expectedAddress, mock->waitUserFenceCall.address);
145+
EXPECT_EQ(expectedValue, mock->waitUserFenceCall.value);
146+
147+
memoryManager->freeGraphicsMemory(allocation);
148+
}
149+
150+
HWCMDTEST_F(IGFX_XE_HP_CORE, DrmCommandStreamMultiTileMemExecTest, GivenDrmSupportsCompletionFenceAndVmBindWhenHandlingCompletionAndOneContextIsReadyThenExpectOneWaitCall) {
151+
EngineControl &defaultEngine = device->getDefaultEngine();
152+
EXPECT_EQ(2u, defaultEngine.commandStreamReceiver->getActivePartitions());
153+
154+
uint32_t postSyncOffset = defaultEngine.commandStreamReceiver->getPostSyncWriteOffset();
155+
EXPECT_NE(0u, postSyncOffset);
156+
157+
mock->completionFenceSupported = true;
158+
mock->isVmBindAvailableCall.callParent = false;
159+
mock->isVmBindAvailableCall.returnValue = true;
160+
161+
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{0, 1024, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
162+
allocation->updateTaskCount(2, defaultEngine.osContext->getContextId());
163+
164+
volatile uint32_t *completionAddress = defaultEngine.commandStreamReceiver->getTagAddress();
165+
completionAddress += (Drm::completionFenceOffset / sizeof(uint32_t));
166+
*completionAddress = 2; //1st context is ready
167+
completionAddress += (postSyncOffset / sizeof(uint32_t));
168+
*completionAddress = 1;
169+
170+
memoryManager->handleFenceCompletion(allocation);
171+
172+
uint64_t expectedAddress = castToUint64(const_cast<uint32_t *>(defaultEngine.commandStreamReceiver->getTagAddress())) +
173+
Drm::completionFenceOffset +
174+
postSyncOffset;
175+
constexpr uint64_t expectedValue = 2;
176+
177+
EXPECT_EQ(1u, mock->waitUserFenceCall.called);
178+
EXPECT_EQ(expectedAddress, mock->waitUserFenceCall.address);
179+
EXPECT_EQ(expectedValue, mock->waitUserFenceCall.value);
180+
181+
memoryManager->freeGraphicsMemory(allocation);
182+
}

‎opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp

Lines changed: 40 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5809,14 +5809,29 @@ TEST_F(DrmMemoryManagerTest, GivenEligbleAllocationTypeWhenCheckingAllocationEli
58095809
}
58105810

58115811
TEST_F(DrmMemoryManagerTest, GivenNotEligbleAllocationTypeWhenCheckingAllocationEligbleForCompletionFenceThenReturnFalse) {
5812-
GraphicsAllocation::AllocationType validAllocations[] = {
5812+
GraphicsAllocation::AllocationType invalidAllocations[] = {
58135813
GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY,
58145814
GraphicsAllocation::AllocationType::CONSTANT_SURFACE,
58155815
GraphicsAllocation::AllocationType::FILL_PATTERN,
58165816
GraphicsAllocation::AllocationType::GLOBAL_SURFACE};
58175817

58185818
for (size_t i = 0; i < 4; i++) {
5819-
EXPECT_FALSE(memoryManager->allocationTypeForCompletionFence(validAllocations[i]));
5819+
EXPECT_FALSE(memoryManager->allocationTypeForCompletionFence(invalidAllocations[i]));
5820+
}
5821+
}
5822+
5823+
TEST_F(DrmMemoryManagerTest, GivenNotEligbleAllocationTypeAndDebugFlagOverridingWhenCheckingAllocationEligbleForCompletionFenceThenReturnTrue) {
5824+
DebugManagerStateRestore dbgState;
5825+
DebugManager.flags.UseDrmCompletionFenceForAllAllocations.set(1);
5826+
5827+
GraphicsAllocation::AllocationType invalidAllocations[] = {
5828+
GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY,
5829+
GraphicsAllocation::AllocationType::CONSTANT_SURFACE,
5830+
GraphicsAllocation::AllocationType::FILL_PATTERN,
5831+
GraphicsAllocation::AllocationType::GLOBAL_SURFACE};
5832+
5833+
for (size_t i = 0; i < 4; i++) {
5834+
EXPECT_TRUE(memoryManager->allocationTypeForCompletionFence(invalidAllocations[i]));
58205835
}
58215836
}
58225837

@@ -5877,4 +5892,27 @@ TEST_F(DrmMemoryManagerTest, givenCompletionFenceEnabledWhenHandlingCompletionOf
58775892
memoryManager->freeGraphicsMemory(allocation);
58785893
}
58795894

5895+
HWTEST_F(DrmMemoryManagerTest, givenCompletionFenceEnabledWhenHandlingCompletionAndTagAddressIsNullThenDoNotCallWaitUserFence) {
5896+
mock->ioctl_expected.total = -1;
5897+
5898+
VariableBackup<bool> backupFenceSupported{&mock->completionFenceSupported, true};
5899+
VariableBackup<bool> backupVmBindCallParent{&mock->isVmBindAvailableCall.callParent, false};
5900+
VariableBackup<bool> backupVmBindReturnValue{&mock->isVmBindAvailableCall.returnValue, true};
5901+
5902+
auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{rootDeviceIndex, 1024, GraphicsAllocation::AllocationType::COMMAND_BUFFER});
5903+
auto engine = memoryManager->getRegisteredEngines()[0];
5904+
allocation->updateTaskCount(2, engine.osContext->getContextId());
5905+
5906+
auto testCsr = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(engine.commandStreamReceiver);
5907+
auto backupTagAddress = testCsr->tagAddress;
5908+
testCsr->tagAddress = nullptr;
5909+
5910+
memoryManager->handleFenceCompletion(allocation);
5911+
EXPECT_EQ(0u, mock->waitUserFenceCall.called);
5912+
5913+
testCsr->tagAddress = backupTagAddress;
5914+
5915+
memoryManager->freeGraphicsMemory(allocation);
5916+
}
5917+
58805918
} // namespace NEO

‎opencl/test/unit_test/os_interface/linux/drm_tests.cpp

Lines changed: 12 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -944,14 +944,23 @@ TEST(DrmTest, GivenCompletionFenceDebugFlagWhenCreatingDrmObjectThenExpectCorrec
944944

945945
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
946946
executionEnvironment->prepareRootDeviceEnvironments(1);
947+
HardwareInfo *hwInfo = defaultHwInfo.get();
948+
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(hwInfo);
949+
950+
auto &hwHelper = HwHelper::get(hwInfo->platform.eRenderCoreFamily);
951+
947952
DrmMock drmDefault{*executionEnvironment->rootDeviceEnvironments[0]};
948-
EXPECT_FALSE(drmDefault.completionFenceSupported);
953+
if (hwHelper.isLinuxCompletionFenceSupported()) {
954+
EXPECT_TRUE(drmDefault.completionFenceSupport());
955+
} else {
956+
EXPECT_FALSE(drmDefault.completionFenceSupport());
957+
}
949958

950959
DebugManager.flags.EnableDrmCompletionFence.set(1);
951960
DrmMock drmEnabled{*executionEnvironment->rootDeviceEnvironments[0]};
952-
EXPECT_TRUE(drmEnabled.completionFenceSupported);
961+
EXPECT_TRUE(drmEnabled.completionFenceSupport());
953962

954963
DebugManager.flags.EnableDrmCompletionFence.set(0);
955964
DrmMock drmDisabled{*executionEnvironment->rootDeviceEnvironments[0]};
956-
EXPECT_FALSE(drmDisabled.completionFenceSupported);
965+
EXPECT_FALSE(drmDisabled.completionFenceSupport());
957966
}

‎opencl/test/unit_test/test_files/igdrcl.config

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -365,6 +365,7 @@ UpdateCrossThreadDataSize = 0
365365
ForceBcsEngineIndex = -1
366366
ResolveDependenciesViaPipeControls = -1
367367
EnableDrmCompletionFence = -1
368+
UseDrmCompletionFenceForAllAllocations = -1
368369
ExperimentalEnableSourceLevelDebugger = 0
369370
Force2dImageAsArray = -1
370371
ForceExtendedBufferSize = -1

0 commit comments

Comments
 (0)