a seed schedule thought

[glycerine]

Hybrid physical-logical clocks might make a nice (deterministic) way to specify the cut-over points to change to a new seed. I have found them very useful in many places. Background and sample implementation (it is tiny, in Go, should be trivial to port, especially as the atomics can be discarded for any single threaded environment) here

https://github.com/glycerine/hlc

-- the idea being that each deterministic "step" of the simulation advances the hlc by at least 1, but maybe more (hlc first try to use the deterministic/monotonic "system clock", but if that clock has not advanced, it uses the low 16 bits to always ensure a new hlc timestamp).

[glycerine]

The other thought that occurred to me this morning was perhaps a Lingua Franca style pair of integers. https://www.lf-lang.org/ was designed for slight higher level deterministic parallelism for embedded systems whose software needs to maintain a strong relationship between logical time and physical time even if the hardware is upgraded (i.e. is run on a faster CPU; this was a major problem for Esterel/Lustre languages for embedded systems in the past). Their (logical time, index) might be an idea worth stealing if the hlc low 16 bits might ever overflow. https://reactor-model.org/ is the full treatment; Lohstroh's 2020 Berkeley Ph.D. Dissertation is interesting https://www2.eecs.berkeley.edu/Pubs/TechRpts/2020/EECS-2020-235.pdf for how they designed timestamps with the two parts.

[sb2bg]

Hi Jason!

I think your second comment lands on the right answer. The LF style (logical time, microstep) pair fits Marionette more naturally than a full HLC. The clever part of an HLC (borrowing low bits to stay monotonic when the physical clock stalls) is solving a coordination problem a deterministic simulator doesn't have. There is exactly one clock authority, and it only advances when the World says so. What remains is just the plain fact that many deterministic steps happen at the same simulated instant, which is exactly what the microstep disambiguates. So no overflow concern either, since the index is per timestamp and unbounded rather than packed into 16 bits.

I'd spec schedule cutpoints in that superdense form: (sim_time_ns, n) meaning "the nth randomness draw at this timestamp." The trace already totally orders every draw, so the pair is really a human friendly projection of the global event index, which matters: "switch seeds at 30s" desugars to (t, 0), while a branch point harvested from an explored run uses the full pair. Both stay deterministic under prefix replay for free.

Hadn't read Lohstroh's treatment, thanks for sharing :)

This will go into design notes on the roadmap later tonight.