openmp parallelisierung

BBTS

Hallo Leute,

ich habe folgenden code nur pseudo

for ( i = ...) {
        for ( j =...) {
          ...
            for ( m = ...) {
                for ( n = ...) {
                        double kernelValue = inCKernel[(i - m + kernelRadius) * kw + (j - n + kernelRadius)];
                        unsigned int ic = inCMatrix[m * width + n];
                        #pragma omp parallel sections num_threads(3)
                        {
                 #pragma omp section
                            {
                                unsigned char intensityKernelPosR = (ic >> 16) & 0xFF;
                                weightR = kernelValue * gaussSimilarity[abs(intensityKernelPosR - r)];
                                totalWeightR += weightR;
                                sumR += (weightR * intensityKernelPosR);

                            }
                            #pragma omp section
                            {
                                unsigned char intensityKernelPosG = (ic >> 8) & 0xFF;
                                weightG = kernelValue * gaussSimilarity[abs(intensityKernelPosG - g)];
                                totalWeightG += weightG;
                                sumG += (weightG * intensityKernelPosG);
                            }
                            #pragma omp section
                            {
                                unsigned char intensityKernelPosB = ic & 0xFF;
                                weightB = kernelValue * gaussSimilarity[abs(intensityKernelPosB - b)];
                                totalWeightB += weightB;
                                sumB += (weightB * intensityKernelPosB);
                            }
                        }
                    }

            }

         }
    }

macht es Sinn solche kleinen Anweisungen zu parallelisieren oder sollte man besser die dritte for Schleife parallelisieren.

Gruß

Na so bekommst du ja nur 3 Threads, was bei den meisten Systemen heutzutage schon suboptimal ist. Ich würde schon eine der Schleifen parallelisieren. reduction (+: ...) nicht vergessen.

BBTS

Es geht mir hier speziell um die Frage: Macht es im speziellen Sinn innerhalb einer Forschleife solche Anweisungen zu parallelisieren oder ist der Aufwand zum erzeugen und joinen eines Threads zu groß?

Das wirst du ultimativ nur durch Profiling herausfinden.

Aber ich finde deinen Ansatz irgendwie schräg, du kannst (zumindest interpretiere ich den Code so) trivial auf höchster Ebene parallelisieren. Warum also irgendwo tief drin? Außer dass du dir vielleicht deine Cachelines verhagelst.

Wie auch immer: Profiler

nachtfeuer

Man müsste vielleicht noch ein wenig was vom Pseudo Betriebsystemverhalten, vom Pseudocompilerverhalten oder von den Pseudohardwareressourcen wissen.
Wie auch immer, es gilt: Probieren geht über Studieren!
Profiler oder Thread-Checker sind wichtige Begleitwerkzeuge für solche Fragen.