VM: 堆内存管理器

Author: MetsukiMio

include/openminecraft/vm/pixeltower/om_pixeltower_memorymanager.hpp

@@ -9,6 +9,7 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <unordered_map>
 #include <vector>
 
 namespace openminecraft::vm::pixeltower
@@ -25,15 +26,17 @@ class OMMemoryManager
     void *allocateArray(std::shared_ptr<OMClass> cls, int *lengths, int dim);
     void *allocateArray(OMArrayType type, int *lengths, int dim);
 
-    void searchFromInstance(void *b, std::vector<void *> &buf);
-    void seatchFromStatic(std::shared_ptr<OMClass> cls, std::vector<void *> &buf);
+    void searchFromInstance(void *b);
+    void searchFromStatic(std::shared_ptr<OMClass> cls);
 
     void deallocate(void *p);
+    void gc();
 
   private:
     void *fetchInternal(int size);
 
     log::OMLogger logger;
+    std::unordered_map<void *, bool> blockStatus;
     std::mutex cacheLock;
     std::shared_ptr<OMClassLoader> cld;
     std::any tower;

src/boot/entrypoint.cpp

@@ -235,8 +235,8 @@ int boot(std::vector<std::string> args)
                         pt->registerNativeFunc("vmstd/internal/SystemPrintStream", "println", "(Ljava/lang/Object;)V",
                                                [&](std::any s) {
                                                    auto argl = std::any_cast<std::list<std::any> *>(s);
-                                                   // logger->debug("[stdout] {}", std::any_cast<void
-                                                   // *>(*(++argl->begin())));
+                                                   // logger->debug("[stdout] {}",
+                                                   // std::any_cast<void*>(*(++argl->begin())));
                                                    return nullptr;
                                                });
                         pt->registerNativeFunc(

src/vm/bytecode/om_bytecode_descriptor.cpp

@@ -37,17 +37,15 @@ OMResult<std::string, std::string> decodeType(std::string raw, int *p)
     case 'Z':
         return OMResult<std::string, std::string>::ok("boolean");
     case 'L': {
-        auto ends = raw.find_first_of(';', *p - 1);
+        auto ends = raw.find_first_of(';', *p - 1) - (*p - 1);
         if (ends == std::variant_npos)
         {
             return OMResult<std::string, std::string>::err("nonstop object type!");
         }
         // inplace split
-        raw[ends] = '\0';
-        auto type = std::string(raw.substr(*p - 1, ends).c_str());
+        auto type = std::string(raw.c_str()).substr(*p - 1, ends);
         auto d = OMResult<std::string, std::string>::ok(type);
-        raw[ends] = ';';
-        *p = ends + 1;
+        *p += ends;
         return d;
     }
     case '[': {

src/vm/pixeltower/v0/om_pixeltower_memorymanager.cpp

@@ -4,9 +4,12 @@
 #include "openminecraft/vm/classfile/om_class_file.hpp"
 #include "openminecraft/vm/pixeltower/om_pixeltower_array_structdef.hpp"
 #include "openminecraft/vm/pixeltower/om_pixeltower_class_structdef.hpp"
+#include "openminecraft/vm/pixeltower/om_pixeltower_frame_structdef.hpp"
+#include "openminecraft/vm/pixeltower/om_pixeltower_interpreter.hpp"
 #include <any>
 #include <memory>
-#include <vector>
+#include <stack>
+#include <typeindex>
 
 #define HEAP_SIZE 1024 * 128
 
@@ -23,7 +26,64 @@ OMMemoryManager::~OMMemoryManager()
 
 void *OMMemoryManager::fetchInternal(int size)
 {
-    return mem::allocator::tracedCallocVMData(1, size);
+    auto p = mem::allocator::tracedMallocVMData(size);
+    memset(p, 0, size);
+    blockStatus[p] = false;
+    if (blockStatus.size() > 16384)
+    {
+        gc();
+    }
+    return p;
+}
+
+void OMMemoryManager::gc()
+{
+    logger.debug("serial gc begin");
+    auto interpr = std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(tower);
+    for (auto p : interpr->stack)
+    {
+        std::stack<std::any> stkb(p.second);
+
+        while (!stkb.empty())
+        {
+            auto i = std::type_index(stkb.top().type());
+            if (i == std::type_index(typeid(void *)))
+            {
+                searchFromInstance(std::any_cast<void *>(stkb.top()));
+            }
+            else if (i == std::type_index(typeid(std::shared_ptr<runtime::OMFrameMetadata>)))
+            {
+                auto fr = std::any_cast<std::shared_ptr<runtime::OMFrameMetadata>>(stkb.top());
+                for (auto r : fr->local)
+                {
+                    if (std::type_index(r.type()) == std::type_index(typeid(void *)))
+                    {
+                        searchFromInstance(std::any_cast<void *>(r));
+                    }
+                }
+            }
+            stkb.pop();
+        }
+    }
+
+    for (auto l : cld->classes)
+    {
+        searchFromStatic(l.second);
+    }
+
+    for (auto p = blockStatus.begin(); p != blockStatus.end();)
+    {
+        if (p->second)
+        {
+            p->second = false;
+            ++p;
+        }
+        else
+        {
+            deallocate(p->first);
+            p = blockStatus.erase(p);
+        }
+    }
 }
 
 void *OMMemoryManager::allocate(std::shared_ptr<OMClass> cls)
@@ -114,11 +174,11 @@ void *OMMemoryManager::allocateArray(OMArrayType type, int *lengths, int dim)
     return result;
 }
 
-void OMMemoryManager::searchFromInstance(void *b, std::vector<void *> &buf)
+void OMMemoryManager::searchFromInstance(void *b)
 {
     if (b != nullptr)
     {
-        buf.push_back(b);
+        blockStatus[b] = true;
     }
     auto arrh = (OMArrayHeader *)b;
     if (b == nullptr)
@@ -136,7 +196,7 @@ void OMMemoryManager::searchFromInstance(void *b, std::vector<void *> &buf)
         auto arr = ARRAY_ACCESS(b, void *);
         for (int i = 0; i < arrh->length; i++)
         {
-            searchFromInstance(arr[i], buf);
+            searchFromInstance(arr[i]);
         }
     }
     else
@@ -146,18 +206,18 @@ void OMMemoryManager::searchFromInstance(void *b, std::vector<void *> &buf)
         {
             if (fi->type == OMFieldType::BytesP && (fi->accessFlag & JVM_Acc_Static) == 0)
             {
-                searchFromInstance(*(void **)OBJECT_ACCESS(b, fi->offset), buf);
+                searchFromInstance(*(void **)OBJECT_ACCESS(b, fi->offset));
             }
         }
     }
 }
-void OMMemoryManager::seatchFromStatic(std::shared_ptr<OMClass> cls, std::vector<void *> &buf)
+void OMMemoryManager::searchFromStatic(std::shared_ptr<OMClass> cls)
 {
     for (auto fi : cls->fields)
     {
         if (fi->type == OMFieldType::BytesP && (fi->accessFlag & JVM_Acc_Static))
         {
-            searchFromInstance(*(void **)OBJECT_ACCESS(cls->staticFieldBlock, fi->offset), buf);
+            searchFromInstance(*(void **)OBJECT_ACCESS(cls->staticFieldBlock, fi->offset));
         }
     }
 }

src/vm/pixeltower/v1/om_pixeltower_debugger.cpp

@@ -136,6 +136,13 @@ std::string OMDebugger::serializeAny(std::any data, int objDepth)
             return fmt::format("{}{}", prefix, fmt::styled("null", fmt::fg(fmt::color::gray)));
         }
 
+        if (objDepth == 0)
+        {
+            objDepth++;
+            updatePref;
+            objDepth--;
+        }
+
         if (arrh->classifierPointer == &ARRAY_TYPE)
         {
             std::string type;
@@ -177,13 +184,6 @@ std::string OMDebugger::serializeAny(std::any data, int objDepth)
                 fmt::format("{}array at {} with type {}", prefix, fmt::styled(baseptr, fmt::fg(fmt::color::red)),
                             fmt::styled(type, fmt::fg(fmt::color::light_green)));
 
-            if (objDepth == 0)
-            {
-                objDepth++;
-                updatePref;
-                objDepth--;
-            }
-
             for (int i = 0; i < arrh->length; i++)
             {
                 target +=