多线程程序中的stackoverflow

Question

I am facing a desing issue. function 1 and 2 call each other few hundred of times,the recursion is not infinite. while running the program,it meet a overflow condition.setting openmp stacksize is also not working.

#pragma omp parallel 
{
    //some variable private to each thread
    //some processing
    //call function1( array )


}

function1( array ){
     //some variable
    //some processing
    //call function2( array )
    //return


}

function2( array ){
      //some variable
     //some processing
    //if condition fail return
    //else call function1()
    //return

}

Answer 1

If calling the other function is truly the last thing in each function, you could manually inline function2 into function1 and turn the recursion into a loop:

function1(array) {
    while(1) {
        // some variables (from function 1)
        // some processing (from function 1)
        // some variables (from function 2)
        // some processing (from function 2)
        if condition fail break;
        // loop back 'calling' function 1 again
    }
}

It may be possible to achieve the same effect by moving the definition of function2 before function1 and declaring it inline -- the compiler's optimizer may then be able to inline the function and turn the tail-recursive calls into branches.

If your functions are more complex than you've described (and not tail recursive) then this won't work simply, though you may be able to transform things a bit to make it tail recursive.

Answer 2

Your best option is to have a single function.
In your comment, you say: «It's not possible because the functions call each other» .

But this is precisely why you're getting a stack overflow, so this can be considered as bad design...

For what I can see, you do not need separate functions.
You could easily solve the issue with, for instance:

#pragma omp parallel 
{
    // Some variables private to each thread
    // Some processing
    // call function1( array )
}

function1( array )
{
    start:
    {
        // Some variables
        // Some processing
    }

    {
        // Some variables
        // Some processing
        // if condition fail return
        // else goto start
    }
}

I know lot's of people says goto statements are bad design choices, but in your situation I don't think it's the case... And it will just save your stack space.

Anyway, it will still be better than a non-working piece of code...