1. Python垃圾回收算法描述 --解读PythonGC.leo

我是个懒人啊,老早就研究过一小点gc,但是一看c语言代码就郁闷了。

今天下午把一直想试试的leo弄下来玩,顺便下下来pythonGC.leo,一会就把整个脉络弄清楚了,leo在阅读复杂代码方面确实不错,其他的好处,挖掘中...,呵呵

如果对一些gc基本不了解,建议先看我以前写的一篇blog,开始了:

   1 
   2 // 这个函数最关键,阅读这个函数能够帮助理解收集工作大致是如何进行的
   3 
   4 static long
   5 collect(PyGC_Head *young, PyGC_Head *old)
   6 {
   7 /*young是当前收集的一代,剩下的对象也就是还有用的对象留下来放到old这一代*/
   8  long n = 0;
   9  long m = 0;
  10  PyGC_Head reachable;
  11  PyGC_Head unreachable;
  12  PyGC_Head finalizers;
  13  PyGC_Head *gc;
  14 
  15  if (debug & DEBUG_STATS) {
  16   PySys_WriteStderr(
  17    "gc: collecting generation %d...\n"
  18    "gc: objects in each generation: %ld %ld %ld\n",
  19    generation,
  20    gc_list_size(&_PyGC_generation0),
  21    gc_list_size(&generation1),
  22    gc_list_size(&generation2));
  23  }
  24 
  25  /* 使用 ob_refcnt 和 gc_refs, 计算容器集合中哪些对象
  26   * 从该集合外部可达的 (比如考虑了容器内部所有引用
  27   * 之后,refcount仍然大于0的) */
  28  update_refs(young);
  29  subtract_refs(young);
  30 
  31  /* 将所有从外部可达的对象移动到
  32   * reachable 集合(ie. gc_refs > 0).  然后, 
  33   * 移动所有从reachable集合中的对象可达的对象
  34   */
  35  gc_list_init(&reachable);
  36  move_roots(young, &reachable);
  37  move_root_reachable(&reachable);
  38 
  39  /* 将不可达的对象移动到临时列表, 
  40   * 在这开始就可以分配新对象了 */
  41  gc_list_init(&unreachable);
  42  gc_list_move(young, &unreachable);
  43 
  44  /* 将可达的对象移动到下一代 */
  45  gc_list_merge(&reachable, old);
  46 
  47  /* 移动从finalizers可达的对象, 我们还不能安全的删除他们
  48   * .  Python程序员注意不要去创建这样的东西。
  49   * 对Python来说 finalizers 就是拥有 __del__ 方法的对象实例. */
  50  gc_list_init(&finalizers);
  51  move_finalizers(&unreachable, &finalizers);
  52  move_finalizer_reachable(&finalizers);
  53 
  54  /* 收集已发现的可回收的对象的统计数据,
  55   * 然后打印调试信息 */
  56  for (gc = unreachable.gc.gc_next; gc != &unreachable;
  57    gc = gc->gc.gc_next) {
  58   m++;
  59   if (debug & DEBUG_COLLECTABLE) {
  60    debug_cycle("collectable", FROM_GC(gc));
  61   }
  62  }
  63  /* 对每个可回收的对象调用tp_clear.  它可以打破引用循环
  64   * .也可能导致一些finalizer对象被释放*/
  65  delete_garbage(&unreachable, old);
  66 
  67  /* 收集不可回收对象的统计数据。
  68   * 打印调试信息. */
  69  for (gc = finalizers.gc.gc_next; gc != &finalizers;
  70    gc = gc->gc.gc_next) {
  71   n++;
  72   if (debug & DEBUG_UNCOLLECTABLE) {
  73    debug_cycle("uncollectable", FROM_GC(gc));
  74   }
  75  }
  76  if (debug & DEBUG_STATS) {
  77   if (m == 0 && n == 0) {
  78    PySys_WriteStderr("gc: done.\n");
  79   }
  80   else {
  81    PySys_WriteStderr(
  82        "gc: done, %ld unreachable, %ld uncollectable.\n",
  83        n+m, n);
  84   }
  85  }
  86 
  87  /* 将finalizers加到一个可达的 Python 垃圾列表
  88   * 程序员必须处理这个问题,如果他们非要创建这种结构的话. */
  89  handle_finalizers(&finalizers, old);
  90 
  91  if (PyErr_Occurred()) {
  92   if (gc_str == NULL) {
  93       gc_str = PyString_FromString("garbage collection");
  94   }
  95   PyErr_WriteUnraisable(gc_str);
  96   Py_FatalError("unexpected exception during garbage collection");
  97  }
  98  allocated = 0;
  99  return n+m;
 100 }

注释够清晰吧(可能翻译有点烂,受不了的话就赶紧去下个leo玩吧) 下面一段是分代机制:

   1 static long
   2 collect_generations(void)
   3 {
   4 /* static就相当于是全局变量了
   5  * collections0的意思就是第0代收集了多少次了
   6  * threshold1的意思就是第0代需要收集多少次才开始收集第1代
   7  * 这里可以先告诉大家threshold1=threshold2=10
   8  * 中心思想就是:从0代开始收集,10次之后收集第1代,
   9  * 又10次之后收集第2代,收集一次后回到第0代
  10  */
  11  static long collections0 = 0;
  12  static long collections1 = 0;
  13  long n = 0;
  14 
  15 
  16  if (collections1 > threshold2) {
  17   generation = 2;
  18   gc_list_merge(&_PyGC_generation0, &generation2);
  19   gc_list_merge(&generation1, &generation2);
  20   if (generation2.gc.gc_next != &generation2) {
  21    n = collect(&generation2, &generation2);
  22   }
  23   collections1 = 0;
  24  }
  25  else if (collections0 > threshold1) {
  26   generation = 1;
  27   collections1++;
  28   gc_list_merge(&_PyGC_generation0, &generation1);
  29   if (generation1.gc.gc_next != &generation1) {
  30    n = collect(&generation1, &generation2);
  31   }
  32   collections0 = 0;
  33  }
  34  else {
  35   generation = 0;
  36   collections0++;
  37   if (_PyGC_generation0.gc.gc_next != &_PyGC_generation0) {
  38    n = collect(&_PyGC_generation0, &generation1);
  39   }
  40  }
  41  return n;
  42 }

再往上走就是_PyObject_GC_Malloc了,这里大家可以看到垃圾回收是什么条件下触发的。

   1 PyObject *
   2 _PyObject_GC_Malloc(PyTypeObject *tp, int nitems)
   3 {
   4  PyObject *op;
   5  const size_t basicsize = _PyObject_VAR_SIZE(tp, nitems);
   6 #ifdef WITH_CYCLE_GC
   7  const size_t nbytes = sizeof(PyGC_Head) + basicsize;
   8  PyGC_Head *g = PyObject_MALLOC(nbytes);
   9  if (g == NULL)
  10   return (PyObject *)PyErr_NoMemory();
  11  g->gc.gc_next = NULL;
  12  allocated++;
  13  /*
  14   *allocated是个全局变量,记录从上次回收以来
  15   *分配的对象的数目,而 threshold0=700
  16   */
  17   if (allocated > threshold0 &&
  18       enabled &&
  19       threshold0 &&
  20       !collecting &&
  21       !PyErr_Occurred()) {
  22   collecting = 1;
  23    collect_generations();
  24   collecting = 0;
  25  }
  26  op = FROM_GC(g);
  27 #else
  28  op = PyObject_MALLOC(basicsize);
  29  if (op == NULL)
  30   return (PyObject *)PyErr_NoMemory();
  31 
  32 #endif
  33  return op;
  34 }

如果还要往上走,就是

   1 PyObject *
   2 _PyObject_GC_New(PyTypeObject *tp)
   3 {
   4  PyObject *op = _PyObject_GC_Malloc(tp, 0);
   5  if (op != NULL)
   6   op = PyObject_INIT(op, tp);
   7  return op;
   8 }

了,分配内存然后初始化,所有的对象模型都是一个样。

当然内部还有许多细节了,比如确定一个对象是否可达,处理引用循环,处理finalizers (想了半天还是不知道该怎么翻译这个词) 等等。大家自己用leo看吧,保证越看越爽,哈哈。

  • 感谢分享快乐体验!我也是一直使用Leo 的,如果你感觉说明不清楚,可以截屏来表达哪!? -- ZoomQuiet