How to avoid blocking (C++, Win32)

Question

I'm making a dll that has to respond to an application's requests. One of the application's requirements is that a call should not take long to complete.

Say, I have a function foo(), which is called by the host application:

int foo(arg){
// some code i need to execute, say,
LengthyRoutine();
return 0;
}

Lets say, foo has to perform a task (or call a function) that is certain to take a long time. The application allows me to set a wait variable; if this variable is non-zero when foo returns, it calls foo again and again (resetting the wait variable before each call) until wait is returned 0.

What's the best approach to this?

Do I go:

int foo(arg){

    if (inRoutine == TRUE) {
        wait = 1;
        return 0;
    } else {
        if (doRoutine == TRUE) {
             LengthyRoutine();
             return 0;
        }
    }

    return 0;
}

This doesn't really solve the problem that LengthyRoutine is gonna take a long time to complete. Should I spawn a thread of some sort that updates inRoutine depending on whether or not it has finished its task?

Thanks..

Answer 1

Spawning another thread is pretty much the best way to do it, just make sure you set the result variables before you set the variable that says you're finished to avoid race conditions. If this is called often you might want to spawn a worker thread ahead of time and reuse it to avoid thread start overhead.

There is another possible solution, do part of the work each time the function is called, however this spends more time in the DLL and probably isn't optimal, as well as being more complex to implement the worker code for most algos.

Answer 2

If incredible rare situation where LengthyRoutine() isn't 3rd party code and you have all the source and it's possible to split it up then you can consider using coroutines.

Answer 3

If C programming, use callback - pass the callback to foo. You have to agree on the callback signature and do some housekeeping to trigger it when the work in LengthyRoutine is done.

typedef (void) callbackFunction(void);

int foo(arg, callbackFunction)
{
   // some code i need to execute, say,
   // register callback and return right away
   // Trigger the LengthyRoutine to run after this function returns

   return 0;
}

LengthyRoutine()
{
   // do lenghty routine

   // now inform the caller with their suppiled callback
   callbackFunction();
}

Essentially Observer Pattern in C. C++ makes the work a lot easier/cleaner in my opinion