Let's say I have two functions:

Code:

---

void bla()
{
while(1)
{
//do something
wait(1)
}
}

---

and
Code:

---

void blub()
{
bla();
while(1)
{
//do something
wait(1)
}
}

---

blub calls bla - the while loop of bla starts running.
Afterwards the while loop of blub is started.

Now my question: Is it GUARANTEED that the while loop of bla is ALWAYS processed before the while loop of blub or can there be random behaviour?


Why should someone use a setup like this?
Well, I've written a DLL for a input device. It is used with a script which simualtes key_... and joy_raw values for this device. This is supposed to be done in bla(). The user writes his function blub(), calls the main function for the device one single time (bla) and then can use the values in his own while loop - without having to use proc_late() or whatever. Does this work out, or can it cause a one frame delay (which DOES hurt)?

Only JCL can answer this, because he wrote the coroutine support.

The question is: the calling function is stored on the stack before the called function is being called. So, the wait call of the called action would be placed in the queue before the wait instruction of the calling function in the very first frame. But it could be as well the case that the wait instructions are executed in the order of the calls of the functions - so the wait instruction of the called function would be executed after the wait call of the calling function.

Nevertheless if 1 frame delay would hurt you or not, this is definitely not good. Normally you use for such a behaviour frame functions (or callbacks for generic code):

Code:

---

function funcA (...) {...}
function funcB (...) {...}

function funcMain (...)
{
   while (1) {
      funcA();
      funcB();
      wait(1);
   }
}

---

By this you assure the right order of your calculations and have no trouble with coroutines. If you are in the case that another programmer does sloppy coroutine programming, simply kick his ass or write it yourself

Hi Firoball,

It's been my my experience that the scheduling of multiple functions with imbedded "while(1) {wait(1);}" is very deterministic, and there is no randomness at all. I strongly suspect that once you have setup an order of execution (i.e. bla first, then blub), it will stay the same for each frame. Don't take my word for it. You can test this easily with some debug logging.

Lucidman

Functions run in the same order they were started. For changing the order of functions see proc_mode ( http://manual.conitec.net/proc_mode.htm ).

Ok, so if I understood correct, my sample setup should work as intended.

Thanks to all contributors.