GC实现 1.堆上分配空间

Author: koshox

CMakeLists.txt

@@ -25,7 +25,7 @@ ADD_EXECUTABLE(pythonvm main.cpp
         #runtime/traceback.cpp
         #runtime/generator.cpp
         runtime/cellObject.cpp
-        #memory/heap.cpp
+        memory/heap.cpp
         #memory/oopClosure.cpp
         code/binaryFileParser.cpp
         code/codeObject.cpp)

memory/heap.cpp

@@ -0,0 +1,130 @@
+//
+// Created by Kosho on 2020/9/13.
+//
+#include <stdlib.h>
+
+#include "runtime/universe.hpp"
+#include "memory/heap.hpp"
+
+Space::Space(size_t size) {
+    _size = size;
+    _base = (char *) malloc(size);
+    _end = _base + size;
+    _top = (char *) (((long long) (_base + 15)) & -16); // 16字节对齐
+    _capacity = _end - _top;
+}
+
+Space::~Space() {
+    if (_base) {
+        free(_base);
+        _base = 0;
+    }
+
+    _top = 0;
+    _end = 0;
+    _capacity = 0;
+    _size = 0;
+}
+
+bool Space::can_alloc(size_t size) {
+    return _capacity > size;
+}
+
+bool Space::has_obj(char *obj) {
+    return obj >= _base && _end > obj;
+}
+
+void *Space::allocate(size_t size) {
+    // 8字节对齐
+    size = (size + 7) & -8;
+    char *start = _top;
+    _top += size;
+    _capacity -= size;
+    return start;
+}
+
+void Space::clear() {
+    memset(_base, 0, _size);
+    _top = (char *) (((long long) (_base + 15)) & -16);
+    _capacity = _end - _top;
+}
+
+Heap *Heap::instance = NULL;
+size_t Heap::MAX_CAP = 2 * 1024 * 1024;
+
+Heap *Heap::get_instance() {
+    if (instance == NULL)
+        instance = new Heap(MAX_CAP);
+
+    return instance;
+}
+
+Heap::Heap(size_t size) {
+    mem_1 = new Space(size);
+    mem_2 = new Space(size);
+    metaspace = new Space(size / 16);
+
+    mem_1->clear();
+    mem_2->clear();
+    metaspace->clear();
+
+    eden = mem_1;
+    survivor = mem_2;
+}
+
+Heap::~Heap() {
+    if (mem_1) {
+        delete mem_1;
+        mem_1 = NULL;
+    }
+
+    if (mem_2) {
+        delete mem_2;
+        mem_2 = NULL;
+    }
+
+    if (metaspace) {
+        delete metaspace;
+        metaspace = NULL;
+    }
+
+    eden = NULL;
+    survivor = NULL;
+}
+
+void *Heap::allocate(size_t size) {
+    if (!eden->can_alloc(size)) {
+        gc();
+    }
+
+    return eden->allocate(size);
+}
+
+void *Heap::allocate_meta(size_t size) {
+    if (!metaspace->can_alloc(size)) {
+        return NULL;
+    }
+
+    return metaspace->allocate(size);
+}
+
+void Heap::copy_live_objects() {
+    // TODO
+}
+
+void Heap::gc() {
+    printf("gc starting...\n");
+    printf("  befroe gc : \n");
+    printf("  eden's capacity is %lu\n", eden->_capacity);
+    copy_live_objects();
+
+    Space *temp = eden;
+    eden = survivor;
+    survivor = temp;
+
+    printf("  after gc : \n");
+    printf("  eden's capacity is %lu\n", eden->_capacity);
+    printf("gc end\n");
+
+    survivor->clear();
+}

memory/heap.hpp

@@ -0,0 +1,69 @@
+//
+// Created by Kosho on 2020/9/13.
+//
+
+#ifndef PYTHONVM_HEAP_HPP
+#define PYTHONVM_HEAP_HPP
+
+#include <memory.h>
+
+class HiObject;
+
+/* base         top          end
+ * ↓            ↓            ↓
+ * |------------|--capacity--|
+ * |-----------size----------|
+ */
+class Space {
+    friend class Heap;
+
+private:
+    char *_base;
+    char *_top;
+    char *_end;
+    size_t _size;
+    size_t _capacity;
+
+    Space(size_t size);
+
+    ~Space();
+
+public:
+    bool can_alloc(size_t size);
+
+    bool has_obj(char *obj);
+
+    void *allocate(size_t size);
+
+    void clear();
+};
+
+class Heap {
+private:
+    Space *mem_1;
+    Space *mem_2;
+
+    Space *eden;
+    Space *survivor;
+
+    Space *metaspace;
+
+    Heap(size_t size);
+
+public:
+    static size_t MAX_CAP;
+    static Heap *instance;
+    static Heap *get_instance();
+
+    ~Heap();
+
+    void *allocate(size_t size);
+
+    void *allocate_meta(size_t size);
+
+    void copy_live_objects();
+
+    void gc();
+};
+
+#endif //PYTHONVM_HEAP_HPP

object/hiObject.cpp

@@ -9,6 +9,7 @@
 #include "object/hiString.hpp"
 #include "runtime/universe.hpp"
 #include "runtime/functionObject.hpp"
+#include "memory/heap.hpp"
 
 ObjectKlass *ObjectKlass::instance = NULL;
 
@@ -110,6 +111,10 @@ HiObject *HiObject::len() {
     return klass()->len(this);
 }
 
+void* HiObject::operator new(size_t size) {
+    return Universe::heap->allocate(size);
+}
+
 TypeKlass *TypeKlass::instance = NULL;
 
 TypeKlass *TypeKlass::get_instance() {

object/hiObject.hpp

@@ -61,6 +61,8 @@ class HiObject {
     HiDict *obj_dict() { return _obj_dict; }
     void set_obj_dict(HiDict *x) { _obj_dict = x; }
     void init_dict();
+
+    void *operator new(size_t size);
 };
 
 /**

object/hiString.cpp

@@ -5,11 +5,12 @@
 #include <string.h>
 #include <stdio.h>
 
-#include "hiString.hpp"
-#include "hiInteger.hpp"
+#include "object/hiString.hpp"
+#include "object/hiInteger.hpp"
 #include "object/hiDict.hpp"
 #include "runtime/universe.hpp"
 #include "runtime/functionObject.hpp"
+#include "memory/heap.hpp"
 
 StringKlass *StringKlass::instance = NULL;
 
@@ -58,15 +59,17 @@ HiObject *StringKlass::equal(HiObject *x, HiObject *y) {
 
 HiString::HiString(const char *x) {
     _length = strlen(x);
-    _value = new char[_length];
+    // _value = new char[_length];
+    _value = (char*)Universe::heap->allocate(_length);
     strcpy(_value, x);
 
     set_klass(StringKlass::get_instance());
 }
 
 HiString::HiString(const char *x, const int length) {
     _length = length;
-    _value = new char[length];
+    // _value = new char[length];
+    _value = (char*)Universe::heap->allocate(_length);
 
     // do not use strcpy here, since '\0' is allowed.
     for (int i = 0; i < length; ++i) {
@@ -78,7 +81,8 @@ HiString::HiString(const char *x, const int length) {
 
 HiString::HiString(const int length) {
     _length = length;
-    _value = new char[length];
+    // _value = new char[length];
+    _value = (char*)Universe::heap->allocate(_length + 1);
     set_klass(StringKlass::get_instance());
 }
 

object/klass.cpp

@@ -2,21 +2,23 @@
 // Created by Kosho on 2020/8/16.
 //
 
-#include <runtime/interpreter.hpp>
+#include "klass.hpp"
+#include "runtime/interpreter.hpp"
 #include "runtime/stringTable.hpp"
 #include "runtime/functionObject.hpp"
-#include "klass.hpp"
+#include "runtime/universe.hpp"
 #include "object/hiObject.hpp"
 #include "object/hiInteger.hpp"
 #include "object/hiString.hpp"
 #include "object/hiDict.hpp"
 #include "object/hiList.hpp"
-#include "runtime/universe.hpp"
+#include "memory/heap.hpp"
 
 #define ST(x) StringTable::get_instance()->STR(x)
 #define STR(x) x##_str
 
 Klass::Klass() {
+    Universe::klasses->add(this);
     _klass_dict = NULL;
     _name = NULL;
     _super = NULL;
@@ -237,3 +239,7 @@ void Klass::order_supers() {
     }
     printf("\n");
 }
+
+void *Klass::operator new(size_t size) {
+    return Universe::heap->allocate_meta(size);
+}

object/klass.hpp

@@ -80,6 +80,8 @@ class Klass {
     virtual HiObject *iter     (HiObject* x) { return 0; }
 
     virtual HiObject *allocate_instance(HiObject* callable, ArrayList<HiObject *> *args);
+
+    void* operator new(size_t size);
 };
 
 #endif //PYTHONVM_KLASS_HPP

runtime/universe.cpp

@@ -3,17 +3,28 @@
 //
 
 #include "runtime/universe.hpp"
+#include "runtime/interpreter.hpp"
+#include "runtime/functionObject.hpp"
+#include "object/hiInteger.hpp"
+#include "object/hiObject.hpp"
 #include "object/hiString.hpp"
-#include "object/hiDict.hpp"
 #include "object/hiList.hpp"
-#include "functionObject.hpp"
+#include "object/hiDict.hpp"
+#include "memory/heap.hpp"
 
 HiObject *Universe::HiTrue = NULL;
 HiObject *Universe::HiFalse = NULL;
 
 HiObject *Universe::HiNone = NULL;
 
+Heap *Universe::heap = NULL;
+
+ArrayList<Klass *> *Universe::klasses = NULL;
+
 void Universe::genesis() {
+    heap = Heap::get_instance();
+    klasses = new ArrayList<Klass *>();
+
     HiTrue = new HiString("True");
     HiFalse = new HiString("False");
     HiNone = new HiString("None");

runtime/universe.hpp

@@ -6,20 +6,27 @@
 #define PYTHONVM_UNIVERSE_HPP
 
 #include <stdio.h>
-#include <object/hiInteger.hpp>
 
 class Klass;
+class Heap;
 class HiInteger;
 class HiObject;
 class CodeObject;
 
+template <typename T>
+class ArrayList;
+
 class Universe {
 public:
     static HiObject *HiTrue;
     static HiObject *HiFalse;
 
     static HiObject *HiNone;
 
+    static ArrayList<Klass*>* klasses;
+
+    static Heap *heap;
+
 public:
     static void genesis();