NXP backend: Add generate_etrecord to ExportRecipe. (pytorch#23106)

### Summary

`export()` has a `generate_etrecord` parameter. When using profiling,
users had to set both
profiling flags on the recipe and `generate_etrecord=True` on the export
call separately,
with no enforcement that the two were kept in sync.

This PR adds `generate_etrecord: bool = False` to `ExportRecipe` so
backends can declare the
requirement as part of the recipe. `ExportSession` resolves the
effective value with OR
semantics: `generate_etrecord or getattr(export_recipe,
"generate_etrecord", False)`.
`ExportRecipe.combine()` also uses OR semantics so the flag propagates
correctly across
combined recipes.

`NXPRecipeProvider` sets `generate_etrecord=rc.use_profiling` on the
Neutron recipe, so
users no longer need to pass `generate_etrecord=True` to `export()` when
enabling profiling.


### Test plan
`pytest export/tests/test_export_session.py
export/tests/test_export_recipe.py
backends/nxp/tests/generic_tests/test_recipe_export.py`


cc @robert-kalmar @JakeStevens @digantdesai @rascani

Author: MartinPavella

backends/nxp/recipes/nxp_recipe_provider.py

@@ -108,8 +108,9 @@ class NeutronRecipeConfig:
         use_neutron_for_format_conversion: Whether Neutron handles data-format conversion.
         fetch_constants_to_sram: Place constant tensors in SRAM on the target.
         dump_kernel_selection_code: Generate kernel-selection files after compilation.
-        use_profiling: Enable Neutron execution profiling. IMPORTANT: To also generate an
-                       ETRecord, pass generate_etrecord=True to export() separately.
+        use_profiling: Enable Neutron execution profiling. When True, the recipe
+                       automatically sets generate_etrecord=True so that a matching
+                       ETRecord is produced without any extra configuration.
         train_fn: Training function required for QAT recipe types (INT8_QAT_NEUTRON and
                   INT8_QAT_NO_DELEGATE). Receives the prepared GraphModule and must
                   perform the training loop. Ignored for PTQ recipe types.
@@ -219,6 +220,9 @@ def _build_recipe(
             executorch_backend_config=ExecutorchBackendConfig(
                 extract_delegate_segments=False
             ),
+            # Profiling requires an ETRecord; set the flag here so callers do
+            # not need to pass generate_etrecord=True to export() separately.
+            generate_etrecord=rc.use_profiling,
         )
 
 

backends/nxp/tests/generic_tests/test_recipe_export.py

@@ -244,6 +244,29 @@ def capturing_init(self_, *args, **kwargs):
         spec_map = {s.key: s.value.decode() for s in captured[0].delegation_spec[1]}
         assert spec_map["use_profiling"] == "True"
 
+    def test_use_profiling_sets_generate_etrecord_true(self):
+        """use_profiling=True must cause the returned recipe to have generate_etrecord=True."""
+        rc = NeutronRecipeConfig(INPUT_SHAPE, use_profiling=True)
+        recipe = NXPRecipeProvider().create_recipe(
+            NXPRecipeType.INT8_PTQ_NEUTRON, neutron_recipe_config=rc
+        )
+        assert recipe.generate_etrecord is True
+
+    def test_use_profiling_false_leaves_generate_etrecord_false(self):
+        """use_profiling=False must leave generate_etrecord as False on the recipe."""
+        rc = NeutronRecipeConfig(INPUT_SHAPE, use_profiling=False)
+        recipe = NXPRecipeProvider().create_recipe(
+            NXPRecipeType.INT8_PTQ_NEUTRON, neutron_recipe_config=rc
+        )
+        assert recipe.generate_etrecord is False
+
+    def test_use_profiling_generates_etrecord(self):
+        """use_profiling=True must produce a non-None ETRecord after full export."""
+        model = SimpleCNN()
+        rc = NeutronRecipeConfig(INPUT_SHAPE, use_profiling=True)
+        sess = _run_export(model, rc)
+        assert sess.get_etrecord() is not None
+
     def test_dump_kernel_selection_code(self, tmp_path, monkeypatch):
         """dump_kernel_selection_code=True causes a kernel selection C file to be written."""
         monkeypatch.chdir(tmp_path)

export/export.py

@@ -163,7 +163,7 @@ def __init__(
             dynamic_shapes: Optional dynamic shape specifications
             constant_methods: Optional dictionary of constant methods
             artifact_dir: Optional directory to store artifacts
-            generate_etrecord: Optional flag to generate an etrecord
+            generate_etrecord: Optional flag to generate an etrecord. Can also be provided by the ExportRecipe.
         """
         # Load model from file if string path provided
         if isinstance(model, str):
@@ -231,7 +231,8 @@ def __init__(
             "export_recipe": self._export_recipe,
             "session_name": name,
             "artifact_dir": artifact_dir,
-            "generate_etrecord": generate_etrecord,
+            "generate_etrecord": generate_etrecord
+            or getattr(export_recipe, "generate_etrecord", False),
         }
 
         self._stage_to_artifacts: Dict[StageType, PipelineArtifact] = {}

export/recipe.py

@@ -258,6 +258,7 @@ class _CombineAccumulator:
     pipeline_stages_values: list = field(default_factory=list)
     source_transform_in_place_values: list = field(default_factory=list)
     release_intermediate_artifacts_values: list = field(default_factory=list)
+    generate_etrecord_values: list = field(default_factory=list)
     backend_config: object = None
     pre_partitioning_callbacks: list = field(default_factory=list)
 
@@ -307,6 +308,8 @@ class ExportRecipe:
         pipeline_stages: Optional list of stages to execute, defaults to a standard pipeline.
         mode: Export mode (debug or release)
         strict: Set the strict flag in the torch export call.
+        generate_etrecord: When True, the export pipeline captures an ETRecord for
+                           use with the ExecuTorch devtools (profiling, debugging).
     """
 
     name: Optional[str] = None
@@ -326,6 +329,7 @@ class ExportRecipe:
     ] = None
     pre_trace_hooks: Optional[List[Callable[[str, torch.nn.Module], None]]] = None
     release_intermediate_artifacts: bool = False
+    generate_etrecord: bool = False
 
     @classmethod
     def get_recipe(cls, recipe: "RecipeType", **kwargs) -> "ExportRecipe":
@@ -626,6 +630,7 @@ def _collect_recipe_fields(
             acc.release_intermediate_artifacts_values.append(
                 recipe.release_intermediate_artifacts
             )
+            acc.generate_etrecord_values.append(recipe.generate_etrecord)
 
             # Use the executorch_backend_config from the first recipe that supplies one.
             if acc.backend_config is None and recipe.executorch_backend_config:
@@ -711,4 +716,6 @@ def _combine_recipes(
                 if acc.source_transform_in_place_values
                 else False
             ),
+            # OR semantics: generate ETRecord when at least one recipe requests it.
+            generate_etrecord=any(acc.generate_etrecord_values),
         )

export/tests/test_export_recipe.py

@@ -850,3 +850,19 @@ def test_pass_lists_preserved_when_only_one_recipe_contributes(self) -> None:
         )
         result = ExportRecipe.combine([r1, r2])
         self.assertEqual(result.quantization_recipe.pre_prepare_passes, [p])
+
+    def test_combine_generate_etrecord_or_semantics_true_false(self) -> None:
+        # Any recipe requesting ETRecord generation must make the combined recipe
+        # request it as well.
+        r1 = ExportRecipe(name="a", generate_etrecord=True)
+        r2 = ExportRecipe(name="b", generate_etrecord=False)
+        result = ExportRecipe.combine([r1, r2])
+        self.assertTrue(result.generate_etrecord)
+
+    def test_combine_generate_etrecord_false_when_none_set(self) -> None:
+        # When no recipe requests ETRecord generation the combined recipe must
+        # not request it either.
+        r1 = ExportRecipe(name="a")
+        r2 = ExportRecipe(name="b")
+        result = ExportRecipe.combine([r1, r2])
+        self.assertFalse(result.generate_etrecord)

export/tests/test_export_session.py

@@ -284,6 +284,39 @@ def test_context_propagation_through_pipeline(self) -> None:
         self.assertEqual(session._run_context["session_name"], "test_session")
         self.assertIsNotNone(session._run_context["constant_methods"])
 
+    def test_generate_etrecord_from_recipe(self) -> None:
+        # When the recipe has generate_etrecord=True and the param is False,
+        # the effective value in the run context must be True.
+        recipe = ExportRecipe(name="test", generate_etrecord=True)
+        session = ExportSession(
+            model=self.model,
+            example_inputs=self.example_inputs,
+            export_recipe=recipe,
+        )
+        self.assertTrue(session._run_context["generate_etrecord"])
+
+    def test_generate_etrecord_from_param_overrides_recipe(self) -> None:
+        # The explicit parameter must win when the recipe has generate_etrecord=False.
+        recipe = ExportRecipe(name="test", generate_etrecord=False)
+        session = ExportSession(
+            model=self.model,
+            example_inputs=self.example_inputs,
+            export_recipe=recipe,
+            generate_etrecord=True,
+        )
+        self.assertTrue(session._run_context["generate_etrecord"])
+
+    def test_generate_etrecord_false_when_neither_set(self) -> None:
+        # Both the recipe and the explicit parameter default to False, so the
+        # effective value must also be False.
+        recipe = ExportRecipe(name="test")
+        session = ExportSession(
+            model=self.model,
+            example_inputs=self.example_inputs,
+            export_recipe=recipe,
+        )
+        self.assertFalse(session._run_context["generate_etrecord"])
+
     def test_stage_registry_unknown_stage_type(self) -> None:
         # Test error handling for unknown stage types in pipeline
         unknown_stage_type = Mock()