code optimierung

[EBFE]

1. keine Kopierereien und "höhere" Datentypen wie Strings (ein "string[x]" Zugriff artet nämlich intern in einige Calls aus und ist keineswegs mit dem "char* hallo[x]" gleichzusetzen). Gleiches gilt für "Concatenierungen" oder gar "+" Operatoren bei Strings.
nimm ein chararray, initialisiere es am Anfag mit 0 und schreibe direkt die Zeichen rein.

2. alle Infos möglichst im voraus berechnen - so auch die Passwortlänge.
3. MD5 Routine aus den Libs ist keineswegs optimal - denn diese sind dazu gedacht, "echte" Daten zu hashen. Sofern man aber auf 12-13 Zeichen beschränkt ist, kann man einiges wegoptimieren:
das ist nämlich der Algo:
Message-Digest Algorithm 5 – Wikipedia
z.B dieser Schritt:

b := ((a + f + k(i) + w(g)) leftrotate r(i)) + b

also das einbeziehen der Eingabe (=w(g) Wert):

so schaut der Speicherzugriff bei 20 Zeichen und 64 Runden:

54 ?- show_mem(20, 64).

0000:                  0                 1                 2                 3
0004:                  4                 5                 6                 7
0008:                  8                 9                10                11
0012:                 12                13               len                15
0016:                  1                 6                11                 0
0020:                  5                10                15                 4
0024:                  9               len                 3                 8
0028:                 13                 2                 7                12
0032:                  5                 8                11               len
0036:                  1                 4                 7                10
0040:                 13                 0                 3                 6
0044:                  9                12                15                 2
0048:                  0                 7               len                 5
0052:                 12                 3                10                 1
0056:                  8                15                 6                13
0060:                  4                11                 2                 9

Zahlen links: aktuelle Runde im Hashalgo, Zahl in der Zeile = Zugriff auf Adresse x in der jeweiligen Runde, LEN ist dabei "Extrabezeichner" für den Zugriff auf den Speicher mit der Längenangabe.

und so bei 4 Zeichen:

53 ?- show_mem(4, 64).

0000:                  0                 1                 2                 3
0004:                  4                []                []                []
0008:                 []                []                []                []
0012:                 []                []               len                []
0016:                  1                []                []                 0
0020:                 []                []                []                 4
0024:                 []               len                 3                []
0028:                 []                 2                []                []
0032:                 []                []                []               len
0036:                  1                 4                []                []
0040:                 []                 0                 3                []
0044:                 []                []                []                 2
0048:                  0                []               len                []
0052:                 []                 3                []                 1
0056:                 []                []                []                []
0060:                  4                []                 2                []

Zahlen links: aktuelle Rundennummer, Zahlen in der Zeile: Zugriff auf Adresse x in der jeweiligen Runde. [] bedeutet dass hier Zugriff auf 0-initialisierten Speicher stattfand, d.h dass man diesen auch ignorieren kann, da ja eine 0 hinzuaddiert werden sollte)

hier kann man sich also jede Menge Speicherzugriffe sparen.
Zudem lassen sich die letzen 15-18 der 64 Runden (länger her) zurückrechnen, was wiederum eine "Verschnellerung" um 25% bietet. Den ultimativen Boost bringt aber Parallelisierung mittels MMX oder gleich SSE:
Software optimization resources. C++ and assembly. Windows, Linux, BSD, Mac OS X
(hier solltest du, je nach Kenntnissstand, ruhig einige Wochen zum durcharbeiten einplanen )
Damit erreicht man mehere zig Mio Hashs pro Sekunde (z.B auf meinem 3 Jahre altem Laptop 32 Mio Hashs/s pro Kern - gegenüber BarsWFs 27 Mio H/s ). Setzt aber voraus, dass man sich mit SSE erstmal beschäftigt (C++ Compiler wird hier einem keineswegs die Arbeit abnehmen - vielleicht nur insofern, dass er die SSE Register selbstständig vergibt, allerdings muss man dem Compiler an vielen Schritten zu seinem "Glück" verhelfen. Letzendlich schaut der hochoptimierte Code wie Macro-Asm aus:
Distracted: New and faster EmDebr finally done
(Md5 cracker mit Source, unwesentlich langsamer als BarsWF)

4. Nicht zuletzt solltest du dich mit Profilersoftware vertraut machen, um die tatsächlichen Problemstellen zu finden. Zumindest eine gute Timerbibliothek suchen und einbauen, so dass man die Zeit für einzelne Abschnitte messen kann und so abschätzen, was am meisten Rechenzeit kostet und optimiert werden muss.