VM: 堆内存管理器

Author: MetsukiMio

include/openminecraft/vm/pixeltower/om_pixeltower_memorymanager.hpp

@@ -7,6 +7,7 @@
 #include "openminecraft/vm/pixeltower/om_pixeltower_classloader.hpp"
 #include <memory>
 #include <mutex>
+#include <unordered_map>
 #include <vector>
 
 namespace openminecraft::vm::pixeltower
@@ -16,7 +17,7 @@ namespace openminecraft::vm::pixeltower
 class OMMemoryManager
 {
   public:
-    OMMemoryManager(std::shared_ptr<OMClassLoader> cld);
+    OMMemoryManager(std::any tower, std::shared_ptr<OMClassLoader> cld);
     ~OMMemoryManager();
 
     void *allocate(std::shared_ptr<OMClass> cls);
@@ -26,13 +27,21 @@ class OMMemoryManager
     void searchFromInstance(void *b, std::vector<void *> &buf);
     void seatchFromStatic(std::shared_ptr<OMClass> cls, std::vector<void *> &buf);
 
-    void deallocate(std::vector<void *> &p);
+    void deallocate(void *p);
+
+    void debug();
+    void compatBlocks();
 
   private:
+    void registerBlock(void *b);
+    void *fetchInternal(int size);
+
     log::OMLogger logger;
-    std::vector<void *> blockCache;
+    void *buffer;
+    std::unordered_map<void *, bool> blockStatus;
     std::mutex cacheLock;
     std::shared_ptr<OMClassLoader> cld;
+    std::any tower;
 };
 } // namespace openminecraft::vm::pixeltower
 

src/boot/entrypoint.cpp

@@ -14,6 +14,7 @@
 #include <memory>
 #include <stack>
 #include <stdexcept>
+#include <string>
 #include <thread>
 #include <typeindex>
 #include <variant>
@@ -128,54 +129,6 @@ int boot(std::vector<std::string> args)
     std::shared_ptr<OMClassFileParser> parser;
     bool recovermode = false;
 
-    std::thread t([&]() {
-        while (true)
-        {
-            mem::castorice::printres();
-            std::this_thread::sleep_for(std::chrono::milliseconds(500));
-
-            std::vector<void *> buf;
-
-            for (auto cls : pt->classloader->classes)
-            {
-                pt->mm->seatchFromStatic(cls.second, buf);
-            }
-
-            auto i = std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(pt->interpreter);
-
-            for (auto stks : i->stack)
-            {
-                std::stack<std::any> stk(stks.second);
-
-                while (!stk.empty())
-                {
-                    if (std::type_index(stk.top().type()) == std::type_index(typeid(void *)))
-                    {
-                        pt->mm->searchFromInstance(std::any_cast<void *>(stk.top()), buf);
-                    }
-                    else if (std::type_index(stk.top().type()) ==
-                             std::type_index(typeid(std::shared_ptr<runtime::OMFrameMetadata>)))
-                    {
-                        auto frame = std::any_cast<std::shared_ptr<runtime::OMFrameMetadata>>(stk.top());
-                        for (auto fr : frame->local)
-                        {
-                            if (std::type_index(fr.type()) == std::type_index(typeid(void *)))
-                            {
-                                pt->mm->searchFromInstance(std::any_cast<void *>(fr), buf);
-                            }
-                        }
-                    }
-
-                    stk.pop();
-                }
-            }
-
-            std::sort(buf.begin(), buf.end());
-            buf.erase(std::unique(buf.begin(), buf.end()), buf.end());
-            pt->mm->deallocate(buf);
-        }
-    });
-
     if (setjmp(recoverBuffer) == 0)
     {
     program:
@@ -210,7 +163,6 @@ int boot(std::vector<std::string> args)
                 {
                     if (commandBuffer[1] == "loadcls")
                     {
-
                         try
                         {
                             pt->loadClass(std::make_shared<std::ifstream>(commandBuffer[2], std::ios::binary));
@@ -238,6 +190,28 @@ int boot(std::vector<std::string> args)
 
                         commandBuffer.clear();
                     }
+                    else if (commandBuffer[1] == "memtest")
+                    {
+                        std::vector<void *> pp;
+                        try
+                        {
+                            while (true)
+                            {
+                                pp.push_back(pt->mm->allocate(pt->fetchClass("java/lang/String")));
+                            }
+                        }
+                        catch (std::logic_error e)
+                        {
+                            pt->mm->debug();
+                        }
+
+                        pt->mm->deallocate(pp[0]);
+                        pt->mm->deallocate(pp[2]);
+                        pt->mm->deallocate(pp[1]);
+                        pt->mm->debug();
+
+                        commandBuffer.clear();
+                    }
                     else if (commandBuffer[1] == "init")
                     {
                         std::vector<std::string> m;

src/vm/pixeltower/v0/om_pixeltower.cpp

@@ -26,7 +26,7 @@ OMPixelTower::OMPixelTower() : logger("OMPixelTower", this)
 {
     interpreter = std::make_shared<runtime::OMInterpreter>(*this);
     classloader = std::make_shared<OMClassLoader>(interpreter);
-    mm = std::make_shared<OMMemoryManager>(classloader);
+    mm = std::make_shared<OMMemoryManager>(interpreter, classloader);
 }
 OMPixelTower::~OMPixelTower()
 {