lestes::std::mem::gc Class Reference

Garbage collector. More...

#include <gc.hh>

List of all members.

Static Public Member Functions
static ulint	live_roots (void)
	Returns number of live root pointers.
static ulint	live_keystones (void)
	Returns number of live keystones.
static void	run (void)
	Runs garbage collection.
Private Member Functions
	gc (const gc &)
	Hides copy constructor.
gc &	operator= (const gc &)
	Hides assignment operator.
Static Private Member Functions
static void	init (void)
	Initializes static variables.
static void	cleanup (void)
	Performs cleanup of static variables.
Static Private Attributes
static ulint	initialized = 0
	Guard flag to prevent multiple initialization.
static root_pointer *	roots
	Doubly linked list of all root pointers.
static keystone *	keystones
	Singly linked list of all keystones.
static keystone *	marked
	Singly linked list of marked keystones.
Friends
class	init_gc
	Initializer accesses gc private methods.
class	root_pointer
	Root pointer accesses gc private fields for speed.
class	keystone
	Keystone accesses gc private fields for speed.

---

Detailed Description

Garbage collector.

Provides garbage collector functionality.

Definition at line 78 of file gc.hh.

---

Constructor & Destructor Documentation

lestes::std::mem::gc::gc

(

const gc &

)

[private]

Hides copy constructor.

---

Member Function Documentation

ulint lestes::std::mem::gc::live_roots

(

void

)

[static]

Returns number of live root pointers.

Counts live root pointers.

Returns:

The number of live root pointers.

Definition at line 114 of file gc.cc.

References lestes::std::mem::root_pointer::next, and roots.

Referenced by lestes::std::mem::gc_test().

{
        ulint cnt = 0;
        for (root_pointer *p = roots->next; p != roots; p = p->next) {
                cnt++;
        }
        return cnt;
}

ulint lestes::std::mem::gc::live_keystones

(

void

)

[static]

Returns number of live keystones.

Counts live keysones.

Returns:

The number of live keystones.

Definition at line 127 of file gc.cc.

References keystones, and lestes::std::mem::keystone::keystones_next.

Referenced by lestes::std::mem::gc_test().

{
        ulint cnt = 0;
        for (keystone *p = keystones; p != NULL; p = p->keystones_next) {
                cnt++;
        }
        return cnt;
}

void lestes::std::mem::gc::run

(

void

)

[static]

Runs garbage collection.

Runs garbage collection, invoked in new_handler. Should be invoked explicitly after completing task.

Definition at line 140 of file gc.cc.

References lestes::std::mem::keystone::enqueue(), lestes::std::mem::keystone::gc_mark(), keystones, lestes::std::mem::keystone::keystones_next, marked, lestes::std::mem::keystone::marked_next, lestes::std::mem::root_pointer::next, roots, and lestes::std::mem::keystone::sweep().

Referenced by cleanup().

{
        // initialize the global marked list
        marked = NULL;
        // walk through all root pointers and
        // insert keystones into marked list
        for (root_pointer *p = roots->next; p != roots; p = p->next) {
                keystone *key = p->pointer_get();
                if (key) key->enqueue();
        }
        
        // mark all levels of keystones
        while (marked != NULL) {
                keystone *old = marked;
                // initialize the global list for new marking
                marked = NULL;
                while (old) {
                        // mark directly reachable keystones
                        old->gc_mark();
                        old = old->marked_next;
                }
        }
        
        keystone *key = keystones;

        // initialize the linked list before new connecting
        keystones = NULL;
        
        // walk through all keystones and sweep unmarked
        while (key != NULL) {
                // save the pointer to next
                keystone *tmp = key->keystones_next;
                // after sweep_object, obj may be invalid
                key->sweep();
                // restore pointer to next
                key = tmp;
        }
}

void lestes::std::mem::gc::init

(

void

)

[static, private]

Initializes static variables.

Initializes static fields of gc class. Prevents multiple initialization.

Definition at line 71 of file gc.cc.

References initialized, keystones, marked, root_pointer, and roots.

Referenced by lestes::std::mem::init_gc::init_gc().

{
        if (initialized++) return;
        // create head of linked list
        roots = new root_pointer(false);
        keystones = NULL;
        marked = NULL;
}

void lestes::std::mem::gc::cleanup

(

void

)

[static, private]

Performs cleanup of static variables.

Performs cleanup of static fields of gc class.

TMA: also cleans all remaining objects.

Definition at line 85 of file gc.cc.

References initialized, roots, and run().

Referenced by lestes::std::mem::init_gc::~init_gc().

{
        if (--initialized) return;
        run();
        delete roots;
}

gc& lestes::std::mem::gc::operator=

(

const gc &

)

[private]

Hides assignment operator.

---

Friends And Related Function Documentation

friend class init_gc [friend]

Initializer accesses gc private methods.

Definition at line 88 of file gc.hh.

friend class root_pointer [friend]

Root pointer accesses gc private fields for speed.

Definition at line 96 of file gc.hh.

Referenced by init().

friend class keystone [friend]

Keystone accesses gc private fields for speed.

Definition at line 98 of file gc.hh.

---

Member Data Documentation

ulint lestes::std::mem::gc::initialized = 0 [static, private]

Guard flag to prevent multiple initialization.

Counter to keep track of number of initializaton objects. Reaches zero only after all initialization objects are destroyed.

Definition at line 94 of file gc.hh.

Referenced by cleanup(), and init().

root_pointer * lestes::std::mem::gc::roots [static, private]

Doubly linked list of all root pointers.

Start of doubly linked list of all root pointers. Initialized to point to the fake head entry.

Definition at line 100 of file gc.hh.

Referenced by cleanup(), init(), live_roots(), lestes::std::mem::root_pointer::root_pointer(), and run().

keystone * lestes::std::mem::gc::keystones [static, private]

Singly linked list of all keystones.

Start of singly linked list of all keystones. Initially the list is empty.

Definition at line 102 of file gc.hh.

Referenced by init(), lestes::std::mem::keystone::keystone(), live_keystones(), run(), and lestes::std::mem::keystone::sweep().

keystone * lestes::std::mem::gc::marked [static, private]

Singly linked list of marked keystones.

Start of singly linked list of marked keystones. Initially the list is empty.

Definition at line 104 of file gc.hh.

Referenced by lestes::std::mem::keystone::enqueue(), init(), and run().

---

The documentation for this class was generated from the following files:

• gc.hh
• gc.cc

---