utiliser free pour l’hôte entraîne une erreur de segmentation

J’ai un fichier cu avec le kernel comme:

__global__ void kernel(float* A,float *B, curandState* globalState,int Asize,int Bsize) { .... } void kernel_wrapper(float** A_host,float** B_host, int Asize ,int Bsize) { ... //allocate host memory *A_host=(float*)malloc(Asize*sizeof(float)); *B_host=(float*)malloc(Bsize*sizeof(float)); //allocate device memory float* A_dev,*B_dev; gpuErrchk(cudaMalloc((void**) &A_dev,Asize* sizeof(float))); gpuErrchk(cudaMalloc((void**) &B_dev,Bsize* sizeof(float))); // copy arrays from host to device gpuErrchk(cudaMemcpy(A_dev, *A_host,Asize* sizeof(float), cudaMemcpyHostToDevice)); gpuErrchk(cudaMemcpy(B_dev, *B_host,Bsize* sizeof(float), cudaMemcpyHostToDevice)); .... kernel<<>>(A_dev,B_dev, devStates,Asize,Bsize); // copy result from device to host gpuErrchk(cudaMemcpy(*A_host, A_dev,Asize* sizeof(float), cudaMemcpyDeviceToHost)); gpuErrchk(cudaMemcpy(*B_host, B_dev,Bsize* sizeof(float), cudaMemcpyDeviceToHost)); //clean up device memory gpuErrchk(cudaFree(A_dev)); gpuErrchk(cudaFree(B_dev)); gpuErrchk(cudaFree(devStates)); //clean up host memory free(*A_host); free(*B_host); } 

et un fichier cpp à partir duquel j’appelle le kernel:

 ... extern void kernel_wrapper(float** A,float** B, int Asize ,int Bsize); ... int main() { ... float* A; float* B; ... kernel_wrapper(&A,&B,Asize ,Bsize); ... free(A); free(B); 

Maintenant, en utilisant le

 free(*A_host); free(*B_host); 

dans le fichier cu résultats dans

Faute de segmentation

Si j’utilise cudaFree ou cudaFreeHost (qui ne sont pas corrects parce que j’alloue avec alloc), il indique “pointeur de périphérique non valide” ou “argument invalide”.

Si je n’utilise pas du tout gratuitement, le programme fonctionne bien.

Pourquoi est-ce et quel est le processus approprié concernant ces allocations de mémoire?

Vous appelez free() deux fois sur les mêmes pointeurs, ce n’est pas valide. La gestion de la mémoire dans ce code est étrange et déroutante.

Je suppose qu’il est plus logique de supprimer les appels kernel_wrapper() fonction kernel_wrapper() ; comme il est configuré pour renvoyer les pointeurs à l’appelant, cela n’a aucun sens de free() la mémoire de la fonction.