Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Unify programming of atomic command

Browse Source 
Change-Id: I13afdb44fb83beaa8673eb6456d2a8edcb6ac047
Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2020-10-01 21:08:46 +02:00
committed by sys_ocldev
parent 5386f8be86
commit 2717fcae54
10 changed files with 75 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
opencl/source/gen8/device_queue_gen8.cpp
View File

@ -5,6 +5,7 @@
*
*/
#include "shared/source/command_container/command_encoder.h"
#include "shared/source/gen8/hw_cmds.h"
#include "opencl/source/device_queue/device_queue_hw.h"
@ -32,14 +33,11 @@ void DeviceQueueHw<Family>::addArbCheckCmdWa() {}
template <>
void DeviceQueueHw<Family>::addMiAtomicCmdWa(uint64_t atomicOpPlaceholder) {
auto miAtomic = slbCS.getSpaceForCmd<Family::MI_ATOMIC>();
*miAtomic = Family::cmdInitAtomic;
miAtomic->setAtomicOpcode(Family::MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_8B_INCREMENT);
miAtomic->setReturnDataControl(0x1);
miAtomic->setCsStall(0x1);
miAtomic->setDataSize(Family::MI_ATOMIC::DATA_SIZE::DATA_SIZE_QWORD);
miAtomic->setMemoryAddress(static_cast<uint32_t>(atomicOpPlaceholder & 0x0000FFFFFFFFULL));
miAtomic->setMemoryAddressHigh(static_cast<uint32_t>((atomicOpPlaceholder >> 32) & 0x0000FFFFFFFFULL));
EncodeAtomic<Family>::programMiAtomic(slbCS,
atomicOpPlaceholder,
Family::MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_8B_INCREMENT,
Family::MI_ATOMIC::DATA_SIZE::DATA_SIZE_QWORD,
0x1u, 0x1u);
}
template <>

14
opencl/source/gen9/device_queue_gen9.cpp
View File

@ -5,6 +5,7 @@
*
*/
#include "shared/source/command_container/command_encoder.h"
#include "shared/source/gen9/hw_cmds.h"
#include "opencl/source/device_queue/device_queue_hw.h"
@ -38,14 +39,11 @@ void DeviceQueueHw<Family>::addArbCheckCmdWa() {
template <>
void DeviceQueueHw<Family>::addMiAtomicCmdWa(uint64_t atomicOpPlaceholder) {
auto miAtomic = slbCS.getSpaceForCmd<Family::MI_ATOMIC>();
*miAtomic = Family::cmdInitAtomic;
miAtomic->setAtomicOpcode(Family::MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_8B_INCREMENT);
miAtomic->setReturnDataControl(0x1);
miAtomic->setCsStall(0x1);
miAtomic->setDataSize(Family::MI_ATOMIC::DATA_SIZE::DATA_SIZE_QWORD);
miAtomic->setMemoryAddress(static_cast<uint32_t>(atomicOpPlaceholder & 0x0000FFFFFFFFULL));
miAtomic->setMemoryAddressHigh(static_cast<uint32_t>((atomicOpPlaceholder >> 32) & 0x0000FFFFFFFFULL));
EncodeAtomic<Family>::programMiAtomic(slbCS,
atomicOpPlaceholder,
Family::MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_8B_INCREMENT,
Family::MI_ATOMIC::DATA_SIZE::DATA_SIZE_QWORD,
0x1u, 0x1u);
}
template <>

2
opencl/source/helpers/hardware_commands_helper.h
View File

@ -142,8 +142,6 @@ struct HardwareCommandsHelper : public PerThreadDataHelper {
WALKER_TYPE<GfxFamily> *walkerCmd,
uint32_t &interfaceDescriptorIndex);
static void programMiAtomic(LinearStream &commandStream, uint64_t writeAddress, typename MI_ATOMIC::ATOMIC_OPCODES opcode, typename MI_ATOMIC::DATA_SIZE dataSize);
static void programMiAtomic(MI_ATOMIC &atomic, uint64_t writeAddress, typename MI_ATOMIC::ATOMIC_OPCODES opcode, typename MI_ATOMIC::DATA_SIZE dataSize);
static void programCacheFlushAfterWalkerCommand(LinearStream *commandStream, const CommandQueue &commandQueue, const Kernel *kernel, uint64_t postSyncAddress);
static const size_t alignInterfaceDescriptorData = 64 * sizeof(uint8_t);

21
opencl/source/helpers/hardware_commands_helper_base.inl
View File

@ -382,27 +382,6 @@ void HardwareCommandsHelper<GfxFamily>::updatePerThreadDataTotal(
DEBUG_BREAK_IF(sizePerThreadDataTotal == 0); // Hardware requires at least 1 GRF of perThreadData for each thread in thread group
}
template <typename GfxFamily>
void HardwareCommandsHelper<GfxFamily>::programMiAtomic(LinearStream &commandStream, uint64_t writeAddress,
typename MI_ATOMIC::ATOMIC_OPCODES opcode,
typename MI_ATOMIC::DATA_SIZE dataSize) {
auto miAtomic = commandStream.getSpaceForCmd<MI_ATOMIC>();
MI_ATOMIC cmd = GfxFamily::cmdInitAtomic;
HardwareCommandsHelper<GfxFamily>::programMiAtomic(cmd, writeAddress, opcode, dataSize);
*miAtomic = cmd;
}
template <typename GfxFamily>
void HardwareCommandsHelper<GfxFamily>::programMiAtomic(MI_ATOMIC &atomic, uint64_t writeAddress,
typename MI_ATOMIC::ATOMIC_OPCODES opcode,
typename MI_ATOMIC::DATA_SIZE dataSize) {
atomic.setAtomicOpcode(opcode);
atomic.setDataSize(dataSize);
atomic.setMemoryAddress(static_cast<uint32_t>(writeAddress & 0x0000FFFFFFFFULL));
atomic.setMemoryAddressHigh(static_cast<uint32_t>(writeAddress >> 32));
}
template <typename GfxFamily>
bool HardwareCommandsHelper<GfxFamily>::doBindingTablePrefetch() {
return true;

22
opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
View File

@ -1051,28 +1051,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, GivenKernelWithSamplersWhenInd
delete[] mockDsh;
}
using HardwareCommandsHelperTests = ::testing::Test;
HWTEST_F(HardwareCommandsHelperTests, whenProgrammingMiAtomicThenSetupAllFields) {
using MI_ATOMIC = typename FamilyType::MI_ATOMIC;
uint64_t writeAddress = 0x10000;
auto opcode = MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_DECREMENT;
auto dataSize = MI_ATOMIC::DATA_SIZE::DATA_SIZE_DWORD;
uint8_t buffer[1024] = {};
LinearStream cmdStream(buffer, 1024);
MI_ATOMIC referenceCommand = FamilyType::cmdInitAtomic;
HardwareCommandsHelper<FamilyType>::programMiAtomic(referenceCommand, writeAddress, opcode, dataSize);
HardwareCommandsHelper<FamilyType>::programMiAtomic(cmdStream, writeAddress, opcode, dataSize);
auto miAtomic = genCmdCast<MI_ATOMIC *>(cmdStream.getCpuBase());
ASSERT_NE(nullptr, miAtomic);
EXPECT_EQ(sizeof(MI_ATOMIC), cmdStream.getUsed());
EXPECT_EQ(0, memcmp(&referenceCommand, miAtomic, sizeof(MI_ATOMIC)));
}
typedef ExecutionModelKernelFixture ParentKernelCommandsFromBinaryTest;
HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelCommandsFromBinaryTest, WhenGettingSizeRequiredForExecutionModelForSurfaceStatesThenReturnSizeOfBlocksPlusMaxBindingTableSizeForAllIdtEntriesAndSchedulerSshSize) {

14
opencl/test/unit_test/mocks/mock_device_queue.h
View File

@ -6,6 +6,8 @@
*/
#pragma once
#include "shared/source/command_container/command_encoder.h"
#include "opencl/source/device_queue/device_queue.h"
#include "opencl/source/device_queue/device_queue_hw.h"
#include "opencl/source/helpers/hardware_commands_helper.h"
@ -109,13 +111,13 @@ class MockDeviceQueueHw : public DeviceQueueHw<GfxFamily> {
auto placeholder = (uint64_t)&igilCmdQueue->m_controls.m_DummyAtomicOperationPlaceholder;
MI_ATOMIC miAtomic = GfxFamily::cmdInitAtomic;
miAtomic.setReturnDataControl(0x1);
miAtomic.setCsStall(0x1);
HardwareCommandsHelper<GfxFamily>::programMiAtomic(miAtomic, placeholder, MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_8B_INCREMENT,
MI_ATOMIC::DATA_SIZE::DATA_SIZE_QWORD);
EncodeAtomic<GfxFamily>::programMiAtomic(&miAtomic,
placeholder,
MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_8B_INCREMENT,
MI_ATOMIC::DATA_SIZE::DATA_SIZE_QWORD,
0x1u, 0x1u);
return miAtomic;
};
}
MI_LOAD_REGISTER_IMM getExpectedLriCmd(bool arbCheck) {
MI_LOAD_REGISTER_IMM lri = GfxFamily::cmdInitLoadRegisterImm;

14
shared/source/command_container/command_encoder.h
View File

@ -248,9 +248,19 @@ struct EncodeAtomic {
using ATOMIC_OPCODES = typename GfxFamily::MI_ATOMIC::ATOMIC_OPCODES;
using DATA_SIZE = typename GfxFamily::MI_ATOMIC::DATA_SIZE;
static void programMiAtomic(MI_ATOMIC *atomic, uint64_t writeAddress,
static void programMiAtomic(LinearStream &commandStream,
uint64_t writeAddress,
ATOMIC_OPCODES opcode,
DATA_SIZE dataSize);
DATA_SIZE dataSize,
uint32_t returnDataControl,
uint32_t csStall);
static void programMiAtomic(MI_ATOMIC *atomic,
uint64_t writeAddress,
ATOMIC_OPCODES opcode,
DATA_SIZE dataSize,
uint32_t returnDataControl,
uint32_t csStall);
};
template <typename GfxFamily>

20
shared/source/command_container/command_encoder.inl
View File

@ -424,18 +424,34 @@ size_t EncodeSempahore<Family>::getSizeMiSemaphoreWait() {
}
template <typename Family>
void EncodeAtomic<Family>::programMiAtomic(MI_ATOMIC *atomic, uint64_t writeAddress,
void EncodeAtomic<Family>::programMiAtomic(MI_ATOMIC *atomic,
uint64_t writeAddress,
ATOMIC_OPCODES opcode,
DATA_SIZE dataSize) {
DATA_SIZE dataSize,
uint32_t returnDataControl,
uint32_t csStall) {
MI_ATOMIC cmd = Family::cmdInitAtomic;
cmd.setAtomicOpcode(opcode);
cmd.setDataSize(dataSize);
cmd.setMemoryAddress(static_cast<uint32_t>(writeAddress & 0x0000FFFFFFFFULL));
cmd.setMemoryAddressHigh(static_cast<uint32_t>(writeAddress >> 32));
cmd.setReturnDataControl(returnDataControl);
cmd.setCsStall(csStall);
*atomic = cmd;
}
template <typename GfxFamily>
void EncodeAtomic<GfxFamily>::programMiAtomic(LinearStream &commandStream,
uint64_t writeAddress,
ATOMIC_OPCODES opcode,
DATA_SIZE dataSize,
uint32_t returnDataControl,
uint32_t csStall) {
auto miAtomic = commandStream.getSpaceForCmd<MI_ATOMIC>();
EncodeAtomic<GfxFamily>::programMiAtomic(miAtomic, writeAddress, opcode, dataSize, returnDataControl, csStall);
}
template <typename Family>
void EncodeBatchBufferStartOrEnd<Family>::programBatchBufferStart(LinearStream *commandStream,
uint64_t address,

6
shared/source/helpers/timestamp_packet.h
View File

@ -145,10 +145,10 @@ struct TimestampPacketHelper {
for (uint32_t i = 0; i < numSupportedDevices; i++) {
timestampPacketNode.incImplicitCpuDependenciesCount();
}
auto miAtomic = cmdStream.getSpaceForCmd<MI_ATOMIC>();
EncodeAtomic<GfxFamily>::programMiAtomic(miAtomic, dependenciesCountAddress,
EncodeAtomic<GfxFamily>::programMiAtomic(cmdStream, dependenciesCountAddress,
MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_INCREMENT,
MI_ATOMIC::DATA_SIZE::DATA_SIZE_DWORD);
MI_ATOMIC::DATA_SIZE::DATA_SIZE_DWORD,
0u, 0u);
}
}

29
shared/test/unit_test/encoders/test_encode_atomic.cpp
View File

@ -5,6 +5,7 @@
*
*/
#include "shared/source/command_stream/linear_stream.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/test/unit_test/cmd_parse/gen_cmd_parse.h"
#include "shared/test/unit_test/fixtures/command_container_fixture.h"
@ -13,14 +14,28 @@ using namespace NEO;
using CommandEncodeAtomic = Test<CommandEncodeStatesFixture>;
HWTEST_F(CommandEncodeAtomic, programMiAtomic) {
HWTEST_F(CommandEncodeAtomic, WhenProgrammingMiAtomicThenExpectAllFieldsSetCorrectly) {
using MI_ATOMIC = typename FamilyType::MI_ATOMIC;
MI_ATOMIC miAtomic;
using ATOMIC_OPCODES = typename FamilyType::MI_ATOMIC::ATOMIC_OPCODES;
using DATA_SIZE = typename FamilyType::MI_ATOMIC::DATA_SIZE;
EncodeAtomic<FamilyType>::programMiAtomic(&miAtomic, 0x123400, MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_DECREMENT,
MI_ATOMIC::DATA_SIZE::DATA_SIZE_DWORD);
constexpr size_t bufferSize = 128u;
uint8_t buffer[bufferSize];
EXPECT_EQ(MI_ATOMIC::ATOMIC_OPCODES::ATOMIC_4B_DECREMENT, miAtomic.getAtomicOpcode());
EXPECT_EQ(MI_ATOMIC::DATA_SIZE::DATA_SIZE_DWORD, miAtomic.getDataSize());
EXPECT_EQ(0x123400u, miAtomic.getMemoryAddress());
LinearStream cmdbuffer(buffer, bufferSize);
EncodeAtomic<FamilyType>::programMiAtomic(cmdbuffer,
static_cast<uint64_t>(0x123400),
ATOMIC_OPCODES::ATOMIC_4B_DECREMENT,
DATA_SIZE::DATA_SIZE_DWORD,
0x1u,
0x1u);
MI_ATOMIC *miAtomicCmd = reinterpret_cast<MI_ATOMIC *>(cmdbuffer.getCpuBase());
EXPECT_EQ(ATOMIC_OPCODES::ATOMIC_4B_DECREMENT, miAtomicCmd->getAtomicOpcode());
EXPECT_EQ(DATA_SIZE::DATA_SIZE_DWORD, miAtomicCmd->getDataSize());
EXPECT_EQ(0x123400u, miAtomicCmd->getMemoryAddress());
EXPECT_EQ(0x1u, miAtomicCmd->getReturnDataControl());
EXPECT_EQ(0x1u, miAtomicCmd->getCsStall());
}