Ich werde nur mit Cuda angestarrt, und nachdem ich die Vektorsummen-Tutorials durchgesehen habeHie Ich dachte, ich würde etwas von Grund auf versuchen, um meine Beine wirklich unter mich zu bekommen.

Das heißt, ich weiß nicht, ob das Problem hier eine einfache Lösung oder eine ganze Reihe von Problemen ist.

Die einfache englische Beschreibung meines Codes lautet wie folgt:

Zunächst gibt es eine counterClass mit Mitgliedern num und count. Durch Setzen von count = 0, wenn count gleich num ist, verfolgt diese Zählerklasse den Rest beim Teilen durch num, während wir die ganzen Zahlen durchlaufen.

Ich habe 2 Funktionen, die ich parallel ausführen möchte. Der erste aufgerufene Zähler erhöht alle meine Zähler (parallel) und der zweite überprüft, ob einer der Zähler 0 (parallel) anzeigt. Wenn ein Zähler 0 anzeigt, teilt num n gleichmäßig, was bedeutet, dass n keine Primzahl ist.

Während ich möchte, dass mein Code nur Primzahlen druckt,it druckt alle Zahlen aus ...

Hier ist der Code:

#include <stdio.h>
#include <stdlib.h>

typedef struct{
    int num;
    int count;
} counterClass;

counterClass new_counterClass(counterClass aCounter, int by, int count){
    aCounter.num = by;
    aCounter.count = count%by;
    return aCounter;
}

__global__ void count(counterClass *Counters){
    int idx = threadIdx.x+blockDim.x*blockIdx.x;
    Counters[idx].count+=1;
    if(Counters[idx].count == Counters[idx].num){
        Counters[idx].count = 0;
    }
    __syncthreads();
}

__global__ void check(counterClass *Counters, bool *result){
    int idx = threadIdx.x+blockDim.x*blockIdx.x;
    if (Counters[idx].count == 0){
        *result = false;
    }
    __syncthreads();
}

int main(){
    int tPrimes = 5;    // Total Primes to Find
    int nPrimes = 1;    // Number of Primes Found
    bool  *d_result, h_result=true;
    counterClass *h_counters =(counterClass *)malloc(tPrimes*sizeof(counterClass));
    h_counters[0]=new_counterClass(h_counters[0], 2 , 0);
    counterClass *d_counters;
    int n = 2;
    cudaMalloc((void **)&d_counters, tPrimes*sizeof(counterClass));
    cudaMalloc((void **)&d_result, sizeof(bool));
    cudaMemcpy(d_counters, h_counters, tPrimes*sizeof(counterClass), cudaMemcpyHostToDevice);
    while(nPrimes<tPrimes){
        h_result=true;
        cudaMemcpy(d_result, &h_result, sizeof(bool), cudaMemcpyHostToDevice);
        n+=1;
        count<<<1,nPrimes>>>(d_counters);
        check<<<1,nPrimes>>>(d_counters,d_result);
        cudaMemcpy(&h_result, d_result, sizeof(bool), cudaMemcpyDeviceToHost);
        if(h_result){
            printf("%d\n", n);
            cudaMemcpy(h_counters, d_counters, tPrimes*sizeof(counterClass), cudaMemcpyDeviceToHost);
            h_counters[nPrimes]=new_counterClass(h_counters[nPrimes], n , 0);
            nPrimes += 1;
            cudaMemcpy(d_counters, h_counters, tPrimes*sizeof(counterClass), cudaMemcpyHostToDevice);
        }
    }
}

Es gibt einige ähnliche FragenCUDA - Teilung des Siebs von Eratosthenes in Teile und gute Beispiele, die als Fragen von Leuten gepostet wurden, die ihren Code verbessern möchten,CUDA Primes Generation & Niedrige Leistung im CUDA-Primzahlengenerator Aber das Durchlesen hat mir nicht geholfen, herauszufinden, was in meinem Code falsch läuft!

Jeder Rat, wie Sie bei der Arbeit mit CUDA effektiver debuggen können, ist willkommen und wenn Sie darauf hinweisen können, was Ich mache falsch (weil ich weiß, dass es nicht der Computerfehler ist), wirst du meinen Respekt für immer haben.

bearbeiten

Anscheinend tritt dieses Problem nur bei mir auf. Vielleicht ist es die Art und Weise, wie ich meinen Code ausführe ...

$ nvcc parraPrimes.cu -o primes
$ ./primes
3
4
5
6

Weitere Verwendung von cuda-memCheck wie empfohlen:

$ cuda-memcheck ./primes
========= CUDA-MEMCHECK
3
4
5
6
========= ERROR SUMMARY: 0 errors

Die Ausgabe vondmesg |grep NVRM ist wie folgt:

[    3.480443] NVRM: loading NVIDIA UNIX x86_64 Kernel Module  304.131  Sun Nov  8 21:43:33 PST 2015

Nvidia-smi ist nicht auf meinem System installiert.