SGCL - Garbage Collector for C++

[Sebastian Nibisz]

SGCL is precise, parallel garbage collection library for C++ (at this time
for Windows 32/64 only). SGCL is free software published under University of
Illinois/NCSA Open Source License.

Get it at:
http://sourceforge.net/projects/sgcl/

Regards
Sebastian Nibisz

[=?ISO-8859-1?Q?Marcel_M=FCller?=]

Sebastian Nibisz schrieb:

struct node
{
node* next;
};

node* root = new node;
node* n = root;

for (int x = 0; x < 1000000; ++x)
{
n = n->next = new node;
}

How to release memory?

struct node
{ // content...
};

std::slist<boos t::shared_ptr<n ode ?
or
struct node
{ boost::shared_p tr<nodenext;
};
or if you look for very high performant solutions try
boost::intrusiv e_ptr which allows very small memory footprints of your
nodes because no additional heap objects are allocated at all.
In fact the only domain of GC solutions are complex data structures with
many cyclic references and without a parent child relation.
Marcel

[Sebastian Nibisz]

or

>
struct node
{ boost::shared_p tr<nodenext;
};

{
for (int x = 0; x < 1000000; ++x)
{
n = n->next = shared_ptr<node >(new node);
}
} // <- STACK OVERFLOW
rgds
Sebastian Nibisz

[Thomas J. Gritzan]

Erik Wikström schrieb:

On 2008-02-28 17:26, Sebastian Nibisz wrote:

>>Garbage collection is for lazy rich folks who can't be bothered to
take out their own trash.

struct node
{
node* next;
};

node* root = new node;
node* n = root;

for (int x = 0; x < 1000000; ++x)
{
n = n->next = new node;
}

How to release memory?

A recursive function?

Stack overflow?

--
Thomas
http://www.netmeister.org/news/learn2quote.html
To iterate is human, to recurse divine.
-L. Peter Deutsch

[Phil Endecott]

Sebastian Nibisz wrote:

>or

struct node
{ boost::shared_p tr<nodenext;
};

{
for (int x = 0; x < 1000000; ++x)
{
n = n->next = shared_ptr<node >(new node);
}
} // <- STACK OVERFLOW

Why?

[Jeff Schwab]

Sebastian Nibisz wrote:

>Garbage collection is for lazy rich folks who can't be bothered to
take out their own trash.

struct node
{
node* next;
};

node* root = new node;
node* n = root;

for (int x = 0; x < 1000000; ++x)
{
n = n->next = new node;
}

How to release memory?

It's hard to guess why you would allocate nodes that way in the first place.

[Sebastian Nibisz]

>{

> for (int x = 0; x < 1000000; ++x)
{
n = n->next = shared_ptr<node >(new node);
}
} // <- STACK OVERFLOW

Why?

{
shared_ptr<node root(new node);
shared_ptr<node n(root);

for (int x = 0; x < 1000000; ++x)
{
n = n->next = shared_ptr<node >(new node);
}
} // <- recursive destruction (root)

rgds
Sebastian Nibisz

[Sebastian Nibisz]

for (int x = 0; x < 10; ++x)

{
n = n->next = new node;
n->next = 0;
}

n=root;
while(n){
root=n;
n=n->next;
delete root;
}

Ok. What if there is a cyclical list?

node* root = new node;
node* n = root;
node* r_n;

int r = rand() % 10;

for (int x = 0; x < 10; ++x)
{
n = n->next = new node;
if (x == r)
{
r_n = n;
}
}

n->next = r_n;

[Sebastian Nibisz]

>struct node

>{
node* next;
};

node* root = new node;
node* n = root;

for (int x = 0; x < 1000000; ++x)
{
n = n->next = new node;
}

How to release memory?

It's hard to guess why you would allocate nodes that way in the first
place.

The parent must know the child.

rgds
Sebastian Nibisz

[James Kanze]

On Feb 28, 7:25 pm, Phil Endecott <spam_from_usen et_0...@chezphi l.org>
wrote:

Sebastian Nibisz wrote:

or

struct node
{ boost::shared_p tr<nodenext;
};

{
for (int x = 0; x < 1000000; ++x)
{
n = n->next = shared_ptr<node >(new node);
}
} // <- STACK OVERFLOW

Why?

You're kidding us, right?

Eric was obviously being facious with his suggestion, since it
obviously wouldn't work; I can't imagine anyone not spotting the
problem immediately. The trick about shared_ptr, here, of
course, is that you don't see the recursion, so you may not
realize that you have the same problem until someone explicitly
asks what will happen.

It's really pretty rare that you can recurse 1000000 times
without the stack overflowing.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Ioannis Vranos]

Sebastian Nibisz wrote:

SGCL is precise, parallel garbage collection library for C++ (at this
time for Windows 32/64 only). SGCL is free software published under
University of Illinois/NCSA Open Source License.

Get it at:
http://sourceforge.net/projects/sgcl/

Regards
Sebastian Nibisz

Sounds like interesting stuff for anyone who wants to use GC in his/her
applications.

The thread shouldn't turn out to the flame "Do we need garbage
collection"? Anyone that can afford it in his/her applications and wants
to, he/she may use it.