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陈述是糟糕的设计选择，但在你的情况下，我认为不是这样......它只会节省你的堆栈空间。

无论如何，它仍然会比非工作代码更好......

多线程程序中的stackoverflow

2 个答案: