Discussion :

[kaiser92]

dans mon post #28, je fait reference a ces weak_ptr comme une solution.
Cela permet en effet de regler le probleme de références cycliques. Il faut de toute facon connaitre toi meme les references cycliques. Car c'est un mecanisme unidirectionnel. Un objet doit "fortement" referencer avec un vrai sharedpointer l'autre objet, et l'autre doit "faiblement" referencer l'autre.
Quand tu en libere un, l'autre est delete, mais si tu libere l'autre en premier, il ne delete pas le second.
C'est pas vraiment utilisable dans mon cas, car mon graph est complexe et dynamique.

[epsilon68]

alors tu as pris une decision, tu essaies une solution?

[epsilon68]

bon j'ai eu envie d'essayer le bidule,
dans ce que j'ai proposé, utiliser l'operateur delete n'est pas vraiment possible pour garder la liste de ceux qui sont deletés, car en fait quand on arrive dans cette fonction, les membres sont deja effacés donc point de retour pour analyser les enfants de ce noeud deja deleté.

par contre l'option 2 où je garde tous les noeuds dans l'operateur new,
je n'appelle pas le delete mais je le retire de la liste des enfants...
et quand on appelle le gc, on fait la liste des differences et on delete ceux qui ne sont pas atteint en parcourant le graph.

je ne sais pas la performance sur de gros volume, et je n'ai rien pour le tester.

allez-y shootez

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
#include <set>
#include <list>
#include <iostream>
#include <string>
 
using namespace std;
 
class Node;
 
 
set<Node*> all_nodes;
Node *root;
 
 
class Node
{
public:
	list<Node*> children;
	string _name;
	string *debug_name;
 
	Node( string name ) : _name(name) {
		cout << "Node " << _name << " created" << endl;
		debug_name = new string(name);
	}
 
	virtual ~Node() { 
		cout << "Node " << _name << " deleted" << endl;
	}
 
	void remove( Node * node ) {
		std::list<Node*>::iterator it_found =	std::find(children.begin(), children.end(), node);
		if( it_found != children.end() ) {
			children.erase( it_found );
		}
	}
 
	void *operator new( size_t size )
    {
		cout << "node allocated of size " << size << endl;
		void* mem = malloc(size);
		all_nodes.insert((Node*)mem);
		return mem;
    }
 
	void operator delete( void *ptr )
    {
		cout << "node " << *(((Node*)ptr)->debug_name) << " deleted by the operator and freed" << endl;
 
                // remove it from the total list
		all_nodes.erase( (Node*)ptr );
 
		free( ptr );
    }
 
};
 
class NodeA : public Node
{
public:
	int count;
 
	NodeA( string name ) : Node( name ) {
		cout << "NodeA " << _name << " created" << endl;
	}
};
 
void gc_rec( Node *node, set<Node*> & set_to_delete ) {
 
	set<Node*>::iterator it_found = std::find(set_to_delete.begin(), set_to_delete.end(), node);
	if( it_found == set_to_delete.end() ) {
		return;
	}
 
	set_to_delete.erase(node);
 
	for( list<Node*>::iterator it=node->children.begin() ; it!= node->children.end() ; ++it) {
		gc_rec( *it, set_to_delete );
	}
}
 
void gc() 
{
	set<Node*> set_to_delete = all_nodes;
 
	gc_rec( root, set_to_delete );
 
	for( set<Node*>::iterator it = set_to_delete.begin(); it!= set_to_delete.end() ; ++it ) {
		delete *it;
	}
}
 
 
int main() 
{
	root = new Node("root");
 
	Node *node1 = new Node("1");
	Node *node2 = new Node("2");
	Node *node3 = new Node("3");
	Node *node4 = new Node("4");
	Node *node5 = new Node("5");
	Node *node6 = new Node("6");
 
	root->children.push_back( node1 );
	root->children.push_back( node2 );
	node1->children.push_back( node3 );
	node1->children.push_back( node4 );
	node2->children.push_back( node4 );
	node3->children.push_back( node5 );
	node5->children.push_back( node3 );
	node5->children.push_back( node6 );
	node6->children.push_back( node6 );
 
	node1->remove( node3 );
 
	gc();
 
	return 0;
}

<EDIT>
en fait pour faire l'option 1, il faudrait appeler une fonction gc_delete() qui ajouterait le noeud dans la liste de ceux qu'il faudrait "deleter"
pourquoi pas en fait?
mais c'est pas sur que ca sera plus efficace en fin de compte.
ca tente quelqu'un un benchmark?
</EDIT>

<EDIT 2>
j'ai oublié de mettre a jour la liste global des noeuds dans le gc ...
</EDIT 2>

<EDIT 3>
j'enleve la ref de la liste dans le "delete" pour etre consistent avec le new
</EDIT 3>

[epsilon68]

allo ?
y-a-t-il encore quelqu'un sur la ligne?

sinon moi j'arrête ....

[camboui]

Moi, je te suis très attentivement , mais où est donc passé kaiser92 ?

[epsilon68]

c'est cool d'entendre que je ne suis pas seul :-)
que penses-tu de la solution proposée?

est-on seulement 2 sur la ligne?
cela vaut-il vraiment le coup de continuer?

[camboui]

Je trouve ce fil-ci beaucoup plus intéressant que celui-là par exemple où l'on parle/polémique dans le vide alors que le tour de la question a été fait.


Il me semble que ta proposition est simple et valide. Elle pourrait résoudre le graph "complexe et dynamique" dont parle kaiser92. Mais s'il ne revient pas relancer son sujet...
Je suis curieux tout de même de savoir comment il aura résolu son portage.

[Goten]

Je trouve ce fil-ci beaucoup plus intéressant que celui-là par exemple où l'on parle/polémique dans le vide alors que le tour de la question a été fait.


Il me semble que ta proposition est simple et valide. Elle pourrait résoudre le graph "complexe et dynamique" dont parle kaiser92. Mais s'il ne revient pas relancer son sujet...
Je suis curieux tout de même de savoir comment il aura résolu son portage.

Blah, tout sujet peut être intéressant. C'est pointless de troller.
Et si le PO est pas là, ce sujet est pas plus intéressant pour autant btw.

[epsilon68]

Et si le PO est pas là, ce sujet est pas plus intéressant pour autant btw.

Je ne comprends pas ta phrase. C'est quoi "PO"?

[Goten]

Posteur original.

[kaiser92]

si si je suis toujours la les gars, mais je sais pas trop quoi faire la, je suis dans les choux.

[epsilon68]

si si je suis toujours la les gars, mais je sais pas trop quoi faire la, je suis dans les choux.

?

je t'ai posté du code ... qui marche ...
et tu ne sais pas quoi faire ?

... je ne comprends plus rien

[camboui]

Je plusois epsilon68

Tu n'as plus qu'à mettre les mains dans le cambouis (sans me toucher hein )

[epsilon68]

au moins répondre aux gens qui t'aident ...

[kaiser92]

c'est gentil les gars, mais je rentre tout juste de congés, je reprend lundi.
En fait j'ai essayé plein de trucs, mais sans succes encore.

[epsilon68]

et la solution que j'ai postée? elle ne va pas?
si non pourquoi?

[kaiser92]

Bonjour a tous, donc finalement pour ce topic, mon chef a decider de zapper le refcounting, car on a trouver mieux.
J utilise finalement le Boehm Garbage collector, qui regle ce probleme et aussi la vitesse d execution d un malloc/new free/delete.
Pour ce que ca interesse je peux vous le filer, de toute facon je vais ouvrir d autres discussions pour ce GC.
Merci de votre aide en tout cas!!

[epsilon68]

merci pour le feedback...

et sinon vous n'avez pas un probleme de portabilité en utilisant ce GC?

tu parles de probleme de rapidité de new/delete, mais avez-vous mis en place un pool de memoire pour comparer la rapidité?

bien joué sinon.

[kaiser92]

Le GC marche sur Linux/Mac, iPhone WinMobile/Win32, ...
Manque juste Symbian, donc va falloir soit qu on le porte soit je vais demander au gars qui l ont developper si ils ont pas essayer de le porter a un certain moment sur Symbian, ce qui est probable quand meme.
Voila, sinon j ai essayer des pools, ca va assez vite et c est pas mal, mais incomparable avec la qualite de ce GC, ca m a pris 1 jour pour comprendre comment l utiliser et a peine 2 jours pour changer mon application.
La j ai pas de fuites memoires et ca va enormement plus vite.
Le plus gros souci la est le portage sur Symbian mais mon chef a insister pour l utiliser, il se rend pas compte du travail que ca va demander, tiens j vais lui dire que c est simple et qu il peut le porter lui meme, histoire de rire

[epsilon68]

tu as regardé la quantité de mémoire utilisé?

quant à l'iphone, je suis surpris de votre choix d'utiliser un GC:
-> les GC sont, je crois, interdits sur cette plateforme...

http://stackoverflow.com/questions/4...ne-applicaions

http://developer.apple.com/iphone/ge...oneapps.action