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

Add source offset entry for arg by value in zebin

Browse Source 
Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
This commit is contained in:
Kacper Nowak
2021-12-15 14:32:25 +00:00
committed by Compute-Runtime-Automation
parent 6e5bc0d5ee
commit 1c74eca1ae
3 changed files with 160 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -205,6 +205,7 @@ static constexpr ConstStringRef addrmode("addrmode");
static constexpr ConstStringRef addrspace("addrspace");
static constexpr ConstStringRef accessType("access_type");
static constexpr ConstStringRef samplerIndex("sampler_index");
static constexpr ConstStringRef sourceOffset("source_offset");
namespace ArgType {
static constexpr ConstStringRef localSize("local_size");
static constexpr ConstStringRef groupCount("group_count");
@@ -450,6 +451,7 @@ enum AccessType : uint8_t {
using ArgTypeT = ArgType;
using OffseT = int32_t;
using SourceOffseT = int32_t;
using SizeT = int32_t;
using ArgIndexT = int32_t;
using AddrmodeT = MemoryAddressingMode;
@@ -462,11 +464,13 @@ namespace Defaults {
static constexpr ArgIndexT argIndex = -1;
static constexpr SlmAlignment slmArgAlignment = 16U;
static constexpr SamplerIndexT samplerIndex = -1;
static constexpr SourceOffseT sourceOffset = -1;
} // namespace Defaults
struct PayloadArgumentBaseT {
ArgTypeT argType = ArgTypeUnknown;
OffseT offset = 0;
SourceOffseT sourceOffset = Defaults::sourceOffset;
SizeT size = 0;
ArgIndexT argIndex = Defaults::argIndex;
AddrmodeT addrmode = MemoryAddressingModeUnknown;

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

@@ -578,6 +578,8 @@ DecodeError readZeInfoPayloadArguments(const NEO::Yaml::YamlParser &parser, cons
} else if (NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::samplerIndex == key) {
validPayload &= parser.readValueChecked(payloadArgumentMemberNd, payloadArgMetadata.samplerIndex);
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 {
outWarning.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unknown entry \"" + key.str() + "\" for payload argument in context of " + context.str() + "\n");
}
@@ -817,8 +819,14 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeArgByvalue: {
auto &argAsValue = dst.payloadMappings.explicitArgs[src.argIndex].as<ArgDescValue>(true);
ArgDescValue::Element valueElement;
valueElement.sourceOffset = 0;
if (src.sourceOffset != -1) {
valueElement.sourceOffset = src.sourceOffset;
} else if (argAsValue.elements.empty() == false) {
outErrReason.append("Missing source offset value for element in argByValue\n");
return DecodeError::InvalidBinary;
}
valueElement.offset = src.offset;
valueElement.sourceOffset = 0U;
valueElement.size = src.size;
argAsValue.elements.push_back(valueElement);
break;

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

@@ -1272,6 +1272,153 @@ kernels:
EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
}
TEST(PopulateKernelDescriptor, GivenArgumentByValueWithMoreThanOneElementWithSourceOffsetsSpecifiedThenSetThemAccordingly) {
NEO::ConstStringRef yaml = R"===(
kernels:
- name: some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type : arg_byvalue
offset : 40
size : 1
arg_index : 0
source_offset : 0
- arg_type : arg_byvalue
offset : 44
size : 4
arg_index : 0
source_offset : 1
...
)===";
namespace Defaults = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::Defaults;
NEO::ZeInfoPayloadArguments args;
int32_t maxArgIndex = Defaults::argIndex;
int32_t maxSmpIndex = Defaults::samplerIndex;
NEO::ProgramInfo programInfo;
ZebinTestData::ValidEmptyProgram zebin;
NEO::ZebinSections zebinSections;
std::string errors, warnings;
zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
NEO::Yaml::YamlParser parser;
bool parseSuccess = parser.parse(yaml, errors, warnings);
ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
auto &argsNode = *parser.findNodeWithKeyDfs("payload_arguments");
auto readPayloadArgsRes = NEO::readZeInfoPayloadArguments(parser, argsNode, args, maxArgIndex, maxSmpIndex, "some_kernel", errors, warnings);
EXPECT_EQ(NEO::DecodeError::Success, readPayloadArgsRes);
EXPECT_EQ(args[0].sourceOffset, 0);
EXPECT_EQ(args[1].sourceOffset, 1);
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);
auto elements = programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs[0].as<ArgDescValue>().elements;
EXPECT_EQ(0, elements[0].sourceOffset);
EXPECT_EQ(1, elements[1].sourceOffset);
}
TEST(PopulateKernelDescriptor, GiveArgumentByValueWithOneElementWithoutSourceOffsetSpecifiedSetItToZero) {
NEO::ConstStringRef yaml = R"===(
kernels:
- name: some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type : arg_byvalue
offset : 40
size : 1
arg_index : 0
...
)===";
namespace Defaults = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::Defaults;
NEO::ZeInfoPayloadArguments args;
int32_t maxArgIndex = Defaults::argIndex;
int32_t maxSmpIndex = Defaults::samplerIndex;
NEO::ProgramInfo programInfo;
ZebinTestData::ValidEmptyProgram zebin;
NEO::ZebinSections zebinSections;
std::string errors, warnings;
zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
NEO::Yaml::YamlParser parser;
bool parseSuccess = parser.parse(yaml, errors, warnings);
ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
auto &argsNode = *parser.findNodeWithKeyDfs("payload_arguments");
auto readPayloadArgsRes = NEO::readZeInfoPayloadArguments(parser, argsNode, args, maxArgIndex, maxSmpIndex, "some_kernel", errors, warnings);
EXPECT_EQ(NEO::DecodeError::Success, readPayloadArgsRes);
EXPECT_EQ(args[0].sourceOffset, Defaults::sourceOffset);
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);
auto elements = programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.explicitArgs[0].as<ArgDescValue>().elements;
EXPECT_EQ(0, elements[0].sourceOffset);
}
TEST(PopulateKernelDescriptor, GivenArgumentByValueWithoutAnySourceOffsetsSpecifiedThenPopulateKernelDescriptorReturnsError) {
NEO::ConstStringRef yaml = R"===(
kernels:
- name: some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type : arg_byvalue
offset : 40
size : 1
arg_index : 0
- arg_type : arg_byvalue
offset : 44
size : 4
arg_index : 0
...
)===";
namespace Defaults = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::Defaults;
NEO::ZeInfoPayloadArguments args;
int32_t maxArgIndex = Defaults::argIndex;
int32_t maxSmpIndex = Defaults::samplerIndex;
NEO::ProgramInfo programInfo;
ZebinTestData::ValidEmptyProgram zebin;
NEO::ZebinSections zebinSections;
std::string errors, warnings;
zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
NEO::Yaml::YamlParser parser;
bool parseSuccess = parser.parse(yaml, errors, warnings);
ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
auto &argsNode = *parser.findNodeWithKeyDfs("payload_arguments");
auto readPayloadArgsRes = NEO::readZeInfoPayloadArguments(parser, argsNode, args, maxArgIndex, maxSmpIndex, "some_kernel", errors, warnings);
EXPECT_EQ(NEO::DecodeError::Success, readPayloadArgsRes);
EXPECT_EQ(args[0].sourceOffset, Defaults::sourceOffset);
EXPECT_EQ(args[1].sourceOffset, Defaults::sourceOffset);
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 err = NEO::populateKernelDescriptor(programInfo, elf, zebinSections, parser, kernelNode, errors, warnings);
EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
EXPECT_STREQ("Missing source offset value for element in argByValue\n", errors.c_str());
}
TEST(ReadEnumCheckedArgType, GivenValidStringRepresentationThenParseItCorrectly) {
using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PayloadArgument::ArgType;
using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadPayloadArgument::ArgType;