Gestione della memoria

Transcript

1 Corso di Fondamenti di Informatica Ingegneria delle Comunicazioni BCOR Ingegneria Elettronica BELR Domenico Daniele Bloisi

2 Docenti Parte I prof. Silvio Salza salza@dis.uniroma1.it Parte II ing. Domenico Daniele Bloisi bloisi@dis.uniroma1.it Nota: %7E corrisponde alla tilde ~ Pagina 2

3 Informazioni Generali ing. Domenico Daniele Bloisi, PhD Dipartimento di Informatica e Sistemistica Via Ariosto 25 (adiacente Piazza Dante, A fermate Manzoni, Vittorio Emanuele, Tram 3 fermata via Labicana) mailto:bloisi@dis.uniroma1.it Pagina 3

4 Ricevimento Martedì DIS, via Ariosto 25 Aula docenti adiacente aula A4 Si consiglia di inviare una per conferma e di controllare la bacheca degli avvisi Pagina 4

5 Sommario Definizione di funzioni Passaggio dei parametri Esecuzione di una funzione Variabili dichiarate in una funzione: scope Organizzazione di un programma Domini definiti induttivamente Ricorsione e funzioni ricorsive a run-time Ricorsione multipla Pagina 5

6 a run-time (1/2) A tempo di esecuzione, il sistema operativo deve gestire diverse zone di memoria: zona che contiene il codice eseguibile del programma determinata a tempo di esecuzione al momento del caricamento del codice dimensione fissata per ogni funzione a tempo di compilazione heap: zona di memoria che contiene le variabili allocate dinamicamente cresce e decresce dinamicamente durante l esecuzione ogni variabile viene allocata e deallocata indipendentemente dalle altre Pagina 6

7 a run-time (2/2) stack o pila dei record di attivazione: zona di memoria per i dati locali alle funzioni (variabili e parametri) cresce e descresce dinamicamente durante l esecuzione viene gestita con un meccanismo a pila Pagina 7

8 Pila dei record di attivazione Una pila (o stack) è una struttura dati con accesso LIFO Last In First Out = l ultimo entrato è il primo a uscire (Esempio: pila di piatti). A run-time il sistema operativo gestisce la pila dei record di attivazione (RDA): per ogni attivazione di funzione viene creato un nuovo RDA in cima alla pila; al termine dell attivazione della funzione il RDA viene rimosso dalla pila. Pagina 8

9 Record di attivazione Un RDA tiene traccia PF v1 VL v2 VR v3 IR v4 delle locazioni di memoria per i parametri formali (se presenti); delle locazioni di memoria per le variabili locali (se presenti); del valore di ritorno dell invocazione della funzione (se la funzione ha tipo di ritorno diverso da void); della locazione di memoria per l indirizzo di ritorno, ovvero l indirizzo della prossima istruzione da eseguire nella funzione chiamante. Pagina 9

10 Esempio di evoluzione della pila dei record di attivazione int B(int pb) { /* b0 */ printf("in B. Parametro pb = %d\n", pb); /* b1 */ return pb+1; } int A(int pa) { /* a0 */ printf("in A. Parametro pa = %d\n", pa); /* a1 */ printf("chiamata di B(%d).\n", pa * 2 ); /* a2 */ int va = B(pa * 2); /* a3 */ printf("di nuovo in A. va = %d\n", va); /* a4 */ return va + pa; } Pagina 10

11 Esempio di evoluzione della pila dei record di attivazione int main() { /* m0 */ printf("in main.\n"); /* m1 */ int vm = 22; /* m2 */ printf("chiamata di A(%d).\n", vm); /* m3 */ vm = A(vm); /* m4 */ printf("di nuovo in main. vm = %d\n", vm); /* m5 */ return 0; } Pagina 11

12 Output prodotto dal programma In main. Chiamata di A(22). In A. Parametro pa = 22 Chiamata di B(44). In B. Parametro pb = 44 Di nuovo in A. va = 45 Di nuovo in main. vm = 67 Pagina 12

13 Program counter Per comprendere cosa avviene durante l esecuzione del codice, è necessario fare riferimento, oltre che alla pila dei RDA, al program counter (PC), il cui valore è l indirizzo della prossima istruzione da eseguire. Si assuma che m0 abbia indirizzo 100 a0 abbia indirizzo 200 b0 abbia indirizzo 300 Pagina 13

14 Evoluzione della pila dei RDA Figura 5.1 Pagina 14

15 Evoluzione della pila dei RDA: individuazione e chiamata di A Prima dell attivazione di A(vm), la pila dei RDA è come mostrato in 1 nella Fig. 5.1: 1. vengono valutati i parametri attuali: in questo caso il parametro attuale è l espressione vm che ha come valore l intero 22; 2. viene individuata la funzione da eseguire in base al numero e tipo dei parametri attuali, cercando la definizione di una funzione la cui segnatura sia conforme alla invocazione: nel nostro caso la funzione da eseguire deve avere la segnatura A(int); 3. viene sospesa l esecuzione della funzione chiamante: nel nostro caso la funzione main; Pagina 15

16 Evoluzione della pila dei RDA: creazione del record di A 4. viene creato il RDA relativo all attivazione corrente della funzione chiamata: nel nostro caso viene creato il RDA relativo all attivazione corrente di A; il RDA contiene: le locazioni di memoria per i parametri formali: nel nostro caso, il parametro pa di tipo int; le locazioni di memoria per le variabili locali: nel nostro caso, la variabile va di tipo int; una locazione di memoria per il valore di ritorno: nel nostro caso indicata con VR; una locazione di memoria per l indirizzo di ritorno: nel nostro caso indicata con IR; 5. viene assegnato il valore dei parametri attuali ai parametri formali: nel nostro caso, il parametro formale pa viene inizializzato con il valore 22; Pagina 16

17 Evoluzione della pila dei RDA: modifica valore del PC 6. l indirizzo di ritorno nel RDA viene impostato all indirizzo della prossima istruzione che deve essere eseguita nella funzione chiamante al termine dell invocazione: nel nostro caso, l indirizzo di ritorno nel RDA relativo all attivazione di A viene impostato al valore 104, che è l indirizzo dell istruzione di main corrispondente all istruzione m4, da eseguire quando l attivazione di A sarà terminata; a questo punto, la pila dei RDA è come mostrato in 2 nella Fig. 5.1; 7. al program counter viene assegnato l indirizzo della prima istruzione della funzione invocata: nel nostro caso, al program counter viene assegnato l indirizzo 200, che è l indirizzo della prima istruzione di A; Pagina 17

18 Evoluzione della pila dei RDA: esecuzione di A 8. si passa ad eseguire la prossima istruzione indicata dal program counter, che sarà la prima istruzione della funzione invocata: nel nostro caso l istruzione di indirizzo 200, ovvero la prima istruzione di A. Dopo questi passi, le istruzioni della funzione chiamata, nel nostro caso di A, vengono eseguite in sequenza. In particolare, avverrà l attivazione, l esecuzione e la terminazione di eventuali funzioni a loro volta invocate nella funzione chiamata. Nel nostro caso, avverrà l attivazione, l esecuzione e la terminazione della funzione B, con un meccanismo analogo a quello adottato per A; la pila dei RDA passerà attraverso gli stati 3 e 4. Pagina 18

19 Evoluzione della pila dei RDA: terminazione di A Analizziamo ora in dettaglio cosa avviene al momento della terminazione dell attivazione di A, cioè quando viene eseguita l istruzione return va+pa; Prima dell esecuzione, la pila dei RDA è come mostrato in 4 nella Fig. 5.1 (in realtà, la zona di memoria predisposta a contenere il valore di ritorno, indicata con VR nella figura, viene inizializzata contestualmente all esecuzione dell istruzione return, e non prima). Pagina 19

20 Evoluzione della pila dei RDA: valore di ritorno 1. al program counter viene assegnato il valore memorizzato nella locazione di memoria riservata all indirizzo di ritorno nel RDA corrente: nel nostro caso, tale valore è pari a 104, che è proprio l indirizzo, memorizzato in IR, della prossima istruzione di main che dovrà essere eseguita; 2. nel caso la funzione invocata preveda la restituzione di un valore di ritorno, tale valore viene memorizzato in un apposita locazione di memoria del RDA corrente: nel nostro caso, il valore 67, risultato della valutazione dell espressione va+pa viene assegnato alla locazione di memoria indicata con VR, predisposta per contenere il valore di ritorno; Pagina 20

21 Evoluzione della pila dei RDA: eliminazione del record 3. viene eliminato dalla pila dei RDA il RDA relativo all attivazione corrente, e il RDA corrente diviene quello immediatamente precedente nella pila; contestualmente all eliminazione del RDA dalla pila dei RDA, un eventuale valore di ritorno viene copiato in una locazione di memoria del RDA del chiamante: nel nostro caso, viene eliminato il RDA relativo all attivazione di A e il RDA corrente diviene quello relativo all attivazione di main; inoltre, il valore 67, memorizzato nella locazione di memoria VR viene assegnato alla variabile vm nel RDA di main; la pila dei RDA è come mostrato in 5 nella Fig. 5.1; Pagina 21

22 Evoluzione della pila dei RDA: prossima istruzione nel PC 4. si passa ad eseguire la prossima istruzione indicata dal program counter, cioè quella appena impostata al passo 1: nel nostro caso, si passa ad eseguire l istruzione di indirizzo 104, che fa riprendere l esecuzione di main. Pagina 22

23 Evoluzione della pila dei RDA nel caso di funzioni ricorsive Nel caso di funzioni ricorsive, i meccanismi con cui evolvono la pila dei RDA ed il program counter sono identici al caso di funzioni non ricorsive. Importante: un RDA è associato ad un attivazione di una funzione e non ad una funzione. Pagina 23

24 Esempio void ricorsivo(int i) { /*r1*/ printf("in ricorsivo(%d)", i); /*r2*/ if (i == 0) /*r3*/ printf(" - Finito\n"); /*r4*/ else { /*r5*/ printf(" - Attivazione " "di ricorsivo(%d)\n", (i-1)); /*r6*/ ricorsivo(i-1); /*r7*/ printf("di nuovo in ricorsivo(%d)", i); /*r8*/ printf(" - Finito\n"); /*r9*/ } /*r10*/ return; } Pagina 24

25 Esempio int main() { /* m0 */ int j; /* m1 */ scanf("%d", &j); /* m2 */ printf("in main"); /* m3 */ printf(" - Attivazione di " "ricorsivo(%d)\n", j); /* m4 */ ricorsivo(j); /* m5 */ printf("di nuovo in main"); /* m6 */ printf(" - Finito\n"); } Pagina 25

26 Output con input 2 In main - Attivazione di ricorsivo(2) In ricorsivo(2) - Attivazione di ricorsivo(1) In ricorsivo(1) - Attivazione di ricorsivo(0) In ricorsivo(0) - Finito Di nuovo in ricorsivo(1) - Finito Di nuovo in ricorsivo(2) - Finito Di nuovo in main - Finito Pagina 26

27 Evoluzione della pila dei RDA Si assuma che m0 abbia indirizzo 100 r0 abbia indirizzo 200 i 0 IR 207 i 1 IR 207 i 1 IR 207 i 1 IR 207 i 2 i 2 IR 105 IR 105 i 2 IR 105 i 2 IR 105 i 2 IR 105 j 2 j 2 j 2 j 2 j 2 j 2 j 2 Pagina 27

28 Evoluzione della pila dei RDA: tipo di ritorno void 105 è l indirizzo dell istruzione che segue l attivazione di ricorsivo(j) in main, mentre 207 è l indirizzo dell istruzione che segue l attivazione di ricorsivo(i-1) in ricorsivo. Dal momento che le funzioni invocate non prevedono la restituzione di un valore di ritorno (il tipo di ritorno è void), i RDA non contengono una locazione di memoria per tale valore. Inoltre, non abbiamo indicato la funzione alla quale si riferisce ciascun RDA, in quanto il RDA in fondo alla pila è relativo a main, e tutti gli altri sono relativi ad attivazioni successive di ricorsivo. Pagina 28

29 Evoluzione della pila dei RDA: IR per attivazioni ricorsive Per le diverse attivazioni ricorsive vengono creati diversi RDA sulla pila, con valori via via decrescenti del parametro i, fino all ultima attivazione ricorsiva, per la quale il parametro i assume valore 0. A questo punto non avviene più un attivazione ricorsiva, viene stampato " - Finito", e l attivazione termina. In cascata, avviene l uscita dalle attivazioni precedenti, ogni volta preceduta dalla stampa di "Di nuovo in ricorsivo(i ) - Finito". L indirizzo di ritorno memorizzato nei RDA per le diverse attivazioni ricorsive è sempre lo stesso, tranne che per la prima attivazione. Pagina 29

30 Ricorsione multipla Si ha ricorsione multipla quando un attivazione di una funzione può causare più di una attivazione ricorsiva della stessa funzione. Esempio: funzione ricorsiva per il calcolo dell n-esimo numero di Fibonacci. F(0), F(1), F(2),... è detta sequenza dei numeri di Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21,... Pagina 30

31 Fibonacci int fibonacci(int n) { if (n < 0) return -1; // F(n) non e definito per n negativo! if (n == 0) return 0; else if (n == 1) return 1; else return fibonacci(n-1) + fibonacci(n-2); } Pagina 31

32 Esempio: Torri di Hanoi Il problema delle Torri di Hanoi ha origine da una leggenda secondo la quale in un tempio vietnamita alcuni monaci sono costantemente impegnati a spostare su tre colonne di diamante 64 dischi d'oro secondo delle precise regole. La leggenda narra che quando i monaci completeranno il lavoro, il mondo finirà. Pagina 32

33 Regole: Torri di Hanoi Lo spostamento della torre di dischi avviene secondo le seguenti regole: inizialmente, la torre di dischi di dimensione decrescente è posizionata su un perno 1; l obiettivo è quello di spostarla su un perno 2, usando un perno 3 di appoggio; le condizioni per effettuare gli spostamenti sono: tutti i dischi, tranne quello spostato, devono stare su una delle torri è possibile spostare un solo disco alla volta, dalla cima di una torre alla cima di un altra torre; un disco non può mai stare su un disco più piccolo. Pagina 33

34 Esempio: Torri di Hanoi 6 dischi stato iniziale stato intermedio stato finale Pagina 34

35 Formulazione ricorsiva Per spostare n > 1 dischi da 1 a 2, usando 3 come appoggio: 1. sposta n 1 dischi da 1 a 3 2. sposta l n-esimo disco da 1 a 2 3. sposta n 1 dischi da 3 a 2 Pagina 35

36 Implementazione tramite ricorsione multipla void muoviundisco(int sorg, int dest) { printf("muovi un disco da %d a %d\n", sorg, dest); } void muovi(int n, int sorg, int dest, int aux) { if (n == 1) muoviundisco(sorg, dest); else { muovi(n-1, sorg, aux, dest); muoviundisco(sorg, dest); muovi(n-1, aux, dest, sorg); } } Pagina 36

37 Implementazione tramite ricorsione multipla int main () { int n; printf("quanti dischi vuoi muovere?\n"); scanf("%d", &n); printf("per muovere %d" " dischi da 1 a 2 con 3 come appoggio:\n", n); muovi(n, 1, 2, 3); } Pagina 37

38 Esecuzione Pagina 38

39 Numero di attivazioni nel caso di ricorsione multipla Quando si usa la ricorsione multipla, bisogna tenere presente che il numero di attivazioni ricorsive potrebbe essere esponenziale nella profondità delle chiamate ricorsive (cioè nell altezza massima della pila dei RDA). Pagina 39

40 Esempio: Torri di Hanoi Nota: nel caso del problema delle Torri di Hanoi il numero esponenziale di attivazioni è una caratteristica intrinseca del problema, nel senso che non esiste una soluzione migliore. Pagina 40

41 Esercizi Esercizio 5.5 Modificare l implementazione ricorsiva della funzione fibonacci in modo che, invocata sull intero n, restituisca, oltre al valore dell n-esimo numero di Fibonacci, anche il numero complessivo di attivazioni ricorsive di fibonacci effettuate per il calcolo. Esercizio 5.6 Verificare se esiste la possibilità di una chiamata ricorsiva alla funzione main. In caso affermativo, scrivere un programma che chiami n > 1 volte la funzione main stampando di volta in volta il numero dell attivazione corrente. Pagina 41