GC.h

Go to the documentation of this file.

// GC.h: Garbage Collector for Gnash
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_GC_H
#define GNASH_GC_H

// Define the following macro to enable GC verbosity 
// Verbosity levels:
//   1 - print stats about how many resources are registered and how many 
//       are deleted, everytime the GC collector runs.
//   2 - print a message for every GcResource being registered and being deleted
//   3 - print info about the mark scan 
//   
//#define GNASH_GC_DEBUG 1

#include <list>
#include <map>
#include <string>
#include <cassert>

#include "dsodefs.h"
#ifdef GNASH_GC_DEBUG
# include "log.h"
# include "utility.h"
#endif

// Forward declarations.
namespace gnash {
    class GC;
}

namespace gnash {

//
class GcRoot
{
public:

    //
    virtual void markReachableResources() const = 0;

    virtual ~GcRoot() {}
};

//
class GcResource
{
public:

    friend class GC;

    //
    GcResource(GC& gc);

    //
    //
    void setReachable() const {

        if (_reachable) {

#if GNASH_GC_DEBUG > 2
            log_debug(_("Instance %p of class %s already reachable, "
                    "setReachable doing nothing"), (void*)this,
                    typeName(*this));
#endif
            return;
        }

#if GNASH_GC_DEBUG  > 2
        log_debug(_("Instance %p of class %s set to reachable, scanning "
                "reachable resources from it"), (void*)this,
                typeName(*this));
#endif

        _reachable = true;
        markReachableResources();
    }

    bool isReachable() const { return _reachable; }

    void clearReachable() const { _reachable = false; }

protected:

    //
    virtual void markReachableResources() const {
        assert(_reachable);
#if GNASH_GC_DEBUG > 1
        log_debug(_("Class %s didn't override the markReachableResources() "
                    "method"), typeName(*this));
#endif
    }

    //
    virtual ~GcResource() {}

private:

    mutable bool _reachable;

};

//
class DSOEXPORT GC
{

public:

    //
    GC(GcRoot& root);

    ~GC();

    //
    void addCollectable(const GcResource* item) {

#ifndef NDEBUG
        assert(item);
        assert(!item->isReachable());
#endif

        _resList.push_back(item); ++_resListSize;

#if GNASH_GC_DEBUG > 1
        log_debug(_("GC: collectable %p added, num collectables: %d"), item, 
                _resListSize);
#endif
    }

    void fuzzyCollect() {

        // Heuristic to decide wheter or not to run the collection cycle
        //
        //
        // Things to consider:
        //
        //  - Cost 
        //      - Depends on the number of reachable collectables
        //      - Depends on the frequency of runs
        //
        //  - Advantages 
        //      - Depends on the number of unreachable collectables
        //
        //  - Cheaply computable informations
        //      - Number of collectables (currently O(n) but can be optimized)
        //      - Total heap-allocated memory (currently unavailable)
        //
        // Current heuristic:
        //
        //  - We run the cycle again if X new collectables were allocated
        //    since last cycle run. X defaults to maxNewCollectablesCount
        //    and can be changed by user (GNASH_GC_TRIGGER_THRESHOLD env
        //    variable).
        //
        // Possible improvements:
        //
        //  - Adapt X (maxNewCollectablesCount) based on cost/advantage
        //    runtime analisys
        //

        if (_resListSize <  _lastResCount + _maxNewCollectablesCount) {
#if GNASH_GC_DEBUG  > 1
            log_debug(_("GC: collection cycle skipped - %d/%d new resources "
                        "allocated since last run (from %d to %d)"),
                    _resListSize-_lastResCount, _maxNewCollectablesCount,
                    _lastResCount, _resListSize);
#endif // GNASH_GC_DEBUG
            return;
        }

        runCycle();
    }

    //
    void runCycle();

    typedef std::map<std::string, unsigned int> CollectablesCount;

    void countCollectables(CollectablesCount& count) const;

private:

    typedef std::list<const GcResource*> ResList;

    void markReachable() {
#if GNASH_GC_DEBUG > 2
        log_debug(_("GC %p: MARK SCAN"), (void*)this);
#endif
        _root.markReachableResources();
    }

    //
    size_t cleanUnreachable();

    size_t _maxNewCollectablesCount;

    ResList _resList;

    ResList::size_type _resListSize;

    GcRoot& _root;

    ResList::size_type _lastResCount;

#ifdef GNASH_GC_DEBUG 

    size_t _collectorRuns;
#endif
};


inline GcResource::GcResource(GC& gc)
    :
    _reachable(false)
{
    gc.addCollectable(this);
}

} // namespace gnash

#endif // GNASH_GC_H