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

Return correct maxFillSize property 

Related-To: NEO-5205

Change-Id: I62b7fec89451c640f70028b8d3ecb81f7655225d
Signed-off-by: Maciej Plewka <maciej.plewka@intel.com>
This commit is contained in:
Maciej Plewka 2020-10-22 11:25:32 +02:00 committed by sys_ocldev
parent 2dcc2f5422
commit 44af85b492
18 changed files with 110 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
level_zero/core/source/cmdlist/cmdlist_hw.h
View File

@ -202,7 +202,6 @@ struct CommandListCoreFamily : CommandListImp {
void appendEventForProfiling(ze_event_handle_t hEvent, bool beforeWalker);
void appendEventForProfilingCopyCommand(ze_event_handle_t hEvent, bool beforeWalker);
void appendSignalEventPostWalker(ze_event_handle_t hEvent);
bool useMemCopyToBlitFill(size_t patternSize);
void programStateBaseAddress(NEO::CommandContainer &container, bool genericMediaStateClearRequired);
void programThreadArbitrationPolicy(Device *device);

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

@ -1207,24 +1207,8 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendBlitFill(void *ptr,
size_t size,
ze_event_handle_t hEvent) {
auto neoDevice = device->getNEODevice();
if (useMemCopyToBlitFill(patternSize)) {
NEO::AllocationProperties properties = {neoDevice->getRootDeviceIndex(),
false,
size,
NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY,
false,
neoDevice->getDeviceBitfield()};
properties.flags.allocateMemory = 1;
auto internalAlloc = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
size_t offset = 0;
for (uint32_t i = 0; i < size / patternSize; i++) {
memcpy_s(ptrOffset(internalAlloc->getUnderlyingBuffer(), offset), (internalAlloc->getUnderlyingBufferSize() - offset), pattern, patternSize);
offset += patternSize;
}
memcpy_s(ptrOffset(internalAlloc->getUnderlyingBuffer(), offset), (internalAlloc->getUnderlyingBufferSize() - offset), pattern, size - offset);
auto ret = CommandListCoreFamily<gfxCoreFamily>::appendMemoryCopy(ptr, internalAlloc->getUnderlyingBuffer(), size, hEvent, 0, nullptr);
commandContainer.getDeallocationContainer().push_back(internalAlloc);
return ret;
if (NEO::HwHelper::get(device->getHwInfo().platform.eRenderCoreFamily).getMaxFillPaternSizeForCopyEngine() < patternSize) {
return ZE_RESULT_ERROR_INVALID_SIZE;
} else {
appendEventForProfiling(hEvent, true);
NEO::SvmAllocationData *allocData = nullptr;

5
level_zero/core/source/cmdlist/cmdlist_hw_base.inl
View File

@ -105,9 +105,4 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
return ZE_RESULT_SUCCESS;
}
template <GFXCORE_FAMILY gfxCoreFamily>
bool CommandListCoreFamily<gfxCoreFamily>::useMemCopyToBlitFill(size_t patternSize) {
return patternSize > sizeof(uint32_t);
}
} // namespace L0

6
level_zero/core/source/device/device_imp.cpp
View File

@ -155,15 +155,19 @@ ze_result_t DeviceImp::getCommandQueueGroupProperties(uint32_t *pCount,
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY |
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS |
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS;
pCommandQueueGroupProperties[engineGroupCount].maxMemoryFillPatternSize = std::numeric_limits<size_t>::max();
}
if (i == static_cast<uint32_t>(NEO::EngineGroupType::Compute)) {
pCommandQueueGroupProperties[engineGroupCount].flags = ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY;
pCommandQueueGroupProperties[engineGroupCount].maxMemoryFillPatternSize = std::numeric_limits<size_t>::max();
}
if (i == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
pCommandQueueGroupProperties[engineGroupCount].flags = ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY;
const auto &hardwareInfo = this->neoDevice->getHardwareInfo();
auto &hwHelper = NEO::HwHelper::get(hardwareInfo.platform.eRenderCoreFamily);
pCommandQueueGroupProperties[engineGroupCount].maxMemoryFillPatternSize = hwHelper.getMaxFillPaternSizeForCopyEngine();
}
pCommandQueueGroupProperties[engineGroupCount].maxMemoryFillPatternSize = sizeof(uint32_t);
pCommandQueueGroupProperties[engineGroupCount].numQueues = static_cast<uint32_t>(engines[i].size());
engineGroupCount++;
}

16
level_zero/core/test/unit_tests/gen12lp/test_device_gen12lp.cpp
View File

@ -124,15 +124,17 @@ HWTEST2_F(DeviceQueueGroupTest,
} else {
EXPECT_EQ(properties[i].numQueues, 1u);
}
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
} else if (i == static_cast<uint32_t>(NEO::EngineGroupType::Compute)) {
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_EQ(properties[i].numQueues, 1u);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
} else if (i == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_EQ(properties[i].numQueues, 1u);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, 4 * sizeof(uint32_t));
}
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, sizeof(uint32_t));
}
}
@ -171,15 +173,17 @@ HWTEST2_F(DeviceQueueGroupTest,
} else {
EXPECT_EQ(properties[i].numQueues, 1u);
}
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
} else if (i == static_cast<uint32_t>(NEO::EngineGroupType::Compute)) {
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_EQ(properties[i].numQueues, 1u);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
} else if (i == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_EQ(properties[i].numQueues, 1u);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, 4 * sizeof(uint32_t));
}
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, sizeof(uint32_t));
}
}
@ -209,11 +213,11 @@ HWTEST2_F(DeviceQueueGroupTest,
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS);
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, sizeof(uint32_t));
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
EXPECT_EQ(properties[i].numQueues, 1u);
} else if (i == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, sizeof(uint32_t));
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, 4 * sizeof(uint32_t));
EXPECT_EQ(properties[i].numQueues, 1u);
}
}
@ -251,11 +255,11 @@ HWTEST2_F(DeviceQueueGroupTest,
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS);
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, sizeof(uint32_t));
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
EXPECT_EQ(properties[i].numQueues, 1u);
} else if (i == static_cast<uint32_t>(NEO::EngineGroupType::Copy)) {
EXPECT_TRUE(properties[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY);
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, sizeof(uint32_t));
EXPECT_EQ(properties[i].maxMemoryFillPatternSize, 4 * sizeof(uint32_t));
EXPECT_EQ(properties[i].numQueues, 1u);
}

4
level_zero/core/test/unit_tests/gen9/test_device_gen9.cpp
View File

@ -54,7 +54,7 @@ HWTEST2_F(DeviceQueueGroupTest, givenCommandQueuePropertiesCallThenCorrectNumber
EXPECT_TRUE(properties.flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS);
EXPECT_TRUE(properties.flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS);
EXPECT_EQ(properties.numQueues, 1u);
EXPECT_EQ(properties.maxMemoryFillPatternSize, sizeof(uint32_t));
EXPECT_EQ(properties.maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
}
HWTEST2_F(DeviceQueueGroupTest, givenQueueGroupsReturnedThenCommandListIsCreatedCorrectly, IsGen9) {
@ -72,7 +72,7 @@ HWTEST2_F(DeviceQueueGroupTest, givenQueueGroupsReturnedThenCommandListIsCreated
EXPECT_TRUE(properties.flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS);
EXPECT_TRUE(properties.flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS);
EXPECT_EQ(properties.numQueues, 1u);
EXPECT_EQ(properties.maxMemoryFillPatternSize, sizeof(uint32_t));
EXPECT_EQ(properties.maxMemoryFillPatternSize, std::numeric_limits<size_t>::max());
ze_context_handle_t hContext;
ze_context_desc_t contextDesc;

22
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
View File

@ -1035,5 +1035,27 @@ HWTEST2_F(CommandListCreate, givenCommandList, SupportedPlatforms) {
auto size = helper.getRenderSurfaceStateSize();
EXPECT_EQ(commandList.getReserveSshSize(), size);
}
HWTEST_F(CommandListCreate, GivenCommandListWhenUnalignedPtrThenLeftMiddleAndRightCopyAdded) {
using XY_COPY_BLT = typename FamilyType::XY_COPY_BLT;
ze_result_t returnValue;
std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::Copy, returnValue));
ASSERT_NE(nullptr, commandList);
EXPECT_EQ(device, commandList->device);
void *srcPtr = reinterpret_cast<void *>(0x4321);
void *dstPtr = reinterpret_cast<void *>(0x2345);
auto result = commandList->appendMemoryCopy(dstPtr, srcPtr, 2 * MemoryConstants::cacheLineSize, nullptr, 0, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
cmdList, ptrOffset(commandList->commandContainer.getCommandStream()->getCpuBase(), 0), commandList->commandContainer.getCommandStream()->getUsed()));
auto itor = find<XY_COPY_BLT *>(cmdList.begin(), cmdList.end());
for (uint32_t i = 0; i < 3u; i++, itor++) {
EXPECT_NE(itor++, cmdList.end());
}
}
} // namespace ult
} // namespace L0

23
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_blit.cpp
View File

@ -160,8 +160,8 @@ HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppenBlitFillCalledWithL
cmdList.initialize(device, NEO::EngineGroupType::Copy);
uint64_t pattern[4] = {1, 2, 3, 4};
void *ptr = reinterpret_cast<void *>(0x1234);
cmdList.appendMemoryFill(ptr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 0x1000, nullptr);
EXPECT_GT(cmdList.appendMemoryCopyBlitCalledTimes, 0u);
auto ret = cmdList.appendMemoryFill(ptr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 0x1000, nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_SIZE, ret);
}
HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppenBlitFillToNotDeviceMemThenInvalidArgumentReturned, Platforms) {
@ -173,7 +173,9 @@ HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppenBlitFillToNotDevice
EXPECT_EQ(ret, ZE_RESULT_ERROR_INVALID_ARGUMENT);
}
HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppenBlitFillThenCopyBltIsProgrammed, Platforms) {
using MemFillPlatforms = IsWithinProducts<IGFX_SKYLAKE, IGFX_TIGERLAKE_LP>;
HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppenBlitFillThenCopyBltIsProgrammed, MemFillPlatforms) {
using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
using XY_COLOR_BLT = typename GfxFamily::XY_COLOR_BLT;
MockCommandListForMemFill<gfxCoreFamily> commandList;
@ -191,21 +193,6 @@ HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppenBlitFillThenCopyBlt
device->setDriverHandle(driverHandle.get());
}
HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListWhenAppendBlitFillCalledWithLargePatternSizeThenInternalAllocHasPattern, Platforms) {
MockCommandListForMemFill<gfxCoreFamily> cmdList;
cmdList.initialize(device, NEO::EngineGroupType::Copy);
uint64_t pattern[4] = {1, 2, 3, 4};
void *ptr = reinterpret_cast<void *>(0x1234);
uint32_t fillElements = 0x101;
auto size = fillElements * sizeof(uint64_t);
cmdList.appendMemoryFill(ptr, reinterpret_cast<void *>(&pattern), sizeof(pattern), size, nullptr);
auto internalAlloc = cmdList.commandContainer.getDeallocationContainer()[0];
for (uint32_t i = 0; i < fillElements; i++) {
auto allocValue = reinterpret_cast<uint64_t *>(internalAlloc->getUnderlyingBuffer())[i];
EXPECT_EQ(allocValue, pattern[i % 4]);
}
}
HWTEST2_F(AppendMemoryCopy, givenCopyOnlyCommandListAndHostPointersWhenMemoryCopyCalledThenPipeControlWithDcFlushAddedIsNotAddedAfterBlitCopy, Platforms) {
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;

2
shared/source/gen11/hw_helper_gen11.cpp
View File

@ -7,7 +7,9 @@
#include "shared/source/gen11/aub_mapper.h"
#include "shared/source/helpers/flat_batch_buffer_helper_hw.inl"
#include "shared/source/helpers/hw_helper_base.inl"
#include "shared/source/helpers/hw_helper_bdw_plus.inl"
#include "shared/source/helpers/hw_helper_bdw_to_icllp.inl"
namespace NEO {
typedef ICLFamily Family;

1
shared/source/gen12lp/hw_helper_gen12lp.cpp
View File

@ -12,6 +12,7 @@ using Family = NEO::TGLLPFamily;
#include "shared/source/gen12lp/helpers_gen12lp.h"
#include "shared/source/helpers/flat_batch_buffer_helper_hw.inl"
#include "shared/source/helpers/hw_helper_base.inl"
#include "shared/source/helpers/hw_helper_bdw_plus.inl"
#include "shared/source/helpers/hw_helper_tgllp_plus.inl"
#include "shared/source/os_interface/hw_info_config.h"

2
shared/source/gen8/hw_helper_gen8.cpp
View File

@ -8,7 +8,9 @@
#include "shared/source/gen8/aub_mapper.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/helpers/flat_batch_buffer_helper_hw.inl"
#include "shared/source/helpers/hw_helper_base.inl"
#include "shared/source/helpers/hw_helper_bdw_plus.inl"
#include "shared/source/helpers/hw_helper_bdw_to_icllp.inl"
namespace NEO {
typedef BDWFamily Family;

2
shared/source/gen9/hw_helper_gen9.cpp
View File

@ -7,7 +7,9 @@
#include "shared/source/gen9/aub_mapper.h"
#include "shared/source/helpers/flat_batch_buffer_helper_hw.inl"
#include "shared/source/helpers/hw_helper_base.inl"
#include "shared/source/helpers/hw_helper_bdw_plus.inl"
#include "shared/source/helpers/hw_helper_bdw_to_icllp.inl"
namespace NEO {
typedef SKLFamily Family;

1
shared/source/helpers/CMakeLists.txt
View File

@ -55,6 +55,7 @@ set(NEO_CORE_HELPERS
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_base.inl
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_bdw_plus.inl
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_bdw_to_icllp.inl
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/hw_helper_extended.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tgllp_plus.inl
${CMAKE_CURRENT_SOURCE_DIR}/hw_info.cpp

2
shared/source/helpers/hw_helper.h
View File

@ -127,6 +127,7 @@ class HwHelper {
virtual bool useSystemMemoryPlacementForISA(const HardwareInfo &hwInfo) const = 0;
virtual bool packedFormatsSupported() const = 0;
virtual bool isCooperativeDispatchSupported(const aub_stream::EngineType engine, const PRODUCT_FAMILY productFamily) const = 0;
virtual size_t getMaxFillPaternSizeForCopyEngine() const = 0;
static uint32_t getSubDevicesCount(const HardwareInfo *pHwInfo);
static uint32_t getEnginesCount(const HardwareInfo &hwInfo);
@ -310,6 +311,7 @@ class HwHelperHw : public HwHelper {
bool packedFormatsSupported() const override;
bool isCooperativeDispatchSupported(const aub_stream::EngineType engine, const PRODUCT_FAMILY productFamily) const override;
size_t getMaxFillPaternSizeForCopyEngine() const override;
protected:
LocalMemoryAccessMode getDefaultLocalMemoryAccessMode(const HardwareInfo &hwInfo) const override;

10
shared/source/helpers/hw_helper_base.inl
View File

@ -394,11 +394,6 @@ uint32_t HwHelperHw<GfxFamily>::getMaxThreadsForWorkgroup(const HardwareInfo &hw
return HwHelper::getMaxThreadsForWorkgroup(hwInfo, maxNumEUsPerSubSlice);
}
template <typename GfxFamily>
inline bool HwHelperHw<GfxFamily>::isFusedEuDispatchEnabled(const HardwareInfo &hwInfo) const {
return false;
}
template <typename GfxFamily>
inline bool HwHelperHw<GfxFamily>::isSpecialWorkgroupSizeRequired(const HardwareInfo &hwInfo, bool isSimulation) const {
return false;
@ -494,11 +489,6 @@ bool HwHelperHw<GfxFamily>::useSystemMemoryPlacementForISA(const HardwareInfo &h
return !getEnableLocalMemory(hwInfo);
}
template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::packedFormatsSupported() const {
return false;
}
template <typename GfxFamily>
bool MemorySynchronizationCommands<GfxFamily>::isPipeControlPriorToPipelineSelectWArequired(const HardwareInfo &hwInfo) {
return false;

14
shared/source/helpers/hw_helper_bdw_plus.inl
View File

@ -5,8 +5,8 @@
*
*/
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/helpers/hw_helper_base.inl"
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/helpers/hw_info.h"
namespace NEO {
@ -113,14 +113,4 @@ inline void MemorySynchronizationCommands<GfxFamily>::setPipeControlExtraPropert
template <typename GfxFamily>
bool MemorySynchronizationCommands<GfxFamily>::isPipeControlWArequired(const HardwareInfo &hwInfo) { return false; }
template <typename GfxFamily>
void LriHelper<GfxFamily>::program(LinearStream *cmdStream, uint32_t address, uint32_t value, bool remap) {
MI_LOAD_REGISTER_IMM cmd = GfxFamily::cmdInitLoadRegisterImm;
cmd.setRegisterOffset(address);
cmd.setDataDword(value);
auto lri = cmdStream->getSpaceForCmd<MI_LOAD_REGISTER_IMM>();
*lri = cmd;
}
} // namespace NEO

38
shared/source/helpers/hw_helper_bdw_to_icllp.inl Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/helpers/hw_info.h"
namespace NEO {
template <typename GfxFamily>
inline bool HwHelperHw<GfxFamily>::isFusedEuDispatchEnabled(const HardwareInfo &hwInfo) const {
return false;
}
template <typename GfxFamily>
void LriHelper<GfxFamily>::program(LinearStream *cmdStream, uint32_t address, uint32_t value, bool remap) {
MI_LOAD_REGISTER_IMM cmd = GfxFamily::cmdInitLoadRegisterImm;
cmd.setRegisterOffset(address);
cmd.setDataDword(value);
auto lri = cmdStream->getSpaceForCmd<MI_LOAD_REGISTER_IMM>();
*lri = cmd;
}
template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::packedFormatsSupported() const {
return false;
}
template <typename GfxFamily>
size_t HwHelperHw<GfxFamily>::getMaxFillPaternSizeForCopyEngine() const {
return sizeof(uint32_t);
}
} // namespace NEO

20
shared/source/helpers/hw_helper_tgllp_plus.inl
View File

@ -5,10 +5,13 @@
*
*/
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/helpers/hw_info.h"
namespace NEO {
template <>
inline bool HwHelperHw<Family>::isFusedEuDispatchEnabled(const HardwareInfo &hwInfo) const {
template <typename GfxFamily>
inline bool HwHelperHw<GfxFamily>::isFusedEuDispatchEnabled(const HardwareInfo &hwInfo) const {
auto fusedEuDispatchEnabled = !hwInfo.workaroundTable.waDisableFusedThreadScheduling;
if (DebugManager.flags.CFEFusedEUDispatch.get() != -1) {
fusedEuDispatchEnabled = (DebugManager.flags.CFEFusedEUDispatch.get() == 0);
@ -16,8 +19,8 @@ inline bool HwHelperHw<Family>::isFusedEuDispatchEnabled(const HardwareInfo &hwI
return fusedEuDispatchEnabled;
}
template <>
void LriHelper<Family>::program(LinearStream *cmdStream, uint32_t address, uint32_t value, bool remap) {
template <typename GfxFamily>
void LriHelper<GfxFamily>::program(LinearStream *cmdStream, uint32_t address, uint32_t value, bool remap) {
MI_LOAD_REGISTER_IMM cmd = Family::cmdInitLoadRegisterImm;
cmd.setRegisterOffset(address);
cmd.setDataDword(value);
@ -27,9 +30,14 @@ void LriHelper<Family>::program(LinearStream *cmdStream, uint32_t address, uint3
*lri = cmd;
}
template <>
bool HwHelperHw<Family>::packedFormatsSupported() const {
template <typename GfxFamily>
bool HwHelperHw<GfxFamily>::packedFormatsSupported() const {
return true;
}
template <typename GfxFamily>
size_t HwHelperHw<GfxFamily>::getMaxFillPaternSizeForCopyEngine() const {
return 4 * sizeof(uint32_t);
}
} // namespace NEO