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

Patchtokens: Add support for querying device globals by host name

Browse Source 
This commit enables parsing symbol infos
passed in the PATCH_TOKEN_PROGRAM_SYMBOL_TABLE patchtoken.
Related-To: NEO-6734
Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
This commit is contained in:
Kacper Nowak
2022-03-03 14:46:26 +00:00
committed by Compute-Runtime-Automation
parent 0ccce5a6d7
commit c5ff07237b
6 changed files with 79 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
shared/source/device_binary_format/patchtokens_decoder.cpp
View File

@ -440,6 +440,9 @@ inline bool decodeToken(const SPatchItemHeader *token, ProgramFromPatchtokens &o
case PATCH_TOKEN_PROGRAM_SYMBOL_TABLE:
assignToken(progTok.symbolTable, token);
break;
case _PATCH_TOKEN_GLOBAL_HOST_ACCESS_TABLE:
assignToken(progTok.hostAccessTable, token);
break;
}
return true;
}

5
shared/source/device_binary_format/patchtokens_decoder.h
View File

@ -42,6 +42,10 @@ enum class ArgObjectTypeSpecialized : uint32_t {
Vme
};
const uint32_t patchTokenGlobalHostAccessTableUnknownId = 1234;
constexpr bool hasGlobalHostAccessTable = ((CURRENT_ICBE_VERSION == 1080 && NUM_PATCH_TOKENS == 58) || (CURRENT_ICBE_VERSION == 1082 && NUM_PATCH_TOKENS == 59));
constexpr uint32_t _PATCH_TOKEN_GLOBAL_HOST_ACCESS_TABLE = hasGlobalHostAccessTable ? 57 : patchTokenGlobalHostAccessTableUnknownId;
using StackVecUnhandledTokens = StackVec<const SPatchItemHeader *, 4>;
using StackVecByValMap = StackVec<const SPatchDataParameterBuffer *, 8>;
using StackVecStrings = StackVec<const SPatchString *, 4>;
@ -179,6 +183,7 @@ struct ProgramFromPatchtokens {
StackVec<const SPatchConstantPointerProgramBinaryInfo *, 4> constantPointer;
StackVec<const SPatchGlobalPointerProgramBinaryInfo *, 4> globalPointer;
const SPatchFunctionTableInfo *symbolTable = nullptr;
const SPatchFunctionTableInfo *hostAccessTable = nullptr;
} programScopeTokens;
StackVec<KernelFromPatchtokens, 2> kernels;
StackVec<const SPatchItemHeader *, 4> unhandledTokens;

25
shared/source/program/program_info_from_patchtokens.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -14,6 +14,8 @@
#include "shared/source/program/kernel_info_from_patchtokens.h"
#include "shared/source/program/program_info.h"
#include <RelocationInfo.h>
namespace NEO {
bool requiresLocalMemoryWindowVA(const PatchTokenBinary::ProgramFromPatchtokens &src) {
@ -106,6 +108,27 @@ void populateProgramInfo(ProgramInfo &dst, const PatchTokenBinary::ProgramFromPa
const auto patch = src.programScopeTokens.symbolTable;
dst.linkerInput->decodeGlobalVariablesSymbolTable(patch + 1, patch->NumEntries);
}
if (src.programScopeTokens.hostAccessTable != nullptr) {
parseHostAccessTable(dst, src.programScopeTokens.hostAccessTable);
}
}
void parseHostAccessTable(ProgramInfo &dst, const void *hostAccessTable) {
hostAccessTable = ptrOffset(hostAccessTable, sizeof(iOpenCL::SPatchItemHeader));
const uint32_t numEntries = *reinterpret_cast<const uint32_t *>(hostAccessTable);
hostAccessTable = ptrOffset(hostAccessTable, sizeof(uint32_t));
auto &deviceToHostNameMap = dst.globalsDeviceToHostNameMap;
struct HostAccessTableEntry {
const char deviceName[vISA::MAX_SYMBOL_NAME_LENGTH];
const char hostName[vISA::MAX_SYMBOL_NAME_LENGTH];
};
ArrayRef<const HostAccessTableEntry> hostAccessTableEntries = {reinterpret_cast<const HostAccessTableEntry *>(hostAccessTable),
numEntries};
for (size_t i = 0; i < hostAccessTableEntries.size(); i++) {
auto &entry = hostAccessTableEntries[i];
deviceToHostNameMap[entry.deviceName] = entry.hostName;
}
}
} // namespace NEO

4
shared/source/program/program_info_from_patchtokens.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -26,4 +26,6 @@ bool requiresLocalMemoryWindowVA(const PatchTokenBinary::ProgramFromPatchtokens
void populateProgramInfo(ProgramInfo &dst, const PatchTokenBinary::ProgramFromPatchtokens &src);
void parseHostAccessTable(ProgramInfo &dst, const void *hostAccessTable);
} // namespace NEO

32
shared/test/unit_test/device_binary_format/patchtokens_tests.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -9,9 +9,11 @@
#include "shared/source/device_binary_format/patchtokens_decoder.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/string.h"
#include "igfxfmid.h"
#include <RelocationInfo.h>
#include <vector>
extern GFXCORE_FAMILY renderCoreFamily;
@ -99,6 +101,34 @@ struct ValidEmptyProgram : NEO::PatchTokenBinary::ProgramFromPatchtokens {
iOpenCL::SProgramBinaryHeader *headerMutable = nullptr;
};
struct ValidProgramWithHostAccessTable : ValidEmptyProgram {
ValidProgramWithHostAccessTable() {
iOpenCL::SPatchFunctionTableInfo hostAccessTok = {};
hostAccessTok.Token = NEO::PatchTokenBinary::_PATCH_TOKEN_GLOBAL_HOST_ACCESS_TABLE;
hostAccessTok.NumEntries = 2;
struct HostAccessTableEntry {
char deviceName[vISA::MAX_SYMBOL_NAME_LENGTH];
char hostName[vISA::MAX_SYMBOL_NAME_LENGTH];
};
hostAccessTok.Size = sizeof(hostAccessTok) + 2 * sizeof(HostAccessTableEntry);
const size_t hostAccessTokStorageSize = sizeof(hostAccessTok) + 2 * sizeof(HostAccessTableEntry);
uint8_t hostAccessTokStorage[hostAccessTokStorageSize] = {};
uint8_t *storagePtr = hostAccessTokStorage;
memcpy_s(storagePtr, hostAccessTokStorageSize, &hostAccessTok, sizeof(iOpenCL::SPatchFunctionTableInfo));
storagePtr = ptrOffset(storagePtr, sizeof(iOpenCL::SPatchFunctionTableInfo));
HostAccessTableEntry *entries = reinterpret_cast<HostAccessTableEntry *>(storagePtr);
strcpy_s(entries[0].deviceName, vISA::MAX_SYMBOL_NAME_LENGTH, "deviceNameOne");
strcpy_s(entries[0].hostName, vISA::MAX_SYMBOL_NAME_LENGTH, "hostNameOne");
strcpy_s(entries[1].deviceName, vISA::MAX_SYMBOL_NAME_LENGTH, "deviceNameTwo");
strcpy_s(entries[1].hostName, vISA::MAX_SYMBOL_NAME_LENGTH, "hostNameTwo");
storage.insert(storage.end(), hostAccessTokStorage, hostAccessTokStorage + hostAccessTokStorageSize);
recalcTokPtr();
headerMutable->PatchListSize = hostAccessTokStorageSize;
}
};
struct ValidProgramWithConstantSurface : ValidEmptyProgram {
ValidProgramWithConstantSurface() {
iOpenCL::SPatchAllocateConstantMemorySurfaceProgramBinaryInfo constSurfTok = {};

14
shared/test/unit_test/program/program_info_from_patchtokens_tests.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -299,3 +299,15 @@ TEST(PopulateProgramInfoFromPatchtokensTests, GivenProgramWithKernelsWhenKernelH
EXPECT_EQ(0U, receivedSegmentIds[0]);
EXPECT_EQ(1U, receivedSegmentIds[1]);
}
TEST(PopulateProgramInfoFromPatchtokensTests, givenProgramWithHostAccessTableGThenPopulateDeviceHostNameMapCorrectly) {
PatchTokensTestData::ValidProgramWithHostAccessTable programTokens;
NEO::PatchTokenBinary::ProgramFromPatchtokens decodedProgram;
bool decodeSuccess = NEO::PatchTokenBinary::decodeProgramFromPatchtokensBlob(programTokens.blobs.programInfo, decodedProgram);
EXPECT_TRUE(decodeSuccess);
NEO::ProgramInfo programInfo;
NEO::populateProgramInfo(programInfo, decodedProgram);
EXPECT_EQ(2u, programInfo.globalsDeviceToHostNameMap.size());
EXPECT_STREQ("hostNameOne", programInfo.globalsDeviceToHostNameMap["deviceNameOne"].c_str());
EXPECT_STREQ("hostNameTwo", programInfo.globalsDeviceToHostNameMap["deviceNameTwo"].c_str());
}