Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Code Optimieren mittelwerte aus großen Daten mengen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
21.07.2016, 10:18 Uhr
~FelidaeTWC
Gast


Ich möchte einen Video stream auswerten und ihn dazu mitteln. Ich haben einen Pointer auf einen Datenblock von 640*120 byte (Monocrome: 8Bit pro Pixel). Die Pixel liegen zeilenweise im speichre. Ich möchte in jeder zeile jeweils 4 Pixel zu einem zusammen mitteln und im Anschuß alle Zeilen zu einer mitteln. Die neuen Daten 160x1 im 16Bit Format möchte ich im Anschluss in eine Datei schreiben.

mein erster Ansatz funktioniert schon ganz gut, aber er lastet meinen cpu Kern zu 100% aus.
hir möchte ich jetzt Optimieren. Ich denke man könnte die Mittelwert Bildung verbessern und oder den Dateizugriff beschleunigen.

hier der code:


C++:
static void process_image(const void *p, int size)
{
    u_int64_t line_summe[160] ={0};
    u_int16_t line_mean [160] = {0};
    unsigned char *pixel_ptr=(unsigned char*)p;
    int j = 0;
    int k = 0;



    if(frame_mode == 0 || frame_mode == 1)
    {

        // Einzelframe-Vorverarbeitung
        // die Pixelwerte von 4 Spalte weden zu einem Wert aufsummiert
        // (120 werte pro spalte * 4 spalten -> 480 Werte)
        // Die Summe wird mit 257 multipieziert und das ergebnis dann durch 480 dividiert.
        // das ergebniss sind genau 160 Mittelwerten je Frame
        // (255*257=65535(DEC)=FFFF(HEX)) ausnutzung des gesamten Zahlenbereichs
        // für möglichs viele nachkommastellen des Mittelwertes


        for (k = 0; k < 120; k++)
        {
               for (j = 0;  j < 160; j++)
               // Zeilen, 4 aufeinander folgende werte der zeile aufsummieren (4 werte für 4 spalten)
               {
                    line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
                    pixel_ptr++;

                    line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
                    pixel_ptr++;

                    line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
                    pixel_ptr++;

                    line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
                    pixel_ptr++;
               }
        }

        for(k=0;k<160;k++)
        {
            line_mean[k]=(u_int16_t)((line_summe[k]*257)/480);  // mittelwerte bilden und Formatieren
        }
        //Mittelwerte in eine Datei schreiben

        if(!fwrite(line_mean, sizeof(line_mean),1,fd_outflie_m))
        {
            errno_exit("Fehler beim schreiben in datei");
        }
    }


    if(frame_mode == 1 || frame_mode == 2  )
    {
          if(!fwrite(p, size, 1, fd_outflie_v))
          {
              errno_exit("Fehler beim schreiben in datei");
          }
    }

    fflush(stderr);
    fprintf(stderr, ".");
    fflush(stdout);
}



für das schreiben der Daten in die Datei verwende ich fopen und fwrite
Ich unterscheide verschiedene Modi. einmal schreibe ich nur die Mittelwerte in einen Datei in einem anderen den gesamten Frame. oder beides. ich verwende zwei for schleifen. eine für jede Zeile und eine für jede Spalte.

ich wollte fragen ob hier jemand eine Idee hat wie ich den Ablauf beschleunigen kann. Grade das schreiben des gesamten Frame ist so zeitaufwendig, dass das Programm öfters ins stottern kommt und ganze Frames verschluckt.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
27.07.2016, 13:24 Uhr
~jemand
Gast


Du mischst C mit C++. That's not good practice. Benutze die Iostreams.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
28.07.2016, 22:47 Uhr
ao

(Operator)


@jemand: Was davon ist C++? Ich erkenne nur C.

@FelidaeTWC: Ich habe den Algorithmus noch nicht so ganz verstanden, aber dass ein Programm die CPU voll auslastet, wenn es kann, ist normal. Dafür ist die CPU da. Wie rechnet das Programm denn an einem Bild?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
29.07.2016, 09:21 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


ja für mich sieht das auch nach reinem C aus.


was halt vermutlich ungünstig formuliert istist deine haupt schleife:



C++:
line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
pixel_ptr++;

line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
pixel_ptr++;

line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
pixel_ptr++;

line_summe [j] = line_summe [j] + (unsigned int)(*(pixel_ptr));
pixel_ptr++;



hier kann es sein das du dir alle pipeline optimierungen zerschießt (da jeder wert vom vorgänger abhängt)

auch schleifenoptimierungen werden vermutlich nicht vorgenommen, da du auf pixel_ptr nicht absolut zugreifst.

ggf mal sich den asm output anschauen, was der compiler dir daraus generiert.

Vermutlich würde ich das lesbarer in form von

C++:
line_summe [j] = (unsigned int)(pixel_ptr[k*4]) + (unsigned int)(pixel_ptr[k*4+1]) ...


schreiben, dann kann der compiler bei geeigneten optimierungsflags vermutlich die schleife ganz entfernen, bzw bei modernen prozessoren vernünftig parallelisieren
--
class God : public ChuckNorris { };

Dieser Post wurde am 29.07.2016 um 09:22 Uhr von FloSoft editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: