u/anatoledp

i make a small embeddable scripting language (zym) with mcu use as a target, runtime only builds, statically provisionable heap, that kind of stuffs. its at 0.3.x and im at a design fork i want opinions on from people who put interpreters on constrained hardware

the vm currently has instruction count preemption that is deterministic and exact. you say fire every N instructions and it fires at instruction N, and both the host and the script can arm it. it also has continuations as a primitive so script can build its own schedulers

exactness costs a counter check on every instruction, measured at about 21% of throughput on dispatch heavy code. checking only at loop back edges and calls recovers 15-17% but the watchdog then overshoots by up to one straight line block instead of firing on the exact instruction

what im considering:

- script side concurrency becomes cooperative fibers/coroutines with explicit yield and native scheduling, no counter involved

- preemption becomes host only, a watchdog and hard stop the embedding code arms to bound runaway or untrusted script. script cannot see or touch it, bounded rather than exact, and it is a compile flag so a fully trusted build drops the check entirely

questions for this crowd specifically:

- for a watchdog on script code, do you need it to fire on an exact instruction, or do you need it to be impossible to outrun and fire within a bounded window? my instinct is bounded is fine for nearly everything but timing determinism people are exactly who i would expect to disagree

- is script side preemption, the script scheduling itself preemptively, something you would actually want on an mcu, or is cooperative plus a host guard the sane shape? i built the script side version and i am not sure anyone needed it

- anyone shipping an interpreter on hardware with a guard on / guard off build split, and did it cause problems later?

these questions have been bugging me for a while so mostly here for the answers, happy to explain any of the reasoning if it helps, have been trying to come to a decision for a few weeks so am reaching out for people that use scripting on their systems and what their expectations are as well as what they actually care about in these regards

website: https://zym-lang.org/

github: https://github.com/zym-lang/

posted zym here a while back (embeddable dynamic scripting language, one shot delimited continuations as a primitive, instruction count preemption that host and script can both drive). its at 0.3.2 now with various edges being smoothed over

im now second guessing the concurrency model and wanted to think it through with people who care about this area as i am completely split on where to take this

the current design is continuations and preemption as a pair. it is powerful, you can write whatever scheduler you want in userland. but ive gotten personal reports were people constructing fibers by hand from the raw primitive and hitting capture/resume edge cases. essentially a want for fibers, they just have to build them

the preemption side is exact. it fires at instruction N for both host and script and that requires a counter check on every dispatch, which i measured at ~21% on dispatch heavy code. i tried several ways to make it cheaper (safepoints at back edges and calls, fuel metering with compiler folded costs, dual dispatch tables) and anything that keeps exact firing does not win. back edge safepoints recover 15-17% but overshoot by up to one straight line block

so what im considering is swapping the whole story:

- native cooperative fibers/coroutines as the concurrency model, native scheduling so a switch is cheap and there is nothing to construct

- continuations either kept as an advanced primitive under the fibers or removed from the surface

- preemption becomes host only, a sandbox guard the embedder arms and script cannot observe. once script cannot observe it, bounded firing is acceptable, so the cheaper check is usable and the whole thing can be a compile flag for hosts that do not need it

that gets everyone 15-20% and a model people already know. what it gives up is the primitive being the surface

what i actually dont know:

- do people who use delimited continuations want them exposed, or would they take fibers built on them and not miss it, and the reverse as well would people who use fibers just prefer to use that or would they want flexibility of continuations? i made them one shot delimited for sanity and most languages hide this anyway

- is native yield/resume ever too limiting? effects and handlers people especially, curious whether fibers give up something you would notice, for those that dont use effects would there be a want for them if cooperative scheduling were the baseline

- would you keep the raw primitive as an escape hatch even if almost nobody touches it, or is that surface area for its own sake that would not get used by the vast majority?

happy to go into the measurements or the design, its been a rabbit hole, just has been absolutely bugging me for the past few weeks on that design decision and if people would actually expect or even use this capability over a simpler and more intuitive model but also not as flexible and i am dying for answers to these

language: https://zym-lang.org

github: https://github.com/zym-lang