From 8bc1fb12513f59b270293e2075b1180c44f22df9 Mon Sep 17 00:00:00 2001 From: Mateusz Hoppe Date: Fri, 9 Jun 2023 11:00:17 +0000 Subject: [PATCH] refactor: add function checking bindless addressing - simplify logic to check addressing mode of a kernel Related-To: NEO-7063 Signed-off-by: Mateusz Hoppe --- .../command_encoder_bdw_and_later.inl | 3 ++- .../command_encoder_xehp_and_later.inl | 10 +++++---- shared/source/kernel/kernel_descriptor.cpp | 13 +++++++++++ shared/source/kernel/kernel_descriptor.h | 2 ++ .../kernel/kernel_descriptor_tests.cpp | 22 ++++++++++++++++++- 5 files changed, 44 insertions(+), 6 deletions(-) diff --git a/shared/source/command_container/command_encoder_bdw_and_later.inl b/shared/source/command_container/command_encoder_bdw_and_later.inl index 05a132c0ff..4d7a352280 100644 --- a/shared/source/command_container/command_encoder_bdw_and_later.inl +++ b/shared/source/command_container/command_encoder_bdw_and_later.inl @@ -99,7 +99,8 @@ void EncodeDispatchKernel::encode(CommandContainer &container, EncodeDis uint32_t bindingTableStateCount = kernelDescriptor.payloadMappings.bindingTable.numEntries; uint32_t bindingTablePointer = 0u; - bool isBindlessKernel = kernelDescriptor.kernelAttributes.bufferAddressingMode == KernelDescriptor::BindlessAndStateless; + bool isBindlessKernel = NEO::KernelDescriptor::isBindlessAddressingKernel(kernelDescriptor); + if (!isBindlessKernel) { container.prepareBindfulSsh(); if (bindingTableStateCount > 0u) { diff --git a/shared/source/command_container/command_encoder_xehp_and_later.inl b/shared/source/command_container/command_encoder_xehp_and_later.inl index b2bb1e9f72..f08c34dcc9 100644 --- a/shared/source/command_container/command_encoder_xehp_and_later.inl +++ b/shared/source/command_container/command_encoder_xehp_and_later.inl @@ -114,16 +114,18 @@ void EncodeDispatchKernel::encode(CommandContainer &container, EncodeDis idd.setSharedLocalMemorySize(slmSize); auto bindingTableStateCount = kernelDescriptor.payloadMappings.bindingTable.numEntries; - auto bufferAddressingMode = kernelDescriptor.kernelAttributes.bufferAddressingMode; + bool skipSshProgramming = false; if (productHelper.isSkippingStatefulInformationRequired(kernelDescriptor)) { bindingTableStateCount = 0u; - bufferAddressingMode = KernelDescriptor::Stateless; + skipSshProgramming = true; } uint32_t bindingTablePointer = 0u; - if ((bufferAddressingMode == KernelDescriptor::BindfulAndStateless) || - kernelDescriptor.kernelAttributes.flags.usesImages) { + + bool isBindlessKernel = NEO::KernelDescriptor::isBindlessAddressingKernel(kernelDescriptor); + + if (!isBindlessKernel && !skipSshProgramming) { container.prepareBindfulSsh(); if (bindingTableStateCount > 0u) { auto ssh = args.surfaceStateHeap; diff --git a/shared/source/kernel/kernel_descriptor.cpp b/shared/source/kernel/kernel_descriptor.cpp index 1617589255..615e078b06 100644 --- a/shared/source/kernel/kernel_descriptor.cpp +++ b/shared/source/kernel/kernel_descriptor.cpp @@ -108,4 +108,17 @@ void KernelDescriptor::updateCrossThreadDataSize() { this->kernelAttributes.crossThreadDataSize = std::max(this->kernelAttributes.crossThreadDataSize, static_cast(alignUp(crossThreadDataSize, 32))); } +bool KernelDescriptor::isBindlessAddressingKernel(const KernelDescriptor &desc) { + bool bindlessBuffers = false; + bool bindlessImages = false; + if (desc.kernelAttributes.bufferAddressingMode == KernelDescriptor::Bindless || desc.kernelAttributes.bufferAddressingMode == KernelDescriptor::BindlessAndStateless) { + bindlessBuffers = true; + } + if (desc.kernelAttributes.flags.usesImages && desc.kernelAttributes.imageAddressingMode == KernelDescriptor::Bindless) { + bindlessImages = true; + } + + return bindlessBuffers || bindlessImages; +} + } // namespace NEO \ No newline at end of file diff --git a/shared/source/kernel/kernel_descriptor.h b/shared/source/kernel/kernel_descriptor.h index bdc2f42cc4..5948858a4c 100644 --- a/shared/source/kernel/kernel_descriptor.h +++ b/shared/source/kernel/kernel_descriptor.h @@ -26,6 +26,8 @@ using StringMap = std::unordered_map; using InstructionsSegmentOffset = uint16_t; struct KernelDescriptor { + static bool isBindlessAddressingKernel(const KernelDescriptor &desc); + enum AddressingMode : uint8_t { AddrNone, Stateless, diff --git a/shared/test/unit_test/kernel/kernel_descriptor_tests.cpp b/shared/test/unit_test/kernel/kernel_descriptor_tests.cpp index eae3f7d5e5..a03d83c7db 100644 --- a/shared/test/unit_test/kernel/kernel_descriptor_tests.cpp +++ b/shared/test/unit_test/kernel/kernel_descriptor_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2022 Intel Corporation + * Copyright (C) 2020-2023 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -107,3 +107,23 @@ TEST(KernelDescriptorAttributesSupportsBuffersBiggerThan4Gb, GivenStatefulBuffer desc.kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::BindlessAndStateless; EXPECT_FALSE(desc.kernelAttributes.supportsBuffersBiggerThan4Gb()); } + +TEST(KernelDescriptor, GivenBufferOrImageBindlessAddressingWhenIsBindlessAddressingKernelCalledThenTrueIsReturned) { + NEO::KernelDescriptor desc; + desc.kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::Bindful; + EXPECT_FALSE(NEO::KernelDescriptor::isBindlessAddressingKernel(desc)); + + desc.kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::BindfulAndStateless; + EXPECT_FALSE(NEO::KernelDescriptor::isBindlessAddressingKernel(desc)); + + desc.kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::Bindless; + EXPECT_TRUE(NEO::KernelDescriptor::isBindlessAddressingKernel(desc)); + + desc.kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::BindlessAndStateless; + EXPECT_TRUE(NEO::KernelDescriptor::isBindlessAddressingKernel(desc)); + + desc.kernelAttributes.bufferAddressingMode = NEO::KernelDescriptor::AddrNone; + desc.kernelAttributes.imageAddressingMode = NEO::KernelDescriptor::Bindless; + desc.kernelAttributes.flags.usesImages = true; + EXPECT_TRUE(NEO::KernelDescriptor::isBindlessAddressingKernel(desc)); +}