question technique sur l'opérateur d'allocation new
29 réponses
Frédéric GOURUL
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis
preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
"Frédéric GOURUL" a écrit dans le message de news:bq5nr1$cb3$
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
merci.
je ne saurai répondre personnellement à la question, mais si j'ai bonne mémoire Scott Meyers discute assez longuement sur l'opérateur new dans son ouvrage More Effective C++ ; peut être une piste de réponse, mais je ne saurai cependant le garantir.
"Frédéric GOURUL" <fgourul@9online.fr> a écrit dans le message de
news:bq5nr1$cb3$1@aphrodite.grec.isp.9tel.net...
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si
quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis
preneur. En gros, je voudrais savoir si ca a un sens de créer un système
qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
merci.
je ne saurai répondre personnellement à la question, mais si j'ai bonne
mémoire Scott Meyers discute assez longuement sur l'opérateur new dans son
ouvrage More Effective C++ ; peut être une piste de réponse, mais je ne
saurai cependant le garantir.
"Frédéric GOURUL" a écrit dans le message de news:bq5nr1$cb3$
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
merci.
je ne saurai répondre personnellement à la question, mais si j'ai bonne mémoire Scott Meyers discute assez longuement sur l'opérateur new dans son ouvrage More Effective C++ ; peut être une piste de réponse, mais je ne saurai cependant le garantir.
DINH Viêt Hoà
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
N'utiliserait-il pas le malloc() (version C) du système pour effectuer cette tâche ?
Par contre la préallocation d'un objet de taille (n * p) est sans doute plus rapide qu'un allocation de n objets de taille p. Ca peut donc effectivement accélérer les choses si c'est vraiment le point critique de ton application.
-- DINH V. Hoa,
etPan! - newsreader, mail user agent -- http://libetpan.sf.net/etpan
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis
preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
N'utiliserait-il pas le malloc() (version C) du système pour effectuer
cette tâche ?
Par contre la préallocation d'un objet de taille (n * p) est sans doute
plus rapide qu'un allocation de n objets de taille p.
Ca peut donc effectivement accélérer les choses si c'est vraiment le
point critique de ton application.
--
DINH V. Hoa,
etPan! - newsreader, mail user agent -- http://libetpan.sf.net/etpan
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
N'utiliserait-il pas le malloc() (version C) du système pour effectuer cette tâche ?
Par contre la préallocation d'un objet de taille (n * p) est sans doute plus rapide qu'un allocation de n objets de taille p. Ca peut donc effectivement accélérer les choses si c'est vraiment le point critique de ton application.
-- DINH V. Hoa,
etPan! - newsreader, mail user agent -- http://libetpan.sf.net/etpan
Luc Hermitte
"Frédéric GOURUL" wrote in news:bq5nr1$cb3$:
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur.
ANdrei Alexandrescu propose de quoi allouer des objets de petites tailles dans "Modern C++ Design", Addisson Wesley. Et la classe résultat du chapitre du bouquin est disponible avec la bibliothèque loki.
-- Luc Hermitte <hermitte at free.fr> FAQ de <news:fr.comp.lang.c++> : <http://www.cmla.ens-cachan.fr/Utilisateurs/dosreis/C++/FAQ/> Dejanews : <http://groups.google.com/advanced_group_search>
"Frédéric GOURUL" <fgourul@9online.fr> wrote in
news:bq5nr1$cb3$1@aphrodite.grec.isp.9tel.net:
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si
quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le
sujet, je suis preneur.
ANdrei Alexandrescu propose de quoi allouer des objets de petites tailles
dans "Modern C++ Design", Addisson Wesley. Et la classe résultat du
chapitre du bouquin est disponible avec la bibliothèque loki.
--
Luc Hermitte <hermitte at free.fr>
FAQ de <news:fr.comp.lang.c++> :
<http://www.cmla.ens-cachan.fr/Utilisateurs/dosreis/C++/FAQ/>
Dejanews : <http://groups.google.com/advanced_group_search>
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur.
ANdrei Alexandrescu propose de quoi allouer des objets de petites tailles dans "Modern C++ Design", Addisson Wesley. Et la classe résultat du chapitre du bouquin est disponible avec la bibliothèque loki.
-- Luc Hermitte <hermitte at free.fr> FAQ de <news:fr.comp.lang.c++> : <http://www.cmla.ens-cachan.fr/Utilisateurs/dosreis/C++/FAQ/> Dejanews : <http://groups.google.com/advanced_group_search>
Loïc Joly
Frédéric GOURUL wrote:
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
C'est une technique assez recommandée, surtout si tes objets sont de taille fixe (le gain est encore plus important).
Je n'ai par contre pas eu l'occasion d'utiliser cette technique moi même (dans mon domaine de travail, on crée souvent plein d'objets en phase d'init où l'on se moque des contraintes de temps, et aucun en cours d'exécution, ou le temps compte), et ne peut donc pas juger de son utilité, mais suffisemment de gens en parlent pour que j'ai confiance en son utilité.
-- Loïc
Frédéric GOURUL wrote:
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis
preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
C'est une technique assez recommandée, surtout si tes objets sont de
taille fixe (le gain est encore plus important).
Je n'ai par contre pas eu l'occasion d'utiliser cette technique moi même
(dans mon domaine de travail, on crée souvent plein d'objets en phase
d'init où l'on se moque des contraintes de temps, et aucun en cours
d'exécution, ou le temps compte), et ne peut donc pas juger de son
utilité, mais suffisemment de gens en parlent pour que j'ai confiance en
son utilité.
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
C'est une technique assez recommandée, surtout si tes objets sont de taille fixe (le gain est encore plus important).
Je n'ai par contre pas eu l'occasion d'utiliser cette technique moi même (dans mon domaine de travail, on crée souvent plein d'objets en phase d'init où l'on se moque des contraintes de temps, et aucun en cours d'exécution, ou le temps compte), et ne peut donc pas juger de son utilité, mais suffisemment de gens en parlent pour que j'ai confiance en son utilité.
-- Loïc
Pierre Maurette
"DINH Viêt Hoà" a écrit [...]
N'utiliserait-il pas le malloc() (version C) du système pour effectuer cette tâche ? Ça semble logique : new() utiliserait malloc() qui lui-même "deale" avec
l'OS. Sous Windows, j'ai vérifié, new() appelle malloc() qui utilise simplement HeapAlloc(). Mais le cas est sans doute particulier, puisque HeapAlloc(), HeapReAlloc() et HeapFree() (de kernel32) correspondent exactement ou presque à malloc(), realloc() et free() du C. En particulier, la seule façon de faire libérer unb block par l'OS est de lui passer (free() et HeapFree()) la valeur numérique d'un pointeur renvoyé lors de l'allocation (malloc(), realloc(), HeapAlloc(), HeapRealloc()). Et ça se passe à peu près de cette façon chez Billou depuis DOS. L'avantage de passer par malloc() n'est pas à première vue évident, puisqu'il semble plus simple d'appeler directement HeapAlloc(). MAis en procédant de cette façon, new(), qui fait partie du langage, reste "portable".
Par contre la préallocation d'un objet de taille (n * p) est sans doute plus rapide qu'un allocation de n objets de taille p. Ca peut donc effectivement accélérer les choses si c'est vraiment le point critique de ton application. Sous Windows, la différence est importante, dixit Microsoft.
Il est clair que chaque demandes (et libération) de mémoire est couteuse. Confronté à des demandes répétées, l'OS va naviguer à vue, et à mon sens peut facilement être amené à se lancer dans un grand ménage à n'importe quel moment (je crois qu'il gère ça à la libération). Il peut exister des OS dans lesquels la mémoire ne serait allouée que par "gros morceau", et on accèderait à des morceaux de ce morceau par des offset, ce qui justifierait le danger d'écrire pointeur = adresse (ça se voit ...). Hé, les spécialistes, ça existe, un OS comme ça ? Si oui, c'est l'implémentation (malloc() & co plutôt que new()) qui gèrerait en finesse, et l'avantage de la préallocation serait moindre.
Cordialement, Pierre
"DINH Viêt Hoà" <dinh.viet.hoa@free.fr> a écrit
[...]
N'utiliserait-il pas le malloc() (version C) du système pour effectuer
cette tâche ?
Ça semble logique : new() utiliserait malloc() qui lui-même "deale" avec
l'OS.
Sous Windows, j'ai vérifié, new() appelle malloc() qui utilise simplement
HeapAlloc().
Mais le cas est sans doute particulier, puisque HeapAlloc(), HeapReAlloc()
et HeapFree() (de kernel32) correspondent exactement ou presque à malloc(),
realloc() et free() du C. En particulier, la seule façon de faire libérer
unb block par l'OS est de lui passer (free() et HeapFree()) la valeur
numérique d'un pointeur renvoyé lors de l'allocation (malloc(), realloc(),
HeapAlloc(), HeapRealloc()).
Et ça se passe à peu près de cette façon chez Billou depuis DOS.
L'avantage de passer par malloc() n'est pas à première vue évident,
puisqu'il semble plus simple d'appeler directement HeapAlloc(). MAis en
procédant de cette façon, new(), qui fait partie du langage, reste
"portable".
Par contre la préallocation d'un objet de taille (n * p) est sans doute
plus rapide qu'un allocation de n objets de taille p.
Ca peut donc effectivement accélérer les choses si c'est vraiment le
point critique de ton application.
Sous Windows, la différence est importante, dixit Microsoft.
Il est clair que chaque demandes (et libération) de mémoire est couteuse.
Confronté à des demandes répétées, l'OS va naviguer à vue, et à mon sens
peut facilement être amené à se lancer dans un grand ménage à n'importe quel
moment (je crois qu'il gère ça à la libération).
Il peut exister des OS dans lesquels la mémoire ne serait allouée que par
"gros morceau", et on accèderait à des morceaux de ce morceau par des
offset, ce qui justifierait le danger d'écrire pointeur = adresse (ça se
voit ...). Hé, les spécialistes, ça existe, un OS comme ça ? Si oui, c'est
l'implémentation (malloc() & co plutôt que new()) qui gèrerait en finesse,
et l'avantage de la préallocation serait moindre.
N'utiliserait-il pas le malloc() (version C) du système pour effectuer cette tâche ? Ça semble logique : new() utiliserait malloc() qui lui-même "deale" avec
l'OS. Sous Windows, j'ai vérifié, new() appelle malloc() qui utilise simplement HeapAlloc(). Mais le cas est sans doute particulier, puisque HeapAlloc(), HeapReAlloc() et HeapFree() (de kernel32) correspondent exactement ou presque à malloc(), realloc() et free() du C. En particulier, la seule façon de faire libérer unb block par l'OS est de lui passer (free() et HeapFree()) la valeur numérique d'un pointeur renvoyé lors de l'allocation (malloc(), realloc(), HeapAlloc(), HeapRealloc()). Et ça se passe à peu près de cette façon chez Billou depuis DOS. L'avantage de passer par malloc() n'est pas à première vue évident, puisqu'il semble plus simple d'appeler directement HeapAlloc(). MAis en procédant de cette façon, new(), qui fait partie du langage, reste "portable".
Par contre la préallocation d'un objet de taille (n * p) est sans doute plus rapide qu'un allocation de n objets de taille p. Ca peut donc effectivement accélérer les choses si c'est vraiment le point critique de ton application. Sous Windows, la différence est importante, dixit Microsoft.
Il est clair que chaque demandes (et libération) de mémoire est couteuse. Confronté à des demandes répétées, l'OS va naviguer à vue, et à mon sens peut facilement être amené à se lancer dans un grand ménage à n'importe quel moment (je crois qu'il gère ça à la libération). Il peut exister des OS dans lesquels la mémoire ne serait allouée que par "gros morceau", et on accèderait à des morceaux de ce morceau par des offset, ce qui justifierait le danger d'écrire pointeur = adresse (ça se voit ...). Hé, les spécialistes, ça existe, un OS comme ça ? Si oui, c'est l'implémentation (malloc() & co plutôt que new()) qui gèrerait en finesse, et l'avantage de la préallocation serait moindre.
Cordialement, Pierre
Pierre Maurette
"Frédéric GOURUL" a écrit
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille... Bonjour,
Voir mon autre message. Sous Windows, avec deux compilateurs testés, la réponse est sauf erreur "non, new() n'optimise pas et appelle l'OS à chaque allocation". Mais je n'ai pas trop cherché dans les commutateurs d'optimisation. Dans l'aide de VS .NET 2003, un très bon article en français : Tas : joies et tourments Murali R. Krishnan Février 1999 (pour Google) Intéressant "en général", et encore plus si vous ciblez Windows (Outlook Express me le laisse penser). J'en ai fait un HTML que j'ai zippé et mis dans votre BAL. Cordialement, Pïerre
"Frédéric GOURUL" <fgourul@9online.fr> a écrit
Bonjour,
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si
quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis
preneur. En gros, je voudrais savoir si ca a un sens de créer un système
qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
Bonjour,
Voir mon autre message.
Sous Windows, avec deux compilateurs testés, la réponse est sauf erreur
"non, new() n'optimise pas et appelle l'OS à chaque allocation". Mais je
n'ai pas trop cherché dans les commutateurs d'optimisation.
Dans l'aide de VS .NET 2003, un très bon article en français :
Tas : joies et tourments
Murali R. Krishnan
Février 1999
(pour Google)
Intéressant "en général", et encore plus si vous ciblez Windows (Outlook
Express me le laisse penser).
J'en ai fait un HTML que j'ai zippé et mis dans votre BAL.
Cordialement,
Pïerre
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un
pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille... Bonjour,
Voir mon autre message. Sous Windows, avec deux compilateurs testés, la réponse est sauf erreur "non, new() n'optimise pas et appelle l'OS à chaque allocation". Mais je n'ai pas trop cherché dans les commutateurs d'optimisation. Dans l'aide de VS .NET 2003, un très bon article en français : Tas : joies et tourments Murali R. Krishnan Février 1999 (pour Google) Intéressant "en général", et encore plus si vous ciblez Windows (Outlook Express me le laisse penser). J'en ai fait un HTML que j'ai zippé et mis dans votre BAL. Cordialement, Pïerre
Jean-Marc Bourguet
"Frédéric GOURUL" writes:
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks.
Ca depend de l'implementation et rien n'est garanti. Une technique courante est que ::new appelle malloc (mais ce n'est pas obligatoire).
Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
Si le temps d'allocation/desallocation est important, c'est souvent interessant.
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
"Frédéric GOURUL" <fgourul@9online.fr> writes:
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks.
Ca depend de l'implementation et rien n'est garanti. Une technique
courante est que ::new appelle malloc (mais ce n'est pas obligatoire).
Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur
le sujet, je suis preneur. En gros, je voudrais savoir si ca a un
sens de créer un système qui ferait de la pré-allocation de mémoire
pour les objets de petite taille...
Si le temps d'allocation/desallocation est important, c'est souvent
interessant.
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
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks.
Ca depend de l'implementation et rien n'est garanti. Une technique courante est que ::new appelle malloc (mais ce n'est pas obligatoire).
Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
Si le temps d'allocation/desallocation est important, c'est souvent interessant.
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
DINH Viêt Hoà writes:
N'utiliserait-il [operator ::new] pas le malloc() (version C) du système pour effectuer cette tâche ?
Ce n'est pas garanti mais c'est courant.
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
DINH Viêt Hoà <dinh.viet.hoa@free.fr> writes:
N'utiliserait-il [operator ::new] pas le malloc() (version C) du
système pour effectuer cette tâche ?
Ce n'est pas garanti mais c'est courant.
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
N'utiliserait-il [operator ::new] pas le malloc() (version C) du système pour effectuer cette tâche ?
Ce n'est pas garanti mais c'est courant.
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
Marc Boyer
Frédéric GOURUL wrote:
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t)
L'implémentation de new est dépendante de ton compilateur. Beaucoup de littérature a été écrite sur de mauvaises performances pour les blocs de petites tailles. La dernière fois que j'ai rapporté cette affirmation, Gabriel Dos m'a expliqué que c'était n'importe quoi. Le sujet ne m'a jamais intéressé au point que je fasse des mesures.
Par contre, ce qui paraît évident, c'est qu'un opérateur qui prend n'importe quelle taille sera moins efficace qu'un opérateur qui ne gère qu'une seule taille. Donc, si toi programmeur tu sais que tu vas allouer beaucoup d'objets de taille fixe N (N=sizeof(TaClasseSupeUtilisee)), il peut être intéressant de particulariser l'opérateur pour cet objet là.
En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
De toute façon, faire de la pré-allocation pour des objets de grosse taille, c'est difficile.
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
Frédéric GOURUL wrote:
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t)
L'implémentation de new est dépendante de ton compilateur.
Beaucoup de littérature a été écrite sur de mauvaises performances
pour les blocs de petites tailles. La dernière fois que j'ai
rapporté cette affirmation, Gabriel Dos m'a expliqué que c'était
n'importe quoi. Le sujet ne m'a jamais intéressé au point que
je fasse des mesures.
Par contre, ce qui paraît évident, c'est qu'un opérateur
qui prend n'importe quelle taille sera moins efficace qu'un
opérateur qui ne gère qu'une seule taille. Donc, si toi
programmeur tu sais que tu vas allouer beaucoup d'objets
de taille fixe N (N=sizeof(TaClasseSupeUtilisee)), il
peut être intéressant de particulariser l'opérateur
pour cet objet là.
En gros, je voudrais savoir si ca a un sens de créer un système qui
ferait de la pré-allocation de mémoire pour les objets de petite taille...
De toute façon, faire de la pré-allocation pour des objets de grosse
taille, c'est difficile.
Marc Boyer
--
Lying for having sex or lying for making war? Trust US presidents :-(
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t)
L'implémentation de new est dépendante de ton compilateur. Beaucoup de littérature a été écrite sur de mauvaises performances pour les blocs de petites tailles. La dernière fois que j'ai rapporté cette affirmation, Gabriel Dos m'a expliqué que c'était n'importe quoi. Le sujet ne m'a jamais intéressé au point que je fasse des mesures.
Par contre, ce qui paraît évident, c'est qu'un opérateur qui prend n'importe quelle taille sera moins efficace qu'un opérateur qui ne gère qu'une seule taille. Donc, si toi programmeur tu sais que tu vas allouer beaucoup d'objets de taille fixe N (N=sizeof(TaClasseSupeUtilisee)), il peut être intéressant de particulariser l'opérateur pour cet objet là.
En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
De toute façon, faire de la pré-allocation pour des objets de grosse taille, c'est difficile.
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
kanze
"Frédéric GOURUL" wrote in message news:<bq5nr1$cb3$...
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
Ça dépend de l'application et du système. Ça m'est arrivé de le faire une fois -- pour une accelération de l'application par une facteur de 300. Mais dans l'ensemble, la plupart (sinon tous) les implémentations de new renvoient à malloc, et qu'il est préférable sans doute d'abord d'expérimenter avec les différentes implémentations de malloc livrées avec ton compilateur.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Frédéric GOURUL" <fgourul@9online.fr> wrote in message
news:<bq5nr1$cb3$1@aphrodite.grec.isp.9tel.net>...
Je me pose pas mal de questions sur l'implémentation de l'opérateur
d'allocation mémoire void* ::operator new(size_t), en particulier s'il
contient des optimisations pour l'allocation des small-blocks. Si
quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le
sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de
créer un système qui ferait de la pré-allocation de mémoire pour les
objets de petite taille...
Ça dépend de l'application et du système. Ça m'est arrivé de le faire
une fois -- pour une accelération de l'application par une facteur de
300. Mais dans l'ensemble, la plupart (sinon tous) les implémentations
de new renvoient à malloc, et qu'il est préférable sans doute d'abord
d'expérimenter avec les différentes implémentations de malloc livrées
avec ton compilateur.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Frédéric GOURUL" wrote in message news:<bq5nr1$cb3$...
Je me pose pas mal de questions sur l'implémentation de l'opérateur d'allocation mémoire void* ::operator new(size_t), en particulier s'il contient des optimisations pour l'allocation des small-blocks. Si quelqu'un pouvait éclairer ma lanterne ou m'indiquer un lien sur le sujet, je suis preneur. En gros, je voudrais savoir si ca a un sens de créer un système qui ferait de la pré-allocation de mémoire pour les objets de petite taille...
Ça dépend de l'application et du système. Ça m'est arrivé de le faire une fois -- pour une accelération de l'application par une facteur de 300. Mais dans l'ensemble, la plupart (sinon tous) les implémentations de new renvoient à malloc, et qu'il est préférable sans doute d'abord d'expérimenter avec les différentes implémentations de malloc livrées avec ton compilateur.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
