General question regarding limits of BP - cancelation

[mryndzionek]

Hi,

I'm investigating the usefulness and limits of BP. So far it looks promising and I only encountered one problem
that essentially, I think, amounts to cancelation. For example this simple, reactive system (as a statechart):

It's easy to write a b-thread for the active superstate. It's also easy to block the tmout events after sig_button.
However how to restart the active state after the second sig_button?
Unblocking tmouts won't guarantee that the sequence starts from the on state.
What is needed, seems to be, canceling and then restarting the active state.
In BP this would amount to canceling and restarting a subset of b-program's
b-threads from another b-thread. Is my reasoning correct? Maybe there is another solution?

Feedback is appreciated.

[michbarsinai]

Cancellation is best done using interrupt(eventSet, function(){}) blocks, where eventSet is the outgoing event (esm_sig_btn here, if I get this correctly).

As for starting at the active->on state, it's a question of how you map the StateCharts event to BP. Suppose there's an event Event("active::enter") selected whenever the systems enters the active state, you could have an infinite loop such as

while ( true ) {
   waitFor(Event("active::enter"));
   request(Event("active/on::enter"));
   // -- or ---
   sync({
     block: Event("active/off::enter"),
     waitFor: Event("active/on::enter")
   });
}

This will make sure whenever the system enters the active state, it will go into the on sub-state.

Does this answer your question? (also - sorry for late reply)

[mryndzionek]

Does this answer your question? (also - sorry for late reply)

No worries.
I think you're proposing explicitly "modeling" the statechart scheduler. I was thinking about implementing the system directly, without enter on::enter. If I remember correctly my conclusion was that additional canceling mechanism is needed built-in into BP. Loosely it would be something like:

bp.registerBThread("bpjs blink", function () {
    while (true) {
        while (true) {
            bp.sync({ request: bp.Event("LED_ON") });
            // start timer requesting "TIMEOUT" after some delay
            bp.sync({ waitFor: bp.Event("TIMEOUT") });

            bp.sync({ request: bp.Event("LED_OFF") });
            // start timer requesting "TIMEOUT" after some delay
            bp.sync({ waitFor: bp.Event("TIMEOUT") });
        }
        bp.on_cancel(); // Will break here after "CANCEL" event
    }
})

bp.registerBThread("bpjs button", function () {
    while (true) {
        bp.sync({ waitFor: bp.Event("BUTTON") });
        // stop "TIMEOUT" timer
        bp.sync({ request: bp.Event("CANCEL") });
        bp.sync({
            waitFor: bp.Event("BUTTON"),
            block: bp.Event("LED_ON"), block: bp.Event("LED_OFF")
        });
    }
})

bp.on_cancel() is the addition (+ timers). In general I ended up writing my own toy framework in C. Here is the link if you're interested: https://github.com/mryndzionek/toy_bp_c/blob/cancelation_2/src/button_blink.c#L62

[michbarsinai]

toy_bp_c is a very cool project!

You are right - I assumed that the statecharts are transpiled into BP and then executed (this is the approach we take zt Provengo (https://provengo.ai) for implementing DSLs). If you're running the BP alongside a state chart engine, that's a different ball game.

I'm not sure what are exact semantics of bp.on_cancel(). If it means "break if sometime at the past there was a cancel event", this could be achieved using interrupt(eventSet, function), which basically adds an implicit wait-for for an event set at any synchronization point, and terminates the thread in case that event was selected. It's not exactly break, but with some additional coding it can be equivalent.

Another option is to use bp.store, which is a central storage for data that bthreads can interact with. This way you can have an independent bthread that waits for the cancel event and writes to the store, and the main bthread would read from the store and break accordingly.

Harel and Marron et al had a position paper about running scenario-based programs next to a state chart here:
https://www.semanticscholar.org/topic/YAKINDU-Statechart-Tools/12021261

[mryndzionek]

I'm not sure what are exact semantics of bp.on_cancel(). If it means "break if sometime at the past there was a cancel event", this could be achieved using interrupt(eventSet, function)

Yeah, this is exactly it. Thanks for detailed response.