fp-stability: remove Tier 2 per-instance disambiguation entirely

Per the weight review, the precision-build-based per-instance disambiguation was the heaviest piece (its own module + a build flag + CMake plumbing + tests) for the narrowest trigger (fires only when the most-flagrant hotspot is also inside a #:for/#:def expansion). Removed in full:

- deleted toolchain/mfc/fp_precision_lines.py and its tests; deleted _disambiguate_instances

- reverted CMakeLists.txt and build.py to upstream (no MFC_FP_PRECISION_LINES option, no marker-strip step, no -D flag); dropped the --fp-precision-lines build arg and the --precision-sim-binary fp-stability arg

- removed the E3 disambiguation stage, its docstring section, and the per-instance summary display

Kept: the lightweight '#:for/#:def-expanded — may represent multiple instances' hotspot warning (cheap, honest, separate from the disambiguation machinery). 57 toolchain tests, ruff, precheck all 7 green; CMakeLists.txt and build.py are byte-identical to upstream.

Author: sbryngelson

CMakeLists.txt

@@ -31,7 +31,6 @@ option(MFC_DOCUMENTATION "Build documentation"                               OFF
 option(MFC_ALL           "Build everything"                                  OFF)
 option(MFC_SINGLE_PRECISION "Build single precision"                         OFF)
 option(MFC_MIXED_PRECISION "Build mixed precision"                           OFF)
-option(MFC_FP_PRECISION_LINES "Strip fypp markers for per-instance fp-stability attribution" OFF)
 
 if (MFC_ALL)
     set(MFC_PRE_PROCESS   ON FORCE)
@@ -434,24 +433,8 @@ macro(HANDLE_SOURCES target useCommon)
         cmake_path(GET fpp FILENAME fpp_filename)
         set(f90 "${CMAKE_BINARY_DIR}/fypp/${target}/${fpp_filename}.f90")
 
-        # In a precision-lines build, Fypp writes a marked intermediate that is
-        # then stripped of its line markers (so each expanded instance compiles
-        # to a distinct physical line) before compilation; the strip step emits a
-        # .linemap.json sidecar.  Otherwise Fypp writes ${f90} directly.  Only the
-        # simulation target is analyzed by fp-stability, so pre/post_process are
-        # always built normally.
-        set(_precision_lines OFF)
-        if (MFC_FP_PRECISION_LINES AND "${target}" STREQUAL "simulation")
-            set(_precision_lines ON)
-        endif()
-        if (_precision_lines)
-            set(f90_out "${CMAKE_BINARY_DIR}/fypp/${target}/${fpp_filename}.marked.f90")
-        else()
-            set(f90_out "${f90}")
-        endif()
-
         add_custom_command(
-            OUTPUT   ${f90_out}
+            OUTPUT   ${f90}
             COMMAND  ${FYPP_EXE} -m re
                                  -I "${CMAKE_BINARY_DIR}/include/${target}"
                                  -I "${${target}_DIR}/include"
@@ -467,25 +450,12 @@ macro(HANDLE_SOURCES target useCommon)
 								 --line-length=999
 		 						 --line-numbering-mode=nocontlines
                                  ${FYPP_GCOV_OPTS}
-                                 "${fpp}" "${f90_out}"
+                                 "${fpp}" "${f90}"
             DEPENDS  "${fpp};${${target}_incs}"
             COMMENT  "Preprocessing (Fypp) ${fpp_filename}"
             VERBATIM
         )
 
-        if (_precision_lines)
-            add_custom_command(
-                OUTPUT   ${f90}
-                COMMAND  ${Python3_EXECUTABLE}
-                         "${CMAKE_SOURCE_DIR}/toolchain/mfc/fp_precision_lines.py"
-                         "${f90_out}" "${f90}"
-                         "${CMAKE_BINARY_DIR}/fypp/${target}/${fpp_filename}.linemap.json"
-                DEPENDS  "${f90_out};${CMAKE_SOURCE_DIR}/toolchain/mfc/fp_precision_lines.py"
-                COMMENT  "Stripping markers (fp-precision-lines) ${fpp_filename}"
-                VERBATIM
-            )
-        endif()
-
         list(APPEND ${target}_SRCs ${f90})
     endforeach()
 endmacro()

toolchain/mfc/build.py

@@ -421,7 +421,6 @@ def configure(self, case: Case):
             flags.append(f"-DMFC_GCov={'ON' if ARG('gcov') else 'OFF'}")
             flags.append(f"-DMFC_Unified={'ON' if ARG('unified') else 'OFF'}")
             flags.append(f"-DMFC_Fastmath={'ON' if ARG('fastmath') else 'OFF'}")
-            flags.append(f"-DMFC_FP_PRECISION_LINES={'ON' if ARG('fp_precision_lines') else 'OFF'}")
 
         command = ["cmake"] + flags + ["-S", cmake_dirpath, "-B", build_dirpath]
 

toolchain/mfc/cli/commands.py

@@ -141,13 +141,6 @@
             default=False,
             dest="deps_only",
         ),
-        Argument(
-            name="fp-precision-lines",
-            help="(fp-stability) Strip fypp line markers so each expanded instance gets a distinct line; emits sidecars for per-instance attribution.",
-            action=ArgAction.STORE_TRUE,
-            default=False,
-            dest="fp_precision_lines",
-        ),
     ],
     examples=[
         Example("./mfc.sh build", "Build all default targets (CPU)"),
@@ -945,13 +938,6 @@
             default=None,
             metavar="PATH",
         ),
-        Argument(
-            name="precision-sim-binary",
-            help="Path to a simulation binary built with --fp-precision-lines. When given, macro-ambiguous hotspots are disambiguated to the individual fypp-expanded instance.",
-            default=None,
-            dest="precision_sim_binary",
-            metavar="PATH",
-        ),
         Argument(
             name="samples",
             short="N",

toolchain/mfc/fp_precision_lines.py

@@ -48,15 +48,6 @@
    One run with --check-max-float=yes; reports locations where a
    double→float conversion would overflow to ±Inf.
 
-I. Per-instance disambiguation (--precision-sim-binary PATH; opt-in)
-   A fypp #:for/#:def expansion collapses many generated computations onto one
-   .fpp line, so a macro-ambiguous hotspot cannot be pinned to a single runtime
-   instance.  Given a simulation binary built with `--fp-precision-lines` (markers
-   stripped so each instance is a distinct line, plus .linemap.json sidecars), the
-   most flagrant macro-ambiguous hotspot is disambiguated: each expanded instance
-   is perturbed alone on the precision binary, ranking them to the responsible
-   instance and showing its concrete generated code.
-
 Logs are saved to fp-stability-logs/ and uploaded as CI artifacts.
 On GitHub Actions: a step summary table and ::warning:: file annotations
 are emitted automatically so failing source lines appear in the PR diff.
@@ -95,7 +86,6 @@
     _emit_github_summary,
 )
 from .fp_stability_runners import (
-    _disambiguate_instances,
     _find_binary,
     _find_verrou,
     _run_cancellation_check,
@@ -419,7 +409,6 @@ def _run_case(
     run_cancellation: bool,
     run_mca: bool,
     run_float_max: bool,
-    prec_sim_bin: str = None,
 ) -> dict:
     name = case["name"]
     compare = case["compare"]
@@ -542,24 +531,6 @@ def _run_case(
             except Exception as exc:
                 cons.print(f"  [bold yellow]dd_line confirmation error[/bold yellow]: {exc}")
 
-        # --- E3: per-instance disambiguation of the most flagrant macro-ambiguous hotspot ---
-        if prec_sim_bin and result["dd_line_locs"]:
-            macro_loc = next((loc for loc in result["dd_line_locs"] if loc.get("macro")), None)
-            if macro_loc:
-                cons.print(f"  [dim]disambiguating fypp instances of {macro_loc['path']}:{macro_loc['start']} (precision binary)...[/dim]")
-                try:
-                    insts = _disambiguate_instances(case, prec_sim_bin, verrou_bin, work_dir, macro_loc["path"], macro_loc["start"])
-                    macro_loc["instances"] = insts
-                    if insts and insts[0]["dev"] > 0:
-                        win = insts[0]
-                        cons.print(f"  flagrant instance: #{win['instance']} (.f90:{win['physline']}, dev={win['dev']:.3e})  {win['snippet']}")
-                    elif insts:
-                        cons.print(f"  [dim]{len(insts)} instance(s) enumerated; none perturbed measurably (hotspot inert)[/dim]")
-                    else:
-                        cons.print("  [dim]no sidecar instances found for this hotspot[/dim]")
-                except Exception as exc:
-                    cons.print(f"  [bold yellow]instance disambiguation error[/bold yellow]: {exc}")
-
         # --- F: cancellation detection ---
         if run_cancellation:
             cons.print("  [dim]cancellation detection...[/dim]")
@@ -638,9 +609,6 @@ def fp_stability():
     run_cancellation = not ARG("no_cancellation")
     run_mca = not ARG("no_mca")
     run_float_max = not ARG("no_float_max")
-    prec_sim_bin = ARG("precision_sim_binary")
-    if prec_sim_bin and not os.path.isfile(prec_sim_bin):
-        raise MFCException(f"precision simulation binary not found: {prec_sim_bin}")
 
     log_dir = os.path.join(MFC_ROOT_DIR, "fp-stability-logs")
     os.makedirs(log_dir, exist_ok=True)
@@ -650,8 +618,6 @@ def fp_stability():
     cons.print(f"  verrou:      {verrou_bin}")
     cons.print(f"  simulation:  {sim_bin}")
     cons.print(f"  pre_process: {pp_bin}")
-    if prec_sim_bin:
-        cons.print(f"  precision:   {prec_sim_bin}  (per-instance disambiguation)")
     cons.print(f"  samples:     {n_samples}")
     features = []
     if run_float:
@@ -690,7 +656,6 @@ def fp_stability():
                 run_cancellation,
                 run_mca,
                 run_float_max,
-                prec_sim_bin,
             )
         except MFCException as exc:
             cons.print(f"  [bold red]ERROR[/bold red]: {exc}")

toolchain/mfc/fp_stability.py

@@ -201,9 +201,6 @@ def _emit_github_summary(results: list, n_samples: int):
                     tags.append(f"_{loc['macro']}-expanded, may represent multiple instances_")
                 suffix = f" — {', '.join(tags)}" if tags else ""
                 md.append(f"- `{where}`{suffix}")
-                for inst in loc.get("instances", [])[:8]:
-                    flag = " ⟵ flagrant" if inst is loc["instances"][0] and inst["dev"] > 0 else ""
-                    md.append(f"  - instance #{inst['instance']} (`.f90:{inst['physline']}`, dev={inst['dev']:.2e}){flag}: `{inst['snippet']}`")
                 snippet = _get_source_context(rel_path, start)
                 if snippet:
                     md.append("  ```fortran")

toolchain/mfc/fp_stability_report.py

@@ -28,7 +28,6 @@
     _parse_rddmin_syms,
     _parse_vg_error_locs,
     _rank_locs,
-    _read_source_line,
 )
 from .printer import cons
 
@@ -477,54 +476,3 @@ def _run_confirmation(case, verrou_bin, sim_bin, work_dir, ref_dir, dd_line_locs
             loc["share_dev"] = _source_perturb_dev(verrou_bin, sim_bin, work_dir, ref_dir, conf_dir, one, compare, f"line{i:02d}") if one else 0.0
     ranked = _rank_locs(dd_line_locs, total=(float_proxy or set_dev))
     return confirmed, set_dev, ranked
-
-
-def _disambiguate_instances(case, prec_sim_bin, verrou_bin, work_dir, hotspot_file, hotspot_line):
-    """Rank the individual fypp-expanded instances of a macro-ambiguous hotspot.
-
-    Uses a precision binary (built with --fp-precision-lines) in which each
-    expanded instance of hotspot_file:hotspot_line compiles to a distinct
-    physical .f90 line.  The sidecar enumerates those physical lines; each is
-    perturbed alone (float mode, vs the precision binary's own nearest-rounding
-    reference) so the dominant instance is identified.
-
-    Returns a list of {instance, physline, dev, snippet} sorted most-flagrant
-    first (empty if no sidecar / no instrumented instances).
-    """
-    from . import fp_precision_lines as fpl
-
-    sidecar_dir = fpl.sidecar_dir_for_binary(prec_sim_bin)
-    sidecar = fpl.load_sidecar(fpl.sidecar_path(sidecar_dir, hotspot_file))
-    instances = fpl.instances_of(sidecar, hotspot_file, hotspot_line)
-    if not instances:
-        return []
-
-    prec_dir = os.path.join(work_dir, "precision")
-    ref_dir = os.path.join(prec_dir, "ref")
-    os.makedirs(ref_dir, exist_ok=True)
-    try:
-        _run_simulation_verrou(verrou_bin, prec_sim_bin, work_dir, ref_dir, rounding_mode="nearest")
-    except MFCException:
-        return []
-    gen_lines = _capture_gen_source(verrou_bin, prec_sim_bin, work_dir, prec_dir, os.path.join(prec_dir, "gen_source.txt"))
-    if gen_lines is None:
-        return []
-
-    f90_file = os.path.join(sidecar_dir, os.path.basename(hotspot_file) + ".f90")
-    compare = case["compare"]
-    results = []
-    for physline, instance in instances:
-        src = _build_source_filter(gen_lines, [(f90_file, physline, physline)])
-        if not src:
-            continue  # this instance performs no instrumented FP op
-        dev = _source_perturb_dev(verrou_bin, prec_sim_bin, work_dir, ref_dir, prec_dir, src, compare, f"inst{instance:02d}")
-        results.append(
-            {
-                "instance": instance,
-                "physline": physline,
-                "dev": dev or 0.0,
-                "snippet": _read_source_line(f90_file, physline).strip(),
-            }
-        )
-    results.sort(key=lambda r: r["dev"], reverse=True)
-    return results