從遞歸轉換為迭代函數cuda c ++

Question

我正在研究一個遺傳程序，其中將一些繁重的工作移植到了CUDA中。 （以前只是OpenMP）。

它的運行速度不是很快，並且我遇到了與遞歸相關的錯誤：

無法靜態確定入口函數'_Z9KScoreOnePdPiS_S_P9CPPGPNode'的堆棧大小

我添加了在CUDA上運行的全部邏輯。 我相信它足以顯示其工作原理。 我很高興聽到我可以添加的其他優化，但是我真的很想采用遞歸，因為它可以加快速度。

非常歡迎舉例說明如何實現這一目標。

__device__ double Fadd(double a, double b)   {
    return a + b;
};


__device__ double Fsubtract(double a, double b)   {
        return a - b;
};

__device__ double action (int fNo, double aa , double bb, double cc, double dd) {
    switch (fNo) {
    case 0 :
        return Fadd(aa,bb);
    case 1 :
        return Fsubtract(aa,bb);
    case 2 :
        return Fmultiply(aa,bb);
    case 3 :
        return Fdivide(aa,bb);
    default:
        return 0.0;
    }

}

__device__ double solve(int node,CPPGPNode * dev_m_Items,double * var_set) {
    if (dev_m_Items[node].is_terminal) {
        return var_set[dev_m_Items[node].tNo];
    } else {
        double values[4];
        for (unsigned int x = 0; x < 4; x++ ) {
            if (x < dev_m_Items[node].fInputs) {
                values[x] = solve(dev_m_Items[node].children[x],dev_m_Items,var_set);
            } else {
                values[x] = 0.0;
            }
        }
        return action(dev_m_Items[node].fNo,values[0],values[1],values[2],values[3]);
    }
}

__global__ void KScoreOne(double *scores,int * root_nodes,double * targets,double * cases,CPPGPNode * dev_m_Items) {
    int pid = blockIdx.x;

    // We only work if this node needs to be calculated
    if (root_nodes[pid] != -1) {
        for (unsigned int case_no = 0; case_no < FITNESS_CASES; case_no ++) {
            double result = solve(root_nodes[pid],dev_m_Items,&cases[case_no]);
            double target = targets[case_no];
            scores[pid] += abs(result - target);
        }
    }
}

我在使任何堆棧示例都適用於大型樹結構時遇到了麻煩，這就是解決的方法。

Answer 1

我已經解決了這個問題。 將遞歸參數放入堆棧中的情況並不完全，但它是一個非常相似的系統。

作為創建節點樹的一部分，我將每個節點附加到一個向量中。 現在，我可以使用http://en.wikipedia.org/wiki/Reverse_Polish_notation反向解決問題，因為每個節點都包含要執行的值或函數，因此非常適合。

它也比遞歸版本快20％，所以我很高興！