Quelconque échec de lancement sur Memcpy
Je rencontre un "quelconque échec de lancement" lors de l'exécution de mon programme en Cuda .
J'ai vérifié les erreurs .
Le programme est un solveur d'équation différentielle . Il itère TOTAL_ITER fois .
ROOM_X sna ROOM_Y sont la largeur et la hauteur de la matrices .
Voici l'en-tête, son nom est "unique :
#define ITER_BETWEEN_SAVES 10000
#define TOTAL_ITER 10000
#define ROOM_X 2048
#define ROOM_Y 2048
#define SOURCE_DIM_X 200
#define SOURCE_DIM_Y 1000
#define ALPHA 1.11e-4
#define DELTA_T 10
#define H 0.1
#include <stdio.h>
void Matrix(float* M);
void SolverCPU(float* M1, float* M2);
__global__ void SolverGPU(float* M1, float* M2);
Ici est le noyau et une fonction de remplissage d'une matrice :
#include "solver.h"
#include<cuda.h>
void Matrix(float* M)
{
for (int j = 0; j < SOURCE_DIM_Y; ++j) {
for (int i = 0; i < SOURCE_DIM_X; ++i) {
M[(i+(ROOM_X/2 - SOURCE_DIM_X/2)) + ROOM_X * (j+(ROOM_Y/2 - SOURCE_DIM_Y/2))] = 100;
}
}
}
__global__ void SolverGPU(float* M1,float *M2) {
int i =threadIdx.x + blockIdx.x * blockDim.x;
int j = threadIdx.y + blockIdx.y * blockDim.y;
float M1_Index = M1[i + ROOM_X * j];
float M1_IndexUp = M1[i+1 + ROOM_X * j];
float M1_IndexDown =M1[i-1 + ROOM_X * j];
float M1_IndexLeft = M1[i + ROOM_X * (j+1)];
float M1_IndexRight = M1[i + ROOM_X *(j-1)];
M2[i + ROOM_X * j] = M1_Index + (ALPHA * DELTA_T / (H*H)) * (M1_IndexUp + M1_IndexDown + M1_IndexLeft +M1_IndexRight - 4*M1_Index);
}
Et voici le principal
int main(int argc, char* argv[] ){
float *M1_h, *M1_d,*M2_h, *M2_d;
int size = ROOM_X * ROOM_Y * sizeof(float);
cudaError_t err = cudaSuccess;
//Allocating Memories on Host
M1_h = (float *)malloc(size);
M2_h = (float *)malloc(size);
//Allocating Memories on Host
err=cudaMalloc((void**)&M1_d, size);
if (err != cudaSuccess) {
fprintf(stderr, "Failed to allocate array_d ... %s .\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
err=cudaMalloc((void**)&M2_d, size);
if (err != cudaSuccess) {
fprintf(stderr, "Failed to allocate array_d ... %s .\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
//Filling the Matrix
Matrix(M1_h);
//Copy on Device
err = cudaMemcpy(M1_d, M1_h, size, cudaMemcpyHostToDevice);
if(err !=0){
printf("%s-%d\n",cudaGetErrorString(err),1);
getchar();
}
err=cudaMemcpy(M2_d, M2_h, size, cudaMemcpyHostToDevice);
if(err !=0){
printf("%s-%d",cudaGetErrorString(err),2);
getchar();
}
dim3 dimGrid(64,64);
dim3 dimBlock(32,32);
//SolverGPU<< <threadsPerBlock, numBlocks >> >(M1_d,M2_d);
for(int i=0;i<TOTAL_ITER;i++) {
if (i%2==0)
SolverGPU<< <dimGrid,dimBlock >> >(M1_d,M2_d);
else
SolverGPU<< <dimGrid,dimBlock >> >(M2_d,M1_d);
}
err=cudaMemcpy(M1_h, M1_d, size, cudaMemcpyDeviceToHost);
if(err !=0){
printf("%s-%d",cudaGetErrorString(err),3);
getchar();
}
cudaFree(M1_d);
cudaFree(M2_d);
free(M1_h);
free(M2_h);
return 0;
}
Il n'y a pas de problème à la compilation .
Whne j'ai vérifier mes erreurs, le "non spécifié lancer échec" s'affiche sur le memcpy APRÈS le noyau .
Ok, donc, j'ai lu que c'est en général parce que le noyau de ce qui ne fonctionne pas correctement . Mais je ne peux pas trouver l'erreur (s) dans le noyau ... je suppose que l'erreur est assez simple , mais ne peut pas trouver à trouver .
- Un "pourquoi n'est-il pas de travail" de la question avec uncompilable code est une complète perte de temps pour tout le monde. Voter à proximité.
- merci pour votre aimable réponse ! 🙂 En effet j'ai oublié de mettre une fonction pour supprimer quelques lignes de code . Vraiment désolé pour cela . J'ai édité mon post . J'espère qu'il va compiler maintenant .
- Comment aurait-il quelqu'un capable de le compiler sans savoir ce
ROOM_X
est, par exemple? DONC attend un MCVE. Il devrait être un code complet. Si vous voulez tester si vous avez écrit correctement à la question, démarrer un nouveau projet vide, et copiez le code de la question que vous avez posté, sans rien ajouter ou changer quoi que ce soit (qui est, après tout, ce que les autres vont faire). Ensuite, voyez si vous pouvez le compiler. Si vous ne pouvez pas, votre question/MCVE est incomplète. - Je l'ai fait . Merci pour l'explication . Je suppose que je pourrais avoir trouvé par moi-même, je suppose que je suis un peu fatigué .x) Maintenant, ce code doit compiler .
Vous devez vous connecter pour publier un commentaire.
Quand j'ai compiler et d'exécuter le code, j'obtiens:
imprimé.
Vous pouvez en effet obtenir "quelconque échec de lancement" à la place. L'erreur exacte des rapports dépendra de la version CUDA, du GPU et de la plate-forme. Mais nous pouvons aller de l'avant peu importe.
Ce message indique que le noyau lancé mais a rencontré une erreur, et n'ont donc pas à se terminer avec succès. Vous pouvez déboguer le noyau problèmes d'exécution à l'aide d'un débogueur, comme cuda-gdb sur linux, ou Nsight VSE sur windows. Mais nous n'avons pas besoin de sortir le débogueur pour l'instant.
Un outil utile est
cuda-memcheck
. Si nous exécuter votre programme aveccuda-memcheck
, nous avons un peu plus de sortie qui indique que le noyau global non valides lit de taille 4. Cela signifie que vous faites un hors-limites d'accès à la mémoire. Nous pouvons obtenir plus de clarté si nous recompiler votre code en ajoutant le-lineinfo
commutateur (ou alternativement avec-G
), puis exécutez de nouveau votre code aveccuda-memcheck
. Maintenant, nous obtenons en sortie qui ressemble à ceci:(et il y a beaucoup plus d'erreur de sortie)
Cela signifie que la première erreur rencontrée par votre noyau a été une défaillance globale de lire de taille 4 (c'est en dehors des limites de l'accès d'essayer de lire un
int
oufloat
la quantité, par exemple). Avec le lineinfo de l'information, nous pouvons voir que cela s'est produit:c'est à dire à la ligne 34 dans le fichier. Cette ligne se trouve être cette ligne de code du noyau:
nous pourrions debug de plus, peut-être à l'aide dans le noyau
printf
déclarations de découvrir où est le problème. Mais nous avons déjà une idée de ce que nous sommes indexation hors des limites du terrain, donc, nous allons inspecter l'indexation:quelles ne de cette évaluation à quand
i
=0 etj
=0 (c'est à dire. pour le thread (0,0) dans votre 2D thread tableau)? Il renvoie à 2048 (c-à -ROOM_X
) qui est illégale d'un index. Essayer de lire à partir deM1[-2048]
créera une faute.Vous avez beaucoup de complexes d'indexation se passe dans votre noyau, donc je suis assez sûr qu'il y a d'autres erreurs ainsi. Vous pouvez utiliser une méthode similaire à suivre ceux qui sont en bas (peut-être en utilisant
printf
à cracher le calcul des indices, ou bien tester les indices de validité).