Mexcuda mit Haltepunkt bei delete []() in .cu-Datei

Question

Ich habe einige Probleme bei der Suche nach dem Fehler, den ich mit meiner Speicherzuweisung gemacht habe. Ich benutze derzeit Visual Studio 2013, Matlab 2015b und CUDA 7.0 auf einer GeForce GT 630 und ich bin ein ziemlich Neuling für GPU-Programmierung, CUDA und Mex.

Wenn ich meinen Code von Matlab mit mexcuda rufe geht es gut, bis ich den kleinen Teil mit colIndexStepSize der .cu-Datei hinzufügen. Das Programm läuft normal bis zum Löschen. Nachdem ich darüber informiert wurde, dass ich hier einen Haltepunkt erreicht habe, stürzt Matlab ab.

Wenn ich die betreffenden Codezeilen entferne, läuft alles wieder reibungslos.

Ich bin mir ziemlich sicher, dass etwas mit meiner Speicherbehandlung nicht stimmt, aber ich kann den Fehler einfach nicht finden. Hier ist der Code, der Probleme macht:

#include <cuda_runtime.h> 
#include <cuda.h> 
#include <cusparse.h> 
#include <device_launch_parameters.h> 
#include <curand.h> 

#include <vector> 

// Test-Makro : (Funktionieren die Zugriffe auf die GPU?) 
#define gpuErrchk(ans){gpuAssert((ans), __FILE__, __LINE__);} 

inline void gpuAssert(cudaError_t code, const char *file, int line, bool abort = true){ 
    if (code != cudaSuccess){ 
     fprintf(stderr, "GPUassert: %s%s%d\n", cudaGetErrorString(code), file, line); 
    } 
} 


__global__ void startEndIndex(int *ergArray, int *first, int *last, float *dxmax, unsigned int *length){ 

    unsigned int index = threadIdx.x + blockIdx.x*blockDim.x; 

    if (index < *length){ 

     first[index] = (*dxmax)*ergArray[index]; 
     last[index] = (*dxmax)*ergArray[index + 1] - 1; 
    } 
} 



void rotateOSSARTrechnung(std::vector<float> *detektor, SparseMatrix<float, float, float> *systemMatrix_coo, Volumen<float, float, float> *volumen, unsigned int iterationen, std::vector<float> *deltaBIterationN, std::vector<float> *matdVoxelGrid, float projektionen,float dxmax, float detZellen, unsigned int threads_max_n, unsigned int threads_max_m, unsigned int threads_max_nnz){ 

unsigned int nnz = (unsigned int)systemMatrix_coo->nnz; 
unsigned int n = (unsigned int)systemMatrix_coo->columnNumber; 
unsigned int mNeu = detZellen; 

float *measuredValues = 0; measuredValues = new float[mNeu](); 

float *volumeN = 0; volumeN =new float[n](); 
float *volumeAlt = 0; volumeAlt = new float[n](); 

float *initValuesM = 0; initValuesM = new float[mNeu](); 

float *volumeNInitZero = 0; volumeNInitZero = new float[n](); 
float *initValuesMInitZero = 0; initValuesMInitZero = new float[mNeu](); 
int *cooRowHostPtr=0; cooRowHostPtr = new int[nnz](); 
int *cooColHostPtr=0; cooColHostPtr = new int[nnz](); 
float *cooValuesHostPtr = 0; cooValuesHostPtr = new float[nnz](); 

unsigned int *colIndex = 0; colIndex = new unsigned int[nnz](); 
float *valIndex = 0; valIndex = new float[nnz](); 
unsigned int *colIndexStepSize = 0; colIndexStepSize = new unsigned int[n](); 

for (unsigned int i = 0; i < n; i++){ 
    colIndexStepSize[i] = nnz; 
} 

unsigned int length = matdVoxelGrid->size(); 
int *ergArray = 0; ergArray = new int[length+1](); 

int *first = 0; first = new int[length](); 
int *last = 0; last = new int[length](); 

int *cooHostColRot = 0; cooHostColRot = new int[nnz](); 


int *d_cooColPtr; 
int *d_cooRowPtr; 
unsigned int *d_nnz; 

int *d_colIndexPtr; 
float *d_valIndexPtr; 
unsigned int *d_colIndexStepSizePtr; 

float *d_cooValuesPtr; 
float *d_measuredValues; 

float *d_volume_alt; 
float *d_volume_neu; 

int *d_ergArray; 

float *d_dxmax; 
unsigned int *d_length; 
unsigned int *d_size; 

int *d_first; 
int *d_last; 

int *d_cooColRotPtr; 

unsigned int *d_count; 

gpuErrchk(cudaMalloc((void**)&d_cooRowPtr, nnz*sizeof(int)));; 
gpuErrchk(cudaMalloc((void**)&d_cooColPtr, nnz*sizeof(int))); 
gpuErrchk(cudaMalloc((void**)&d_cooValuesPtr, nnz*sizeof(float))); 

gpuErrchk(cudaMalloc((void**)&d_measuredValues, mNeu*sizeof(float))); 
gpuErrchk(cudaMalloc((void**)&d_volume_alt, n*sizeof(float))); 
gpuErrchk(cudaMalloc((void**)&d_volume_neu, n*sizeof(float))); 

gpuErrchk(cudaMalloc((void**)&d_nnz, sizeof(unsigned int))); 

gpuErrchk(cudaMalloc((void**)&d_colIndexPtr, (nnz)*sizeof(int))); 
gpuErrchk(cudaMalloc((void**)&d_valIndexPtr, (nnz)*sizeof(float))); 
gpuErrchk(cudaMalloc((void**)&d_colIndexStepSizePtr, n*sizeof(unsigned int))); 

gpuErrchk(cudaMalloc((void**)&d_ergArray, (length+1)*sizeof(int))); 

gpuErrchk(cudaMalloc((void**)&d_dxmax, sizeof(float))); 
gpuErrchk(cudaMalloc((void**)&d_length, sizeof(unsigned int))); 
gpuErrchk(cudaMalloc((void**)&d_size, sizeof(unsigned int))); 

gpuErrchk(cudaMalloc((void**)&d_first, length*sizeof(int))); 
gpuErrchk(cudaMalloc((void**)&d_last, length*sizeof(int))); 

gpuErrchk(cudaMalloc((void**)&d_cooColRotPtr, nnz*sizeof(int))); 

gpuErrchk(cudaMalloc((void**)&d_count, sizeof(unsigned int))); 

for (unsigned int i = 0; i < nnz; i++){ 
    cooRowHostPtr[i] = systemMatrix_coo->cooRowInd->at(i); 
    cooColHostPtr[i] = systemMatrix_coo->cooColInd->at(i); 
    cooValuesHostPtr[i] = systemMatrix_coo->cooValues->at(i); 
} 

for (unsigned int j = 0; j < n; j++){ 
    volumen->setValueAtElement(j, (float)cooColHostPtr[j]); 
} 

gpuErrchk(cudaMemcpy(d_nnz, &nnz, sizeof(unsigned int), cudaMemcpyHostToDevice)); 

gpuErrchk(cudaMemcpy(d_dxmax, &dxmax, sizeof(float), cudaMemcpyHostToDevice)); 
gpuErrchk(cudaMemcpy(d_length, &length, sizeof(unsigned int), cudaMemcpyHostToDevice)); 

// (Initialwerte sind immer gleich) 
gpuErrchk(cudaMemcpy(d_cooRowPtr, cooRowHostPtr, nnz*sizeof(int), cudaMemcpyHostToDevice)); 
gpuErrchk(cudaMemcpy(d_cooValuesPtr, cooValuesHostPtr, nnz*sizeof(float), cudaMemcpyHostToDevice)); 
gpuErrchk(cudaMemcpy(d_cooColPtr, cooColHostPtr, nnz*sizeof(int), cudaMemcpyHostToDevice)); 

gpuErrchk(cudaMemcpy(d_valIndexPtr, cooValuesHostPtr, nnz*sizeof(float), cudaMemcpyHostToDevice)); 

unsigned int threads_nnz = threads_max_nnz; 

unsigned int thread_length = length; 
unsigned int block_length = 1; 

unsigned int index = 0; 

for (unsigned int s = 0; s < length; s++){ 
    for (unsigned int t = 0; t <= s; t++){ 
     index = s + 1; 
     ergArray[index] += (int)matdVoxelGrid->at(t); 
    } 
} 

gpuErrchk(cudaMemcpy(d_ergArray, ergArray, (length+1)*sizeof(int), cudaMemcpyHostToDevice)); 

startEndIndex <<< block_length, thread_length >>>(d_ergArray, d_first, d_last, d_dxmax, d_length); 

gpuErrchk(cudaMemcpy(first, d_first, length*sizeof(int), cudaMemcpyDeviceToHost)); 
gpuErrchk(cudaMemcpy(last, d_last, length*sizeof(int), cudaMemcpyDeviceToHost)); 

for (unsigned int j = 0; j < length; j++){ 
    volumen->setValueAtElement(j, (float)first[j]); 
} 


for (unsigned int j = 0; j < length; j++){ 
    volumen->setValueAtElement(j, (float)last[j]); 
} 


unsigned int size = 0; 

for (unsigned int iter = 0; iter < iterationen; iter++){ 
    for (unsigned int proj = 1; proj <= projektionen; proj++){ 

     unsigned int begin1 = (proj - 1)*mNeu; 
     unsigned int end1 = proj*mNeu; 

     for (unsigned int j = begin1; j < end1; j++){ 
      measuredValues[j] = detektor->at(j); 
     } 

     gpuErrchk(cudaMemcpy(d_measuredValues, measuredValues, mNeu*sizeof(float), cudaMemcpyHostToDevice)); 

     for (unsigned int u = 0; u < length; u++){ 
      size = ceil(matdVoxelGrid->at(u)* (proj - 1) * dxmax/projektionen); 
      gpuErrchk(cudaMemcpy(d_size, &size, sizeof(unsigned int), cudaMemcpyHostToDevice)); 

      gpuErrchk(cudaMemcpy(d_count, &u, sizeof(unsigned int), cudaMemcpyHostToDevice)); 

      if (proj > 1){ 

       for (unsigned int i = 0; i < nnz; i++) {//(first[u] <= cooCols[index] <= last[u]){ 

        if (first[u] <= cooColHostPtr[i] && cooColHostPtr[i] <= last[u]){ 
         cooHostColRot[i] = first[u] + (int)(cooColHostPtr[i] + size) % (last[u] - first[u] + 1);// (int)(cooColHostPtr[i] + size) % (last[u]); // (int)(first[u] + ((int)(cooColHostPtr[i] + dxmax) % (last[u] - first[u] + 1))); 
        } 
       } 
      } 
      else{ 
       for (unsigned int i = 0; i < nnz; i++) { 
        cooHostColRot[i] = cooColHostPtr[i]; 
       } 
      } 
     } 


// --------- troubling code starts HERE ---------------- 
     unsigned int wert = 0, index = 0; 
     for (unsigned int i = 0; i < nnz; i++){ 
      index = cooHostColRot[i]; 
      wert = colIndexStepSize[index]; 

      if (wert >= i){ 
       colIndexStepSize[index] = i; 
      } 
     } 

     for (unsigned int j = 0; j < n; j++){ 
      volumen->setValueAtElement(j, colIndexStepSize[j]); 
     } 

      gpuErrchk(cudaMemcpy(d_colIndexStepSizePtr, colIndexStepSize, n*sizeof(unsigned int), cudaMemcpyHostToDevice)); 

    // --------- troubling code ends HERE ---------------- 

      gpuErrchk(cudaMemcpy(d_colIndexPtr, cooHostColRot, nnz*sizeof(int), cudaMemcpyHostToDevice)); 


     } 
    } 


    cudaFree(d_cooRowPtr); 
    cudaFree(d_cooColPtr); 
    cudaFree(d_cooValuesPtr); 
    cudaFree(d_measuredValues); 
    cudaFree(d_volume_alt); 
    cudaFree(d_volume_neu); 
    cudaFree(d_colCount); 
    cudaFree(d_rowCount); 
    cudaFree(d_ergSumCol); 
    cudaFree(d_ergSumRow); 
    cudaFree(d_ergMult); 
    cudaFree(d_nnz); 
    cudaFree(d_faktor); 
    cudaFree(d_colIndexPtr); 
    cudaFree(d_valIndexPtr); 
    cudaFree(d_ergSumNNZforCol); 
    cudaFree(d_colIndexStepSizePtr); 
    cudaFree(d_deltaB); 

    cudaFree(d_ergArray); 
    cudaFree(d_dxmax); 
    cudaFree(d_length); 
    cudaFree(d_size); 
    cudaFree(d_first); 
    cudaFree(d_last); 
    cudaFree(d_cooColRotPtr); 
    cudaFree(d_count); 

    delete[](ergArray); ergArray = NULL; 
    delete[](measuredValues); measuredValues = NULL; 
    delete[](cooColHostPtr); cooColHostPtr = NULL; 
    delete[](cooRowHostPtr); cooRowHostPtr = NULL; 
    delete[](cooValuesHostPtr); cooValuesHostPtr = NULL; 
    delete[](volumeN); volumeN = NULL; 
    delete[](ergArray); ergArray = NULL; 
    delete[](initValuesM); initValuesM = NULL; 
    delete[](colIndex); colIndex = NULL; 
    delete[](valIndex); valIndex = NULL; 
    delete[](volumeAlt); volumeAlt = NULL; 
    delete[](volumeNInitZero); volumeNInitZero = NULL; 
    delete[](initValuesMInitZero); initValuesMInitZero = NULL; 
    delete[](colIndexStepSize); colIndexStepSize = NULL; 
    delete[](deltaBArray); deltaBArray = NULL; 

    delete[](first); first = NULL; 
    delete[](last); last = NULL; 

    delete[](cooHostColRot); cooHostColRot = NULL; 

    deltaB->~vector(); 
    deltaB = NULL; 

}

Wenn jemand einen Fehler sehe ich gemacht, bitte sagen Sie mir, ich bin offen für jede Beratung.

Vielen Dank im Voraus! Mit freundlichen Grüßen

EDIT: @AnderBiguri richtig war, habe ich eine außerhalb der Grenzen Zugriff auf das Array aus Meßwerte. Hier ist die korrigierte Teil des Codes in Frage:

 for (unsigned int j = 0; j < mNeu; j++){ 
      measuredValues[j] = detektor->at((proj-1)*mNeu+j); 
     } 

Meßwerte ist nur Mneu Elemente lang, aber ich habe Zugang einige Elemente Weg hinter diesem Punkt.

Also, vielen Dank für die Hilfe!

Answer 1

@AnderBiguri hatte Recht, ich machte einen unzulässigen Zugriff auf das Array measuredValues. Hier ist der korrigierte Teil des Codes in Frage:

for (unsigned int j = 0; j < mNeu; j++){ 
     measuredValues[j] = detektor->at((proj-1)*mNeu+j); 
    } 

musste ich nur die Grenzen des für die Schleife und Vektor einzustellen Zugriff auf die Grenzen des Arrays passen.

Nochmals vielen Dank!