[RFC] Restartable sequences about rfcs HOT 3 OPEN

Hi

Is this not a special case to determine (for some reason) that a code block has executed without preemptions? Or in a more general setting, atomic implies that the number of preemptions the code has been exposed to is 0.

This is not currently a notion of RTFM (but can be encoded by hand if so wished by manually inserting some entry code in each handler similarly to your suggestion). Alternatively one could think of exploiting the underlying debugging features (not sure exactly how, but I think there are probing counters for interrupts). If this is to be a feature of RTFM either the OH should be 0 when not used, or explicitly opted in. It would require some changes to RTFM app analysis and code generation.

Regarding the implementation:
What you implement is some sort of double buffering for a consistent view. This can likely NOT be implemented in safe Rust, but can be useful here and in other scenarios. I suggest looking at the lock free implementations of SPSC/MPSC in heapless, perhaps double buffer could go there. (Idea is to access the double buffered state through an atomically updated reference).

Best regards
Per

from rfcs.

Is this not a special case to determine (for some reason) that a code block has executed without preemptions? Or in a more general setting, atomic implies that the number of preemptions the code has been exposed to is 0.

Correct.

This is not currently a notion of RTFM (but can be encoded by hand if so wished by manually inserting some entry code in each handler similarly to your suggestion).

I might be mistaken, but it seems like you can't actually add any code to handlers used for software tasks. (Instead of supporting this directly, would adding something more general to allow this be preferred instead? Maybe something like #[interrupt_{prologue, epilogue}]? Or something less general, like generating and exposing an interrupt sequence number?)

Alternatively one could think of exploiting the underlying debugging features (not sure exactly how, but I think there are probing counters for interrupts).

I searched for a bit but couldn't find one for the cortex-m3, at least.

If this is to be a feature of RTFM either the OH should be 0 when not used, or explicitly opted in. It would require some changes to RTFM app analysis and code generation.

Gating it behind a feature seems like the easiest option for this.

What you implement is some sort of double buffering for a consistent view. This can likely NOT be implemented in safe Rust, but can be useful here and in other scenarios. I suggest looking at the lock free implementations of SPSC/MPSC in heapless, perhaps double buffer could go there. (Idea is to access the double buffered state through an atomically updated reference).

Sure, a better implementation could commit with a double (or triple) buffer (and avoid blocking interrupts entirely), but that's up to the user. A double/triple buffer allows you to publish a consistent view, this proposal allows you to generate the consistent view that you're publishing to your buffer.

from rfcs.

Any further thoughts on this?

from rfcs.