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

feature(zebin): set bindless adressing modes in kernel attributes 

- when bindless adressing is set in zeinfo, kernel attributes should
reflect that.

Related-To: NEO-7063

Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>
This commit is contained in:
Mateusz Hoppe 2023-05-30 16:04:08 +00:00 committed by Compute-Runtime-Automation
parent 9054ca15ec
commit e017ed0be9
2 changed files with 136 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
shared/source/device_binary_format/zebin/zeinfo_decoder.cpp
View File

@ -946,11 +946,43 @@ DecodeError decodeZeInfoKernelPayloadArguments(KernelDescriptor &dst, Yaml::Yaml
dst.payloadMappings.explicitArgs.resize(maxArgumentIndex + 1);
dst.kernelAttributes.numArgsToPatch = maxArgumentIndex + 1;
bool bindlessBufferAccess = false;
bool bindlessImageAccess = false;
bool bindfulBufferAccess = false;
bool bindfulImageAccess = false;
for (const auto &arg : payloadArguments) {
auto decodeErr = populateKernelPayloadArgument(dst, arg, outErrReason, outWarning);
if (DecodeError::Success != decodeErr) {
return decodeErr;
}
if (arg.addrmode == Types::Kernel::PayloadArgument::MemoryAddressingModeBindless) {
if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTPointer>()) {
bindlessBufferAccess = true;
} else if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTImage>()) {
bindlessImageAccess = true;
}
} else if (arg.addrmode == Types::Kernel::PayloadArgument::MemoryAddressingModeStateful) {
if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTPointer>()) {
bindfulBufferAccess = true;
} else if (dst.payloadMappings.explicitArgs[arg.argIndex].is<NEO::ArgDescriptor::ArgTImage>()) {
bindfulImageAccess = true;
}
}
}
if ((bindlessBufferAccess && bindfulBufferAccess) ||
(bindlessImageAccess && bindfulImageAccess)) {
outErrReason.append("DeviceBinaryFormat::Zebin::.ze_info : bindless and bindful addressing modes must not be mixed.\n");
return DecodeError::InvalidBinary;
}
if (bindlessBufferAccess) {
dst.kernelAttributes.bufferAddressingMode = KernelDescriptor::BindlessAndStateless;
}
if (bindlessImageAccess) {
dst.kernelAttributes.imageAddressingMode = KernelDescriptor::Bindless;
}
dst.kernelAttributes.crossThreadDataSize = static_cast<uint16_t>(alignUp(dst.kernelAttributes.crossThreadDataSize, 32));
}

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

@ -1508,6 +1508,110 @@ kernels:
EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessBufferAddressingWhenDecodingZeInfoThenBufferAddressingModeIsBindlessAndStateless) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type: arg_bypointer
offset: 0
size: 4
arg_index: 0
addrmode: bindless
addrspace: global
access_type: readwrite
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::Success, err);
EXPECT_EQ(KernelDescriptor::BindlessAndStateless, kernelDescriptor->kernelAttributes.bufferAddressingMode);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessImageAddressingWhenDecodingZeInfoThenImageAddressingModeIsBindless) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type: arg_bypointer
offset: 0
size: 0
arg_index: 0
addrmode: bindless
addrspace: image
access_type: readonly
image_type: image_2d
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::Success, err);
EXPECT_EQ(KernelDescriptor::Bindless, kernelDescriptor->kernelAttributes.imageAddressingMode);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessAndBindfulBufferAddressingWhenDecodingZeInfoThenErrorReturned) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type: arg_bypointer
offset: 0
size: 4
arg_index: 0
addrmode: bindless
addrspace: global
access_type: readwrite
- arg_type: arg_bypointer
offset: 4
size: 4
arg_index: 1
addrmode: stateful
addrspace: global
access_type: readwrite
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
EXPECT_STREQ("DeviceBinaryFormat::Zebin::.ze_info : bindless and bindful addressing modes must not be mixed.\n", errors.c_str());
EXPECT_EQ(KernelDescriptor::BindfulAndStateless, kernelDescriptor->kernelAttributes.bufferAddressingMode);
}
TEST_F(decodeZeInfoKernelEntryTest, GivenBindlessAndBindfulImageAddressingWhenDecodingZeInfoThenErrorReturned) {
ConstStringRef zeinfo = R"===(
kernels:
- name : some_kernel
execution_env:
simd_size: 8
payload_arguments:
- arg_type: arg_bypointer
offset: 0
size: 0
arg_index: 0
addrmode: bindless
addrspace: image
access_type: readonly
image_type: image_2d
- arg_type: arg_bypointer
offset: 8
size: 0
arg_index: 1
addrmode: stateful
addrspace: image
access_type: readonly
image_type: image_2d
...
)===";
auto err = decodeZeInfoKernelEntry(zeinfo);
EXPECT_EQ(NEO::DecodeError::InvalidBinary, err);
EXPECT_STREQ("DeviceBinaryFormat::Zebin::.ze_info : bindless and bindful addressing modes must not be mixed.\n", errors.c_str());
EXPECT_EQ(KernelDescriptor::Bindful, kernelDescriptor->kernelAttributes.imageAddressingMode);
}
TEST(ReadZeInfoExecutionEnvironment, GivenValidYamlEntriesThenSetProperMembers) {
NEO::ConstStringRef yaml = R"===(---
kernels: