Informatica 3. LEZIONE 4: Semantica operazionale. Modulo 1: Strutture a blocchi Modulo 2: Comportamenti dinamici

Transcript

1 Informatica 3 LEZIONE 4: Semantica operazionale Modulo 1: Strutture a blocchi Modulo 2: Comportamenti dinamici

2 Informatica 3 Lezione 4 - Modulo 1 Strutture a blocchi

3 C4: Blocchi annidati int f( ); { int x, y,w; //blocco 1 while (...) { int x, z; // blocco 2 while () {inty; // blocco 3 if () {intx, w; // blocco 4 if () { int a, b, c, d; // blocco 5 Implementazioni possibili: Allocazione statica di un record di attivazione per la routine con blocchi annidati semplice, efficiente in termini di tempo Allocazione dinamica per i dati locali quando si esegue il blocco efficiente in termini di spazio

4 Allocazione statica record di attivazione con overlay puntatore di ritorno link dinamico x in //1 y in //1 w in //1 x in //2 - a in //5 z in //2 - b in // 5 y in //3 - x in //4 - c in //5 w in //4 - d in //5 blocco 3 albero statico degli annidamenti blocco 2 blocco 1 blocco 4 blocco 5

5 Routine annidate int x, y, z; f1 ( ) { //blocco 1 int t, u; f2 ( ) { //blocco 2 int x, w; f3 ( ) { //blocco 3 int y, w, t; //fine blocco 3 x = y + t + w + z; //fine blocco 2 //fine blocco 1 main ( ); { //blocco 4 int z, t; //fine blocco 4 blocco 1 blocco 2 blocco 3 blocco 0 blocco 4 OSSERVAZIONE: Non supportato in C++ Supportato in Pascal, Modula- 2 e Ada

6 Accesso a variabili non locali var globale main f1 f2 f3 f2 CURRENT x,y,z z,t t,u x,w y,w,t x,w x=y+t+w+z link dinamici

7 Accesso a variabili non locali var globale main f1 f2 f3 f2 LINK TATICI x,y,z z,t t,u x,w y,w,t x,w x=y+t+w+z offset RdA 0 punt. di ritorno 1 link dinamico 2 link statico 3 var locali link dinamici CURRENT

8 Accesso a variabili non locali Seguire le catene statiche richiede un sovraccarico a run-time Soluzione: per ogni variabile memorizzare la distanza dal record di attivazione dell unità variabile locale: distanza = 0 variabile nell unità esterna: distanza = 1 variabile nell unità ancora più esterna: distanza = 2... Per ogni variabile si può calcolare staticamente: (distanza, offset) Funzione per calcolare l indirizzo: fp(d)=if d=0 then D[0] else D[fp(d-1)+2] Indirizzo di una variabile: D[fp(distanza) + offset]

9 Semantica della chiamata Chiamata della routine set 1, D[1]+1 set D[1], ip+5 set D[1]+1, D[0] set D[1]+2, fp(d) set 0, D[1] set 1, D[1]+RA jump ind_inizio alloca spazio sullo stack per valore di ritorno imposta il valore del puntatore di ritorno imposta il link dinamico imposta il link statico imposta CURRENT imposta FREE (RA=dimensione record attivaz.) indirizzo prima istruzione del codice invocato

10 Informatica 3 Lezione 4 - Modulo 2 Comportamenti dinamici

11 C5: Allocazione dati dinamica struct nodo{ int num; nodo* succ; ; nodo* n = new nodo; stack heap La vita di una variabile allocata dinamicamente non dipende dall unità in cui la variabile viene dichiarata I dati vengono allocati nello HEAP

12 RdA con dimensione nota a tempo di Es. array dinamici in Ada esecuzione type VECTOR is array (INTEGER range<>); A: VECTOR (1..N); B: VECTOR (1..M); // N e M valori interi noti a tempo di esecuzione Modello semantico: Si riserva un puntatore nel descrittore di ogni array dinamico Gli array vengono allocati (sopra l ultimo RdA) L accesso agli array viene effettuato indirettamente tramite puntatore

13 Typing dinamico Typing dinamico Se il linguaggio utilizza il typing dinamico il tipo della variabile non può essere determinato a tempo di compilazione Il descrittore della variabile deve contenere anche il tipo della variabile Se il tipo può cambiare a tempo di esecuzione la dimensione ed il contenuto del descrittore possono variare il descrittore viene mantenuto nello heap e il RdA conterrà il puntatore al descrittore o all oggetto stesso nello heap

14 Scoping dinamico Scoping dinamico lo scope di un nome dipende dalla catena di chiamate a tempo di esecuzione (catena dinamica) sub2 ( ) { declare x; x ; y ; sub1 ( ) { declare y; x ; y ; sub2 ( ); main ( ) { declare x, y, z; z = 0; x = 5; y = 7; sub1; sub2;

15 Scoping dinamico Scoping dinamico lo scope di un nome dipende dalla catena di chiamate a tempo di esecuzione (catena dinamica) sub2 ( ) { declare x; x ; y ; sub1 ( ) { declare y; x ; y ; sub2 ( ); main ( ) { declare x, y, z; z = 0; x = 5; y = 7; sub1; sub2;

16 Scoping dinamico Scoping dinamico lo scope di un nome dipende dalla catena di chiamate a tempo di esecuzione (catena dinamica) sub2 ( ) { declare x; x ; y ; sub1 ( ) { declare y; x ; y ; sub2 ( ); main ( ) { declare x, y, z; z = 0; x = 5; y = 7; sub1; sub2;

17 Scoping dinamico Scoping dinamico lo scope di un nome dipende dalla catena di chiamate a tempo di esecuzione (catena dinamica) sub2 ( ) { declare x; x ; y ; sub1 ( ) { declare y; x ; y ; sub2 ( ); main ( ) { declare x, y, z; z = 0; x = 5; y = 7; sub1; sub2;

18 Passaggio dei parametri Parametri Dati per riferimento: il chiamante passa all unità chiamata l indirizzo del parametro attuale per copia: i parametri vengono trattati come variabili locali per nome: i nomi dei parametri attuali vengono sostituiti con i nomi dei parametri formali Routine

19 Passaggio per riferimento ambiente unità chiamante chiamata routine parametro attuale ambiente unità chiamata Semantica: azione dell unità chiamante: parametro formale set D[0] + off, fp(d) + o se il param. attuale non è per riferimento set D[0] + off, D[ fp(d) + o ] se il param. attuale è per riferimento accesso al parametro da parte dell unità chiamata: avviene tramite indirizzamento indiretto: D[D[0] + off]

20 Passaggio per copia Passaggio per valore l unità chiamante valuta il parametro attuale --> il suo valore viene utilizzato per inizializzare il parametro formale corrispondente non c è flusso di informazione di ritorno verso l unità chiamante parametro attuale parametro formal Passaggio per risultato flusso di informazioni dal chiamante all unità chiamata al termine del sottoprogramma il valore dei parametri formali viene copiato nei corrispondenti parametri attuali del chiamante Passaggio per valore-risultato flusso di informazione in entrambe le direzioni i parametri formali vengono inizializzati alla chiamata del sottoprogramma e copiati nei parametri attuali al termine del sottoprogramma parametro attuale parametro formal parametro attuale parametro formale

21 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a;

22 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] 10 x y chiamata per riferimento

23 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] 0 x y chiamata per riferimento

24 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] 1 x y chiamata per riferimento

25 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] x y chiamata per copia valore-risultat

26 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] x y chiamata per copia valore-risultat

27 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] x y chiamata per copia valore-risultat

28 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a[i] = a[j] x y chiamata per copia valore-risultat

29 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a 10 x chiamata per riferimento

30 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a 1 x chiamata per riferimento

31 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a 2 x chiamata per riferimento

32 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a x chiamata per copia valore-risultat

33 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a 1 10 x chiamata per copia valore-risultat

34 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a 1 11 x chiamata per copia valore-risultat

35 Passaggio per riferimento vs. per valore-risultato Differiscono quando: due parametri formali diventano alias un parametro formale e una variabile non locale sono alias i = j; a [i] = 10; foo (a[i], a[j]); a = 10; goo (a); foo (x, y) { x = 0; y ++; goo (x) { a = 1; //a non locale e visibile x = x + a; a x chiamata per copia valore-risultat

36 Passaggio per nome Sostituzione testuale di tutte le occorrenze dei parametri formali con i parametri attuali swap (int a,b); int temp; { temp = a; a = b; b = temp; ;

37 Passaggio per nome Sostituzione testuale di tutte le occorrenze dei parametri formali con i parametri attuali swap (int a,b); int temp; { temp = a; a = b; b = temp; ; swap(i, a[i]) swap (int i,a[i]); int temp; { temp = i; i = a[i]; a[i] = temp; ;

38 Passaggio per nome Sostituzione testuale di tutte le occorrenze dei parametri formali con i parametri attuali swap (int a,b); int temp; { temp = a; a = b; b = temp; ; swap(i, a[i]), con i=3 e a[3]=4 swap (int i,a[i]); int temp; { temp = i; i = a[i]; a[i] = temp; ; i=4 e a[4]=3 Costoso da implementare

39 Linguaggi e passaggi parametri Per riferimento Per valore Per nome Fortran X Algol 60 X X Simula 67 X X X Pascal, C++ X X C con puntatori X

40 Routine come parametro 1 int u, v; 2 a ( ) 3 { 4 int y; 5 6 ; 7 b (routine x) 8 { 9 int u, v, y; 10 c ( ) 11 { 12 y = ; ; 15 x ( ); 16 b (c); main ( ) 20 { 21 b(a); 22 ;

41 Routine come parametro 1 int u, v; 2 a ( ) 3 { 4 int y; 5 6 ; 7 b (routine x) 8 { 9 int u, v, y; 10 c ( ) 11 { 12 y = ; ; 15 x ( ); 16 b (c); main ( ) 20 { 21 b(a); 22 ;

42 Routine come parametro 1 int u, v; 2 a ( ) 3 { 4 int y; 5 6 ; 7 b (routine x) 8 { 9 int u, v, y; 10 c ( ) 11 { 12 y = ; ; 15 x ( ); 16 b (c); main ( ) 20 { 21 b(a); 22 ; ambiente globale (u,v) a() (y) b(x) (u,v,y) c() main()

43 Implementazione RdA globale u v a ambiente globale (u,v) a() (y) b() (u,v,y) main() c()

44 Implementazione link statici RdA globale u v a RdA main link dinamici ambiente globale (u,v) a() (y) b() (u,v,y) main() c()

45 Implementazione nk statici RdA globale u v a RdA main RdA b[1] x=a u[b,1] v[b,1] y[b,1] c link dinamici ambiente globale (u,v) a() (y) b() (u,v,y) c() main()

46 Implementazione link statici RdA globale u v a RdA main RdA b[1] x=a u[b,1] v[b,1] y[b,1] c RdA a y[a] link dinamici ambiente globale (u,v) a() (y) b() (u,v,y) c() main()

47 Implementazione nk statici RdA globale u v a RdA main RdA b[1] x=a u[b,1] v[b,1] y[b,1] c link dinamici ambiente globale (u,v) a() (y) b() (u,v,y) c() main()

48 Implementazione (2) nk statici RdA globale u v a RdA main RdA b[1] x=a u[b,1] v[b,1] y[b,1] c RdA b[2] x=c u[b,2] v[b,2] y[b,2] c link dinamici ambiente globale (u,v) a() (y) b() (u,v,y) c() main()

49 Implementazione (2) nk statici RdA globale u v a RdA main RdA b[1] x=a u[b,1] v[b,1] y[b,1] c RdA b[2] x=c u[b,2] v[b,2] y[b,2] c RdA c link dinamici ambiente globale (u,v) a() (y) b() (u,v,y) c() main()