Question

Bien qu'il ya beaucoup de différentes implémentations complexes de malloc / free pour C / C ++, je suis à la recherche d'un très simple et (surtout) petit qui fonctionne sur un tampon de taille fixe et supports realloc. Réentrance etc. ne sont pas nécessaires et mes objets sont petites et ne varient beaucoup en taille. Y at-il mise en œuvre que vous pourriez recommander?

EDIT :

Je vais utiliser cette mise en œuvre pour un tampon de communication au niveau du récepteur à des objets de transport avec une taille variable (inconnue au récepteur). Les objets attribués ne vivrai pas longtemps, mais il y a peut-être plusieurs objets utilisés en même temps.

Comme tout le monde semble recommander l'malloc standard, je devrais peut-être reformuler ma question. Ce que j'ai besoin est la mise en œuvre de malloc « simple » au-dessus d'un tampon que je peux commencer à optimiser pour mes propres besoins. Peut-être que la question initiale était peu claire parce que je ne suis pas à la recherche d'un malloc optimisé, que pour un simple. Je ne veux pas commencer par une glibc-malloc et l'étendre, mais avec un poids léger.

Était-ce utile?

La solution

Kerninghan et Ritchie semblent avoir fourni un petit malloc / gratuit dans leur livre C - c'est exactement ce que je cherchais (reimplementation trouvé ici) . Je vais ajouter un simple realloc.

Je serait toujours heureux au sujet des suggestions pour d'autres implémentations aussi simples et concis que celui-ci (par exemple, en utilisant une liste doublement chaînée).

Autres conseils

Je recommande celui qui est venu avec la bibliothèque standard fourni avec votre compilateur.

Il faut également noter qu'il n'y a aucun moyen juridique de redéfinir malloc / gratuit

Le malloc / free / realloc qui viennent avec votre compilateur sont presque certainement mieux que certaines fonctions que vous allez brancher.

Il est possible d'améliorer les choses pour les objets de taille fixe, mais cela ne comporte pas en général d'essayer de remplacer le malloc mais complétant avec pools de mémoire . En règle générale, vous devez utiliser malloc pour obtenir une grande partie de la mémoire que vous pouvez diviser en blocs distincts de la taille appropriée, et de gérer ces blocs.

Il me semble que vous êtes à la recherche d'un pool de mémoire. bibliothèque Apache Runtime a une assez bonne, et il est trop multiplateformes.

Il ne peut pas être tout à fait léger, mais la source est ouvert et vous pouvez le modifier.

Je réinventer généralement pas la roue avec des fonctions d'allocation à moins que mon modèle mémoire l'utilisation est soit non supporté par malloc / etc. ou La mémoire peut être divisée en une ou plusieurs pré-alloué zones, chacune contenant un ou deux tas LIFO (libérant toutes les versions de l'objet tous les objets dans le même segment de mémoire qui ont été alloués après). Dans une version commune du dernier scénario, la seule fois que quelque chose est libéré, tout est libéré; dans un tel cas, malloc () peut être utilement réécrite comme:

char *malloc_ptr;
void *malloc(int size)
{
  void *ret;
  ret = (void*)malloc_ptr;
  malloc_ptr += size;
  return ret;
}

zéro octets de surcharge pour objet alloué. Un exemple d'un scénario dans lequel un gestionnaire de mémoire personnalisé a été utilisé pour un scénario où malloc () était insuffisante était une application où les enregistrements de test de longueur variable produit des enregistrements de résultats de longueur variable (qui pourrait être plus ou moins); l'application nécessaire pour gérer la récupération des résultats et ajouter plus de tests mi-lot. Des essais ont été stockés à des adresses croissantes à partir de la partie inférieure du tampon, tandis que les résultats ont été stockés à des adresses décroissantes à partir de la partie supérieure. En tant que tâche de fond, les tests après l'actuel seraient copiés sur le début de la mémoire tampon (car il n'y avait qu'un seul pointeur qui a été utilisé pour lire des tests pour le traitement, la logique de copie mettra à jour ce pointeur au besoin). Avait l'application utilisée malloc / gratuit, il est possible que l'entrelacement des allocations pour les tests et les résultats pourraient avoir fragmenté la mémoire, mais avec le système utilisé il n'y avait pas un tel risque.

Il y a une implémentation de pool de mémoire relativement simple CCAN :

http://ccodearchive.net/info/antithread/alloc.html

Cela ressemble correspond à votre facture. Bien sûr, alloc.c est 1230 lignes, mais une bonne partie de ce test est le code et la manipulation de la liste. Il est un peu plus complexe que le code mis en œuvre, mais l'allocation de mémoire décente est compliquée.

Faisant écho à des conseils pour mesurer d'abord et ne se spécialisent si la performance est nul -. Devrait être facile de faire abstraction de vos malloc / reallocs libre / tel que le remplacement est simple

Compte tenu de la plate-forme spécialisée Je ne peux pas commenter sur l'efficacité des runtimes. Si vous faites votre propre enquête sur la mise en commun d'objets alors (voir d'autres réponses) ou une petite allocation d'objets à la Loki ou cette vaut un coup d'oeil. Le second lien a quelques commentaires intéressants sur la question ainsi.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top