Блог

Я создал параллельную версию алгоритма BFS, теперь я пытаюсь сериализовать тот же алгоритм, чтобы получить представление об ускорении. Мой код таков:

 #include <stdio.h>
#include <stdlib.h>
#include <math.h>

struct Node 
{
    int begin;     // begining of the substring
    int num;    // size of the sub-string 
};

void BFS (Node *Va, int *Ea, bool* Fa, bool *Xa, int *Ca,bool *para, int tid)
{

    int nid;

        if (Fa[tid] == true amp;amp; Xa[tid] == false)
        {
          Fa[tid] = false; 

                   for (int i = Va[tid].begin;  i < (Va[tid].begin   Va[tid].num); i  ) // Va begin is where it's edges' subarray begins, Va is it's                                                                        number of elements
            {           
                nid = Ea[i];

                if (Xa[nid] == false)
                {
                  Ca[nid] = Ca[tid]   1;
                  Fa[nid] = true;
                  *para = true;
                }   
            }
            Xa[tid] = true;
        }

}

int main()
{


    struct Node Va[4]; 
    Va[0].begin=0; 
    Va[0].num=2; 
    Va[1].begin=1; 
    Va[1].num=0; 
    Va[2].begin=2; 
    Va[2].num=2; 
    Va[3].begin=1; 
    Va[3].num=0; 
    int edges[]={1,2,3,1}; 
    //cudaMalloc((void**)amp;Va,sizeof(Node)*4); 
    //cudaMemcpy(Va,node,sizeof(Node)*4,cudaMemcpyHostToDevice); 

    int Ea[4]={1,2,3,3}; 
    //cudaMalloc((void**)amp;Ea,sizeof(Node)*4); 
    //cudaMemcpy(Ea,edges,sizeof(Node)*4,cudaMemcpyHostToDevice); 

    bool Fa[4]={false};     
    int source=0; 
    Fa[source]=true; 
    //cudaMalloc((void**)amp;Fa,sizeof(bool)*4); 
    //cudaMemcpy(Fa,frontier,sizeof(bool)*4,cudaMemcpyHostToDevice); 

    bool Xa[4]={false}; 
    //cudaMalloc((void**)amp;Xa,sizeof(bool)*4); 
    //cudaMemcpy(Xa,visited,sizeof(bool)*4,cudaMemcpyHostToDevice); 

    int Ca[4]={0}; 
    //cudaMalloc((void**)amp;Ca,sizeof(int)*4); 
    //cudaMemcpy(Ca,custo,sizeof(int)*4,cudaMemcpyHostToDevice); 

    //dim3 grid(1,1,1); 
    //dim3 threads(4,1,1); 


    bool* para; 
    int i=1,n=0,j;


    for (j=0; j<4 ; j  )
    {
    BFS(Va,Ea,Fa,Xa,Ca,para,j);

    printf("Run number: %d >> ",n); 
    for(int i=0;i<4;i  ) 
        printf("%d  ",Ca[i]); 
    printf("n");


    printf ("n             Xa :"); 
    for(int i=0;i<4;i  ) 
        printf("%d  ",Xa[i]); 
    printf("nn");



    n  ;
    printf("%d",n);
    }



        printf("nFinal:n");
    for(int i=0;i<4;i  ) 
        printf("%d  ",Ca[i]); 
    printf("n");

}
 

Обратите внимание, что это бывшая программа CUDA…

Кроме того, я компилирую с помощью g , чтобы я мог использовать переменные bool.

Проблема в том, что я получаю ошибку seg, как только я выполняю первый запуск функции BFS.

para ни на что не указывает, но вы присваиваете ему.

объявите его как bool para и передайте amp;para вместо этого