Is there a way to prioritise Coroutines?

[brewmanz]

How do I prioritise Coroutines? I expect that there is no preemptive scheduling, only yield of control with COROUTINE_DELAY (or similar).
BTW will COROUTINE_DELAY(0) actually yield control, or continue straight away?
Let's say I have COROUTINE(urgent), COROUTINE(normal), and COROUTINE(background).
How do I ensure that urgent gets dispatched before the others, should multiple routines be ready to run?
Is dispatch order decided by declaration order?
Or by order of foo.runCoroutine() in loop() (which I suspect) ?
Would the most appropriate way to prioritise them be:

void loop() {
  urgent.runCoroutine();
  normal.runCoroutine();
  urgent.runCoroutine();
  background.runCoroutine();
  urgent.runCoroutine(); // Or does having this here achieve 'not very much' ??
}

?
Thanks for this useful library, and any assistance you can give.

[bxparks]

AceRoutine is a cooperative multitasking library, so there is no ability to prioritize one coroutine over another. I am not even sure what "higher priority" would even mean in the context of this library. Do you have a concrete example where this might be important?

If you call your coroutines manually using Coroutine::runCoroutine() in the global loop(), then each coroutine will get a chance to run exactly as you have written the order of the runCoroutine() methods. If you call urgent.runCoroutine() a second or third time, then I guess it gets a "higher priority" in the sense that it gets 2-3 chances to run for each iteration of the loop(), but all others get only one chance to run.

With regards to COROUTINE_DELAY(0), if you peek into the implementation, you will see that it is basically equivalent to COROUTINE_YIELD(). (Admittedly, that code is written as a macro which is more difficult to understand..)

[brewmanz]

So many examples e.g. any time critical foreground task with potentially blocking background processes.
Anyway, an actual concrete example I am currently working on - an oscilloscope.
Urgent - sampling the ADC every N microseconds+ (using registers, not analogRead), waiting for completion, and storing values in array.
Normal - examine recent ADC values looking for rising/falling triggers, to monitor and control array of stored ADC values.
Background 1 - Check for any commands from IDE SerialPlotter.
Background 2 - Checking that Serial has space to write data (Serial.available()), otherwise Serial writing becomes blocking. If buffer is, say, over 50% free, then trundle through ADC values array and Serial write data for plotting in IDE SerialPlotter.
Should all the coroutines be eligible for dispatching, I want Urgent to run with a higher priority. At worst, I want Urgent to only wait for one of the others to finish/yield.

• Arguably having ADC reads done via interrupt would be better time-wise, but requires locking of stored values array that Normal and Background2 process.

[bxparks]

If you have the concepts of foreground and background tasks in your app, then this library may not be suitable for you. This is a cooperative multitasking library, not a preemptive one. All tasks are treated equally within this library. Any coroutine, no matter how low priority you consider it to be, can completely block the scheduling of all other coroutines.

You could configure your coroutines to delay with different values, with higher priority using smaller delays. That works for many situations. But it does not change the fundamental property that all coroutines must cooperate with each other so that they don't block unnecessarily.