[QNN EP]: Fusion of multiply and reciprocal to divide #302
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,190 @@ | ||
| // Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. | ||
| // SPDX-License-Identifier: MIT | ||
|
|
||
| // ReciprocalMulFusion: Fuses SingleNode Reciprocal->Mul into ElementWiseDivide. | ||
| // QDQGroup pattern avoided to preserve separate quantization of 1/b. | ||
|
|
||
| #include "core/providers/qnn/builder/qnn_node_group/reciprocal_mul_fusion.h" | ||
|
|
||
| #include <array> | ||
| #include <memory> | ||
| #include <string> | ||
| #include <unordered_map> | ||
| #include <utility> | ||
|
|
||
| #include <gsl/gsl> | ||
|
|
||
| #include "core/providers/qnn/builder/op_builder_factory.h" | ||
| #include "core/providers/qnn/builder/qnn_model_wrapper.h" | ||
| #include "core/providers/qnn/builder/qnn_node_group/utils.h" | ||
| #include "core/providers/qnn/builder/qnn_utils.h" | ||
| #include "core/providers/qnn/ort_api.h" | ||
|
|
||
| namespace onnxruntime { | ||
| namespace qnn { | ||
|
|
||
| // Convenience macros for validation and creation paths. | ||
| #define ValidateOnQnn(qnn_model_wrapper, reciprocal_node_unit, mul_node_unit, recip_is_mul_input0) \ | ||
| CreateOrValidateOnQnn((qnn_model_wrapper), (reciprocal_node_unit), (mul_node_unit), (recip_is_mul_input0), /*validate=*/true) | ||
| #define CreateOnQnn(qnn_model_wrapper, reciprocal_node_unit, mul_node_unit, recip_is_mul_input0) \ | ||
| CreateOrValidateOnQnn((qnn_model_wrapper), (reciprocal_node_unit), (mul_node_unit), (recip_is_mul_input0), /*validate=*/false) | ||
|
|
||
| // Forward declaration. | ||
| static Ort::Status CreateOrValidateOnQnn(QnnModelWrapper& qnn_model_wrapper, | ||
| const OrtNodeUnit& reciprocal_node_unit, | ||
| const OrtNodeUnit& mul_node_unit, | ||
| bool recip_is_mul_input0, | ||
| bool validate); | ||
|
|
||
| // TryFusion: Matches Reciprocal->Mul pattern and validates fusion. | ||
| std::unique_ptr<IQnnNodeGroup> ReciprocalMulFusion::TryFusion( | ||
| QnnModelWrapper& qnn_model_wrapper, | ||
| const OrtNodeUnit& reciprocal_node_unit, | ||
| const std::unordered_map<const OrtNode*, const OrtNodeUnit*>& node_to_node_unit, | ||
| const std::unordered_map<const OrtNodeUnit*, const IQnnNodeGroup*>& node_unit_to_qnn_node_group, | ||
| const Ort::Logger& logger) { | ||
| ORT_UNUSED_PARAMETER(logger); | ||
|
|
||
| // Step 1: Check op-type and unit type. | ||
| // Only accept SingleNode Reciprocal to preserve separate quantization of 1/b. | ||
| if (reciprocal_node_unit.OpType() != "Reciprocal" || | ||
| reciprocal_node_unit.UnitType() != OrtNodeUnit::Type::SingleNode) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| // Step 2: Locate single Mul consumer (handles QDQ boundaries). | ||
| const OrtNodeUnit* mul_node_unit = | ||
| GetChildNodeUnitAllowQdq(qnn_model_wrapper, reciprocal_node_unit, "Mul", | ||
| node_to_node_unit, node_unit_to_qnn_node_group); | ||
| if (mul_node_unit == nullptr) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| // Step 3: Determine which Mul input carries the Reciprocal output. | ||
| const auto& mul_inputs = mul_node_unit->Inputs(); | ||
| const std::string& recip_output_name = reciprocal_node_unit.Outputs()[0].name; | ||
| bool recip_is_mul_input0 = (mul_inputs[0].name == recip_output_name); | ||
| bool recip_is_mul_input1 = (mul_inputs[1].name == recip_output_name); | ||
|
|
||
| if (!recip_is_mul_input0 && !recip_is_mul_input1) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| if (recip_is_mul_input0 && recip_is_mul_input1) { | ||
| return nullptr; // Both inputs same: would change semantics. | ||
| } | ||
|
|
||
| // Step 4: QNN capability validation (dry-run). | ||
| if (Ort::Status status = ValidateOnQnn(qnn_model_wrapper, reciprocal_node_unit, *mul_node_unit, recip_is_mul_input0); | ||
| !status.IsOK()) { | ||
| return nullptr; | ||
| } | ||
|
|
||
| // Step 5: Construct fusion object. | ||
| return std::make_unique<ReciprocalMulFusion>(reciprocal_node_unit, *mul_node_unit, recip_is_mul_input0); | ||
| } | ||
|
|
||
| ReciprocalMulFusion::ReciprocalMulFusion(const OrtNodeUnit& reciprocal_node_unit, | ||
| const OrtNodeUnit& mul_node_unit, | ||
| bool recip_is_mul_input0) | ||
| : node_units_{&reciprocal_node_unit, &mul_node_unit}, | ||
| recip_is_mul_input0_{recip_is_mul_input0} { | ||
| } | ||
|
|
||
| Ort::Status ReciprocalMulFusion::IsSupported(QnnModelWrapper& qmw, | ||
| const Ort::Logger& logger) const { | ||
| ORT_UNUSED_PARAMETER(logger); | ||
| return ValidateOnQnn(qmw, *node_units_[0], *node_units_[1], recip_is_mul_input0_); | ||
| } | ||
|
|
||
| Ort::Status ReciprocalMulFusion::AddToModelBuilder(QnnModelWrapper& qmw, | ||
| const Ort::Logger& logger) const { | ||
| ORT_UNUSED_PARAMETER(logger); | ||
| return CreateOnQnn(qmw, *node_units_[0], *node_units_[1], recip_is_mul_input0_); | ||
| } | ||
|
|
||
| gsl::span<const OrtNodeUnit* const> ReciprocalMulFusion::GetNodeUnits() const { | ||
| return node_units_; | ||
| } | ||
|
|
||
| const OrtNodeUnit* ReciprocalMulFusion::GetTargetNodeUnit() const { | ||
| return node_units_[1]; // Mul is the convergence point. | ||
| } | ||
|
|
||
| // CreateOrValidateOnQnn: Shared validate/build path. | ||
| static Ort::Status CreateOrValidateOnQnn(QnnModelWrapper& qnn_model_wrapper, | ||
| const OrtNodeUnit& reciprocal_node_unit, | ||
| const OrtNodeUnit& mul_node_unit, | ||
| bool recip_is_mul_input0, | ||
| bool validate) { | ||
| RETURN_IF_NOT(reciprocal_node_unit.OpType() == "Reciprocal", | ||
| ("ReciprocalMulFusion: expected Reciprocal op, got " + reciprocal_node_unit.OpType()).c_str()); | ||
| RETURN_IF_NOT(mul_node_unit.OpType() == "Mul", | ||
| ("ReciprocalMulFusion: expected Mul op, got " + mul_node_unit.OpType()).c_str()); | ||
|
|
||
| // Resolve tensor roles. | ||
| const OrtNodeUnitIODef& denominator_def = reciprocal_node_unit.Inputs()[0]; | ||
| const auto& mul_inputs = mul_node_unit.Inputs(); | ||
| const OrtNodeUnitIODef& numerator_def = recip_is_mul_input0 ? mul_inputs[1] : mul_inputs[0]; | ||
| const OrtNodeUnitIODef& output_def = mul_node_unit.Outputs()[0]; | ||
| const std::string node_name = utils::UniqueNameGenerator().New(reciprocal_node_unit); | ||
|
|
||
| if (validate) { | ||
| // Dry-run: capability query only. | ||
| QnnTensorWrapper numerator_tensor; | ||
| QnnTensorWrapper denominator_tensor; | ||
| QnnTensorWrapper output_tensor; | ||
|
|
||
| RETURN_IF_ERROR(qnn_model_wrapper.MakeTensorWrapper(numerator_def, numerator_tensor)); | ||
| RETURN_IF_ERROR(qnn_model_wrapper.MakeTensorWrapper(denominator_def, denominator_tensor)); | ||
| RETURN_IF_ERROR(qnn_model_wrapper.MakeTensorWrapper(output_def, output_tensor)); | ||
|
|
||
| RETURN_IF_ERROR(qnn_model_wrapper.ValidateQnnNode( | ||
| node_name, | ||
| QNN_OP_PACKAGE_NAME_QTI_AISW, | ||
| QNN_OP_ELEMENT_WISE_DIVIDE, | ||
| /*input_tensors=*/{numerator_tensor.GetQnnTensor(), denominator_tensor.GetQnnTensor()}, | ||
| /*output_tensors=*/{output_tensor.GetQnnTensor()}, | ||
| /*params=*/{})); | ||
| } else { | ||
| // Build path: register tensors and create QNN node. | ||
|
|
||
| if (!qnn_model_wrapper.IsQnnTensorWrapperExist(numerator_def.name)) { | ||
| QnnTensorWrapper numerator_tensor; | ||
| RETURN_IF_ERROR(qnn_model_wrapper.MakeTensorWrapper(numerator_def, numerator_tensor)); | ||
| RETURN_IF_NOT(qnn_model_wrapper.AddTensorWrapper(std::move(numerator_tensor)), | ||
| "ReciprocalMulFusion: failed to add numerator tensor wrapper."); | ||
| } | ||
|
|
||
| if (!qnn_model_wrapper.IsQnnTensorWrapperExist(denominator_def.name)) { | ||
| QnnTensorWrapper denominator_tensor; | ||
| RETURN_IF_ERROR(qnn_model_wrapper.MakeTensorWrapper(denominator_def, denominator_tensor)); | ||
| RETURN_IF_NOT(qnn_model_wrapper.AddTensorWrapper(std::move(denominator_tensor)), | ||
| "ReciprocalMulFusion: failed to add denominator tensor wrapper."); | ||
| } | ||
|
|
||
| if (!qnn_model_wrapper.IsQnnTensorWrapperExist(output_def.name)) { | ||
| QnnTensorWrapper output_tensor; | ||
| RETURN_IF_ERROR(qnn_model_wrapper.MakeTensorWrapper(output_def, output_tensor)); | ||
| RETURN_IF_NOT(qnn_model_wrapper.AddTensorWrapper(std::move(output_tensor)), | ||
| "ReciprocalMulFusion: failed to add output tensor wrapper."); | ||
| } | ||
|
|
||
| // Create fused ElementWiseDivide node. | ||
| RETURN_IF_NOT( | ||
| qnn_model_wrapper.CreateQnnNode( | ||
| node_name, | ||
| QNN_OP_PACKAGE_NAME_QTI_AISW, | ||
| QNN_OP_ELEMENT_WISE_DIVIDE, | ||
| /*input_names=*/{numerator_def.name, denominator_def.name}, | ||
| /*output_names=*/{output_def.name}, | ||
| /*param_tensor_names=*/{}, | ||
| /*do_op_validation=*/validate), | ||
| "ReciprocalMulFusion: failed to create fused ElementWiseDivide node."); | ||
| } | ||
|
|
||
| return Ort::Status(); | ||
| } | ||
|
|
||
| } // namespace qnn | ||
| } // namespace onnxruntime |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,48 @@ | ||
| // Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. | ||
| // SPDX-License-Identifier: MIT | ||
|
|
||
| // ReciprocalMulFusion: Fuses SingleNode Reciprocal->Mul into ElementWiseDivide. | ||
|
|
||
| #pragma once | ||
|
|
||
| #include <array> | ||
| #include <memory> | ||
| #include <unordered_map> | ||
|
|
||
| #include "core/providers/qnn/builder/qnn_node_group/qnn_node_group.h" | ||
| #include "core/providers/qnn/ort_api.h" | ||
|
|
||
| namespace onnxruntime { | ||
| namespace qnn { | ||
|
|
||
| class QnnModelWrapper; | ||
|
|
||
| /// Fuses Reciprocal->Mul into ElementWiseDivide (SingleNode only to preserve quantization). | ||
| class ReciprocalMulFusion : public IQnnNodeGroup { | ||
| public: | ||
| ReciprocalMulFusion(const OrtNodeUnit& reciprocal_node_unit, const OrtNodeUnit& mul_node_unit, | ||
| bool recip_is_mul_input0); | ||
| ORT_DISALLOW_COPY_AND_ASSIGNMENT(ReciprocalMulFusion); | ||
|
|
||
| // IQnnNodeGroup interface | ||
| Ort::Status IsSupported(QnnModelWrapper& qmw, const Ort::Logger& logger) const override; | ||
| Ort::Status AddToModelBuilder(QnnModelWrapper& qmw, const Ort::Logger& logger) const override; | ||
| gsl::span<const OrtNodeUnit* const> GetNodeUnits() const override; | ||
| const OrtNodeUnit* GetTargetNodeUnit() const override; | ||
| std::string_view Type() const override { return "ReciprocalMulFusion"; } | ||
|
|
||
| // Factory | ||
| static std::unique_ptr<IQnnNodeGroup> TryFusion( | ||
| QnnModelWrapper& qnn_model_wrapper, | ||
| const OrtNodeUnit& reciprocal_node_unit, | ||
| const std::unordered_map<const OrtNode*, const OrtNodeUnit*>& node_to_node_unit, | ||
| const std::unordered_map<const OrtNodeUnit*, const IQnnNodeGroup*>& node_unit_to_qnn_node_group, | ||
| const Ort::Logger& logger); | ||
|
|
||
| private: | ||
| std::array<const OrtNodeUnit*, 2> node_units_; // [0]=Reciprocal, [1]=Mul | ||
| bool recip_is_mul_input0_{false}; // Which Mul input slot carries Reciprocal output. | ||
| }; | ||
|
|
||
| } // namespace qnn | ||
| } // namespace onnxruntime |
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
this is not needed as there are no changes in this file.