Ein paar Performance Fragen

also die conv2Bin Funktion wird am häufigsten durchlaufen.

Ich denke mein Programm ist schon recht schnell, benutze
kaum Bibliotheksfunktionen außer 1 2 mal memcpy,
arbeite auf indizierten Arrays wo ich schnell an die gewünschten Stellen
komme, arbeite viel mit "<<" und ">>" anstatt Multiplikationen und Divisionen.

Deswegen schau ich mir ja jetzt grad solche Funktionen an die öfters benutzt
werden und vielleicht durch Profis wie auch noch effizienter werden können.

CStoll

Hmm, die if()-Abfrage da drin kannst du auf jeden Fall kürzen zu:

binField[binIndex++] = (inputField[i] & (128 >> j)/*BINCONV[j]*/) == 0);

(keine Ahnung, ob der Compiler intelligent genug ist, sowas von selber zu optimieren).

(btw, und Bibliotheksfunktionen sind in vielen Fällen wesentlich besser optimiert als du das jemals mit handgeschriebenem Code hinbekommen kannst)

hm, stimmt! gute idee werd ich einfach mal machen, wer traut schon seinem Compiler

Klar sind Bibpliotheksfunktionen sehr gut optimiert, wollt ich nicht abstreiten :p aber für die Sachen die ich da mache gibts eh keine geeigneten Funktionen für.

Was sollte man denn noch alles aus performace-Technischen Grunden beachten.
vorallem auf einem langsamen Prozessor?

binField[binIndex++] = ((inputField[i] & (128 >> j)) == 0);

funktioniert irgendwie nicht, bekomm da andere Ergebnisse raus

CStoll

Also auf der Ebene einzelner Funktionen bleibt wohl nur Mikro-Optimierung (Ersparnis einzelner Taktzyklen). Wenn du echt etwas an Leistung herausholen willst, müsstest du vermutlich dein gesamtes System umbauen. Das geht dann z.B. in die Richtung "Lazy Evaluation" (siehe Tim's Lösung zum Array-Rotieren) oder Verwendung anderer Basisalgorithmen (der Umstieg von BubbleSort auf QuickSort kann in manchen Fällen schon einiges ausmachen - gerade wenn du oft große Datenmengen sortieren mußt).

Undertaker

Veritas696 schrieb:

Beschreibung:
Die Funktion wandelt ein "Bytearray" in ein "BitArray" um
Bsp: aus
aus inputField -> [0x01, 0x05, 0xF0]
wird
binField = [0,0,0,0,0,0,0,1,
0,0,0,0,0,1,0,1,
1,1,1,1,0,0,0,0]

wofür brauchst du das?
ich habe so den verdacht, dass du auf diese funktion komplett verzichten kannst...

binField[binIndex++] = !((inputField[i] & (128 >> j)) == 0);

musste noch invertiert werden aber funzt auch nicht wirklich

@Undertaker: brauch das damit ich die einzelnen Bits Permutieren kann mit entsprechenden Matrizen.

@CStoll: na das würde zu weit führen, und sortieren muss ich auch nix.

Geht im großen und ganzen ums Bitknipsen(Permutieren, expandieren, XOR etc.)

P.S: na bald wisst ihr wohl auch was ich hier eigentlich tue

Undertaker

Veritas696 schrieb:

@Undertaker: brauch das damit ich die einzelnen Bits Permutieren kann mit entsprechenden Matrizen.

kannst du nicht das bit zu dem zeitpunkt rausholen, wenn du's brauchst?
dann könntest du auf die umwandlung verzichten...
z.b. so:

// Helper function to read one bit from array
int GetBit (unsigned char *array, unsigned int pos) 
{
  unsigned int bytepos = pos>>3;
  unsigned int bit = 7 - (pos - (bytepos<<3));
  return !!(array[bytepos] & (1<<bit)); 
}

die funktion gibt 1 zurück, wenn das bit in 'array' an stelle 'pos' gesetzt ist, sonst 0

CStoll

Veritas696 schrieb:

@CStoll: na das würde zu weit führen, und sortieren muss ich auch nix.

Ja, das war nur ein Beispiel (da ich deine Zielstellung nicht kannte, vermutlich ein schlechtes).

Geht im großen und ganzen ums Bitknipsen(Permutieren, expandieren, XOR etc.)

Da ist es wesentlich Platz- (und meistens auch zeit-)sparender, die Bits nicht auf Vorrat auseinanderzunehmen, sondern erst bei Bedarf genau die Bits herauszuziehen, mit denen du rechnen willst.

Das währe vielleicht Platzsparender, aber bestimmt nicht Zeitsparender
wenn ich für jedes Bit eines Bytes verunden,shiften,vergleichen,neusetzen, Funktionsaufruf, subtrahieren etc. machen muss und das mehrmals, wenn ich an Stelle davon

binField[i] = binCopy[permut[i]];

schreiben kann.

wie gesagt, die Platzersparnis ist nicht sooo wichtig

pointercrash**

Warum willst Du den Inhalt rotieren?

Wenn Du eine feste Größe hast, mach' das über die Arrayindices:

Eine Methode für's Lesen startet von Index blah (default 0) aus, der readout- Index bricht an der Arraygrenze einfach um.

Rechtsshift ist Reduzierung von blah um eins, Linksshift um blah plus eins, blah bricht bei den Arraygrenzen um.

Mit den Indices zu spielen ist viel performanter, als die Inhalte umzukopieren.

Brauchste Code?

na dann lass mal gucken