Gestion de la mémoire [Sources]

**gege2061** · 13/06/2006, 17h53

Bonjour,

voilà j'ai fait un gestionnaire pour sécuriser les allocations dynamiques (les fonctione commencent pas le préfixe sma_) :

Vérification du retour de malloc
Test si le pointeur passé à sma_free à bien été alloué par sma_malloc ou enregistré
Test des débordement
Vérification des fuites

Voici un p'tit exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
#include <stdlib.h>
#include "include/sma.h"
 
int main(void)
{
  char *p[3] = { NULL };
 
/* Initialisation */
  sma_init (NULL);
/* Allocation */
  p[1] = sma_malloc (10 * sizeof (*p[1]));
/* Ecriture en dehors de la zone allouee */
  p[1][10] = 1;
  p[1][-1] = 1;
/* Reallocation */
  p[1] = sma_realloc (p[1], 20);
/* Enregistrement d'une allocation externe */
  p[2] = malloc (3);
  sma_register (p[2]);
/* Affiche l'etat du gestionnaire */
  sma_profil ();
  p[1]++;
/* Liberation */
  sma_free (p[1]);
  sma_free (p[2]);
/* Verification des fuites memoires */
  sma_end ();
  return 0;
}

Résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
===== malloc (10) dans src\main.c:11 =====
        + 10 octects a 003D2434
 
===== realloc (p[1], 20) dans src\main.c:15 =====
        Warning : Underflow a 003D2434[-1]
        Warning : Overflow  a 003D2434[10]
        - 10 octects a 003D2434 dans src\main.c:11
        + 20 octects dans 003D249C
 
===== Allocation externe "p[2]" dans src\main.c:18 =====
        003D3B38
 
|----------------------------------------------------------------|
|                        Profile memoire                         |
|                                              src\main.c     19 |
|----------------------------------------------------------------|
| | Taille |   Addr    |  Ligne |  Fichier                       |
|----------------------------------------------------------------|
| |     20 | 003D249C |     15 |                     src\main.c |
|*|      0 | 003D3B38 |     18 |                     src\main.c |
|----------------------------------------------------------------|
 
===== free (p[1]) dans src\main.c:21 =====
        Warning : Pointeur non enregistre 003D249D
 
===== free (p[2]) dans src\main.c:22 =====
        - 0 octects a 003D3B38 alloue dans src\main.c:18
 
===== Fuites memoire =====
|----------------------------------------------------------------|
|                        Profile memoire                         |
|                                              src\main.c     23 |
|----------------------------------------------------------------|
| | Taille |   Addr    |  Ligne |  Fichier                       |
|----------------------------------------------------------------|
| |     20 | 003D249C |     15 |                     src\main.c |
|----------------------------------------------------------------|
 
Free 003D2498
Fuites reparees

J'espère que cela vous sera utile et si vous avez des remarques (amélioration, bug...), postez le tout à la suite

Disponible via subversion : http://subversion.developpez.com/pro...1/C/sma/trunk/

**fearyourself** · 13/06/2006, 20h13

Ca a l'air fort sympa, je vais regarder ton code avec un regard critique demain!

Jc

**Emmanuel Delahaye** · 13/06/2006, 21h22

Envoyé par gege2061

Bonjour,

voilà j'ai fait un gestionnaire pour sécuriser les allocations dynamiques (les fonctione commencent pas le préfixe sma_) :

Vérification du retour de malloc
Test si le pointeur passé à sma_free à bien été alloué par sma_malloc ou enregistré
Test des débordement
Vérification des fuites

Si je comprends bien, il faut que le je teste avec mon propre mécanisme de détecton de fuites pour voir si il ne génère pas de fuites !

Mon mécanisme (SYSALLOC) n'utilise pas malloc(), sinon, on ne peut rien vérifier du tout (on est pas indépendant).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (1365 rec)
SYSALLOC Successful initialization: 1365 records available
===== malloc (10) dans main.c:16 =====
        + 10 octects a 003D5C4C
 
===== realloc (p[1], 20) dans main.c:20 =====
        Warning : Underflow a 003D5C4C[-1]
        Warning : Overflow  a 003D5C4C[10]
        - 10 octects a 003D5C4C dans main.c:16
        + 20 octects dans 003D5CB4
 
===== Allocation externe "p[2]" dans main.c:23 =====
        003D3BD0
 
|----------------------------------------------------------------|
|                        Profile memoire                         |
|                                                  main.c     24 |
|----------------------------------------------------------------|
| | Taille |   Addr    |  Ligne |  Fichier                       |
|----------------------------------------------------------------|
| |     20 | 003D5CB4 |     20 |                         main.c |
|*|      0 | 003D3BD0 |     23 |                         main.c |
|----------------------------------------------------------------|
 
===== free (p[1]) dans main.c:26 =====
        Warning : Pointeur non enregistre 003D5CB5
 
===== free (p[2]) dans main.c:27 =====
        - 0 octects a 003D3BD0 alloue dans main.c:23
 
===== Fuites memoire =====
|----------------------------------------------------------------|
|                        Profile memoire                         |
|                                                  main.c     28 |
|----------------------------------------------------------------|
| | Taille |   Addr    |  Ligne |  Fichier                       |
|----------------------------------------------------------------|
| |     20 | 003D5CB4 |     20 |                         main.c |
|----------------------------------------------------------------|
 
Free 003D5CB0
Fuites reparees
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D5CB0 (28 bytes) realloc'ed at line 303 of '..\src\sma.c' not freed
SYSALLOC Released Memory
FRMWRK.Terminated
 
Press ENTER to continue.

Y'a un bug...

Je propose un meilleure organisation du code (supprimmer les lignes avant le trait /* -------------- */ )

**DaZumba** · 14/06/2006, 10h09

Envoyé par Emmanuel Delahaye

Mon mécanisme (SYSALLOC) n'utilise pas malloc(), sinon, on ne peut rien vérifier du tout (on est pas indépendant).

Je ne comprend pas cette phrase. Ton sys_malloc() est bien un wrapper de malloc(), non ?

**Emmanuel Delahaye** · 14/06/2006, 10h22

Envoyé par DaZumba

Je ne comprend pas cette phrase. Ton sys_malloc() est bien un wrapper de malloc(), non ?

Oui, c'est un wrapper, mais le mécanisme de traçage n'utilise pas malloc(), sinon, on ne s'en sort plus !

http://emmanuel-delahaye.developpez....src/sysalloc.c

Simple application d'un principe de bon sens qui dit : "On ne peut être juge et partie"

**DaZumba** · 14/06/2006, 10h31

Envoyé par Emmanuel Delahaye

le mécanisme de traçage n'utilise pas malloc()

Ah, c'est cela que tu voulais dire ! Ok - c'est evident, en effet.

**fearyourself** · 14/06/2006, 10h37

Cette discussion me rappelle un problème de spécifications... Comment spécifier un outil qui dois spécifier des programmes...

Mais bon, ce programme part d'une bonne idée et permet, jusqu'à un certain degré de vérifier les fuites et les débordements mémoires.

Ensuite, il est vrai, que si les structures de données étaient déclarées statiquement cela pourrait être mieux...

Je trouve que c'est déjà pas mal,
Jc

**Emmanuel Delahaye** · 14/06/2006, 10h41

Envoyé par fearyourself

Cette discussion me rappelle un problème de spécifications... Comment spécifier un outil qui dois spécifier des programmes...

C'est clairement un problème de poule et d'oeuf. Un outil de vérification ne doit pas utiliser les outils qu'il est sensé vérifier...

Mais bon, ce programme part d'une bonne idée et permet, jusqu'à un certain degré de vérifier les fuites et les débordements mémoires.

Si tu arrives à démontrer qu'il ne provoque pas de fuites lui-même, pas de problèmes.

Ensuite, il est vrai, que si les structures de données étaient déclarées statiquement cela pourrait être mieux...

Je trouve que c'est déjà pas mal,

Tu as corrigé la fuite que j'ai signalée ?

**Médinoc** · 14/06/2006, 11h22

[HS]

Envoyé par Emmanuel Delahaye

le mécanisme de traçage n'utilise pas malloc()

En fait, ton mécanisme permet de tracer au maximum len / sizeof (sREC) allocations "simultanées", c'est ça ?
[/HS]

**Emmanuel Delahaye** · 14/06/2006, 11h31

Envoyé par Médinoc

[HS]

En fait, ton mécanisme permet de tracer au maximum len / sizeof (sREC) allocations "simultanées", c'est ça ?
[/HS]

Peut être. La valeur est indiquée au lancement...

Ce que je sais c'est que si ca pète (message d'erreur), je recompile en doublant la taille du bloc statique que je fournis au gestionnaire...

http://emmanuel-delahaye.developpez....nuel-sysalloc/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part