C für Fortgeschri/ene 2 Dynamische Speicherverwaltung Programmprüfung und Debugging. Benedikt Huber

Transkript

1 C für Fortgeschri/ene 2 Dynamische Speicherverwaltung Programmprüfung und Debugging Benedikt Huber (benedikt@vmars.tuwien.ac.at) SS

2 Dynamische Speicherverwaltung Christian El Salloum SS

3 Speicherverwaltung in C Stack main () f () printf () Statisch allozierte Variablen Feste Adresse, statisch bekannter Speicherplatzbedarf Am Stack allozierte, lokale Variablen Statisch bekannte Speicherplatzbedarf (ANSI C) Noch nicht betrachtet Speicherplatz dynamischer Größe Dynamisch angeforderter Speicher, dessen Lebensdauer nicht an Anweisungsblöcke gebunden ist Global Dynamic (Heap) Global Static Text (Code)

4 Wiederholung Statisch allozierte Variablen Definition: Außerhalb von Funktionen... oder innerhalb mit Schlüsselwort static Statisch bekannter Speicherplatzbedarf uint8_t dat[8 * sizeof(frame_t)]; static char buf[] = "0x0000"; char *msg = "segfault"; Adresse stets gültig Initialisiert (implizit oder explizit)

5 Wiederholung Lokale Variablen Definition: zu Beginn eines Anweisungsblocks Speicherplatzbedarf statisch bekannt (ANSI C) Ausnahme: Arrays variabler Größe (C99) Ausnahme: Mit alloca() angeforderter Speicher Keine Default-Initialisierung Freigabe des Speichers beim Verlassen des Blocks Adresse verliert Gültigkeit

6 Wiederholung Adressen lokaler Variablen int*f(){ int x=2; int *y = &x; } return y; /* Fehler */ int g() { int *z = f(); }? SP Wert x 2 y Addr(x) z SP Wert?? z Addr(x)

7 Dynamisch angeforderter Speicher Beispiel Einlesen genau einer Zeile einer Textdatei Zeilenlänge prinzipiell unbeschränkt Memory Allocators Anfordern von Speicher beliebiger Größe malloc(3) Freigeben zuvor angeforderten Speichers free(3) Ändern der Größe angeforderten Speichers realloc(3) Betriebssystemunabhängige API Keine automatische Speicherverwaltung

8 Dynamische Speicheranforderung void *malloc(size_t size) Alloziert size bytes zusammenhängenden Speichers Rückgabewert: Startadresse des Speicherbereichs Adresse identifiziert Speicherbereich (free) Beispiele int *x = malloc(sizeof(*x)); int *x = malloc(sizeof(int) * ARRAYSIZE); Speicher nicht initialisiert man 3 calloc

9 Freigabe angeforderten Speichers void free(void* allocatedmemory) free erwartet gültige Adresse von malloc,realloc,etc. zurückgegeben zwischenzeitlich nicht freigegeben Achtung! Nach der Freigabe mittels free darf der Speicherbereich nicht mehr verwendet werden D.h.: Pointer, die in den Speicherbereich zeigen, dürfen nicht mehr dereferenziert werden

10 Ändern der Größe eines Speicherbereichs void* realloc(void* ptr, size_t size) Ändert die Größe des durch ptr identifizierten Speicherbereichs Daten wenn notwendig kopiert, nach realloc ist i.a. zurückgegebener Pointer zu verwenden Achtung Bestehende Pointer auf alte Adresse werden ungültig Im Fehlerfall (NULL retourniert) bleibt alte Adresse gültig

11 Beispiel Beispiel: Einfacher Stack #define BLOCKSIZE 16 typedef struct { unsigned capacity; char *begin; char *top; } cstack_t; void stack_init (cstack_t* s); void stack_push (cstack_t* s, char c); void stack_cleanup (cstack_t* s);

12 Beispiel slot 0 malloc void stack_init (cstack_t* s) { s->capacity = BLOCKSIZE; capacity = 16 s->begin = malloc(blocksize * sizeof(char)); begin top slot 1 slot 2... slot 13 slot 14 slot 15 if(s->begin == NULL) bail( malloc failed ); } s->top = s->begin;

13 Beispiel realloc void stack_push (cstack_t* s, char c) { s->top = s->top + 1; /* Grow stack if neccessary */ slot 0 } *s->top = c; capacity = 16 begin top slot 1 slot 2... slot 13 slot 14 slot 15 s->begin + capacity

14 Beispiel slot 0 realloc s->top = s->top + 1; capacity = 32 begin top slot 1 slot 2... slot 15 slot if(s->top == s->begin + s->capacity) { char *newstack; slot 30 slot 31 s->capacity += BLOCKSIZE; newstack = realloc(s->begin, s->capacity * sizeof(char));

15 Beispiel slot 0 realloc } if(newstack == NULL) { free(s->begin); bail( realloc failed ); } s->top = newstack + (s->top s->begin); s->begin = newstack; capacity = 32 begin top slot 1 slot 2... slot 15 slot slot 30 slot 31

16 Beispiel free void stack_cleanup (cstack_t* s) { if(s->begin!= NULL) { } free(s->begin); } /* Stack MUST not be used anymore! */

17 Bonusmaterial malloc Bibliothek malloc/free Bibliothek (z.b. libc) verwaltet vom Betriebssystem angeforderte Speicherblöcke Online Algorithmus (keine Annahmen über zukünftige Allokationen möglich) Beispiel: Doug Lea s malloc 128 Bins : Schnelle Allokation für kleine Blöcke, Suche für größere Blöcke Meta-Information in Boundary Tag neben dem allozierten Speicherblock 1 Anforderung neuen Speichers mit mmap(2) und sbrk(2) 1 siehe auch: h/p://phrack.org/issues.html?issue=57&id=8

18 Bonusmaterial alloca Dynamische Speicheranforderung am Stack man 3 alloca Auch: Arrays variabler Größe (C99) Vor- und Nachteile Automatische Gültigkeitsdauer + Freigabe Stackallokation häufig performanter Unbekannte / variable maximale Stackgröße Keine Fehlermeldung bei fehlgeschlagener Anforderung (z.b. Segmentation Fault) Nicht ANSI C konform (nicht in Übung)

19 Dynamischer Speicher in C malloc / free: Portabel & Flexibel Aber: Sehr fehleranfällig! Verwenden bereits freigegebenen Speichers Doppelte Freigabe Memory Leak: Speicher wird nicht (rechtzeitig) freigegeben Programmanalyse, Debugging

20 Programmanalyse und Debugging Christian El Salloum SS

21 Programmanalyse und Debugging Statische Analyse (Inspektion des Programms) Am Source Code oder Binärdatei z.b.: -Wall, splint, Model Checking (CBMC) Dynamische Analyse (Automatische Inspektion des Programmablaufs) Instrumentiertes Programm z.b.: valgrind Debugging (manuelle Inspektion des Programmablaufs)

22 Statische Analysetools: splint Analysiert Source Code des Programms Erkennt viele (aber nicht alle) typische Fehler Fehlervorbeugung Warnung bei fehleranfälligen Konstrukten Strengere Typregel Fehlererkennung Verwendung uninitialisierten Speichers Verwendung ungültiger Adressen (NULL)

23 Beispiel Beispielprogramm #include <stdlib.h> #include <stdio.h> int** f() { } int *x = malloc(sizeof(*x)); int **y = malloc(sizeof(*y)); *y = x; *y = NULL; return y; int main(int argc, char**argv) { } if(argc!= 1) return 1; int**mem = f(); if(*mem) free(*mem); free(mem);

24 Beispiel splint Analyse #include <stdlib.h> #include <stdio.h> int** f() { } int *x = malloc(sizeof(*x)); int **y = malloc(sizeof(*y)); *y = x; *y = NULL; return y; int main(int argc, char**argv) { } if(argc!= 1) return 1; int**mem = f(); if(*mem) free(*mem); free(mem); example.c:6:4: Dereference of possibly null pointer y example.c:7:3: Owned storage *y (type int *) not released before assignment: *y = NULL

25 Dynamische Analyse: valgrind Während der Programmausführung werden zusätzliche Informationen gesammelt Qualität hängt daher auch von Testläufen ab Beispiel: valgrind Framework zur Instrumentierung von Programmen Simuliert parallel zum Programm ein Modell zur Fehlererkennung memcheck: valgrind Modul um Fehler in der dynamischen Speicherverwaltung zu finden

26 Beispiel valgrind #include <stdlib.h> #include <stdio.h> int** f() { int *x = malloc(sizeof(*x)); int **y = malloc(sizeof(*y)); *y = x; *y = NULL; return y; } valgrind./example int main(int 4 bytes argc, in char**argv) 1 blocks are { definitely lost if(argc ==1902==!= 1) return at 1; 0x4024F20: malloc int**mem ==1902== = f(); by 0x : f (example.c:4) if(*mem) ==1902== free(*mem); by 0x804846E: main (example.c:11) free(mem); }

27 Beispiel valgrind #include <stdlib.h> #include <stdio.h> int** Achtung: f() { int valgrind *x = malloc(sizeof(*x));./example somearg int **y Kein = Memory malloc(sizeof(*y)); Leak in Testlauf *y = x; Daher Problem nicht erkannt } *y = NULL; return y; int main(int argc, char**argv) { } if(argc!= 1) return 1; int**mem = f(); if(*mem) free(*mem); free(mem);

28 splint&valgrind: Weitere Informationen splint Annotationen Spezielle Kommentare um Treffsicherheit der Analyse zu erhöhen Weitere valgrind Module Helgrind: Fehlererkennung bei Verwendung von Threads Module zur Programmoptimierung Ausprobieren! 1 1 Primer: h/p://wiki.vmars.tuwien.ac.at/

29 Debugging Christian El Salloum SS

30 Debugging Finden und Beheben der Ursache eines bekannten Programmfehlers Manuell Debugnachrichten Zusätzliche Überprüfungen Mit Hilfe eines Debuggers Anhalten und Inspektion des laufenden Prozesses

31 Debugnachrichten Bedingtes Kompilieren gcc g DDEBUG Im Normalfall keine DEBUG Nachrichten #ifdef DEBUG #define DBGMSG(str) do{ \ fprintf(stderr, "%s\n", str) \ } while(0) #else #define DBGMSG(str) /* Do not generate code */ #endif

32 Debugnachrichten: Vordefinierte Makros printf("[%s,%s]%s:%d, in %s(): %s\n", DATE, TIME, FILE, LINE, FUNCTION, My Message"); [Mar , 21:55:31] macros.c:4, in main(): My Message

33 Debugging Tools Am laufenden Prozess Aufgaben des Debuggers: Anhalten des Prozesses an bestimmten Punkten Inspektion des Speichers und der Prozessorregister Manipulation der CPU Register und des Arbeitsspeichers

34 GDB: The GNU Project Debugger Vorbereitung und Starten gcc Option g (Symbole) gdb myprogram Optimierungen verkomplizieren Debugging Eliminierte Variablen Strukturelle Änderungen (z.b. Vertauschen von Schleifen) Achtung: u.u. treten Fehler nur in optimierter Version auf

35 Breakpoints Punkte im Programm, an denen Ausführung unterbrochen werden soll Realisierung in HW (CPU Unterstützung) oder SW (Modifikation des Programmcodes) Spezifikation Adresse des Programmcounters Funktion Zeilennummer (Achtung: Optimierungen!)

36 GDB Basics Ausführen des Programms und Breakpoints break main run file1.txt file2.txt break mycat.c:23 continue next / step nexti/ / stepi until / until mycat.c:24

37 Inspektion des Prozesses print Eingabe Ergebnis print argc $1 = 1 print argv[0] print/x &argc $2 = hello print *((int*)0xbffff2b0) $4 = 1 $3 = 0xbffff2b0 display ~ Ausgabe bei jeder Unterbrechung Modifikation des Speichers mit print p (var = 0)

38 Watchpoints Unterbricht Ausführung wenn sich Variable ändert Realisierung in HW (bis 16 Bytes auf x86) Oder in SW (langsam single stepping) GDB watch myvar Anwendungbereiche Beobachtung einer bestimmten Variable über einen längeren Zeitraum Falls unbekannt, wann sich Variable ändert

39 GDB und Signale Als breakpoint konfigurierbar SIGINT Kontrolle an Debugger Schwerwiegende Fehler: SIGSEGV Signale können selektiv an Programm weitergegeben werden info signals handle SIGUSR1 nostop print pass

40 GDB Demo Sessions Christian El Salloum SS

41 DEMO: Programm /* GDB demo */ void print_avg(char *fn) { int64_t count, sum = 0; char line[linesize]; /* line buffer */ FILE *istream; /* input stream */ } istream = fopen(fn, "r"); while(fgets(line,linesize,istream)!= NULL) { ++count; sum =+ strtol(line,null,10); } printf("avg: %.2f\n",((double)sum)/count);

42 Zusammenfassung Dynamische Speicherverwaltung malloc / free /realloc Fallstricke Fehlersuche Programmanalyse Debugging: GDB Weitere Informationen Webpage von splint, valgrind, gdb

43 ENDE Danke für die Aufmerksamkeit!