NXP backend: Update eIQ Neutron SDK to 3.1.2 (pytorch#19938)

### Summary
This PR updates the Neutron SDK to the most recent version (3.1.2). This
version removes the old conversion flow and forces the use of the new
MLIR flow. This change is reflected in ExecuTorch NXP backend by the
removal of the `use_new_flow_neutron_c` flag.


### Test plan
Tested by all NXP backend tests.


cc @robert-kalmar @JakeStevens @digantdesai @rascani

Author: MartinPavella

backends/nxp/backend/ir/converter/node_converters/ops_converters/abs_converter.py

@@ -34,15 +34,11 @@ def _is_supported_on_target(
         parameters_mapping: dict[str, Parameter],
         custom_delegation_options: CustomDelegationOptions,
     ) -> bool:
-
-        if neutron_target_spec.use_new_flow_neutron_c:
-            # Requirements specified by the new Neutron flow documentation.
-
-            supported_types = [torch.int8, torch.uint8]
-            if not NodeConverter.uses_quantization_type_for_io(
-                node, supported_types, [0], [0]
-            ):
-                return False
+        supported_types = [torch.int8, torch.uint8]
+        if not NodeConverter.uses_quantization_type_for_io(
+            node, supported_types, [0], [0]
+        ):
+            return False
 
         return True
 

backends/nxp/backend/ir/converter/node_converters/ops_converters/adaptive_avg_pool_2d_converter.py

@@ -78,22 +78,19 @@ def _is_supported_on_target(
             AdaptiveAvgPool2dConverter._get_equivalent_avg_pool_parameters(node)
         )
 
-        if neutron_target_spec.use_new_flow_neutron_c:
-            # Requirements specified by the new Neutron flow documentation.
-
-            if not NodeConverter.uses_quantization_type_for_io(
-                node,
-                supported_types=[torch.int8, torch.uint8],
-                input_indices=[0],
-                output_indices=[0],
-            ):
-                return False
-
-            if any(k > 4096 for k in kernel_size):
-                return False
-
-            if any(s > 4096 for s in stride):
-                return False
+        if not NodeConverter.uses_quantization_type_for_io(
+            node,
+            supported_types=[torch.int8, torch.uint8],
+            input_indices=[0],
+            output_indices=[0],
+        ):
+            return False
+
+        if any(k > 4096 for k in kernel_size):
+            return False
+
+        if any(s > 4096 for s in stride):
+            return False
 
         return True
 

backends/nxp/backend/ir/converter/node_converters/ops_converters/add_tensor_converter.py

@@ -26,33 +26,24 @@ def _is_supported_on_target(
         parameters_mapping: dict[str, Parameter],
         custom_delegation_options: CustomDelegationOptions,
     ) -> bool:
-        if neutron_target_spec.use_new_flow_neutron_c:
-            if not NodeConverter.at_least_one_input_shape_matches_the_output_shape(
-                node
-            ):
-                return False
-
-            # If one input is in channel first and ranks of input tensors are not equal, we need to add Transposes
-            # Transpose is currently not supported for new flow
-            if any(
-                input_node.meta[NXP_NODE_FORMAT].is_channels_first()
-                for input_node in node.all_input_nodes
-            ) and NodeConverter._node_inputs_ranks_not_equal(node):
-                return False
+        if not NodeConverter.at_least_one_input_shape_matches_the_output_shape(node):
+            return False
 
-            supported_types = [torch.int8, torch.uint8]
-            if not NodeConverter.uses_quantization_type_for_io(
-                node, supported_types, [0, 1], [0]
-            ):
-                return False
+        # If one input is in channel first and ranks of input tensors are not equal, we need to add Transposes
+        # Transpose is currently not supported for new flow
+        if any(
+            input_node.meta[NXP_NODE_FORMAT].is_channels_first()
+            for input_node in node.all_input_nodes
+        ) and NodeConverter._node_inputs_ranks_not_equal(node):
+            return False
 
-            return True
-        else:
-            if NodeConverter.uses_shape_broadcasting(node):
-                # Shape broadcasting may require the addition of `Transpose` ops during conversion.
-                return False
+        supported_types = [torch.int8, torch.uint8]
+        if not NodeConverter.uses_quantization_type_for_io(
+            node, supported_types, [0, 1], [0]
+        ):
+            return False
 
-            return True
+        return True
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/avg_pool_2d_converter.py

@@ -64,20 +64,17 @@ def _is_supported_on_target(
         kernel = node.args[1]
         stride = node.args[2]
 
-        if neutron_target_spec.use_new_flow_neutron_c:
-            # Requirements specified by the new Neutron flow documentation.
-
-            supported_types = [torch.int8, torch.uint8]
-            if not NodeConverter.uses_quantization_type_for_io(
-                node, supported_types, [0], [0]
-            ):
-                return False
+        supported_types = [torch.int8, torch.uint8]
+        if not NodeConverter.uses_quantization_type_for_io(
+            node, supported_types, [0], [0]
+        ):
+            return False
 
-            if any(k > 4096 for k in kernel):
-                return False
+        if any(k > 4096 for k in kernel):
+            return False
 
-            if any(s > 4096 for s in stride):
-                return False
+        if any(s > 4096 for s in stride):
+            return False
 
         return True
 

backends/nxp/backend/ir/converter/node_converters/ops_converters/clamp_converter.py

@@ -109,21 +109,18 @@ def _is_supported_on_target(
         if all(b is None or math.isinf(b) for b in bounds):
             return False
 
-        if neutron_target_spec.use_new_flow_neutron_c:
-            io_quant_consistent = ClampConverter._io_quant_is_same(node)
-            quant_supported = NodeConverter.uses_quantization_type_for_io(
-                node,
-                supported_types=[torch.int8, torch.uint8],
-                input_indices=[0],
-                output_indices=[0],
-            )
-
-            # We either convert to ReLU -> SingleInputQuantization pattern
-            # or we convert to Min/Max, which requires same quantization on
-            # both input and output.
-            return (relu_compatible | io_quant_consistent) and quant_supported
+        io_quant_consistent = ClampConverter._io_quant_is_same(node)
+        quant_supported = NodeConverter.uses_quantization_type_for_io(
+            node,
+            supported_types=[torch.int8, torch.uint8],
+            input_indices=[0],
+            output_indices=[0],
+        )
 
-        return relu_compatible
+        # We either convert to ReLU -> SingleInputQuantization pattern
+        # or we convert to Min/Max, which requires same quantization on
+        # both input and output.
+        return (relu_compatible | io_quant_consistent) and quant_supported
 
     @classmethod
     def supports_partitioning_result(
@@ -183,7 +180,7 @@ def convert(self, node: Node):
         t_op = self._create_tflite_op_with_io_tensors(node)
 
         # Clamp convertible to some variant of ReLU
-        if not self.neutron_target_spec.use_new_flow_neutron_c or to_relu:
+        if to_relu:
             # noinspection PyTypeChecker,PyUnboundLocalVariable
             t_op.opcode_index = self.builder.op_code_index_for_op_type(
                 self.BOUNDS_TO_RELU_NEUTRON_IR_OP[bounds]

backends/nxp/backend/ir/converter/node_converters/ops_converters/constant_pad_nd_converter.py

@@ -9,8 +9,6 @@
 import numpy as np
 import torch
 
-from executorch.backends.nxp.backend.data_format import NXP_NODE_FORMAT
-
 from executorch.backends.nxp.backend.edge_helper import input_rank
 from executorch.backends.nxp.backend.ir.converter.conversion.translator import (
     apply_permutation_to,
@@ -42,33 +40,15 @@ def _is_supported_on_target(
         parameters_mapping: dict[str, Parameter],
         custom_delegation_options: CustomDelegationOptions,
     ) -> bool:
-        if neutron_target_spec.use_new_flow_neutron_c:
-            # Requirements specified by the new Neutron flow documentation.
-
-            if not NodeConverter.uses_quantization_type_for_io(
-                node,
-                supported_types=[torch.int8, torch.uint8],
-                input_indices=[0],
-                output_indices=[0],
-            ):
-                return False
-
-            return True
+        if not NodeConverter.uses_quantization_type_for_io(
+            node,
+            supported_types=[torch.int8, torch.uint8],
+            input_indices=[0],
+            output_indices=[0],
+        ):
+            return False
 
-        else:
-            paddings = node.args[1]
-            if node.meta[NXP_NODE_FORMAT].is_channels_first():
-                # Dim `1` will end up being the channels. It is padded by paddings[4:6].
-                if len(paddings) > 4 and paddings[4:6] != [0, 0]:
-                    # Attempt to Pad channels dimension -> currently not supported
-                    return False
-            else:
-                # Dim `-1` will end up being the channels. It is padded by paddings[:2].
-                if len(paddings) > 0 and paddings[:2] != [0, 0]:
-                    # Attempt to Pad channels dimension -> currently not supported
-                    return False
-
-            return True
+        return True
 
     @staticmethod
     def _is_supported_in_IR(

backends/nxp/backend/ir/converter/node_converters/ops_converters/leaky_relu_converter.py

@@ -35,21 +35,15 @@ def _is_supported_on_target(
         parameters_mapping: dict[str, Parameter],
         custom_delegation_options: CustomDelegationOptions,
     ) -> bool:
-        if neutron_target_spec.use_new_flow_neutron_c:
-            # Requirements specified by the new Neutron flow documentation.
+        if not NodeConverter.uses_quantization_type_for_io(
+            node,
+            supported_types=[torch.int8, torch.uint8],
+            input_indices=[0],
+            output_indices=[0],
+        ):
+            return False
 
-            if not NodeConverter.uses_quantization_type_for_io(
-                node,
-                supported_types=[torch.int8, torch.uint8],
-                input_indices=[0],
-                output_indices=[0],
-            ):
-                return False
-
-            return True
-        else:
-
-            return True
+        return True
 
     def convert(self, node: Node):
         """Convert the `aten.leaky_relu.default` operator to Neutron IR `LeakyRelu`.

backends/nxp/backend/ir/converter/node_converters/ops_converters/max_pool2d_with_indices_converter.py

@@ -73,50 +73,18 @@ def _is_supported_on_target(
             MaxPool2DWithIndicesConverter._get_node_args(node)
         )
 
-        if neutron_target_spec.use_new_flow_neutron_c:
-            # Requirements specified by the new Neutron flow documentation.
-
-            supported_types = [torch.int8, torch.uint8]
-            if not NodeConverter.uses_quantization_type_for_io(
-                node, supported_types, [0], [0]
-            ):
-                return False
-
-            # If there is no padding, Neutron allows maximum stride of 4096. Otherwise, it's 32. But the converter
-            #  always inserts a `Pad` operator to add the padding, so the `MaxPool` never pads it's input itself, so
-            #  4096 is always the limit. And similarly, the `MaxPool` input padding limitation does not apply either.
-            maximum_supported_stride = 4096
-            if any(s > maximum_supported_stride for s in stride):
-                return False
-
-        else:
-            # Shape of the main output (index 0)
-            output_shape = node.meta["val"][0].shape
-            if output_shape[0] != 1:
-                # /neutron-converter/src/OperatorC/MaxPoolPlugin.cpp?at=NEUTRON_SOFTWARE_2.2.2#106
-                return False
-
-            # Neutron only has a restriction on `stride_h`. `stride_w` is not restricted.
-            stride_h = stride[0]
-            if stride_h not in (1, 2):
-                # /neutron-library/src/utils/NeutronLibraryInterrogation.cpp?at=refs%2Ftags%2FNEUTRON_SOFTWARE_2.2.2#901
-                # /neutron-library/src/utils/NeutronLibraryInterrogation.cpp?at=refs%2Ftags%2FNEUTRON_SOFTWARE_2.2.2#923
-                return False
-
-            channels = output_shape[1]
-            if channels % neutron_target_spec.get_num_macs() != 0:
-                # /neutron-library/src/utils/NeutronLibraryInterrogation.cpp?at=refs%2Ftags%2FNEUTRON_SOFTWARE_2.2.2#903
-                # /neutron-library/src/utils/NeutronLibraryInterrogation.cpp?at=refs%2Ftags%2FNEUTRON_SOFTWARE_2.2.2#925
-                return False
-
-            if any(pad > kernel_dim for pad, kernel_dim in zip(padding, kernel_size)):
-                # /neutron-library/src/utils/NeutronLibraryInterrogation.cpp?at=refs%2Ftags%2FNEUTRON_SOFTWARE_2.2.2#904-907
-                # /neutron-library/src/utils/NeutronLibraryInterrogation.cpp?at=refs%2Ftags%2FNEUTRON_SOFTWARE_2.2.2#926-929
-
-                # Cannot be tested as PyTorch crashes in this case. It requires the padding to be at most half of the
-                #  effective kernel size, which is an even stricter requirement than what Neutron imposes.
-                # https://github.com/pytorch/pytorch/blob/449b1768410104d3ed79d3bcfe4ba1d65c7f22c0/torch/_meta_registrations.py#L4483-L4489
-                return False
+        supported_types = [torch.int8, torch.uint8]
+        if not NodeConverter.uses_quantization_type_for_io(
+            node, supported_types, [0], [0]
+        ):
+            return False
+
+        # If there is no padding, Neutron allows maximum stride of 4096. Otherwise, it's 32. But the converter
+        #  always inserts a `Pad` operator to add the padding, so the `MaxPool` never pads it's input itself, so
+        #  4096 is always the limit. And similarly, the `MaxPool` input padding limitation does not apply either.
+        maximum_supported_stride = 4096
+        if any(s > maximum_supported_stride for s in stride):
+            return False
 
         return True