Comment realloc devine la taille du bloc mémoire d'origine?

Version imprimable

Bonjour,

Comme vous avez pu le lire dans le titre une question me turlupine sur la fonction realloc :mrgreen: !!!

Vous pouvez voir dans ce post https://www.developpez.net/forums/d1...loc-ca-marche/ que je propose une interprétation de la fonction realloc :
Code:

1 2 3 4 5 6 7 8 9 10 void *realloc(void *blocACopier, size_t nouvelleTaille){ void *tmp=malloc(nouvelleTaille); //allocation d'une nouvelle zone mémoire if(tmp==NULL){ //allocation raté return NULL; } memcopy(tmp, blocACopier, ancienneTaille); //copie free(blocACopier); //libération return tmp; }
On peut y voir que ancienneTaille ne fait pas parti des paramètres et est déterminée par la fonction elle même. Or après plusieurs recherche obtenir la taille d'une zone mémoire allouée dynamiquement avec la bibliothèque standard est impossible, seulement realloc y arrive très bien ! :weird:

D'où ma question : comment elle fait?

Bonjour,
En fait malloc(), calloc() et realloc() allouent au moins 8 octets de plus que demandés, stockent dans ces octets les tailles allouées, et retournent un pointeur augmenté de 8. Le format de ces données n'est pas standardisé, c'est pourquoi on ne doit pas y accéder. Un code possible

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
void *realloc( void *blocACopier , size_t nouvelleTaille ) {
   size_t  alloues = 0;     // bytes réservés
   size_t  taille = 0;      // bytes utilisables
   if ( blocACopier ) {
      alloues = ((size_t*)blocACopier)[-1]; // une structure possible ou une autre?
      taille  = ((size_t*)blocACopier)[-2];
      while ( nouvelleTaille > alloues  &&  la-zone-suivant-le-bloc-est-disponible ) {
         fusionner-le-bloc-avec-le-bloc-suivant-et-trouver-nouvelle-valeur-pour-'alloues'
         ((size_t*)blocACopier)[-1] = alloues;
      }
   }
   if ( nouvelleTaille > alloues ) {        // allocation nécessaire ailleurs
      void *tmp = malloc( nouvelleTaille ); //allocation d'une nouvelle zone mémoire et 2*size_t avant
      if ( !tmp ) return NULL;
      if ( blocAcopier ) {
         memcpy( tmp , blocACopier , taille );
         free( blocACopier );
         blocACopier = tmp;
      }
   }
   else { // assez ou trop grand
      if ( nouvelleTaille + TAILLE_HYSTERESIS < alloues ) { // trop grand
         couper-le-bloc-ne-garder-que-le-necessaire-et-trouver-nouvelle-valeur-pour-'alloues'
         ((size_t*)blocACopier)[-1] = alloues;
      }
      ((size_t*)blocACopier)[-2] = nouvelleTaille;  // noter la nouvelle taille utile
   }
   return blocACopier;
}

09/12/2017, 17h01
theludovyc

Bonjour @dalfab,

Merci pour ta réponse. C'est dommage que ça ne soit pas standardisé, pourquoi un tel choix a t'il été fait?
09/12/2017, 20h01
Jamatronic

Pour interdire aux programmeurs d'aller consulter ces données et faire des bidouilles avec ?

Si vous le faites, c'est à vos risques et périls.
09/12/2017, 21h57
Mat.M

Code:

memcopy(tmp, blocACopier, ancienneTaille);

si ancienneTaille est supérieure à nouvelleTaille bonjour les plantages et dépassement mémoire 8O !
10/12/2017, 13h19
theludovyc

Citation:

Envoyé par Jamatronic

Pour interdire aux programmeurs d'aller consulter ces données et faire des bidouilles avec ?

Si vous le faites, c'est à vos risques et périls.

Bonjour @Jamatronic,
Je ne vois pas l'intérêt d'interdire cela au programmeur. Le faire d'accord, où est ce que je peut trouvé des tutos précis là dessus?

Citation:

Envoyé par Mat.M

Code:

memcopy(tmp, blocACopier, ancienneTaille);

si ancienneTaille est supérieure à nouvelleTaille bonjour les plantages et dépassement mémoire 8O !

Bonjour @Mat.M
J'ai mis un lien vers mon post ou j'explique que je fait cette interprétation qu'en cas d'une augmentation.
11/12/2017, 18h14
Médinoc

Citation:

Envoyé par dalfab

Bonjour,
En fait malloc(), calloc() et realloc() allouent au moins 8 octets de plus que demandés, stockent dans ces octets les tailles allouées, et retournent un pointeur augmenté de 8.

C'est un détail d'implémentation et rien ne garantie que ce soit vraiment le cas (un OS pourrait stocker ses tailles quelque part en espace Kernel à la place, voire les déduires de ses listes chaînées de blocs...).

Le fait est que le standard C ne prévoit aucun moyen de demander à l'implémentation la taille d'un bloc alloué. Choix délibéré ou oubli, je l'ignore.
D'autres bibliothèques faisant de l'allocation de mémoire (comme les diverses de Windows) proposent de telles fonctions (LocalSize()/GlobalSize() pour LocalAlloc()/GlobalAlloc() (retournent la taille réelle du bloc, qui peut être plus grande que celle initialement demandée), HeapSize() pour HeapAlloc(), VirtualQuery() pour VirtualAlloc(), mais rien pour la mémoire allouée via CoTaskMemAlloc())

Résultat, si tu fais un programme en C standard, c'est à toi de garder trace des tailles allouées (y compris, par exemple, en utilisant la tactique mentionnée par dalfab).
11/12/2017, 18h28
Matt_Houston

Citation:

Envoyé par Médinoc

Choix délibéré ou oubli, je l'ignore.

Quelle en serait l'utilité ? Ce serait imposer d'énormes contraintes au système d'allocation pour bien peu d'avantages offerts au programmeur au final.

@dalfab : même si ce que tu écris était vérifié dans 85% des cas ça reste de la pure spéculation. La libc fait ce qu'elle veut en fin de compte.
11/12/2017, 19h28
Christophe

malloc fonctionne sur des systèmes différents allant de Linux à MS-DOS. Il peut donc être logique que la façon dont la fonction gère l'allocation soit différente et qu'il ne faille pas "bricoler". C'est l'intérêt d'une fonction système, tu ne te préoccupe pas de son fonctionnement, tu lui donnes une (ou plusieurs) entrée(s) et tu attend un résultat en sortie.

Tu peux toujours étudier le code source de la fonction.

Ou plus facile d'accès un tuto comme celui-ci :
http://www.inf.udec.cl/~leo/Malloc_tutorial.pdf
12/12/2017, 11h45
theludovyc

Merci pour vos réponses c'est hyper enrichissant :) !

On s'éloigne un peu du sujet alors j'ai ouvert une nouvelle discussion https://www.developpez.net/forums/d1...irie-standard/