IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Réseau C Discussion :

mon realloc perso


Sujet :

Réseau C

  1. #41
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    C'est uniquement un traceur de mémoire dynamique. C'est à toi d'écrire le pool, mais est-ce bien nécessaire ? Sur tous les systèmes embarqués où j'avais un malloc()/free() opérationnel, je n'ai jamais eu besoin de pool.
    En fait, a priori, oui ! J'ai vu sur internet que le pool etait necessaire pour qu'une interruption ne fasse pas un malloc sur un bloc memoire qui est en train d'etre alloué...

    J'ai repris le code permettant de faire le pool :

    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
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
     
    void heap_init(int size) {
        wHeapStart=(wHeapRecord *)malloc(size);
        wHeapFirst=wHeapStart;
        wHeapStart->flags=WHEAP_RECORD_FLAG_UNUSED;
        wHeapStart->next=0;
        wHeapStart->size=size-sizeof(wHeapRecord);
    }
     
    void * Monmalloc(size_t size) {
        wHeapRecord * rec = wHeapFirst;
        void * voidptr;
        int n;
        size=(size+3)&(~3);
        if(size==0) size=4;
        size+=WHEAP_PAD_SIZE;
        if(!rec) { fprintf(stderr, "wHeapAlloc: heap full!"); return 0; } // should not happen given normal use.
        while(rec->size<size) {
    		fprintf(stderr, "ok1\n");
            if(!rec->next) { fprintf(stderr, "wHeapAlloc: heap too full!"); return 0; } // cannot alloc
            if(rec->next->flags!=WHEAP_RECORD_FLAG_INUSE) { // try to merge with next one
                rec->size+=rec->next->size+WHEAP_RECORD_SIZE;
                rec->next=rec->next->next;
            } else { // skip ahead to more friendly waters
                rec=rec->next;
                while(rec->next) {
                    if(rec->flags!=WHEAP_RECORD_FLAG_INUSE) break;
                    rec=rec->next;
                }
                if(rec->flags==WHEAP_RECORD_FLAG_INUSE) { fprintf(stderr, "wHeapAlloc: heap too full!"); return 0; } // no empty slots :(
            }
        }
        rec->flags=WHEAP_RECORD_FLAG_INUSE;
        n=rec->size-size;
    	if(rec <= NULL)
    		fprintf(stderr, "rec null\n");
    	if(sizeof(wHeapRecord) == 0)
    		fprintf(stderr, "wHeapRecord = 0\n");
     
        voidptr = ((char *)rec)+sizeof(wHeapRecord)+WHEAP_PAD_START;
     
        if(n<WHEAP_SIZE_CUTOFF) { // pad to include unused portion
            rec->unused=n;
        } else { // chop block into 2
            wHeapRecord * rec2;
            rec2=(wHeapRecord *)(((char *)rec)+WHEAP_RECORD_SIZE+size);
            rec2->flags=WHEAP_RECORD_FLAG_UNUSED;
            rec2->size=rec->size-size-WHEAP_RECORD_SIZE;
            rec->size=size;
            rec2->next=rec->next;
            rec->next=rec2;
            rec->unused=0;
        }
     
        if(rec==wHeapFirst) {
     
            while(wHeapFirst->next && wHeapFirst->flags==WHEAP_RECORD_FLAG_INUSE) wHeapFirst=wHeapFirst->next;
            if(wHeapFirst->flags==WHEAP_RECORD_FLAG_INUSE) {wHeapFirst=0;}
        }
     
        return voidptr;    
    }
     
     
    void Monfree(void * data) {
        wHeapRecord * rec = (wHeapRecord *)(((char *)data)-WHEAP_RECORD_SIZE-WHEAP_PAD_START);
        if(rec->flags!=WHEAP_RECORD_FLAG_INUSE) { // note heap error
            fprintf(stderr, "wHeapFree: Data already freed! 0x%X",data);
        }
        rec->flags=WHEAP_RECORD_FLAG_FREED;
        if(rec<wHeapFirst || !wHeapFirst) wHeapFirst=rec; // reposition the "starting" pointer.
    }
    Bon ce code est censé marché mais renvoie NULL pour l'une de mes allocations sans renvoyer d'erreur... En fait, c'est le voidptr qui est null.. Je comprends bien pourquoi..

    Sinon a part faire ce pool, je ne vois pas comment resoudre mon probleme car je ne comprends pas sa cause..

  2. #42
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    En fait, a priori, oui ! J'ai vu sur internet que le pool etait necessaire pour qu'une interruption ne fasse pas un malloc sur un bloc memoire qui est en train d'etre alloué...
    Exact mais on avait un système qui nous permettait d'envoyer des message à une tâche. Sinon, effectivement, on utilisait alors un pool fixe extrêmement simple et rapide.

    Usage :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    /* creation */
       #define BLOCK_SIZE 128
       #define NB_BLOCKS 8
     
       pool_s mypool = pool_create (BLOCK_SIZE, NB_BLOCKS);
     
    /* utilisation */
       char *p = pool_alloc(mypool);
       /* ... */
       pool_free (mypool, p);
     
    /* terminaison */
       pool_delete (mypool);
    J'ai repris le code permettant de faire le pool :
    Bon ce code est censé marché
    Ce code est incomplet, je ne vois pas bien ce que je peux faire...
    Pas de Wi-Fi à la maison : CPL

  3. #43
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    En fait, j'utilise le code cette facon.. Je ne me sers que de ces trois fonctions.. Je n'avait pas l'impression qu'il etait incomplet.. c'est peut etre pour ca que j'ai du mal a le faire marcher.. La plupart du temps, tout fonctionne mais de temps en temps ca me renvoie NULL..

    Pour ton pool, le code ressemble a celui que je t'ai envoyé ou le tien est plus efficace ?

    Sinon pour apporter de l'eau au moulin, j'ai remarqué un truc tres bizarre.. Si je mets un printf ds le malloc, le programme reste bloqué dessus et me l'affiche en boucle comme si il etait ds une boucle infinie sans que le programme soit planté pour autant... Si je ne mets pas ce printf, il sort normalement du malloc...

    ??? KES KI SE PASSE ???

  4. #44
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    Non d'accord, je viens de comprendre.. Il manquait ca :

    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
     
    #define WHEAP_RECORD_FLAG_INUSE     0
    #define WHEAP_RECORD_FLAG_UNUSED    1
    #define WHEAP_RECORD_FLAG_FREED     2
     
    typedef struct WHEAP_RECORD {
        struct WHEAP_RECORD * next;
        unsigned short flags, unused;
        int size;
    } wHeapRecord;
     
     
    #define WHEAP_PAD_START     0
    #define WHEAP_PAD_END       0
    #undef WHEAP_DO_PAD
    #define WHEAP_RECORD_SIZE   (sizeof(wHeapRecord))
    #define WHEAP_PAD_SIZE      ((WHEAP_PAD_START)+(WHEAP_PAD_END))
    #define WHEAP_SIZE_CUTOFF   ((WHEAP_RECORD_SIZE)+64)
    Desolé, lundi matin difficile !

  5. #45
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    Non d'accord, je viens de comprendre.. Il manquait ca :
    C'est encore incomplet. Ceci fonctionne :
    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
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
     
    #include <stdlib.h>
    #include <stdio.h>
     
    #define WHEAP_RECORD_FLAG_INUSE     0
    #define WHEAP_RECORD_FLAG_UNUSED    1
    #define WHEAP_RECORD_FLAG_FREED     2
     
    typedef struct WHEAP_RECORD
    {
       struct WHEAP_RECORD *next;
       unsigned short flags, unused;
       int size;
    }
    wHeapRecord;
     
     
    #define WHEAP_PAD_START     0
    #define WHEAP_PAD_END       0
    #undef WHEAP_DO_PAD
    #define WHEAP_RECORD_SIZE   (sizeof(wHeapRecord))
    #define WHEAP_PAD_SIZE      ((WHEAP_PAD_START)+(WHEAP_PAD_END))
    #define WHEAP_SIZE_CUTOFF   ((WHEAP_RECORD_SIZE)+64)
     
     
    static wHeapRecord *wHeapStart;
    static wHeapRecord *wHeapFirst;
     
     
    void heap_init (int size)
    {
       wHeapStart = (wHeapRecord *) malloc (size);
       wHeapFirst = wHeapStart;
       wHeapStart->flags = WHEAP_RECORD_FLAG_UNUSED;
       wHeapStart->next = 0;
       wHeapStart->size = size - sizeof (wHeapRecord);
    }
     
    void *Monmalloc (size_t size)
    {
       wHeapRecord *rec = wHeapFirst;
       void *voidptr;
       int n;
       size = (size + 3) & (~3);
       if (size == 0)
          size = 4;
       size += WHEAP_PAD_SIZE;
       if (!rec)
       {
          fprintf (stderr, "wHeapAlloc: heap full!");
          return 0;
       }                            // should not happen given normal use.
       while (rec->size < size)
       {
          fprintf (stderr, "ok1\n");
          if (!rec->next)
          {
             fprintf (stderr, "wHeapAlloc: heap too full!");
             return 0;
          }                         // cannot alloc
          if (rec->next->flags != WHEAP_RECORD_FLAG_INUSE)
          {                         // try to merge with next one
             rec->size += rec->next->size + WHEAP_RECORD_SIZE;
             rec->next = rec->next->next;
          }
          else
          {                         // skip ahead to more friendly waters
             rec = rec->next;
             while (rec->next)
             {
                if (rec->flags != WHEAP_RECORD_FLAG_INUSE)
                   break;
                rec = rec->next;
             }
             if (rec->flags == WHEAP_RECORD_FLAG_INUSE)
             {
                fprintf (stderr, "wHeapAlloc: heap too full!");
                return 0;
             }                      // no empty slots :(
          }
       }
       rec->flags = WHEAP_RECORD_FLAG_INUSE;
       n = rec->size - size;
       if (rec <= NULL)
          fprintf (stderr, "rec null\n");
       if (sizeof (wHeapRecord) == 0)
          fprintf (stderr, "wHeapRecord = 0\n");
     
       voidptr = ((char *) rec) + sizeof (wHeapRecord) + WHEAP_PAD_START;
     
       if (n < WHEAP_SIZE_CUTOFF)
       {                            // pad to include unused portion
          rec->unused = n;
       }
       else
       {                            // chop block into 2
          wHeapRecord *rec2;
          rec2 = (wHeapRecord *) (((char *) rec) + WHEAP_RECORD_SIZE + size);
          rec2->flags = WHEAP_RECORD_FLAG_UNUSED;
          rec2->size = rec->size - size - WHEAP_RECORD_SIZE;
          rec->size = size;
          rec2->next = rec->next;
          rec->next = rec2;
          rec->unused = 0;
       }
     
       if (rec == wHeapFirst)
       {
     
          while (wHeapFirst->next && wHeapFirst->flags == WHEAP_RECORD_FLAG_INUSE)
             wHeapFirst = wHeapFirst->next;
          if (wHeapFirst->flags == WHEAP_RECORD_FLAG_INUSE)
          {
             wHeapFirst = 0;
          }
       }
     
       return voidptr;
    }
     
     
    void Monfree (void *data)
    {
       wHeapRecord *rec =
          (wHeapRecord *) (((char *) data) - WHEAP_RECORD_SIZE - WHEAP_PAD_START);
       if (rec->flags != WHEAP_RECORD_FLAG_INUSE)
       {                            // note heap error
          fprintf (stderr, "wHeapFree: Data already freed! %p", data);
       }
       rec->flags = WHEAP_RECORD_FLAG_FREED;
       if (rec < wHeapFirst || !wHeapFirst)
          wHeapFirst = rec;         // reposition the "starting" pointer.
    }
     
     
    #ifdef TEST
    #include <string.h>
     
    int main (void)
    {
       heap_init (64);
     
       char *s = Monmalloc (52);
     
       if (s != NULL)
       {
          strcpy (s, "hello world !");
          puts (s);
          Monfree (s), s = NULL;
       }
       return 0;
    }
    #endif
    Mais il y a des warnings étranges...
    Project : Forums
    Compiler : GNU GCC Compiler (called directly)
    Directory : C:\dev\forums2\
    --------------------------------------------------------------------------------
    Switching to target: default
    Compiling: main.c
    main.c: In function `Monmalloc':
    main.c:52: warning: comparison between signed and unsigned
    main.c:83: warning: comparison of distinct pointer types lacks a cast
    main.c:90: warning: comparison between signed and unsigned
    Linking console executable: C:\dev\forums2\console.exe
    Process terminated with status 0 (0 minutes, 3 seconds)
    0 errors, 3 warnings
    Et quand je passe le code au détecteur de mensonges :
    SYSALLOC Err: Not-matched list:
    SYSALLOC Bloc 003D24E8 (64 bytes) malloc'ed at line 35 of 'main.c' not freed
    Pas de Wi-Fi à la maison : CPL

  6. #46
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    tient, c'est bizarre, je n'ai pas ces warning..

    ca fait bizarre de te demander ca a toi mais, je peux voir ton main ?

    Sinon, je ne trouve pas ton mem.h dans la liste des fichiers a inclure pour l'utilisation de sysmalloc...

    Et pour finir, un nouveau truc bizarre, quand j'utilise le pool, je ne peux plus utiliser les printf pour afficher des valeurs comme int, etc.. ca ne marche pas non plus avec les fprintf(stdout,... ou stderr...

    Comprend toujours ps..

  7. #47
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    tient, c'est bizarre, je n'ai pas ces warning..
    http://emmanuel-delahaye.developpez....tm#cfg_compilo
    ca fait bizarre de te demander ca a toi mais, je peux voir ton main ?
    ... surtout qu'il est dans le code que j'ai posté...
    Sinon, je ne trouve pas ton mem.h dans la liste des fichiers a inclure pour l'utilisation de sysmalloc...
    OK, j'ai ajouté le lien (changement récent, oups...)
    Et pour finir, un nouveau truc bizarre, quand j'utilise le pool, je ne peux plus utiliser les printf pour afficher des valeurs comme int, etc.. ca ne marche pas non plus avec les fprintf(stdout,... ou stderr...
    Chez moi, ça fonctionne. Montre le code exact qui ne fonctionne pas.
    Pas de Wi-Fi à la maison : CPL

  8. #48
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    Desolé, je n'avais pas été jusqu'au bout du post... !! Le undi est vraiment difficile...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    void memoryReport(void)
    {
    	wHeapRecord * rec = wHeapFirst;
    	if(rec == NULL)
    		printf("rec null..\n");
    	while(rec != NULL)
    	{
    		printf("grr\n");
    		fprintf(stdout, "std size = %d\n", rec->size);
    		printf("size = %d\n", rec->size);
    		rec = rec->next;
    	}
    }
    Dans ce code, le "grrr" (qui signifie que ca commence a me gonfler ;-) ) s'affiche mais pas le reste...

    sinon, ok pour le reste.. Je vais modifier mon compilo. Pour ce qui est du pool, si tu en as un autre plus efficace, je susi preneur.. Sans vouloir abuser.. !!

    Pour le sysalloc, je l'ai compilé en .a mais il me dit, a l'utilisation :

    undefined reference to sys_mem_init.... pourtant j'ai bien placé le .a dans le bon repertoire..

  9. #49
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    void memoryReport(void)
    {
    	wHeapRecord * rec = wHeapFirst;
    	if(rec == NULL)
    		printf("rec null..\n");
    	while(rec != NULL)
    	{
    		printf("grr\n");
    		fprintf(stdout, "std size = %d\n", rec->size);
    		printf("size = %d\n", rec->size);
    		rec = rec->next;
    	}
    }
    Dans ce code, le "grrr" (qui signifie que ca commence a me gonfler ;-) ) s'affiche mais pas le reste...
    Bizarre. En appelant cette ronction juste avant le retour de main(), j'obtiens ceci :
    <...>
    hello world !
    grr
    std size = 52
    size = 52
    <...>
    SYSALLOC Err: Not-matched list:
    SYSALLOC Bloc 003D24E8 (64 bytes) malloc'ed at line 35 of 'main.c' not freed
    <...>
    Press ENTER to continue.
    Ce qui me parait tout ce qu'il y a de correct...
    sinon, ok pour le reste.. Je vais modifier mon compilo.
    Pas besoin de le patcher, une simple modification de configuration suffira
    Pour ce qui est du pool, si tu en as un autre plus efficace, je susi preneur.. Sans vouloir abuser.. !!
    Je n'en ai pas sous la main, mais ça se code en quelques lignes...
    Pour le sysalloc, je l'ai compilé en .a mais il me dit, a l'utilisation :

    undefined reference to sys_mem_init.... pourtant j'ai bien placé le .a dans le bon repertoire.
    C'est donc une bibliothèque statique. Quelle est son nom exact ? Il faut l'ajouter au projet comme n'importe quelle autre bibliothèque statique...
    Pas de Wi-Fi à la maison : CPL

  10. #50
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    je lui ai donné le nom libsysalloc... Je l'ai placé avec mes autres .a. j'ai aussi ajouté -lsysalloc dans la liste des lib statique a ajouter..

    J'ai modifié la structure wHeapRecord. J'ai mis unsigned int au lieu du int mais ca ne change rien.. ca marche toujours pas.

    Pour ce qui est du pool.. Tu penses qu'il vaut mieux que j'évite d'utiliser celui que je t'ai montré ? Ca se code en quelques lignes ? Je vais regarder si je ne trouve pas ca sur le net car je ne vois pas comment faire ca... Je n'avais jamais entendu parlé de ca avant vendredi !

  11. #51
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    je lui ai donné le nom libsysalloc... Je l'ai placé avec mes autres .a. j'ai aussi ajouté -lsysalloc dans la liste des lib statique a ajouter..
    As-tu défini la macro globale DBG_SYSALLOC comme indiqué dans la doc ?
    J'ai modifié la structure wHeapRecord. J'ai mis unsigned int au lieu du int mais ca ne change rien.. ca marche toujours pas.
    C'est à dire ? Attention, si il y a des tests avec des valeurs < 0, tu as peut être tout cassé...
    Pour ce qui est du pool.. Tu penses qu'il vaut mieux que j'évite d'utiliser celui que je t'ai montré ?
    Il y a quelques chacaleries comme <= NULL ! Mais si il est vendu comme validé, pourquoi pas...
    Ca se code en quelques lignes ? Je vais regarder si je ne trouve pas ca sur le net car je ne vois pas comment faire ca... Je n'avais jamais entendu parlé de ca avant vendredi !
    Et tu faisais le code toi même ? C'est pas difficile. Pour un pool de N blocks de taille T, Il suffit de gérer un tableau de N structures contenant l'adresse du bloc i (i de 0 à N-1) et un indicateur 'libre/occupé'. C'est rien du tout.

    Dans l'init (pool_create()), tu crées un gros bloc (il peut être unique et contigu), le tableau de structures, tu l'initialises avec les bonnes adresses.

    pool_alloc() cherche le premier bloc libre, le marque occupé et retourne son adresse. Si rien n'est libre, il retourne NULL.

    pool_free() cherche le bloc et le marque libre.

    pool_delete() détruit tout ce qui a été crée.

    Pour une implémentation 'professionnelle', je recommande un ADT.

    http://emmanuel-delahaye.developpez.com/tad.htm
    Pas de Wi-Fi à la maison : CPL

  12. #52
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    en fait, je l'ai ajouté dans les options du compilo.. mais en fait, je ne sais pas bien ce qu'il faut en faire de cette variable...

    J'ai également tenté de mettre les fichiers directements dans le projet (plus exactement dans les fichiers sources de la librairie open source que j'utilise dans laquelle se trouve notament la definitions de mes malloc)

    Maintenant ce n'est plus sys_mem_init qui n'est plus defini mais assert_fail...

  13. #53
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    en fait, je l'ai ajouté dans les options du compilo.. mais en fait, je ne sais pas bien ce qu'il faut en faire de cette variable...
    Euh, tu parles de quoi ? Il faut citer, sinon, on ne comprend rien...
    Pas de Wi-Fi à la maison : CPL

  14. #54
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    excuse moi.. C'est vrai que ca devient de plus en plus brouillon..

    Je voulai parler de la macro globale DBG_SYSALLOC.. Je ne sais pas comment la definir.. Est ce dans le compilo ou dans un des fichiers.. Et quelle valeur lui donner ?

    C'est bon, ca compil.. J'ai ajouté le fichier assert.c dans le projet tout simplement...

    Maintenant ca compil. Il me suffit d'ajouter sysalloc.h a tous les fichiers qui font des malloc c bien ca ? Alors jai du boulot car la librairie open source que j'utilise possède de nombreux fichiers !

  15. #55
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    Je voulai parler de la macro globale DBG_SYSALLOC.. Je ne sais pas comment la definir.. Est ce dans le compilo ou dans un des fichiers.. Et quelle valeur lui donner ?
    Il suffit de la définir sur la ligne de commandedu compilateur. Il n'y a pas de valeur à donner. Avec gcc, c'est -Dmamacro, soit :

    -DDBG_SYSALLOC

    c'est tout.

    Avec Code::Blocks, il y a une zone "#defines" dans la configuration du compilateur. Tu peux y mettre DBG_SYSALLOC.

    C'est bon, ca compil.. J'ai ajouté le fichier assert.c dans le projet tout simplement...
    Exact, je l'ai oublié. Je vais mettre à jour la doc. (C'est aussi un changement récent, désolé, moi, je ne m'en rend pas compte, car je fais une seule bibliothèque avec tous les sources...)
    Maintenant ca compil. Il me suffit d'ajouter sysalloc.h a tous les fichiers qui font des malloc c bien ca ? Alors jai du boulot car la librairie open source que j'utilise possède de nombreux fichiers !
    Oui, c'est la seule contrainte. En première ligne des .c, on est bien d'accord (avant tout autre #include).

    Tu remarqueras que gràce à ce système le code lui même n'est pas modifié.

    Attention quand même, la méthode a ses limites. Si il y a des malloc()/free() dans des bibliothèques pré-compilées dont tu n'as pas les sources (strdup(), par exemple), évidemment, SYSALLOC n'en saura rien et le bilan sera faux.
    Pas de Wi-Fi à la maison : CPL

  16. #56
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    Emmanuel Delahaye :

    Il suffit de la définir sur la ligne de commandedu compilateur. Il n'y a pas de valeur à donner. Avec gcc, c'est -Dmamacro, soit :

    -DDBG_SYSALLOC
    Ah daccord.. J'ai appris un truc !

    Bon donc ca compil a present.. Tache suivante : trouver comment ca marche ! lol

    Est ce que tu as une explication pour mes printf qui ne fonctionnent pas ?

    Une autre question concernant l'utilisation de sysalloc, le malloc est détourné quoiqu'il arrive ou il faut impérativement que le fichier sysalloc.h soit présent ?

    Si je définis par exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Monmalloc(int size)
    {
        malloc(size);
    }
    dans un fichier a part, il suffit que je mette l'include uniquement dans le fichier ou est definie Monmalloc pour qu'il soit prit en compte par sysmalloc non ? J'espere que je susi assez clair...

    D'autre part, c'est pas de bol mais le programme que j'ai repris utilise beaucoup la fonction strdup... j'avoue que je ne comprends pas bien pourquoi ni a quoi sert trop cette fonction qui ne fait que dupliquer une chaine de caractére... Il risque donc s'y avoir un ecart entre le rapport de sysalloc et la reallité..

  17. #57
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    ca y est j'ai mis en pratique le sysmalloc...

    J'ai placé l'include en première ligne de tous les fichiers .c contenant des malloc..

    J'ai également mis le SYS_INIT sur ON pour avoir toutes les traces possibles et j'ai viré le pool que je t'ai montré précédement.

    Premier constat, mon programme ne plante presque plus... Je ne sais pas si cela est du au sysmalloc.

    Second constat, je n'ai pas de traces a chaques fois que je fais un malloc mais seulement lorsque j'utilise la fonction sys_mem_trace ()..

    Est ce normal ?

  18. #58
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    Une autre question concernant l'utilisation de sysalloc, le malloc est détourné quoiqu'il arrive ou il faut impérativement que le fichier sysalloc.h soit présent ?
    Si je définis par exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Monmalloc(int size)
    {
        malloc(size);
    }
    dans un fichier a part, il suffit que je mette l'include uniquement dans le fichier ou est definie Monmalloc pour qu'il soit prit en compte par sysmalloc non ?
    Si c'est centralisé comme ça, oui, mais mon système de trace va perdre de son intérêt, car il va toujours indiquer les même lignes du même fichier. Seul l'adresse (pas très parlante...) et la taille (un peu plus significative) seront différentes...

    malloc(), realloc(), calloc() et free() sont 'détournées' dans tous les fichiers qui 'voient' "ed/inc/sysalloc.h"
    D'autre part, c'est pas de bol mais le programme que j'ai repris utilise beaucoup la fonction strdup... j'avoue que je ne comprends pas bien pourquoi ni a quoi sert trop cette fonction qui ne fait que dupliquer une chaine de caractére... Il risque donc s'y avoir un ecart entre le rapport de sysalloc et la reallité..
    Dans ce cas, il faut récupérer le module STR (et ce qui manque ?), et il suffit d'ajouter ces 2 lignes dans les fichiers qui utilisent strdup :

    #include "ed/inc/str.h"
    #define strdup(s) STR_dup(s)

    puis d'ajouter le module STR à la bibliothèque.

    Tous les strdup() seront alors redirigés vers mon STR_dup() qui utilise malloc() avec "ed/inc/sysalloc.h" et le compte sera bon.
    Pas de Wi-Fi à la maison : CPL

  19. #59
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par gdpasmini
    J'ai également mis le SYS_INIT sur ON pour avoir toutes les traces possibles et j'ai viré le pool que je t'ai montré précédement.
    En principe, avec ON, on a les traces en temps réel sur stdout (ou stderr, je ne sais plus) si on est pas dans une interruption, évidemment... (tiens, c'est peut être ça ton problème de printf() qui ne fonctionne pas...)
    Premier constat, mon programme ne plante presque plus... Je ne sais pas si cela est du au sysmalloc.
    En principe non, mais j'empêche peut être de libérer avec NULL... Ca soigne peut être une non conformité de ton implémentation de free()...

    En fait, non free() est appelé systématiquement. :
    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
    /* ---------------------------------------------------------------------
       sys_free()
       ---------------------------------------------------------------------
       Role :
       ---------------------------------------------------------------------
       E : adresse
       S :
       --------------------------------------------------------------------- */
    void sys_free (void *const p
                   ,char const *const szFile
                   ,int const line)
    {
       free (p);
     
    #if DBG
       if (p)
       {
          put (&G_Trace, p, 0, ACT_FREE, szFile, line, G_Trace.eTrace);
          cnt_dec (&G_Trace.count.allocated);
       }
    #else
       (void) szFile;
       (void) line;
    #endif
    }
    Le fait que le comportement change est le signe qu'il y a un comportement indéfini dans ton code. (Un bug quoi...)
    Second constat, je n'ai pas de traces a chaques fois que je fais un malloc mais seulement lorsque j'utilise la fonction sys_mem_trace ()..

    Est ce normal ?
    En principe, non, mais voir ci-dessus.
    Pas de Wi-Fi à la maison : CPL

  20. #60
    Membre régulier
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    382
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 382
    Points : 80
    Points
    80
    Par défaut
    Ok c'st bon j'ai fait tout ca !

    Merci !

    Pour le sys_init qui est maintenant sur ON, il ne parle toujours pas bcp.. Mais mon programme ne plante plus bcp non plus..

    Tu trouve ca bizarre ou ton module aurait pu améliorer la gestion de la memoire ?

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Vos avis sur mon site perso
    Par Fildz dans le forum Mon site
    Réponses: 12
    Dernier message: 19/08/2006, 23h07
  2. Mon site perso
    Par matech dans le forum Mon site
    Réponses: 11
    Dernier message: 09/08/2006, 00h29
  3. Probléme d'execution de mon Kernel perso
    Par bouazza92 dans le forum C
    Réponses: 54
    Dernier message: 05/08/2006, 13h16
  4. Mon site perso : les pages d'Alex6891 - avis
    Par alex6891 dans le forum Mon site
    Réponses: 10
    Dernier message: 25/07/2006, 18h35
  5. [C#] Comment implementer mon Navigateur perso par défaut ?
    Par ArHacKnIdE dans le forum Windows Forms
    Réponses: 8
    Dernier message: 12/02/2006, 19h53

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