wasm-jit: implement the missing runtime flags (#16206)

OMEdit sends `-startTime`/`-stopTime`/`-tolerance`/`-outputFormat` on
every run, none of which the wasm-jit runtime implemented, so every
simulation started from it was refused outright.

`SimMeta::apply_flags` is C's `read_experiment` (plus the step-size
checks `solver_main.c` makes right after it): the run scalars the
model was translated with, overridden by the command line.
`n_intervals` is C's `numSteps`, so a moved step size lands on the
output grid. Whichever entry point owns the driver applies it once
per run to its own copy — the host through `SimModel::run_meta`,
`rt_sim_start` in-wasm, `_start` in the standalone.

Implemented at the same time:

- `-outputPath` and `-r`: result-file resolution. The standalone
  honoured neither.
- `-noemit`: C's `sim_noemit`, i.e. `-outputFormat=empty`.
- `-iit`: the time `-iif`'s result file is read at.
- `-mei` / `-mbi`: the event-iteration and bisection caps, the
  latter in both `fixedstep` and gbode.
- `-newtonFTol` / `-newtonXTol` / `-newtonMaxStepFactor`: a new
  `rt_set_newton_tuning` export, since the homotopy Newton and
  KINSOL both read them as C's globals do.
- `-steadyState` / `-steadyStateTol`: reported through `terminated`,
  so every driver's stop path serves it.
- `-w`: rides the `-lv` mask as `SHOW_ALL_WARNINGS`, so the one
  value pushed into the wasm runtime carries it.
- `-logFormat=text`, `-daeMode` and `-jacobianThreads`: accepted
  with C's warnings.

`-outputFormat=csv|plt|ia` stays refused: no writer here yet.

The rejection an unimplemented flag gets no longer explains itself
with "so the run would silently ignore it" — that rationale is about
the design, not about the flag, and it belongs on `C_FLAGS`.

Verified against the C runtime with `diffSimulationResults` over
dassl, euler and gbode with the moved scalars: no differing
variables. The startup log matches C line for line, in C's order.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: sjoelund

OMCompiler/Compiler/OpenModelica.rs/openmodelica_codegen_wasm_jit/src/CodegenWasmJit.rs

@@ -183,12 +183,17 @@ const SQRT_EPS: f64 = 1.4901161193847656e-08;
 const FD_DELTA: f64 = 6.664001874625056e-08;
 /// Newton/LM convergence tolerance: stop once a residual / step measure drops below.
 const NEWTON_EPS: f64 = 1.0e-6;
-/// C's `newtonFTol`/`newtonXTol` (nonlinearSolverHomotopy.c). `newton_solve`
-/// mirrors C's residual-gated convergence: a step-stall counts as success only
-/// when the residual is also small (`< NEWTON_FTOL*1e3`), else it fails so the
-/// homotopy globaliser engages instead of accepting a non-root.
-const NEWTON_FTOL: f64 = 1.0e-12;
-const NEWTON_XTOL: f64 = 1.0e-12;
+/// C's `newtonFTol`/`newtonXTol` (nonlinearSolverHomotopy.c), which `-newtonFTol` /
+/// `-newtonXTol` move. `newton_solve` mirrors C's residual-gated convergence: a
+/// step-stall counts as success only when the residual is also small
+/// (`< ftol*1e3`), else it fails so the homotopy globaliser engages instead of
+/// accepting a non-root.
+fn newton_ftol() -> f64 {
+    crate::solvers::newton_ftol()
+}
+fn newton_xtol() -> f64 {
+    crate::solvers::newton_xtol()
+}
 const MAX_ITER: i32 = 100;
 /// Line-search damping floor (2^-10): below this, keep the small step and let the
 /// outer iteration retry (or hit the iteration limit → recoverable failure).
@@ -558,7 +563,7 @@ fn homotopy_solve(
 
         // ---- Corrector: Newton with coordinate `pos` fixed ----
         let last_step = y1[n] >= 1.0;
-        let h_eps = if last_step { NEWTON_FTOL } else { H_EPS };
+        let h_eps = if last_step { newton_ftol() } else { H_EPS };
         let mut pos = if last_step { n as i32 } else { tangent_pos };
         let mut step_accept = false;
         let mut corrector_ok = true;
@@ -672,7 +677,7 @@ pub(crate) fn newton_solve(
 
     eval(x, &mut fvec);
     let mut error_f = enorm(&fvec);
-    if error_f < NEWTON_FTOL {
+    if error_f < newton_ftol() {
         return true;
     }
     f_old.copy_from_slice(&fvec);
@@ -758,15 +763,16 @@ pub(crate) fn newton_solve(
         if neg_steps > 20 {
             return false;
         }
-        let f_small = error_f < NEWTON_FTOL || scaled_error_f < NEWTON_FTOL;
-        let x_small = delta_x < NEWTON_XTOL || delta_x_scaled < NEWTON_XTOL;
+        let (ftol, xtol) = (newton_ftol(), newton_xtol());
+        let f_small = error_f < ftol || scaled_error_f < ftol;
+        let x_small = delta_x < xtol || delta_x_scaled < xtol;
         if f_small && x_small {
             return true;
         }
-        small_steps += (delta_x < NEWTON_XTOL * 100.0 || delta_x_scaled < NEWTON_XTOL * 100.0) as i32;
+        small_steps += (delta_x < xtol * 100.0 || delta_x_scaled < xtol * 100.0) as i32;
         if x_small || small_steps > 20 {
             // Stalled step: accept only with a small residual (C's ftol*1e3), else fail.
-            return error_f < NEWTON_FTOL * 1.0e3 || scaled_error_f < NEWTON_FTOL * 1.0e3;
+            return error_f < ftol * 1.0e3 || scaled_error_f < ftol * 1.0e3;
         }
         iter += 1;
         if iter > MAX_ITER {
@@ -1566,8 +1572,8 @@ fn newton_c(
 ) -> (bool, bool) {
     const ALPHA: f64 = 1.0e-1;
     const LAMBDA_MIN_C: f64 = 1.0e-4;
-    let ftol_sq = NEWTON_FTOL * NEWTON_FTOL;
-    let xtol_sq = NEWTON_XTOL * NEWTON_XTOL;
+    let ftol_sq = newton_ftol() * newton_ftol();
+    let xtol_sq = newton_xtol() * newton_xtol();
     let nsq = |v: &[f64]| -> f64 {
         let e = enorm(v);
         e * e
@@ -2147,11 +2153,9 @@ fn solve_newton_c(
     }
 }
 
-/// KINSOL function-norm / scaled-step stopping tolerances (C's `newtonFTol` /
-/// `newtonXTol`, `model_help.c`) and the norm below which C accepts a less
-/// accurate solution rather than failing (`FTOL_WITH_LESS_ACCURACY`).
-const KIN_FNORMTOL: f64 = 1.0e-12;
-const KIN_SCSTEPTOL: f64 = 1.0e-12;
+/// The norm below which C accepts a less accurate solution rather than failing
+/// (`FTOL_WITH_LESS_ACCURACY`). KINSOL's own stopping tolerances are C's
+/// `newtonFTol`/`newtonXTol`, i.e. [`newton_ftol`]/[`newton_xtol`].
 const KIN_FTOL_LESS_ACCURACY: f64 = 1.0e-6;
 
 /// `‖diag(scale)·v‖∞`, the norm KINSOL's stopping tests use.
@@ -2289,7 +2293,7 @@ fn newton_sparse_solve(
             if !fnorm.is_finite() {
                 break;
             }
-            if fnorm <= KIN_FNORMTOL {
+            if fnorm <= newton_ftol() {
                 solved = true;
                 break;
             }
@@ -2332,7 +2336,7 @@ fn newton_sparse_solve(
             }
             x.copy_from_slice(&xnew);
             fnorm = fnew;
-            if step <= KIN_SCSTEPTOL {
+            if step <= newton_xtol() {
                 solved = fnorm < KIN_FTOL_LESS_ACCURACY;
                 break;
             }

OMCompiler/Compiler/OpenModelica.rs/openmodelica_codegen_wasm_jit_runtime/src/nls.rs

@@ -252,10 +252,15 @@ pub extern "C" fn rt_sim_start(meta_ptr: u32, meta_len: u32, fn_base: u32, prese
     crate::sundials::reset_caches();
 
     let bytes = unsafe { core::slice::from_raw_parts(meta_ptr as *const u8, meta_len as usize) };
-    let model = match openmodelica_sim_meta::decode(bytes) {
+    let mut model = match openmodelica_sim_meta::decode(bytes) {
         Ok(m) => m,
         Err(_) => return -1,
     };
+    // A session always has a host, which renders `read_experiment`'s notices from
+    // the same flags; saying it again here would double every line.
+    driver::set_log_sink(|_| {});
+    simflags::with_flags(|f| model.apply_flags(f));
+    driver::set_log_sink(crate::omclog::sink);
 
     crate::nls::rt_set_step_size(model.step_size());
     // `-lv=LOG_NLS` names the iteration variables; only the metadata has them.
@@ -269,7 +274,6 @@ pub extern "C" fn rt_sim_start(meta_ptr: u32, meta_len: u32, fn_base: u32, prese
     driver::set_cancel_hook(cancel_hook);
     driver::set_init_done_hook(init_done_hook);
     driver::set_no_throw_hook(|v| unsafe { rt_host_set_no_throw(v as i32) });
-    driver::set_log_sink(crate::omclog::sink);
 
     let mut engine = InWasmEngine { fn_base, present_mask };
     let sim_data = crate::rt_alloc(model.layout.total);

OMCompiler/Compiler/OpenModelica.rs/openmodelica_codegen_wasm_jit_runtime/src/session.rs

@@ -65,6 +65,33 @@ static NLSS_MIN_SIZE: AtomicU32 = AtomicU32::new(1000);
 static NLSS_MAX_DENSITY: core::sync::atomic::AtomicU64 =
     core::sync::atomic::AtomicU64::new(0x3FB999999999999A); // 0.1
 
+/// C's `newtonFTol` / `newtonXTol` / `maxStepFactor` (`model_help.c`), which
+/// `-newtonFTol` / `-newtonXTol` / `-newtonMaxStepFactor` move. The homotopy Newton
+/// and KINSOL both read them, so they live here rather than in either solver.
+static NEWTON_FTOL: core::sync::atomic::AtomicU64 = core::sync::atomic::AtomicU64::new(0x3D719799812DEA11); // 1e-12
+static NEWTON_XTOL: core::sync::atomic::AtomicU64 = core::sync::atomic::AtomicU64::new(0x3D719799812DEA11);
+static MAX_STEP_FACTOR: core::sync::atomic::AtomicU64 = core::sync::atomic::AtomicU64::new(0x426D1A94A2000000); // 1e12
+
+#[unsafe(no_mangle)]
+pub extern "C" fn rt_set_newton_tuning(ftol: f64, xtol: f64, max_step_factor: f64) {
+    NEWTON_FTOL.store(ftol.to_bits(), Ordering::Relaxed);
+    NEWTON_XTOL.store(xtol.to_bits(), Ordering::Relaxed);
+    MAX_STEP_FACTOR.store(max_step_factor.to_bits(), Ordering::Relaxed);
+}
+
+pub(crate) fn newton_ftol() -> f64 {
+    f64::from_bits(NEWTON_FTOL.load(Ordering::Relaxed))
+}
+
+pub(crate) fn newton_xtol() -> f64 {
+    f64::from_bits(NEWTON_XTOL.load(Ordering::Relaxed))
+}
+
+#[cfg(sundials)]
+pub(crate) fn max_step_factor() -> f64 {
+    f64::from_bits(MAX_STEP_FACTOR.load(Ordering::Relaxed))
+}
+
 /// Set the four selectors for the next run. Host-driven builds call this through
 /// the export; the in-wasm session calls [`apply_flags`] instead.
 #[unsafe(no_mangle)]
@@ -95,6 +122,8 @@ pub(crate) fn apply_flags(f: &openmodelica_sim_meta::simflags::SimFlags) {
     rt_set_solvers(nls, nls_ls, ls, lss);
     let (min_size, max_density) = openmodelica_sim_meta::simflags::nlss_thresholds(f);
     rt_set_nlss_thresholds(min_size, max_density);
+    let (ftol, xtol, msf) = openmodelica_sim_meta::simflags::newton_tuning(f);
+    rt_set_newton_tuning(ftol, xtol, msf);
 }
 
 pub(crate) fn nls() -> Nls {

OMCompiler/Compiler/OpenModelica.rs/openmodelica_codegen_wasm_jit_runtime/src/solvers.rs

@@ -140,7 +140,12 @@ impl SimEngine for StandaloneEngine {
 /// Run the prepared model with the shared driver and write its result file.
 /// A failure traps (the command then exits nonzero).
 fn run() {
-    let m = read_meta();
+    let mut m = read_meta();
+    driver::set_log_sink(crate::omclog::sink);
+    simflags::with_flags(|f| {
+        simflags::print_notices(f);
+        m.apply_flags(f);
+    });
     let sim_data = crate::rt_alloc(m.layout.total);
     let mut engine = StandaloneEngine;
     crate::nls::rt_set_step_size(m.step_size());
@@ -195,7 +200,17 @@ fn run() {
         result.n_reals,
         &params,
     );
-    std::fs::write(format!("{}_res.mat", m.prefix), bytes).expect("wasm-jit standalone: cannot write result file");
+    std::fs::write(result_file(&m.prefix), bytes).expect("wasm-jit standalone: cannot write result file");
+}
+
+/// C's result-file resolution (`simulation_runtime.cpp`): `-r` outright, else
+/// `<prefix>_res.mat` under `-outputPath`.
+fn result_file(prefix: &str) -> String {
+    simflags::with_flags(|f| match (&f.result_file, &f.output_path) {
+        (Some(r), _) => r.clone(),
+        (None, Some(dir)) => format!("{dir}/{prefix}_res.mat"),
+        (None, None) => format!("{prefix}_res.mat"),
+    })
 }
 
 /// Wall clock for the driver, in ms since the first reading.

OMCompiler/Compiler/OpenModelica.rs/openmodelica_codegen_wasm_jit_runtime/src/standalone.rs

@@ -311,11 +311,9 @@ pub(crate) mod kinsol {
     const KIN_LSOLVE_FAIL: c_int = -12;
     const KIN_REPTD_SYSFUNC_ERR: c_int = -15;
 
-    /// C's `newtonFTol`/`newtonXTol`, `maxStepFactor` and `FTOL_WITH_LESS_ACCURACY`
-    /// defaults, and `RETRY_MAX`.
-    const FNORMTOL: f64 = 1.0e-12;
-    const SCSTEPTOL: f64 = 1.0e-12;
-    const MAXSTEPFACTOR: f64 = 1.0e12;
+    /// C's `FTOL_WITH_LESS_ACCURACY` and `RETRY_MAX`; the stopping tolerances and
+    /// the step factor are C's `newtonFTol`/`newtonXTol`/`maxStepFactor`, which
+    /// `crate::solvers` holds because `-newtonFTol` and friends move them.
     const FTOL_LESS_ACCURACY: f64 = 1.0e-6;
     const RETRY_MAX: i32 = 5;
 
@@ -425,7 +423,7 @@ pub(crate) mod kinsol {
                 n,
                 nnz,
                 strategy: KIN_LINESEARCH,
-                maxstepfactor: MAXSTEPFACTOR,
+                maxstepfactor: crate::solvers::max_step_factor(),
                 numeric_jac: false,
             };
             if s.kin.is_null()
@@ -446,8 +444,8 @@ pub(crate) mod kinsol {
                 {
                     return None;
                 }
-                KINSetFuncNormTol(s.kin, FNORMTOL);
-                KINSetScaledStepTol(s.kin, SCSTEPTOL);
+                KINSetFuncNormTol(s.kin, crate::solvers::newton_ftol());
+                KINSetScaledStepTol(s.kin, crate::solvers::newton_xtol());
                 KINSetNumMaxIters(s.kin, 100 * n as c_long);
                 KINSetNoInitSetup(s.kin, 0);
             }
@@ -583,8 +581,8 @@ pub(crate) mod kinsol {
             }
             if reset_tol {
                 unsafe {
-                    KINSetFuncNormTol(self.kin, FNORMTOL);
-                    KINSetScaledStepTol(self.kin, SCSTEPTOL);
+                    KINSetFuncNormTol(self.kin, crate::solvers::newton_ftol());
+                    KINSetScaledStepTol(self.kin, crate::solvers::newton_xtol());
                 }
             }
             if success {