SlideShare una empresa de Scribd logo
1 de 42
Descargar para leer sin conexión
Parte 1




               Gestione della memoria




Linguaggi dinamici – A.A. 2009/2010
                                        1
Introduzione
T   Ciascun linguaggio di programmazione mette a
    disposizione meccanismi per la gestione della
    memoria (principale)
T   Funzionalità ad alto livello di un gestore della
    memoria:
      T   Allocazione di risorse
          All    i         i
      T   Rilascio di risorse




Linguaggi dinamici – A.A. 2009/2010
                                                       2
Due diverse filosofie
T   C: la gestione della memoria è troppo
    importante per questo va lasciata al
    programmatore
T   Smalltalk: la gestione della memoria è troppo
    importante per questo va lasciata al sistema




Linguaggi dinamici – A.A. 2009/2010
                                                    3
Gestione manuale della memoria
T   Nei linguaggi di “vecchio stampo”, sono
    messe a disposizione del programmatore le
    funzioni di allocazione e deallocazione della
    memoria, c e usa o le p
      e o a, che usano e primitive de s ste a
                                 t e del sistema
    operativo sottostante
      T   C: malloc(), free()
T   La gestione della memoria è interamente
    lasciata al programmatore
      T   Gestione eccezionalmente veloce
      T   Gestione eccezionalmente soggetta ad errori di
          G ti            i  l   t       tt d       i
          violazione di segmento

Linguaggi dinamici – A.A. 2009/2010
                                                           4
Gestione manuale della memoria
T   Schema di gestione manuale della memoria
      <Acquisizione della memoria>
      T


    T <Uso della memoria>


    T <Rilascio della memoria>


T  Esempio (C):
ptr = malloc(size);
<uso di memoria tramite ptr, *ptr>;
  uso                         ptr ;
free(ptr);




Linguaggi dinamici – A.A. 2009/2010
                                               5
Gestione manuale della memoria
T   Vantaggi:
      T   La velocità delle operazioni di gestione è elevata (in
          sostanza, è quella del kernel sottostante)
      T   I pattern di acquisizione/rilascio sono espliciti
T   Svantaggi:
      T   Onere di programmazione non indifferente, legato
          O                     i        i diff   t l     t
          all'uso della memoria
          (aritmetica dei puntatori : segmentation fault,
                                                   fault
          puntatore a memoria liberata : dangling reference)
      T   Gestione manuale non scala con le dimensioni del
          programma (è molto facile dimenticarsi qualche
          free() : memory leak)

Linguaggi dinamici – A.A. 2009/2010
                                                                   6
Gestione automatica della memoria
T   Nei linguaggi più moderni, una macchina
    virtuale fornisce l'astrazione portabile di un
                      l astrazione
    calcolatore
T   La macchina virtuale implementa il proprio
    gestore della memoria, che svolge le
    operazioni di allocazione e deallocazione in
    maniera automatica, a tempo di esecuzione
T   Non esiste più il concetto di allocazione
    N       i t iù           tt     ll    i
    dinamica della memoria
T   Il programmatore deve solo preoccuparsi di
    dichiarare ed utilizzare variabili semplici o
    complesse, mutevoli in tipo e dimensione
Linguaggi dinamici – A.A. 2009/2010
                                                     7
Gestione automatica della memoria
T   Schema di gestione automatica della memoria
     Dichiarazione di una variabile (semplice o
      T

     complessa)
   T <U
     <Uso d ll variabile>
           della   i bil >
T Esempio (Perl):
my @array = ();
push @array, 10;
push @array, “ciao”;




Linguaggi dinamici – A.A. 2009/2010
                                                  8
Gestione automatica della memoria
T   Vantaggi:
      T   L uso
          L'uso della memoria occupata dalle strutture dati è
          controllato dall'interprete (assenza di violazioni di
          segmento)
      T   La memoria viene prenotata quando serve
          (
          (dichiarazione di una variabile) e rilasciata quando
                                          )             q
          non serve più (uscita da un blocco di codice) (è
          molto più difficile avere memory leak)
T   Svantaggi:
      T   La velocità delle operazioni di gestione è molto
                             p             g
          bassa (interviene l'interprete)
      T   I pattern di acquisizione/rilascio non sono espliciti

Linguaggi dinamici – A.A. 2009/2010
                                                                  9
Parte 1




                      Garbage Collection
                           g




Linguaggi dinamici – A.A. 2009/2010
                                           10
Definizione
T   La garbage collection è una forma di gestione
    automatica della memoria
      T   John McCarthy, LISP, 1959
T   Un
    U modulo software appartenente al run time
          d l    ft            t    t l      ti
    environment, detto garbage collector, si
    preoccupa di effettuare (più o meno
                  ff tt     ( iù
    periodicamente) le seguenti operazioni:
      T   Individua variabili, strutture dati, oggetti che
          sono usciti dallo scope attuale del programma e
          non potranno mai più essere referenziati
                  t         i iù            f     i ti
          dall'applicazione
      T   Rilascia l memoria relativa a tali entità
          Ril    i la        i    l ti    t li tità
Linguaggi dinamici – A.A. 2009/2010
                                                             11
Uso
T   Linguaggi con un garbage collector
      T   Java, C#, Smalltalk, Lisp,
          Java C# Smalltalk Lisp Haskell
      T   Python, Ruby, Lua, Tcl
      T   Delphi (dynamic array, long string, variant,
          interface)
T   Linguaggi nati con una gestione manuale,
    estendibili con un garbage collector:
      T   C, C++ (Boehm Garbage Collector)
T   Linguaggi che fanno uso di tecniche
    dinamiche alternative alla garbage collection:
      T   Perl,
          Perl PHP
Linguaggi dinamici – A.A. 2009/2010
                                                         12
Tracing Garbage Collector
                  g      g




Linguaggi dinamici – A.A. 2009/2010
                                        13
Introduzione
T   La stragrande maggioranza dei garbage
    collector segue una strategia detta tracing
    garbage collection
T   Un tracing garbage collector esegue il
    seguente flusso di operazioni
      1)Determina quali oggetti sono raggiungibili (
      1)D t     i        li      tti            i  ibili (o
        potenzialmente tali)
      2)Scarta tutti gli altri oggetti (rilasciandone la
      2)S    t t tti li lt i         tti ( il i d      l
        relativa memoria)
T   Per
    P oggetto si intende un qualunque tipo di
                   ii    d        l         i
    entità richiedente memoria principale (numero,
    struttura d ti complessa, istanza di classe)
     t tt     dati      l     i t         l    )
Linguaggi dinamici – A.A. 2009/2010
                                                              14
Raggiungibilità di un oggetto
T   Un oggetto è detto raggiungibile se esiste una
    variabile che lo referenzia
      T   Il riferimento può essere diretto (una variabile
          contiene l'oggetto)
                     l oggetto)
      T   Il riferimento può essere indiretto (una variabile
          contiene un “puntatore” all'oggetto)
                         puntatore all oggetto)




Linguaggi dinamici – A.A. 2009/2010
                                                               15
Raggiungibilità di un oggetto
T   In altre parole, in un dato istante temporale, un
    oggetto può essere raggiungibile solamente
    nei seguenti due modi
T   Raggiungibilità diretta
      T   Alcuni oggetti (detti radice) si assume siano
          raggiungibili
           T Tutti gli oggetti dello stack frame corrente

             (variabili locali parametri della funzione
                        locali,
             correntemente in esecuzione)
           T Tutte le variabili globali




Linguaggi dinamici – A.A. 2009/2010
                                                            16
Raggiungibilità di un oggetto
T   In altre parole, in un dato istante temporale, un
    oggetto può essere raggiungibile solamente
    nei seguenti due modi
T   Raggiungibilità indiretta
      T   Ogni oggetto riferito da un oggetto
          raggiungibile direttamente è a sua volta un
                                      è,      volta,
          oggetto raggiungibile
      T   La raggiungiblità è pertanto una chiusura
                            è, pertanto,
          transitiva




Linguaggi dinamici – A.A. 2009/2010
                                                        17
Problemi legati alla raggiungibilità
T   La raggiungibilità di un oggetto si può
    intendere in due modi
T   In senso sintattico (syntactic garbage):
      T   quali oggetti possono essere raggiunti o no per
               li     tti                       i ti
          via dei vincoli sintattici del linguaggio
      T   Semplice (dal punto di vista teorico) da
          S       li (d l            i        i )d
          verificare
      T   La raggiungibilità è intesa in senso sintattico
          dalla stragrande maggioranza dei garbage
          collector
             ll t


Linguaggi dinamici – A.A. 2009/2010
                                                            18
Problemi legati alla raggiungibilità
T   La raggiungibilità di un oggetto si può
    intendere in due modi
T   In senso semantico (semantic garbage):
      T   quali oggetti possono essere raggiunti o no per
              li      tti                       i ti
          via del flusso del codice eseguito
      T   Richiede l
          Ri hi d la soluzione dell'halting problem: d
                          l i    d ll'h l i         bl dato
          un programma ed un ingresso, decidere se il
          programma esegue per sempre o finisce
      T   Tale problema è indecidibile: non esiste un
          algoritmo in grado di risolvere l'halting problem
           l     it  i     d     i l        l'h lti    bl
          per ciascun programma e per ciascun ingresso
      T   Euristiche i
          E i ti h nei garbage collector di ricerca
                              b      ll t         i
Linguaggi dinamici – A.A. 2009/2010
                                                              19
Algoritmo Mark and Sweep
T   Ciascun oggetto presente in memoria ha un
    flag (tipicamente un bit) riservato per le
          (tipicamente,
    attività di garbage collection
T   Il flag assume due distinti valori:
      T   0: l'oggetto corrispondente non è stato ancora
          riconosciuto come raggiungibile
      T   1: l'oggetto corrispondente è stato riconosciuto
          come raggiungibile
T   Quando non è in esecuzione il garbage
    collector, tale flag è sempre mantenuto al
      ll         l fl                        l
    valore 0

Linguaggi dinamici – A.A. 2009/2010
                                                             20
Algoritmo Mark and Sweep
T   Prima fase dell'algoritmo
      T   Si individua ciascun oggetto raggiungibile
          direttamente o indirettamente
      T   Si i
             imposta il relativo flag al valore 1
                    t     l ti fl      l l
T   Seconda fase dell'algoritmo
      T   Si esaminano tutti gli oggetti presenti in
          memoria
      T   Gli oggetti con flag pari a 0 si considerano non
          raggiungibili, e la relativa memoria viene
          liberata
T                     g
    Terza fase dell'algoritmo
      T   Viene azzerato il flag degli oggetti superstiti
Linguaggi dinamici – A.A. 2009/2010
                                                             21
Manchevolezze dell'algoritmo
T   L'interprete si deve interrompere durante
    l esecuzione dell algoritmo
    l'esecuzione dell'algoritmo di garbage
    collection
      T   I programmi in esecuzione si “congelano” in
                                          congelano
          maniera imprevedibile
      T   La scrittura di applicazioni a bassa latenza e
          real-time è impossibile
T   L'intero insieme degli oggetti deve essere
    esaminato una volta linearmente
T   L'insieme degli oggetti sopravvissuti deve
    L'i i      d li        i        i    id
    essere esaminato una volta linearmente

Linguaggi dinamici – A.A. 2009/2010
                                                           22
Algoritmo Tri-colour Marking
T   L'insieme degli oggetti presenti in memoria
    viene partizionato in tre sottoinsiemi
T   White set:
      T   Oggetti candidati alla rimozione
          O   tti    did ti ll i      i
T   Black set:
      T   Oggetti che non hanno (dimostrabilmente)
          riferimenti ad altri oggetti nel white set
T   Gray set:
      T   Oggetti che non sono nel white o nel black set
          (non si è ancora scoperto se hanno o no
          riferimenti al white set)
                                  )
Linguaggi dinamici – A.A. 2009/2010
                                                           23
Algoritmo Tri-colour Marking
T   Prima fase dell'algoritmo
      T   L'insieme degli oggetti presenti in memoria
          viene partizionato in tre sottoinsiemi
      T   White t Oggetti candidati alla rimozione (ad
          Whit set: O       tti     did ti ll i     i ( d
          es. sono usciti dallo scope); alla fine
          dell algoritmo
          dell'algoritmo saranno tutti distrutti
      T   Black set: Oggetti non candidati alla rimozione
          che non hanno riferimenti diretti ad oggetti nel
          white set (all'inizio il black set è vuoto)
      T   Grey set: Oggetti che non sono nel white o nel
          black set

Linguaggi dinamici – A.A. 2009/2010
                                                             24
Algoritmo Tri-colour Marking
T   Seconda fase dell'algoritmo
      T   Si sceglie un oggetto O dal grey set
      T   L'oggetto O non è un candidato alla rimozione,
          pertanto va salvato spostandolo nel black set
               t t         l t        t d l        l bl k t
      T   Si identificano tutti gli oggetti R1, ..., Rk
          referenziati direttamente da O
             f      i ti di tt      t d
      T   Si considerano gli oggetti W1, ..., Wj del
          sottoinsieme R1, ..., Rk appartenenti al white set
              tt i i                     t       ti l hit   t
      T   W1, ..., Wj sarebbero da eliminare, ma sono
          riferenziati da un oggetto che non si può
          rimuovere (O); essi vanno spostati nel grey set

Linguaggi dinamici – A.A. 2009/2010
                                                                25
Algoritmo Tri-colour Marking
T   Terza fase dell'algoritmo
      T   Si ripete la seconda fase fino a quando il grey
          set non si svuota
T   Quarta fase d ll' l
    Q   t f     dell'algoritmo
                          it
      T   Gli oggetti nel white set sono dimostrabilmente:
           T candidati alla rimozione


           T non collegati ad un oggetto da salvare

             (quindi, non raggiungibili da parte di un
             oggetto ancora utilizzato dal programma)
      T   La memoria relativa agli oggetti nel white set
          può essere rilasciata

Linguaggi dinamici – A.A. 2009/2010
                                                             26
Vantaggi dell'algoritmo
T   L'algoritmo Tri-colour Marking può essere
    eseguito senza richiedere l interruzione
                                l'interruzione
    completa dell'interprete
T   Il run time mantiene continuamente i tre
    insiemi black, white, grey
T   Le i
    L prime tre fasi dell'algoritmo di garbage
               t f i d ll' l    it          b
    collection vengono eseguite contestualmente
    all'allocazione ed alla modifica di oggetti
      ll' ll    i    d ll      difi           tti
T   La quarta fase viene invocata quando il grey
    set si svuota
T   Non viene mai scandito l'intero insieme degli g
    oggetti, bensì solo il white set
Linguaggi dinamici – A.A. 2009/2010
                                                      27
Generational Garbage
                       Collector




Linguaggi dinamici – A.A. 2009/2010
                                         28
Introduzione
T   Uno studio empirico mostra che, per diverse
    tipologie di programmi, gli oggetti creati più di
                 programmi
    recente hanno la maggiore probabilità di
    d e ta e ag u g b
    diventare irragiungibili nell'immediato futuro
                              e       ed ato utu o
T   Gli oggetti hanno una mortalità infantile
    elevata
T   Tale osservazione può essere presa come una
    vera e propria ipotesi di lavoro: l'ipotesi
    generazionale



Linguaggi dinamici – A.A. 2009/2010
                                                        29
Generazioni
T   Gli oggetti nell'heap vengono divisi in zone di
    memoria distinte, dette generazioni
             distinte
T   Generazioni diverse contengono oggetti con
    diversa “vecchiaia”
             vecchiaia
T   New Generation: oggetti nuovi
      T   Eden: oggetti appena creati
      T   Survivor Space 1 e 2: oggetti sopravvissuti ad
          alcune garbage collection “minori”
T   Old generation: oggetti più vecchi
        g              gg     p
T   Perm: oggetti permanenti usati dalla VM
    (definizioni di classi e metodi)
Linguaggi dinamici – A.A. 2009/2010
                                                           30
Generazioni




Linguaggi dinamici – A.A. 2009/2010
                                               31
Minor collection
T   Quando la generazione New tende a riempirsi,
    viene invocata una minor collection
T   Gli oggetti raggiungibili dell'Eden vengono
    copiati nel Survivor Space 1
T   L'Eden si svuota e può essere nuovamente
    utilizzato per allocazioni di nuovi oggetti
     tili   t       ll     i i        i     tti
T   Nelle minor collection successive, gli oggetti
    raggiungibili dell'Eden e del Survivor Space 1
    vengono copiati nel Survivor Space 2
T   Dopo alcune minor collection, gli oggetti sono
    considerati anziani (tenured) e vengono
                         (         )     g
    spostati nella generazione Old
Linguaggi dinamici – A.A. 2009/2010
                                                     32
Minor collection




Linguaggi dinamici – A.A. 2009/2010
                                               33
Major collection
T   Quando la generazione Old si riempie, viene
    invocata una major collection
T   Primo passo: il garbage collector scandisce
    l intero
    l'intero heap alla ricerca di oggetti non
    raggiungibili
T   Secondo passo: t tti gli oggetti non
    S       d         tutti li     tti
    raggiungibili vengono rimossi, e la memoria
    corrispondente liberata
         i     d t lib     t




Linguaggi dinamici – A.A. 2009/2010
                                                  34
Major collection




Linguaggi dinamici – A.A. 2009/2010
                                               35
Alternative al GC:
                     Reference Counting




Linguaggi dinamici – A.A. 2009/2010
                                           36
Algoritmo Reference Counting
T   Alcuni linguaggi dinamici adottano alternative
    più snelle di un garbage collector classico
T   La più interessante di tali alternative è il
    reference counting
      T   Perl, PHP
T   A ciascun oggetto viene associato un
    contatore degli oggetti che lo stanno
    referenziando
T   Quando il contatore vale 0, nessuno sta
                               ,
    referenziando l'oggetto, che può essere
    distrutto
Linguaggi dinamici – A.A. 2009/2010
                                                     37
Vantaggi dell'algoritmo
T   L'algoritmo di reference counting è molto più
    veloce di un qualunque algoritmo di garbage
    collection
T   Ci si può letteralmente dimenticare di chiudere
    i descrittori dei file
      T   Quando si esce da un blocco di codice, il
          Q     d i       d      bl           di
          reference count della variabile va a 0
      T   La
          L variabile d
                 i bil descrittore viene i
                            itt     i    immediatamente
                                               di t  t
          distrutta
      T   Con un garbage collector, l'operazione non è
          C           b       ll t    l'     i
          necessariamente immediata

Linguaggi dinamici – A.A. 2009/2010
                                                          38
Svantaggi dell'algoritmo
T   È necessario mantenere e gestire un contatore
    in ogni oggetto
T   L'algoritmo di reference counting presenta il
    problema dei riferimenti circolari
T   Si considerino due oggetti A e B che puntano
    l'uno all'altro
T   Sia A che B hanno due riferimenti:
      T   Quello della variabile che li contiene
      T   Quello dell'oggetto che punta a loro
                       gg          p



Linguaggi dinamici – A.A. 2009/2010
                                                    39
Riferimento circolare

               ref A
                 f                            ref B
                                                f
                                      ref B




                                      ref A




Linguaggi dinamici – A.A. 2009/2010
                                                      40
Svantaggi dell'algoritmo
T   Quando uno dei due oggetti (ad esempio, A)
    esce dal suo scope
      T   Non è più accessibile tramite la sua variabile
      T   la
          l sua memoria non può essere liberata, dal
                       i         ò         lib  t d l
          momento che un altro oggetto la sta
          referenziando
T   L'effetto esterno è quello di un memory leak
    (consumo memoria, ma non ho la variabile)
    (                  i           h l   i bil )
T   Devo cancellare A e B per liberare memoria



Linguaggi dinamici – A.A. 2009/2010
                                                           41
Riferimenti deboli
T   Una soluzione a tale problema consiste
    nell adozione
    nell'adozione dei riferimenti deboli (weak
    reference)
      T   Modulo Scalar::Utils (Perl)
T   I riferimenti circolari sono esplicitamente
    marcati come deboli (dal programmatore o
    dall'interprete), e non sono considerati
    dall'algoritmo di reference counting
T   Quando l'oggetto esce dal suo scope, può
    essere didistrutto
T   Caveat: tutti I link all'oggetto diventano nulli!
Linguaggi dinamici – A.A. 2009/2010
                                                        42

Más contenido relacionado

Destacado

Pe a1 perl-unit_testing
Pe a1 perl-unit_testingPe a1 perl-unit_testing
Pe a1 perl-unit_testingMajong DevJfu
 
Corso Python Django
Corso Python DjangoCorso Python Django
Corso Python Djangobarmassimo
 
Py a3 python-metaprogramming
Py a3 python-metaprogrammingPy a3 python-metaprogramming
Py a3 python-metaprogrammingMajong DevJfu
 
Py a2 python-documentazione
Py a2 python-documentazionePy a2 python-documentazione
Py a2 python-documentazioneMajong DevJfu
 
Pe a2 perl-documentazione
Pe a2 perl-documentazionePe a2 perl-documentazione
Pe a2 perl-documentazioneMajong DevJfu
 
Pe a3 perl-metaprogramming
Pe a3 perl-metaprogrammingPe a3 perl-metaprogramming
Pe a3 perl-metaprogrammingMajong DevJfu
 
Py a1 python-unit_testing
Py a1 python-unit_testingPy a1 python-unit_testing
Py a1 python-unit_testingMajong DevJfu
 
Py a6 python-database
Py a6 python-databasePy a6 python-database
Py a6 python-databaseMajong DevJfu
 
9 - Architetture Software - SOA Cloud
9 - Architetture Software - SOA Cloud9 - Architetture Software - SOA Cloud
9 - Architetture Software - SOA CloudMajong DevJfu
 

Destacado (15)

T2 architettura
T2 architetturaT2 architettura
T2 architettura
 
T1 introduzione
T1 introduzioneT1 introduzione
T1 introduzione
 
Pe a1 perl-unit_testing
Pe a1 perl-unit_testingPe a1 perl-unit_testing
Pe a1 perl-unit_testing
 
Pe t3 perl-moduli
Pe t3 perl-moduliPe t3 perl-moduli
Pe t3 perl-moduli
 
Corso Python Django
Corso Python DjangoCorso Python Django
Corso Python Django
 
Py a3 python-metaprogramming
Py a3 python-metaprogrammingPy a3 python-metaprogramming
Py a3 python-metaprogramming
 
Py a2 python-documentazione
Py a2 python-documentazionePy a2 python-documentazione
Py a2 python-documentazione
 
Py t1 python-intro
Py t1 python-introPy t1 python-intro
Py t1 python-intro
 
Pe a2 perl-documentazione
Pe a2 perl-documentazionePe a2 perl-documentazione
Pe a2 perl-documentazione
 
Pe t4 perl-oggetti
Pe t4 perl-oggettiPe t4 perl-oggetti
Pe t4 perl-oggetti
 
Pe a3 perl-metaprogramming
Pe a3 perl-metaprogrammingPe a3 perl-metaprogramming
Pe a3 perl-metaprogramming
 
Py a1 python-unit_testing
Py a1 python-unit_testingPy a1 python-unit_testing
Py a1 python-unit_testing
 
Py a6 python-database
Py a6 python-databasePy a6 python-database
Py a6 python-database
 
Py a4 python-file
Py a4 python-filePy a4 python-file
Py a4 python-file
 
9 - Architetture Software - SOA Cloud
9 - Architetture Software - SOA Cloud9 - Architetture Software - SOA Cloud
9 - Architetture Software - SOA Cloud
 

Más de Majong DevJfu

8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processesMajong DevJfu
 
7 - Architetture Software - Software product line
7 - Architetture Software - Software product line7 - Architetture Software - Software product line
7 - Architetture Software - Software product lineMajong DevJfu
 
6 - Architetture Software - Model transformation
6 - Architetture Software - Model transformation6 - Architetture Software - Model transformation
6 - Architetture Software - Model transformationMajong DevJfu
 
5 - Architetture Software - Metamodelling and the Model Driven Architecture
5 - Architetture Software - Metamodelling and the Model Driven Architecture5 - Architetture Software - Metamodelling and the Model Driven Architecture
5 - Architetture Software - Metamodelling and the Model Driven ArchitectureMajong DevJfu
 
4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture PortfolioMajong DevJfu
 
3 - Architetture Software - Architectural styles
3 - Architetture Software - Architectural styles3 - Architetture Software - Architectural styles
3 - Architetture Software - Architectural stylesMajong DevJfu
 
2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture2 - Architetture Software - Software architecture
2 - Architetture Software - Software architectureMajong DevJfu
 
1 - Architetture Software - Software as a product
1 - Architetture Software - Software as a product1 - Architetture Software - Software as a product
1 - Architetture Software - Software as a productMajong DevJfu
 
10 - Architetture Software - More architectural styles
10 - Architetture Software - More architectural styles10 - Architetture Software - More architectural styles
10 - Architetture Software - More architectural stylesMajong DevJfu
 
25 architectural adaptation
25 architectural adaptation25 architectural adaptation
25 architectural adaptationMajong DevJfu
 

Más de Majong DevJfu (20)

8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes
 
7 - Architetture Software - Software product line
7 - Architetture Software - Software product line7 - Architetture Software - Software product line
7 - Architetture Software - Software product line
 
6 - Architetture Software - Model transformation
6 - Architetture Software - Model transformation6 - Architetture Software - Model transformation
6 - Architetture Software - Model transformation
 
5 - Architetture Software - Metamodelling and the Model Driven Architecture
5 - Architetture Software - Metamodelling and the Model Driven Architecture5 - Architetture Software - Metamodelling and the Model Driven Architecture
5 - Architetture Software - Metamodelling and the Model Driven Architecture
 
4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio
 
3 - Architetture Software - Architectural styles
3 - Architetture Software - Architectural styles3 - Architetture Software - Architectural styles
3 - Architetture Software - Architectural styles
 
2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture
 
1 - Architetture Software - Software as a product
1 - Architetture Software - Software as a product1 - Architetture Software - Software as a product
1 - Architetture Software - Software as a product
 
10 - Architetture Software - More architectural styles
10 - Architetture Software - More architectural styles10 - Architetture Software - More architectural styles
10 - Architetture Software - More architectural styles
 
Uml3
Uml3Uml3
Uml3
 
Uml2
Uml2Uml2
Uml2
 
6
66
6
 
5
55
5
 
4 (uml basic)
4 (uml basic)4 (uml basic)
4 (uml basic)
 
3
33
3
 
2
22
2
 
1
11
1
 
Tmd template-sand
Tmd template-sandTmd template-sand
Tmd template-sand
 
26 standards
26 standards26 standards
26 standards
 
25 architectural adaptation
25 architectural adaptation25 architectural adaptation
25 architectural adaptation
 

T5 memoria

  • 1. Parte 1 Gestione della memoria Linguaggi dinamici – A.A. 2009/2010 1
  • 2. Introduzione T Ciascun linguaggio di programmazione mette a disposizione meccanismi per la gestione della memoria (principale) T Funzionalità ad alto livello di un gestore della memoria: T Allocazione di risorse All i i T Rilascio di risorse Linguaggi dinamici – A.A. 2009/2010 2
  • 3. Due diverse filosofie T C: la gestione della memoria è troppo importante per questo va lasciata al programmatore T Smalltalk: la gestione della memoria è troppo importante per questo va lasciata al sistema Linguaggi dinamici – A.A. 2009/2010 3
  • 4. Gestione manuale della memoria T Nei linguaggi di “vecchio stampo”, sono messe a disposizione del programmatore le funzioni di allocazione e deallocazione della memoria, c e usa o le p e o a, che usano e primitive de s ste a t e del sistema operativo sottostante T C: malloc(), free() T La gestione della memoria è interamente lasciata al programmatore T Gestione eccezionalmente veloce T Gestione eccezionalmente soggetta ad errori di G ti i l t tt d i violazione di segmento Linguaggi dinamici – A.A. 2009/2010 4
  • 5. Gestione manuale della memoria T Schema di gestione manuale della memoria <Acquisizione della memoria> T T <Uso della memoria> T <Rilascio della memoria> T Esempio (C): ptr = malloc(size); <uso di memoria tramite ptr, *ptr>; uso ptr ; free(ptr); Linguaggi dinamici – A.A. 2009/2010 5
  • 6. Gestione manuale della memoria T Vantaggi: T La velocità delle operazioni di gestione è elevata (in sostanza, è quella del kernel sottostante) T I pattern di acquisizione/rilascio sono espliciti T Svantaggi: T Onere di programmazione non indifferente, legato O i i diff t l t all'uso della memoria (aritmetica dei puntatori : segmentation fault, fault puntatore a memoria liberata : dangling reference) T Gestione manuale non scala con le dimensioni del programma (è molto facile dimenticarsi qualche free() : memory leak) Linguaggi dinamici – A.A. 2009/2010 6
  • 7. Gestione automatica della memoria T Nei linguaggi più moderni, una macchina virtuale fornisce l'astrazione portabile di un l astrazione calcolatore T La macchina virtuale implementa il proprio gestore della memoria, che svolge le operazioni di allocazione e deallocazione in maniera automatica, a tempo di esecuzione T Non esiste più il concetto di allocazione N i t iù tt ll i dinamica della memoria T Il programmatore deve solo preoccuparsi di dichiarare ed utilizzare variabili semplici o complesse, mutevoli in tipo e dimensione Linguaggi dinamici – A.A. 2009/2010 7
  • 8. Gestione automatica della memoria T Schema di gestione automatica della memoria Dichiarazione di una variabile (semplice o T complessa) T <U <Uso d ll variabile> della i bil > T Esempio (Perl): my @array = (); push @array, 10; push @array, “ciao”; Linguaggi dinamici – A.A. 2009/2010 8
  • 9. Gestione automatica della memoria T Vantaggi: T L uso L'uso della memoria occupata dalle strutture dati è controllato dall'interprete (assenza di violazioni di segmento) T La memoria viene prenotata quando serve ( (dichiarazione di una variabile) e rilasciata quando ) q non serve più (uscita da un blocco di codice) (è molto più difficile avere memory leak) T Svantaggi: T La velocità delle operazioni di gestione è molto p g bassa (interviene l'interprete) T I pattern di acquisizione/rilascio non sono espliciti Linguaggi dinamici – A.A. 2009/2010 9
  • 10. Parte 1 Garbage Collection g Linguaggi dinamici – A.A. 2009/2010 10
  • 11. Definizione T La garbage collection è una forma di gestione automatica della memoria T John McCarthy, LISP, 1959 T Un U modulo software appartenente al run time d l ft t t l ti environment, detto garbage collector, si preoccupa di effettuare (più o meno ff tt ( iù periodicamente) le seguenti operazioni: T Individua variabili, strutture dati, oggetti che sono usciti dallo scope attuale del programma e non potranno mai più essere referenziati t i iù f i ti dall'applicazione T Rilascia l memoria relativa a tali entità Ril i la i l ti t li tità Linguaggi dinamici – A.A. 2009/2010 11
  • 12. Uso T Linguaggi con un garbage collector T Java, C#, Smalltalk, Lisp, Java C# Smalltalk Lisp Haskell T Python, Ruby, Lua, Tcl T Delphi (dynamic array, long string, variant, interface) T Linguaggi nati con una gestione manuale, estendibili con un garbage collector: T C, C++ (Boehm Garbage Collector) T Linguaggi che fanno uso di tecniche dinamiche alternative alla garbage collection: T Perl, Perl PHP Linguaggi dinamici – A.A. 2009/2010 12
  • 13. Tracing Garbage Collector g g Linguaggi dinamici – A.A. 2009/2010 13
  • 14. Introduzione T La stragrande maggioranza dei garbage collector segue una strategia detta tracing garbage collection T Un tracing garbage collector esegue il seguente flusso di operazioni 1)Determina quali oggetti sono raggiungibili ( 1)D t i li tti i ibili (o potenzialmente tali) 2)Scarta tutti gli altri oggetti (rilasciandone la 2)S t t tti li lt i tti ( il i d l relativa memoria) T Per P oggetto si intende un qualunque tipo di ii d l i entità richiedente memoria principale (numero, struttura d ti complessa, istanza di classe) t tt dati l i t l ) Linguaggi dinamici – A.A. 2009/2010 14
  • 15. Raggiungibilità di un oggetto T Un oggetto è detto raggiungibile se esiste una variabile che lo referenzia T Il riferimento può essere diretto (una variabile contiene l'oggetto) l oggetto) T Il riferimento può essere indiretto (una variabile contiene un “puntatore” all'oggetto) puntatore all oggetto) Linguaggi dinamici – A.A. 2009/2010 15
  • 16. Raggiungibilità di un oggetto T In altre parole, in un dato istante temporale, un oggetto può essere raggiungibile solamente nei seguenti due modi T Raggiungibilità diretta T Alcuni oggetti (detti radice) si assume siano raggiungibili T Tutti gli oggetti dello stack frame corrente (variabili locali parametri della funzione locali, correntemente in esecuzione) T Tutte le variabili globali Linguaggi dinamici – A.A. 2009/2010 16
  • 17. Raggiungibilità di un oggetto T In altre parole, in un dato istante temporale, un oggetto può essere raggiungibile solamente nei seguenti due modi T Raggiungibilità indiretta T Ogni oggetto riferito da un oggetto raggiungibile direttamente è a sua volta un è, volta, oggetto raggiungibile T La raggiungiblità è pertanto una chiusura è, pertanto, transitiva Linguaggi dinamici – A.A. 2009/2010 17
  • 18. Problemi legati alla raggiungibilità T La raggiungibilità di un oggetto si può intendere in due modi T In senso sintattico (syntactic garbage): T quali oggetti possono essere raggiunti o no per li tti i ti via dei vincoli sintattici del linguaggio T Semplice (dal punto di vista teorico) da S li (d l i i )d verificare T La raggiungibilità è intesa in senso sintattico dalla stragrande maggioranza dei garbage collector ll t Linguaggi dinamici – A.A. 2009/2010 18
  • 19. Problemi legati alla raggiungibilità T La raggiungibilità di un oggetto si può intendere in due modi T In senso semantico (semantic garbage): T quali oggetti possono essere raggiunti o no per li tti i ti via del flusso del codice eseguito T Richiede l Ri hi d la soluzione dell'halting problem: d l i d ll'h l i bl dato un programma ed un ingresso, decidere se il programma esegue per sempre o finisce T Tale problema è indecidibile: non esiste un algoritmo in grado di risolvere l'halting problem l it i d i l l'h lti bl per ciascun programma e per ciascun ingresso T Euristiche i E i ti h nei garbage collector di ricerca b ll t i Linguaggi dinamici – A.A. 2009/2010 19
  • 20. Algoritmo Mark and Sweep T Ciascun oggetto presente in memoria ha un flag (tipicamente un bit) riservato per le (tipicamente, attività di garbage collection T Il flag assume due distinti valori: T 0: l'oggetto corrispondente non è stato ancora riconosciuto come raggiungibile T 1: l'oggetto corrispondente è stato riconosciuto come raggiungibile T Quando non è in esecuzione il garbage collector, tale flag è sempre mantenuto al ll l fl l valore 0 Linguaggi dinamici – A.A. 2009/2010 20
  • 21. Algoritmo Mark and Sweep T Prima fase dell'algoritmo T Si individua ciascun oggetto raggiungibile direttamente o indirettamente T Si i imposta il relativo flag al valore 1 t l ti fl l l T Seconda fase dell'algoritmo T Si esaminano tutti gli oggetti presenti in memoria T Gli oggetti con flag pari a 0 si considerano non raggiungibili, e la relativa memoria viene liberata T g Terza fase dell'algoritmo T Viene azzerato il flag degli oggetti superstiti Linguaggi dinamici – A.A. 2009/2010 21
  • 22. Manchevolezze dell'algoritmo T L'interprete si deve interrompere durante l esecuzione dell algoritmo l'esecuzione dell'algoritmo di garbage collection T I programmi in esecuzione si “congelano” in congelano maniera imprevedibile T La scrittura di applicazioni a bassa latenza e real-time è impossibile T L'intero insieme degli oggetti deve essere esaminato una volta linearmente T L'insieme degli oggetti sopravvissuti deve L'i i d li i i id essere esaminato una volta linearmente Linguaggi dinamici – A.A. 2009/2010 22
  • 23. Algoritmo Tri-colour Marking T L'insieme degli oggetti presenti in memoria viene partizionato in tre sottoinsiemi T White set: T Oggetti candidati alla rimozione O tti did ti ll i i T Black set: T Oggetti che non hanno (dimostrabilmente) riferimenti ad altri oggetti nel white set T Gray set: T Oggetti che non sono nel white o nel black set (non si è ancora scoperto se hanno o no riferimenti al white set) ) Linguaggi dinamici – A.A. 2009/2010 23
  • 24. Algoritmo Tri-colour Marking T Prima fase dell'algoritmo T L'insieme degli oggetti presenti in memoria viene partizionato in tre sottoinsiemi T White t Oggetti candidati alla rimozione (ad Whit set: O tti did ti ll i i ( d es. sono usciti dallo scope); alla fine dell algoritmo dell'algoritmo saranno tutti distrutti T Black set: Oggetti non candidati alla rimozione che non hanno riferimenti diretti ad oggetti nel white set (all'inizio il black set è vuoto) T Grey set: Oggetti che non sono nel white o nel black set Linguaggi dinamici – A.A. 2009/2010 24
  • 25. Algoritmo Tri-colour Marking T Seconda fase dell'algoritmo T Si sceglie un oggetto O dal grey set T L'oggetto O non è un candidato alla rimozione, pertanto va salvato spostandolo nel black set t t l t t d l l bl k t T Si identificano tutti gli oggetti R1, ..., Rk referenziati direttamente da O f i ti di tt t d T Si considerano gli oggetti W1, ..., Wj del sottoinsieme R1, ..., Rk appartenenti al white set tt i i t ti l hit t T W1, ..., Wj sarebbero da eliminare, ma sono riferenziati da un oggetto che non si può rimuovere (O); essi vanno spostati nel grey set Linguaggi dinamici – A.A. 2009/2010 25
  • 26. Algoritmo Tri-colour Marking T Terza fase dell'algoritmo T Si ripete la seconda fase fino a quando il grey set non si svuota T Quarta fase d ll' l Q t f dell'algoritmo it T Gli oggetti nel white set sono dimostrabilmente: T candidati alla rimozione T non collegati ad un oggetto da salvare (quindi, non raggiungibili da parte di un oggetto ancora utilizzato dal programma) T La memoria relativa agli oggetti nel white set può essere rilasciata Linguaggi dinamici – A.A. 2009/2010 26
  • 27. Vantaggi dell'algoritmo T L'algoritmo Tri-colour Marking può essere eseguito senza richiedere l interruzione l'interruzione completa dell'interprete T Il run time mantiene continuamente i tre insiemi black, white, grey T Le i L prime tre fasi dell'algoritmo di garbage t f i d ll' l it b collection vengono eseguite contestualmente all'allocazione ed alla modifica di oggetti ll' ll i d ll difi tti T La quarta fase viene invocata quando il grey set si svuota T Non viene mai scandito l'intero insieme degli g oggetti, bensì solo il white set Linguaggi dinamici – A.A. 2009/2010 27
  • 28. Generational Garbage Collector Linguaggi dinamici – A.A. 2009/2010 28
  • 29. Introduzione T Uno studio empirico mostra che, per diverse tipologie di programmi, gli oggetti creati più di programmi recente hanno la maggiore probabilità di d e ta e ag u g b diventare irragiungibili nell'immediato futuro e ed ato utu o T Gli oggetti hanno una mortalità infantile elevata T Tale osservazione può essere presa come una vera e propria ipotesi di lavoro: l'ipotesi generazionale Linguaggi dinamici – A.A. 2009/2010 29
  • 30. Generazioni T Gli oggetti nell'heap vengono divisi in zone di memoria distinte, dette generazioni distinte T Generazioni diverse contengono oggetti con diversa “vecchiaia” vecchiaia T New Generation: oggetti nuovi T Eden: oggetti appena creati T Survivor Space 1 e 2: oggetti sopravvissuti ad alcune garbage collection “minori” T Old generation: oggetti più vecchi g gg p T Perm: oggetti permanenti usati dalla VM (definizioni di classi e metodi) Linguaggi dinamici – A.A. 2009/2010 30
  • 32. Minor collection T Quando la generazione New tende a riempirsi, viene invocata una minor collection T Gli oggetti raggiungibili dell'Eden vengono copiati nel Survivor Space 1 T L'Eden si svuota e può essere nuovamente utilizzato per allocazioni di nuovi oggetti tili t ll i i i tti T Nelle minor collection successive, gli oggetti raggiungibili dell'Eden e del Survivor Space 1 vengono copiati nel Survivor Space 2 T Dopo alcune minor collection, gli oggetti sono considerati anziani (tenured) e vengono ( ) g spostati nella generazione Old Linguaggi dinamici – A.A. 2009/2010 32
  • 33. Minor collection Linguaggi dinamici – A.A. 2009/2010 33
  • 34. Major collection T Quando la generazione Old si riempie, viene invocata una major collection T Primo passo: il garbage collector scandisce l intero l'intero heap alla ricerca di oggetti non raggiungibili T Secondo passo: t tti gli oggetti non S d tutti li tti raggiungibili vengono rimossi, e la memoria corrispondente liberata i d t lib t Linguaggi dinamici – A.A. 2009/2010 34
  • 35. Major collection Linguaggi dinamici – A.A. 2009/2010 35
  • 36. Alternative al GC: Reference Counting Linguaggi dinamici – A.A. 2009/2010 36
  • 37. Algoritmo Reference Counting T Alcuni linguaggi dinamici adottano alternative più snelle di un garbage collector classico T La più interessante di tali alternative è il reference counting T Perl, PHP T A ciascun oggetto viene associato un contatore degli oggetti che lo stanno referenziando T Quando il contatore vale 0, nessuno sta , referenziando l'oggetto, che può essere distrutto Linguaggi dinamici – A.A. 2009/2010 37
  • 38. Vantaggi dell'algoritmo T L'algoritmo di reference counting è molto più veloce di un qualunque algoritmo di garbage collection T Ci si può letteralmente dimenticare di chiudere i descrittori dei file T Quando si esce da un blocco di codice, il Q d i d bl di reference count della variabile va a 0 T La L variabile d i bil descrittore viene i itt i immediatamente di t t distrutta T Con un garbage collector, l'operazione non è C b ll t l' i necessariamente immediata Linguaggi dinamici – A.A. 2009/2010 38
  • 39. Svantaggi dell'algoritmo T È necessario mantenere e gestire un contatore in ogni oggetto T L'algoritmo di reference counting presenta il problema dei riferimenti circolari T Si considerino due oggetti A e B che puntano l'uno all'altro T Sia A che B hanno due riferimenti: T Quello della variabile che li contiene T Quello dell'oggetto che punta a loro gg p Linguaggi dinamici – A.A. 2009/2010 39
  • 40. Riferimento circolare ref A f ref B f ref B ref A Linguaggi dinamici – A.A. 2009/2010 40
  • 41. Svantaggi dell'algoritmo T Quando uno dei due oggetti (ad esempio, A) esce dal suo scope T Non è più accessibile tramite la sua variabile T la l sua memoria non può essere liberata, dal i ò lib t d l momento che un altro oggetto la sta referenziando T L'effetto esterno è quello di un memory leak (consumo memoria, ma non ho la variabile) ( i h l i bil ) T Devo cancellare A e B per liberare memoria Linguaggi dinamici – A.A. 2009/2010 41
  • 42. Riferimenti deboli T Una soluzione a tale problema consiste nell adozione nell'adozione dei riferimenti deboli (weak reference) T Modulo Scalar::Utils (Perl) T I riferimenti circolari sono esplicitamente marcati come deboli (dal programmatore o dall'interprete), e non sono considerati dall'algoritmo di reference counting T Quando l'oggetto esce dal suo scope, può essere didistrutto T Caveat: tutti I link all'oggetto diventano nulli! Linguaggi dinamici – A.A. 2009/2010 42