Komunikat o błędzie CUDA: nieokreślona awaria uruchamiania

Question

To jest część mojego kodu CUDA. Ale ostatnia część tego kodu mówi jakiś komunikat o błędzie.

unsigned int *mat_count; 
off_t *mat_position; 
unsigned int *matches_count; 
off_t *matches_position; 
...... 
cudaMalloc ((void **) &mat_count, sizeof(unsigned int)*10); 
cudaMalloc ((void **) &mat_position, sizeof(off_t)*10); 
...... 
matches_count = (unsigned int *)malloc(sizeof(unsigned int)*10); 
matches_position = (off_t *)malloc(sizeof(off_t)*10); 
for (i = 0 ; i < 10 ; i++) { 
    matches_count [i] = 0; 
    matches_position[i] = 0; 
} 
...... 
cudaMemcpy (mat_count, matches_count , sizeof(unsigned int)*10, cudaMemcpyHostToDevice); 
cudaMemcpy (mat_position, matches_position, sizeof(off_t)*10,  cudaMemcpyHostToDevice); 
...... 
match<<<BLK_SIZE,THR_SIZE>>>(
     reference_total, 
     indextable_total, 
     sequences, 
     start_sequence, 
     sequence_length, 
     end_sequence, 
     ref_base, 
     idx_base, 
     msk_base, 
     mat_count, 
     mat_position, 
     reference, 
     first_indexes, 
     seqmaskc 
     ); 
err=cudaGetLastError(); 
if(err!=cudaSuccess) 
{ 
printf("\n1 %s\n", cudaGetErrorString(err)); 
} 
err= cudaMemcpy (matches_count , mat_count, sizeof(unsigned int)*10, cudaMemcpyDeviceToHost); 
if(err!=cudaSuccess) 
{ 
printf("\n2 %s\n", cudaGetErrorString(err)); 
} 
err= cudaMemcpy (matches_position, mat_position, sizeof(off_t)*10, cudaMemcpyDeviceToHost); 
if(err!=cudaSuccess) 
{ 
printf("\n3 %s\n", cudaGetErrorString(err)); 
} 

Następująca część kodu zgłosiła komunikat o błędzie "nieokreślony błąd uruchomienia". Nie wiem, dlaczego ten komunikat o błędzie jest zgłaszany.

err=cudaMemcpy (matches_position, mat_position, sizeof(off_t)*10, cudaMemcpyDeviceToHost); 
if(err!=cudaSuccess) 
{ 
printf("\n3 %s\n", cudaGetErrorString(err)); 
} 

Poniższe elementy są częścią funkcji dopasowania.

__global__ void match(...) 
{ 
    ...... 
reference_blk = (THR_SIZE * blockIdx.x + threadIdx.x) * 32 + reference; 
...... 
//-- added for parallize --// 
for (p = start_p ; p != last_p ; p++) { 
    for (s = start_sequence, sequence = sequences ; s != end_sequence ; 
      s++, sequence += sequence_bytes) { 
     ref_off = *(((unsigned int*)(idx_base)) + p); 

     shifted_in = 0; 

     if((int)(first_indexes[s-start_sequence] % 8 - ref_off % 8) < 0){ 
      int shamt2 = (ref_off % 8 - first_indexes[s-start_sequence] % 8); 

      mask_buffer = *((unsigned long *)(msk_base + (ref_off - first_indexes[s-start_sequence])/8)) >> shamt2; 

      if(((*(unsigned long *)(seqmaskc + 16 * (s-start_sequence)))^mask_buffer) << shamt2) continue; 
     } 
     else if((int)(first_indexes[s-start_sequence] % 8 - ref_off % 8) == 0){ 
      mask_buffer = *((unsigned long *)(msk_base + (ref_off)/8)); 

      if((*(unsigned long *)(seqmaskc + 16 * (s-start_sequence))^mask_buffer)) continue; 
     } 
     else{ 
      int shamt2 = 8 - (first_indexes[s-start_sequence] % 8 - ref_off % 8); 

      mask_buffer = *((unsigned long *)(msk_base + (ref_off/8- first_indexes[s-start_sequence]/8) - 1)) >> shamt2; 

      if(((*(unsigned long *)(seqmaskc + 16 * (s-start_sequence)))^mask_buffer) << shamt2) continue; 
     } 

     //full compare 
     if((int)(first_indexes[s-start_sequence] % 4 - ref_off % 4) < 0){ 
      int shamt = (ref_off % 4 - first_indexes[s-start_sequence] % 4) * 2; 
      memcpy(reference_blk, ref_base + ref_off/4 - first_indexes[s-start_sequence]/4, sequence_bytes); 
      ...... 
      //-- instead of memcmp --// 
      int v = 0; 
      char *p1 = (char *)sequence; 
      char *p2 = (char *)reference_blk; 
      int tmp_asd = sequence_bytes; 
      while(tmp_asd!=0){ 
       v = *(p1++) - *(p2++); 
       if(v!=0) 
        break; 
       tmp_asd--; 
      } 

      if(v == 0){ 
       mat_count[s - (int)start_sequence]++;  /* Maintain count */ 
       mat_position[s - (int)start_sequence] = ref_off-first_indexes[s-start_sequence]; /* Record latest position */ 
      } 
     } 
     else if((int)(first_indexes[s-start_sequence] % 4 - ref_off % 4)== 0){ 
      memcpy(reference_blk, ref_base + ref_off/4 - first_indexes[s-start_sequence]/4, sequence_bytes); 
      ....... 
      //-- instead of memcmp --// 
      int v = 0; 
      char *p1 = (char *)sequence; 
      char *p2 = (char *)reference_blk; 
      int tmp_asd = sequence_bytes; 
      while(tmp_asd!=0){ 
       v = *(p1++) - *(p2++); 
       if(v!=0) 
        break; 
       tmp_asd--; 
      } 
      if(v == 0){ 
       mat_count[s - (int)start_sequence]++;  /* Maintain count */ 
       mat_position[s - (int)start_sequence] = ref_off-first_indexes[s-start_sequence]; /* Record latest position */ 
      } 
     } 
     else 
     { 
      int shamt = 8 - (first_indexes[s-start_sequence] % 4 - ref_off % 4) * 2; 

      memcpy(reference_blk, ref_base + ref_off/4 - first_indexes[s-start_sequence]/4 - 1, 32); 
      ...... 
      //-- instead of memcmp --// 
      int v = 0; 
      char *p1 = (char *)sequence; 
      char *p2 = (char *)reference_blk; 
      int tmp_asd = sequence_bytes; 
      while(tmp_asd!=0){ 
       v = *(p1++) - *(p2++); 
       if(v!=0) 
        break; 
       tmp_asd--; 
      } 

      if (v == 0){ 
       mat_count[s - (int)start_sequence]++;  /* Maintain count */ 
       mat_position[s - (int)start_sequence] = ref_off-first_indexes[s-start_sequence];/* Record latest position */ 
      } 
     } 
    } 
} 

}

Answer 1

nieokreślony awaria uruchomienie jest prawie zawsze segfault. Masz błąd indeksowania gdzieś w jądrze, prawdopodobnie podczas uzyskiwania dostępu do pamięci globalnej.

bym przejrzeć kodzie, ale łagodnie niezrozumiałe ...

Answer 2

Kompilacja aplikacji z flagami debugowania nvcc -G -g i spróbuj uruchomić aplikację wewnątrz cuda-memcheck lub cuda-gdb. To może dać ci wskazówkę, gdzie może leżeć problem.

Wystarczy uruchomić

cuda-memcheck ./yourApp