Gestion de la mémoire [Sources]

[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

Voici un p'tit exemple :

Code :

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 :

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]

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

Jc

[Emmanuel Delahaye]

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 :

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]

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]

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]

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]

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]

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 ?

[fearyourself]

Envoyé par Emmanuel Delahaye

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

Est-ce vraiment nécessaire? Je veux dire, si on sait déterminer les fuites de l'utilisateur, est-ce obligatoire de garantir qu'on ne provoque pas de fuites?

Je parle bien sûr dans l'optique où le programme est là pour seulement détecter les fuites... Bien sûr ce n'est pas génial, mais est-ce nécessaire?

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

Il ne désalloue pas correctement (enfin on dirait)

Code :

1
2
3
4
 
    fprintf (stream, "Free %p\n", obj->real_start);
    obj_remove (obj);
    free (obj), obj = NULL;

J'aurais plutôt mis :

Code :

1
2
3
4
 
    fprintf (stream, "Free %p\n", obj->real_start);
    free(obj->real_start), obj->real_start = NULL;
    obj_remove (obj);

De plus j'ai l'impression qu'il y a un double free sur ce code... le free(obj) est déjà fait dans l'appel obj_remove (qui appelle list_remove qui le fait...)

Jc

[Médinoc]

[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]

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 :

static char Trace[1 << 8];

devient

Code :

static char Trace[1 << 9];

etc.

[gege2061]

@Emmanuel Delahaye : bien sûr que l'on tourne en rond (pour l'oeuf et la poule c'est connu depuis longtemps qui a été le premier). C'est pour ça que le but est de rendre ce module sûr.

Envoyé par Emmanuel Delahaye

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

Pas compris Qu'est ce que tu appel mécanisme de traçage ?

Merci pour les corrections je vais regarder ça

[Emmanuel Delahaye]

Envoyé par gege2061

Pas compris Qu'est ce que tu appel mécanisme de traçage ?

Le code en plus qui enregistre les données d'allocation (fonction, adresse, taille, fichier, ligne) et qui sont appairées par la fonction de libération.

J'ai du mal à comprendre ta question, vu que tu as un mécanisme équivallent chez toi...

[gege2061]

Envoyé par Emmanuel Delahaye

Le code en plus qui enregistre les données d'allocation (fonction, adresse, taille, fichier, ligne) et qui sont appairées par la fonction de libération.

J'ai du mal à comprendre ta question, vu que tu as un mécanisme équivallent chez toi...

Nan c'est moi qui comprend rien :

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 pensais que tu n'utilisais pas malloc en interne pour allouer de la mémoire (d'où mon étonnement).

[gege2061]

Pour ceux que ça intéresse, le projet est toujours en développement !

Je pense fixer la version 1 d'ici peux donc si vous avez des remarques :

• Les sources sont disponibles via subversion : http://subversion.developpez.com/pro...1/C/sma/trunk/
  
  Code :

  svn co http://subversion.developpez.com/projets/gege2061/C/sma/trunk/ libsma

• La documentation en ligne : http://nicolasj.developpez.com/sma/sma_8h.html

Si vous n'avez pas Code::Blocks, le makefile devrait arriver d'ici peu.

Compilation à la rache :

Code :

cd libsma && gcc -c *.c && ar rcs libsma.a *.o

Déploiement :

• Copier sma.h et libsma.a dans le dossier de votre projet
• Inclure sma.h en tant que dernier header dans tout les fichiers de votre projet
• Ajouter la ligne suivante au début du main :
  
  Code :

  sma_init (SMA_INFO, NULL);

• Pour la compilation, ajoutez simplement l'option -lsma

[ironzorg]

Tu oublies le ranlib