cost_analysis: use portable compare_files for reference tests

Add --omit-revision to drop the volatile git-revision line, and end the
report with a single trailing newline (leading section separators instead
of trailing ones) so it is byte-stable. The tests then use plain
cmake -E compare_files instead of sed/diff, making them portable. The tree
dump is diffed against a new R2.tree.txt.expected fixture.

Author: ajay-mk

utilities/cost_analysis/CMakeLists.txt

@@ -10,26 +10,26 @@ target_link_libraries(cost_analysis PRIVATE
 target_set_warning_flags(cost_analysis)
 
 foreach(NAME IN ITEMS "ccsd_r2" "df_r1")
+    # --omit-revision drops the volatile git-revision line so a plain
+    # compare_files suffices; the tool writes the report next to the driver.
     add_test(
         NAME "sequant/cost_analysis/${NAME}/generate"
-        COMMAND cost_analysis --driver "${CMAKE_CURRENT_LIST_DIR}/examples/${NAME}.json")
+        COMMAND cost_analysis --driver "${CMAKE_CURRENT_LIST_DIR}/examples/${NAME}.json" --omit-revision)
     set_tests_properties("sequant/cost_analysis/${NAME}/generate"
         PROPERTIES FIXTURES_SETUP "COST_ANALYSIS_${NAME}")
 
-    # Strip the volatile git-revision line before diffing; -B ignores the extra
-    # trailing blank line the live report carries but the fixture doesn't.
     add_test(
         NAME "sequant/cost_analysis/${NAME}/verify"
-        COMMAND bash -c "diff -B <(sed '/^_SeQuant:/d' '${NAME}.md') <(sed '/^_SeQuant:/d' '${NAME}.md.expected')"
+        COMMAND "${CMAKE_COMMAND}" -E compare_files "${NAME}.md" "${NAME}.md.expected"
         WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/examples")
     set_tests_properties("sequant/cost_analysis/${NAME}/verify"
         PROPERTIES FIXTURES_REQUIRED "COST_ANALYSIS_${NAME}")
 endforeach()
 
-# ccsd_r2 exercises --dump_tree; check the tree file was produced.
+# ccsd_r2 exercises --dump_tree; diff the tree dump against its fixture.
 add_test(
     NAME "sequant/cost_analysis/ccsd_r2/dump_tree"
-    COMMAND bash -c "test -f R2.tree.txt"
+    COMMAND "${CMAKE_COMMAND}" -E compare_files "R2.tree.txt" "R2.tree.txt.expected"
     WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/examples")
 set_tests_properties("sequant/cost_analysis/ccsd_r2/dump_tree"
     PROPERTIES FIXTURES_REQUIRED "COST_ANALYSIS_ccsd_r2")

utilities/cost_analysis/README.md

@@ -108,10 +108,11 @@ The quantities that aren't self-evident:
 ## Tests
 
 Reference tests (`ctest -R sequant/cost_analysis`) run the tool on `examples/`
-and diff the report against a frozen `*.md.expected` (the volatile git-revision
-line is stripped before diffing):
+with `--omit-revision` (which drops the volatile git-revision line, making the
+report byte-stable) and compare it against a frozen `*.md.expected` via
+`cmake -E compare_files`:
 
 - `.../ccsd_r2/*` — spin-orbital CCSD R2 (a `Sum` of terms) whose two ladder
-  terms share one `g*t` intermediate, exercising the reuse census; also checks
-  the `--dump_tree` output was produced.
+  terms share one `g*t` intermediate, exercising the reuse census; also diffs
+  the `--dump_tree` output against `R2.tree.txt.expected`.
 - `.../df_r1/*` — a single density-fitted product (the non-`Sum` path).

utilities/cost_analysis/cost_analysis.cpp

@@ -337,6 +337,9 @@ int main(int argc, char** argv) {
   std::filesystem::path driver;
   app.add_option("--driver", driver, "Path to the JSON driver file")
       ->required();
+  bool omit_revision = false;
+  app.add_flag("--omit-revision", omit_revision,
+               "Omit the git-revision line (for reproducible test diffs)");
   CLI11_PARSE(app, argc, argv);
 
   try {
@@ -349,7 +352,8 @@ int main(int argc, char** argv) {
     std::filesystem::current_path(
         std::filesystem::absolute(driver).parent_path());
 
-    const Config cfg = load_config(d);
+    Config cfg = load_config(d);
+    cfg.out.omit_revision = omit_revision;
     setup_context(cfg);  // registry baked before any parse
 
     std::vector<std::pair<std::string, CellResult>> results;

utilities/cost_analysis/cost_analysis.hpp

@@ -41,6 +41,8 @@ struct OutSpec {
   std::string path = "cost_analysis.md";
   std::size_t top_n = 20;  ///< rows in the largest/expensive tables
   bool dump_tree = false;  ///< also write each result's binarized tree
+  bool omit_revision =
+      false;  ///< drop the git-revision line (reproducible diffs)
 };
 
 /// One `equations[]` entry: a named equation file to analyze.

utilities/cost_analysis/examples/R2.tree.txt.expected

@@ -0,0 +1,3 @@
+(g(a_1,a_2,i_1,i_2) * 1)
+((g(a_3,a_4,i_1,i_2) * t(i_3,i_4,a_3,a_4)) * R(a_1,a_2,i_3,i_4))
+((g(a_3,a_4,i_1,i_2) * t(i_3,i_4,a_3,a_4)) * t(a_1,a_2,i_3,i_4))

utilities/cost_analysis/examples/ccsd_r2.md.expected

@@ -1,7 +1,5 @@
 # SeQuant cost analysis
 
-_SeQuant: <version>_
-
 Sizes in MB (8 bytes/element).
 
 ## R2

utilities/cost_analysis/examples/df_r1.md.expected

@@ -1,7 +1,5 @@
 # SeQuant cost analysis
 
-_SeQuant: <version>_
-
 Sizes in MB (16 bytes/element).
 
 ## R1

utilities/cost_analysis/report.cpp

@@ -36,7 +36,6 @@ void report_largest(const CellResult& cell, std::size_t top_n,
                        rec->label, rec->spaces, mb(rec->memory, bytes_per_elem),
                        rec->uses, full_expr(*node), rec->flops.text());
   }
-  out << "\n";
 }
 
 void report_expensive(const CellResult& cell, std::size_t top_n,
@@ -59,7 +58,6 @@ void report_expensive(const CellResult& cell, std::size_t top_n,
                        rec->spaces, rec->uses, full_expr(*node),
                        rec->flops.text());
   }
-  out << "\n";
 }
 
 void report_shape_histogram(const CellResult& cell, double bytes_per_elem,
@@ -92,7 +90,6 @@ void report_shape_histogram(const CellResult& cell, double bytes_per_elem,
   for (const auto& [shape, g] : rows)
     out << std::format("| {} | {:.4f} | {} | {} |\n", shape,
                        mb(g.mem, bytes_per_elem), g.count, g.uses);
-  out << "\n";
 }
 
 }  // namespace
@@ -109,37 +106,40 @@ void write_report(
     const std::vector<std::pair<std::string, CellResult>>& results,
     const SimResult& sim, std::ostream& out) {
   const double bytes_per_elem = cfg.real_field ? 8.0 : 16.0;
-  out << "# SeQuant cost analysis\n\n"
-      << std::format("_SeQuant: {}_\n\n", git_revision())
-      << std::format("Sizes in MB ({} bytes/element).\n\n", bytes_per_elem);
+  // Sections are separated by a leading blank line rather than a trailing one,
+  // so the report ends with a single newline (matches the committed fixtures).
+  out << "# SeQuant cost analysis\n";
+  if (!cfg.out.omit_revision)
+    out << std::format("\n_SeQuant: {}_\n", git_revision());
+  out << std::format("\nSizes in MB ({} bytes/element).\n", bytes_per_elem);
   for (const auto& [name, cell] : results) {
-    out << std::format("## {}\n\n", name);
+    out << std::format("\n## {}\n", name);
     out << std::format(
-        "Terms: {}; distinct intermediates: {}; reused: {}; largest: {:.4f} "
-        "MB; peak storage: {:.4f} MB.\n\n",
+        "\nTerms: {}; distinct intermediates: {}; reused: {}; largest: {:.4f} "
+        "MB; peak storage: {:.4f} MB.\n",
         cell.n_terms, cell.n_distinct, cell.n_reused,
         mb(cell.largest_mem, bytes_per_elem),
         mb(cell.peak_storage, bytes_per_elem));
     // Op-count only; no concrete FLOP number.
-    out << std::format("Total operations (symbolic): {}\n\n",
+    out << std::format("\nTotal operations (symbolic): {}\n",
                        cell.total_flops.text());
-    out << "### Largest intermediates\n\n";
+    out << "\n### Largest intermediates\n\n";
     report_largest(cell, cfg.out.top_n, bytes_per_elem, out);
-    out << "### Most expensive contractions\n\n";
+    out << "\n### Most expensive contractions\n\n";
     report_expensive(cell, cfg.out.top_n, out);
-    out << "### Shape census\n\n";
+    out << "\n### Shape census\n\n";
     report_shape_histogram(cell, bytes_per_elem, out);
   }
   if (cfg.cache.enabled) {
     out << std::format(
-        "## Cache (gated, volatile leaf = \"{}\", min_repeats = {})\n\n",
+        "\n## Cache (gated, volatile leaf = \"{}\", min_repeats = {})\n\n",
         cfg.optimize.volatile_leaf, cfg.cache.min_repeats);
     out << "| Metric | Value |\n|---|---|\n";
     out << std::format("| Cached | {} |\n", sim.n_cached);
     out << std::format("| Persistent | {} |\n", sim.n_persistent);
     out << std::format("| Persistent footprint (MB) | {:.4f} |\n",
                        mb(sim.persistent_footprint, bytes_per_elem));
-    out << std::format("| Total cached footprint (MB) | {:.4f} |\n\n",
+    out << std::format("| Total cached footprint (MB) | {:.4f} |\n",
                        mb(sim.cached_footprint, bytes_per_elem));
   }
 }