intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: correct naming of enum class constants 9/n

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-12-19 07:40:17 +00:00
committed by Compute-Runtime-Automation
parent c612a86d28
commit a6458433dc
78 changed files with 712 additions and 712 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shared/source/built_ins/built_ins.cpp
View File

@@ -41,7 +41,7 @@ const SipKernel &BuiltIns::getSipKernel(SipKernelType type, Device &device) {
auto ret = compilerInterface->getSipKernelBinary(device, type, sipBinary, stateSaveAreaHeader);
UNRECOVERABLE_IF(ret != TranslationOutput::ErrorCode::Success);
UNRECOVERABLE_IF(ret != TranslationOutput::ErrorCode::success);
UNRECOVERABLE_IF(sipBinary.size() == 0);
const auto allocType = AllocationType::kernelIsaInternal;

12
shared/source/command_container/command_encoder.h
View File

@@ -83,10 +83,10 @@ enum class MiPredicateType : uint32_t {
};
enum class CompareOperation : uint32_t {
Equal = 0,
NotEqual = 1,
GreaterOrEqual = 2,
Less = 3,
equal = 0,
notEqual = 1,
greaterOrEqual = 2,
less = 3,
};
struct EncodeWalkerArgs {
@@ -281,8 +281,8 @@ struct EncodeMathMMIO {
protected:
enum class IncrementOrDecrementOperation {
Increment = 0,
Decrement = 1,
increment = 0,
decrement = 1,
};
static void encodeIncrementOrDecrement(LinearStream &cmdStream, AluRegisters operandRegister, IncrementOrDecrementOperation operationType);

96
shared/source/command_container/command_encoder.inl
View File

@@ -111,12 +111,12 @@ void EncodeMathMMIO<Family>::encodeMulRegVal(CommandContainer &container, uint32
i = 0;
while (i < logLws) {
if (val & (1 << i)) {
EncodeMath<Family>::addition(container, AluRegisters::R_1,
AluRegisters::R_0, AluRegisters::R_2);
EncodeMath<Family>::addition(container, AluRegisters::gpr1,
AluRegisters::gpr0, AluRegisters::gpr2);
EncodeSetMMIO<Family>::encodeREG(container, RegisterOffsets::csGprR1, RegisterOffsets::csGprR2);
}
EncodeMath<Family>::addition(container, AluRegisters::R_0,
AluRegisters::R_0, AluRegisters::R_2);
EncodeMath<Family>::addition(container, AluRegisters::gpr0,
AluRegisters::gpr0, AluRegisters::gpr2);
EncodeSetMMIO<Family>::encodeREG(container, RegisterOffsets::csGprR0, RegisterOffsets::csGprR2);
i++;
}
@@ -136,9 +136,9 @@ void EncodeMathMMIO<Family>::encodeGreaterThanPredicate(CommandContainer &contai
EncodeSetMMIO<Family>::encodeMEM(container, RegisterOffsets::csGprR0, firstOperand);
EncodeSetMMIO<Family>::encodeIMM(container, RegisterOffsets::csGprR1, secondOperand, true);
/* RegisterOffsets::csGprR* registers map to AluRegisters::R_* registers */
EncodeMath<Family>::greaterThan(container, AluRegisters::R_0,
AluRegisters::R_1, AluRegisters::R_2);
/* RegisterOffsets::csGprR* registers map to AluRegisters::gpr* registers */
EncodeMath<Family>::greaterThan(container, AluRegisters::gpr0,
AluRegisters::gpr1, AluRegisters::gpr2);
EncodeSetMMIO<Family>::encodeREG(container, RegisterOffsets::csPredicateResult, RegisterOffsets::csGprR2);
}
@@ -152,9 +152,9 @@ void EncodeMathMMIO<Family>::encodeBitwiseAndVal(CommandContainer &container, ui
bool workloadPartition) {
EncodeSetMMIO<Family>::encodeREG(container, RegisterOffsets::csGprR13, regOffset);
EncodeSetMMIO<Family>::encodeIMM(container, RegisterOffsets::csGprR14, immVal, true);
EncodeMath<Family>::bitwiseAnd(container, AluRegisters::R_13,
AluRegisters::R_14,
AluRegisters::R_15);
EncodeMath<Family>::bitwiseAnd(container, AluRegisters::gpr13,
AluRegisters::gpr14,
AluRegisters::gpr15);
EncodeStoreMMIO<Family>::encode(*container.getCommandStream(),
RegisterOffsets::csGprR15, dstAddress, workloadPartition);
}
@@ -175,15 +175,15 @@ void EncodeMathMMIO<Family>::encodeAlu(MI_MATH_ALU_INST_INLINE *pAluParam, AluRe
MI_MATH_ALU_INST_INLINE aluParam;
aluParam.DW0.Value = 0x0;
aluParam.DW0.BitField.ALUOpcode = static_cast<uint32_t>(AluRegisters::OPCODE_LOAD);
aluParam.DW0.BitField.Operand1 = static_cast<uint32_t>(AluRegisters::R_SRCA);
aluParam.DW0.BitField.ALUOpcode = static_cast<uint32_t>(AluRegisters::opcodeLoad);
aluParam.DW0.BitField.Operand1 = static_cast<uint32_t>(AluRegisters::srca);
aluParam.DW0.BitField.Operand2 = static_cast<uint32_t>(srcA);
*pAluParam = aluParam;
pAluParam++;
aluParam.DW0.Value = 0x0;
aluParam.DW0.BitField.ALUOpcode = static_cast<uint32_t>(AluRegisters::OPCODE_LOAD);
aluParam.DW0.BitField.Operand1 = static_cast<uint32_t>(AluRegisters::R_SRCB);
aluParam.DW0.BitField.ALUOpcode = static_cast<uint32_t>(AluRegisters::opcodeLoad);
aluParam.DW0.BitField.Operand1 = static_cast<uint32_t>(AluRegisters::srcb);
aluParam.DW0.BitField.Operand2 = static_cast<uint32_t>(srcB);
*pAluParam = aluParam;
pAluParam++;
@@ -197,7 +197,7 @@ void EncodeMathMMIO<Family>::encodeAlu(MI_MATH_ALU_INST_INLINE *pAluParam, AluRe
pAluParam++;
aluParam.DW0.Value = 0x0;
aluParam.DW0.BitField.ALUOpcode = static_cast<uint32_t>(AluRegisters::OPCODE_STORE);
aluParam.DW0.BitField.ALUOpcode = static_cast<uint32_t>(AluRegisters::opcodeStore);
aluParam.DW0.BitField.Operand1 = static_cast<uint32_t>(finalResultRegister);
aluParam.DW0.BitField.Operand2 = static_cast<uint32_t>(postOperationStateRegister);
*pAluParam = aluParam;
@@ -230,13 +230,13 @@ void EncodeMathMMIO<Family>::encodeAluAdd(MI_MATH_ALU_INST_INLINE *pAluParam,
AluRegisters firstOperandRegister,
AluRegisters secondOperandRegister,
AluRegisters finalResultRegister) {
encodeAlu(pAluParam, firstOperandRegister, secondOperandRegister, AluRegisters::OPCODE_ADD, finalResultRegister, AluRegisters::R_ACCU);
encodeAlu(pAluParam, firstOperandRegister, secondOperandRegister, AluRegisters::opcodeAdd, finalResultRegister, AluRegisters::accu);
}
template <typename Family>
void EncodeMathMMIO<Family>::encodeAluSubStoreCarry(MI_MATH_ALU_INST_INLINE *pAluParam, AluRegisters regA, AluRegisters regB, AluRegisters finalResultRegister) {
/* regB is subtracted from regA */
encodeAlu(pAluParam, regA, regB, AluRegisters::OPCODE_SUB, finalResultRegister, AluRegisters::R_CF);
encodeAlu(pAluParam, regA, regB, AluRegisters::opcodeSub, finalResultRegister, AluRegisters::cf);
}
template <typename Family>
@@ -244,7 +244,7 @@ void EncodeMathMMIO<Family>::encodeAluAnd(MI_MATH_ALU_INST_INLINE *pAluParam,
AluRegisters firstOperandRegister,
AluRegisters secondOperandRegister,
AluRegisters finalResultRegister) {
encodeAlu(pAluParam, firstOperandRegister, secondOperandRegister, AluRegisters::OPCODE_AND, finalResultRegister, AluRegisters::R_ACCU);
encodeAlu(pAluParam, firstOperandRegister, secondOperandRegister, AluRegisters::opcodeAnd, finalResultRegister, AluRegisters::accu);
}
template <typename Family>
@@ -253,23 +253,23 @@ void EncodeMathMMIO<Family>::encodeIncrementOrDecrement(LinearStream &cmdStream,
LriHelper<Family>::program(&cmdStream, RegisterOffsets::csGprR7 + 4, 0, true);
EncodeAluHelper<Family, 4> aluHelper;
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, operandRegister);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_7);
aluHelper.setNextAlu((operationType == IncrementOrDecrementOperation::Increment) ? AluRegisters::OPCODE_ADD
: AluRegisters::OPCODE_SUB);
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, operandRegister, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, operandRegister);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr7);
aluHelper.setNextAlu((operationType == IncrementOrDecrementOperation::increment) ? AluRegisters::opcodeAdd
: AluRegisters::opcodeSub);
aluHelper.setNextAlu(AluRegisters::opcodeStore, operandRegister, AluRegisters::accu);
aluHelper.copyToCmdStream(cmdStream);
}
template <typename Family>
void EncodeMathMMIO<Family>::encodeIncrement(LinearStream &cmdStream, AluRegisters operandRegister) {
encodeIncrementOrDecrement(cmdStream, operandRegister, IncrementOrDecrementOperation::Increment);
encodeIncrementOrDecrement(cmdStream, operandRegister, IncrementOrDecrementOperation::increment);
}
template <typename Family>
void EncodeMathMMIO<Family>::encodeDecrement(LinearStream &cmdStream, AluRegisters operandRegister) {
encodeIncrementOrDecrement(cmdStream, operandRegister, IncrementOrDecrementOperation::Decrement);
encodeIncrementOrDecrement(cmdStream, operandRegister, IncrementOrDecrementOperation::decrement);
}
/*
@@ -614,7 +614,7 @@ void EncodeIndirectParams<Family>::setWorkDimIndirect(CommandContainer &containe
if (NEO::isValidOffset(workDimOffset)) {
auto dstPtr = ptrOffset(crossThreadAddress, workDimOffset);
constexpr uint32_t resultRegister = RegisterOffsets::csGprR0;
constexpr AluRegisters resultAluRegister = AluRegisters::R_0;
constexpr AluRegisters resultAluRegister = AluRegisters::gpr0;
const uint32_t offset = static_cast<uint32_t>((1ull << 8 * (dstPtr & 0b11)) - 1);
const uint32_t memoryMask = std::numeric_limits<uint32_t>::max() - static_cast<uint32_t>((1ull << 8 * ((dstPtr & 0b11) + 1)) - 1) + offset;
@@ -629,33 +629,33 @@ void EncodeIndirectParams<Family>::setWorkDimIndirect(CommandContainer &containe
} else {
constexpr uint32_t groupCount2Register = RegisterOffsets::csGprR1;
constexpr AluRegisters groupCount2AluRegister = AluRegisters::R_1;
constexpr AluRegisters groupCount2AluRegister = AluRegisters::gpr1;
constexpr uint32_t groupSize1Register = RegisterOffsets::csGprR0;
constexpr AluRegisters groupSize1AluRegister = AluRegisters::R_0;
constexpr AluRegisters groupSize1AluRegister = AluRegisters::gpr0;
constexpr uint32_t groupCount1Register = RegisterOffsets::csGprR1;
constexpr AluRegisters groupCount1AluRegister = AluRegisters::R_1;
constexpr AluRegisters groupCount1AluRegister = AluRegisters::gpr1;
constexpr AluRegisters sumAluRegister = AluRegisters::R_0;
constexpr AluRegisters sumAluRegister = AluRegisters::gpr0;
constexpr AluRegisters workDimEq3AluRegister = AluRegisters::R_3;
constexpr AluRegisters workDimEq3AluRegister = AluRegisters::gpr3;
constexpr AluRegisters workDimGe2AluRegister = AluRegisters::R_4;
constexpr AluRegisters workDimGe2AluRegister = AluRegisters::gpr4;
constexpr uint32_t constantOneRegister = RegisterOffsets::csGprR5;
constexpr AluRegisters constantOneAluRegister = AluRegisters::R_5;
constexpr AluRegisters constantOneAluRegister = AluRegisters::gpr5;
constexpr uint32_t constantTwoRegister = RegisterOffsets::csGprR6;
constexpr AluRegisters constantTwoAluRegister = AluRegisters::R_6;
constexpr AluRegisters constantTwoAluRegister = AluRegisters::gpr6;
constexpr uint32_t backupRegister = RegisterOffsets::csGprR7;
constexpr AluRegisters backupAluRegister = AluRegisters::R_7;
constexpr AluRegisters backupAluRegister = AluRegisters::gpr7;
constexpr uint32_t memoryMaskRegister = RegisterOffsets::csGprR8;
constexpr AluRegisters memoryMaskAluRegister = AluRegisters::R_8;
constexpr AluRegisters memoryMaskAluRegister = AluRegisters::gpr8;
constexpr uint32_t offsetRegister = RegisterOffsets::csGprR8;
constexpr AluRegisters offsetAluRegister = AluRegisters::R_8;
constexpr AluRegisters offsetAluRegister = AluRegisters::gpr8;
if (offset) {
EncodeSetMMIO<Family>::encodeMEM(container, backupRegister, dstPtr);
@@ -877,7 +877,7 @@ void EncodeBatchBufferStartOrEnd<Family>::programConditionalDataMemBatchBufferSt
LriHelper<Family>::program(&commandStream, RegisterOffsets::csGprR8, compareDataLow, true);
LriHelper<Family>::program(&commandStream, RegisterOffsets::csGprR8 + 4, compareDataHigh, true);
programConditionalBatchBufferStartBase(commandStream, startAddress, AluRegisters::R_7, AluRegisters::R_8, compareOperation, indirect);
programConditionalBatchBufferStartBase(commandStream, startAddress, AluRegisters::gpr7, AluRegisters::gpr8, compareOperation, indirect);
}
template <typename Family>
@@ -896,7 +896,7 @@ void EncodeBatchBufferStartOrEnd<Family>::programConditionalDataRegBatchBufferSt
LriHelper<Family>::program(&commandStream, RegisterOffsets::csGprR8, compareDataLow, true);
LriHelper<Family>::program(&commandStream, RegisterOffsets::csGprR8 + 4, compareDataHigh, true);
programConditionalBatchBufferStartBase(commandStream, startAddress, AluRegisters::R_7, AluRegisters::R_8, compareOperation, indirect);
programConditionalBatchBufferStartBase(commandStream, startAddress, AluRegisters::gpr7, AluRegisters::gpr8, compareOperation, indirect);
}
template <typename Family>
@@ -915,21 +915,21 @@ void EncodeBatchBufferStartOrEnd<Family>::programConditionalRegMemBatchBufferSta
EncodeSetMMIO<Family>::encodeREG(commandStream, RegisterOffsets::csGprR8, compareReg);
LriHelper<Family>::program(&commandStream, RegisterOffsets::csGprR8 + 4, 0, true);
programConditionalBatchBufferStartBase(commandStream, startAddress, AluRegisters::R_7, AluRegisters::R_8, compareOperation, indirect);
programConditionalBatchBufferStartBase(commandStream, startAddress, AluRegisters::gpr7, AluRegisters::gpr8, compareOperation, indirect);
}
template <typename Family>
void EncodeBatchBufferStartOrEnd<Family>::programConditionalBatchBufferStartBase(LinearStream &commandStream, uint64_t startAddress, AluRegisters regA, AluRegisters regB,
CompareOperation compareOperation, bool indirect) {
EncodeAluHelper<Family, 4> aluHelper;
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, regA);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, regB);
aluHelper.setNextAlu(AluRegisters::OPCODE_SUB);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, regA);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, regB);
aluHelper.setNextAlu(AluRegisters::opcodeSub);
if ((compareOperation == CompareOperation::Equal) || (compareOperation == CompareOperation::NotEqual)) {
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_ZF);
} else if ((compareOperation == CompareOperation::GreaterOrEqual) || (compareOperation == CompareOperation::Less)) {
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_CF);
if ((compareOperation == CompareOperation::equal) || (compareOperation == CompareOperation::notEqual)) {
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::zf);
} else if ((compareOperation == CompareOperation::greaterOrEqual) || (compareOperation == CompareOperation::less)) {
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::cf);
} else {
UNRECOVERABLE_IF(true);
}
@@ -939,7 +939,7 @@ void EncodeBatchBufferStartOrEnd<Family>::programConditionalBatchBufferStartBase
EncodeSetMMIO<Family>::encodeREG(commandStream, RegisterOffsets::csPredicateResult2, RegisterOffsets::csGprR7);
MiPredicateType predicateType = MiPredicateType::noopOnResult2Clear; // Equal or Less
if ((compareOperation == CompareOperation::NotEqual) || (compareOperation == CompareOperation::GreaterOrEqual)) {
if ((compareOperation == CompareOperation::notEqual) || (compareOperation == CompareOperation::greaterOrEqual)) {
predicateType = MiPredicateType::noopOnResult2Set;
}

2
shared/source/command_container/encode_alu_helper.h
View File

@@ -31,7 +31,7 @@ class EncodeAluHelper {
}
void setNextAlu(AluRegisters opcode) {
setNextAlu(opcode, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE);
setNextAlu(opcode, AluRegisters::opcodeNone, AluRegisters::opcodeNone);
}
void setNextAlu(AluRegisters opcode, AluRegisters operand1, AluRegisters operand2) {

18
shared/source/command_stream/transfer_direction.h
View File

@@ -9,25 +9,25 @@
namespace NEO {
enum class TransferDirection {
HostToHost,
HostToLocal,
LocalToHost,
LocalToLocal,
hostToHost,
hostToLocal,
localToHost,
localToLocal,
};
inline TransferDirection createTransferDirection(bool srcLocal, bool dstLocal) {
if (srcLocal) {
if (dstLocal) {
return TransferDirection::LocalToLocal;
return TransferDirection::localToLocal;
} else {
return TransferDirection::LocalToHost;
return TransferDirection::localToHost;
}
} else {
if (dstLocal) {
return TransferDirection::HostToLocal;
return TransferDirection::hostToLocal;
} else {
return TransferDirection::HostToHost;
return TransferDirection::hostToHost;
}
}
}
} // namespace NEO
} // namespace NEO

58
shared/source/compiler_interface/compiler_interface.cpp
View File

@@ -59,7 +59,7 @@ TranslationOutput::ErrorCode CompilerInterface::build(
const TranslationInput &input,
TranslationOutput &output) {
if (false == isCompilerAvailable(input.srcType, input.outType)) {
return TranslationOutput::ErrorCode::CompilerNotAvailable;
return TranslationOutput::ErrorCode::compilerNotAvailable;
}
IGC::CodeType::CodeType_t srcCodeType = input.srcType;
@@ -87,7 +87,7 @@ TranslationOutput::ErrorCode CompilerInterface::build(
input.internalOptions, ArrayRef<const char>(), ArrayRef<const char>(), igcRevision, igcLibSize, igcLibMTime);
output.deviceBinary.mem = cache->loadCachedBinary(kernelFileHash, output.deviceBinary.size);
if (output.deviceBinary.mem) {
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
}
@@ -114,13 +114,13 @@ TranslationOutput::ErrorCode CompilerInterface::build(
fclOptions.get(), fclInternalOptions.get());
if (fclOutput == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
TranslationOutput::makeCopy(output.frontendCompilerLog, fclOutput->GetBuildLog());
if (fclOutput->Successful() == false) {
return TranslationOutput::ErrorCode::BuildFailure;
return TranslationOutput::ErrorCode::buildFailure;
}
output.intermediateCodeType = intermediateCodeType;
@@ -143,7 +143,7 @@ TranslationOutput::ErrorCode CompilerInterface::build(
input.internalOptions, specIdsRef, specValuesRef, igcRevision, igcLibSize, igcLibMTime);
output.deviceBinary.mem = cache->loadCachedBinary(kernelFileHash, output.deviceBinary.size);
if (output.deviceBinary.mem) {
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
}
@@ -153,13 +153,13 @@ TranslationOutput::ErrorCode CompilerInterface::build(
fclOptions.get(), fclInternalOptions.get(), input.gtPinInput);
if (igcOutput == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
TranslationOutput::makeCopy(output.backendCompilerLog, igcOutput->GetBuildLog());
if (igcOutput->Successful() == false) {
return TranslationOutput::ErrorCode::BuildFailure;
return TranslationOutput::ErrorCode::buildFailure;
}
if (cache != nullptr && cache->getConfig().enabled) {
@@ -169,7 +169,7 @@ TranslationOutput::ErrorCode CompilerInterface::build(
TranslationOutput::makeCopy(output.deviceBinary, igcOutput->GetOutput());
TranslationOutput::makeCopy(output.debugData, igcOutput->GetDebugData());
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode CompilerInterface::compile(
@@ -178,11 +178,11 @@ TranslationOutput::ErrorCode CompilerInterface::compile(
TranslationOutput &output) {
if ((IGC::CodeType::oclC != input.srcType) && (IGC::CodeType::elf != input.srcType)) {
return TranslationOutput::ErrorCode::AlreadyCompiled;
return TranslationOutput::ErrorCode::alreadyCompiled;
}
if (false == isCompilerAvailable(input.srcType, input.outType)) {
return TranslationOutput::ErrorCode::CompilerNotAvailable;
return TranslationOutput::ErrorCode::compilerNotAvailable;
}
auto outType = input.outType;
@@ -201,19 +201,19 @@ TranslationOutput::ErrorCode CompilerInterface::compile(
fclOptions.get(), fclInternalOptions.get());
if (fclOutput == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
TranslationOutput::makeCopy(output.frontendCompilerLog, fclOutput->GetBuildLog());
if (fclOutput->Successful() == false) {
return TranslationOutput::ErrorCode::CompilationFailure;
return TranslationOutput::ErrorCode::compilationFailure;
}
output.intermediateCodeType = outType;
TranslationOutput::makeCopy(output.intermediateRepresentation, fclOutput->GetOutput());
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode CompilerInterface::link(
@@ -221,7 +221,7 @@ TranslationOutput::ErrorCode CompilerInterface::link(
const TranslationInput &input,
TranslationOutput &output) {
if (false == isCompilerAvailable(input.srcType, input.outType)) {
return TranslationOutput::ErrorCode::CompilerNotAvailable;
return TranslationOutput::ErrorCode::compilerNotAvailable;
}
auto inSrc = CIF::Builtins::CreateConstBuffer(igcMain.get(), input.src.begin(), input.src.size());
@@ -229,7 +229,7 @@ TranslationOutput::ErrorCode CompilerInterface::link(
auto igcInternalOptions = CIF::Builtins::CreateConstBuffer(igcMain.get(), input.internalOptions.begin(), input.internalOptions.size());
if (inSrc == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
CIF::RAII::UPtr_t<IGC::OclTranslationOutputTagOCL> currOut;
@@ -246,12 +246,12 @@ TranslationOutput::ErrorCode CompilerInterface::link(
igcOptions.get(), igcInternalOptions.get(), input.gtPinInput);
if (currOut == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
if (currOut->Successful() == false) {
TranslationOutput::makeCopy(output.backendCompilerLog, currOut->GetBuildLog());
return TranslationOutput::ErrorCode::LinkFailure;
return TranslationOutput::ErrorCode::linkFailure;
}
currOut->GetOutput()->Retain(); // shared with currSrc
@@ -262,12 +262,12 @@ TranslationOutput::ErrorCode CompilerInterface::link(
TranslationOutput::makeCopy(output.deviceBinary, currOut->GetOutput());
TranslationOutput::makeCopy(output.debugData, currOut->GetDebugData());
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode CompilerInterface::getSpecConstantsInfo(const NEO::Device &device, ArrayRef<const char> srcSpirV, SpecConstantInfo &output) {
if (false == isIgcAvailable()) {
return TranslationOutput::ErrorCode::CompilerNotAvailable;
return TranslationOutput::ErrorCode::compilerNotAvailable;
}
auto igcTranslationCtx = createIgcTranslationCtx(device, IGC::CodeType::spirV, IGC::CodeType::oclGenBin);
@@ -279,10 +279,10 @@ TranslationOutput::ErrorCode CompilerInterface::getSpecConstantsInfo(const NEO::
auto retVal = getSpecConstantsInfoImpl(igcTranslationCtx.get(), inSrc.get(), output.idsBuffer.get(), output.sizesBuffer.get());
if (!retVal) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode CompilerInterface::createLibrary(
@@ -290,7 +290,7 @@ TranslationOutput::ErrorCode CompilerInterface::createLibrary(
const TranslationInput &input,
TranslationOutput &output) {
if (false == isIgcAvailable()) {
return TranslationOutput::ErrorCode::CompilerNotAvailable;
return TranslationOutput::ErrorCode::compilerNotAvailable;
}
auto igcSrc = CIF::Builtins::CreateConstBuffer(igcMain.get(), input.src.begin(), input.src.size());
@@ -304,25 +304,25 @@ TranslationOutput::ErrorCode CompilerInterface::createLibrary(
igcOptions.get(), igcInternalOptions.get());
if (igcOutput == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
TranslationOutput::makeCopy(output.backendCompilerLog, igcOutput->GetBuildLog());
if (igcOutput->Successful() == false) {
return TranslationOutput::ErrorCode::LinkFailure;
return TranslationOutput::ErrorCode::linkFailure;
}
output.intermediateCodeType = intermediateRepresentation;
TranslationOutput::makeCopy(output.intermediateRepresentation, igcOutput->GetOutput());
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode CompilerInterface::getSipKernelBinary(NEO::Device &device, SipKernelType type, std::vector<char> &retBinary,
std::vector<char> &stateSaveAreaHeader) {
if (false == isIgcAvailable()) {
return TranslationOutput::ErrorCode::CompilerNotAvailable;
return TranslationOutput::ErrorCode::compilerNotAvailable;
}
bool bindlessSip = false;
@@ -348,7 +348,7 @@ TranslationOutput::ErrorCode CompilerInterface::getSipKernelBinary(NEO::Device &
auto deviceCtx = getIgcDeviceCtx(device);
if (deviceCtx == nullptr) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
auto systemRoutineBuffer = igcMain->CreateBuiltin<CIF::Builtins::BufferLatest>();
@@ -360,13 +360,13 @@ TranslationOutput::ErrorCode CompilerInterface::getSipKernelBinary(NEO::Device &
stateSaveAreaBuffer.get());
if (!result) {
return TranslationOutput::ErrorCode::UnknownError;
return TranslationOutput::ErrorCode::unknownError;
}
retBinary.assign(systemRoutineBuffer->GetMemory<char>(), systemRoutineBuffer->GetMemory<char>() + systemRoutineBuffer->GetSizeRaw());
stateSaveAreaHeader.assign(stateSaveAreaBuffer->GetMemory<char>(), stateSaveAreaBuffer->GetMemory<char>() + stateSaveAreaBuffer->GetSizeRaw());
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
CIF::RAII::UPtr_t<IGC::IgcFeaturesAndWorkaroundsTagOCL> CompilerInterface::getIgcFeaturesAndWorkarounds(NEO::Device const &device) {

14
shared/source/compiler_interface/compiler_interface.h
View File

@@ -47,13 +47,13 @@ struct TranslationInput {
struct TranslationOutput {
enum class ErrorCode {
Success = 0,
CompilerNotAvailable,
CompilationFailure,
BuildFailure,
LinkFailure,
AlreadyCompiled,
UnknownError,
success = 0,
compilerNotAvailable,
compilationFailure,
buildFailure,
linkFailure,
alreadyCompiled,
unknownError,
};
struct MemAndSize {

12
shared/source/compiler_interface/linker.cpp
View File

@@ -319,7 +319,7 @@ LinkingStatus Linker::link(const SegmentInfo &globalVariablesSegInfo, const Segm
auto initialUnresolvedExternalsCount = outUnresolvedExternals.size();
success = success && relocateSymbols(globalVariablesSegInfo, globalConstantsSegInfo, exportedFunctionsSegInfo, globalStringsSegInfo, instructionsSegments, constantsInitDataSize, variablesInitDataSize);
if (!success) {
return LinkingStatus::Error;
return LinkingStatus::error;
}
patchInstructionsSegments(instructionsSegments, outUnresolvedExternals, kernelDescriptors);
patchDataSegments(globalVariablesSegInfo, globalConstantsSegInfo, globalVariablesSeg, globalConstantsSeg,
@@ -329,13 +329,13 @@ LinkingStatus Linker::link(const SegmentInfo &globalVariablesSegInfo, const Segm
resolveBuiltins(pDevice, outUnresolvedExternals, instructionsSegments);
if (initialUnresolvedExternalsCount < outUnresolvedExternals.size()) {
return LinkingStatus::LinkedPartially;
return LinkingStatus::linkedPartially;
}
success = resolveExternalFunctions(kernelDescriptors, externalFunctions);
if (!success) {
return LinkingStatus::Error;
return LinkingStatus::error;
}
return LinkingStatus::LinkedFully;
return LinkingStatus::linkedFully;
}
bool Linker::relocateSymbols(const SegmentInfo &globalVariables, const SegmentInfo &globalConstants, const SegmentInfo &exportedFunctions, const SegmentInfo &globalStrings,
@@ -603,9 +603,9 @@ void Linker::applyDebugDataRelocations(const NEO::Elf::Elf<NEO::Elf::EI_CLASS_64
auto targetSectionOffset = decodedElf.sectionHeaders[reloc.targetSectionIndex].header->offset;
auto relocLocation = reinterpret_cast<uint64_t>(inputOutputElf.begin()) + targetSectionOffset + reloc.offset;
if (static_cast<Elf::RELOCATION_X8664_TYPE>(reloc.relocType) == Elf::RELOCATION_X8664_TYPE::R_X8664_64) {
if (static_cast<Elf::RELOCATION_X8664_TYPE>(reloc.relocType) == Elf::RELOCATION_X8664_TYPE::relocation64) {
*reinterpret_cast<uint64_t *>(relocLocation) = symbolAddress;
} else if (static_cast<Elf::RELOCATION_X8664_TYPE>(reloc.relocType) == Elf::RELOCATION_X8664_TYPE::R_X8664_32) {
} else if (static_cast<Elf::RELOCATION_X8664_TYPE>(reloc.relocType) == Elf::RELOCATION_X8664_TYPE::relocation32) {
*reinterpret_cast<uint32_t *>(relocLocation) = static_cast<uint32_t>(symbolAddress & uint32_t(-1));
}
}

6
shared/source/compiler_interface/linker.h
View File

@@ -37,9 +37,9 @@ enum class SegmentType : uint32_t {
};
enum class LinkingStatus : uint32_t {
Error,
LinkedFully,
LinkedPartially
error,
linkedFully,
linkedPartially
};
inline const char *asString(SegmentType segment) {

2
shared/source/debugger/debugger_l0_tgllp_and_later.inl
View File

@@ -79,7 +79,7 @@ void DebuggerL0Hw<GfxFamily>::programSbaTrackingCommandsSingleAddressSpace(NEO::
// Store SBA field offset to R0
NEO::EncodeSetMMIO<GfxFamily>::encodeIMM(cmdStream, RegisterOffsets::csGprR0, static_cast<uint32_t>(pair.first), true);
// Add GPR0 to GPR15, store result in GPR1
NEO::EncodeMath<GfxFamily>::addition(cmdStream, AluRegisters::R_0, AluRegisters::R_15, AluRegisters::R_1);
NEO::EncodeMath<GfxFamily>::addition(cmdStream, AluRegisters::gpr0, AluRegisters::gpr15, AluRegisters::gpr1);
// Cmds to store dest address - from GPR
auto miStoreRegMemLow = cmdStream.getSpaceForCmd<MI_STORE_REGISTER_MEM>();

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

@@ -18,8 +18,8 @@ namespace NEO {
namespace Elf {
enum class RELOCATION_X8664_TYPE : uint32_t {
R_X8664_64 = 0x1,
R_X8664_32 = 0xa
relocation64 = 0x1,
relocation32 = 0xa
};
template <ELF_IDENTIFIER_CLASS numBits = EI_CLASS_64>

8
shared/source/direct_submission/direct_submission_hw.h
View File

@@ -42,9 +42,9 @@ struct TagData {
};
enum class DirectSubmissionSfenceMode : int32_t {
Disabled = 0,
BeforeSemaphoreOnly = 1,
BeforeAndAfterSemaphore = 2
disabled = 0,
beforeSemaphoreOnly = 1,
beforeAndAfterSemaphore = 2
};
namespace UllsDefaults {
@@ -225,7 +225,7 @@ class DirectSubmissionHw {
uint32_t activeTiles = 1u;
uint32_t immWritePostSyncOffset = 0u;
uint32_t currentRelaxedOrderingQueueSize = 0;
DirectSubmissionSfenceMode sfenceMode = DirectSubmissionSfenceMode::BeforeAndAfterSemaphore;
DirectSubmissionSfenceMode sfenceMode = DirectSubmissionSfenceMode::beforeAndAfterSemaphore;
volatile uint32_t reserved = 0u;
uint32_t dispatchErrorCode = 0;
QueueThrottle lastSubmittedThrottle = QueueThrottle::MEDIUM;

100
shared/source/direct_submission/direct_submission_hw.inl
View File

@@ -131,7 +131,7 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeSetMMIO<GfxFamily>::encodeREG(schedulerCmdStream, RegisterOffsets::csGprR0, RegisterOffsets::csGprR9);
EncodeSetMMIO<GfxFamily>::encodeREG(schedulerCmdStream, RegisterOffsets::csGprR0 + 4, RegisterOffsets::csGprR9 + 4);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(schedulerCmdStream, 0, RegisterOffsets::csGprR1, 0, CompareOperation::Equal, true, false);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(schedulerCmdStream, 0, RegisterOffsets::csGprR1, 0, CompareOperation::equal, true, false);
LriHelper<GfxFamily>::program(&schedulerCmdStream, RegisterOffsets::csGprR2, 0, true);
LriHelper<GfxFamily>::program(&schedulerCmdStream, RegisterOffsets::csGprR2 + 4, 0, true);
@@ -159,16 +159,16 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeAluHelper<GfxFamily, 10> aluHelper;
aluHelper.setMocs(miMathMocs);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_2);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_6);
aluHelper.setNextAlu(AluRegisters::OPCODE_SHL);
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_7);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_8);
aluHelper.setNextAlu(AluRegisters::OPCODE_ADD);
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_6, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOADIND, AluRegisters::R_0, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::OPCODE_FENCE_RD);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr2);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr6);
aluHelper.setNextAlu(AluRegisters::opcodeShl);
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::accu);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr7);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr8);
aluHelper.setNextAlu(AluRegisters::opcodeAdd);
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr6, AluRegisters::accu);
aluHelper.setNextAlu(AluRegisters::opcodeLoadind, AluRegisters::gpr0, AluRegisters::accu);
aluHelper.setNextAlu(AluRegisters::opcodeFenceRd);
aluHelper.copyToCmdStream(schedulerCmdStream);
@@ -181,13 +181,13 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeMiPredicate<GfxFamily>::encode(schedulerCmdStream, MiPredicateType::disable);
EncodeMathMMIO<GfxFamily>::encodeDecrement(schedulerCmdStream, AluRegisters::R_1);
EncodeMathMMIO<GfxFamily>::encodeDecrement(schedulerCmdStream, AluRegisters::R_2);
EncodeMathMMIO<GfxFamily>::encodeDecrement(schedulerCmdStream, AluRegisters::gpr1);
EncodeMathMMIO<GfxFamily>::encodeDecrement(schedulerCmdStream, AluRegisters::gpr2);
EncodeSetMMIO<GfxFamily>::encodeREG(schedulerCmdStream, RegisterOffsets::csGprR0, RegisterOffsets::csGprR9);
EncodeSetMMIO<GfxFamily>::encodeREG(schedulerCmdStream, RegisterOffsets::csGprR0 + 4, RegisterOffsets::csGprR9 + 4);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(schedulerCmdStream, 0, RegisterOffsets::csGprR1, 0, CompareOperation::Equal, true, false);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(schedulerCmdStream, 0, RegisterOffsets::csGprR1, 0, CompareOperation::equal, true, false);
LriHelper<GfxFamily>::program(&schedulerCmdStream, RegisterOffsets::csGprR7, 8, true);
LriHelper<GfxFamily>::program(&schedulerCmdStream, RegisterOffsets::csGprR7 + 4, 0, true);
@@ -197,20 +197,20 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeAluHelper<GfxFamily, 14> aluHelper;
aluHelper.setMocs(miMathMocs);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_1);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_7);
aluHelper.setNextAlu(AluRegisters::OPCODE_SHL);
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_7);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_8);
aluHelper.setNextAlu(AluRegisters::OPCODE_ADD);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOADIND, AluRegisters::R_7, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::OPCODE_FENCE_RD);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_6);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD0, AluRegisters::R_SRCB, AluRegisters::OPCODE_NONE);
aluHelper.setNextAlu(AluRegisters::OPCODE_ADD);
aluHelper.setNextAlu(AluRegisters::OPCODE_STOREIND, AluRegisters::R_ACCU, AluRegisters::R_7);
aluHelper.setNextAlu(AluRegisters::OPCODE_FENCE_WR);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr1);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr7);
aluHelper.setNextAlu(AluRegisters::opcodeShl);
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::accu);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr7);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr8);
aluHelper.setNextAlu(AluRegisters::opcodeAdd);
aluHelper.setNextAlu(AluRegisters::opcodeLoadind, AluRegisters::gpr7, AluRegisters::accu);
aluHelper.setNextAlu(AluRegisters::opcodeFenceRd);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr6);
aluHelper.setNextAlu(AluRegisters::opcodeLoad0, AluRegisters::srcb, AluRegisters::opcodeNone);
aluHelper.setNextAlu(AluRegisters::opcodeAdd);
aluHelper.setNextAlu(AluRegisters::opcodeStoreind, AluRegisters::accu, AluRegisters::gpr7);
aluHelper.setNextAlu(AluRegisters::opcodeFenceWr);
aluHelper.copyToCmdStream(schedulerCmdStream);
}
@@ -221,12 +221,12 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeMiPredicate<GfxFamily>::encode(schedulerCmdStream, MiPredicateType::disable);
EncodeMathMMIO<GfxFamily>::encodeIncrement(schedulerCmdStream, AluRegisters::R_2);
EncodeMathMMIO<GfxFamily>::encodeIncrement(schedulerCmdStream, AluRegisters::gpr2);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalRegRegBatchBufferStart(
schedulerCmdStream,
loopSectionStartAddress,
AluRegisters::R_1, AluRegisters::R_2, CompareOperation::NotEqual, false);
AluRegisters::gpr1, AluRegisters::gpr2, CompareOperation::notEqual, false);
LriHelper<GfxFamily>::program(&schedulerCmdStream, RegisterOffsets::csGprR2, 0, true);
LriHelper<GfxFamily>::program(&schedulerCmdStream, RegisterOffsets::csGprR2 + 4, 0, true);
@@ -250,12 +250,12 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(
schedulerCmdStream,
loopSectionStartAddress,
RegisterOffsets::csGprR1, currentRelaxedOrderingQueueSize, CompareOperation::GreaterOrEqual, false, false);
RegisterOffsets::csGprR1, currentRelaxedOrderingQueueSize, CompareOperation::greaterOrEqual, false, false);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(
schedulerCmdStream,
loopSectionStartAddress,
RegisterOffsets::csGprR5, 1, CompareOperation::Equal, false, false);
RegisterOffsets::csGprR5, 1, CompareOperation::equal, false, false);
}
// 6. Scheduler loop check section
@@ -267,13 +267,13 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchStaticRelaxedOrderingSch
EncodeAluHelper<GfxFamily, 4> aluHelper;
aluHelper.setMocs(miMathMocs);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_9);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_10);
aluHelper.setNextAlu(AluRegisters::OPCODE_ADD);
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_0, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr9);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr10);
aluHelper.setNextAlu(AluRegisters::opcodeAdd);
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr0, AluRegisters::accu);
aluHelper.copyToCmdStream(schedulerCmdStream);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalRegMemBatchBufferStart(schedulerCmdStream, 0, semaphoreGpuVa, RegisterOffsets::csGprR11, CompareOperation::GreaterOrEqual, true);
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalRegMemBatchBufferStart(schedulerCmdStream, 0, semaphoreGpuVa, RegisterOffsets::csGprR11, CompareOperation::greaterOrEqual, true);
EncodeBatchBufferStartOrEnd<GfxFamily>::programBatchBufferStart(&schedulerCmdStream, schedulerStartAddress + RelaxedOrderingHelper::StaticSchedulerSizeAndOffsetSection<GfxFamily>::loopStartSectionStart,
false, false, false);
@@ -420,7 +420,7 @@ bool DirectSubmissionHw<GfxFamily, Dispatcher>::makeResourcesResident(DirectSubm
template <typename GfxFamily, typename Dispatcher>
inline void DirectSubmissionHw<GfxFamily, Dispatcher>::unblockGpu() {
if (sfenceMode >= DirectSubmissionSfenceMode::BeforeSemaphoreOnly) {
if (sfenceMode >= DirectSubmissionSfenceMode::beforeSemaphoreOnly) {
CpuIntrinsics::sfence();
}
@@ -430,7 +430,7 @@ inline void DirectSubmissionHw<GfxFamily, Dispatcher>::unblockGpu() {
semaphoreData->queueWorkCount = currentQueueWorkCount;
if (sfenceMode == DirectSubmissionSfenceMode::BeforeAndAfterSemaphore) {
if (sfenceMode == DirectSubmissionSfenceMode::beforeAndAfterSemaphore) {
CpuIntrinsics::sfence();
}
}
@@ -800,7 +800,7 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::dispatchRelaxedOrderingQueueStal
// patch conditional bb_start with current GPU address
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataRegBatchBufferStart(bbStartStream, ringCommandStream.getCurrentGpuAddressPosition(),
RegisterOffsets::csGprR1, 0, CompareOperation::Equal, false, false);
RegisterOffsets::csGprR1, 0, CompareOperation::equal, false, false);
relaxedOrderingSchedulerRequired = false;
}
@@ -857,19 +857,19 @@ void DirectSubmissionHw<GfxFamily, Dispatcher>::preinitializeRelaxedOrderingSect
EncodeAluHelper<GfxFamily, 9> aluHelper;
aluHelper.setMocs(miMathMocs);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_1);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_8);
aluHelper.setNextAlu(AluRegisters::OPCODE_SHL);
aluHelper.setNextAlu(AluRegisters::OPCODE_STORE, AluRegisters::R_8, AluRegisters::R_ACCU);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_8);
aluHelper.setNextAlu(AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_6);
aluHelper.setNextAlu(AluRegisters::OPCODE_ADD);
aluHelper.setNextAlu(AluRegisters::OPCODE_STOREIND, AluRegisters::R_ACCU, AluRegisters::R_7);
aluHelper.setNextAlu(AluRegisters::OPCODE_FENCE_WR);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr1);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr8);
aluHelper.setNextAlu(AluRegisters::opcodeShl);
aluHelper.setNextAlu(AluRegisters::opcodeStore, AluRegisters::gpr8, AluRegisters::accu);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr8);
aluHelper.setNextAlu(AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr6);
aluHelper.setNextAlu(AluRegisters::opcodeAdd);
aluHelper.setNextAlu(AluRegisters::opcodeStoreind, AluRegisters::accu, AluRegisters::gpr7);
aluHelper.setNextAlu(AluRegisters::opcodeFenceWr);
aluHelper.copyToCmdStream(stream);
EncodeMathMMIO<GfxFamily>::encodeIncrement(stream, AluRegisters::R_1);
EncodeMathMMIO<GfxFamily>::encodeIncrement(stream, AluRegisters::gpr1);
UNRECOVERABLE_IF(stream.getUsed() != RelaxedOrderingHelper::getSizeTaskStoreSection<GfxFamily>());

8
shared/source/helpers/blit_helper.cpp
View File

@@ -30,7 +30,7 @@ BlitOperationResult BlitHelper::blitMemoryToAllocationBanks(const Device &device
const Vec3<size_t> &size, DeviceBitfield memoryBanks) {
const auto &hwInfo = device.getHardwareInfo();
if (!hwInfo.capabilityTable.blitterOperationsSupported) {
return BlitOperationResult::Unsupported;
return BlitOperationResult::unsupported;
}
auto &gfxCoreHelper = device.getGfxCoreHelper();
@@ -52,7 +52,7 @@ BlitOperationResult BlitHelper::blitMemoryToAllocationBanks(const Device &device
auto bcsEngineUsage = gfxCoreHelper.preferInternalBcsEngine() ? EngineUsage::internal : EngineUsage::regular;
auto bcsEngine = pDeviceForBlit->tryGetEngine(bcsEngineType, bcsEngineUsage);
if (!bcsEngine) {
return BlitOperationResult::Unsupported;
return BlitOperationResult::unsupported;
}
bcsEngine->commandStreamReceiver->initializeResources();
@@ -67,11 +67,11 @@ BlitOperationResult BlitHelper::blitMemoryToAllocationBanks(const Device &device
const auto newTaskCount = bcsEngine->commandStreamReceiver->flushBcsTask(blitPropertiesContainer, true, false, *pDeviceForBlit);
if (newTaskCount == CompletionStamp::gpuHang) {
return BlitOperationResult::GpuHang;
return BlitOperationResult::gpuHang;
}
}
return BlitOperationResult::Success;
return BlitOperationResult::success;
}
} // namespace NEO

10
shared/source/helpers/blit_helper.h
View File

@@ -17,10 +17,10 @@ class Device;
class GraphicsAllocation;
enum class BlitOperationResult {
Unsupported,
Fail,
Success,
GpuHang
unsupported,
fail,
success,
gpuHang
};
namespace BlitHelperFunctions {
@@ -39,4 +39,4 @@ struct BlitHelper {
const Vec3<size_t> &size, DeviceBitfield memoryBanks);
};
} // namespace NEO
} // namespace NEO

68
shared/source/helpers/register_offsets.h
View File

@@ -55,42 +55,42 @@ inline constexpr uint32_t globalTimestampUn = 0x235c;
// Alu opcodes
enum class AluRegisters : uint32_t {
OPCODE_NONE = 0x000,
OPCODE_FENCE_RD = 0x001,
OPCODE_FENCE_WR = 0x002,
opcodeNone = 0x000,
opcodeFenceRd = 0x001,
opcodeFenceWr = 0x002,
OPCODE_LOAD = 0x080,
OPCODE_LOAD0 = 0x081,
OPCODE_LOADIND = 0x082,
OPCODE_STORE = 0x180,
OPCODE_ADD = 0x100,
OPCODE_SUB = 0x101,
OPCODE_AND = 0x102,
OPCODE_OR = 0x103,
opcodeLoad = 0x080,
opcodeLoad0 = 0x081,
opcodeLoadind = 0x082,
opcodeStore = 0x180,
opcodeAdd = 0x100,
opcodeSub = 0x101,
opcodeAnd = 0x102,
opcodeOr = 0x103,
OPCODE_SHL = 0x105,
OPCODE_STOREIND = 0x181,
opcodeShl = 0x105,
opcodeStoreind = 0x181,
R_0 = 0x0,
R_1 = 0x1,
R_2 = 0x2,
R_3 = 0x3,
R_4 = 0x4,
R_5 = 0x5,
R_6 = 0x6,
R_7 = 0x7,
R_8 = 0x8,
R_9 = 0x9,
R_10 = 0xA,
R_11 = 0xB,
R_12 = 0xC,
R_13 = 0xD,
R_14 = 0xE,
R_15 = 0xF,
gpr0 = 0x0,
gpr1 = 0x1,
gpr2 = 0x2,
gpr3 = 0x3,
gpr4 = 0x4,
gpr5 = 0x5,
gpr6 = 0x6,
gpr7 = 0x7,
gpr8 = 0x8,
gpr9 = 0x9,
gpr10 = 0xA,
gpr11 = 0xB,
gpr12 = 0xC,
gpr13 = 0xD,
gpr14 = 0xE,
gpr15 = 0xF,
R_SRCA = 0x20,
R_SRCB = 0x21,
R_ACCU = 0x31,
R_ZF = 0x32,
R_CF = 0x33
srca = 0x20,
srcb = 0x21,
accu = 0x31,
zf = 0x32,
cf = 0x33
};

2
shared/source/helpers/timestamp_packet.h
View File

@@ -116,7 +116,7 @@ struct TimestampPacketHelper {
uint64_t compareOffset = packetId * timestampPacketNode.getSinglePacketSize();
EncodeBatchBufferStartOrEnd<GfxFamily>::programConditionalDataMemBatchBufferStart(cmdStream, 0, compareAddress + compareOffset, TimestampPacketConstants::initValue,
NEO::CompareOperation::Equal, true, false);
NEO::CompareOperation::equal, true, false);
}
}

4
shared/source/memory_manager/memory_manager.cpp
View File

@@ -1034,7 +1034,7 @@ bool MemoryManager::allocateBindlessSlot(GraphicsAllocation *allocation) {
bool MemoryTransferHelper::transferMemoryToAllocation(bool useBlitter, const Device &device, GraphicsAllocation *dstAllocation, size_t dstOffset, const void *srcMemory, size_t srcSize) {
if (useBlitter) {
if (BlitHelperFunctions::blitMemoryToAllocation(device, dstAllocation, dstOffset, srcMemory, {srcSize, 1, 1}) == BlitOperationResult::Success) {
if (BlitHelperFunctions::blitMemoryToAllocation(device, dstAllocation, dstOffset, srcMemory, {srcSize, 1, 1}) == BlitOperationResult::success) {
return true;
}
}
@@ -1042,7 +1042,7 @@ bool MemoryTransferHelper::transferMemoryToAllocation(bool useBlitter, const Dev
}
bool MemoryTransferHelper::transferMemoryToAllocationBanks(const Device &device, GraphicsAllocation *dstAllocation, size_t dstOffset, const void *srcMemory,
size_t srcSize, DeviceBitfield dstMemoryBanks) {
auto blitSuccess = BlitHelper::blitMemoryToAllocationBanks(device, dstAllocation, dstOffset, srcMemory, {srcSize, 1, 1}, dstMemoryBanks) == BlitOperationResult::Success;
auto blitSuccess = BlitHelper::blitMemoryToAllocationBanks(device, dstAllocation, dstOffset, srcMemory, {srcSize, 1, 1}, dstMemoryBanks) == BlitOperationResult::success;
if (!blitSuccess) {
return device.getMemoryManager()->copyMemoryToAllocationBanks(dstAllocation, dstOffset, srcMemory, srcSize, dstMemoryBanks);

30
shared/test/common/helpers/relaxed_ordering_commands_helper.h
View File

@@ -95,27 +95,27 @@ bool verifyIncrementOrDecrement(void *cmds, AluRegisters aluRegister, bool incre
}
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, aluRegister)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, aluRegister)) {
return false;
}
miAluCmd++;
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_7)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr7)) {
return false;
}
miAluCmd++;
if (increment && !verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_ADD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (increment && !verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeAdd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!increment && !verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_SUB, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!increment && !verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeSub, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
miAluCmd++;
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_STORE, aluRegister, AluRegisters::R_ACCU)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeStore, aluRegister, AluRegisters::accu)) {
return false;
}
@@ -163,28 +163,28 @@ bool verifyBaseConditionalBbStart(void *cmd, CompareOperation compareOperation,
}
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, regA)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, regA)) {
return false;
}
miAluCmd++;
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, regB)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, regB)) {
return false;
}
miAluCmd++;
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_SUB, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeSub, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
miAluCmd++;
if (compareOperation == CompareOperation::Equal || compareOperation == CompareOperation::NotEqual) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_ZF)) {
if (compareOperation == CompareOperation::equal || compareOperation == CompareOperation::notEqual) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::zf)) {
return false;
}
} else {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_CF)) {
if (!verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::cf)) {
return false;
}
}
@@ -195,7 +195,7 @@ bool verifyBaseConditionalBbStart(void *cmd, CompareOperation compareOperation,
}
auto predicateCmd = reinterpret_cast<MI_SET_PREDICATE *>(++lrrCmd);
if ((compareOperation == CompareOperation::Equal) || (compareOperation == CompareOperation::Less)) {
if ((compareOperation == CompareOperation::equal) || (compareOperation == CompareOperation::less)) {
if (!verifyMiPredicate<FamilyType>(predicateCmd, MiPredicateType::noopOnResult2Clear)) {
return false;
}
@@ -259,7 +259,7 @@ bool verifyConditionalDataMemBbStart(void *cmd, uint64_t startAddress, uint64_t
return false;
}
return verifyBaseConditionalBbStart<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
return verifyBaseConditionalBbStart<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
template <typename FamilyType>
@@ -288,7 +288,7 @@ bool verifyConditionalDataRegBbStart(void *cmds, uint64_t startAddress, uint32_t
return false;
}
return verifyBaseConditionalBbStart<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
return verifyBaseConditionalBbStart<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
template <typename FamilyType>
@@ -318,7 +318,7 @@ bool verifyConditionalRegMemBbStart(void *cmds, uint64_t startAddress, uint64_t
return false;
}
return verifyBaseConditionalBbStart<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
return verifyBaseConditionalBbStart<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
} // namespace RelaxedOrderingCommandsHelper

4
shared/test/common/mocks/mock_compiler_interface.h
View File

@@ -132,7 +132,7 @@ class MockCompilerInterface : public CompilerInterface {
if (this->sipKernelBinaryOverride.size() > 0) {
retBinary = this->sipKernelBinaryOverride;
this->requestedSipKernel = type;
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
} else {
return CompilerInterface::getSipKernelBinary(device, type, retBinary, stateAreaHeader);
}
@@ -200,7 +200,7 @@ struct MockCompilerInterfaceCaptureBuildOptions : CompilerInterface {
copy(out.deviceBinary, output.intermediateRepresentation);
out.intermediateCodeType = output.intermediateCodeType;
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode build(const NEO::Device &device, const TranslationInput &input, TranslationOutput &out) override {

2
shared/test/common/mocks/mock_compiler_interface_spirv.cpp
View File

@@ -25,7 +25,7 @@ TranslationOutput::ErrorCode MockCompilerInterfaceSpirv::compile(const NEO::Devi
output.deviceBinary.size = size;
output.intermediateCodeType = IGC::CodeType::spirV;
return TranslationOutput::ErrorCode::Success;
return TranslationOutput::ErrorCode::success;
}
TranslationOutput::ErrorCode MockCompilerInterfaceSpirv::build(const NEO::Device &device, const TranslationInput &input, TranslationOutput &out) {
return this->compile(device, input, out);

4
shared/test/common/mocks/mock_elf.h
View File

@@ -91,7 +91,7 @@ struct MockElfEncoder : public NEO::Elf::ElfEncoder<numBits> {
NEO::Elf::ElfRela<NEO::Elf::ELF_IDENTIFIER_CLASS::EI_CLASS_64> relocationsWithAddend;
relocationsWithAddend.addend = 0x1a8;
relocationsWithAddend.info = static_cast<decltype(relocationsWithAddend.info)>(textSectionIndex) << 32 | uint32_t(NEO::Elf::RELOCATION_X8664_TYPE::R_X8664_64);
relocationsWithAddend.info = static_cast<decltype(relocationsWithAddend.info)>(textSectionIndex) << 32 | uint32_t(NEO::Elf::RELOCATION_X8664_TYPE::relocation64);
relocationsWithAddend.offset = 8;
elfEncoder.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SpecialSectionNames::debugInfo, ArrayRef<const uint8_t>(dummyData, sizeof(dummyData)));
@@ -108,7 +108,7 @@ struct MockElfEncoder : public NEO::Elf::ElfEncoder<numBits> {
relaDebugSection->info = debugSectionIndex;
relocationsWithAddend.addend = 0;
relocationsWithAddend.info = static_cast<decltype(relocationsWithAddend.info)>(textSectionIndex) << 32 | uint32_t(NEO::Elf::RELOCATION_X8664_TYPE::R_X8664_64);
relocationsWithAddend.info = static_cast<decltype(relocationsWithAddend.info)>(textSectionIndex) << 32 | uint32_t(NEO::Elf::RELOCATION_X8664_TYPE::relocation64);
relocationsWithAddend.offset = 0;
elfEncoder.appendSection(NEO::Elf::SHT_RELA, NEO::Elf::SpecialSectionNames::relaPrefix.str() + NEO::Elf::SpecialSectionNames::debug.str() + "_line",

8
shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp
View File

@@ -358,7 +358,7 @@ TEST(CompilerInterfaceCachedTests, GivenNoCachedBinaryWhenBuildingThenErrorIsRet
inputArgs.allowCaching = true;
MockDevice device;
auto err = compilerInterface->build(device, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::BuildFailure, err);
EXPECT_EQ(TranslationOutput::ErrorCode::buildFailure, err);
gEnvironment->fclPopDebugVars();
gEnvironment->igcPopDebugVars();
@@ -387,7 +387,7 @@ TEST(CompilerInterfaceCachedTests, GivenCachedBinaryWhenBuildingThenSuccessIsRet
TranslationOutput translationOutput;
MockDevice device;
auto err = compilerInterface->build(device, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
gEnvironment->fclPopDebugVars();
gEnvironment->igcPopDebugVars();
@@ -418,7 +418,7 @@ TEST(CompilerInterfaceCachedTests, givenKernelWithoutIncludesAndBinaryInCacheWhe
TranslationOutput translationOutput;
inputArgs.allowCaching = true;
auto retVal = compilerInterface->build(device, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, retVal);
EXPECT_EQ(TranslationOutput::ErrorCode::success, retVal);
gEnvironment->fclPopDebugVars();
gEnvironment->igcPopDebugVars();
@@ -442,7 +442,7 @@ TEST(CompilerInterfaceCachedTests, givenKernelWithIncludesAndBinaryInCacheWhenCo
TranslationOutput translationOutput;
inputArgs.allowCaching = true;
auto retVal = compilerInterface->build(device, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::BuildFailure, retVal);
EXPECT_EQ(TranslationOutput::ErrorCode::buildFailure, retVal);
gEnvironment->fclPopDebugVars();
}

80
shared/test/unit_test/compiler_interface/compiler_interface_tests.cpp
View File

@@ -153,7 +153,7 @@ TEST(CompilerInterfaceCreateInstance, WhenInitializeFailedThenReturnNull) {
TEST_F(CompilerInterfaceTest, WhenCompilingToIsaThenSuccessIsReturned) {
TranslationOutput translationOutput;
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
}
TEST_F(CompilerInterfaceTest, WhenPreferredIntermediateRepresentationSpecifiedThenPreserveIt) {
@@ -165,14 +165,14 @@ TEST_F(CompilerInterfaceTest, WhenPreferredIntermediateRepresentationSpecifiedTh
inputArgs.preferredIntermediateType = IGC::CodeType::llvmLl;
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(IGC::CodeType::llvmLl, translationOutput.intermediateCodeType);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
}
TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenBuildFailsGracefully) {
pCompilerInterface->igcMain.reset(nullptr);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilerNotAvailable, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilerNotAvailable, err);
}
TEST_F(CompilerInterfaceTest, whenFclTranslatorReturnsNullptrThenBuildFailsGracefully) {
@@ -184,7 +184,7 @@ TEST_F(CompilerInterfaceTest, whenFclTranslatorReturnsNullptrThenBuildFailsGrace
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
pCompilerInterface->failCreateFclTranslationCtx = false;
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
}
TEST_F(CompilerInterfaceTest, whenIgcTranslatorReturnsNullptrThenBuildFailsGracefully) {
@@ -196,7 +196,7 @@ TEST_F(CompilerInterfaceTest, whenIgcTranslatorReturnsNullptrThenBuildFailsGrace
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
pCompilerInterface->failCreateIgcTranslationCtx = true;
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
}
TEST_F(CompilerInterfaceTest, GivenOptionsWhenCompilingToIsaThenSuccessIsReturned) {
@@ -216,7 +216,7 @@ TEST_F(CompilerInterfaceTest, GivenOptionsWhenCompilingToIsaThenSuccessIsReturne
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
gEnvironment->fclPopDebugVars();
gEnvironment->igcPopDebugVars();
@@ -228,7 +228,7 @@ TEST_F(CompilerInterfaceTest, WhenCompilingToIrThenSuccessIsReturned) {
gEnvironment->fclPushDebugVars(fclDebugVars);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
gEnvironment->fclPopDebugVars();
}
@@ -237,19 +237,19 @@ TEST_F(CompilerInterfaceTest, GivenProgramCreatedFromIrWhenCompileIsCalledThenDo
TranslationOutput translationOutput = {};
inputArgs.srcType = IGC::CodeType::spirV;
auto err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::AlreadyCompiled, err);
EXPECT_EQ(TranslationOutput::ErrorCode::alreadyCompiled, err);
inputArgs.srcType = IGC::CodeType::llvmBc;
err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::AlreadyCompiled, err);
EXPECT_EQ(TranslationOutput::ErrorCode::alreadyCompiled, err);
inputArgs.srcType = IGC::CodeType::llvmLl;
err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::AlreadyCompiled, err);
EXPECT_EQ(TranslationOutput::ErrorCode::alreadyCompiled, err);
inputArgs.srcType = IGC::CodeType::oclGenBin;
err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::AlreadyCompiled, err);
EXPECT_EQ(TranslationOutput::ErrorCode::alreadyCompiled, err);
}
TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenCompileFailsGracefully) {
@@ -260,7 +260,7 @@ TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenCompileFailsGraceful
pCompilerInterface->setIgcMain(nullptr);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilerNotAvailable, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilerNotAvailable, err);
gEnvironment->fclPopDebugVars();
}
@@ -273,7 +273,7 @@ TEST_F(CompilerInterfaceTest, whenFclTranslatorReturnsNullptrThenCompileFailsGra
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
pCompilerInterface->failCreateFclTranslationCtx = false;
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
gEnvironment->fclPopDebugVars();
}
@@ -285,7 +285,7 @@ TEST_F(CompilerInterfaceTest, GivenForceBuildFailureWhenCompilingToIrThenCompila
gEnvironment->fclPushDebugVars(fclDebugVars);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->compile(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilationFailure, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilationFailure, err);
gEnvironment->fclPopDebugVars();
}
@@ -297,7 +297,7 @@ TEST_F(CompilerInterfaceTest, GivenForceBuildFailureWhenLinkingIrThenLinkFailure
gEnvironment->igcPushDebugVars(igcDebugVars);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->link(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::LinkFailure, err);
EXPECT_EQ(TranslationOutput::ErrorCode::linkFailure, err);
gEnvironment->igcPopDebugVars();
}
@@ -310,7 +310,7 @@ TEST_F(CompilerInterfaceTest, WhenLinkIsCalledThenOclGenBinIsTheTranslationTarge
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->link(*pDevice, inputArgs, translationOutput);
gEnvironment->igcPopDebugVars();
ASSERT_EQ(TranslationOutput::ErrorCode::Success, err);
ASSERT_EQ(TranslationOutput::ErrorCode::success, err);
ASSERT_EQ(1u, pCompilerInterface->requestedTranslationCtxs.size());
MockCompilerInterface::TranslationOpT translation = {IGC::CodeType::elf, IGC::CodeType::oclGenBin};
@@ -325,7 +325,7 @@ TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenLinkFailsGracefully)
pCompilerInterface->setIgcMain(nullptr);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->link(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilerNotAvailable, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilerNotAvailable, err);
gEnvironment->igcPopDebugVars();
}
@@ -338,7 +338,7 @@ TEST_F(CompilerInterfaceTest, whenSrcAllocationFailsThenLinkFailsGracefully) {
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->link(*pDevice, inputArgs, translationOutput);
MockCIFBuffer::failAllocations = false;
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
gEnvironment->igcPopDebugVars();
}
@@ -351,7 +351,7 @@ TEST_F(CompilerInterfaceTest, whenTranslateReturnsNullptrThenLinkFailsGracefully
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->link(*pDevice, inputArgs, translationOutput);
pCompilerInterface->failCreateIgcTranslationCtx = false;
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
gEnvironment->igcPopDebugVars();
}
@@ -364,7 +364,7 @@ TEST_F(CompilerInterfaceTest, GivenForceBuildFailureWhenCreatingLibraryThenLinkF
gEnvironment->igcPushDebugVars(igcDebugVars);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->createLibrary(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::LinkFailure, err);
EXPECT_EQ(TranslationOutput::ErrorCode::linkFailure, err);
gEnvironment->igcPopDebugVars();
}
@@ -377,7 +377,7 @@ TEST_F(CompilerInterfaceTest, WhenCreateLibraryIsCalledThenLlvmBcIsUsedAsInterme
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->createLibrary(*pDevice, inputArgs, translationOutput);
gEnvironment->igcPopDebugVars();
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
ASSERT_EQ(1U, pCompilerInterface->requestedTranslationCtxs.size());
EXPECT_EQ(IGC::CodeType::llvmBc, pCompilerInterface->requestedTranslationCtxs[0].second);
@@ -391,7 +391,7 @@ TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenCreateLibraryFailsGr
pCompilerInterface->setIgcMain(nullptr);
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->createLibrary(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilerNotAvailable, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilerNotAvailable, err);
gEnvironment->igcPopDebugVars();
}
@@ -404,7 +404,7 @@ TEST_F(CompilerInterfaceTest, whenIgcTranslatorReturnsNullptrThenCreateLibraryFa
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->createLibrary(*pDevice, inputArgs, translationOutput);
pCompilerInterface->failCreateIgcTranslationCtx = false;
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
gEnvironment->igcPopDebugVars();
}
@@ -424,7 +424,7 @@ TEST_F(CompilerInterfaceTest, GivenForceBuildFailureWhenFclBuildingThenBuildFail
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::BuildFailure, err);
EXPECT_EQ(TranslationOutput::ErrorCode::buildFailure, err);
gEnvironment->fclPopDebugVars();
}
@@ -444,7 +444,7 @@ TEST_F(CompilerInterfaceTest, GivenForceBuildFailureWhenIgcBuildingThenBuildFail
TranslationOutput translationOutput = {};
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::BuildFailure, err);
EXPECT_EQ(TranslationOutput::ErrorCode::buildFailure, err);
gEnvironment->igcPopDebugVars();
}
@@ -760,7 +760,7 @@ TEST_F(CompilerInterfaceTest, givenUpdatedSpecConstValuesWhenBuildProgramThenPro
TranslationOutput translationOutput;
auto err = pCompilerInterface->build(*pDevice, inputArgs, translationOutput);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
}
TEST_F(CompilerInterfaceTest, GivenRequestForNewFclTranslationCtxWhenDeviceCtxIsNotAvailableThenCreateNewDeviceCtxAndUseItToReturnValidTranslationCtx) {
@@ -1010,7 +1010,7 @@ TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenGetSipKernelBinaryFa
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::csr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilerNotAvailable, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilerNotAvailable, err);
EXPECT_EQ(0U, sipBinary.size());
}
@@ -1022,7 +1022,7 @@ TEST_F(CompilerInterfaceTest, whenIgcReturnsErrorThenGetSipKernelBinaryFailsGrac
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::csr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
EXPECT_EQ(0U, sipBinary.size());
gEnvironment->igcPopDebugVars();
@@ -1034,7 +1034,7 @@ TEST_F(CompilerInterfaceTest, whenGetIgcDeviceCtxReturnsNullptrThenGetSipKernelB
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::csr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
}
TEST_F(CompilerInterfaceTest, whenEverythingIsOkThenGetSipKernelReturnsIgcsOutputAsSipBinary) {
@@ -1044,7 +1044,7 @@ TEST_F(CompilerInterfaceTest, whenEverythingIsOkThenGetSipKernelReturnsIgcsOutpu
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::csr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
gEnvironment->igcPopDebugVars();
@@ -1056,17 +1056,17 @@ TEST_F(CompilerInterfaceTest, whenRequestingSipKernelBinaryThenProperSystemRouti
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::csr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::contextSaveRestore, getIgcDebugVars().typeOfSystemRoutine);
err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::dbgCsr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::debug, getIgcDebugVars().typeOfSystemRoutine);
err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::dbgCsrLocal, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::debugSlm, getIgcDebugVars().typeOfSystemRoutine);
@@ -1079,19 +1079,19 @@ TEST_F(CompilerInterfaceTest, WhenRequestingBindlessDebugSipThenProperSystemRout
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::csr, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::contextSaveRestore, getIgcDebugVars().typeOfSystemRoutine);
EXPECT_EQ(MockCompilerDebugVars::SipAddressingType::bindful, getIgcDebugVars().receivedSipAddressingType);
err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::dbgCsrLocal, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::debugSlm, getIgcDebugVars().typeOfSystemRoutine);
EXPECT_EQ(MockCompilerDebugVars::SipAddressingType::bindful, getIgcDebugVars().receivedSipAddressingType);
err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::dbgBindless, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
EXPECT_NE(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::debug, getIgcDebugVars().typeOfSystemRoutine);
EXPECT_EQ(MockCompilerDebugVars::SipAddressingType::bindless, getIgcDebugVars().receivedSipAddressingType);
@@ -1105,7 +1105,7 @@ TEST_F(CompilerInterfaceTest, whenRequestingInvalidSipKernelBinaryThenErrorIsRet
std::vector<char> sipBinary;
std::vector<char> stateAreaHeader;
auto err = pCompilerInterface->getSipKernelBinary(*this->pDevice, SipKernelType::count, sipBinary, stateAreaHeader);
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
EXPECT_EQ(0U, sipBinary.size());
EXPECT_EQ(IGC::SystemRoutineType::undefined, getIgcDebugVars().typeOfSystemRoutine);
@@ -1116,7 +1116,7 @@ TEST_F(CompilerInterfaceTest, whenCompilerIsNotAvailableThenGetSpecializationCon
pCompilerInterface->igcMain.reset();
NEO::SpecConstantInfo sci;
auto err = pCompilerInterface->getSpecConstantsInfo(*pDevice, ArrayRef<char>{}, sci);
EXPECT_EQ(TranslationOutput::ErrorCode::CompilerNotAvailable, err);
EXPECT_EQ(TranslationOutput::ErrorCode::compilerNotAvailable, err);
}
TEST_F(CompilerInterfaceTest, givenCompilerInterfacewhenGettingIgcFeaturesAndWorkaroundsThenValidPointerIsReturned) {
@@ -1233,14 +1233,14 @@ TEST_F(CompilerInterfaceTest, whenIgcTranlationContextCreationFailsThenErrorIsRe
pCompilerInterface->failCreateIgcTranslationCtx = true;
NEO::SpecConstantInfo specConstInfo;
auto err = pCompilerInterface->getSpecConstantsInfo(*pDevice, inputArgs.src, specConstInfo);
EXPECT_EQ(TranslationOutput::ErrorCode::UnknownError, err);
EXPECT_EQ(TranslationOutput::ErrorCode::unknownError, err);
}
TEST_F(CompilerInterfaceTest, givenCompilerInterfaceWhenGetSpecializationConstantsThenSuccesIsReturned) {
TranslationOutput translationOutput;
NEO::SpecConstantInfo specConstInfo;
auto err = pCompilerInterface->getSpecConstantsInfo(*pDevice, inputArgs.src, specConstInfo);
EXPECT_EQ(TranslationOutput::ErrorCode::Success, err);
EXPECT_EQ(TranslationOutput::ErrorCode::success, err);
}
struct UnknownInterfaceCIFMain : MockCIFMain {

58
shared/test/unit_test/compiler_interface/linker_tests.cpp
View File

@@ -750,7 +750,7 @@ HWTEST_F(LinkerTests, givenEmptyLinkerInputThenLinkerOutputIsEmpty) {
globalVar, globalConst, exportedFunc, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
EXPECT_EQ(0U, unresolvedExternals.size());
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -772,7 +772,7 @@ HWTEST_F(LinkerTests, givenInvalidLinkerInputThenLinkerFails) {
globalVar, globalConst, exportedFunc, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, extFuncs);
EXPECT_EQ(NEO::LinkingStatus::Error, linkResult);
EXPECT_EQ(NEO::LinkingStatus::error, linkResult);
}
HWTEST_F(LinkerTests, givenUnresolvedExternalSymbolsWhenResolveBuiltinsIsCalledThenSubDeviceIDSymbolsAreRemoved) {
@@ -886,7 +886,7 @@ HWTEST_F(LinkerTests, givenUnresolvedExternalWhenPatchingInstructionsThenLinkPar
globalVar, globalConst, exportedFunc, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedPartially, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, relocatedSymbols.size());
ASSERT_EQ(1U, unresolvedExternals.size());
@@ -997,7 +997,7 @@ HWTEST_F(LinkerTests, givenValidSymbolsAndRelocationsThenInstructionSegmentsAreP
globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, unresolvedExternals,
pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(3U, relocatedSymbols.size());
@@ -1061,7 +1061,7 @@ HWTEST_F(LinkerTests, givenInvalidSymbolOffsetWhenPatchingInstructionsThenReloca
globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::Error, linkResult);
EXPECT_EQ(NEO::LinkingStatus::error, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -1071,7 +1071,7 @@ HWTEST_F(LinkerTests, givenInvalidSymbolOffsetWhenPatchingInstructionsThenReloca
globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments, unresolvedExternals,
pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
}
HWTEST_F(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFails) {
@@ -1113,7 +1113,7 @@ HWTEST_F(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFail
globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedPartially, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(1U, relocatedSymbols.size());
ASSERT_EQ(1U, unresolvedExternals.size());
@@ -1124,7 +1124,7 @@ HWTEST_F(LinkerTests, givenInvalidRelocationOffsetThenPatchingOfInstructionsFail
globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
}
HWTEST_F(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocationFails) {
@@ -1168,7 +1168,7 @@ HWTEST_F(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocati
globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::Error, linkResult);
EXPECT_EQ(NEO::LinkingStatus::error, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, relocatedSymbols.size());
ASSERT_EQ(0U, unresolvedExternals.size());
@@ -1177,7 +1177,7 @@ HWTEST_F(LinkerTests, givenUnknownSymbolTypeWhenPatchingInstructionsThenRelocati
linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
}
HWTEST_F(LinkerTests, givenValidStringSymbolsAndRelocationsWhenPatchingThenItIsProperlyPatched) {
@@ -1216,7 +1216,7 @@ HWTEST_F(LinkerTests, givenValidStringSymbolsAndRelocationsWhenPatchingThenItIsP
{}, {}, {}, stringSegment,
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_TRUE(linker.extractRelocatedSymbols().empty());
@@ -1371,7 +1371,7 @@ HWTEST_F(LinkerTests, givenValidSymbolsAndRelocationsWhenPatchingDataSegmentsThe
&globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {},
unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData),
initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
EXPECT_EQ(0U, unresolvedExternals.size());
auto constantsAddr = globalConstantsSegmentInfo.gpuAddress;
@@ -1522,7 +1522,7 @@ HWTEST_F(LinkerTests, givenValidSymbolsAndRelocationsToBssDataSectionsWhenPatchi
&globalVariablesPatchableSegment, &globalConstantsPatchableSegment, patchableInstructionSegments,
unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData),
initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
EXPECT_EQ(0U, unresolvedExternals.size());
auto globalConstantsSegmentAddr = reinterpret_cast<uint64_t *>(globalConstantsPatchableSegment.getUnderlyingBuffer());
@@ -1569,7 +1569,7 @@ HWTEST_F(LinkerTests, givenInvalidSymbolWhenPatchingDataSegmentsThenRelocationIs
&globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {},
unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData,
sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedPartially, linkResult);
EXPECT_EQ(1U, unresolvedExternals.size());
}
@@ -1608,7 +1608,7 @@ HWTEST_F(LinkerTests, givenInvalidRelocationOffsetWhenPatchingDataSegmentsThenRe
&globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {},
unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData),
initGlobalVariablesData, sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedPartially, linkResult);
EXPECT_EQ(1U, unresolvedExternals.size());
}
@@ -1634,7 +1634,7 @@ HWTEST_F(LinkerTests, givenInvalidRelocationSegmentWhenPatchingDataSegmentsThenR
auto linkResult = linker.link(globalSegment, {}, {}, {},
nullptr, nullptr, {},
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedPartially, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedPartially, linkResult);
EXPECT_EQ(1U, unresolvedExternals.size());
}
@@ -1674,7 +1674,7 @@ HWTEST_F(LinkerTests, given32BitBinaryWithValidSymbolsAndRelocationsWhenPatching
&globalVariablesPatchableSegment, &globalConstantsPatchableSegment, {},
unresolvedExternals, pDevice, initGlobalConstantData, sizeof(initGlobalConstantData), initGlobalVariablesData,
sizeof(initGlobalVariablesData), kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(globalVariablesSegmentInfo.gpuAddress & 0xffffffff, *(uint32_t *)(globalConstantsSegmentInfo.gpuAddress));
@@ -1826,7 +1826,7 @@ TEST_F(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocation
NEO::Elf::Elf<NEO::Elf::EI_CLASS_64>::RelocationInfo reloc0 = {};
reloc0.offset = 64;
reloc0.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::R_X8664_64);
reloc0.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::relocation64);
reloc0.symbolName = ".debug_abbrev";
reloc0.symbolSectionIndex = 3;
reloc0.symbolTableIndex = 0;
@@ -1837,7 +1837,7 @@ TEST_F(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocation
NEO::Elf::Elf<NEO::Elf::EI_CLASS_64>::RelocationInfo reloc1 = {};
reloc1.offset = 32;
reloc1.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::R_X8664_32);
reloc1.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::relocation32);
reloc1.symbolName = ".debug_line";
reloc1.symbolSectionIndex = 4;
reloc1.symbolTableIndex = 0;
@@ -1848,7 +1848,7 @@ TEST_F(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocation
NEO::Elf::Elf<NEO::Elf::EI_CLASS_64>::RelocationInfo reloc2 = {};
reloc2.offset = 32;
reloc2.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::R_X8664_64);
reloc2.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::relocation64);
reloc2.symbolName = ".text";
reloc2.symbolSectionIndex = 0;
reloc2.symbolTableIndex = 0;
@@ -1859,7 +1859,7 @@ TEST_F(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocation
NEO::Elf::Elf<NEO::Elf::EI_CLASS_64>::RelocationInfo reloc3 = {};
reloc3.offset = 0;
reloc3.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::R_X8664_64);
reloc3.relocType = static_cast<uint32_t>(Elf::RELOCATION_X8664_TYPE::relocation64);
reloc3.symbolName = ".data";
reloc3.symbolSectionIndex = 1;
reloc3.symbolTableIndex = 0;
@@ -1971,7 +1971,7 @@ TEST_F(LinkerTests, givenImplicitArgRelocationAndStackCallsThenPatchRelocationWi
auto linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
deviceFactory.rootDevices[0], nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -2033,7 +2033,7 @@ TEST_F(LinkerDebuggingSupportedTests, givenImplicitArgRelocationAndEnabledDebugg
auto linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
device, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -2082,7 +2082,7 @@ TEST_F(LinkerDebuggingSupportedTests, givenNoImplicitArgRelocationAndEnabledDebu
auto linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
device, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -2138,7 +2138,7 @@ TEST_F(LinkerTests, givenImplicitArgRelocationWithoutStackCallsAndDisabledDebugg
auto linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
device, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -2182,7 +2182,7 @@ TEST_F(LinkerTests, givenNoImplicitArgRelocationAndStackCallsThenImplicitArgsAre
auto linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
deviceFactory.rootDevices[0], nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -2239,7 +2239,7 @@ TEST_F(LinkerTests, givenMultipleImplicitArgsRelocationsWithinSingleKernelWhenLi
auto linkResult = linker.link(globalVarSegment, globalConstSegment, exportedFuncSegment, {},
nullptr, nullptr, patchableInstructionSegments, unresolvedExternals,
deviceFactory.rootDevices[0], nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(NEO::LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(NEO::LinkingStatus::linkedFully, linkResult);
auto relocatedSymbols = linker.extractRelocatedSymbols();
EXPECT_EQ(0U, unresolvedExternals.size());
EXPECT_EQ(0U, relocatedSymbols.size());
@@ -2266,7 +2266,7 @@ HWTEST_F(LinkerTests, givenDependencyOnMissingExternalFunctionWhenLinkingThenFai
globalVar, globalConst, exportedFunc, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(LinkingStatus::Error, linkResult);
EXPECT_EQ(LinkingStatus::error, linkResult);
}
HWTEST_F(LinkerTests, givenDependencyOnMissingExternalFunctionAndNoExternalFunctionInfosWhenLinkingThenDoNotResolveDependenciesAndReturnSuccess) {
@@ -2284,7 +2284,7 @@ HWTEST_F(LinkerTests, givenDependencyOnMissingExternalFunctionAndNoExternalFunct
globalVar, globalConst, exportedFunc, {},
patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
unresolvedExternals, pDevice, nullptr, 0, nullptr, 0, kernelDescriptors, externalFunctions);
EXPECT_EQ(LinkingStatus::LinkedFully, linkResult);
EXPECT_EQ(LinkingStatus::linkedFully, linkResult);
}
TEST_F(LinkerTests, givenRelaWhenPatchingInstructionsSegmentThenAddendIsAdded) {

6
shared/test/unit_test/debugger/test_l0_debugger.cpp
View File

@@ -182,7 +182,7 @@ HWTEST_F(L0DebuggerTest, givenDebuggerWhenCreatedThenModuleHeapDebugAreaIsCreate
auto mockBlitMemoryToAllocation = [](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
Vec3<size_t> size) -> NEO::BlitOperationResult {
memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
return BlitOperationResult::Success;
return BlitOperationResult::success;
};
VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
&NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);
@@ -223,7 +223,7 @@ HWTEST_F(L0DebuggerTest, givenBindlessSipWhenModuleHeapDebugAreaIsCreatedThenRes
auto mockBlitMemoryToAllocation = [](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
Vec3<size_t> size) -> NEO::BlitOperationResult {
memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
return BlitOperationResult::Success;
return BlitOperationResult::success;
};
VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
&NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);
@@ -247,7 +247,7 @@ HWTEST_F(L0DebuggerTest, givenUseBindlessDebugSipZeroWhenModuleHeapDebugAreaIsCr
auto mockBlitMemoryToAllocation = [](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
Vec3<size_t> size) -> NEO::BlitOperationResult {
memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
return BlitOperationResult::Success;
return BlitOperationResult::success;
};
VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
&NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);

32
shared/test/unit_test/device_binary_format/elf/elf_decoder_tests.cpp
View File

@@ -37,11 +37,11 @@ class TestElf {
ElfRela<ELF_CLASS::EI_CLASS_64> relocationsWithAddend[2];
relocationsWithAddend[0].addend = relaAddend;
relocationsWithAddend[0].info = relaSymbolIndexes[0] << 32 | uint32_t(RELOCATION_X8664_TYPE::R_X8664_64);
relocationsWithAddend[0].info = relaSymbolIndexes[0] << 32 | uint32_t(RELOCATION_X8664_TYPE::relocation64);
relocationsWithAddend[0].offset = relaOffsets[0];
relocationsWithAddend[1].addend = relaAddend;
relocationsWithAddend[1].info = relaSymbolIndexes[1] << 32 | uint32_t(RELOCATION_X8664_TYPE::R_X8664_32);
relocationsWithAddend[1].info = relaSymbolIndexes[1] << 32 | uint32_t(RELOCATION_X8664_TYPE::relocation32);
relocationsWithAddend[1].offset = relaOffsets[1];
elfEncoder.appendSection(SHT_PROGBITS, SpecialSectionNames::debug, ArrayRef<const uint8_t>(dummyData, sizeof(dummyData)));
@@ -55,10 +55,10 @@ class TestElf {
relaDebugSection->info = debugSectionIndex;
ElfRel<ELF_CLASS::EI_CLASS_64> relocations[2];
relocations[0].info = relSymbolIndex << 32 | uint64_t(RELOCATION_X8664_TYPE::R_X8664_64);
relocations[0].info = relSymbolIndex << 32 | uint64_t(RELOCATION_X8664_TYPE::relocation64);
relocations[0].offset = relOffsets[0];
relocations[1].info = relSymbolIndex << 32 | uint64_t(RELOCATION_X8664_TYPE::R_X8664_64);
relocations[1].info = relSymbolIndex << 32 | uint64_t(RELOCATION_X8664_TYPE::relocation64);
relocations[1].offset = relOffsets[1];
elfEncoder.appendSection(SHT_PROGBITS, SpecialSectionNames::line, std::string{"dummy_line_data______________________"});
@@ -536,19 +536,19 @@ TEST(ElfDecoder, GivenElf64WhenExtractingDataFromElfRelocationThenCorrectRelocTy
elf.elfFileHeader = &header64;
ElfRela<EI_CLASS_64> rela;
rela.info = decltype(ElfRela<EI_CLASS_64>::info)(RELOCATION_X8664_TYPE::R_X8664_64) | decltype(ElfRela<EI_CLASS_64>::info)(5) << 32;
rela.info = decltype(ElfRela<EI_CLASS_64>::info)(RELOCATION_X8664_TYPE::relocation64) | decltype(ElfRela<EI_CLASS_64>::info)(5) << 32;
auto type = elf.extractRelocType(rela);
auto symbolIndex = elf.extractSymbolIndex(rela);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_64), type);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation64), type);
EXPECT_EQ(5, symbolIndex);
ElfRel<EI_CLASS_64> rel;
rel.info = decltype(ElfRela<EI_CLASS_64>::info)(RELOCATION_X8664_TYPE::R_X8664_32) | decltype(ElfRela<EI_CLASS_64>::info)(6) << 32;
rel.info = decltype(ElfRela<EI_CLASS_64>::info)(RELOCATION_X8664_TYPE::relocation32) | decltype(ElfRela<EI_CLASS_64>::info)(6) << 32;
type = elf.extractRelocType(rel);
symbolIndex = elf.extractSymbolIndex(rel);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_32), type);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation32), type);
EXPECT_EQ(6, symbolIndex);
}
@@ -558,19 +558,19 @@ TEST(ElfDecoder, GivenElf32WhenExtractingDataFromElfRelocationThenCorrectRelocTy
elf.elfFileHeader = &header64;
ElfRela<EI_CLASS_32> rela;
rela.info = decltype(ElfRela<EI_CLASS_32>::info)(RELOCATION_X8664_TYPE::R_X8664_32) | decltype(ElfRela<EI_CLASS_32>::info)(5) << 8;
rela.info = decltype(ElfRela<EI_CLASS_32>::info)(RELOCATION_X8664_TYPE::relocation32) | decltype(ElfRela<EI_CLASS_32>::info)(5) << 8;
auto type = elf.extractRelocType(rela);
auto symbolIndex = elf.extractSymbolIndex(rela);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_32), type);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation32), type);
EXPECT_EQ(5, symbolIndex);
ElfRel<EI_CLASS_32> rel;
rel.info = decltype(ElfRel<EI_CLASS_32>::info)(RELOCATION_X8664_TYPE::R_X8664_32) | decltype(ElfRel<EI_CLASS_32>::info)(6) << 8;
rel.info = decltype(ElfRel<EI_CLASS_32>::info)(RELOCATION_X8664_TYPE::relocation32) | decltype(ElfRel<EI_CLASS_32>::info)(6) << 8;
type = elf.extractRelocType(rel);
symbolIndex = elf.extractSymbolIndex(rel);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_32), type);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation32), type);
EXPECT_EQ(6, symbolIndex);
}
@@ -693,7 +693,7 @@ TEST(ElfDecoder, GivenElfWithRelocationsWhenDecodedThenCorrectRelocationsAndSymo
EXPECT_EQ(testElf.relaAddend, debugRelocations[0].addend);
EXPECT_EQ(testElf.relaOffsets[0], debugRelocations[0].offset);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_64), debugRelocations[0].relocType);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation64), debugRelocations[0].relocType);
EXPECT_STREQ("global_object_symbol_0", debugRelocations[0].symbolName.c_str());
EXPECT_EQ(7, debugRelocations[0].symbolSectionIndex);
EXPECT_EQ(3, debugRelocations[0].symbolTableIndex);
@@ -701,7 +701,7 @@ TEST(ElfDecoder, GivenElfWithRelocationsWhenDecodedThenCorrectRelocationsAndSymo
EXPECT_EQ(testElf.relaAddend, debugRelocations[1].addend);
EXPECT_EQ(testElf.relaOffsets[1], debugRelocations[1].offset);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_32), debugRelocations[1].relocType);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation32), debugRelocations[1].relocType);
EXPECT_STREQ("local_function_symbol_1", debugRelocations[1].symbolName.c_str());
EXPECT_EQ(1, debugRelocations[1].symbolSectionIndex);
EXPECT_EQ(1, debugRelocations[1].symbolTableIndex);
@@ -709,7 +709,7 @@ TEST(ElfDecoder, GivenElfWithRelocationsWhenDecodedThenCorrectRelocationsAndSymo
EXPECT_EQ(0u, debugRelocations[2].addend);
EXPECT_EQ(testElf.relOffsets[1], debugRelocations[2].offset);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_64), debugRelocations[2].relocType);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation64), debugRelocations[2].relocType);
EXPECT_STREQ("section_symbol_2", debugRelocations[2].symbolName.c_str());
EXPECT_EQ(1, debugRelocations[2].symbolSectionIndex);
EXPECT_EQ(2, debugRelocations[2].symbolTableIndex);
@@ -717,7 +717,7 @@ TEST(ElfDecoder, GivenElfWithRelocationsWhenDecodedThenCorrectRelocationsAndSymo
EXPECT_EQ(0u, relocations[0].addend);
EXPECT_EQ(testElf.relOffsets[0], relocations[0].offset);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::R_X8664_64), relocations[0].relocType);
EXPECT_EQ(uint32_t(RELOCATION_X8664_TYPE::relocation64), relocations[0].relocType);
EXPECT_STREQ("section_symbol_2", relocations[0].symbolName.c_str());
EXPECT_EQ(1, relocations[0].symbolSectionIndex);
EXPECT_EQ(2, relocations[0].symbolTableIndex);

98
shared/test/unit_test/direct_submission/direct_submission_tests_2.cpp
View File

@@ -1097,7 +1097,7 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(++lrrCmd, 0, RegisterOffsets::csGprR1, 0, CompareOperation::Equal, true)) {
if (!RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(++lrrCmd, 0, RegisterOffsets::csGprR1, 0, CompareOperation::equal, true)) {
return false;
}
@@ -1166,43 +1166,43 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
}
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_2)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr2)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_6)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr6)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_SHL, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeShl, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_ACCU)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::accu)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_7)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr7)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_8)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr8)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_ADD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeAdd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_6, AluRegisters::R_ACCU)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr6, AluRegisters::accu)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOADIND, AluRegisters::R_0, AluRegisters::R_ACCU)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoadind, AluRegisters::gpr0, AluRegisters::accu)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_FENCE_RD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeFenceRd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
@@ -1218,13 +1218,13 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
}
miPredicate++;
if (!RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(miPredicate, AluRegisters::R_1, false)) {
if (!RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(miPredicate, AluRegisters::gpr1, false)) {
return false;
}
auto cmds = ptrOffset(miPredicate, EncodeMathMMIO<FamilyType>::getCmdSizeForIncrementOrDecrement());
if (!RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(cmds, AluRegisters::R_2, false)) {
if (!RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(cmds, AluRegisters::gpr2, false)) {
return false;
}
@@ -1238,7 +1238,7 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(++lrrCmd, 0, RegisterOffsets::csGprR1, 0, CompareOperation::Equal, true)) {
if (!RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(++lrrCmd, 0, RegisterOffsets::csGprR1, 0, CompareOperation::equal, true)) {
return false;
}
@@ -1271,59 +1271,59 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
}
miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_1)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr1)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_7)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr7)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_SHL, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeShl, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_7, AluRegisters::R_ACCU)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr7, AluRegisters::accu)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_7)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr7)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_8)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr8)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_ADD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeAdd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOADIND, AluRegisters::R_7, AluRegisters::R_ACCU)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoadind, AluRegisters::gpr7, AluRegisters::accu)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_FENCE_RD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeFenceRd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_6)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr6)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD0, AluRegisters::R_SRCB, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad0, AluRegisters::srcb, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_ADD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeAdd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STOREIND, AluRegisters::R_ACCU, AluRegisters::R_7)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStoreind, AluRegisters::accu, AluRegisters::gpr7)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_FENCE_WR, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeFenceWr, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
@@ -1335,14 +1335,14 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
}
miPredicate++;
if (!RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(miPredicate, AluRegisters::R_2, true)) {
if (!RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(miPredicate, AluRegisters::gpr2, true)) {
return false;
}
cmds = ptrOffset(miPredicate, EncodeMathMMIO<FamilyType>::getCmdSizeForIncrementOrDecrement());
if (!RelaxedOrderingCommandsHelper::verifyConditionalRegRegBbStart<FamilyType>(cmds, schedulerStartGpuAddress + RelaxedOrderingHelper::StaticSchedulerSizeAndOffsetSection<FamilyType>::loopStartSectionStart,
AluRegisters::R_1, AluRegisters::R_2, CompareOperation::NotEqual, false)) {
AluRegisters::gpr1, AluRegisters::gpr2, CompareOperation::notEqual, false)) {
return false;
}
@@ -1364,14 +1364,14 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
}
if (!RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(++arbCheck, schedulerStartGpuAddress + RelaxedOrderingHelper::StaticSchedulerSizeAndOffsetSection<FamilyType>::loopStartSectionStart,
RegisterOffsets::csGprR1, expectedQueueSizeLimit, CompareOperation::GreaterOrEqual, false)) {
RegisterOffsets::csGprR1, expectedQueueSizeLimit, CompareOperation::greaterOrEqual, false)) {
return false;
}
auto conditionalBbStartcmds = ptrOffset(arbCheck, EncodeBatchBufferStartOrEnd<FamilyType>::getCmdSizeConditionalDataRegBatchBufferStart(false));
if (!RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(conditionalBbStartcmds, schedulerStartGpuAddress + RelaxedOrderingHelper::StaticSchedulerSizeAndOffsetSection<FamilyType>::loopStartSectionStart,
RegisterOffsets::csGprR5, 1, CompareOperation::Equal, false)) {
RegisterOffsets::csGprR5, 1, CompareOperation::equal, false)) {
return false;
}
@@ -1398,23 +1398,23 @@ bool DirectSubmissionRelaxedOrderingTests::verifyStaticSchedulerProgramming(Grap
}
miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_9)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr9)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_10)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr10)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_ADD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeAdd, AluRegisters::opcodeNone, AluRegisters::opcodeNone)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_0, AluRegisters::R_ACCU)) {
if (!RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr0, AluRegisters::accu)) {
return false;
}
if (!RelaxedOrderingCommandsHelper::verifyConditionalRegMemBbStart<FamilyType>(++miAluCmd, 0, semaphoreGpuVa, RegisterOffsets::csGprR11, CompareOperation::GreaterOrEqual, true)) {
if (!RelaxedOrderingCommandsHelper::verifyConditionalRegMemBbStart<FamilyType>(++miAluCmd, 0, semaphoreGpuVa, RegisterOffsets::csGprR11, CompareOperation::greaterOrEqual, true)) {
return false;
}
@@ -1796,25 +1796,25 @@ HWTEST_F(DirectSubmissionRelaxedOrderingTests, whenDispatchingWorkThenDispatchTa
}
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_1));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr1));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_8));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr8));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_SHL, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeShl, AluRegisters::opcodeNone, AluRegisters::opcodeNone));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STORE, AluRegisters::R_8, AluRegisters::R_ACCU));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStore, AluRegisters::gpr8, AluRegisters::accu));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCA, AluRegisters::R_8));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srca, AluRegisters::gpr8));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_LOAD, AluRegisters::R_SRCB, AluRegisters::R_6));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeLoad, AluRegisters::srcb, AluRegisters::gpr6));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_ADD, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeAdd, AluRegisters::opcodeNone, AluRegisters::opcodeNone));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_STOREIND, AluRegisters::R_ACCU, AluRegisters::R_7));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeStoreind, AluRegisters::accu, AluRegisters::gpr7));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::OPCODE_FENCE_WR, AluRegisters::OPCODE_NONE, AluRegisters::OPCODE_NONE));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyAlu<FamilyType>(++miAluCmd, AluRegisters::opcodeFenceWr, AluRegisters::opcodeNone, AluRegisters::opcodeNone));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(++miAluCmd, AluRegisters::R_1, true));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyIncrementOrDecrement<FamilyType>(++miAluCmd, AluRegisters::gpr1, true));
}
HWTEST_F(DirectSubmissionRelaxedOrderingTests, givenNotEnoughSpaceForTaskStoreSectionWhenDispatchingThenSwitchRingBuffers) {
@@ -1898,7 +1898,7 @@ HWTEST2_F(DirectSubmissionRelaxedOrderingTests, givenBbWithStallingCmdsWhenDispa
EncodeBatchBufferStartOrEnd<FamilyType>::getCmdSizeConditionalDataRegBatchBufferStart(false);
uint64_t expectedJumpAddress = directSubmission.ringCommandStream.getGpuBase() + offset + jumpOffset;
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(startAddress, expectedJumpAddress, RegisterOffsets::csGprR1, 0, CompareOperation::Equal, false));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(startAddress, expectedJumpAddress, RegisterOffsets::csGprR1, 0, CompareOperation::equal, false));
HardwareParse hwParse;
hwParse.parseCommands<FamilyType>(directSubmission.ringCommandStream, offset + EncodeBatchBufferStartOrEnd<FamilyType>::getCmdSizeConditionalDataRegBatchBufferStart(false));
@@ -1999,7 +1999,7 @@ HWTEST2_F(DirectSubmissionRelaxedOrderingTests, whenStoppingRingThenProgramSched
EncodeBatchBufferStartOrEnd<FamilyType>::getCmdSizeConditionalDataRegBatchBufferStart(false);
uint64_t expectedJumpAddress = directSubmission.ringCommandStream.getGpuBase() + offset + jumpOffset;
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(startAddress, expectedJumpAddress, RegisterOffsets::csGprR1, 0, CompareOperation::Equal, false));
EXPECT_TRUE(RelaxedOrderingCommandsHelper::verifyConditionalDataRegBbStart<FamilyType>(startAddress, expectedJumpAddress, RegisterOffsets::csGprR1, 0, CompareOperation::equal, false));
HardwareParse hwParse;
hwParse.parseCommands<FamilyType>(directSubmission.ringCommandStream, offset + EncodeBatchBufferStartOrEnd<FamilyType>::getCmdSizeConditionalDataRegBatchBufferStart(false));

6
shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp
View File

@@ -229,7 +229,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenPciBarrierWhenCreateDirectSubmissionThenP
MockDrmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> directSubmission(commandStreamReceiver);
EXPECT_NE(nullptr, directSubmission.pciBarrierPtr);
EXPECT_NE(DirectSubmissionSfenceMode::Disabled, directSubmission.sfenceMode);
EXPECT_NE(DirectSubmissionSfenceMode::disabled, directSubmission.sfenceMode);
EXPECT_FALSE(directSubmission.miMemFenceRequired);
SysCalls::munmap(ptr, MemoryConstants::pageSize);
@@ -250,7 +250,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenPciBarrierWhenCreateDirectSubmissionAndMm
MockDrmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> directSubmission(commandStreamReceiver);
EXPECT_EQ(nullptr, directSubmission.pciBarrierPtr);
EXPECT_NE(DirectSubmissionSfenceMode::Disabled, directSubmission.sfenceMode);
EXPECT_NE(DirectSubmissionSfenceMode::disabled, directSubmission.sfenceMode);
auto expectMiMemFence = device->getHardwareInfo().capabilityTable.isIntegratedDevice ? false : device->getRootDeviceEnvironment().getHelper<ProductHelper>().isGlobalFenceInDirectSubmissionRequired(device->getHardwareInfo());
EXPECT_EQ(directSubmission.miMemFenceRequired, expectMiMemFence);
@@ -271,7 +271,7 @@ HWTEST_F(DrmDirectSubmissionTest, givenPciBarrierDisabledWhenCreateDirectSubmiss
MockDrmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> directSubmission(commandStreamReceiver);
EXPECT_EQ(nullptr, directSubmission.pciBarrierPtr);
EXPECT_NE(DirectSubmissionSfenceMode::Disabled, directSubmission.sfenceMode);
EXPECT_NE(DirectSubmissionSfenceMode::disabled, directSubmission.sfenceMode);
auto expectMiMemFence = device->getHardwareInfo().capabilityTable.isIntegratedDevice ? false : device->getRootDeviceEnvironment().getHelper<ProductHelper>().isGlobalFenceInDirectSubmissionRequired(device->getHardwareInfo());
EXPECT_EQ(directSubmission.miMemFenceRequired, expectMiMemFence);

102
shared/test/unit_test/encoders/test_encode_math.cpp
View File

@@ -21,9 +21,9 @@ HWTEST_F(EncodeMathMMIOTest, WhenEncodingAluThenCorrectOpcodesOperandsAdded) {
using MI_MATH_ALU_INST_INLINE = typename FamilyType::MI_MATH_ALU_INST_INLINE;
MI_MATH_ALU_INST_INLINE aluParam[5];
AluRegisters regA = AluRegisters::R_0;
AluRegisters regB = AluRegisters::R_1;
AluRegisters finalResultRegister = AluRegisters::R_2;
AluRegisters regA = AluRegisters::gpr0;
AluRegisters regB = AluRegisters::gpr1;
AluRegisters finalResultRegister = AluRegisters::gpr2;
memset(aluParam, 0, sizeof(MI_MATH_ALU_INST_INLINE) * 5);
@@ -31,29 +31,29 @@ HWTEST_F(EncodeMathMMIOTest, WhenEncodingAluThenCorrectOpcodesOperandsAdded) {
finalResultRegister);
EXPECT_EQ(aluParam[0].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_LOAD));
static_cast<uint32_t>(AluRegisters::opcodeLoad));
EXPECT_EQ(aluParam[0].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_SRCA));
static_cast<uint32_t>(AluRegisters::srca));
EXPECT_EQ(aluParam[0].DW0.BitField.Operand2, static_cast<uint32_t>(regA));
EXPECT_EQ(aluParam[1].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_LOAD));
static_cast<uint32_t>(AluRegisters::opcodeLoad));
EXPECT_EQ(aluParam[1].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_SRCB));
static_cast<uint32_t>(AluRegisters::srcb));
EXPECT_EQ(aluParam[1].DW0.BitField.Operand2,
static_cast<uint32_t>(regB));
EXPECT_EQ(aluParam[2].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_ADD));
static_cast<uint32_t>(AluRegisters::opcodeAdd));
EXPECT_EQ(aluParam[2].DW0.BitField.Operand1, 0u);
EXPECT_EQ(aluParam[2].DW0.BitField.Operand2, 0u);
EXPECT_EQ(aluParam[3].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_STORE));
static_cast<uint32_t>(AluRegisters::opcodeStore));
EXPECT_EQ(aluParam[3].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_2));
static_cast<uint32_t>(AluRegisters::gpr2));
EXPECT_EQ(aluParam[3].DW0.BitField.Operand2,
static_cast<uint32_t>(AluRegisters::R_ACCU));
static_cast<uint32_t>(AluRegisters::accu));
EXPECT_EQ(aluParam[4].DW0.Value, 0u);
}
@@ -62,9 +62,9 @@ HWTEST_F(EncodeMathMMIOTest, WhenEncodingAluSubStoreCarryThenCorrectOpcodesOpera
using MI_MATH_ALU_INST_INLINE = typename FamilyType::MI_MATH_ALU_INST_INLINE;
MI_MATH_ALU_INST_INLINE aluParam[5];
AluRegisters regA = AluRegisters::R_0;
AluRegisters regB = AluRegisters::R_1;
AluRegisters finalResultRegister = AluRegisters::R_2;
AluRegisters regA = AluRegisters::gpr0;
AluRegisters regB = AluRegisters::gpr1;
AluRegisters finalResultRegister = AluRegisters::gpr2;
memset(aluParam, 0, sizeof(MI_MATH_ALU_INST_INLINE) * 5);
@@ -72,30 +72,30 @@ HWTEST_F(EncodeMathMMIOTest, WhenEncodingAluSubStoreCarryThenCorrectOpcodesOpera
finalResultRegister);
EXPECT_EQ(aluParam[0].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_LOAD));
static_cast<uint32_t>(AluRegisters::opcodeLoad));
EXPECT_EQ(aluParam[0].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_SRCA));
static_cast<uint32_t>(AluRegisters::srca));
EXPECT_EQ(aluParam[0].DW0.BitField.Operand2,
static_cast<uint32_t>(regA));
EXPECT_EQ(aluParam[1].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_LOAD));
static_cast<uint32_t>(AluRegisters::opcodeLoad));
EXPECT_EQ(aluParam[1].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_SRCB));
static_cast<uint32_t>(AluRegisters::srcb));
EXPECT_EQ(aluParam[1].DW0.BitField.Operand2,
static_cast<uint32_t>(regB));
EXPECT_EQ(aluParam[2].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_SUB));
static_cast<uint32_t>(AluRegisters::opcodeSub));
EXPECT_EQ(aluParam[2].DW0.BitField.Operand1, 0u);
EXPECT_EQ(aluParam[2].DW0.BitField.Operand2, 0u);
EXPECT_EQ(aluParam[3].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_STORE));
static_cast<uint32_t>(AluRegisters::opcodeStore));
EXPECT_EQ(aluParam[3].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_2));
static_cast<uint32_t>(AluRegisters::gpr2));
EXPECT_EQ(aluParam[3].DW0.BitField.Operand2,
static_cast<uint32_t>(AluRegisters::R_CF));
static_cast<uint32_t>(AluRegisters::cf));
EXPECT_EQ(aluParam[4].DW0.Value, 0u);
}
@@ -104,9 +104,9 @@ HWTEST_F(EncodeMathMMIOTest, givenAluRegistersWhenEncodeAluAndIsCalledThenAluPar
using MI_MATH_ALU_INST_INLINE = typename FamilyType::MI_MATH_ALU_INST_INLINE;
MI_MATH_ALU_INST_INLINE aluParam[5];
AluRegisters regA = AluRegisters::R_0;
AluRegisters regB = AluRegisters::R_1;
AluRegisters finalResultRegister = AluRegisters::R_2;
AluRegisters regA = AluRegisters::gpr0;
AluRegisters regB = AluRegisters::gpr1;
AluRegisters finalResultRegister = AluRegisters::gpr2;
memset(aluParam, 0, sizeof(MI_MATH_ALU_INST_INLINE) * 5);
@@ -114,29 +114,29 @@ HWTEST_F(EncodeMathMMIOTest, givenAluRegistersWhenEncodeAluAndIsCalledThenAluPar
finalResultRegister);
EXPECT_EQ(aluParam[0].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_LOAD));
static_cast<uint32_t>(AluRegisters::opcodeLoad));
EXPECT_EQ(aluParam[0].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_SRCA));
static_cast<uint32_t>(AluRegisters::srca));
EXPECT_EQ(aluParam[0].DW0.BitField.Operand2, static_cast<uint32_t>(regA));
EXPECT_EQ(aluParam[1].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_LOAD));
static_cast<uint32_t>(AluRegisters::opcodeLoad));
EXPECT_EQ(aluParam[1].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_SRCB));
static_cast<uint32_t>(AluRegisters::srcb));
EXPECT_EQ(aluParam[1].DW0.BitField.Operand2,
static_cast<uint32_t>(regB));
EXPECT_EQ(aluParam[2].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_AND));
static_cast<uint32_t>(AluRegisters::opcodeAnd));
EXPECT_EQ(aluParam[2].DW0.BitField.Operand1, 0u);
EXPECT_EQ(aluParam[2].DW0.BitField.Operand2, 0u);
EXPECT_EQ(aluParam[3].DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_STORE));
static_cast<uint32_t>(AluRegisters::opcodeStore));
EXPECT_EQ(aluParam[3].DW0.BitField.Operand1,
static_cast<uint32_t>(AluRegisters::R_2));
static_cast<uint32_t>(AluRegisters::gpr2));
EXPECT_EQ(aluParam[3].DW0.BitField.Operand2,
static_cast<uint32_t>(AluRegisters::R_ACCU));
static_cast<uint32_t>(AluRegisters::accu));
EXPECT_EQ(aluParam[4].DW0.Value, 0u);
}
@@ -289,7 +289,7 @@ HWTEST_F(CommandEncodeAluTests, whenProgrammingIncrementOperationThenUseCorrectA
using MI_MATH = typename FamilyType::MI_MATH;
constexpr size_t bufferSize = EncodeMathMMIO<FamilyType>::getCmdSizeForIncrementOrDecrement();
constexpr AluRegisters incRegister = AluRegisters::R_1;
constexpr AluRegisters incRegister = AluRegisters::gpr1;
uint8_t buffer[bufferSize] = {};
LinearStream cmdStream(buffer, bufferSize);
@@ -310,24 +310,24 @@ HWTEST_F(CommandEncodeAluTests, whenProgrammingIncrementOperationThenUseCorrectA
EXPECT_EQ(3u, miMathCmd->DW0.BitField.DwordLength);
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_LOAD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_SRCA), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeLoad), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::srca), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(incRegister), miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_LOAD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_SRCB), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_7), miAluCmd->DW0.BitField.Operand2);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeLoad), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::srcb), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::gpr7), miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_ADD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeAdd), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(0u, miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(0u, miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_STORE), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeStore), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(incRegister), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_ACCU), miAluCmd->DW0.BitField.Operand2);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::accu), miAluCmd->DW0.BitField.Operand2);
}
HWTEST_F(CommandEncodeAluTests, whenProgrammingDecrementOperationThenUseCorrectAluCommands) {
@@ -336,7 +336,7 @@ HWTEST_F(CommandEncodeAluTests, whenProgrammingDecrementOperationThenUseCorrectA
using MI_MATH = typename FamilyType::MI_MATH;
constexpr size_t bufferSize = EncodeMathMMIO<FamilyType>::getCmdSizeForIncrementOrDecrement();
constexpr AluRegisters decRegister = AluRegisters::R_1;
constexpr AluRegisters decRegister = AluRegisters::gpr1;
uint8_t buffer[bufferSize] = {};
LinearStream cmdStream(buffer, bufferSize);
@@ -357,22 +357,22 @@ HWTEST_F(CommandEncodeAluTests, whenProgrammingDecrementOperationThenUseCorrectA
EXPECT_EQ(3u, miMathCmd->DW0.BitField.DwordLength);
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_LOAD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_SRCA), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeLoad), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::srca), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(decRegister), miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_LOAD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_SRCB), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_7), miAluCmd->DW0.BitField.Operand2);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeLoad), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::srcb), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::gpr7), miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_SUB), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeSub), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(0u, miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(0u, miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_STORE), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeStore), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(decRegister), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_ACCU), miAluCmd->DW0.BitField.Operand2);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::accu), miAluCmd->DW0.BitField.Operand2);
}

2
shared/test/unit_test/encoders/test_encode_math_xehp_and_later.cpp
View File

@@ -64,5 +64,5 @@ HWTEST2_F(XeHPAndLaterCommandEncoderMathTest, WhenAppendsAGreaterThanThenPredica
auto cmdALU = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(cmdMATH + 3);
EXPECT_EQ(cmdALU->DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_SUB));
static_cast<uint32_t>(AluRegisters::opcodeSub));
}

44
shared/test/unit_test/encoders/test_encode_pvc_and_later.cpp
View File

@@ -41,27 +41,27 @@ struct EncodeConditionalBatchBufferStartTest : public ::testing::Test {
EXPECT_EQ(3u, miMathCmd->DW0.BitField.DwordLength);
auto miAluCmd = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(++miMathCmd);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_LOAD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_SRCA), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeLoad), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::srca), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(regA), miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_LOAD), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_SRCB), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeLoad), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::srcb), miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(static_cast<uint32_t>(regB), miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_SUB), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeSub), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(0u, miAluCmd->DW0.BitField.Operand1);
EXPECT_EQ(0u, miAluCmd->DW0.BitField.Operand2);
miAluCmd++;
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::OPCODE_STORE), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_7), miAluCmd->DW0.BitField.Operand1);
if (compareOperation == CompareOperation::Equal || compareOperation == CompareOperation::NotEqual) {
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_ZF), miAluCmd->DW0.BitField.Operand2);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::opcodeStore), miAluCmd->DW0.BitField.ALUOpcode);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::gpr7), miAluCmd->DW0.BitField.Operand1);
if (compareOperation == CompareOperation::equal || compareOperation == CompareOperation::notEqual) {
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::zf), miAluCmd->DW0.BitField.Operand2);
} else {
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::R_CF), miAluCmd->DW0.BitField.Operand2);
EXPECT_EQ(static_cast<uint32_t>(AluRegisters::cf), miAluCmd->DW0.BitField.Operand2);
}
auto lrrCmd = reinterpret_cast<MI_LOAD_REGISTER_REG *>(++miAluCmd);
@@ -69,7 +69,7 @@ struct EncodeConditionalBatchBufferStartTest : public ::testing::Test {
EXPECT_EQ(RegisterOffsets::csGprR7, lrrCmd->getSourceRegisterAddress());
auto predicateCmd = reinterpret_cast<MI_SET_PREDICATE *>(++lrrCmd);
if (compareOperation == CompareOperation::Equal) {
if (compareOperation == CompareOperation::equal) {
EXPECT_EQ(static_cast<uint32_t>(MiPredicateType::noopOnResult2Clear), predicateCmd->getPredicateEnable());
} else {
EXPECT_EQ(static_cast<uint32_t>(MiPredicateType::noopOnResult2Set), predicateCmd->getPredicateEnable());
@@ -102,7 +102,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgrammingConditionalDataM
constexpr uint64_t compareAddress = 0x56780000;
constexpr uint32_t compareData = 9876;
for (auto compareOperation : {CompareOperation::Equal, CompareOperation::NotEqual, CompareOperation::GreaterOrEqual}) {
for (auto compareOperation : {CompareOperation::equal, CompareOperation::notEqual, CompareOperation::greaterOrEqual}) {
for (bool indirect : {false, true}) {
uint8_t buffer[expectedSize] = {};
LinearStream cmdStream(buffer, expectedSize);
@@ -127,7 +127,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgrammingConditionalDataM
EXPECT_EQ(RegisterOffsets::csGprR8 + 4, lriCmd->getRegisterOffset());
EXPECT_EQ(0u, lriCmd->getDataDword());
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
}
}
@@ -147,7 +147,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgramming64bConditionalDa
constexpr uint64_t compareAddress = 0x56780000;
constexpr uint64_t compareData = 0x12345678'12345678;
for (auto compareOperation : {CompareOperation::Equal, CompareOperation::NotEqual, CompareOperation::GreaterOrEqual}) {
for (auto compareOperation : {CompareOperation::equal, CompareOperation::notEqual, CompareOperation::greaterOrEqual}) {
for (bool indirect : {false, true}) {
uint8_t buffer[expectedSize] = {};
LinearStream cmdStream(buffer, expectedSize);
@@ -172,7 +172,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgramming64bConditionalDa
EXPECT_EQ(RegisterOffsets::csGprR8 + 4, lriCmd->getRegisterOffset());
EXPECT_EQ(static_cast<uint32_t>(compareData >> 32), lriCmd->getDataDword());
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
}
}
@@ -192,7 +192,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgrammingConditionalDataR
constexpr uint32_t compareReg = RegisterOffsets::csGprR1;
constexpr uint32_t compareData = 9876;
for (auto compareOperation : {CompareOperation::Equal, CompareOperation::NotEqual, CompareOperation::GreaterOrEqual}) {
for (auto compareOperation : {CompareOperation::equal, CompareOperation::notEqual, CompareOperation::greaterOrEqual}) {
for (bool indirect : {false, true}) {
uint8_t buffer[expectedSize] = {};
LinearStream cmdStream(buffer, expectedSize);
@@ -217,7 +217,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgrammingConditionalDataR
EXPECT_EQ(RegisterOffsets::csGprR8 + 4, lriCmd->getRegisterOffset());
EXPECT_EQ(0u, lriCmd->getDataDword());
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
}
}
@@ -237,7 +237,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgramming64bConditionalDa
constexpr uint32_t compareReg = RegisterOffsets::csGprR1;
constexpr uint64_t compareData = 0x12345678'12345678;
for (auto compareOperation : {CompareOperation::Equal, CompareOperation::NotEqual, CompareOperation::GreaterOrEqual}) {
for (auto compareOperation : {CompareOperation::equal, CompareOperation::notEqual, CompareOperation::greaterOrEqual}) {
for (bool indirect : {false, true}) {
uint8_t buffer[expectedSize] = {};
LinearStream cmdStream(buffer, expectedSize);
@@ -262,7 +262,7 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgramming64bConditionalDa
EXPECT_EQ(RegisterOffsets::csGprR8 + 4, lriCmd->getRegisterOffset());
EXPECT_EQ(static_cast<uint32_t>(compareData >> 32), lriCmd->getDataDword());
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::R_7, AluRegisters::R_8);
validateBaseProgramming<FamilyType>(++lriCmd, compareOperation, startAddress, indirect, AluRegisters::gpr7, AluRegisters::gpr8);
}
}
}
@@ -276,10 +276,10 @@ HWTEST2_F(EncodeConditionalBatchBufferStartTest, whenProgrammingConditionalRegRe
EXPECT_EQ(expectedSize, EncodeBatchBufferStartOrEnd<FamilyType>::getCmdSizeConditionalRegRegBatchBufferStart());
constexpr uint64_t startAddress = 0x12340000;
constexpr AluRegisters compareReg1 = AluRegisters::R_1;
constexpr AluRegisters compareReg2 = AluRegisters::R_2;
constexpr AluRegisters compareReg1 = AluRegisters::gpr1;
constexpr AluRegisters compareReg2 = AluRegisters::gpr2;
for (auto compareOperation : {CompareOperation::Equal, CompareOperation::NotEqual, CompareOperation::GreaterOrEqual}) {
for (auto compareOperation : {CompareOperation::equal, CompareOperation::notEqual, CompareOperation::greaterOrEqual}) {
for (bool indirect : {false, true}) {
uint8_t buffer[expectedSize] = {};
LinearStream cmdStream(buffer, expectedSize);

2
shared/test/unit_test/gen11/test_encode_math_gen11.cpp
View File

@@ -65,5 +65,5 @@ GEN11TEST_F(CommandEncoderMathTestGen11, WhenAppendsAGreaterThanThenPredicateCor
auto cmdALU = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(cmdMATH + 3);
EXPECT_EQ(cmdALU->DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_SUB));
static_cast<uint32_t>(AluRegisters::opcodeSub));
}

2
shared/test/unit_test/gen12lp/test_encode_math_gen12lp.cpp
View File

@@ -64,5 +64,5 @@ GEN12LPTEST_F(CommandEncoderMathTestGen12Lp, WhenAppendsAGreaterThanThenPredicat
auto cmdALU = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(cmdMATH + 3);
EXPECT_EQ(cmdALU->DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_SUB));
static_cast<uint32_t>(AluRegisters::opcodeSub));
}

2
shared/test/unit_test/gen8/test_encode_math_gen8.cpp
View File

@@ -65,5 +65,5 @@ GEN8TEST_F(CommandEncoderMathTestGen8, WhenAppendsAGreaterThanThenPredicateCorre
auto cmdALU = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(cmdMATH + 3);
EXPECT_EQ(cmdALU->DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_SUB));
static_cast<uint32_t>(AluRegisters::opcodeSub));
}

2
shared/test/unit_test/gen9/test_encode_math_gen9.cpp
View File

@@ -65,5 +65,5 @@ GEN9TEST_F(CommandEncoderMathTestGen9, WhenAppendsAGreaterThanThenPredicateCorre
auto cmdALU = reinterpret_cast<MI_MATH_ALU_INST_INLINE *>(cmdMATH + 3);
EXPECT_EQ(cmdALU->DW0.BitField.ALUOpcode,
static_cast<uint32_t>(AluRegisters::OPCODE_SUB));
static_cast<uint32_t>(AluRegisters::opcodeSub));
}

4
shared/test/unit_test/memory_manager/memory_manager_tests.cpp
View File

@@ -3016,7 +3016,7 @@ TEST(MemoryTransferHelperTest, WhenBlitterIsSelectedButBlitCopyFailsThenFallback
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
EXPECT_EQ(BlitOperationResult::Unsupported, BlitHelperFunctions::blitMemoryToAllocation(*device, &graphicsAllocation, 0, srcData, {dataSize, 1, 1}));
EXPECT_EQ(BlitOperationResult::unsupported, BlitHelperFunctions::blitMemoryToAllocation(*device, &graphicsAllocation, 0, srcData, {dataSize, 1, 1}));
auto result = MemoryTransferHelper::transferMemoryToAllocation(true, *device, &graphicsAllocation, 0u, srcData, dataSize);
EXPECT_TRUE(result);
@@ -3041,7 +3041,7 @@ TEST(MemoryTransferHelperTest, givenBlitOperationSupportedWhenBcsEngineNotAvaila
auto bcsEngine = device->tryGetEngine(aub_stream::EngineType::ENGINE_BCS, EngineUsage::regular);
EXPECT_EQ(nullptr, bcsEngine);
EXPECT_EQ(BlitOperationResult::Unsupported, BlitHelperFunctions::blitMemoryToAllocation(*device, &graphicsAllocation, 0, srcData, {dataSize, 1, 1}));
EXPECT_EQ(BlitOperationResult::unsupported, BlitHelperFunctions::blitMemoryToAllocation(*device, &graphicsAllocation, 0, srcData, {dataSize, 1, 1}));
}
TEST(MemoryManagerTest, givenMemoryManagerWithLocalMemoryWhenCreatingMultiGraphicsAllocationInSystemMemoryThenForceSystemMemoryPlacement) {

2
shared/test/unit_test/program/program_initialization_tests.cpp
View File

@@ -205,7 +205,7 @@ TEST(AllocateGlobalSurfaceTest, GivenAllocationInLocalMemoryWhichRequiresBlitter
auto mockBlitMemoryToAllocation = [&blitsCounter](const Device &device, GraphicsAllocation *memory, size_t offset, const void *hostPtr,
Vec3<size_t> size) -> BlitOperationResult {
blitsCounter++;
return BlitOperationResult::Success;
return BlitOperationResult::success;
};
VariableBackup<BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup{
&BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation};