Question de gros nullos en c++
Voila, je dois allouer puis désalouer un gros paquet d'objets en mémoire
(je sais j'en suis à la préhistoire car j'utilise new et delete)
Pour éviter de fragmenter la mémoire, est-ce qu'il est utile de
désalouer dans le sens inverse de l'allocation, ou bien est-ce que le
système gère ça suffisament bien pour ne pas se poser ce genre de question?
Bien sûr, çà a un coût : le GC lui-même (avec ses avantages et ses inconvénients), l'indirection supplémentaire par rapport à des pointeurs bruts....
Je ne vois pas ou il y a une indirection supplementaire avec les GC compactant.
les allocations dynamiques ne retournent pas un pointeur (adresse du bloc) mais un handle (adresse d'un pointeur contenant l'adresse du bloc). le handle est constant pour le code utilisant, le pointeur intermédiaire peut être changer lors du compactage mémoire.
C'est une technique d'implementation, et elle est loin d'etre indispensable. Je ne suis meme pas sur qu'elle soit la plus courante (ca risque de dependre du choix qu'a fait MS pour son implementation de CLI).
A ce que j'ai lu, c'est le choix de .NET. As-tu un pointeur sur d'autres techniques ?
Bien sûr, çà a un coût : le GC lui-même (avec ses avantages et ses
inconvénients), l'indirection supplémentaire par rapport à des pointeurs
bruts....
Je ne vois pas ou il y a une indirection supplementaire avec les GC
compactant.
les allocations dynamiques ne retournent pas un pointeur (adresse du bloc)
mais un handle (adresse d'un pointeur contenant l'adresse du bloc). le
handle est constant pour le code utilisant, le pointeur intermédiaire peut
être changer lors du compactage mémoire.
C'est une technique d'implementation, et elle est loin d'etre
indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
(ca risque de dependre du choix qu'a fait MS pour son implementation
de CLI).
A ce que j'ai lu, c'est le choix de .NET. As-tu un pointeur sur d'autres
techniques ?
Bien sûr, çà a un coût : le GC lui-même (avec ses avantages et ses inconvénients), l'indirection supplémentaire par rapport à des pointeurs bruts....
Je ne vois pas ou il y a une indirection supplementaire avec les GC compactant.
les allocations dynamiques ne retournent pas un pointeur (adresse du bloc) mais un handle (adresse d'un pointeur contenant l'adresse du bloc). le handle est constant pour le code utilisant, le pointeur intermédiaire peut être changer lors du compactage mémoire.
C'est une technique d'implementation, et elle est loin d'etre indispensable. Je ne suis meme pas sur qu'elle soit la plus courante (ca risque de dependre du choix qu'a fait MS pour son implementation de CLI).
A ce que j'ai lu, c'est le choix de .NET. As-tu un pointeur sur d'autres techniques ?
-- Loïc
Jean-Marc Bourguet
Loïc Joly writes:
Sylvain writes:
Jean-Marc Bourguet wrote on 22/06/2006 09:02:
"Arnaud Debaene" writes:
Bien sûr, çà a un coût : le GC lui-même (avec ses avantages et ses inconvénients), l'indirection supplémentaire par rapport à des pointeurs bruts....
Je ne vois pas ou il y a une indirection supplementaire avec les GC compactant.
les allocations dynamiques ne retournent pas un pointeur (adresse du bloc) mais un handle (adresse d'un pointeur contenant l'adresse du bloc). le handle est constant pour le code utilisant, le pointeur intermédiaire peut être changer lors du compactage mémoire. C'est une technique d'implementation, et elle est loin d'etre
indispensable. Je ne suis meme pas sur qu'elle soit la plus courante (ca risque de dependre du choix qu'a fait MS pour son implementation de CLI).
A ce que j'ai lu, c'est le choix de .NET. As-tu un pointeur sur d'autres techniques ?
J'ai pas de pointeurs spécifiques pour ça.
Un désavantage évident est la nécessité de modifier tous les pointeurs, mais je ne suis pas sûr que ça coûte plus cher que la double indirection qui doit tuer les caches, surtout que copier simplement ou copier en modifiant ça ne doit pas changer grand chose.
Une technique dont je me souvient est de faire un "mark and sweep" classique suivit d'une phase de compaction. On peut même combiner la phase de compaction avec la phase "mark" en supprimant la nécessité de faire un "sweep" -- mais en utilisant plus de mémoire.
Il y a aussi les GC "générationnels" qui utilisent deux faits: - la volatilité est essentiellement dans la mémoire allouée récemment - les nouveaux objets pointent vers les vieux, les vieux pointent rarement vers les nouveaux (en particulier avec les langages fonctionnels "purs", les vieux ne pointent jamais vers les nouveaux) pour éviter de parcourir toute la mémoire à chaque fois.
Quelques pointeurs qui pourraient être utiles:
http://www.cs.kent.ac.uk/people/staff/rej/gc.html http://www.iecc.com/gclist/ (la FAQ mais voir aussi les archives). http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Bien sûr, çà a un coût : le GC lui-même (avec ses avantages et ses
inconvénients), l'indirection supplémentaire par rapport à des pointeurs
bruts....
Je ne vois pas ou il y a une indirection supplementaire avec les GC
compactant.
les allocations dynamiques ne retournent pas un pointeur (adresse du bloc)
mais un handle (adresse d'un pointeur contenant l'adresse du bloc). le
handle est constant pour le code utilisant, le pointeur intermédiaire peut
être changer lors du compactage mémoire.
C'est une technique d'implementation, et elle est loin d'etre
indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
(ca risque de dependre du choix qu'a fait MS pour son implementation
de CLI).
A ce que j'ai lu, c'est le choix de .NET. As-tu un
pointeur sur d'autres techniques ?
J'ai pas de pointeurs spécifiques pour ça.
Un désavantage évident est la nécessité de modifier tous les
pointeurs, mais je ne suis pas sûr que ça coûte plus cher
que la double indirection qui doit tuer les caches, surtout
que copier simplement ou copier en modifiant ça ne doit pas
changer grand chose.
Une technique dont je me souvient est de faire un "mark and
sweep" classique suivit d'une phase de compaction. On peut
même combiner la phase de compaction avec la phase "mark" en
supprimant la nécessité de faire un "sweep" -- mais en
utilisant plus de mémoire.
Il y a aussi les GC "générationnels" qui utilisent deux
faits:
- la volatilité est essentiellement dans la mémoire
allouée récemment
- les nouveaux objets pointent vers les vieux, les vieux
pointent rarement vers les nouveaux (en particulier
avec les langages fonctionnels "purs", les vieux ne
pointent jamais vers les nouveaux)
pour éviter de parcourir toute la mémoire à chaque fois.
Quelques pointeurs qui pourraient être utiles:
http://www.cs.kent.ac.uk/people/staff/rej/gc.html
http://www.iecc.com/gclist/ (la FAQ mais voir aussi les archives).
http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Bien sûr, çà a un coût : le GC lui-même (avec ses avantages et ses inconvénients), l'indirection supplémentaire par rapport à des pointeurs bruts....
Je ne vois pas ou il y a une indirection supplementaire avec les GC compactant.
les allocations dynamiques ne retournent pas un pointeur (adresse du bloc) mais un handle (adresse d'un pointeur contenant l'adresse du bloc). le handle est constant pour le code utilisant, le pointeur intermédiaire peut être changer lors du compactage mémoire. C'est une technique d'implementation, et elle est loin d'etre
indispensable. Je ne suis meme pas sur qu'elle soit la plus courante (ca risque de dependre du choix qu'a fait MS pour son implementation de CLI).
A ce que j'ai lu, c'est le choix de .NET. As-tu un pointeur sur d'autres techniques ?
J'ai pas de pointeurs spécifiques pour ça.
Un désavantage évident est la nécessité de modifier tous les pointeurs, mais je ne suis pas sûr que ça coûte plus cher que la double indirection qui doit tuer les caches, surtout que copier simplement ou copier en modifiant ça ne doit pas changer grand chose.
Une technique dont je me souvient est de faire un "mark and sweep" classique suivit d'une phase de compaction. On peut même combiner la phase de compaction avec la phase "mark" en supprimant la nécessité de faire un "sweep" -- mais en utilisant plus de mémoire.
Il y a aussi les GC "générationnels" qui utilisent deux faits: - la volatilité est essentiellement dans la mémoire allouée récemment - les nouveaux objets pointent vers les vieux, les vieux pointent rarement vers les nouveaux (en particulier avec les langages fonctionnels "purs", les vieux ne pointent jamais vers les nouveaux) pour éviter de parcourir toute la mémoire à chaque fois.
Quelques pointeurs qui pourraient être utiles:
http://www.cs.kent.ac.uk/people/staff/rej/gc.html http://www.iecc.com/gclist/ (la FAQ mais voir aussi les archives). http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Sylvain
Jean-Marc Bourguet wrote on 22/06/2006 13:47:
C'est une technique d'implementation, et elle est loin d'etre indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
que qualifie "indispensable" ? pas la double indirection j'espère ? sinon je vois mal un gestionnaire de mémoire déplacer d'autorité un bloc en laissant le pointeur du client désigner une zone qui ne contient plus ses données.
(ca risque de dependre du choix qu'a fait MS pour son implementation de CLI).
je ne sais pas ce que cli fait, le sujet n'était pas MS.
btw, tu peux expliquer pourquoi un GC compactant le plus simple aurait besoin de 2 fois la mémoire qu'il met à disposition ? une gestion basée sur handle n'a que besoin d'un bloc (fixe ou dynamique) pour stocker les handles (soit qlq Ko).
Sylvain.
Jean-Marc Bourguet wrote on 22/06/2006 13:47:
C'est une technique d'implementation, et elle est loin d'etre
indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
que qualifie "indispensable" ? pas la double indirection j'espère ?
sinon je vois mal un gestionnaire de mémoire déplacer d'autorité un bloc
en laissant le pointeur du client désigner une zone qui ne contient plus
ses données.
(ca risque de dependre du choix qu'a fait MS pour son implementation
de CLI).
je ne sais pas ce que cli fait, le sujet n'était pas MS.
btw, tu peux expliquer pourquoi un GC compactant le plus simple aurait
besoin de 2 fois la mémoire qu'il met à disposition ? une gestion basée
sur handle n'a que besoin d'un bloc (fixe ou dynamique) pour stocker les
handles (soit qlq Ko).
C'est une technique d'implementation, et elle est loin d'etre indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
que qualifie "indispensable" ? pas la double indirection j'espère ? sinon je vois mal un gestionnaire de mémoire déplacer d'autorité un bloc en laissant le pointeur du client désigner une zone qui ne contient plus ses données.
(ca risque de dependre du choix qu'a fait MS pour son implementation de CLI).
je ne sais pas ce que cli fait, le sujet n'était pas MS.
btw, tu peux expliquer pourquoi un GC compactant le plus simple aurait besoin de 2 fois la mémoire qu'il met à disposition ? une gestion basée sur handle n'a que besoin d'un bloc (fixe ou dynamique) pour stocker les handles (soit qlq Ko).
Sylvain.
Jean-Marc Bourguet
Jean-Marc Bourguet writes:
Quelques pointeurs qui pourraient être utiles:
http://www.cs.kent.ac.uk/people/staff/rej/gc.html http://www.iecc.com/gclist/ (la FAQ mais voir aussi les archives). http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
Encore une reference (je ne retombais pas dessus hier)
http://www.memorymanagement.org
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Jean-Marc Bourguet <jm@bourguet.org> writes:
Quelques pointeurs qui pourraient être utiles:
http://www.cs.kent.ac.uk/people/staff/rej/gc.html
http://www.iecc.com/gclist/ (la FAQ mais voir aussi les archives).
http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
Encore une reference (je ne retombais pas dessus hier)
http://www.memorymanagement.org
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
http://www.cs.kent.ac.uk/people/staff/rej/gc.html http://www.iecc.com/gclist/ (la FAQ mais voir aussi les archives). http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
Encore une reference (je ne retombais pas dessus hier)
http://www.memorymanagement.org
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Jean-Marc Bourguet
Sylvain writes:
Jean-Marc Bourguet wrote on 22/06/2006 13:47:
C'est une technique d'implementation, et elle est loin d'etre indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
que qualifie "indispensable" ? pas la double indirection j'espère ? sinon je vois mal un gestionnaire de mémoire déplacer d'autorité un bloc en laissant le pointeur du client désigner une zone qui ne contient plus ses données.
La double indirection n'est pas indispensable, il suffit de mettre a jour les pointeurs.
Une des techniques est de marquer l'original comme deplacer en y laissant un pointeur vers la nouvelle position.
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Sylvain <noSpam@mail.net> writes:
Jean-Marc Bourguet wrote on 22/06/2006 13:47:
C'est une technique d'implementation, et elle est loin d'etre
indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
que qualifie "indispensable" ? pas la double indirection j'espère ?
sinon je vois mal un gestionnaire de mémoire déplacer d'autorité un
bloc en laissant le pointeur du client désigner une zone qui ne
contient plus ses données.
La double indirection n'est pas indispensable, il suffit de mettre a
jour les pointeurs.
Une des techniques est de marquer l'original comme deplacer en y
laissant un pointeur vers la nouvelle position.
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
C'est une technique d'implementation, et elle est loin d'etre indispensable. Je ne suis meme pas sur qu'elle soit la plus courante
que qualifie "indispensable" ? pas la double indirection j'espère ? sinon je vois mal un gestionnaire de mémoire déplacer d'autorité un bloc en laissant le pointeur du client désigner une zone qui ne contient plus ses données.
La double indirection n'est pas indispensable, il suffit de mettre a jour les pointeurs.
Une des techniques est de marquer l'original comme deplacer en y laissant un pointeur vers la nouvelle position.
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
adebaene
Sylvain writes:
btw, tu peux expliquer pourquoi un GC compactant le plus simple aurait besoin de 2 fois la mémoire qu'il met à disposition ?
Cet article précise que ce n'est qu'une implémentation possible, pas la seule (notamment en utilisant des GC générationnels...)
C'est pour ca que je n'ai parle que l'algo le plus simple, je n'ai pas ecrit que c'etait la seule approche possible. Les autres que je connais me semblent tous plus complexes.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
adebaene@club-internet.fr writes:
Sylvain <noSpam@mail.net> writes:
btw, tu peux expliquer pourquoi un GC compactant le plus simple aurait
besoin de 2 fois la mémoire qu'il met à disposition ?
Cet article précise que ce n'est qu'une implémentation possible, pas
la seule (notamment en utilisant des GC générationnels...)
C'est pour ca que je n'ai parle que l'algo le plus simple, je n'ai pas
ecrit que c'etait la seule approche possible. Les autres que je
connais me semblent tous plus complexes.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Cet article précise que ce n'est qu'une implémentation possible, pas la seule (notamment en utilisant des GC générationnels...)
C'est pour ca que je n'ai parle que l'algo le plus simple, je n'ai pas ecrit que c'etait la seule approche possible. Les autres que je connais me semblent tous plus complexes.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
