p
u
b
l
i
c
i
t
é
publicité
  1. #1
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 842
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 32
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 842
    Points : 11 523
    Points
    11 523

    Par défaut Gestion de la mémoire

    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/

  2. #2
    Expert Confirmé Sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    décembre 2005
    Messages
    5 005
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2005
    Messages : 5 005
    Points : 10 862
    Points
    10 862

    Par défaut

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

    Jc

  3. #3
    Expert Confirmé Sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    14 509
    Détails du profil
    Informations personnelles :
    Âge : 58
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : décembre 2003
    Messages : 14 509
    Points : 20 178
    Points
    20 178

    Par défaut

    Citation 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 /* -------------- */ )
    Fichiers attachés Fichiers attachés
    • Type de fichier : c main.c (519 octets, 34 affichages)
    • Type de fichier : c list.c (2,5 Ko, 31 affichages)
    • Type de fichier : c sma.c (9,0 Ko, 32 affichages)
    • Type de fichier : h list.h (1,0 Ko, 26 affichages)
    • Type de fichier : h sma.h (2,0 Ko, 22 affichages)
    Pas de Wi-Fi à la maison : CPL

  4. #4
    Membre Expert
    Inscrit en
    décembre 2004
    Messages
    1 478
    Détails du profil
    Informations forums :
    Inscription : décembre 2004
    Messages : 1 478
    Points : 1 661
    Points
    1 661

    Par défaut

    Citation 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 ?

  5. #5
    Expert Confirmé Sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    14 509
    Détails du profil
    Informations personnelles :
    Âge : 58
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : décembre 2003
    Messages : 14 509
    Points : 20 178
    Points
    20 178

    Par défaut

    Citation 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"
    Pas de Wi-Fi à la maison : CPL

  6. #6
    Membre Expert
    Inscrit en
    décembre 2004
    Messages
    1 478
    Détails du profil
    Informations forums :
    Inscription : décembre 2004
    Messages : 1 478
    Points : 1 661
    Points
    1 661

    Par défaut

    Citation 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.

  7. #7
    Expert Confirmé Sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    décembre 2005
    Messages
    5 005
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2005
    Messages : 5 005
    Points : 10 862
    Points
    10 862

    Par défaut

    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

  8. #8
    Expert Confirmé Sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    14 509
    Détails du profil
    Informations personnelles :
    Âge : 58
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : décembre 2003
    Messages : 14 509
    Points : 20 178
    Points
    20 178

    Par défaut

    Citation 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 ?
    Pas de Wi-Fi à la maison : CPL

  9. #9
    Expert Confirmé Sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    décembre 2005
    Messages
    5 005
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2005
    Messages : 5 005
    Points : 10 862
    Points
    10 862

    Par défaut

    Citation 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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  10. #10
    Expert Confirmé Sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    septembre 2005
    Messages
    24 810
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2005
    Messages : 24 810
    Points : 35 968
    Points
    35 968

    Par défaut

    [HS]
    Citation 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]
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  11. #11
    Expert Confirmé Sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    14 509
    Détails du profil
    Informations personnelles :
    Âge : 58
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : décembre 2003
    Messages : 14 509
    Points : 20 178
    Points
    20 178

    Par défaut

    Citation 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
    static char Trace[1 << 8];
    devient
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    static char Trace[1 << 9];
    etc.
    Pas de Wi-Fi à la maison : CPL

  12. #12
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 842
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 32
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 842
    Points : 11 523
    Points
    11 523

    Par défaut

    @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.

    Citation 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

  13. #13
    Expert Confirmé Sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    14 509
    Détails du profil
    Informations personnelles :
    Âge : 58
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : décembre 2003
    Messages : 14 509
    Points : 20 178
    Points
    20 178

    Par défaut

    Citation 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...
    Pas de Wi-Fi à la maison : CPL

  14. #14
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 842
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 32
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 842
    Points : 11 523
    Points
    11 523

    Par défaut

    Citation 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 :
    Citation 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).

  15. #15
    Rédacteur

    Avatar de gege2061
    Femme Profil pro
    Administrateur de base de données
    Inscrit en
    juin 2004
    Messages
    5 842
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 32
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : juin 2004
    Messages : 5 842
    Points : 11 523
    Points
    11 523

    Par défaut

    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 :


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

    Compilation à la rache :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
      sma_init (SMA_INFO, NULL);
    • Pour la compilation, ajoutez simplement l'option -lsma

  16. #16
    Membre confirmé Avatar de ironzorg
    Inscrit en
    juillet 2006
    Messages
    288
    Détails du profil
    Informations forums :
    Inscription : juillet 2006
    Messages : 288
    Points : 205
    Points
    205

    Par défaut

    Tu oublies le ranlib

Discussions similaires

  1. Réponses: 17
    Dernier message: 02/02/2006, 12h03
  2. gestion de la mémoire
    Par moldavi dans le forum C++
    Réponses: 17
    Dernier message: 04/02/2005, 23h18
  3. Réponses: 11
    Dernier message: 26/12/2004, 22h50
  4. Gestion de la mémoire entre plusieurs DLL
    Par Laurent Gomila dans le forum C++
    Réponses: 7
    Dernier message: 27/07/2004, 15h28
  5. Gestion des variables - mémoire ?
    Par RIVOLLET dans le forum Langage
    Réponses: 4
    Dernier message: 26/10/2002, 12h44

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo