4. überlegung: erformenceproblem bei iteration mit einem array

überlegung: erformenceproblem bei iteration mit einem array

  • S

    hi,

    habe ein buffer (array) bestehend aus 414_720 char einträgen.

    diese speichere ich nach einer bestimmten reihenfolge in einer datei ab.
    genauer ist der inhalt ein ausgelesener framebuffer von 720x576 pixeln.
    da ich den buffer in ein bmp-bildchen umwandle (das klappt auch gut) muss ich wie oben beschrieben in einer bestimmten reihenfolge vorgehen. also das array von hinten rückwärts zu jeweils 720 zeichen durchforsten.
    dazu verwende ich zwei for-iterationen wobei die erste jeweils 576x aufgerufen wird und die innere jeweils 720 zeichen einzeln schreibt.

    nun ist es so das die ausführung des programmes an performence zu wünschen lässt und ich nach einer besseren lösung suche.

    wäre es nicht besser diesbezüglich die innere schleife wegfallen zu lassen und das gewünschte ergebnis mittels eines temp-strings als rückgabe einer funktion an fwrite zu übergeben??? das müsste doch die performence eigentlich steigern???
    z.b. <nicht getestet>

    char *StringReturn (char *buffer, char *var)
{
    return(memcpy(var, buffer, 720));
}

char tmp[720];
1 . for 
    2. (innere schleife nun weg)
    fwrite(StringReturn(fb_buffer, tmp), 720, 1, fh);
    0
  • A

    Etwas schneller dürfte es schon sein, wenn du gleich einen ganzen Block schreibst und nicht jedes Zeichen einzeln.

    Allerdings kann ich mir kaum vorstellen, dass deine bisherige Variante so langsam ist. Wie viele ms braucht sie denn? Und wie sieht das Coding dazu aus?

    0
  • M

    Wie wäre es, wenn Du einen Pointer auf den Originalpuffer benutzt, und von dem aus immer 720 Zeichen schreibst, und danach um 720 Zeichen nach vorne verschiebst?

    unsigned char *cp = frame_buffer+575*720;

while(cp>=frame_buffer)
{
   fwrite(cp,720,1,fh);
   cp -= 720;
}

    oder so ähnlich?

    0
  • S

    danke für eure antworten, jetzt bin ich wieder an meinem rechner und konnte meine gedanken umsetzen.
    ich hab das nun folgender maßen gemacht...

    hier die alte variante:

    // Datenpixel speichern
	long x;
	long z;
	for (i=pic->yres; i>0; i--)
	{
		x = (i*pic->xres) - pic->xres;	// Anfang
		z = x + pic->xres;		// Ende
		for (; x<z; x++)
			fwrite(&pic->buffer[x], 1, 1, fh);
	}

    benchmark:

    User time (seconds): 2.08
        System time (seconds): 0.18
        Percent of CPU this job got: 91%
        Elapsed (wall clock) time (h:mm:ss or m:ss): 0m 2.45s

    und hier die neue:

    // Datenpixel speichern
long x;
char tmp[720];
for (i=pic->yres; i>0; i--)
{
	x = (i*pic->xres) - pic->xres;	// Anfang
	ReturnString(&pic->buffer[x], tmp);
	fwrite(&tmp, 720, 1, fh);
}

    benchmark neu:

    User time (seconds): 0.06
        System time (seconds): 0.19
        Percent of CPU this job got: 101%
        Elapsed (wall clock) time (h:mm:ss or m:ss): 0m 0.24s

    ich würd mal meinen das es um einiges schneller ist 😃 😃 😃

    0
  • M

    stdin schrieb:

    danke für eure antworten, jetzt bin ich wieder an meinem rechner und konnte meine gedanken umsetzen.
    ich hab das nun folgender maßen gemacht...
    ...
    und hier die neue:

    // Datenpixel speichern
long x;
char tmp[720];
for (i=pic->yres; i>0; i--)
{
	x = (i*pic->xres) - pic->xres;	// Anfang
	ReturnString(&pic->buffer[x], tmp);
	fwrite(&tmp, 720, 1, fh);
}

    ...

    Ein bisschen Potential hast Du da auch noch:

    // Datenpixel speichern
long x;
char tmp[720];
x = (pic->yres-1)*pic->xres;
for (i=pic->yres; i>0; i--)
{
   ReturnString(&pic->buffer[x], tmp);
   fwrite(&tmp, 720, 1, fh);
   x -= pic->xres;
}

    Das spart die Multiplikation etc. in der Schleife. Bringt aber bestenfalls Mikrosekunden 😃

    0
Anmelden zum Antworten