From 1599e5bafe5f74e4b5e0d6be93e29c6ecc755b48 Mon Sep 17 00:00:00 2001 From: Zbigniew Zdanowicz Date: Fri, 11 Jul 2025 14:35:04 +0000 Subject: [PATCH] feature: add missing experimental mcl api calls Related-To: NEO-10492 Signed-off-by: Zbigniew Zdanowicz --- .../mcl_ext/zex_mutable_cmdlist_api.cpp | 100 ++++++++++++ level_zero/core/source/cmdlist/cmdlist.h | 5 - .../cmdlist_extended/cmdlist_extended.inl | 24 --- level_zero/core/source/cmdlist/cmdlist_hw.h | 5 - .../driver/extension_function_address.cpp | 5 + .../source/mutable_cmdlist/mutable_cmdlist.h | 5 + .../mutable_cmdlist/mutable_cmdlist_hw.h | 5 + .../core/test/unit_tests/mocks/mock_cmdlist.h | 21 --- .../mutable_cmdlist_hw_experimental.inl | 146 +++++++++++++++++- .../zex_mutable_cmdlist_variable_ext.h | 115 ++++++++++++++ 10 files changed, 374 insertions(+), 57 deletions(-) diff --git a/level_zero/api/driver_experimental/public/mcl_ext/zex_mutable_cmdlist_api.cpp b/level_zero/api/driver_experimental/public/mcl_ext/zex_mutable_cmdlist_api.cpp index f0bdf89123..c172cc1285 100644 --- a/level_zero/api/driver_experimental/public/mcl_ext/zex_mutable_cmdlist_api.cpp +++ b/level_zero/api/driver_experimental/public/mcl_ext/zex_mutable_cmdlist_api.cpp @@ -266,6 +266,66 @@ zexCommandListAppendStoreRegVariable( return MutableCommandList::fromHandle(hCommandList)->appendMIStoreRegVariable(getMclAluReg(reg), variable); } +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegReg( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t destination, + zex_mcl_alu_reg_t source) { + hCommandList = toInternalType(hCommandList); + if (nullptr == hCommandList) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + return MutableCommandList::fromHandle(hCommandList)->appendMILoadRegReg(getMclAluReg(destination), getMclAluReg(source)); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegMem( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t reg, + uint64_t address) { + hCommandList = toInternalType(hCommandList); + if (nullptr == hCommandList) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + return MutableCommandList::fromHandle(hCommandList)->appendMILoadRegMem(getMclAluReg(reg), address); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegImm( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t destination, + uint32_t val) { + hCommandList = toInternalType(hCommandList); + if (nullptr == hCommandList) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + return MutableCommandList::fromHandle(hCommandList)->appendMILoadRegImm(getMclAluReg(destination), val); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMIStoreRegMem( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t reg, + uint64_t address) { + hCommandList = toInternalType(hCommandList); + if (nullptr == hCommandList) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + return MutableCommandList::fromHandle(hCommandList)->appendMIStoreRegMem(getMclAluReg(reg), address); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMIMath( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_operation_t *opArray, + size_t noOperations) { + hCommandList = toInternalType(hCommandList); + if (nullptr == hCommandList) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + return MutableCommandList::fromHandle(hCommandList)->appendMIMath(reinterpret_cast(opArray), noOperations); +} + ze_result_t ZE_APICALL zexCommandListTempMemSetEleCount( ze_command_list_handle_t hCommandList, @@ -486,6 +546,46 @@ zexCommandListAppendStoreRegVariable( return L0::MCL::zexCommandListAppendStoreRegVariable(hCommandList, reg, hVariable); } +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegReg( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t destination, + zex_mcl_alu_reg_t source) { + return L0::MCL::zexCommandListAppendMILoadRegReg(hCommandList, destination, source); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegMem( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t reg, + uint64_t address) { + return L0::MCL::zexCommandListAppendMILoadRegMem(hCommandList, reg, address); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegImm( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t destination, + uint32_t val) { + return L0::MCL::zexCommandListAppendMILoadRegImm(hCommandList, destination, val); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMIStoreRegMem( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t reg, + uint64_t address) { + return L0::MCL::zexCommandListAppendMIStoreRegMem(hCommandList, reg, address); +} + +ze_result_t ZE_APICALL +zexCommandListAppendMIMath( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_operation_t *opArray, + size_t noOperations) { + return L0::MCL::zexCommandListAppendMIMath(hCommandList, opArray, noOperations); +} + ze_result_t ZE_APICALL zexCommandListTempMemSetEleCount( ze_command_list_handle_t hCommandList, diff --git a/level_zero/core/source/cmdlist/cmdlist.h b/level_zero/core/source/cmdlist/cmdlist.h index 4c8d16082b..50865c7cf7 100644 --- a/level_zero/core/source/cmdlist/cmdlist.h +++ b/level_zero/core/source/cmdlist/cmdlist.h @@ -186,11 +186,6 @@ struct CommandList : _ze_command_list_handle_t { const size_t *pOffsets, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0; - virtual ze_result_t appendMILoadRegImm(uint32_t reg, uint32_t value, bool isBcs) = 0; - virtual ze_result_t appendMILoadRegReg(uint32_t reg1, uint32_t reg2) = 0; - virtual ze_result_t appendMILoadRegMem(uint32_t reg1, uint64_t address) = 0; - virtual ze_result_t appendMIStoreRegMem(uint32_t reg1, uint64_t address) = 0; - virtual ze_result_t appendMIMath(void *aluArray, size_t aluCount) = 0; virtual ze_result_t appendMIBBStart(uint64_t address, size_t predication, bool secondLevel) = 0; virtual ze_result_t appendMIBBEnd() = 0; virtual ze_result_t appendMINoop() = 0; diff --git a/level_zero/core/source/cmdlist/cmdlist_extended/cmdlist_extended.inl b/level_zero/core/source/cmdlist/cmdlist_extended/cmdlist_extended.inl index f12cbf618b..4a2ea6f6ae 100644 --- a/level_zero/core/source/cmdlist/cmdlist_extended/cmdlist_extended.inl +++ b/level_zero/core/source/cmdlist/cmdlist_extended/cmdlist_extended.inl @@ -11,30 +11,6 @@ namespace L0 { -template -ze_result_t CommandListCoreFamily::appendMILoadRegImm(uint32_t reg, uint32_t value, bool isBcs) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; -} -template -ze_result_t CommandListCoreFamily::appendMILoadRegReg(uint32_t reg1, uint32_t reg2) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; -} - -template -ze_result_t CommandListCoreFamily::appendMILoadRegMem(uint32_t reg1, uint64_t address) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; -} - -template -ze_result_t CommandListCoreFamily::appendMIStoreRegMem(uint32_t reg1, uint64_t address) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; -} - -template -ze_result_t CommandListCoreFamily::appendMIMath(void *aluArray, size_t aluCount) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; -} - template ze_result_t CommandListCoreFamily::appendMIBBStart(uint64_t address, size_t predication, diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.h b/level_zero/core/source/cmdlist/cmdlist_hw.h index 18ed4d02ee..98ebea171a 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw.h +++ b/level_zero/core/source/cmdlist/cmdlist_hw.h @@ -170,11 +170,6 @@ struct CommandListCoreFamily : public CommandListImp { uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents, CmdListMemoryCopyParams &memoryCopyParams) override; - ze_result_t appendMILoadRegImm(uint32_t reg, uint32_t value, bool isBcs) override; - ze_result_t appendMILoadRegReg(uint32_t reg1, uint32_t reg2) override; - ze_result_t appendMILoadRegMem(uint32_t reg1, uint64_t address) override; - ze_result_t appendMIStoreRegMem(uint32_t reg1, uint64_t address) override; - ze_result_t appendMIMath(void *aluArray, size_t aluCount) override; ze_result_t appendMIBBStart(uint64_t address, size_t predication, bool secondLevel) override; ze_result_t appendMIBBEnd() override; ze_result_t appendMINoop() override; diff --git a/level_zero/core/source/driver/extension_function_address.cpp b/level_zero/core/source/driver/extension_function_address.cpp index d8c853f335..c30bf6881d 100644 --- a/level_zero/core/source/driver/extension_function_address.cpp +++ b/level_zero/core/source/driver/extension_function_address.cpp @@ -101,6 +101,11 @@ void *ExtensionFunctionAddressHelper::getExtensionFunctionAddress(const std::str RETURN_FUNC_PTR_IF_EXIST(zexKernelSetVariableGroupSize); RETURN_FUNC_PTR_IF_EXIST(zexVariableGetInfo); RETURN_FUNC_PTR_IF_EXIST(zexCommandListGetVariablesList); + RETURN_FUNC_PTR_IF_EXIST(zexCommandListAppendMILoadRegReg); + RETURN_FUNC_PTR_IF_EXIST(zexCommandListAppendMILoadRegMem); + RETURN_FUNC_PTR_IF_EXIST(zexCommandListAppendMILoadRegImm); + RETURN_FUNC_PTR_IF_EXIST(zexCommandListAppendMIStoreRegMem); + RETURN_FUNC_PTR_IF_EXIST(zexCommandListAppendMIMath); // Metrics RETURN_FUNC_PTR_IF_EXIST(zetIntelMetricTracerCreateExp); diff --git a/level_zero/core/source/mutable_cmdlist/mutable_cmdlist.h b/level_zero/core/source/mutable_cmdlist/mutable_cmdlist.h index 391bdc89fa..71a5e74e0c 100644 --- a/level_zero/core/source/mutable_cmdlist/mutable_cmdlist.h +++ b/level_zero/core/source/mutable_cmdlist/mutable_cmdlist.h @@ -126,6 +126,11 @@ struct MutableCommandList { virtual ze_result_t appendJump(Label *label, const InterfaceOperandDescriptor *condition) = 0; virtual ze_result_t appendMILoadRegVariable(MclAluReg reg, Variable *variable) = 0; virtual ze_result_t appendMIStoreRegVariable(MclAluReg reg, Variable *variable) = 0; + virtual ze_result_t appendMILoadRegImm(MclAluReg reg, uint32_t value) = 0; + virtual ze_result_t appendMILoadRegReg(MclAluReg reg1, MclAluReg reg2) = 0; + virtual ze_result_t appendMILoadRegMem(MclAluReg reg1, uint64_t address) = 0; + virtual ze_result_t appendMIStoreRegMem(MclAluReg reg1, uint64_t address) = 0; + virtual ze_result_t appendMIMath(void *aluArray, size_t aluCount) = 0; virtual ze_result_t tempMemSetElementCount(size_t elementCount) = 0; virtual ze_result_t tempMemGetSize(size_t *tempMemSize) = 0; diff --git a/level_zero/core/source/mutable_cmdlist/mutable_cmdlist_hw.h b/level_zero/core/source/mutable_cmdlist/mutable_cmdlist_hw.h index 9546971f18..0bf3f15fa4 100644 --- a/level_zero/core/source/mutable_cmdlist/mutable_cmdlist_hw.h +++ b/level_zero/core/source/mutable_cmdlist/mutable_cmdlist_hw.h @@ -76,6 +76,11 @@ struct MutableCommandListCoreFamily : public MutableCommandListImp, public Comma ze_result_t appendSetPredicate(NEO::MiPredicateType predicateType) override; ze_result_t appendMILoadRegVariable(MclAluReg reg, Variable *variable) override; ze_result_t appendMIStoreRegVariable(MclAluReg reg, Variable *variable) override; + ze_result_t appendMILoadRegImm(MclAluReg reg, uint32_t value) override; + ze_result_t appendMILoadRegReg(MclAluReg reg1, MclAluReg reg2) override; + ze_result_t appendMILoadRegMem(MclAluReg reg1, uint64_t address) override; + ze_result_t appendMIStoreRegMem(MclAluReg reg1, uint64_t address) override; + ze_result_t appendMIMath(void *aluArray, size_t aluCount) override; void programStateBaseAddressHook(size_t cmdBufferOffset, bool surfaceBaseAddressModify) override; void setBufferSurfaceState(void *address, NEO::GraphicsAllocation *alloc, Variable *variable) override; diff --git a/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h b/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h index a98a814f06..00d2aae45f 100644 --- a/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h +++ b/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h @@ -565,27 +565,6 @@ struct Mock : public CommandList { uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents)); - ADDMETHOD_NOBASE(appendMILoadRegImm, ze_result_t, ZE_RESULT_SUCCESS, - (uint32_t reg, - uint32_t value, - bool isBcs)); - - ADDMETHOD_NOBASE(appendMILoadRegReg, ze_result_t, ZE_RESULT_SUCCESS, - (uint32_t reg1, - uint32_t reg2)); - - ADDMETHOD_NOBASE(appendMILoadRegMem, ze_result_t, ZE_RESULT_SUCCESS, - (uint32_t reg1, - uint64_t address)); - - ADDMETHOD_NOBASE(appendMIStoreRegMem, ze_result_t, ZE_RESULT_SUCCESS, - (uint32_t reg1, - uint64_t address)); - - ADDMETHOD_NOBASE(appendMIMath, ze_result_t, ZE_RESULT_SUCCESS, - (void *aluArray, - size_t aluCount)); - ADDMETHOD_NOBASE(appendMIBBStart, ze_result_t, ZE_RESULT_SUCCESS, (uint64_t address, size_t predication, diff --git a/level_zero/experimental/source/mutable_cmdlist/mutable_cmdlist_hw_experimental.inl b/level_zero/experimental/source/mutable_cmdlist/mutable_cmdlist_hw_experimental.inl index 12920a1245..4b920adb79 100644 --- a/level_zero/experimental/source/mutable_cmdlist/mutable_cmdlist_hw_experimental.inl +++ b/level_zero/experimental/source/mutable_cmdlist/mutable_cmdlist_hw_experimental.inl @@ -51,6 +51,147 @@ constexpr uint32_t regToMMIO(MclAluReg reg) { return 0; } +template +ze_result_t MutableCommandListCoreFamily::appendMILoadRegImm(MclAluReg reg, uint32_t value) { + NEO::LriHelper::program(this->commandContainer.getCommandStream(), + regToMMIO(reg), + value, + false, + this->isCopyOnly(false)); + return ZE_RESULT_SUCCESS; +} + +template +ze_result_t MutableCommandListCoreFamily::appendMILoadRegReg(MclAluReg reg1, MclAluReg reg2) { + using MI_LOAD_REGISTER_REG = typename GfxFamily::MI_LOAD_REGISTER_REG; + MI_LOAD_REGISTER_REG cmd = GfxFamily::cmdInitLoadRegisterReg; + cmd.setSourceRegisterAddress(regToMMIO(reg2)); + cmd.setDestinationRegisterAddress(regToMMIO(reg1)); + auto buffer = this->commandContainer.getCommandStream()->getSpace(sizeof(cmd)); + *reinterpret_cast(buffer) = cmd; + return ZE_RESULT_SUCCESS; +} + +template +ze_result_t MutableCommandListCoreFamily::appendMILoadRegMem(MclAluReg reg1, uint64_t address) { + using MI_LOAD_REGISTER_MEM = typename GfxFamily::MI_LOAD_REGISTER_MEM; + MI_LOAD_REGISTER_MEM cmd = GfxFamily::cmdInitLoadRegisterMem; + cmd.setRegisterAddress(regToMMIO(reg1)); + cmd.setMemoryAddress(address); + auto buffer = this->commandContainer.getCommandStream()->getSpace(sizeof(cmd)); + *reinterpret_cast(buffer) = cmd; + return ZE_RESULT_SUCCESS; +} + +template +ze_result_t MutableCommandListCoreFamily::appendMIStoreRegMem(MclAluReg reg1, uint64_t address) { + using MI_STORE_REGISTER_MEM = typename GfxFamily::MI_STORE_REGISTER_MEM; + MI_STORE_REGISTER_MEM cmd0 = GfxFamily::cmdInitStoreRegisterMem; + cmd0.setRegisterAddress(regToMMIO(reg1)); + cmd0.setMemoryAddress(address); + auto buffer = this->commandContainer.getCommandStream()->getSpace(sizeof(cmd0)); + *reinterpret_cast(buffer) = cmd0; + return ZE_RESULT_SUCCESS; +} + +template +ze_result_t MutableCommandListCoreFamily::appendMIMath(void *aluArray, size_t aluCount) { + using MI_MATH = typename GfxFamily::MI_MATH; + using MI_MATH_ALU_INST_INLINE = typename GfxFamily::MI_MATH_ALU_INST_INLINE; + constexpr int32_t aluRegisterRSrca = 0x20; + constexpr int32_t aluRegisterRSrcb = 0x21; + + // Add instruction MI_MATH with 4 MI_MATH_ALU_INST_INLINE operands + auto pCmd3 = reinterpret_cast(this->commandContainer.getCommandStream()->getSpace(sizeof(MI_MATH) + aluCount * 4 * sizeof(MI_MATH_ALU_INST_INLINE))); + MI_MATH miMath; + miMath.DW0.Value = 0x0; + miMath.DW0.BitField.InstructionType = MI_MATH::COMMAND_TYPE_MI_COMMAND; + miMath.DW0.BitField.InstructionOpcode = MI_MATH::MI_COMMAND_OPCODE_MI_MATH; + // 0x3 - 5 Dwords length cmd (-2): 1 for MI_MATH, 4 for MI_MATH_ALU_INST_INLINE + miMath.DW0.BitField.DwordLength = static_cast(aluCount * 4 - 1); + *reinterpret_cast(pCmd3) = miMath; + pCmd3++; + MI_MATH_ALU_INST_INLINE *pAluParam = reinterpret_cast(pCmd3); + MI_MATH_ALU_INST_INLINE aluParam; + + zex_mcl_alu_operation_t *exAluArray = reinterpret_cast(aluArray); + for (size_t loop = 0; loop < aluCount; loop++, exAluArray++) { + aluParam.DW0.Value = 0x0; + // Setup first operand of MI_MATH - load regSource1 into register A + if (exAluArray->regSource1 != zex_mcl_alu_reg_t::ZE_MCL_ALU_REG_NONE) { + switch (exAluArray->regSource1) { + case zex_mcl_alu_reg_t::ZE_MCL_ALU_REG_CONST0: + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_LOAD0); + break; + case zex_mcl_alu_reg_t::ZE_MCL_ALU_REG_CONST1: + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_LOAD1); + break; + default: + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_LOAD); + break; + } + + aluParam.DW0.BitField.Operand1 = aluRegisterRSrca; + aluParam.DW0.BitField.Operand2 = static_cast(exAluArray->regSource1) / 2; + + } else { + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_NOOP); + aluParam.DW0.BitField.Operand1 = 0; + aluParam.DW0.BitField.Operand2 = 0; + } + *pAluParam = aluParam; + pAluParam++; + + aluParam.DW0.Value = 0x0; + // Setup second operand of MI_MATH - load regSource2 into register B + if (exAluArray->regSource2 != zex_mcl_alu_reg_t::ZE_MCL_ALU_REG_NONE) { + switch (exAluArray->regSource2) { + case zex_mcl_alu_reg_t::ZE_MCL_ALU_REG_CONST0: + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_LOAD0); + break; + case zex_mcl_alu_reg_t::ZE_MCL_ALU_REG_CONST1: + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_LOAD1); + break; + default: + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_LOAD); + break; + } + aluParam.DW0.BitField.Operand1 = aluRegisterRSrcb; + aluParam.DW0.BitField.Operand2 = static_cast(exAluArray->regSource2) / 2; + + } else { + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_NOOP); + aluParam.DW0.BitField.Operand1 = 0; + aluParam.DW0.BitField.Operand2 = 0; + } + *pAluParam = aluParam; + pAluParam++; + + // Setup third operand of MI_MATH - "Operation" on registers A and B + aluParam.DW0.Value = 0x0; + aluParam.DW0.BitField.ALUOpcode = static_cast(exAluArray->opType); + aluParam.DW0.BitField.Operand1 = 0; + aluParam.DW0.BitField.Operand2 = 0; + *pAluParam = aluParam; + pAluParam++; + + aluParam.DW0.Value = 0x0; + // Setup fourth operand of MI_MATH - store result into regDest + if (exAluArray->flag >= zex_mcl_alu_flag_t::ZE_MCL_ALU_FLAG_NACC) { + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_STOREINV); + aluParam.DW0.BitField.Operand2 = static_cast(exAluArray->flag) - 0x100; + } else { + aluParam.DW0.BitField.ALUOpcode = static_cast(zex_mcl_alu_op_type_t::ZE_MCL_ALU_OP_STORE); + aluParam.DW0.BitField.Operand2 = static_cast(exAluArray->flag); + } + aluParam.DW0.BitField.Operand1 = static_cast(exAluArray->regDest) / 2; + *pAluParam = aluParam; + pAluParam++; + } + + return ZE_RESULT_SUCCESS; +} + template ze_result_t MutableCommandListCoreFamily::appendJump(Label *label, const InterfaceOperandDescriptor *condition) { auto cs = this->commandContainer.getCommandStream(); @@ -60,8 +201,9 @@ ze_result_t MutableCommandListCoreFamily::appendJump(Label *label if (condition->memory != nullptr) { if (condition->flags & InterfaceOperandDescriptor::Flags::usesVariable) { auto variable = reinterpret_cast(condition->memory); - if (false == variable->isType(VariableType::buffer)) + if (false == variable->isType(VariableType::buffer)) { return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } appendMILoadRegVariable(MclAluReg::mclAluRegPredicate2, variable); } else { @@ -69,7 +211,7 @@ ze_result_t MutableCommandListCoreFamily::appendJump(Label *label NEO::EncodeSetMMIO::encodeMEM(*cs, regToMMIO(MclAluReg::mclAluRegPredicate2), memAddr, getBase()->isCopyOnly(false)); } } else { - auto regMMIO = static_cast(condition->offset); + auto regMMIO = regToMMIO(static_cast(condition->offset)); NEO::EncodeSetMMIO::encodeREG(*cs, regToMMIO(MclAluReg::mclAluRegPredicate2), regMMIO, getBase()->isCopyOnly(false)); } diff --git a/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h b/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h index 07d1ecd88d..cd989ff5e3 100644 --- a/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h +++ b/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h @@ -149,6 +149,40 @@ typedef enum _zex_mcl_alu_reg_t { ZE_MCL_ALU_REG_MAX = 42 } zex_mcl_alu_reg_t; +typedef enum _zex_mcl_alu_op_type_t { + ZE_MCL_ALU_OP_ADD = 0x100, + ZE_MCL_ALU_OP_SUB = 0x101, + ZE_MCL_ALU_OP_AND = 0x102, + ZE_MCL_ALU_OP_OR = 0x103, + ZE_MCL_ALU_OP_XOR = 0x104, + ZE_MCL_ALU_OP_STORE = 0x180, + ZE_MCL_ALU_OP_STOREINV = 0x580, + ZE_MCL_ALU_OP_LOAD = 0x080, + ZE_MCL_ALU_OP_LOAD0 = 0x081, + ZE_MCL_ALU_OP_LOAD1 = 0x481, + ZE_MCL_ALU_OP_LOADINV = 0x480, + ZE_MCL_ALU_OP_NOOP = 0x0, + ZE_MCL_ALU_OP_MAX +} zex_mcl_alu_op_type_t; + +typedef enum _zex_mcl_alu_flag_t { + ZE_MCL_ALU_FLAG_ACC = 0x31, + ZE_MCL_ALU_FLAG_ZF = 0x32, + ZE_MCL_ALU_FLAG_CF = 0x33, + ZE_MCL_ALU_FLAG_NACC = ZE_MCL_ALU_FLAG_ACC + 0x100, + ZE_MCL_ALU_FLAG_NZF = ZE_MCL_ALU_FLAG_ZF + 0x100, + ZE_MCL_ALU_FLAG_NCF = ZE_MCL_ALU_FLAG_CF + 0x100, + ZE_MCL_ALU_FLAG_MAX +} zex_mcl_alu_flag_t; + +typedef struct _zex_mcl_alu_operation_t { + zex_mcl_alu_op_type_t opType; + zex_mcl_alu_reg_t regDest; + zex_mcl_alu_reg_t regSource1; + zex_mcl_alu_reg_t regSource2; + zex_mcl_alu_flag_t flag; +} zex_mcl_alu_operation_t; + /////////////////////////////////////////////////////////////////////////////// /// @brief Appends command loading value (DWORD) to GPR register from /// variable's buffer. @@ -167,6 +201,62 @@ zexCommandListAppendStoreRegVariable( zex_mcl_alu_reg_t reg, ///< [in] GPR register source zex_variable_handle_t hVariable); ///< [in] handle of variable +/////////////////////////////////////////////////////////////////////////////// +/// @brief Appends command to load a value from source register to destination register. +/// +/// @details +/// - Performs a register-to-register copy operation. +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegReg( + ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list + zex_mcl_alu_reg_t destination, ///< [in] destination register + zex_mcl_alu_reg_t source); ///< [in] source register + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Appends command to load a value from memory address to register. +/// +/// @details +/// - Loads a DWORD from the specified memory address into the register. +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegMem( + ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list + zex_mcl_alu_reg_t reg, ///< [in] destination register + uint64_t address); ///< [in] source memory address + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Appends command to load an immediate value into a register. +/// +/// @details +/// - Loads the provided immediate 32-bit value into the destination register. +ze_result_t ZE_APICALL +zexCommandListAppendMILoadRegImm( + ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list + zex_mcl_alu_reg_t destination, ///< [in] destination register + uint32_t val); ///< [in] immediate value to load + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Appends command to store a value from register to memory. +/// +/// @details +/// - Stores a DWORD from the register to the specified memory address. +ze_result_t ZE_APICALL +zexCommandListAppendMIStoreRegMem( + ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list + zex_mcl_alu_reg_t reg, ///< [in] source register + uint64_t address); ///< [in] destination memory address + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Appends commands to perform ALU operations. +/// +/// @details +/// - Executes an array of ALU operations in sequence. +/// - Operations can include arithmetic, logical, and register transfer commands. +ze_result_t ZE_APICALL +zexCommandListAppendMIMath( + ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list + zex_mcl_alu_operation_t *opArray, ///< [in] array of ALU operations to perform + size_t noOperations); ///< [in] number of operations in the array + typedef ze_result_t(ZE_APICALL *zex_pfnKernelSetArgumentVariableCb_t)( ze_kernel_handle_t hKernel, uint32_t argIndex, @@ -188,6 +278,31 @@ typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendStoreRegVariableCb_t)( zex_mcl_alu_reg_t reg, zex_variable_handle_t hVariable); +typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMILoadRegRegCb_t)( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t destination, + zex_mcl_alu_reg_t source); + +typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMILoadRegMemCb_t)( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t reg, + uint64_t address); + +typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMILoadRegImmCb_t)( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t destination, + uint32_t val); + +typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMIStoreRegMemCb_t)( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_reg_t reg, + uint64_t address); + +typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMIMathCb_t)( + ze_command_list_handle_t hCommandList, + zex_mcl_alu_operation_t *opArray, + size_t noOperations); + #if defined(__cplusplus) } // extern "C" #endif