Fehler: ein unzulässiger Speicherzugriff wurde

Question

Ich hatte Zweifel error: calling a __host__ function from a __global__ function is not allowed angetroffen und ich bekam die ans. dementsprechend habe ich meinen Code geändert bt ich kann nicht auf d_point [i] zugreifen. wie kann ich darauf zugreifen?

__global__ void densefun(int *d_counters,float2 *d_points,int d_x_max,int d_y_max,int width,int height, int min_distance,int size) 
{ 
    int i = blockDim.x * blockIdx.x + threadIdx.x; 

    if(i <= size) 
    { 
     float2 point = (d_points)[i]; 
     int x = floorf(point.x); 
     int y = floorf(point.y); 
     printf(" (%d %d)",x,y); 
     if(x < d_x_max && y < d_y_max) 
     { 
      x /= min_distance; 
      y /= min_distance; 
      (d_counters)[y*width+x]++; 
      __syncthreads(); 
     } 
    } 
} 


void DenseSample(const Mat& grey, std::vector<Point2f>& points, const double quality, const int min_distance) 
{ 
    int width = grey.cols/min_distance; 
    int height = grey.rows/min_distance; 
    Mat eig; 
    cornerMinEigenVal(grey, eig, 3, 3); 
    double maxVal = 0; 
    minMaxLoc(eig, 0, &maxVal); 
    const double threshold = maxVal*quality; 
    std::vector<int> counters(width*height); 
    int x_max = min_distance*width; 
    int y_max = min_distance*height; 
    printf("in descriptor size:%ld ",points.size()); 
    int *d_counters; 
    float2 *d_points; 
    cudaMalloc(&d_counters,counters.size()*width*height*sizeof(int)); 
    printf("in cuda point size:%d  ",points.size()); 
    cudaMalloc(&d_points,points.size()*sizeof(float2)); 
    cout<<"points.size() : "<<points.size()<<endl; 
    cudaMemcpy(d_points, &points, points.size()*sizeof(float2), cudaMemcpyHostToDevice); 
    int blk=cvFloor(points.size()/1024)+1; 
    cout<<"blk : "<<blk<<endl; 
    if(points.size()>0) 
    { 
     densefun<<<blk,1024>>>(d_counters,d_points,x_max,y_max,width,height,min_distance, points.size()); 
     cudaError_t err = cudaGetLastError(); 
     if (err != cudaSuccess) 
     printf("Error: %s\n", cudaGetErrorString(err)); 
     cudaMemcpy(&counters, d_counters, counters.size()* width*height*sizeof(int), cudaMemcpyDeviceToHost); 
    } 
    cudaFree(d_counters); 
    cudaFree(d_points); 
    points.clear(); 
    int index = 0; 
    int offset = min_distance/2; 
    for(int i = 0; i < height; i++) 
    for(int j = 0; j < width; j++, index++) 
    { 
     if(counters[index] <= 0) 
     { 
      int x = j*min_distance+offset; 
      int y = i*min_distance+offset; 
      if(eig.at<float>(y, x) > threshold) 
      points.push_back(Point2f(float(x), float(y))); 
     } 
    } 
} 

Ausgabe ist: in Deskriptors Größe: 1605 in cuda Punktgröße: 1605 points.size(): 1605

blk: 2 Fehler: ein illegaler Speicherzugriff in Deskriptors Größe aufgetreten: 918 in CUDA Punktgröße: 918 points.size(): 918

blk: 1 Fehler: ein illegales Zugriffsspeicher aufgetreten

Answer 1

Sie einen Thread gird mit Block erstellen Länge 1024 und Rasterlänge gleich

int blk=cvFloor(points.size()/1024)+1;

die im Wesentlichen bedeutet, dass die Anzahl der Gewindegänge von 1024 größer ist als points.size() mehrere sein. In diesem Fall verwenden:

int i = blockDim.x * blockIdx.x + threadIdx.x; 
float2 point = (d_points)[i]; 

kann nicht erfolgreich sein, weil man fast sicher sein kann, dass Sie außerhalb der Grenzen Speicherzugriff erhalten. Fügen Sie einige Bedingungen hinzu, um sicherzustellen, dass dies nicht geschieht.

__global__ void densefun(int *d_counters,float2 *d_points,int d_x_max,int d_y_max,int width, int height, int min_distance) 
{ 
    int i = blockDim.x * blockIdx.x + threadIdx.x; 
    if(i < width * height) 
    { 
     //rest of the code 
    } 

} 

Auch Sie zuteilen nicht enugh Speicher für d_points:

float2 *d_points; 

cudaMalloc(&d_points,points.size()*sizeof(float)); 

Wenn Sie Array von float2 zuordnen möchten (oder kopieren, um es) benötigen Sie sizeof(float2) zu verwenden.