如何从CUDA内核代码中的字符数组元素打印单词？

我有一个文本字符数组，由文本文件中的单词填充

例如

text[0]=“一”，

text[1]=“两个”

等等

所有数组元素都等于线程数。我想使用CUDA将所有文本数组打印到屏幕上。我尝试使用以下代码打印，但它不起作用。我很困惑如何将像
text[][]
这样的数组传递给CUDA内核函数

#define MAX_SIZE 100   
#define elements 20 

__global__ void calculate(char *d_text) {
  int idx = threadIdx.x;
  printf("test %s /n", d_text[idx]);
}

int main() {
  char text[MAX_SIZE][MAX_SIZE]; // have text array with words
  char *d_text;

  cudaMalloc((void **)&d_data, DATA_BYTES);

  cudaMemcpy(d_text, text, STRING_BYTES, cudaMemcpyHostToDevice);

  calculate << < 1, elements >> > (d_text);

  cudaDeviceSynchronize();
}

#定义最大尺寸100
#定义要素20
__全局无效计算（字符*文本）{
int idx=threadIdx.x；
printf（“测试%s/n”，d_文本[idx]）；
}
int main（）{
char text[MAX_SIZE][MAX_SIZE]；//具有带单词的文本数组
字符*d_文本；
cudamaloc（（void**）和数据，数据字节）；
cudaMemcpy（d_text，text，STRING_字节，cudaMemcpyHostToDevice）；
计算>>（d_文本）；
cudaDeviceSynchronize（）；
}
在主机和设备之间移动数据时，CUDA中的多维阵列通常需要“深度复制”操作。但是，在这种情况下，我们可以利用以下事实：数组的宽度在
MAX\u SIZE
处是固定的（在编译时已知）。我们可以定义此宽度的一种类型，使2D数组处理与1D数组处理一样简单：

$ cat t426.cu
#include <stdio.h>

const char s1[] = "one\0";
const char s2[] = "two\0";
const int MAX_SIZE = 10;
typedef char carr[MAX_SIZE];

__global__ void calculate(carr *text) {
  int idx = threadIdx.x;
  printf("test %s \n", text[idx]);
}

int main() {
  char text[MAX_SIZE][MAX_SIZE]; // have text array with words
  memcpy(text[0], s1, sizeof(s1));
  memcpy(text[1], s2, sizeof(s2));
  carr *d_text;

  cudaMalloc((void **)&d_text, MAX_SIZE*MAX_SIZE);

  cudaMemcpy(d_text, text, MAX_SIZE*MAX_SIZE, cudaMemcpyHostToDevice);

  calculate << < 1, 2 >> > (d_text);

  cudaDeviceSynchronize();
}
$ nvcc -arch=sm_61 -o t426 t426.cu
$ cuda-memcheck ./t426
========= CUDA-MEMCHECK
test one
test two
========= ERROR SUMMARY: 0 errors
$

$cat t426.cu
#包括
常量字符s1[]=“一个\0”；
常量字符s2[]=“两个\0”；
const int MAX_SIZE=10；
typedef char carr[最大大小]；
__全局无效计算（carr*文本）{
int idx=threadIdx.x；
printf（“测试%s\n”，文本[idx]）；
}
int main（）{
char text[MAX_SIZE][MAX_SIZE]；//具有带单词的文本数组
memcpy（文本[0]，s1，sizeof（s1））；
memcpy（文本[1]，s2，大小为（s2））；
carr*d_文本；
Cudamaloc（（void**）和d_文本，最大尺寸*最大尺寸）；
cudaMemcpy（d_text，text，MAX_SIZE*MAX_SIZE，cudamemcpyhostodevice）；
计算>>（d_文本）；
cudaDeviceSynchronize（）；
}
$nvcc-arch=sm_61-o t426 t426.cu
$cuda memcheck./t426
==========CUDA-MEMCHECK
测试一
测试二
======错误摘要：0个错误
$

有关CUDA中2D或多维数组的更一般处理方法，请参阅。
在主机和设备之间移动数据时，CUDA中的多维数组通常需要“深度复制”操作。但是，在这种情况下，我们可以利用以下事实：数组的宽度在
MAX\u SIZE
处是固定的（在编译时已知）。我们可以定义此宽度的一种类型，使2D数组处理与1D数组处理一样简单：

$ cat t426.cu
#include <stdio.h>

const char s1[] = "one\0";
const char s2[] = "two\0";
const int MAX_SIZE = 10;
typedef char carr[MAX_SIZE];

__global__ void calculate(carr *text) {
  int idx = threadIdx.x;
  printf("test %s \n", text[idx]);
}

int main() {
  char text[MAX_SIZE][MAX_SIZE]; // have text array with words
  memcpy(text[0], s1, sizeof(s1));
  memcpy(text[1], s2, sizeof(s2));
  carr *d_text;

  cudaMalloc((void **)&d_text, MAX_SIZE*MAX_SIZE);

  cudaMemcpy(d_text, text, MAX_SIZE*MAX_SIZE, cudaMemcpyHostToDevice);

  calculate << < 1, 2 >> > (d_text);

  cudaDeviceSynchronize();
}
$ nvcc -arch=sm_61 -o t426 t426.cu
$ cuda-memcheck ./t426
========= CUDA-MEMCHECK
test one
test two
========= ERROR SUMMARY: 0 errors
$

$cat t426.cu
#包括
常量字符s1[]=“一个\0”；
常量字符s2[]=“两个\0”；
const int MAX_SIZE=10；
typedef char carr[最大大小]；
__全局无效计算（carr*文本）{
int idx=threadIdx.x；
printf（“测试%s\n”，文本[idx]）；
}
int main（）{
char text[MAX_SIZE][MAX_SIZE]；//具有带单词的文本数组
memcpy（文本[0]，s1，sizeof（s1））；
memcpy（文本[1]，s2，大小为（s2））；
carr*d_文本；
Cudamaloc（（void**）和d_文本，最大尺寸*最大尺寸）；
cudaMemcpy（d_text，text，MAX_SIZE*MAX_SIZE，cudamemcpyhostodevice）；
计算>>（d_文本）；
cudaDeviceSynchronize（）；
}
$nvcc-arch=sm_61-o t426 t426.cu
$cuda memcheck./t426
==========CUDA-MEMCHECK
测试一
测试二
======错误摘要：0个错误
$

<> P> >对于CUDA中的二维或多维数组，请参阅./P>。我认为值得指出的是，CUDA中的多维数组与C++中的工作方式相同（不令人惊讶，因为CUDA是C++家族中的编程语言），从这个角度看，没有特殊的处理。谢谢！这就是我要找的！我编辑了这个答案，以删除对“特殊”处理的引用。我认为值得指出的是，CUDA中的多维数组工作与C++中的相同，这一点并不令人惊讶（因为CUDA是C++家族中的编程语言），从这个角度看，没有特殊的处理。谢谢！这就是我要找的！我编辑了答案，删除了对“特殊”处理的引用。