brep_kernel/props/mass_properties/

profile.rs

use std::cell::Cell;
use web_time::Instant;

#[derive(Default, Clone, Copy)]
pub(crate) struct MassProfile {
    pub enabled: bool,
    pub faces: u64,
    pub trimmed_faces: u64,
    pub route_biperiodic: u64,
    pub route_winding: u64,
    pub route_seam_band: u64,
    pub route_cap: u64,
    pub route_wall: u64,
    pub route_hopped_raw: u64,
    pub route_hopped_unwrapped: u64,
    pub route_straddle: u64,
    pub route_periodic_raw: u64,
    pub route_raw: u64,
    pub route_untrimmed: u64,
    pub route_affine: u64,
    /// A single loop of four axis-parallel line pcurves inside the domain,
    /// integrated over the knot-span cells clipped to that rectangle.
    pub route_iso_rectangle: u64,
    pub polygon_chords: u64,
    pub base_cells: u64,
    pub full_cells: u64,
    pub full_stations: u64,
    pub leaf_cells: u64,
    pub tri_stations: u64,
    pub corr_chords: u64,
    pub corr_stations: u64,
    pub polygons_ms: f64,
    pub base_clip_ms: f64,
    pub cells_ms: f64,
    /// Hierarchical child clipping inside the quadtree (a subset of `cells_ms`).
    pub child_clip_ms: f64,
    /// Tensor Gauss stations over fully covered cells (a subset of `cells_ms`).
    pub full_ms: f64,
    /// Triangle cubature over depth-limit leaf cells (a subset of `cells_ms`).
    pub leaf_ms: f64,
    pub corr_ms: f64,
    pub untrimmed_ms: f64,
    pub gate_ms: f64,
    /// Choosing the panels and orders of a span from its weights
    /// (`rule`), and how many spans had to read a weight at all: the cost of
    /// the rational rule's decision, apart from the stations it then asks for.
    pub rule_ms: f64,
    pub rule_spans: u64,
    pub rule_sampled: u64,
    /// Emit one `mass.face` line per face (`BREP_PROFILE_MASS_FACES`).
    pub face_lines: bool,
    /// Sign-query attribution.
    pub sign_reused: u64,
    pub sign_reread: u64,
    pub sign_hash_ms: f64,
}

thread_local! {
    static PROFILE: Cell<MassProfile> = const { Cell::new(MassProfile {
        enabled: false, faces: 0, trimmed_faces: 0, route_biperiodic: 0, route_winding: 0,
        route_seam_band: 0, route_cap: 0, route_wall: 0, route_hopped_raw: 0,
        route_hopped_unwrapped: 0, route_straddle: 0, route_periodic_raw: 0, route_raw: 0,
        route_untrimmed: 0, route_affine: 0, route_iso_rectangle: 0, polygon_chords: 0, base_cells: 0, full_cells: 0,
        full_stations: 0, leaf_cells: 0, tri_stations: 0, corr_chords: 0, corr_stations: 0,
        polygons_ms: 0.0, base_clip_ms: 0.0, cells_ms: 0.0, child_clip_ms: 0.0, full_ms: 0.0,
        leaf_ms: 0.0, corr_ms: 0.0, untrimmed_ms: 0.0, gate_ms: 0.0, rule_ms: 0.0,
        rule_spans: 0, rule_sampled: 0, face_lines: false,
        sign_reused: 0, sign_reread: 0, sign_hash_ms: 0.0,
    }) };
}

/// Read-modify-write the thread-local profile when it is enabled; a no-op
/// (one flag read) otherwise.
impl crate::profile::Counters for MassProfile {
    fn armed(&self) -> bool {
        self.enabled
    }
}

pub(crate) fn mass_profile(update: impl FnOnce(&mut MassProfile)) {
    crate::profile::update(&PROFILE, update)
}

pub(crate) fn mass_profile_enabled() -> bool {
    crate::profile::armed(&PROFILE)
}

/// The live counters, for a before/after delta around one face.
pub(crate) fn snapshot() -> MassProfile {
    PROFILE.with(|cell| cell.get())
}

pub(crate) fn face_lines_enabled() -> bool {
    PROFILE.with(|cell| cell.get().face_lines)
}

/// Which route the face just took, read off the counter that moved.
fn route_name(delta: &MassProfile) -> &'static str {
    for (count, name) in [
        (delta.route_affine, "affine"),
        (delta.route_untrimmed, "untrimmed"),
        (delta.route_iso_rectangle, "iso_rect"),
        (delta.route_biperiodic, "biperiodic"),
        (delta.route_winding, "winding"),
        (delta.route_seam_band, "seam_band"),
        (delta.route_cap, "cap"),
        (delta.route_wall, "wall"),
        (delta.route_hopped_raw, "hopped_raw"),
        (delta.route_hopped_unwrapped, "hopped_unwrapped"),
        (delta.route_straddle, "straddle"),
        (delta.route_periodic_raw, "periodic_raw"),
        (delta.route_raw, "raw"),
    ] {
        if count > 0 {
            return name;
        }
    }
    "none"
}

/// One `mass.face` line: the face's surface kind and trim size beside the
/// route it took, the stations it cost and where its milliseconds went.
/// `before` is [`snapshot`] taken before the face's integration, `wall_ms`
/// the face's whole elapsed time. Only called when `face_lines` is armed.
#[allow(clippy::too_many_arguments)]
pub(crate) fn emit_face(
    call: &str,
    shell: usize,
    face: usize,
    kind: &str,
    degree_u: usize,
    degree_v: usize,
    closed_u: bool,
    closed_v: bool,
    loops: usize,
    coedges: usize,
    before: MassProfile,
    wall_ms: f64,
) {
    let now = PROFILE.with(|cell| cell.get());
    let d = MassProfile {
        route_biperiodic: now.route_biperiodic - before.route_biperiodic,
        route_winding: now.route_winding - before.route_winding,
        route_seam_band: now.route_seam_band - before.route_seam_band,
        route_cap: now.route_cap - before.route_cap,
        route_wall: now.route_wall - before.route_wall,
        route_hopped_raw: now.route_hopped_raw - before.route_hopped_raw,
        route_hopped_unwrapped: now.route_hopped_unwrapped - before.route_hopped_unwrapped,
        route_straddle: now.route_straddle - before.route_straddle,
        route_periodic_raw: now.route_periodic_raw - before.route_periodic_raw,
        route_raw: now.route_raw - before.route_raw,
        route_untrimmed: now.route_untrimmed - before.route_untrimmed,
        route_affine: now.route_affine - before.route_affine,
        polygon_chords: now.polygon_chords - before.polygon_chords,
        base_cells: now.base_cells - before.base_cells,
        full_cells: now.full_cells - before.full_cells,
        full_stations: now.full_stations - before.full_stations,
        leaf_cells: now.leaf_cells - before.leaf_cells,
        tri_stations: now.tri_stations - before.tri_stations,
        corr_chords: now.corr_chords - before.corr_chords,
        corr_stations: now.corr_stations - before.corr_stations,
        polygons_ms: now.polygons_ms - before.polygons_ms,
        base_clip_ms: now.base_clip_ms - before.base_clip_ms,
        cells_ms: now.cells_ms - before.cells_ms,
        child_clip_ms: now.child_clip_ms - before.child_clip_ms,
        full_ms: now.full_ms - before.full_ms,
        leaf_ms: now.leaf_ms - before.leaf_ms,
        corr_ms: now.corr_ms - before.corr_ms,
        untrimmed_ms: now.untrimmed_ms - before.untrimmed_ms,
        gate_ms: now.gate_ms - before.gate_ms,
        rule_ms: now.rule_ms - before.rule_ms,
        rule_spans: now.rule_spans - before.rule_spans,
        rule_sampled: now.rule_sampled - before.rule_sampled,
        ..MassProfile::default()
    };
    eprintln!(
        "mass.face call={call} shell={shell} face={face} kind={kind} deg={degree_u}x{degree_v} closed={}{} loops={loops} coedges={coedges} route={} chords={} base_cells={} full_cells={} full_stations={} leaf_cells={} tri_stations={} corr_chords={} corr_stations={} ms={:.3} gate_ms={:.3} polygons_ms={:.3} base_clip_ms={:.3} child_clip_ms={:.3} full_ms={:.3} leaf_ms={:.3} corr_ms={:.3} untrimmed_ms={:.3} cells_ms={:.3}",
        if closed_u { "u" } else { "-" },
        if closed_v { "v" } else { "-" },
        route_name(&d), d.polygon_chords, d.base_cells, d.full_cells, d.full_stations,
        d.leaf_cells, d.tri_stations, d.corr_chords, d.corr_stations, wall_ms, d.gate_ms,
        d.polygons_ms, d.base_clip_ms, d.child_clip_ms, d.full_ms, d.leaf_ms, d.corr_ms,
        d.untrimmed_ms, d.cells_ms,
    );
}

/// Milliseconds since `started` when profiling is on; `None` otherwise.
pub(crate) fn profile_started() -> Option<Instant> {
    crate::profile::started(&PROFILE)
}

pub(crate) use crate::profile::elapsed_ms;

/// Start a profiled call: resets the counters and arms them when
/// `BREP_PROFILE` is set. Returns whether profiling is on.
pub(crate) fn begin(call: &str) -> Option<(String, Instant)> {
    let enabled = crate::profile::profile_enabled();
    let face_lines = enabled && std::env::var("BREP_PROFILE_MASS_FACES").is_ok();
    PROFILE.with(|cell| {
        cell.set(MassProfile {
            enabled,
            face_lines,
            ..MassProfile::default()
        })
    });
    enabled.then(|| (call.to_string(), Instant::now()))
}

/// End a profiled call: print the line and disarm the counters.
pub(crate) fn end(token: Option<(String, Instant)>) {
    let Some((call, started)) = token else {
        return;
    };
    let p = PROFILE.with(|cell| cell.get());
    profile_line!(
        "mass.profile call={call} ms={:.2} faces={} trimmed={} routes: affine={} untrimmed={} biperiodic={} winding={} seam_band={} cap={} wall={} hopped_raw={} hopped_unwrapped={} straddle={} periodic_raw={} raw={} | chords={} base_cells={} full_cells={} full_stations={} leaf_cells={} tri_stations={} corr_chords={} corr_stations={} | gate_ms={:.2} polygons_ms={:.2} base_clip_ms={:.2} cells_ms={:.2} child_clip_ms={:.2} full_ms={:.2} leaf_ms={:.2} corr_ms={:.2} untrimmed_ms={:.2} rule_ms={:.2} rule_spans={} rule_sampled={}",
        started.elapsed().as_secs_f64() * 1_000.0,
        p.faces, p.trimmed_faces, p.route_affine, p.route_untrimmed, p.route_biperiodic,
        p.route_winding, p.route_seam_band, p.route_cap, p.route_wall, p.route_hopped_raw,
        p.route_hopped_unwrapped, p.route_straddle, p.route_periodic_raw, p.route_raw,
        p.polygon_chords, p.base_cells, p.full_cells, p.full_stations, p.leaf_cells,
        p.tri_stations, p.corr_chords, p.corr_stations, p.gate_ms, p.polygons_ms,
        p.base_clip_ms, p.cells_ms, p.child_clip_ms, p.full_ms, p.leaf_ms, p.corr_ms,
        p.untrimmed_ms,
        p.rule_ms,
        p.rule_spans,
        p.rule_sampled,
    );
    if call == "solid_signed_volume_for_sign" {
        eprintln!("mass.sign_query caller={} faces={} reused={} reread={} hash_ms={:.3} ms={:.3}",
            current_caller(), p.faces, p.sign_reused, p.sign_reread, p.sign_hash_ms,
            started.elapsed().as_secs_f64() * 1000.0);
    }
    PROFILE.with(|cell| cell.set(MassProfile::default()));
}

// ---------------------------------------------------------------------------
// Sign-check attribution: the identity of the face set a call integrated.
// ---------------------------------------------------------------------------

thread_local! {
    /// The call site that is asking, for the duration of one integrator call.
    static CALLER: Cell<Option<&'static str>> = const { Cell::new(None) };
}

/// Names the call site for every integrator call made while it is alive, so
/// the `mass.identity` line can say WHO paid for the integral rather than
/// leaving a log reader to infer it from the neighbouring profile lines.
///
/// Diagnostic only: nothing but the identity line reads it, and the identity
/// line only exists under `BREP_PROFILE_MASS_IDENTITY` /
/// `BREP_PROFILE_MASS_DUMP`. The guard restores the previous name on drop so
/// a labelled site nested inside another labelled site reports itself and
/// then hands the outer name back.
pub struct MassCaller(Option<&'static str>);

impl Drop for MassCaller {
    fn drop(&mut self) {
        CALLER.with(|cell| cell.set(self.0));
    }
}

pub fn mass_caller(name: &'static str) -> MassCaller {
    MassCaller(CALLER.with(|cell| cell.replace(Some(name))))
}

fn current_caller() -> &'static str {
    CALLER.with(|cell| cell.get()).unwrap_or("unlabelled")
}

/// One line per integrator call naming the CONTENT of the face set it read
/// (`BREP_PROFILE_MASS_IDENTITY`), and optionally the solid itself written to
/// disk (`BREP_PROFILE_MASS_DUMP=<dir>`, which implies the line).
///
/// This is the instrument behind "how many sign checks integrate a face set a
/// later measurement integrates again". The 2026-09-13 integrator record
/// paired them by STATION SIGNATURE — face count and station counts — and said
/// plainly that two congruent solids would match too. A content hash settles
/// that: equal hashes mean the two calls saw the same geometry in the same
/// order, so the second one's answer was already computed.
///
/// It is a measurement lever, not a product path: hashing every solid costs
/// its control points, which is why it is off unless asked for, and why the
/// timing tables in the record are taken with it OFF.
pub(crate) struct IdentityDump {
    /// `None` unless `BREP_PROFILE_MASS_DUMP` named a directory.
    directory: Option<String>,
}

thread_local! {
    /// Per-process call counter so a dump's file name orders the calls the way
    /// stderr does. Thread-local like the rest of this module; the populations
    /// this instrument serves are single-threaded replays.
    static DUMP_SEQUENCE: Cell<u64> = const { Cell::new(0) };
}

/// Read the two switches. Returns `None` when neither is set, which is the
/// only cost on the shipped path.
pub(crate) fn identity_dump() -> Option<IdentityDump> {
    let directory = std::env::var("BREP_PROFILE_MASS_DUMP").ok();
    if directory.is_none() && std::env::var("BREP_PROFILE_MASS_IDENTITY").is_err() {
        return None;
    }
    Some(IdentityDump { directory })
}

/// Emit the identity line for a finished call, and write the solid when a dump
/// directory was named. `values` are the raw f64 bits the call returned, in
/// the order the probe reads them back.
pub(crate) fn emit_identity(
    dump: IdentityDump,
    call: &str,
    solid: &crate::BrepSolid,
    values: &[(&str, f64)],
) {
    let started = Instant::now();
    let identity = super::identity::face_set_identity(solid);
    let hash_ms = started.elapsed().as_secs_f64() * 1_000.0;
    let sequence = DUMP_SEQUENCE.with(|cell| {
        let next = cell.get() + 1;
        cell.set(next);
        next
    });
    let printed: Vec<String> = values
        .iter()
        .map(|(name, value)| format!("{name}={:016x}", value.to_bits()))
        .collect();
    let mut path = String::new();
    if let Some(directory) = dump.directory {
        let file = format!("{directory}/{sequence:05}-{call}.json");
        match serde_json::to_string(solid) {
            Ok(text) => {
                if let Err(error) = std::fs::write(&file, text) {
                    eprintln!("mass.dump write failed for {file}: {error}");
                } else {
                    path = file;
                }
            }
            Err(error) => eprintln!("mass.dump serialize failed for {file}: {error}"),
        }
        // A sidecar beside the solid so the probe needs only the directory:
        // the stderr line carries the same fields, but correlating a probe run
        // against a captured log is one more thing to get wrong.
        let meta = format!(
            "{{\"call\":\"{call}\",\"seq\":{sequence},\"faces\":{},\"hash\":\"{}\",\"values\":\"{}\"}}",
            identity.faces,
            identity.hex(),
            printed.join(" "),
        );
        let meta_file = format!("{directory}/{sequence:05}-{call}.meta.json");
        if let Err(error) = std::fs::write(&meta_file, meta) {
            eprintln!("mass.dump write failed for {meta_file}: {error}");
        }
    }
    eprintln!(
        "mass.identity call={call} caller={} seq={sequence} faces={} hash={} hash_ms={hash_ms:.3} {}{}",
        current_caller(),
        identity.faces,
        identity.hex(),
        printed.join(" "),
        if path.is_empty() {
            String::new()
        } else {
            format!(" path={path}")
        },
    );
}

/// Per-face attribution beside the integrator's detailed route line.
pub(crate) fn sign_face(shell: usize, face: &crate::FaceRecord, reread: bool, hash_ms: f64) {
    mass_profile(|p| {
        p.sign_reread += u64::from(reread);
        p.sign_reused += u64::from(!reread);
        p.sign_hash_ms += hash_ms;
    });
    if face_lines_enabled() {
        eprintln!("mass.sign_face caller={} shell={shell} id={} reused={} hash_ms={hash_ms:.3}",
            current_caller(), face.id, !reread);
    }
}

/// Persist successful oracle readings even when case_replay captures a
/// successful child's stderr. The file is diagnostic evidence, never a memo.
pub(crate) fn emit_sign_oracle(solid: &crate::BrepSolid, reading: f64, exact: f64) -> Result<(), String> {
    let identity = crate::mass_properties::face_set_identity(solid);
    let error = (reading - exact).abs();
    let relative = if exact == 0.0 { 0.0 } else { error / exact.abs() };
    eprintln!("mass.sign_oracle caller={} faces={} relative={relative:.3e}", current_caller(), identity.faces);
    if let Some(path) = std::env::var_os("BREP_SIGN_TERMS_ORACLE_LOG") {
        use std::io::Write;
        let row = serde_json::json!({
            "faces": identity.faces, "identity": identity.hex(),
            "retained": reading, "whole_body": exact, "relative_error": relative,
            "caller": current_caller(),
        });
        let mut file = std::fs::OpenOptions::new().create(true).append(true).open(path)
            .map_err(|error| format!("sign terms oracle log: {error}"))?;
        writeln!(file, "{row}").map_err(|error| format!("sign terms oracle log: {error}"))?;
    }
    Ok(())
}