如何在CUDA中为三维字符串数组分配内存

Question

我在CUDA中实现混合二叉树。我被困在传递3d数组字符串。我已经看到我们不能在内核中使用字符串，所以我想使用char数组。我试过这个，但我没有得到，我认为内核函数没有执行。

int k=2;
int size_trie=pow(2,k);

int size_tab_r=32;
double size_tab_c=20;
#define block_size 10

string rt[8][32][20];

我想在内核函数中传递这个3d数组。

//kernel function 

__global__ void search_trie(char **a,int *c,char ips[],int size,int size_trie,int size_tab_r,int size_tab_c)
{
if(i<size_trie && j<size_tab_r && k<size_tab_c)
{
if(a[i*size_tab_r*size_tab_c+j*size_tab_c+k][0] != '\0')
{
int Mid,Lbound=0,Ubound=size_tab_r-1;

    while(Lbound<=Ubound)
    {
            Mid=(Lbound+Ubound)/2;
            if(size>Mid)
                    Lbound=Mid+1;
            else if(size<Mid)
                    Ubound=Mid-1;
            else
            {
                      for(int k1=0;k1<size_tab_c;k1++)
                      {
                            if(a[i*size_tab_r*size_tab_c+(Mid-1)*size_tab_c+k1][0] !='\0')
                            {

                             for(int i1=0;i1<size;i1++)
                            {
                                    if(ips[i1] == a[i*size_tab_r*size_tab_c+(Mid-1)*size_tab_c+k1][i1])
                                    {
                                            c[i]=Mid-1;
                                            return;
                                    }
                            }

                            }
                      }

                     int ret[20];
 for(int k1=0;k1<size_tab_c;k1++)
                      {
                            ret[k1]=-1;
                            if(a[i*size_tab_r*size_tab_c+(Mid-1)*size_tab_c+k1][0] !='\0')
                            {
                            for(int i1=0;i1<size;i1++)
                            {
                                    if(ips[i1] == a[i*size_tab_r*size_tab_c+(Mid-1)*size_tab_c+k1][i1])
                                    {
                                            ret[k1] = i1;
                                    }
                                    else
                                    {
                                            break;
                                    }
                            }
                            }
                      }
                    int max=-1;
                    for(int i1=0;i1<size_tab_c;i1++)
                    {
                            if(ret[i1]>max)
                            max=ret[i1];
                    }
                    c[i]=max;
                    return;
            }
    }
}
else
c[i]=-1;
return;
}
 else
 return;
}



// host

int size_ips;
char ips[30];
cout<<"Enter size of ip address\n";
cin>>size_ips;

cout<<"Enter the ip address to search\n";
cin>>ips;

double size=size_trie*size_tab_r*size_tab_c*sizeof(char);

char **dA;
 int *dC;
 cudaMalloc(&dA,size);
 cudaMalloc(&dC,size_trie);
 dim3 threadBlock(size_trie,size_trie);
 dim3 grid(size_tab_r,size_tab_c);
 cudaMemcpy(dA,rt,32*size,cudaMemcpyHostToDevice);
 cudaEventRecord(start);
  search_trie<<<grid,threadBlock>>>dA,dC,ips,size_ips, size_trie,size_tab_r, size_tab_c);
 cudaMemcpy(ct,dC,size_trie,cudaMemcpyDeviceToHost);