Je suis en train de developper une bibliotheque (geometrique) qui cree
pas mal d'objets temporaires. Actuellement, on a des fonctions qui
creent et retournent les objets temporaires (exemple : des points de
construction, intersections de primitives ...) qui servent au calcul final.
La fonction cliente recupere l'objet qui l'interesse et le reste est
detruit par le client (automatiquement en fin de fonction). L'objet est
ensuite utilise par le client comme bon lui semble (dans le client qu'on
developpe en parallele, on passe que des references). Au niveau de la
bibliotheque, rien ne distingue un objet temporaire d'un objet qu'on va
conserver.
Je me demandais si on ne pouvait pas faire mieux. Normalement, je me
tournerais vers un garbage collector (en changeant les fonctions pour
qu'elles retournent des pointeurs), mais une contrainte est que ce soit
le plus rapide possible (donc, a priori, on doit pouvoir faire mieux).
Une autre solution serait d'utiliser un manager d'objets qui les
creerait/detruirait et se contenterait de retourner des references, mais
ce qui m'ennuie c'est que dans ce cas, le client est objet de demander
au manager de detruire les objets temporaires.
Ce qui me plairait assez, c'est une solution intermediaire, avec un
manager qui "saurait" quand detruire les objets. C'est ce qui me semble
une solution relativement elegante, meme si je ne sais pas trop comment
l'implementer.
D'ou ma question, avez-vous une solution elegante pour gerer proprement
et elegamment les objets temporaires?
D'ou ma question, avez-vous une solution elegante pour gerer proprement et elegamment les objets temporaires?
Je ne suis pas certain d'avoir bien compris le problème, mais une solution à base de smart pointeur pourrait-elle être un compromis envisageable ?
-- Arnaud
Stan
"toto" a écrit dans le message de news: 432e8b23$0$15846$
Bonjour,
Je suis en train de developper une bibliotheque (geometrique) qui cree pas mal d'objets temporaires. Actuellement, on a des fonctions qui creent et retournent les objets temporaires (exemple : des points de
L'utilisation de références permet de faire ce genre d'économie. Notamment lorsque les objets sont traités par une flopée de fonctions.
-- -Stan
"toto" <toto@toto.toto_invalid> a écrit dans le message de news:
432e8b23$0$15846$626a14ce@news.free.fr...
Bonjour,
Je suis en train de developper une bibliotheque (geometrique) qui cree pas
mal d'objets temporaires. Actuellement, on a des fonctions qui creent et
retournent les objets temporaires (exemple : des points de
L'utilisation de références permet de faire ce genre d'économie.
Notamment lorsque les objets sont traités par une flopée de fonctions.
"toto" a écrit dans le message de news: 432e8b23$0$15846$
Bonjour,
Je suis en train de developper une bibliotheque (geometrique) qui cree pas mal d'objets temporaires. Actuellement, on a des fonctions qui creent et retournent les objets temporaires (exemple : des points de
L'utilisation de références permet de faire ce genre d'économie. Notamment lorsque les objets sont traités par une flopée de fonctions.
-- -Stan
kanze
Arnaud Meurgues wrote:
toto wrote:
D'ou ma question, avez-vous une solution elegante pour gerer proprement et elegamment les objets temporaires?
Je ne suis pas certain d'avoir bien compris le problème, mais une solution à base de smart pointeur pourrait-elle être un compromis envisageable ?
Il a dit que la performance était importante. Alors, un glaneur de cellules classique serait sûrement plus indiqué. L'idéal, dans les cas où la performance est importante, c'est de déclencher le glaneur au moment quand il y a la mimimum d'objets actifs. Si j'ai bien compris aussi, ses objets ne contiennent pas de pointeurs ; il doit être possible lors de l'allocation de le dire au glaneur de cellules, pour qu'il ne les parcourt pas par la suite, mais n'ayant jamais eu le problème, je ne connais pas les détails. (Grosso modo, je crois, dans ce cas-là, le glaneur doit maintenir deux arènes -- un pour les objets avec pointeur, et l'autre pour ceux sans pointeur. Dans le cas de C++, un new de placement permettrait de lui dire lequel utiliser. Je suis assez sûr qu'on peut faire quelque chose comme ça avec le glaneur de Boehm.)
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Arnaud Meurgues wrote:
toto wrote:
D'ou ma question, avez-vous une solution elegante pour gerer
proprement et elegamment les objets temporaires?
Je ne suis pas certain d'avoir bien compris le problème, mais
une solution à base de smart pointeur pourrait-elle être un
compromis envisageable ?
Il a dit que la performance était importante. Alors, un glaneur
de cellules classique serait sûrement plus indiqué. L'idéal,
dans les cas où la performance est importante, c'est de
déclencher le glaneur au moment quand il y a la mimimum d'objets
actifs. Si j'ai bien compris aussi, ses objets ne contiennent
pas de pointeurs ; il doit être possible lors de l'allocation de
le dire au glaneur de cellules, pour qu'il ne les parcourt pas
par la suite, mais n'ayant jamais eu le problème, je ne connais
pas les détails. (Grosso modo, je crois, dans ce cas-là, le
glaneur doit maintenir deux arènes -- un pour les objets avec
pointeur, et l'autre pour ceux sans pointeur. Dans le cas de
C++, un new de placement permettrait de lui dire lequel
utiliser. Je suis assez sûr qu'on peut faire quelque chose comme
ça avec le glaneur de Boehm.)
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
D'ou ma question, avez-vous une solution elegante pour gerer proprement et elegamment les objets temporaires?
Je ne suis pas certain d'avoir bien compris le problème, mais une solution à base de smart pointeur pourrait-elle être un compromis envisageable ?
Il a dit que la performance était importante. Alors, un glaneur de cellules classique serait sûrement plus indiqué. L'idéal, dans les cas où la performance est importante, c'est de déclencher le glaneur au moment quand il y a la mimimum d'objets actifs. Si j'ai bien compris aussi, ses objets ne contiennent pas de pointeurs ; il doit être possible lors de l'allocation de le dire au glaneur de cellules, pour qu'il ne les parcourt pas par la suite, mais n'ayant jamais eu le problème, je ne connais pas les détails. (Grosso modo, je crois, dans ce cas-là, le glaneur doit maintenir deux arènes -- un pour les objets avec pointeur, et l'autre pour ceux sans pointeur. Dans le cas de C++, un new de placement permettrait de lui dire lequel utiliser. Je suis assez sûr qu'on peut faire quelque chose comme ça avec le glaneur de Boehm.)
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
toto
kanze wrote:
Il a dit que la performance était importante. Alors, un glaneur de cellules classique serait sûrement plus indiqué. L'idéal, dans les cas où la performance est importante, c'est de déclencher le glaneur au moment quand il y a la mimimum d'objets actifs. Si j'ai bien compris aussi, ses objets ne contiennent pas de pointeurs ; il doit être possible lors de l'allocation de le dire au glaneur de cellules, pour qu'il ne les parcourt pas par la suite, mais n'ayant jamais eu le problème, je ne connais pas les détails. (Grosso modo, je crois, dans ce cas-là, le glaneur doit maintenir deux arènes -- un pour les objets avec pointeur, et l'autre pour ceux sans pointeur. Dans le cas de C++, un new de placement permettrait de lui dire lequel utiliser. Je suis assez sûr qu'on peut faire quelque chose comme ça avec le glaneur de Boehm.)
Merci, je vais voir.
kanze wrote:
Il a dit que la performance était importante. Alors, un glaneur
de cellules classique serait sûrement plus indiqué. L'idéal,
dans les cas où la performance est importante, c'est de
déclencher le glaneur au moment quand il y a la mimimum d'objets
actifs. Si j'ai bien compris aussi, ses objets ne contiennent
pas de pointeurs ; il doit être possible lors de l'allocation de
le dire au glaneur de cellules, pour qu'il ne les parcourt pas
par la suite, mais n'ayant jamais eu le problème, je ne connais
pas les détails. (Grosso modo, je crois, dans ce cas-là, le
glaneur doit maintenir deux arènes -- un pour les objets avec
pointeur, et l'autre pour ceux sans pointeur. Dans le cas de
C++, un new de placement permettrait de lui dire lequel
utiliser. Je suis assez sûr qu'on peut faire quelque chose comme
ça avec le glaneur de Boehm.)
Il a dit que la performance était importante. Alors, un glaneur de cellules classique serait sûrement plus indiqué. L'idéal, dans les cas où la performance est importante, c'est de déclencher le glaneur au moment quand il y a la mimimum d'objets actifs. Si j'ai bien compris aussi, ses objets ne contiennent pas de pointeurs ; il doit être possible lors de l'allocation de le dire au glaneur de cellules, pour qu'il ne les parcourt pas par la suite, mais n'ayant jamais eu le problème, je ne connais pas les détails. (Grosso modo, je crois, dans ce cas-là, le glaneur doit maintenir deux arènes -- un pour les objets avec pointeur, et l'autre pour ceux sans pointeur. Dans le cas de C++, un new de placement permettrait de lui dire lequel utiliser. Je suis assez sûr qu'on peut faire quelque chose comme ça avec le glaneur de Boehm.)
