Wie kann ich Programme effizienter gestalten? Kleine Intro

1. Effiziente Programme
Performanceverbesserung
Erhard Dinhobl
Margit Weber
Martin Reiterer
Stefan Reiterer

2. Agenda
Schritte zur Performance-Verbesserung:
• Herausheben von Schleifeninvarianten
• Caching / Memoziation
• Binäre Suche
• Memory Mapping der passwd Datei
• Direct Memory Access (DMA)
• Adressberechnungen vermeiden
• Schreibeoperationen vermeiden
Resultierendes Programm
Performancevergleich

3. Herausheben von Schleifeninvarianten
Problem: Dateien öffnen im Normalfall sehr aufwändig!
Datei nicht in jedem Schleifendurchgang neu öffnen
Ursprünglich Verbessert
char *uid2name (int uid) { File *passwd;
...
File *passwd = fopen(...); char *uid2name (int uid) {
... ...
} }
int main () {
int main () { ...
... passwd = fopen (...);
while (...) { while (...) {
uid2name (...); uid2name (...);
} }
} fclose (passwd);
}

4. Herausheben von Schleifeninvarianten

5. Caching / Memoziation
Problem: I/O-Operationen sehr aufwändig!
Datei bei ersten Aufruf von uid2name parsen und in
Prozessspeicher chachen
Ursprünglich Verbessert
passwd Datei wurde bei jedem Aufruf Beim 1. Aufruf:
von uid2name mittels I/O- passwd Datei komplett einlesen,
Operationen durchsucht notwendige Informationen intern
cachen und Datei wieder schließen
Ab 2. Aufruf:
Ergebnis aus Cache (Liste,
Array) zurückliefern.

6. Caching / Memoziation

7. Binäre Suche
Problem: Lineare Suche in interner Datenstruktur (unsortiertes
Array) ist sehr aufwändig.
Lösungsvorschlag: Binäre Suche in interner Datenstruktur.
Vorteil Nachteile
• Sortierung der Datenstruktur
• Geringerer Suchaufwand, im notwendig (hoher Sortieraufwand). In
Vergleich zu linearer Suche. unserem Fall war dies zwar nicht
• Da passwd Datei "fast" sortiert notwendig, konnten aber durch die
ist, muss interne Datenstruktur Rechenoperationen (/2, etc.) nicht viel
nicht sortiert werden. Rechenzeit gewinnen. Weiters
können nicht richtig einsortierte
Lineare Suche für "Ausreißer"
Elemente die gesamte Suche als
ganzes in vielen Fällen zunichte
machen.

8. Öffnen der Datei - mmap
Bisherige Version Verbessert
fopen() open()
pro Zeile getline() (char *) mmap()
mmap() liefert Pointer auf
char im Speicher, pro Zeile
auslesen fällt weg.

9. Speicher von mmap() verwenden
(while-body)
len = map; //aktuelle Pos. im Speicher
while(*len != ':') len++; //bis zum ersten : in Zeile gehen
old = map; //aktuelle Pos. speichern
map = len + 1; //im Speicher bis nach : weitergehen
map += 2; //:x: überspringen
len = map; //aktuelle Pos. nach :x: setzen
while(*len != ':') len++; //weiter bis nächsten :
fach = atoi(map); //nach :x: ist UID
map = len + 1; //nach UID positionieren
filecn[fach] = old; //old zeigt auf UName

10. Speicher von mmap() verwenden II
- Trotz Speicherverwendung sehr landsam: ~3.1 Mio
Iterationen
- Speicher von char-Pointern ebenfalls Verwalten
- Gesamte Datei im Speicher (!!)
mit strcpy realisieren, genauso langsam/schnell

11. Direct Memory-Access
Problem: Iterativer Suchaufwand von O(n2)
Iterative Suche durch (direkten) Speicherzugriff ersetzen
Ursprünglich Verbessert
• Stützung von Modulo-Algebra
linearer Suchaufwand zum • Einordnung der gecachten Daten
Durchsuchen der gecachten Daten
in Equivalenzklassen (Kongruenz-
(Tuppel aus UID und Benutzername)
Klassen)
• Lineare Suche innerhalb dieser
Klassen
• 3K Klassen ~ DMA

12. mmap - Direct Memory-Access

13. Adressberechnungen vermeiden
Problem: Da wir die passwd Datei in einer internen
Datenstruktur (Array) verwalten, benötigen wir direkten Zugriff
auf einzelne Arrayelemente.
Ursprünglich Verbessert
parsen der passwd Datei: Innerhalb Mittels Pointer auf die Datenstruktur
einer while Schleife (siehe später) (Array) zugreifen:
entry_ptr->name = lname
wird auf Elemente des Arrays mittels
Index zugegriffen:
Spart Prozessor die
entry[index].name = lname Adressberechnung in jedem
Schleifendurchgang.
Anmerkung: Diese Optimierung
können die meisten Compiler von
selbst.

14. Schreibeoperationen vermeiden
Problem: Schreibeoperationen im Speicher sind sehr
zeitaufwändig.
strtok durch strchr und strncpy ersetzen
Ursprünglich Verbessert
strtok wurde zum parsen der passwd 1. strchr zur Positionierung im
Datei verwendet: Speicher verwenden
searchstr = strchr(data, ':');
• strncpy zum Lesen von n
char *lname = strtok(line, ":");
Zeichen im Speicher verwende
strncpy(entry_ptr->name, data,
strtok schreibt '0' in den Speicher searchstr - data);

15. Schreibeoperationen vermeiden

16. strcpy/strncpy
char tmp[STR_SIZE] = {""};
char tmp2[STR_SIZE] = {""};
len = strchr(map, ':') - map; //UName finden
strncpy(tmp2, map, len); //UName herauskopieren
map += len + 1; //:x: überspringen
map = strchr(map, ':') + 1; //:x: überspringen
len = strchr(map, ':') - map; //UID finden
strncpy(tmp, map, len); //UID herauskopieren
fach = atoi(tmp); //UID konvertieren
strcpy(filecn[fach], tmp2); //in HashTable speichern

17. Gegenüberstellung der Optimierungen
Zyklen

18. Gegenüberstellung der Optimierungen
Speicher

19. Unsere Lösung
Caching / Memoziation der passwd Einträge
Direkter Zugriff auf interne Datenstruktur (Pointer auf einfach
verkettete Listen)
Vermeidung von Schreibzugriffen auf den Speicher
Verwendung eines Pools von Strukturelementen, anstatt
malloc für jedes neue Strukturelement. (Listenerstellung)
Nur Pointeroperation zum Parsen der passwd Datei