Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor passing GlobalFenceAllocation to DirectSubmission 

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski 2022-04-07 13:03:01 +00:00 committed by Compute-Runtime-Automation
parent 6f0f15a0b8
commit fc4eaa1894
19 changed files with 154 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/test/unit_test/command_stream/command_stream_receiver_hw_2_tests.cpp
View File

@ -1374,7 +1374,7 @@ HWTEST_F(BcsTests, givenBlitterDirectSubmissionEnabledWhenProgrammingBlitterThen
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>(); auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
using DirectSubmission = MockDirectSubmissionHw<FamilyType, BlitterDispatcher<FamilyType>>; using DirectSubmission = MockDirectSubmissionHw<FamilyType, BlitterDispatcher<FamilyType>>;
csr.blitterDirectSubmission = std::make_unique<DirectSubmission>(*pDevice, *csr.osContext); csr.blitterDirectSubmission = std::make_unique<DirectSubmission>(*pDevice, *csr.osContext, csr.getGlobalFenceAllocation());
csr.recordFlusheBatchBuffer = true; csr.recordFlusheBatchBuffer = true;
DirectSubmission *directSubmission = reinterpret_cast<DirectSubmission *>(csr.blitterDirectSubmission.get()); DirectSubmission *directSubmission = reinterpret_cast<DirectSubmission *>(csr.blitterDirectSubmission.get());
bool initRet = directSubmission->initialize(true, false); bool initRet = directSubmission->initialize(true, false);
@ -1417,7 +1417,7 @@ HWTEST_F(BcsTests, givenBlitterDirectSubmissionEnabledWhenFlushTagUpdateThenBatc
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>(); auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
using DirectSubmission = MockDirectSubmissionHw<FamilyType, BlitterDispatcher<FamilyType>>; using DirectSubmission = MockDirectSubmissionHw<FamilyType, BlitterDispatcher<FamilyType>>;
csr.blitterDirectSubmission = std::make_unique<DirectSubmission>(*pDevice, *csr.osContext); csr.blitterDirectSubmission = std::make_unique<DirectSubmission>(*pDevice, *csr.osContext, csr.getGlobalFenceAllocation());
csr.recordFlusheBatchBuffer = true; csr.recordFlusheBatchBuffer = true;
DirectSubmission *directSubmission = reinterpret_cast<DirectSubmission *>(csr.blitterDirectSubmission.get()); DirectSubmission *directSubmission = reinterpret_cast<DirectSubmission *>(csr.blitterDirectSubmission.get());
bool initRet = directSubmission->initialize(true, false); bool initRet = directSubmission->initialize(true, false);

29
opencl/test/unit_test/os_interface/linux/drm_command_stream_tests_1.cpp
View File

@ -654,8 +654,8 @@ struct DrmDirectSubmissionFunctionsCalled {
template <typename GfxFamily> template <typename GfxFamily>
struct MockDrmDirectSubmissionToTestDtor : public DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> { struct MockDrmDirectSubmissionToTestDtor : public DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> {
MockDrmDirectSubmissionToTestDtor<GfxFamily>(Device &device, OsContext &osContext, DrmDirectSubmissionFunctionsCalled &functionsCalled) MockDrmDirectSubmissionToTestDtor<GfxFamily>(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation, DrmDirectSubmissionFunctionsCalled &functionsCalled)
: DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext), functionsCalled(functionsCalled) { : DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext, globalFenceAllocation), functionsCalled(functionsCalled) {
} }
~MockDrmDirectSubmissionToTestDtor() override { ~MockDrmDirectSubmissionToTestDtor() override {
if (ringStart) { if (ringStart) {
@ -680,7 +680,8 @@ struct MockDrmDirectSubmissionToTestDtor : public DrmDirectSubmission<GfxFamily,
HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenEnabledDirectSubmissionWhenDtorIsCalledButRingIsNotStartedThenDontCallStopRingBufferNorWaitForTagValue) { HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenEnabledDirectSubmissionWhenDtorIsCalledButRingIsNotStartedThenDontCallStopRingBufferNorWaitForTagValue) {
DrmDirectSubmissionFunctionsCalled functionsCalled{}; DrmDirectSubmissionFunctionsCalled functionsCalled{};
auto directSubmission = std::make_unique<MockDrmDirectSubmissionToTestDtor<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext, functionsCalled); auto directSubmission = std::make_unique<MockDrmDirectSubmissionToTestDtor<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext,
device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation(), functionsCalled);
ASSERT_NE(nullptr, directSubmission); ASSERT_NE(nullptr, directSubmission);
EXPECT_FALSE(directSubmission->ringStart); EXPECT_FALSE(directSubmission->ringStart);
@ -694,14 +695,15 @@ HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenEnabledDirectSubmi
template <typename GfxFamily> template <typename GfxFamily>
struct MockDrmDirectSubmissionToTestRingStop : public DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> { struct MockDrmDirectSubmissionToTestRingStop : public DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> {
MockDrmDirectSubmissionToTestRingStop<GfxFamily>(Device &device, OsContext &osContext) MockDrmDirectSubmissionToTestRingStop<GfxFamily>(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
: DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext) { : DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext, globalFenceAllocation) {
} }
using DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>::ringStart; using DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>::ringStart;
}; };
HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenEnabledDirectSubmissionWhenStopRingBufferIsCalledThenClearRingStart) { HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenEnabledDirectSubmissionWhenStopRingBufferIsCalledThenClearRingStart) {
auto directSubmission = std::make_unique<MockDrmDirectSubmissionToTestRingStop<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext); auto directSubmission = std::make_unique<MockDrmDirectSubmissionToTestRingStop<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext,
device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
ASSERT_NE(nullptr, directSubmission); ASSERT_NE(nullptr, directSubmission);
directSubmission->stopRingBuffer(); directSubmission->stopRingBuffer();
@ -710,8 +712,8 @@ HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenEnabledDirectSubmi
template <typename GfxFamily> template <typename GfxFamily>
struct MockDrmDirectSubmissionDispatchCommandBuffer : public DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> { struct MockDrmDirectSubmissionDispatchCommandBuffer : public DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> {
MockDrmDirectSubmissionDispatchCommandBuffer<GfxFamily>(Device &device, OsContext &osContext) MockDrmDirectSubmissionDispatchCommandBuffer<GfxFamily>(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
: DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext) { : DrmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext, globalFenceAllocation) {
} }
ADDMETHOD_NOBASE(dispatchCommandBuffer, bool, false, ADDMETHOD_NOBASE(dispatchCommandBuffer, bool, false,
@ -720,8 +722,8 @@ struct MockDrmDirectSubmissionDispatchCommandBuffer : public DrmDirectSubmission
template <typename GfxFamily> template <typename GfxFamily>
struct MockDrmBlitterDirectSubmissionDispatchCommandBuffer : public DrmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>> { struct MockDrmBlitterDirectSubmissionDispatchCommandBuffer : public DrmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>> {
MockDrmBlitterDirectSubmissionDispatchCommandBuffer<GfxFamily>(Device &device, OsContext &osContext) MockDrmBlitterDirectSubmissionDispatchCommandBuffer<GfxFamily>(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
: DrmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>>(device, osContext) { : DrmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>>(device, osContext, globalFenceAllocation) {
} }
ADDMETHOD_NOBASE(dispatchCommandBuffer, bool, false, ADDMETHOD_NOBASE(dispatchCommandBuffer, bool, false,
@ -729,7 +731,8 @@ struct MockDrmBlitterDirectSubmissionDispatchCommandBuffer : public DrmDirectSub
}; };
HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenDirectSubmissionFailsThenFlushReturnsError) { HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenDirectSubmissionFailsThenFlushReturnsError) {
static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->directSubmission = std::make_unique<MockDrmDirectSubmissionDispatchCommandBuffer<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext); static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->directSubmission = std::make_unique<MockDrmDirectSubmissionDispatchCommandBuffer<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext,
device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
auto directSubmission = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->directSubmission.get(); auto directSubmission = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->directSubmission.get();
static_cast<MockDrmDirectSubmissionDispatchCommandBuffer<FamilyType> *>(directSubmission)->dispatchCommandBufferResult = false; static_cast<MockDrmDirectSubmissionDispatchCommandBuffer<FamilyType> *>(directSubmission)->dispatchCommandBufferResult = false;
@ -746,7 +749,9 @@ HWTEST_TEMPLATED_F(DrmCommandStreamDirectSubmissionTest, givenDirectSubmissionFa
} }
HWTEST_TEMPLATED_F(DrmCommandStreamBlitterDirectSubmissionTest, givenBlitterDirectSubmissionFailsThenFlushReturnsError) { HWTEST_TEMPLATED_F(DrmCommandStreamBlitterDirectSubmissionTest, givenBlitterDirectSubmissionFailsThenFlushReturnsError) {
static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->blitterDirectSubmission = std::make_unique<MockDrmBlitterDirectSubmissionDispatchCommandBuffer<FamilyType>>(*device.get(), *device->getDefaultEngine().osContext); static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->blitterDirectSubmission = std::make_unique<MockDrmBlitterDirectSubmissionDispatchCommandBuffer<FamilyType>>(*device.get(),
*device->getDefaultEngine().osContext,
device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
auto blitterDirectSubmission = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->blitterDirectSubmission.get(); auto blitterDirectSubmission = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->blitterDirectSubmission.get();
static_cast<MockDrmBlitterDirectSubmissionDispatchCommandBuffer<FamilyType> *>(blitterDirectSubmission)->dispatchCommandBufferResult = false; static_cast<MockDrmBlitterDirectSubmissionDispatchCommandBuffer<FamilyType> *>(blitterDirectSubmission)->dispatchCommandBufferResult = false;

10
opencl/test/unit_test/os_interface/windows/device_command_stream_tests.cpp
View File

@ -119,12 +119,12 @@ struct MockWddmCsr : public WddmCommandStreamReceiver<GfxFamily> {
if (DebugManager.flags.EnableDirectSubmission.get() == 1) { if (DebugManager.flags.EnableDirectSubmission.get() == 1) {
if (!initBlitterDirectSubmission) { if (!initBlitterDirectSubmission) {
directSubmission = std::make_unique< directSubmission = std::make_unique<
MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>>(device, osContext); MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>>(device, osContext, globalFenceAllocation);
ret = directSubmission->initialize(true, false); ret = directSubmission->initialize(true, false);
this->dispatchMode = DispatchMode::ImmediateDispatch; this->dispatchMode = DispatchMode::ImmediateDispatch;
} else { } else {
blitterDirectSubmission = std::make_unique< blitterDirectSubmission = std::make_unique<
MockWddmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>>>(device, osContext); MockWddmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>>>(device, osContext, globalFenceAllocation);
blitterDirectSubmission->initialize(true, false); blitterDirectSubmission->initialize(true, false);
} }
} }
@ -1056,8 +1056,8 @@ HWTEST_F(WddmCsrCompressionTests, givenDisabledCompressionWhenFlushingThenDontIn
template <typename GfxFamily> template <typename GfxFamily>
struct MockWddmDrmDirectSubmissionDispatchCommandBuffer : public MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> { struct MockWddmDrmDirectSubmissionDispatchCommandBuffer : public MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>> {
MockWddmDrmDirectSubmissionDispatchCommandBuffer<GfxFamily>(Device &device, OsContext &osContext) MockWddmDrmDirectSubmissionDispatchCommandBuffer<GfxFamily>(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
: MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext) { : MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>(device, osContext, globalFenceAllocation) {
} }
bool dispatchCommandBuffer(BatchBuffer &batchBuffer, FlushStampTracker &flushStamp) override { bool dispatchCommandBuffer(BatchBuffer &batchBuffer, FlushStampTracker &flushStamp) override {
@ -1092,7 +1092,7 @@ TEST_F(WddmCommandStreamMockGdiTest, givenDirectSubmissionFailsThenFlushReturnsE
nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(),
&cs, commandBuffer->getUnderlyingBuffer(), false}; &cs, commandBuffer->getUnderlyingBuffer(), false};
csr->directSubmission = std::make_unique<MockSubmission>(*device.get(), *osContext); csr->directSubmission = std::make_unique<MockSubmission>(*device.get(), *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
auto res = csr->flush(batchBuffer, csr->getResidencyAllocations()); auto res = csr->flush(batchBuffer, csr->getResidencyAllocations());
EXPECT_EQ(NEO::SubmissionStatus::FAILED, res); EXPECT_EQ(NEO::SubmissionStatus::FAILED, res);

4
shared/source/command_stream/command_stream_receiver_hw_base.inl
View File

@ -1317,11 +1317,11 @@ inline bool CommandStreamReceiverHw<GfxFamily>::initDirectSubmission(Device &dev
auto lock = this->obtainUniqueOwnership(); auto lock = this->obtainUniqueOwnership();
if (!this->isAnyDirectSubmissionEnabled()) { if (!this->isAnyDirectSubmissionEnabled()) {
if (EngineHelpers::isBcs(osContext.getEngineType())) { if (EngineHelpers::isBcs(osContext.getEngineType())) {
blitterDirectSubmission = DirectSubmissionHw<GfxFamily, BlitterDispatcher<GfxFamily>>::create(device, osContext); blitterDirectSubmission = DirectSubmissionHw<GfxFamily, BlitterDispatcher<GfxFamily>>::create(device, osContext, this->globalFenceAllocation);
ret = blitterDirectSubmission->initialize(submitOnInit, this->isUsedNotifyEnableForPostSync()); ret = blitterDirectSubmission->initialize(submitOnInit, this->isUsedNotifyEnableForPostSync());
} else { } else {
directSubmission = DirectSubmissionHw<GfxFamily, RenderDispatcher<GfxFamily>>::create(device, osContext); directSubmission = DirectSubmissionHw<GfxFamily, RenderDispatcher<GfxFamily>>::create(device, osContext, this->globalFenceAllocation);
ret = directSubmission->initialize(submitOnInit, this->isUsedNotifyEnableForPostSync()); ret = directSubmission->initialize(submitOnInit, this->isUsedNotifyEnableForPostSync());
} }
auto directSubmissionController = executionEnvironment.initializeDirectSubmissionController(); auto directSubmissionController = executionEnvironment.initializeDirectSubmissionController();

6
shared/source/direct_submission/create_direct_submission_drm/create_direct_submission_hw.inl
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -9,7 +9,7 @@
namespace NEO { namespace NEO {
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
inline std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> DirectSubmissionHw<GfxFamily, Dispatcher>::create(Device &device, OsContext &osContext) { inline std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> DirectSubmissionHw<GfxFamily, Dispatcher>::create(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation) {
return std::make_unique<DrmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext); return std::make_unique<DrmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext, globalFenceAllocation);
} }
} // namespace NEO } // namespace NEO

8
shared/source/direct_submission/create_direct_submission_drm_or_wddm/create_direct_submission_hw.inl
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -10,11 +10,11 @@
namespace NEO { namespace NEO {
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
inline std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> DirectSubmissionHw<GfxFamily, Dispatcher>::create(Device &device, OsContext &osContext) { inline std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> DirectSubmissionHw<GfxFamily, Dispatcher>::create(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation) {
if (device.getRootDeviceEnvironment().osInterface->getDriverModel()->getDriverModelType() == DriverModelType::DRM) { if (device.getRootDeviceEnvironment().osInterface->getDriverModel()->getDriverModelType() == DriverModelType::DRM) {
return std::make_unique<DrmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext); return std::make_unique<DrmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext, globalFenceAllocation);
} else { } else {
return std::make_unique<WddmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext); return std::make_unique<WddmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext, globalFenceAllocation);
} }
} }
} // namespace NEO } // namespace NEO

6
shared/source/direct_submission/create_direct_submission_wddm/create_direct_submission_hw.inl
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -9,7 +9,7 @@
namespace NEO { namespace NEO {
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
inline std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> DirectSubmissionHw<GfxFamily, Dispatcher>::create(Device &device, OsContext &osContext) { inline std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> DirectSubmissionHw<GfxFamily, Dispatcher>::create(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation) {
return std::make_unique<WddmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext); return std::make_unique<WddmDirectSubmission<GfxFamily, Dispatcher>>(device, osContext, globalFenceAllocation);
} }
} // namespace NEO } // namespace NEO

6
shared/source/direct_submission/direct_submission_hw.h
View File

@ -60,8 +60,7 @@ class OsContext;
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
class DirectSubmissionHw { class DirectSubmissionHw {
public: public:
DirectSubmissionHw(Device &device, DirectSubmissionHw(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation);
OsContext &osContext);
virtual ~DirectSubmissionHw(); virtual ~DirectSubmissionHw();
@ -73,7 +72,7 @@ class DirectSubmissionHw {
MOCKABLE_VIRTUAL bool dispatchCommandBuffer(BatchBuffer &batchBuffer, FlushStampTracker &flushStamp); MOCKABLE_VIRTUAL bool dispatchCommandBuffer(BatchBuffer &batchBuffer, FlushStampTracker &flushStamp);
static std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> create(Device &device, OsContext &osContext); static std::unique_ptr<DirectSubmissionHw<GfxFamily, Dispatcher>> create(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation);
protected: protected:
static constexpr size_t prefetchSize = 8 * MemoryConstants::cacheLineSize; static constexpr size_t prefetchSize = 8 * MemoryConstants::cacheLineSize;
@ -148,6 +147,7 @@ class DirectSubmissionHw {
Device &device; Device &device;
OsContext &osContext; OsContext &osContext;
const HardwareInfo *hwInfo = nullptr; const HardwareInfo *hwInfo = nullptr;
const GraphicsAllocation *globalFenceAllocation = nullptr;
GraphicsAllocation *ringBuffer = nullptr; GraphicsAllocation *ringBuffer = nullptr;
GraphicsAllocation *ringBuffer2 = nullptr; GraphicsAllocation *ringBuffer2 = nullptr;
GraphicsAllocation *semaphores = nullptr; GraphicsAllocation *semaphores = nullptr;

12
shared/source/direct_submission/direct_submission_hw.inl
View File

@ -30,9 +30,8 @@
namespace NEO { namespace NEO {
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
DirectSubmissionHw<GfxFamily, Dispatcher>::DirectSubmissionHw(Device &device, DirectSubmissionHw<GfxFamily, Dispatcher>::DirectSubmissionHw(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
OsContext &osContext) : device(device), osContext(osContext), globalFenceAllocation(globalFenceAllocation) {
: device(device), osContext(osContext) {
hwInfo = &device.getHardwareInfo(); hwInfo = &device.getHardwareInfo();
auto hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily); auto hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
@ -618,11 +617,8 @@ size_t DirectSubmissionHw<GfxFamily, Dispatcher>::getDiagnosticModeSection() {
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchSystemMemoryFenceAddress() { void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchSystemMemoryFenceAddress() {
auto &engineControl = device.getEngine(this->osContext.getEngineType(), this->osContext.getEngineUsage()); UNRECOVERABLE_IF(!this->globalFenceAllocation);
EncodeMemoryFence<GfxFamily>::encodeSystemMemoryFence(ringCommandStream, this->globalFenceAllocation);
UNRECOVERABLE_IF(engineControl.osContext->getContextId() != engineControl.osContext->getContextId());
EncodeMemoryFence<GfxFamily>::encodeSystemMemoryFence(ringCommandStream, engineControl.commandStreamReceiver->getGlobalFenceAllocation());
} }
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>

5
shared/source/direct_submission/linux/drm_direct_submission.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -16,8 +16,7 @@ class DrmDirectSubmission : public DirectSubmissionHw<GfxFamily, Dispatcher> {
using DirectSubmissionHw<GfxFamily, Dispatcher>::ringCommandStream; using DirectSubmissionHw<GfxFamily, Dispatcher>::ringCommandStream;
using DirectSubmissionHw<GfxFamily, Dispatcher>::switchRingBuffersAllocations; using DirectSubmissionHw<GfxFamily, Dispatcher>::switchRingBuffersAllocations;
DrmDirectSubmission(Device &device, DrmDirectSubmission(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation);
OsContext &osContext);
~DrmDirectSubmission(); ~DrmDirectSubmission();

5
shared/source/direct_submission/linux/drm_direct_submission.inl
View File

@ -20,9 +20,8 @@
namespace NEO { namespace NEO {
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
DrmDirectSubmission<GfxFamily, Dispatcher>::DrmDirectSubmission(Device &device, DrmDirectSubmission<GfxFamily, Dispatcher>::DrmDirectSubmission(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
OsContext &osContext) : DirectSubmissionHw<GfxFamily, Dispatcher>(device, osContext, globalFenceAllocation) {
: DirectSubmissionHw<GfxFamily, Dispatcher>(device, osContext) {
this->disableMonitorFence = true; this->disableMonitorFence = true;

5
shared/source/direct_submission/windows/wddm_direct_submission.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -19,8 +19,7 @@ class Wddm;
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
class WddmDirectSubmission : public DirectSubmissionHw<GfxFamily, Dispatcher> { class WddmDirectSubmission : public DirectSubmissionHw<GfxFamily, Dispatcher> {
public: public:
WddmDirectSubmission(Device &device, WddmDirectSubmission(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation);
OsContext &osContext);
~WddmDirectSubmission(); ~WddmDirectSubmission();

7
shared/source/direct_submission/windows/wddm_direct_submission.inl
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -23,9 +23,8 @@ namespace NEO {
DECLARE_COMMAND_BUFFER(CommandBufferHeader, UMD_OCL, FALSE, FALSE, PERFTAG_OCL); DECLARE_COMMAND_BUFFER(CommandBufferHeader, UMD_OCL, FALSE, FALSE, PERFTAG_OCL);
template <typename GfxFamily, typename Dispatcher> template <typename GfxFamily, typename Dispatcher>
WddmDirectSubmission<GfxFamily, Dispatcher>::WddmDirectSubmission(Device &device, WddmDirectSubmission<GfxFamily, Dispatcher>::WddmDirectSubmission(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation)
OsContext &osContext) : DirectSubmissionHw<GfxFamily, Dispatcher>(device, osContext, globalFenceAllocation) {
: DirectSubmissionHw<GfxFamily, Dispatcher>(device, osContext) {
osContextWin = reinterpret_cast<OsContextWin *>(&osContext); osContextWin = reinterpret_cast<OsContextWin *>(&osContext);
wddm = osContextWin->getWddm(); wddm = osContextWin->getWddm();
commandBufferHeader = std::make_unique<COMMAND_BUFFER_HEADER_REC>(); commandBufferHeader = std::make_unique<COMMAND_BUFFER_HEADER_REC>();

84
shared/test/unit_test/direct_submission/direct_submission_tests_1.cpp
View File

@ -31,7 +31,7 @@ HWTEST_F(DirectSubmissionTest, whenDebugCacheFlushDisabledSetThenExpectNoCpuCach
DebugManager.flags.DirectSubmissionDisableCpuCacheFlush.set(1); DebugManager.flags.DirectSubmissionDisableCpuCacheFlush.set(1);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.disableCpuCacheFlush); EXPECT_TRUE(directSubmission.disableCpuCacheFlush);
uintptr_t expectedPtrVal = 0; uintptr_t expectedPtrVal = 0;
@ -51,7 +51,7 @@ HWTEST_F(DirectSubmissionTest, whenDebugCacheFlushDisabledNotSetThenExpectCpuCac
DebugManager.flags.DirectSubmissionDisableCpuCacheFlush.set(0); DebugManager.flags.DirectSubmissionDisableCpuCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_FALSE(directSubmission.disableCpuCacheFlush); EXPECT_FALSE(directSubmission.disableCpuCacheFlush);
uintptr_t expectedPtrVal = 0xABCD00u; uintptr_t expectedPtrVal = 0xABCD00u;
@ -64,7 +64,7 @@ HWTEST_F(DirectSubmissionTest, whenDebugCacheFlushDisabledNotSetThenExpectCpuCac
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenStopThenRingIsNotStarted) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenStopThenRingIsNotStarted) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>(); auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
csr.directSubmission.reset(&directSubmission); csr.directSubmission.reset(&directSubmission);
@ -80,7 +80,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenStopThenRingIsNotStarted
HWTEST_F(DirectSubmissionTest, givenBlitterDirectSubmissionWhenStopThenRingIsNotStarted) { HWTEST_F(DirectSubmissionTest, givenBlitterDirectSubmissionWhenStopThenRingIsNotStarted) {
MockDirectSubmissionHw<FamilyType, BlitterDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, BlitterDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>(); auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
std::unique_ptr<OsContext> osContext(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), 0, std::unique_ptr<OsContext> osContext(OsContext::create(pDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), 0,
EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::Regular}, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::Regular},
@ -103,7 +103,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenMakingResourcesResidentT
pDevice->getRootDeviceEnvironmentRef().memoryOperationsInterface.reset(mockMemoryOperations.get()); pDevice->getRootDeviceEnvironmentRef().memoryOperationsInterface.reset(mockMemoryOperations.get());
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -124,7 +124,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenMakingResourcesResidentT
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionInitializedWhenRingIsStartedThenExpectAllocationsCreatedAndCommandsDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionInitializedWhenRingIsStartedThenExpectAllocationsCreatedAndCommandsDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.disableCpuCacheFlush); EXPECT_TRUE(directSubmission.disableCpuCacheFlush);
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
@ -140,7 +140,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionInitializedWhenRingIsStarted
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionInitializedWhenRingIsNotStartedThenExpectAllocationsCreatedAndCommandsNotDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionInitializedWhenRingIsNotStartedThenExpectAllocationsCreatedAndCommandsNotDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -156,7 +156,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionInitializedWhenRingIsNotStar
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSwitchBuffersWhenCurrentIsPrimaryThenExpectNextSecondary) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSwitchBuffersWhenCurrentIsPrimaryThenExpectNextSecondary) {
using RingBufferUse = typename MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>::RingBufferUse; using RingBufferUse = typename MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>::RingBufferUse;
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -170,7 +170,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSwitchBuffersWhenCurrentIsPr
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSwitchBuffersWhenCurrentIsSecondaryThenExpectNextPrimary) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSwitchBuffersWhenCurrentIsSecondaryThenExpectNextPrimary) {
using RingBufferUse = typename MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>::RingBufferUse; using RingBufferUse = typename MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>::RingBufferUse;
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -186,7 +186,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSwitchBuffersWhenCurrentIsSe
} }
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionAllocateFailWhenRingIsStartedThenExpectRingNotStarted) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionAllocateFailWhenRingIsStartedThenExpectRingNotStarted) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.disableCpuCacheFlush); EXPECT_TRUE(directSubmission.disableCpuCacheFlush);
directSubmission.allocateOsResourcesReturn = false; directSubmission.allocateOsResourcesReturn = false;
@ -199,7 +199,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionAllocateFailWhenRingIsStarte
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSubmitFailWhenRingIsStartedThenExpectRingNotStartedCommandsDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSubmitFailWhenRingIsStartedThenExpectRingNotStartedCommandsDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.submitReturn = false; directSubmission.submitReturn = false;
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
@ -211,7 +211,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionSubmitFailWhenRingIsStartedT
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsStartedThenExpectNoStartCommandsDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsStartedThenExpectNoStartCommandsDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -224,7 +224,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsStartedThenEx
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedThenExpectStartCommandsDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedThenExpectStartCommandsDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -238,7 +238,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedThe
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedSubmitFailThenExpectStartCommandsDispatchedRingNotStarted) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedSubmitFailThenExpectStartCommandsDispatchedRingNotStarted) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -253,7 +253,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedSub
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedAndSwitchBufferIsNeededThenExpectRingAllocationChangedStartCommandsDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedAndSwitchBufferIsNeededThenExpectRingAllocationChangedStartCommandsDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -280,7 +280,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStartWhenRingIsNotStartedAnd
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStopWhenStopRingIsCalledThenExpectStopCommandDispatched) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionStopWhenStopRingIsCalledThenExpectStopCommandDispatched) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -302,11 +302,11 @@ HWTEST_F(DirectSubmissionTest,
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t regularSizeEnd = regularDirectSubmission.getSizeEnd(); size_t regularSizeEnd = regularDirectSubmission.getSizeEnd();
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
directSubmission.disableMonitorFence = true; directSubmission.disableMonitorFence = true;
@ -348,7 +348,7 @@ HWTEST_F(DirectSubmissionTest,
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchSemaphoreThenExpectCorrectSizeUsed) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchSemaphoreThenExpectCorrectSizeUsed) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -359,7 +359,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchSemaphoreThenExp
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchStartSectionThenExpectCorrectSizeUsed) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchStartSectionThenExpectCorrectSizeUsed) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -369,7 +369,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchStartSectionThen
} }
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchSwitchRingBufferSectionThenExpectCorrectSizeUsed) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchSwitchRingBufferSectionThenExpectCorrectSizeUsed) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -381,7 +381,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchSwitchRingBuffer
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchFlushSectionThenExpectCorrectSizeUsed) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchFlushSectionThenExpectCorrectSizeUsed) {
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -393,7 +393,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchFlushSectionThen
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchTagUpdateSectionThenExpectCorrectSizeUsed) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchTagUpdateSectionThenExpectCorrectSizeUsed) {
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> MockDirectSubmissionHw<FamilyType, Dispatcher>
directSubmission(*pDevice, *osContext); directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -405,7 +405,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchTagUpdateSection
HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchEndingSectionThenExpectCorrectSizeUsed) { HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenDispatchEndingSectionThenExpectCorrectSizeUsed) {
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -420,7 +420,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenGetDispatchSizeThenExpec
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0); DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t expectedSize = directSubmission.getSizeStartSection() + size_t expectedSize = directSubmission.getSizeStartSection() +
Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) + Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) +
@ -436,7 +436,7 @@ HWTEST_F(DirectSubmissionTest,
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0); DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.workloadMode = 1; directSubmission.workloadMode = 1;
size_t expectedSize = Dispatcher::getSizeStoreDwordCommand() + size_t expectedSize = Dispatcher::getSizeStoreDwordCommand() +
@ -454,7 +454,7 @@ HWTEST_F(DirectSubmissionTest,
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.workloadMode = 2; directSubmission.workloadMode = 2;
size_t expectedSize = Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) + size_t expectedSize = Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) +
Dispatcher::getSizeMonitorFence(*directSubmission.hwInfo) + Dispatcher::getSizeMonitorFence(*directSubmission.hwInfo) +
@ -468,7 +468,7 @@ HWTEST_F(DirectSubmissionTest,
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableCacheFlush = true; directSubmission.disableCacheFlush = true;
size_t expectedSize = directSubmission.getSizeStartSection() + size_t expectedSize = directSubmission.getSizeStartSection() +
Dispatcher::getSizeMonitorFence(*directSubmission.hwInfo) + Dispatcher::getSizeMonitorFence(*directSubmission.hwInfo) +
@ -483,7 +483,7 @@ HWTEST_F(DirectSubmissionTest,
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0); DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableMonitorFence = true; directSubmission.disableMonitorFence = true;
size_t expectedSize = directSubmission.getSizeStartSection() + size_t expectedSize = directSubmission.getSizeStartSection() +
Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) + Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) +
@ -496,7 +496,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenGetEndSizeThenExpectCorr
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t expectedSize = Dispatcher::getSizeStopCommandBuffer() + size_t expectedSize = Dispatcher::getSizeStopCommandBuffer() +
Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) + Dispatcher::getSizeCacheFlush(*directSubmission.hwInfo) +
@ -510,7 +510,7 @@ HWTEST_F(DirectSubmissionTest, givenDirectSubmissionWhenSettingAddressInReturnCo
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START; using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -527,7 +527,7 @@ HWTEST_F(DirectSubmissionTest, whenDirectSubmissionInitializedThenExpectCreatedA
std::unique_ptr<MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>> directSubmission = std::unique_ptr<MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>> directSubmission =
std::make_unique<MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>>(*pDevice, std::make_unique<MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>>(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission->initialize(false, false); bool ret = directSubmission->initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -538,7 +538,7 @@ HWTEST_F(DirectSubmissionTest, whenDirectSubmissionInitializedThenExpectCreatedA
directSubmission = std::make_unique< directSubmission = std::make_unique<
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>>(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>>(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
ret = directSubmission->initialize(false, false); ret = directSubmission->initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -549,7 +549,7 @@ HWTEST_F(DirectSubmissionTest, whenDirectSubmissionInitializedThenExpectCreatedA
directSubmission = std::make_unique< directSubmission = std::make_unique<
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>>(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>>(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
ret = directSubmission->initialize(false, false); ret = directSubmission->initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
nulledAllocation = directSubmission->semaphores; nulledAllocation = directSubmission->semaphores;
@ -677,7 +677,7 @@ HWTEST_F(DirectSubmissionTest,
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_TRUE(directSubmission.disableCacheFlush);
@ -712,7 +712,7 @@ HWTEST_F(DirectSubmissionTest,
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_TRUE(directSubmission.disableCacheFlush);
@ -750,7 +750,7 @@ HWTEST_F(DirectSubmissionTest,
NEO::IoFunctions::mockVfptrinfCalled = 0u; NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence);
EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_TRUE(directSubmission.disableCacheFlush);
@ -790,7 +790,7 @@ HWTEST_F(DirectSubmissionTest,
NEO::IoFunctions::mockVfptrinfCalled = 0u; NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount; uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount;
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence);
@ -886,7 +886,7 @@ HWTEST_F(DirectSubmissionTest,
NEO::IoFunctions::mockVfptrinfCalled = 0u; NEO::IoFunctions::mockVfptrinfCalled = 0u;
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount; uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount;
EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush);
EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence);
@ -949,7 +949,7 @@ HWTEST_F(DirectSubmissionTest,
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_NE(nullptr, directSubmission.diagnostic.get()); EXPECT_NE(nullptr, directSubmission.diagnostic.get());
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled); EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);
@ -1000,7 +1000,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, DirectSubmissionTest,
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -1022,7 +1022,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DirectSubmissionTest, givenDebugFlagSetWhenDispatch
using MI_ARB_CHECK = typename FamilyType::MI_ARB_CHECK; using MI_ARB_CHECK = typename FamilyType::MI_ARB_CHECK;
using Dispatcher = BlitterDispatcher<FamilyType>; using Dispatcher = BlitterDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret); EXPECT_TRUE(ret);

50
shared/test/unit_test/direct_submission/direct_submission_tests_2.cpp
View File

@ -95,7 +95,7 @@ struct DirectSubmissionDispatchMiMemFenceTest : public DirectSubmissionDispatchB
}; };
HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenInitializingDirectSubmissionThenEnableMiMemFenceProgramming) { HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenInitializingDirectSubmissionThenEnableMiMemFenceProgramming) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(miMemFenceSupported, directSubmission.miMemFenceRequired); EXPECT_EQ(miMemFenceSupported, directSubmission.miMemFenceRequired);
EXPECT_FALSE(directSubmission.systemMemoryFenceAddressSet); EXPECT_FALSE(directSubmission.systemMemoryFenceAddressSet);
@ -108,7 +108,7 @@ HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenIni
} }
HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenDispatchingWithoutInitThenEnableMiMemFenceProgramming) { HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenDispatchingWithoutInitThenEnableMiMemFenceProgramming) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
EXPECT_EQ(miMemFenceSupported, directSubmission.miMemFenceRequired); EXPECT_EQ(miMemFenceSupported, directSubmission.miMemFenceRequired);
@ -126,7 +126,7 @@ HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenDis
} }
HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenSysMemFenceIsAlreadySentThenDontReprogram) { HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenMiMemFenceSupportedWhenSysMemFenceIsAlreadySentThenDontReprogram) {
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
EXPECT_EQ(miMemFenceSupported, directSubmission.miMemFenceRequired); EXPECT_EQ(miMemFenceSupported, directSubmission.miMemFenceRequired);
@ -145,7 +145,7 @@ HWTEST_F(DirectSubmissionDispatchMiMemFenceTest, givenDebugFlagSetWhenCreatingDi
DebugManagerStateRestore restorer; DebugManagerStateRestore restorer;
DebugManager.flags.DirectSubmissionInsertExtraMiMemFenceCommands.set(0); DebugManager.flags.DirectSubmissionInsertExtraMiMemFenceCommands.set(0);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_FALSE(directSubmission.miMemFenceRequired); EXPECT_FALSE(directSubmission.miMemFenceRequired);
EXPECT_FALSE(directSubmission.systemMemoryFenceAddressSet); EXPECT_FALSE(directSubmission.systemMemoryFenceAddressSet);
@ -172,7 +172,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DirectSubmissionDispatchBufferTest,
ultCsr->createWorkPartitionAllocation(*pDevice); ultCsr->createWorkPartitionAllocation(*pDevice);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.partitionConfigSet); EXPECT_TRUE(directSubmission.partitionConfigSet);
directSubmission.partitionConfigSet = false; directSubmission.partitionConfigSet = false;
directSubmission.disableMonitorFence = false; directSubmission.disableMonitorFence = false;
@ -245,11 +245,11 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0); DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch(); size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch();
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableMonitorFence = true; directSubmission.disableMonitorFence = true;
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
@ -296,11 +296,11 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0); DebugManager.flags.DirectSubmissionDisableCacheFlush.set(0);
MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch(); size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch();
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableCacheFlush = true; directSubmission.disableCacheFlush = true;
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
@ -345,12 +345,12 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> regularDirectSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch(); size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch();
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.workloadMode = 1; directSubmission.workloadMode = 1;
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
@ -392,11 +392,11 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM; using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> regularDirectSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> regularDirectSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch(); size_t regularSizeDispatch = regularDirectSubmission.getSizeDispatch();
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.workloadMode = 2; directSubmission.workloadMode = 2;
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
@ -432,7 +432,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -474,7 +474,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -511,7 +511,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, false); bool ret = directSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -550,7 +550,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(false, false); bool ret = directSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -588,7 +588,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest, givenDirectSubmissionPrintBuffersWh
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
testing::internal::CaptureStdout(); testing::internal::CaptureStdout();
@ -622,7 +622,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.partitionConfigSet); EXPECT_TRUE(directSubmission.partitionConfigSet);
directSubmission.activeTiles = 2; directSubmission.activeTiles = 2;
directSubmission.partitionedMode = true; directSubmission.partitionedMode = true;
@ -686,7 +686,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.partitionConfigSet); EXPECT_TRUE(directSubmission.partitionConfigSet);
directSubmission.activeTiles = 2; directSubmission.activeTiles = 2;
directSubmission.partitionedMode = true; directSubmission.partitionedMode = true;
@ -738,7 +738,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableMonitorFence = false; directSubmission.disableMonitorFence = false;
bool ret = directSubmission.initialize(true, true); bool ret = directSubmission.initialize(true, true);
@ -774,7 +774,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableMonitorFence = false; directSubmission.disableMonitorFence = false;
bool ret = directSubmission.initialize(true, true); bool ret = directSubmission.initialize(true, true);
@ -813,7 +813,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, true); bool ret = directSubmission.initialize(true, true);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -838,7 +838,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest,
FlushStampTracker flushStamp(true); FlushStampTracker flushStamp(true);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.initialize(true, true); bool ret = directSubmission.initialize(true, true);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -860,7 +860,7 @@ HWTEST_F(DirectSubmissionDispatchBufferTest, givenDebugFlagSetWhenDispatchingWor
for (int32_t debugFlag : {-1, 0, 1, 2}) { for (int32_t debugFlag : {-1, 0, 1, 2}) {
DebugManager.flags.DirectSubmissionInsertSfenceInstructionPriorToSubmission.set(debugFlag); DebugManager.flags.DirectSubmissionInsertSfenceInstructionPriorToSubmission.set(debugFlag);
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, *osContext); MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_TRUE(directSubmission.initialize(true, true)); EXPECT_TRUE(directSubmission.initialize(true, true));
auto initialCounterValue = CpuIntrinsicsTests::sfenceCounter.load(); auto initialCounterValue = CpuIntrinsicsTests::sfenceCounter.load();

4
shared/test/unit_test/direct_submission/direct_submission_tests_xe_hp_core.cpp
View File

@ -20,7 +20,7 @@ XE_HP_CORE_TEST_F(DirectSubmissionTestXE_HP_CORE, givenBlitterUsedWhenDispatchin
using Dispatcher = BlitterDispatcher<FamilyType>; using Dispatcher = BlitterDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(sizeof(MI_BATCH_BUFFER_START), directSubmission.getSizePrefetchMitigation()); EXPECT_EQ(sizeof(MI_BATCH_BUFFER_START), directSubmission.getSizePrefetchMitigation());
@ -45,7 +45,7 @@ XE_HP_CORE_TEST_F(DirectSubmissionTestXE_HP_CORE, givenBlitterUsedWhenDispatchin
using Dispatcher = BlitterDispatcher<FamilyType>; using Dispatcher = BlitterDispatcher<FamilyType>;
MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice, MockDirectSubmissionHw<FamilyType, Dispatcher> directSubmission(*pDevice,
*osContext); *osContext, pDevice->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(sizeof(MI_ARB_CHECK), directSubmission.getSizeDisablePrefetcher()); EXPECT_EQ(sizeof(MI_ARB_CHECK), directSubmission.getSizeDisablePrefetcher());

28
shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -78,7 +78,7 @@ struct MockDrmDirectSubmission : public DrmDirectSubmission<GfxFamily, Dispatche
using BaseClass::wait; using BaseClass::wait;
using BaseClass::workPartitionAllocation; using BaseClass::workPartitionAllocation;
MockDrmDirectSubmission(Device &device, OsContext &osContext) : DrmDirectSubmission<GfxFamily, Dispatcher>(device, osContext) { MockDrmDirectSubmission(Device &device, OsContext &osContext, const GraphicsAllocation *globalFenceAllocation) : DrmDirectSubmission<GfxFamily, Dispatcher>(device, osContext, globalFenceAllocation) {
this->disableMonitorFence = false; this->disableMonitorFence = false;
} }
}; };
@ -87,7 +87,7 @@ using namespace NEO;
HWTEST_F(DrmDirectSubmissionTest, givenDrmDirectSubmissionWhenCallingLinuxImplementationThenExpectInitialImplementationValues) { HWTEST_F(DrmDirectSubmissionTest, givenDrmDirectSubmissionWhenCallingLinuxImplementationThenExpectInitialImplementationValues) {
MockDrmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> drmDirectSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> drmDirectSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
auto drm = static_cast<DrmMock *>(executionEnvironment.rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Drm>()); auto drm = static_cast<DrmMock *>(executionEnvironment.rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Drm>());
EXPECT_TRUE(drm->isDirectSubmissionActive()); EXPECT_TRUE(drm->isDirectSubmissionActive());
@ -114,7 +114,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenDrmDirectSubmissionWhenCallingLinuxImplem
HWTEST_F(DrmDirectSubmissionTest, whenCreateDirectSubmissionThenValidObjectIsReturned) { HWTEST_F(DrmDirectSubmissionTest, whenCreateDirectSubmissionThenValidObjectIsReturned) {
auto directSubmission = DirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>::create(*device.get(), auto directSubmission = DirectSubmissionHw<FamilyType, RenderDispatcher<FamilyType>>::create(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_NE(directSubmission.get(), nullptr); EXPECT_NE(directSubmission.get(), nullptr);
bool ret = directSubmission->initialize(false, false); bool ret = directSubmission->initialize(false, false);
@ -126,7 +126,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenDisabledMonitorFenceWhenDispatchSwitchRin
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableMonitorFence = true; directSubmission.disableMonitorFence = true;
directSubmission.ringStart = true; directSubmission.ringStart = true;
@ -153,7 +153,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenDisabledMonitorFenceWhenUpdateTagValueThe
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
directSubmission.disableMonitorFence = true; directSubmission.disableMonitorFence = true;
directSubmission.ringStart = true; directSubmission.ringStart = true;
@ -185,7 +185,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionNewResourceTlbFlushWhenDi
DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(1); DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(1);
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -213,7 +213,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenNewResourceBoundhWhenDispatchCommandBuffe
DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(-1); DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(-1);
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -244,7 +244,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenNoNewResourceBoundhWhenDispatchCommandBuf
DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(-1); DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(-1);
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -274,7 +274,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionNewResourceTlbFlusZeroAnd
DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(0); DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(0);
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = directSubmission.allocateResources(); bool ret = directSubmission.allocateResources();
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -300,7 +300,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmDirectSubmissionTest, givenMultipleActiveTilesWh
using Dispatcher = RenderDispatcher<FamilyType>; using Dispatcher = RenderDispatcher<FamilyType>;
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
uint32_t offset = directSubmission.postSyncOffset; uint32_t offset = directSubmission.postSyncOffset;
EXPECT_NE(0u, offset); EXPECT_NE(0u, offset);
@ -338,7 +338,7 @@ HWTEST_F(DrmDirectSubmissionTest,
ultCsr->createWorkPartitionAllocation(*device); ultCsr->createWorkPartitionAllocation(*device);
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(2u, directSubmission.activeTiles); EXPECT_EQ(2u, directSubmission.activeTiles);
EXPECT_TRUE(directSubmission.partitionedMode); EXPECT_TRUE(directSubmission.partitionedMode);
@ -363,7 +363,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenRenderDispatcherAndMultiTileDeviceWhenCre
ultCsr->createWorkPartitionAllocation(*device); ultCsr->createWorkPartitionAllocation(*device);
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(1u, directSubmission.activeTiles); EXPECT_EQ(1u, directSubmission.activeTiles);
EXPECT_FALSE(directSubmission.partitionedMode); EXPECT_FALSE(directSubmission.partitionedMode);
@ -386,7 +386,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenBlitterDispatcherAndMultiTileDeviceWhenCr
EXPECT_EQ(2u, osContext->getDeviceBitfield().count()); EXPECT_EQ(2u, osContext->getDeviceBitfield().count());
MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(), MockDrmDirectSubmission<FamilyType, Dispatcher> directSubmission(*device.get(),
*osContext.get()); *osContext.get(), device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(1u, directSubmission.activeTiles); EXPECT_EQ(1u, directSubmission.activeTiles);
EXPECT_FALSE(directSubmission.partitionedMode); EXPECT_FALSE(directSubmission.partitionedMode);

34
shared/test/unit_test/direct_submission/windows/wddm_direct_submission_tests.cpp
View File

@ -52,7 +52,7 @@ using WddmDirectSubmissionTest = WddmDirectSubmissionFixture;
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenDirectIsInitializedAndStartedThenExpectProperCommandsDispatched) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenDirectIsInitializedAndStartedThenExpectProperCommandsDispatched) {
std::unique_ptr<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>> wddmDirectSubmission = std::unique_ptr<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>> wddmDirectSubmission =
std::make_unique<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>>(*device.get(), std::make_unique<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>>(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(1u, wddmDirectSubmission->commandBufferHeader->NeedsMidBatchPreEmptionSupport); EXPECT_EQ(1u, wddmDirectSubmission->commandBufferHeader->NeedsMidBatchPreEmptionSupport);
@ -84,7 +84,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenDirectIsInitializedAndNotStarted
device->setPreemptionMode(PreemptionMode::Disabled); device->setPreemptionMode(PreemptionMode::Disabled);
std::unique_ptr<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>> wddmDirectSubmission = std::unique_ptr<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>> wddmDirectSubmission =
std::make_unique<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>>(*device.get(), std::make_unique<MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>>(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(0u, wddmDirectSubmission->commandBufferHeader->NeedsMidBatchPreEmptionSupport); EXPECT_EQ(0u, wddmDirectSubmission->commandBufferHeader->NeedsMidBatchPreEmptionSupport);
@ -111,7 +111,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenDirectIsInitializedAndNotStarted
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSubmitingCmdBufferThenExpectPassWddmContextAndProperHeader) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSubmitingCmdBufferThenExpectPassWddmContextAndProperHeader) {
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = wddmDirectSubmission.initialize(false, false); bool ret = wddmDirectSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -130,7 +130,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSubmitingCmdBufferThenExpectPass
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesThenExpectRingMonitorFenceCreatedAndAllocationsResident) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesThenExpectRingMonitorFenceCreatedAndAllocationsResident) {
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = wddmDirectSubmission.allocateResources(); bool ret = wddmDirectSubmission.allocateResources();
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -149,7 +149,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesFenceCreation
ASSERT_NE(nullptr, ringBuffer); ASSERT_NE(nullptr, ringBuffer);
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
DirectSubmissionAllocations allocations; DirectSubmissionAllocations allocations;
allocations.push_back(ringBuffer); allocations.push_back(ringBuffer);
@ -168,7 +168,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesFenceCreation
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesResidencyFailsThenExpectRingMonitorFenceCreatedAndAllocationsNotResident) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenAllocateOsResourcesResidencyFailsThenExpectRingMonitorFenceCreatedAndAllocationsNotResident) {
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
wddm->callBaseMakeResident = false; wddm->callBaseMakeResident = false;
wddm->makeResidentStatus = false; wddm->makeResidentStatus = false;
@ -190,7 +190,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenGettingTagDataThenExpectContextM
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
TagData tagData; TagData tagData;
wddmDirectSubmission.getTagAddressValue(tagData); wddmDirectSubmission.getTagAddressValue(tagData);
@ -201,7 +201,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenGettingTagDataThenExpectContextM
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandleResidencyThenExpectWddmWaitOnPaginfFenceFromCpuCalled) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandleResidencyThenExpectWddmWaitOnPaginfFenceFromCpuCalled) {
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
wddmDirectSubmission.handleResidency(); wddmDirectSubmission.handleResidency();
@ -216,7 +216,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandlingRingBufferCompletionThen
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
uint64_t completionValue = 0x12345679ull; uint64_t completionValue = 0x12345679ull;
wddmDirectSubmission.handleCompletionRingBuffer(completionValue, contextFence); wddmDirectSubmission.handleCompletionRingBuffer(completionValue, contextFence);
@ -230,7 +230,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenHandlingRingBufferCompletionThen
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferStartedThenExpectDispatchSwitchCommandsLinearStreamUpdated) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferStartedThenExpectDispatchSwitchCommandsLinearStreamUpdated) {
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START; using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = wddmDirectSubmission.initialize(true, false); bool ret = wddmDirectSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -256,7 +256,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferStartedThenEx
HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferNotStartedThenExpectNoSwitchCommandsLinearStreamUpdated) { HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferNotStartedThenExpectNoSwitchCommandsLinearStreamUpdated) {
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START; using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = wddmDirectSubmission.initialize(false, false); bool ret = wddmDirectSubmission.initialize(false, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -283,7 +283,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenSwitchingRingBufferStartedAndWai
using RingBufferUse = typename MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>::RingBufferUse; using RingBufferUse = typename MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>>::RingBufferUse;
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START; using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
bool ret = wddmDirectSubmission.initialize(true, false); bool ret = wddmDirectSubmission.initialize(true, false);
EXPECT_TRUE(ret); EXPECT_TRUE(ret);
@ -319,7 +319,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmWhenUpdatingTagValueThenExpectComple
contextFence.currentFenceValue = value; contextFence.currentFenceValue = value;
MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
uint64_t actualTagValue = wddmDirectSubmission.updateTagValue(); uint64_t actualTagValue = wddmDirectSubmission.updateTagValue();
EXPECT_EQ(value, actualTagValue); EXPECT_EQ(value, actualTagValue);
@ -348,7 +348,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmResidencyEnabledWhenCreatingDestroyi
std::unique_ptr<MockWddmDirectSubmission<FamilyType, Dispatcher>> wddmSubmission = std::unique_ptr<MockWddmDirectSubmission<FamilyType, Dispatcher>> wddmSubmission =
std::make_unique<MockWddmDirectSubmission<FamilyType, Dispatcher>>(*device.get(), std::make_unique<MockWddmDirectSubmission<FamilyType, Dispatcher>>(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled); EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);
EXPECT_EQ(2u, NEO::IoFunctions::mockVfptrinfCalled); EXPECT_EQ(2u, NEO::IoFunctions::mockVfptrinfCalled);
@ -375,7 +375,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmResidencyEnabledWhenAllocatingResour
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
wddm->callBaseMakeResident = true; wddm->callBaseMakeResident = true;
wddm->createPagingFenceLogger(); wddm->createPagingFenceLogger();
@ -406,7 +406,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmResidencyEnabledWhenHandleResidencyT
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
wddm->createPagingFenceLogger(); wddm->createPagingFenceLogger();
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled); EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);
@ -435,7 +435,7 @@ HWTEST_F(WddmDirectSubmissionTest, givenWddmResidencyEnabledWhenSubmitToGpuThenS
NEO::IoFunctions::mockFcloseCalled = 0u; NEO::IoFunctions::mockFcloseCalled = 0u;
MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device.get(), MockWddmDirectSubmission<FamilyType, Dispatcher> wddmDirectSubmission(*device.get(),
*osContext); *osContext, device->getDefaultEngine().commandStreamReceiver->getGlobalFenceAllocation());
wddm->createPagingFenceLogger(); wddm->createPagingFenceLogger();
EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled); EXPECT_EQ(1u, NEO::IoFunctions::mockFopenCalled);

4
shared/test/unit_test/os_interface/windows/wddm_command_stream_l0_tests.cpp
View File

@ -81,12 +81,12 @@ struct MockWddmCsrL0 : public WddmCommandStreamReceiver<GfxFamily> {
if (DebugManager.flags.EnableDirectSubmission.get() == 1) { if (DebugManager.flags.EnableDirectSubmission.get() == 1) {
if (!initBlitterDirectSubmission) { if (!initBlitterDirectSubmission) {
directSubmission = std::make_unique< directSubmission = std::make_unique<
MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>>(device, osContext); MockWddmDirectSubmission<GfxFamily, RenderDispatcher<GfxFamily>>>(device, osContext, globalFenceAllocation);
ret = directSubmission->initialize(true, false); ret = directSubmission->initialize(true, false);
this->dispatchMode = DispatchMode::ImmediateDispatch; this->dispatchMode = DispatchMode::ImmediateDispatch;
} else { } else {
blitterDirectSubmission = std::make_unique< blitterDirectSubmission = std::make_unique<
MockWddmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>>>(device, osContext); MockWddmDirectSubmission<GfxFamily, BlitterDispatcher<GfxFamily>>>(device, osContext, globalFenceAllocation);
blitterDirectSubmission->initialize(true, false); blitterDirectSubmission->initialize(true, false);
} }
} }