Uso de cudamalloc(). ¿Por qué el doble puntero?

Esto es simplemente un horrible, horrible diseño de API. El problema con el paso de punteros dobles para una función de asignación que obtiene memoria abstracta (void *) es que tiene que hacer una variable temporal de tipo void * para mantener el resultado, luego asignarlo al puntero real del tipo correcto que desea usar. El casting, como en (void**)&device_array, no es válido C y resulta en un comportamiento indefinido. Simplemente debe escribir una función de envoltura que se comporta como normal malloc y devuelve un puntero, como en:

void *fixed_cudaMalloc(size_t len)
{
    void *p;
    if (cudaMalloc(&p, len) == success_code) return p;
    return 0;
}

Lo lanzamos en doble puntero porque es un puntero al puntero. Tiene que apuntar a un puntero de memoria GPU. Lo que hace cudaMalloc () es que asigna un puntero de memoria (con espacio) en la GPU que luego es apuntado por el primer argumento que damos.

El problema: debe devolver dos valores: Devolver código y puntero a la memoria (en caso de que el código de retorno indique éxito). Por lo tanto, debe hacer que uno de ellos sea un puntero para devolver el tipo. Y como el tipo de retorno tiene la opción entre puntero de retorno a int (para el código de error) o puntero de retorno a puntero (para la dirección de memoria). Allí una solución es tan buena como la otra (y una de ellas produce el puntero a puntero (prefiero usar este término en lugar de double pointer , ya que esto suena más como un puntero a un número de coma flotante doble)).

En malloc tiene la propiedad nice que puede tener punteros nulos para indicar un error, por lo que básicamente necesita solo un valor devuelto.. No estoy seguro de si esto es posible con un puntero a la memoria del dispositivo, ya que podría ser que no hay o un valor nulo incorrecto (recuerde: Esto es CUDA y NO Ansi C). Podría ser que el puntero null en el sistema host es completamente diferente del null utilizado para el dispositivo, y como tal, el retorno de puntero nulo para indicar errores no funciona, y debe hacer la API de esta manera (eso también significaría que no tiene NULL común en ambos dispositivos).

En C/C++, puede asignar un bloque de memoria dinámicamente en tiempo de ejecución llamando a la función malloc.

int * h_array
h_array = malloc(sizeof(int))

La función malloc devuelve la dirección del bloque de memoria asignado que se puede almacenar en una variable de algún tipo de puntero.
La asignación de memoria en CUDA es un poco diferente de dos maneras,

1. El cudamalloc devuelve un entero como código de error en lugar de un puntero al bloque de memoria.

2. Además del tamaño de byte a ser asignado, cudamalloc también requiere un puntero de doble vacío como su primer parámetro.

   Int * d_array cudamalloc ((void **) &d_array, sizeof (int))

La razón detrás de la primera diferencia es que toda la función CUDA API sigue la convención de devolver un código de error entero. Así que para hacer las cosas consistentes, cudamalloc API también devuelve un entero.

Hay requisitos para un puntero doble como el primer argumento de la función que se pueden entender en dos pasos.

En primer lugar, desde ya hemos decidido hacer que el cudamalloc devuelva un valor entero, ya no podemos usarlo para devolver la dirección de la memoria asignada. En C, la única otra forma para que una función se comunique es pasando el puntero o la dirección a la función. La función puede realizar cambios en el valor almacenado en la dirección o la dirección donde apunta el puntero. Los cambios a esos valores se pueden recuperar más tarde fuera del ámbito de la función utilizando la misma dirección de memoria.

Cómo el trabajos de doble puntero

El siguiente diagrama ilustra cómo funciona con el doble puntero.

int cudamalloc((void **) &d_array, int type_size) {
  *d_array = malloc(type_size)
  return return_code
}

¿por Qué necesitamos el doble puntero? Por qué esto funciona

Normalmente vivo en el mundo de python, así que también luché para entender por qué esto no funcionará.

int cudamalloc((void *) d_array, int type_size) {
  d_array = malloc(type_size)
  ...
  return error_status
}

Entonces, ¿por qué no funciona? Porque en C, cuando se llama cudamalloc, se crea una variable local llamada d_array y se asigna con el valor de la primera función argumento. No hay manera de que podamos recuperar el valor en esa variable local fuera del ámbito de la función. Por eso necesitamos un puntero a un puntero aquí.

int cudamalloc((void *) d_array, int type_size) {
  *d_array = malloc(type_size)
  ...
  return return_code
}