在 C++ 中实现一个轻量的标记清除 gc 系统

最新推荐文章于 2022-11-27 15:32:13 发布
最新推荐文章于 2022-11-27 15:32:13 发布
阅读量887 收藏 1
点赞数
分类专栏： C&&C++ 文章标签： c++ tree iterator struct null url
 

在 C++ 中实现一个轻量的标记清除 gc 系统

最近想把 engine 做一个简单 C++ 封装，结合 QT 使用。engine 本身是用纯 C 实现的，大部分应用基于 lua 开发。对对象生命期管理也依赖 lua 的 gc 系统。关于这部分的设计，可以参考我以前写的一篇 为 lua 封装 C 对象的生存期管理问题 。

当我们把中间层搬到 C++ 中时，遇到的问题之一就是，C++ 没有原生的 gc 支持。我也曾经写过一个 gc 库。但在特定应用下还不够简洁。这几天过年休息，仔细考虑了一下相关的需求，尝试实现了一个更简单的 gc 框架。不到 200 行代码吧，我直接列在这篇 blog 里。

这些尚是一些玩具代码，我花了一天时间来写。有许多考虑不周的地方，以及不完整的功能。但可以阐明一些基本思路。

首先我需要一个标记清除的 gc 系统，用来解决引用记数不容易解决的循环引用问题。它的实现不想比引用记数复杂太多，并有相同甚至更高的性能。

我不想使用复杂的 template 技术，利用太多的语法糖让使用看起来简单。如果需要让这些 C++ 代码看起来更现代，更有“品味”，我想也不是很难的事情。

接口和实现希望尽量分离，对用的人少暴露细节。但不拘泥于教条，强求做成类似 COM 那样的通用 ABI 。还是尽量利用 C++ 语言本身提供的机制，不滥用。

使用尽量简单，不要让使用人员有太大负担。

功能满足最低需求即可。代码容易阅读，使用人员可以很快理解原理，不至于误用。也方便日后扩展以适应新的需求。

代码如下：（可打包下载）

/*

 *  filename:  i_gcobject.h

 *  Copyright (c) 2010 ,

 *      Cloud Wu . All rights reserved.

 *

 *      http://www.codingnow.com

 *

 *  Use, modification and distribution are subject to the "New BSD License"

 *  as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.

 */

 

#ifndef interfacce_gcobject_h

#define interfacce_gcobject_h

 

#define interface struct

 

interface i_gcobject {

    virtual ~i_gcobject() {}

    virtual void touch() {}

    virtual void mark() = 0 ;

    virtual void grab() = 0 ;

    virtual void release() = 0 ;

 

    static void collect();

};

 

#endif

所有支持 gc 管理的接口都继承至 i_gcobject ，提供三个方法，

1.    mark 可以把这个对象打上标记，被标记的对象将不会被 collect 回收。

2.    grab 将对象挂接到一个被称呼为 root 的特殊 gcobject 上。

3.    release 将对象从 root 上取掉。

另提供 touch 的模板方法供 mark 回调，用来标记同一对象中的不同部分。

mark 方法一般在 touch 方法中使用，另外，collect 方法将主动调用 root 的 mark 。

/*

 *  filename:  i_gcholder.h

 *  Copyright (c) 2010 ,

 *      Cloud Wu . All rights reserved.

 *

 *      http://www.codingnow.com

 *

 *  Use, modification and distribution are subject to the "New BSD License"

 *  as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.

 */

 

#ifndef interfacce_gcholder_h

#define interfacce_gcholder_h

 

#include "i_gcobject.h"

 

interface i_gcholder : virtual i_gcobject {

    virtual void hold(i_gcobject *) = 0;

    virtual void unhold(i_gcobject *) = 0;

 

    static i_gcholder * create();

};

 

#endif

i_gcholder 为 root 的接口，提供 hold 和 unhold 方法来挂接需要持久保留的 gcobject 。

/*

 *  filename:  gcobject.h

 *  Copyright (c) 2010 ,

 *      Cloud Wu . All rights reserved.

 *

 *      http://www.codingnow.com

 *

 *  Use, modification and distribution are subject to the "New BSD License"

 *  as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.

 */

 

#ifndef gc_object_h

#define gc_object_h

 

#include "i_gcobject.h"

 

class gcobject : virtual i_gcobject {

    bool marked;

public:

    gcobject();

    virtual void mark();

    virtual void grab();

    virtual void release();

    struct f_unmarked;

};

 

#endif

/*

 *  filename:  gcobject.cpp

 *  Copyright (c) 2010 ,

 *      Cloud Wu . All rights reserved.

 *

 *      http://www.codingnow.com

 *

 *  Use, modification and distribution are subject to the "New BSD License"

 *  as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.

 */

 

#include "gcobject.h"

#include "i_gcholder.h"

 

#include <vector>

#include <algorithm>

 

static bool gc_trigger;

static std::vector<gcobject *> gc_pool;

static i_gcholder * gc_root = i_gcholder::create();

 

struct gcobject::f_unmarked {

    bool operator() (gcobject * value) {

        bool unmarked = value->marked != gc_trigger;

        if (unmarked) {

            delete value;

        }

        return unmarked;

    }

};

 

gcobject::gcobject() : marked(!gc_trigger)

{

    gc_pool.push_back(this);

}

 

void

gcobject::mark()

{

    if (marked != gc_trigger) {

        marked = gc_trigger;

        touch();

    }

}

 

void

gcobject::grab()

{

    gc_root->hold(this);

}

 

void

gcobject::release()

{

    gc_root->unhold(this);

}

 

void

i_gcobject::collect()

{

    gc_root->mark();

 

    gc_pool.erase(remove_if(gc_pool.begin(), gc_pool.end() , gcobject::f_unmarked()), gc_pool.end());

 

    gc_trigger = !gc_trigger;

}

gcobject 为具体的 gc 实现，实现了 mark 、grab、release 和 collect 方法。

1.    mark 采用的直接向一 bool 变量设置标记。这个标记利用了 trigger 这个乒乓开关，每次 collect 都会切换状态。

2.    grab 和 release 可以把对象挂接到 root 上，或从上取掉。

3.    collect 会主动从 root 开始 mark ，并释放那些没有 mark 的对象。

/*

 *  Copyright (c) 2010 ,

 *      Cloud Wu . All rights reserved.

 *

 *      http://www.codingnow.com

 *

 *  Use, modification and distribution are subject to the "New BSD License"

 *  as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.

 */

 

#include "i_gcholder.h"

#include "gcobject.h"

#include <vector>

#include <algorithm>

#include <cassert>

 

class gcholder : public virtual i_gcholder, virtual gcobject {

    std::vector<i_gcobject *> hold_set;

    std::vector<i_gcobject *> unhold_set;

    bool set_changed;

    bool hold_set_sorted;

    bool unhold_set_sorted;

    void combine_set();

    virtual void touch();

    virtual void hold(i_gcobject *obj) {

        hold_set.push_back(obj);

        hold_set_sorted = false;

        set_changed = true;

    }

    virtual void unhold(i_gcobject *obj) {

        unhold_set.push_back(obj);

        unhold_set_sorted = false;

        set_changed = true;

    }

    struct f_mark {

        void operator() (i_gcobject *obj) {

            obj->mark();

        }

    };

public:

    gcholder() :

        set_changed(false),

        hold_set_sorted(true) ,

        unhold_set_sorted(true) {}

};

 

void

gcholder::combine_set()

{

    if (!hold_set_sorted) {

        std::sort(hold_set.begin(),hold_set.end());

        hold_set_sorted = true;

    }

    if (!unhold_set_sorted) {

        std::sort(unhold_set.begin(),unhold_set.end());

        unhold_set_sorted = true;

    }

    if (!unhold_set.empty()) {

        std::vector<i_gcobject *>::iterator iter1 = hold_set.begin();

        std::vector<i_gcobject *>::iterator iter2 = unhold_set.begin();

        while (iter1 != hold_set.end() && iter2 != unhold_set.end()) {

            if (*iter1 == *iter2) {

                *iter1 = NULL;

                ++iter1;

                ++iter2;

            }

            else {

                assert(*iter1 < *iter2);

                ++iter1;

            }

        }

        i_gcobject * null = NULL;

        hold_set.erase(std::remove(hold_set.begin(),hold_set.end(),null) , hold_set.end());

        unhold_set.clear();

    }

}

 

void

gcholder::touch()

{

    if (set_changed) {

        combine_set();

        set_changed = false;

    }

 

    std::for_each(hold_set.begin(), hold_set.end(), f_mark());

}

 

i_gcholder *

i_gcholder::create()

{

    return new gcholder;

}

gcholder 理论上可以有多个实例，并相互挂接。（否则不需要继承至 i_gcobject ）这个设计可以用来模拟多级的堆栈。但实际上并不需要这么复杂。因为在大部分应用里，如果你的程序有一个周期性的主循环，就可以不在 gc 系统里模拟出一个多级的堆栈。我们只用在循环之外做 collect 即可。再堆栈调用的较深层次触发 collect 反而效果不佳，会导致许多临时 gc 对象无法回收。

最后来看一个玩具代码，用 stl 里的 mutliset 实现了一个简单的树接口。可能没有什么使用价值，但它演示了一个较复杂的对象相互引用的关系。并可以展示 gc 如何正确工作。

/*

 *  filename:  test.cpp

 *  Copyright (c) 2010 ,

 *      Cloud Wu . All rights reserved.

 *

 *      http://www.codingnow.com

 *

 *  Use, modification and distribution are subject to the "New BSD License"

 *  as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.

 */

 

#include "gcobject.h"

 

#include <cstdio>

#include <set>

#include <algorithm>

 

interface i_tree : virtual i_gcobject {

    virtual void link(i_tree *p) = 0;

 

    static i_tree * create();

};

 

class tree : public virtual i_tree , virtual gcobject {

    tree *parent;

    std::multiset<tree *> children;

 

    struct f_mark {

        void operator() (tree *node) {

            node->mark();

        }

    };

 

    virtual void touch() {

        if (parent)

            parent->mark();

 

        std::for_each(children.begin(), children.end(), f_mark());

    }

 

    void unlink();

 

    virtual void link(i_tree *parent);

public:

    tree() : parent(NULL) {

        printf("create node %p\n",this);

    }

    ~tree() {

        printf("release node %p\n",this);

    }

};

 

void

tree::unlink()

{

    if (parent) {

        parent->children.erase(this);

 

        parent = NULL;

    }

}

 

void

tree::link(i_tree *p)

{

    unlink();

    if (p) {

        tree * cp = dynamic_cast<tree *>(p);

        cp->children.insert(this);

        parent = cp;

    }

}

 

i_tree *

i_tree::create()

{

    return new tree;

}

 

int

main()

{

    i_tree *root = i_tree::create();

 

    root->grab();

 

    i_tree *node;

 

    node = i_tree::create();

    node->link(root);

 

    node = i_tree::create();

    node->link(root);

 

    i_gcobject::collect();

 

    printf("collected\n");

    node->link(NULL);

 

    i_gcobject::collect();

 

    printf("finalize\n");

 

    root->release();

 

    i_gcobject::collect();

 

    return 0;

}

我们在实现一个基于 gc 的对象时，可以先定义出需要的接口，让接口从 i_gcobject 继承。例如上例中的 i_tree 。

然后在实现这个接口时，可以虚继承 gcobject 。例如上例中的 tree 。

如果有需要，就重载 touch 方法，在 touch 方法中 mark 相关的 gcobject 。对于 tree 这个例子，就是调用父亲和孩子节点的 mark 。

对象依然可以写析构函数，相当于对象的 finalize 。在析构函数中，不要再释放和它相关的 gcobject ，那些留给 gc 系统去完成。（例如在 tree 里，就不要在 ~tree 中 delete children 容器中的变量，也不需要把自己从父亲节点上摘掉）

如果仅仅只是使用那些接口，则不需要再包含 gcobject.h ，因为 gcobject 的细节只供实现 i_gcobject 时使用。

 

一剑平江湖
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
再论C++之垃圾回收（GC）
QBox/Golang/CERL/StdExt/TPL/WinxGui - 许式伟的专栏
11-24 3万+
本文已经迁移到： http://cpp.winxgui.com/cn:garbage-collection-in-cplusplus使用智能指针（smart pointers） http://www.codeproject.com/cpp/garbage_collect.asp 原理：基于引用计数（reference count）。这种垃圾回收（gc）算法无非都是给每一
gc算法（标记清除，复制，标记整理）
cainiao_study的博客
06-18 9996
此处记录下对gc算法的理解 1.对于标记清除，分为2部分，先进行标记，然后进行清除，如下图所示： 对上图中的灰色部分进行垃圾回收，回收后的截图如下所示： 从图中可知，进行标记清理后，可以看出，清楚后的内存可用内存增加，但是清除垃圾后的内存地址不连接，出现垃圾碎片，当有大对象需要进行内存分配时，会因为找不到足够内存进行分配对象而造成垃圾回收，频繁的垃圾回收影响效率和性能 2.对上一个...
C++实现垃圾回收器（GC）
最新发布
qq285503851的博客
11-27 1668
C++实现垃圾回收器（GC），下面将写一个类，只要继承这个类，在合适的位置使用GC::instance.collect();就可以批量delete已申请的内存，如果有一些内存不需要释放可以添加例外GC::instance.pin(p2);，使用GC::instance.unpin§;在.net中，不必考虑内存问题，因为有垃圾回收机制，但是在C++中，必须靠程序员释放申请的内存空间，如果操作不得当，很有可能会内存泄漏。
一个简单的C++垃圾回收器实现（GC）
weixin_33682719的博客
08-09 550
在C++本来是没有垃圾回收器的，而随着内存的廉价一些新型的语言都加入了垃圾回收的策略（Garbage Collection），比如Java，C#等语言。带着垃圾回收原理的探究的想法，这里简单实现一个垃圾回收器：采用引用计数的方法。使用C++语言。代码完整/********************** **gc.h ***********************/ #i...
GC基本算法及C++GC机制
weixin_34419321的博客
12-27 573
前言 垃圾收集器是一种动态存储分配器，它自动释放程序不再需要的已分配的块，这些块也称为垃圾。在程序员看来，垃圾就是不再被引用的对象。自动回收垃圾的过程则称为垃圾收集（garbage collection）。在一个支持垃圾收集的语言中，程序显式地申请内存，但从不需要显式的释放它们。垃圾收集器会定期识别垃圾块，并将垃圾块放回空闲链表中。显然，C语言的malloc包不是一个带GC功能的分配器，程序员显式...
轻量级C++实现的httpserver和httpclient
03-17
总的来说，"轻量级C++实现的httpserver和httpclient"是一个很好的学习资源，它展示了如何利用mongoose库在C++项目中快速实现HTTP服务功能，为开发者提供了更灵活的选择。无论是为了学习还是实际项目开发，这都是一个...
C++实现最小二乘法一元回归和多项式拟合
03-23
在进行曲线拟合时用的最多的是最小二乘法，其中以一元函数（线性）和多元函数（多项式）居多，下面这个类专门用于进行多项式拟合，可以根据用户输入的阶次进行多项式拟合，算法来自于网上，和GSL的拟合算法对比过，...
用c++实现在一个txt文件中查找字符
12-28
用c++实现在一个txt文件中查找字符，算法就是字符串匹配，没什么技巧性，最后还给出了运行时间，适合初学者参考
一个C++跨平台的轻量级日志类
01-29
// 一个跨平台的轻量级日志类。此类在于展示： // 1. 多线程写日志的思想。（写日志的动作不应对主程序产生较大影响） // 2. 展示了跨平台的线程安全、信号通知等机制 // 3. 展示了一个高效的数据处理器 // 4. 展示...
删除文件恢复C++实现
05-27
在Windows系统中，当一个文件被删除，系统并不会立即清除其在硬盘上的数据，而是将其从文件分配表（FAT或MFT，对于NTFS）中移除，释放出相应的簇链。这意味着只要数据尚未被新数据覆盖，理论上就有可能恢复已删除的...
迷你垃圾回收器mini gc for c
04-10
研究tinygc源代码写了一个迷你的保守垃圾回收器，欢迎多多交流。
内存管理器（二十一）标记-清扫回收算法
密码小仙女
08-05 899
内存回收一共有四种基本的算法及若干高级算法： 标记-清扫，标记-复制，标记-整理，引用计数。 任何自动内存管理都需要面临三个基本任务： 1.为新对象分配空间。 2.确定存活时间。 3.回收死亡对象所占空间。 讨论前提： 多线程条件下，只有一个回收线程。 垃圾回收前提： “万物静止式”回收，所有的资源分配器都会静止，回收线程开始运作，从资源分配器的角度来看回收过程是原子的。 回...
垃圾回收算法之标记-清除算法
K.Sun
11-01 2051
标记-清除（Mark-Sweep）算法顾名思义，主要就是两个动作，一个是标记，另一个就是清除。标记就是根据特定的算法（如：引用计数算法，可达性分析算法等）标出内存中哪些对象可以回收，哪些对象还要继续用。标记指示回收，那就直接收掉；标记指示对象还能用，那就原地不动留下。缺点 标记与清除效率低; 清除之后内存会产生大量碎片；
C++简单实现GC和内存池
略游
07-22 2701
C++简单实现GC和内存池   本章前言：     这章就是为了避开传统的new\delete创建堆对象的手法，如果使用不当指针容易出现问题，所以本章简单的实现了引用计数垃圾回收，使用起来貌似还不错。Bug还有待测试。   最终效果：     通过DND_GC_CLASS宏来定义一个Student类后，用户还是能通过正常的方法使用Student类。但宏额外生成了HStudent类，通过这个
C/C++中几种经典的垃圾回收算法
kanwoerzi
10-20 838
1.引用计数算法 引用计数（Reference Counting）算法是每个对象计算指向它的指针的数量，当有一个指针指向自己时计数值加1；当删除一个指向自己的指针时，计数值减1，如果计数值减为0，说明已经不存在指向该对象的指针了，所以它可以被安全的销毁了。可以很直观的用下面的图表示： 引用计数算法的优点在于内存管理的开销分布于整个应用程序运行期间，非常的“平滑”，无需挂起应用程序的...
GC_2_标记-清除算法
伍叶的博客
03-28 1709
2 GC标记-清除算法   世界上首个值得纪念的GC算法是GC标记-清除算法（Mark Sweep GC）。自其问世以来，一直到半个世纪后的今天，它依然是各种处理程序所用的伟大的算法。 2.1 什么是GC标记-清除算法   由标记阶段和清除阶段组成。标记阶段是把所有活动对象都做上标记。清除阶段是把那些没有标记的对象，也就是非活动对象回收。通过这两个阶段，就可以令不能利用的空间重新得到利用。下
C++的简易内存管理工具实现--垃圾回收
weixin_38600908的博客
07-25 727
Writing a Mark-Sweep Garbage Collector Tracing vs. Direct collectors 所有 GC 算法都分为tracing和direct。 尽管被称为“垃圾”收集器，但跟踪收集器实际上并不识别垃圾。相反，情况恰恰相反——它们识别活着的对象，通过扩展将其他一切视为垃圾。 Mark-Sweep 是一个跟踪收集器，因此我们将在我们的实现中进行跟踪阶段。 由于我们选择在 C++ 中实现收集器，我们现在将讨论与它的运行时系统相关的一些细节。 C++ specif
C++杂志订阅管理系统方案.pdf
05-16
C++杂志订阅管理系统方案.pdfC++杂志订阅管理系统方案.pdfC++杂志订阅管理系统方案.pdfC++杂志订阅管理系统方案.pdfC++杂志订阅管理系统方案.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值