多线程程序中的stackoverflow

Question

我正面临设计问题。 函数1和2相互调用数百次，递归不是无限的。 在运行程序时，它满足溢出条件。设置openmp stacksize也不起作用。

#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

如果确实调用另一个函数是每个函数中的最后一件事，则可以手动将function2内联到function1并将递归转换为循环：

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
    }
}

它可能会通过移动的定义，以达到同样的效果function2之前function1和内联宣布它-编译器的优化器则能够内联函数，把尾递归调用到分支机构。

如果您的函数比您所描述的要复杂（而不是尾部递归），那么这将无法简单地工作，尽管您可以稍微改变一下内容使其尾部递归。

Answer 2

最好的选择是只有一个功能。
在您的评论中，您说： «不可能，因为函数彼此调用» 。

但这正是为什么堆栈会溢出的原因，因此可以认为这是错误的设计...

据我所知，您不需要单独的功能。
您可以轻松解决问题，例如：

#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
    }
}

我知道很多人说goto语句是错误的设计选择，但是在您的情况下，我认为情况并非如此……这只会节省您的堆栈空间。

无论如何，它仍然比不起作用的代码要好。