Skip to content

Reference counting handling circular memory references.

License

Notifications You must be signed in to change notification settings

thrunduil/cyclic_rc

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

13 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

cyclic_rc

Reference counting handling circular memory references.

cyclic_rc :: shared_ptr class offers similar functionality to std :: shared_ptr, but is able to reclaim memory in case of reference cycles. This class retains shared ownership of an object through a pointer. Several shared_ptr objects may own the same object. The object is destroyed and its memory deallocated when:

  1. reference count drops to zero , or
  2. reference count is nonzero, but during cycle collection phase it is discovered, that this object belongs to mutually referencing group of objects, not referenced by any object outside this group.

During collection phase a set of possibly no longer accessible objects is created. Next all objects referenced by objects from this set are visited. The user must provide a function, that perform this traversal.

cyclic_rc :: shared_ptr can work in multithreaded environment, however garbage collection is blocking.

References:

[1] "A Pure Reference Counting Garbage Collector", 2001, Bacon, D. F., Attanasio, C. R., Rajan, V. T., Smith, S. E., & LEE, H.

Code example

Simple bitset operations:

#include "cyclic_rc/shared_ptr.h"
#include <iostream>

using namespace cyclic_rc;

// forward declarations
struct tree;
using tree_ptr  = shared_ptr<tree, false>;

// class managed by shared_ptr in single-thread mode
struct tree : cyclic_rc_base<false>
{
    tree_ptr    left;
    tree_ptr    right;

    ~tree()
    {
        std::cout << "tree destroyed" << "\n";
    };

    // implementation of traversal function
    void visit_children(int t) override
    {
        left.visit_children(t);
        right.visit_children(t);
    };
};

void example()
{
    // create reference cycle
    tree_ptr root = tree_ptr(new tree());

    root->left  = root;
    root->right = root;
    
    std::cout << "object no longer accessible" << "\n";
    root = tree_ptr();

    std::cout << "collector called" << "\n";
    
    // force garbage collection
    tree_ptr::collect(true);
};

Output:
    object no longer accessible
    collector called
    tree destroyed

Licence

This library is published under GPL licence.

About

Reference counting handling circular memory references.

Topics

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published