source: src/Common/GC.cc@ f229fc2

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// GC.cc --
//
// Author           : Aaron B. Moss
// Created On       : Thu Mar 15 14:47:00 2018
// Last Modified By : Aaron B. Moss
// Last Modified On : Thu Mar 15 14:47:00 2018
// Update Count     : 1
//

#include "GC.h"

#include "Common/PassVisitor.h"

#include "SynTree/GcTracer.h"

#include <algorithm>
#include <cassert>

GC& GC::get() {
        static GC gc;
        return gc;
}

GC::GC() : mark(false), using_young(false), old(), young(), static_roots() {
        old.reserve(70000);
}

GC::~GC() {
        for ( GC_Object* o : young ) {
                delete o;
        }

        for ( GC_Object* o : old ) {
                delete o;
        }
}

const GC& GC::operator<< (const GC_Traceable* obj) const {
        if( obj )
        {
                if( obj->mark != this->mark ) {
                        obj->mark = this->mark;
                        obj->trace( *this );
                }
        }
        return *this;
}

void GC::register_object(GC_Object* obj) {
        (using_young ? young : old).push_back(obj);
        obj->mark = !this->mark;  // initialize as un-marked
}

void GC::register_static_root(BaseSyntaxNode* root) {
        static_roots.push_back(root);
}

void GC::new_generation() {
        assert(!using_young && "Cannot start new generation when young generation already in use");
        
        using_young = true;  // mark young generation as in-use
        mark = !mark;        // switch mark so aged young objects will still be unmarked in old
}

void GC::trace_static_roots() {
        PassVisitor<GcTracer> tracer{ *this };
        for ( BaseSyntaxNode* root : static_roots ) {
                root->accept( tracer );
        }
}

void GC::collect_young() {
        // collect young gen
        for ( GC_Object*& obj : young ) {
                if ( obj->mark != mark ) {
                        delete obj;
                        obj = nullptr;
                }
        }
        
        // move uncollected elements into old gen
        auto end_live = std::remove( young.begin(), young.end(), nullptr );
        old.insert( old.end(), young.begin(), end_live );
        
        // clear young gen
        using_young = false;
        young.clear();

        // reset mark to return to old generation mark
        mark = !mark;
}

void GC::collect() {
        // ensure not called when young gen is active
        assert(!using_young && "Cannot do old collection when young generation is active");

        // collect old gen
        for ( GC_Object*& obj : old ) {
                if ( obj->mark != mark ) {
                        delete obj;
                        obj = nullptr;
                }
        }

        // clear collected elements
        old.erase( std::remove( old.begin(), old.end(), nullptr ), old.end() );

        // reset mark
        mark = !mark;
}

GC_Object::GC_Object() {
        GC::get().register_object( this );
}

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //