X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=blobdiff_plain;ds=sidebyside;f=process.tex;h=45363c591eb6a225a0df92e6c41d4d717f15ad26;hb=b68aa96c16958fda51be7ce0fc43ff51b1171342;hp=51f0863b292af8422e1a0585d645d1f5f54d4fc9;hpb=b6f7823d632746be29b7a05e7b9ab04b14a450f8;p=gapil.git diff --git a/process.tex b/process.tex index 51f0863..45363c5 100644 --- a/process.tex +++ b/process.tex @@ -418,15 +418,15 @@ medesima. Esiste però un terzo tipo di allocazione, che non è prevista dal linguaggio C, che è l'allocazione dinamica della memoria, necessaria quando il quantitativo di memoria che serve è determinabile solo in corso di esecuzione del -programma. +programma. Il C non consente di usare variabili allocate dinamicamente, non è possibile cioè definire in fase di programmazione una variabile le cui dimensioni possano essere modificate durante l'esecuzione del programma; però le librerie del C forniscono una serie opportuna di funzioni per permettere l'allocazione dinamica di spazio in memoria (in genere nello heap, usando la system call -\texttt{sbrk}), solo che a questo punto sarà possibile usarlo solo in maniera -indiretta attraverso dei puntatori. +\texttt{sbrk}), solo che a questo punto detto spazio sarà accessibile solo in +maniera indiretta attraverso dei puntatori. \subsection{Le funzioni \texttt{malloc}, \texttt{calloc}, \texttt{realloc} e @@ -466,22 +466,115 @@ quattro, i prototipi sono i seguenti: Il puntatore che le funzioni di allocazione ritornano è garantito essere sempre correttamente allineato per tutti i tipi di dati; ad esempio sulle macchine a 32 bit in genere è allineato a multipli di 4 bytes e sulle macchine -a 64 bit a multipli di 8 bytes. Il puntatori ritornati sono di tipo generico -così non è necessario effettuare un cast per assegnarli a puntatori di altro -tipo. - +a 64 bit a multipli di 8 bytes. + +In genere su usano le funzioni \texttt{malloc} e \texttt{calloc} per allocare +dinamicamente la memoria necessaria al programma, siccome i puntatori +ritornati sono di tipo generico non è necessario effettuare un cast per +assegnarli a puntatori al tipo di variabile per la quale si effettua la +allocazione. + +La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando +\texttt{free}\footnote{le glibc provvedono anche una funzione \texttt{cfree} + defininita per compatibilità con SunOS, che è deprecata} una volta che non +sia più necessaria. Questa funzione vuole come parametro un puntatore +restituito da una precedente chiamata a una qualunque delle funzioni di +allocazione e che non sia già stato liberato da un'altra chiamata a +\texttt{free}, in caso contrario il comportamento della funzione è indefinito. + +La funzione \texttt{realloc} si usa invece per cambiare (in genere aumentare) +la dimensione di un'area di memoria precedentemente allocata, la funzione +vuole in ingresso il puntatore restituito dalla precedente chiamata ad una +\texttt{malloc} (se è passato un valore \texttt{NULL} allora la funzione si +comporta come \texttt{malloc}\footnote{questo è vero per linux e + l'implementazione secondo lo standard ANSI C, ma non è vero per alcune + vecchie implementazioni, inoltre alcune versioni delle librerie del C + consentivano di usare \texttt{realloc} anche per un puntatore liberato con + \texttt{free} purché non ci fossero state altre chiamate a funzioni di + allocazione, questa funzionalità è totalmente deprecata e non è consentita + sotto linux}), ad esempio quando si deve far crescere la dimensione di un +vettore; in questo caso se è disponibile dello spazio adiacente al precedente +la funzione lo utilzza, altrimenti rialloca altrove un blocco della dimensione +voluta copiandoci automaticamente il contenuto, lo spazio in più non viene +inizializzato. + +Il fatto che il blocco di memoria restituito da \texttt{realloc} possa +camabiare comporta che si deve sempre riassegnare al puntatore passato per il +ridimensionamento il valore di ritorno della funzione, e che non ci devono +essere altri puntatori che puntino all'interno di un'area che si vuole +ridimensionare. + + +Uno degli errori più comuni (specie se si ha a che fare con array di +puntatori) è infatti quello di chiamare \texttt{free} più di una volta sullo +stesso puntatore; per evitare questo problema una soluzione di ripiego è +quella di assegnare sempre a \texttt{NULL} ogni puntatore liberato con +\texttt{free}, dato che, quando il parametro è un puntatore nullo, +\texttt{free} non esegue nessuna operazione. + +Linux e le glibc hanno una implementazione delle routine di allocazione che è +controllabile dall'utente attraverso alcune variabili di ambiente, in +particolare diventa possibile tracciare questo tipo di errori usando la +variabile \texttt{MALLOC\_CHECK\_} che quando viene settata mette in uso una +versione meno efficiente delle funzioni, che però è più tollerante nei +confronti di piccoli errori come quello di chiamate doppie a \texttt{free}; in +pparticolare se la variabile è posta a zero gli errori vengono ignorati, se è +posta ad 1 viene stampato un avviso sullo standard error e se + + +Il problema più comune e più difficile da tracciare che si incontra con +l'allocazione della memoria è però quando la memoria non più utilizzata non +viene opportunamente liberata (quello che in inglese viene chiamato +\textit{memory-leak}, traducibile come \textsl{perdita di memoria}). + +Un caso tipico è quando l'allocazione viene fatta da una subroutine per un uso +locale, ma la memoria non viene liberata una volta usata; chiamate ripetute +alla stessa suubroutine causeranno a lungo andare un esaurimento della memoria +disponibile, con un conseguente crash dell'applicazione che può avvenire in +qualunque momento senza nessuna relazione con la subroutine che contiene +l'errore. + +Per questo motivo l'implementazione delle routine di allocazione delle glibc +mette a disposizione una serie di funzionalità (su cui torneremo in +\secref{sec:proc_mem_advanced}) che permettono di tracciare le allocazioni e +le disallocazione, e definisce anche una serie di possibili agganci che +permettono di sostituire alle funzioni di libreria una propria versione (che +può essere più o meno specializzata per il debugging). \subsection{La funzione \texttt{alloca}} \label{sec:proc_mem_alloca} +Una alternativa possibile all'uso di \texttt{malloc}, che non soffre del tipo +di problemi di memomry leak descritti in precedenza è la funzione +\texttt{alloca} che invece che allocare la memoria nello heap usa lo il +segmento di stack della funzione corrente. La sintassi è identica: +\begin{prototype}{stdlib.h}{void *alloca(size\_t size)} + Alloca \texttt{size} bytes nel segmento di stack della funzione chiamante. + La memoria non viene inizializzata. + + La funzione restituisce il puntatore alla zona di memoria allocata in caso + di successo e \texttt{NULL} in caso di fallimento, nel qual caso + \texttt{errno} viene settata a \texttt{ENOMEM}. +\end{prototype} +ma in questo caso non è più necessario liberare la memoria in quanto questa +viene rilasciata automaticamente al ritorno della funzione. + +Come è evidente questa funzione ha molti vantaggi, in particolare in Linux +la funzione è molto veloce ed occupa poco spazio, essendo codificata +direttamente dentro il compilatore, inoltre \subsection{Le funzioni \texttt{brk} e \texttt{sbrk}} \label{sec:proc_mem_sbrk} +\subsection{La personalizzazione delle funzioni di allocazione} +\label{sec:proc_mem_malloc_custom} + + \subsection{Il controllo della memoria virtuale} -\label{sec:proc_mem_sbrk} +\label{sec:proc_mem_mlock} + \section{Il controllo di flusso non locale} \label{sec:proc_flux}