Gehts noch schneller ...?

MiP schrieb:

Ja, benutze ++i statt i++ ! Schau mal hier:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39454.html

Spielt bei Built-Ins keine Rolle, aber wenn man sich Preincrement angewöhnt, dann benutzt man ihn auch automatisch bei anderen Typen.

AndOne

Oh, muss ich zu meiner Schande gestehen das mit dem ++i kannt ich bisher garnicht.
Werds mir mal anschauen.

hustbaer

@OP: Ich glaube nicht dass man da noch was rausholen kann.

@MiP: Das ist jetzt aber nicht ernst gemeint???

Don06

Das einzige, was mir noch einfiele, wäre zu parallelisieren. Das geht in dem Beispiel recht gut. Allerdings wäre wohl bei einer so geringen Datenmenge (1000 Byte => 4000 Byte) der Aufwand zur Erstellung der Threads größer als der Gewinn an Schnelligkeit. Vielleicht solltest du es einfach mal messen.

Gruß
Don06

AndOne

das mit den 1000 bytes war nur ein Beispiel, in der Praxis sind das dann so 157248
Bytes. Das merkt man dann schon denk ich, das ganze muss 50mal in der sek passieren.

lagalopex

Je nach Anwendung ließe sich auch mmx, sse* oder so benutzen. Also keine Threads sondern direkte parallele Berechnung in der Hardware. Was das ganze natürlich nicht wirklich portabel machen würde. OpenMP würde die parallelisierung von Schleifen sehr einfach machen, aber es muss abgewägt werden, ob das was bringt (mehrere CPUs?).

BorisDieKlinge

welche IDE verwendest du? compilier das mal im release modes, dann müsste das machbar sein.

Fellhuhn

Vielleicht schneller:

unsigned char _8BitPuffer[1000];
unsigned short _16BitBuffer[1000];
unsigned short _Pallette16Bit[256];

unsigned char *8BitPtr = _8BitPuffer;
unsigned char *16BitPtr = _16BitBuffer;

for (int i=0;i<1000;i++) *(16BitPtr++) =_Pallette16Bit[*(8BitPtr++)];

oder gar:

unsigned char _8BitPuffer[1000];
unsigned short _16BitBuffer[1000];
unsigned short _Pallette16Bit[256];

unsigned char *8BitPtr = _8BitPuffer;
unsigned char *16BitPtr = _16BitBuffer;

for (int i=0;i<500;i++){
  *(16BitPtr++) =_Pallette16Bit[*(8BitPtr++)];
  *(16BitPtr++) =_Pallette16Bit[*(8BitPtr++)];
}

Wobei die Schleife an sich wohl kaum Zeit verbrät.

Oder Duff's Device:

unsigned char _8BitPuffer[1000];
unsigned short _16BitBuffer[1000];
unsigned short _Pallette16Bit[256];

unsigned char *8BitPtr = _8BitPuffer;
unsigned char *16BitPtr = _16BitBuffer;

    int count = 1000;

    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 7:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 6:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 5:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 4:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 3:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 2:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
    case 1:      *(16BitPtr++) = _Pallette16Bit[*(8BitPtr++)];
               } while (--n > 0);

_matze

http://msdn.microsoft.com/de-de/library/26td21ds.aspx

AndOne

@Fellhuhn, werd mal nachher das ganze messen. Mal kucken obs damit wirklich
schneller geht, meld mich dann mit den Ergebnissen.

Thorsten