nedmalloc: d'où vient mem> = fm?

Question

Lors de l'implémentation de nedmalloc dans mon application, je suis fréquemment confronté à une situation où nedmalloc refuse de libérer un bloc de mémoire, affirmant qu'il ne l'a pas alloué. J'utilise la version v1.06beta1_svn1151. Pendant le débogage, je suis arrivé au point où je vois une condition particulière qui échoue, tous les autres (y compris les nombres magiques) réussissent. La condition est la suivante:

if((size_t)mem-(size_t)fm>=(size_t)1<<(SIZE_T_BITSIZE-1)) return 0; 

Sur Win32 cela semble être équivalent à:

if((int)((size_t)mem-(size_t)fm)<0) return 0; 

qui semble être le même que:

if((size_t)mem<(size_t)fm) return 0; 

Dans mon cas, je vois vraiment mem < fm. Ce que je ne comprends pas maintenant, c'est d'où vient cette condition. Je ne peux rien trouver qui garantirait le fm < = m n'importe où dans le code. Pourtant, "sélectionner n'est pas cassé": je doute que ce soit vraiment un bug dans nedmalloc, très probablement je fais quelque chose de mal quelque part, mais je ne peux pas le trouver. Une fois que j'ai activé les fonctionnalités de débogage de nedmalloc, le problème disparaît. Si quelqu'un comprend le travail interne de nedmalloc, pourriez-vous m'expliquer pourquoi fm < = mem est garanti?

Answer 1

Je peux voir maintenant pour cette ligne il y a eu un commentaire/* Voir si mem est plus bas en mémoire que mem */et il a été désactivé en utilisant #if 0 dans beta svn1159. La condition n'est pas mature et elle est probablement erronée (elle est toujours laissée dans la partie spécifique du code de Linux - probablement mal là aussi?

Leçon apprise: "beta peut être cassé".

Answer 2

Je suppose que SIZE_T_BITSIZE est le nombre de bits dans le type size_t, donc décalage 1 par SIZE_T_BITSIZE - 1 vous donnera (SIZE_MAX + 1)/2 valeur (mathématique). La condition teste si (size_t)mem - (size_t)fm est supérieure ou égale à la valeur mathématique de (SIZE_MAX + 1)/2.

Ce n'est pas la même chose que (int)((size_t)mem - (size_t)fm) < 0. De plus, si mem et/ou fm sont moulés à size_t, qui est un type non signé, l'arithmétique se produit dans les types non signés, ce qui signifie que la différence ne peut pas être inférieure à 0. Donc, même si (size_t)mem est inférieur à (size_t)fm, (size_t)mem - (size_t)fm est jamais va être inférieur à 0. Il est égal à la différence mem - fm plus SIZE_MAX plus 1, ce qui est une valeur positive. La conversion de cette valeur en int peut déborder, ce qui est défini par l'implémentation ou ne peut pas déborder, auquel cas vous obtenez une valeur positive.

Donc, pour répondre à votre question, si (size_t)mem est inférieur à (size_t)fm, vous avez probablement un bug avant ce point.

Qu'est-ce que m? Par m, voulez-vous dire mem?

Modifier: Apparaît comme un bogue dans nedmalloc, pour les raisons que j'ai mentionnées ci-dessus. Le code en question a été commented out in the latest version.