Nanoseconds as an integral count.

Read the monotonic clock. Absolute value is not meaningful; use deltas between readings.

On Linux/macOS we use MonotonicRaw for NTP-frequency-adjustment-free timing; on Windows we fall back to the portable Monotonic clock.

Read clock before and after; return the delta in nanoseconds.

This is a stopwatch: start captures the initial time, and each stop reads the current clock and subtracts. Calling stop multiple times gives cumulative elapsed time since the single start.

Single timing of a pure function. Returns (nanos, result).

n timings of the same function. Returns ( [nanos], lastResult ).

n timings collapsed to a single average nanosecond count.

The computation is run n times; the total time is divided by n.

n IO timings collapsed to a single average nanosecond count.

Meter an IO action with timeX.

The result is a Circuit polymorphic in the tensor t, so it can be lifted into pipelines using either (,) (lazy knot-tying) or Either (iteration) without changing the combinator.

Meter a pure function with timeX. Forces to WHNF inside the timed bracket so the work cannot be floated out.

Warm up the clock with n dummy reads. Avoids cold-start artefacts.

Reify a circuit using the cartesian tensor (,).

Convenience alias for run with t = (,), used by the runners below to extract a K from a metered circuit.

Measure a single call to a pure function. Forces the result to WHNF inside the timed IO action so the work cannot be floated out.

Measure a single call to a K arrow.

Measure a K arrow repeated n times. Returns per-run measurements and the last result.

The step is marked NOINLINE so GHC cannot float the computation out of the timing loop.

>>> import Circuit.Category (K(..))
>>> import Circuit.Meter (Meter(..))
>>> let m = Meter (K $ \_ -> pure 0) (K $ \_ -> pure 0)
>>> runK (timesK 100 3 m (K (pure . (*2)))) 5
([...,...,...],10)