Allocation Mémoire T. HSU. September 29, IUT de LENS, Département informatique. T. HSU Allocation Mémoire

Dimension: px

Commencer à balayer dès la page:

Download "Allocation Mémoire T. HSU. September 29, 2014. IUT de LENS, Département informatique. T. HSU Allocation Mémoire"

Bérengère Bergeron
il y a 7 ans
Total affichages :

1 Allocation Mémoire T. HSU IUT de LENS, Département informatique September 29, 2014

2 Introduction Les algorithmes sous-jacents à tout programme informatique consomment essentiellement deux ressources : du temps et de l espace Deux stratégies d allocation mémoire peuvent être employées Allocation statique Allocation dynamique L opération symétrique de l allocation est couramment appelée libération ou désallocation de la mémoire

mémoire peuvent être employées Allocation statique Allocation dynamique L opération

3 Allocation Statique Allouer statiquement de la mémoire pour un programme signifie : prévoir l espace mémoire nécessaire avant l exécution du programme, en spécifiant la quantité nécessaire dans le code source, réserver cet espace au moment de la compilation, dans le fichier binaire produit, au chargement du programme en mémoire, juste avant l exécution, l espace réservé devient alors accessible. Lors de l exécution, aucune allocation n a lieu L avantage de l allocation statique se situe essentiellement au niveau des performances, puisqu on évite les coûts de l allocation dynamique à l exécution : la mémoire statique est immédiatement utilisable.

en mémoire, juste avant l exécution, l espace réservé devient alors accessible.

4 Allocation dynamique La plupart des programmes ont des besoins en mémoire variables Il est nécessaire de pouvoir (à des moments arbitraires de l exécution) demander au système l allocation de nouvelles zones de mémoire Il faut alors penser à libérer cette mémoire mise à disposition lorsque l on en a plus besoin A la charge du programmeur? A la charge du langage (garbage collector)?

allocation de nouvelles zones de mémoire Il faut alors penser à libérer cette mémoire mise à

5 Comparaison L allocation statique est la méthode la plus sûre dans le sens où : la quantité consommée est constante et complètement connue avant l exécution, elle est généralement accessible exclusivement en lecture seule (non modifiable). C est toutefois une méthode très inflexible et insuffisante pour les programmes dont les besoins peuvent varier de façon imprévisible L allocation dynamique offre le plus de possibilités Les ressources allouées ont une durée de vie indéfinie.

C est toutefois une méthode très inflexible et insuffisante pour les programmes dont les besoins peuvent varier de façon

6 Les problèmes potentiels Les index hors bornes : Un classique Les référencements de pointeurs non alloués : Un autre classique Les fuites mémoires Deux philosophies différentes C/C++ Pas de vérifications Pas de Garbage collector Le codeur est considéré comme responsable Java Vérifications Garbage collector Le codeur est considéré comme irresponsable Bjarne Stroustrup (créateur du C++) : Il est dit que les programmeurs JAVA savent que la gestion de la mémoire est si importante qu elle ne peut pas être laissée aux programmeurs, et que les programmeurs C savent que la gestion de la mémoire est si importante qu elle ne peut pas être laissée au système

codeur est considéré comme irresponsable Bjarne Stroustrup (créateur du C++) : Il est dit que les programmeurs JAVA savent que la gestion de la mémoire est si

7 Part I Programmation C/C++

8 Les pointeurs Le début

9 Les pointeurs Le début int x; x

10 Les pointeurs Le début int x; x = 18; 18 x

11 Les pointeurs Le début int x; x = 18; x Comment connaitre l adresse de x (c est a dire la valeur : 52) Cela est fait avec la notation & : &x

12 Les pointeurs La suite On peut créer des variables pointeurs : Elle est destinée à contenir une adresse mémoire. Cela est fait avec la notation *

13 Les pointeurs La suite On peut créer des variables pointeurs : Elle est destinée à contenir une adresse mémoire. Cela est fait avec la notation * x int x = 18; int *px; px

14 Les pointeurs La suite On peut créer des variables pointeurs : Elle est destinée à contenir une adresse mémoire. Cela est fait avec la notation * x int x = 18; int *px; px = &x; px

15 Les pointeurs La suite On peut créer des variables pointeurs : Elle est destinée à contenir une adresse mémoire. Cela est fait avec la notation * x int x = 18; int *px; px = &x; px

16 Pointeurs et tableaux int Tab[5]; for(int i = 0;i<5;i++) Tab[i] = i*2; int *ptab = Tab; // Tab est un pointeur!!!!!!! ptatb[2] = tab[2] = *(Tab + 2) = *(ptab + 2) = ptab[2] Tab ptab

!!!!!! ptatb[2] = tab[2] = *(Tab + 2) = *(ptab + 2) = 4 50

17 Une petite fonction void permute(int a,int b) { int tmp = a; a = b; b = tmp; } int main() { x = 12; y = 2; permute(x,y); printf("%d %d",x,y); } Qu est ce qui est affiché??

18 Pointeurs dans les fonctions Pour pouvoir modifier une variable, il faut lui donner son adresse D où l utilisation des pointeurs. void permute(int *a,int *b) { int tmp = *a; *a = *b; *b = tmp; } int main() { x = 12; y = 2; permute(&x,&y); printf("%d %d",x,y); }

void permute(int *a,int *b) { int tmp = *a; *a = *b; *b = tmp; }

19 Pointeurs dans les fonctions De la même manière, un tableau sera donné par un pointeur sur son premier élément int max(int *tab,int sz) { int tmp = tab[0]; for(int i = 1;i<sz;i++) if(tmp<tab[i]) tmp = tab[i]; return tmp; } int main() { int mytab = {1,4,5,23,544}; int m = max(mytab,5); printf("%d,m); }

tab[0]; for(int i = 1;i<sz;i++) if(tmp<tab[i]) tmp = tab[i]; return tmp; }

20 Allocation dynamique Pour l instant, les tableaux, variables utilisés étaient alloués statiquement Soit un pointeur px tout seul. Pour l instant on ne peut pas utiliser px : *px = 3;!!! INTERDIT On doit pouvoir allouer de l espace pour px Cet espace peut être de longueur indeterminé (1 élement, 2..)

Pour l instant on ne peut pas utiliser px : *px = 3;!

21 Allocation dynamique en C px int *px;

22 Allocation dynamique en C px int *px; px = malloc(sizeof(int)*3);

23 Allocation dynamique en C px int *px; px = malloc(sizeof(int)*3);

24 Allocations dynamiques en C void *malloc(size t size); Allocation de n octets en mémoire Il faut caster Pas d initialisation void *calloc(size t nmemb, size t size) Initialisation! void *realloc(void *ptr, size t size); Réallocation Utilisé lorsque un tableau grandit par exemple

25 DéAllocation en C Tout ce qui est alloué doit être désalloué Il est primordial de désallouer tout ce qui a été alloué Autrement : fuites mémoires Une fonction void free(void *ptr)

26 Exemple int main() { int * a1,*a2; } a1 = (int*)malloc(sizeof(int)*4); //Alloc tab 4 a2 = (int *)calloc(4,sizeof(int));//alloc tab 4 init 0 a1 = (int*)realloc(a1,sizeof(int)*10);// realloc de a1 free(a1); free(a2);

27 Et en C++ La fonction new pour allouer un pointeur La fonction delete pour désaouler un pointeur On peut également allouer des tableaux i n t main ( ) { i n t a1, a2 ; a1 = new i n t [ 1 0 ] ; // a l l o c t a b l e a u 10 a2 = new i n t ( 2 ) ; // a l l o c a2 i n i t a 2 } delete [ ] a1 ; // f r e e t a b l e a u delete a2 ; // f r e e p o i n t e u r return 0 ;

28 Exemple de Fuites mémoires i n t f ( ) { i n t a1 ; // dans l a p i l e : v a r i a b l e l o c a l e // On a l l o u e a1 a1 = ( i n t ) m a l l o c ( s i z e o f ( i n t ) 1 0 ) ; // Le contenu e s t a l l o u e dans l e t a s // On f a i t ce que l on veut avec a1 // On o u b l i e de d e s a l l o u e r a1 // l e contenu d e v i e n t i n a c c e s s i b l e // mais t o u j o u r s p r e s e n t } i n t main ( ) { f ( ) ; // Appel de f f ( ) ; // Autre Appel de f }

29 Une règle d or Toujours désallouer ce qui a été alloué

30 Organisation de la mémoire La mémoire d un programme est segmentée en plusieurs parties : La zone.text : contient les instructions : en lecture seule La zone.data : stocke les données globales initialisées La zone.bss : stocke les données globales non initialisées La zone User Stack Frame : contient le tas et la pile Utilisé pour les variables locales et dynamiques

31 La pile Réside en mémoire haute Croit avec des adresses décroissantes LIFO Utilisé pour Appel des fonctions : passage de paramètres, Sauvegarde des registres Stockage des variables locales

32 Le tas Croit avec des adresses croissantes Utilisé pour Stockage des données de grandes tailles Stockage des données alloués dynamiquement

33 Un exemple i n t i n d = 1 ; // Dans data char s t r ; // dans b s s i n t r i e n ; // Dans b s s void f ( ) { i n t i ; // Dans l a p i l e char c [ 5 ] ; // Dans l a p i l e char s ; // Dans l a p i l e // R e s e r v a t i o n de 5 c a r a c t e r e s dans l e t a s s t r = ( char ) m a l l o c ( s i z e o f ( char ) 5 ) ; // R e s e r v a t i o n de 5 c a r a c t e r e s dans l e t a s s = ( char ) m a l l o c ( s i z e o f ( char ) 5 ) ; s t r c p y ( s t r, abcd ) ; s t r c p y ( s, abcd ) ; }

34 Part II Programmation JAVA

35 Architecture Java INTEL INTEL Linux Linux INTEL Linux INTEL Linux MAC MAC MAC Indépendant de l archi MAC SPARC SPARC SPARC SPARC Source Compilateur Executable Source Compilateur JAVAC Pseudo Code (Byte Code) Interpréteur Classique JAVA Machine Virtuelle Java (JVM)

36 Machine virtuelle La machine virtuelle JAVA permet d avoir un code portable C est la machine virtuelle qui se charge de toute l allocation mémoire Allocation et java Les allocations statiques ne concernent que les types primitifs (int, ) Tous les objets (et donc les tableaux) doivent être allouées dynamiquement

37 Allocation en Java i n t main ( ) { i n t a1, a2, a3 ; Objec o ; } a1 = new i n t [ 4 ] ; // a l l o c t a b l e a u : i n i t a 0 a2 = new i n t [ 5 ] ; // un a u t r e t a b l e a u o = new Object ( ) ; // l e garbage c o l l e c t o r r e c u p e r e l e s d i v e r s // o b j e t s a l l o u e s e t l e s r e s t i t u e

38 Désallocation en Java Vous n avez rien à faire La JVM s occupe de tout Est ce à dire qu il n y a plus de fuites mémoires? Que se passe t il si on a beaucoup de fuites mémoires?

39 Le Garbage Collector Déterminer quelles références ne peuvent pas être utilisées (à un instant donné) récupérer le stockage utilisé par ces références Notion d atteignabilité d un objet voir fr.wikipedia.org/wiki/ramasse-miettes Langages utilisant le GC : Lisp, Caml, C#, Java, Python

Documents pareils

Cours de Programmation Impérative: Zones de mémoires et pointeurs

Cours de Programmation Impérative: Zones de mémoires et pointeurs Julien David A101 - david@lipn.univ-paris13.fr Julien David (A101 - david@lipn.univ-paris13.fr) 1 / 1 Zò nè s `dè m`é mò i rè Julien