Unterschiedliche Ergebnisse zwischen Debug und Release

Rücksicht auf mein Kommentar, das ist der code, dass ist wahrscheinlich die Wurzel des Problems:

#pragma omp parallel for shared(last, bestHit, cVal, rad, veneOffset)
{
    ...
    last = GetSADFloatRel(adapted, &fSamples.at(offset), 4*w+1, 4*w+1, 0);
    if(bestHit > last)
    {

last ist nur zugewiesen werden, bevor es wieder Lesen, so ist es ein guter Kandidat für eine lastprivate variable, wenn Sie wirklich brauchen, wird der Wert aus der letzten iteration außerhalb der parallelen region. Ansonsten einfach machen es private.

Zugang zu bestHit, cVal, rad, und veneOffset synchronisiert werden sollten, die von einer kritischen region:

#pragma omp critical
if (bestHit > last)
{
    bestHit = last;
    rad = (r+8)*0.25f;
    cVal = c * 2;
    veneOffset =(-0.5f + (1.0f / 3.0f) * k + (1.0f / 3.0f) / 2.0f);
    if(fabs(veneOffset) < 0.001)
        veneOffset = 0.0f;
}

Beachten Sie, dass standardmäßig werden alle Variablen, mit Ausnahme der Zähler parallel for Schleifen und jene definiert, die innerhalb der parallelen region, die geteilt werden, d.h. die shared Klausel in Ihrem Fall tut nichts, es sei denn, Sie gelten auch für die default(none) - Klausel.

Andere Sache, die Sie sollten sich bewusst sein, dass in 32-bit-Modus von Visual Studio verwendet x87-FPU Mathematik, während im 64-bit Modus er verwendet SSE-math standardmäßig. x87-FPU hat Zwischenberechnungen mit 80-bit floating-point-Präzision (auch für Berechnungen mit float nur) während der SSE-Einheit unterstützt nur die standard-IEEE single und double-Genauigkeit. Einführung in OpenMP oder andere Parallelisierung Technik, um eine 32-bit-x87-FPU-code bedeutet, dass an bestimmten Punkten Zwischenwerte sollten zurück konvertiert werden, um die einzelnen Genauigkeit von float und wenn man ausreichend viele Zeiten zu einem leichten oder deutlichen Unterschied (abhängig von der numerischen Stabilität des Algorithmus) konnte beobachtet werden, dass zwischen den Ergebnissen aus den serial-code und die parallelen.

Basierend auf deinem code, ich würde vorschlagen, die folgenden geänderten code geben Ihnen eine gute parallele Leistung, weil es keine synchronisation bei jeder iteration:

#pragma omp parallel private(last)
{
    int rBest = 0, kBest = 0, cBest = 0;
    float myBestHit = bestHit;

    #pragma omp for
    for(int r = 0; r < 53; ++r)
    {
        for(int k = 0; k < 3; ++k)
        {
            for(int c = 0; c < 30; ++c)
            {
                for(int o = -1; o <= 1; ++o)
                {
                    /*
                    r: 2.0f - 15.0f, in 53 steps, representing the radius of blood vessel
                    c: 0-29, in steps of 1, representing the absorption value (collagene)
                    iO: 0-2, depending on current radius. Signifies a subpixel offset (-1/3, 0, 1/3)
                    o: since we are not sure we hit the middle, move -1 to 1 pixels along the samples
                    */

                    int offset = r * 3 * 61 * 30 + k * 30 * 61 + c * 61 + o + (61 - (4*w+1))/2;

                    if(offset < 0 || offset == fSamples.size())
                    {
                        continue;
                    }
                    last = GetSADFloatRel(adapted, &fSamples.at(offset), 4*w+1, 4*w+1, 0);
                    if(myBestHit > last)
                    {
                        myBestHit = last;
                        rBest = r;
                        cBest = c;
                        kBest = k;
                    }
                    last = GetSADFloatRel(input, &fSamples.at(offset), w * 4 + 1, w * 4 + 1, 0);
                    if(myBestHit > last)
                    {
                        myBestHit = last;
                        rBest = r;
                        cBest = c;
                        kBest = k;
                    }
                }
            }
        }
    }
    #pragma omp critical
    if (bestHit > myBestHit)
    {
        bestHit = myBestHit;
        rad = (rBest+8)*0.25f;
        cVal = cBest * 2;
        veneOffset =(-0.5f + (1.0f / 3.0f) * kBest + (1.0f / 3.0f) / 2.0f);
        if(fabs(veneOffset) < 0.001)
        veneOffset = 0.0f;
    }
}

Es speichert nur die Werte der Parameter, die die besten Treffer in jeden thread und dann am Ende der parallelen region berechnet rad, cVal und veneOffset auf der Grundlage der besten Werte. Jetzt ist es nur eine kritische region, und es ist am Ende der code. Kann man dies umgehen, auch, aber Sie würden die Einführung eines zusätzlichen arrays.

Eine Sache zu überprüfen ist, dass alle Variablen initialisiert sind. Viele Male un-optimierten code (Debug-Modus) initialisiert den Speicher.

Gerade über jede nicht definierte Verhalten kann für dieses Konto: initialisierten
Variablen, Schurke Zeiger, mehrere änderungen des gleichen Objekts
ohne eine dazwischenliegende Sequenz, die zeigen, etc. etc. Die Tatsache, dass die
die Ergebnisse sind manchmal unreproduceable argumentiert eher für eine
nicht initialisierte variable, es kann aber auch vorkommen von Zeiger-Probleme oder
bounds-Fehler.

Bewusst sein, dass die Optimierung ändern können Ergebnisse, vor allem auf einem Intel.
Optimierung ändern können, welche Zwischenwerte spill-Speicher, und
wenn Sie schon nicht gezielt verwendet Klammern, auch die Reihenfolge der Auswertung
in einem Ausdruck. (Und wie wir alle wissen, im Maschinen-floating-point -, (a +
b) + c) != a + (b + c).) Noch sollten die Ergebnisse deterministisch sein:
erhalten Sie unterschiedliche Ergebnisse, je nach dem Grad der Optimierung,
aber für eine beliebige Gruppe von Optimierungs-flags, sollten Sie die gleichen Ergebnisse erhalten.