intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-26 07:00:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add slm_alignment entry to .zeInfo payload_arguments section

Browse Source 
This commit adds suport for parsing "slm_alignment" entry in .ze_info
section.
- Set requiredSlmAlignment for addresing mode slm
- Enable optional passed slm alignment parsing (with default value=16
left).

Related-To: NEO-6817
Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
This commit is contained in:
Kacper Nowak
2022-03-24 12:28:45 +00:00
committed by Compute-Runtime-Automation
parent a285712cc4
commit afd71beee9
3 changed files with 86 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
shared/source/device_binary_format/elf/zebin_elf.h
View File

@@ -165,6 +165,7 @@ static constexpr ConstStringRef addrspace("addrspace");
static constexpr ConstStringRef accessType("access_type");
static constexpr ConstStringRef samplerIndex("sampler_index");
static constexpr ConstStringRef sourceOffset("source_offset");
static constexpr ConstStringRef slmArgAlignment("slm_alignment");
namespace ArgType {
static constexpr ConstStringRef localSize("local_size");
static constexpr ConstStringRef groupCount("group_count");
@@ -430,12 +431,12 @@ using ArgIndexT = int32_t;
using AddrmodeT = MemoryAddressingMode;
using AddrspaceT = AddressSpace;
using AccessTypeT = AccessType;
using SlmAlignment = uint8_t;
using SlmAlignmentT = uint8_t;
using SamplerIndexT = int32_t;
namespace Defaults {
static constexpr ArgIndexT argIndex = -1;
static constexpr SlmAlignment slmArgAlignment = 16U;
static constexpr SlmAlignmentT slmArgAlignment = 16U;
static constexpr SamplerIndexT samplerIndex = -1;
static constexpr SourceOffseT sourceOffset = -1;
} // namespace Defaults
@@ -450,6 +451,7 @@ struct PayloadArgumentBaseT {
AddrspaceT addrspace = AddressSpaceUnknown;
AccessTypeT accessType = AccessTypeUnknown;
SamplerIndexT samplerIndex = Defaults::samplerIndex;
SlmAlignmentT slmArgAlignment = Defaults::slmArgAlignment;
};
} // namespace PayloadArgument

4
shared/source/device_binary_format/zebin_decoder.cpp
View File

@@ -582,6 +582,8 @@ DecodeError readZeInfoPayloadArguments(const NEO::Yaml::YamlParser &parser, cons
outMaxSamplerIndex = std::max<int32_t>(outMaxSamplerIndex, payloadArgMetadata.samplerIndex);
} else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::sourceOffset == key) {
validPayload &= readZeInfoValueChecked(parser, payloadArgumentMemberNd, payloadArgMetadata.sourceOffset, context, outErrReason);
} else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::slmArgAlignment == key) {
validPayload &= readZeInfoValueChecked(parser, payloadArgumentMemberNd, payloadArgMetadata.slmArgAlignment, context, outErrReason);
} else {
outWarning.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unknown entry \"" + key.str() + "\" for payload argument in context of " + context.str() + "\n");
}
@@ -840,7 +842,7 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
break;
case NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::MemoryAddressingModeSharedLocalMemory:
dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescPointer>(false).slmOffset = src.offset;
dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescPointer>(false).requiredSlmAlignment = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::Defaults::slmArgAlignment;
dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescPointer>(false).requiredSlmAlignment = src.slmArgAlignment;
break;
}
break;

79
shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp
View File

@@ -1993,6 +1993,47 @@ kernels:
EXPECT_EQ(2, args[0].argIndex);
}
TEST(ReadZeInfoPayloadArguments, GivenArgByPointerWithSlmAddresingModeAndSlmAlignmentThenSetSlmAlignmentAccordingly) {
NEO::ConstStringRef yaml = R"===(---
kernels:
- name: some_kernel
payload_arguments:
- arg_type : arg_bypointer
offset : 24
size : 4
arg_index : 2
addrmode : slm
- arg_type : arg_bypointer
offset : 16
size : 8
arg_index : 1
addrmode : slm
slm_alignment: 8
)===";
std::string parserErrors;
std::string parserWarnings;
NEO::Yaml::YamlParser parser;
bool success = parser.parse(yaml, parserErrors, parserWarnings);
ASSERT_TRUE(success);
auto &argsNode = *parser.findNodeWithKeyDfs("payload_arguments");
std::string errors;
std::string warnings;
NEO::ZeInfoPayloadArguments args;
int32_t maxArgIndex = -1;
int32_t maxSmpIndex = -1;
auto err = NEO::readZeInfoPayloadArguments(parser, argsNode, args, maxArgIndex, maxSmpIndex, "some_kernel", errors, warnings);
EXPECT_EQ(NEO::DecodeError::Success, err);
EXPECT_TRUE(errors.empty()) << errors;
EXPECT_TRUE(warnings.empty()) << warnings;
ASSERT_EQ(2U, args.size());
EXPECT_EQ(NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeArgBypointer, args[0].argType);
EXPECT_EQ(NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeArgBypointer, args[1].argType);
EXPECT_EQ(16, args[0].slmArgAlignment);
EXPECT_EQ(8, args[1].slmArgAlignment);
}
TEST(ReadZeInfoBindingTableIndices, GivenInvalidValueForKnownEntryThenFails) {
NEO::ConstStringRef yaml = R"===(---
kernels:
@@ -4744,6 +4785,44 @@ TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeEnqueuedLocalSizeWhenA
EXPECT_TRUE(warnings.empty()) << warnings;
}
TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeByPointerWithSlmAlignmentSetThenPopulatesKernelDescriptor) {
NEO::ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 32
payload_arguments:
- arg_type : arg_bypointer
offset : 0
size : 8
arg_index : 0
addrmode : slm
slm_alignment: 8
)===";
NEO::ProgramInfo programInfo;
ZebinTestData::ValidEmptyProgram zebin;
zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
std::string errors, warnings;
auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
NEO::Yaml::YamlParser parser;
bool parseSuccess = parser.parse(zeinfo, errors, warnings);
ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
NEO::ZebinSections zebinSections;
auto extractErr = NEO::extractZebinSections(elf, zebinSections, errors, warnings);
ASSERT_EQ(NEO::DecodeError::Success, extractErr) << errors << " " << warnings;
auto &kernelNode = *parser.createChildrenRange(*parser.findNodeWithKeyDfs("kernels")).begin();
auto res = NEO::populateKernelDescriptor(programInfo, elf, zebinSections, parser, kernelNode, errors, warnings);
EXPECT_EQ(NEO::DecodeError::Success, res);
ASSERT_EQ(1u, programInfo.kernelInfos.size());
ASSERT_EQ(1u, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs.size());
const auto &arg = programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs[0].as<ArgDescPointer>();
EXPECT_EQ(8, arg.requiredSlmAlignment);
}
TEST(PopulateArgDescriptorCrossthreadPalyoad, GivenArgTypeEnqueuedLocalSizeWhenArgSizeValidThenPopulatesKernelDescriptor) {
uint32_t vectorSizes[] = {4, 8, 12};