VM (new pixeltower): 线程本地存储 (混合栈 stage 1)

Author: MetsukiMio

include/openminecraft/vm/pixeltower/v0/om_pixeltower.hpp

@@ -17,11 +17,14 @@ class OMPixelTower
     void init(std::string basePath);
     void load(std::string path);
     void init(std::vector<std::shared_ptr<std::istream>> &streams);
-    void testAppendMethod();
+    void stackTest(OMMethod *method);
     OMKlassLoader *loader;
     OMPixelTowerHeap *heap;
     OMPixelTowerHeap *metaspace;
 
+    void initCurrentThread(uint64_t tlsSize);
+    void destroyCurrentThread();
+
   private:
     log::OMLogger logger;
 };

include/openminecraft/vm/pixeltower/v0/om_pixeltower_frame.hpp

@@ -0,0 +1,16 @@
+#ifndef OM_PIXELTOWER_FRAME_HPP
+#define OM_PIXELTOWER_FRAME_HPP
+
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp"
+namespace openminecraft::vm::pixeltower::v0
+{
+struct OMFrame
+{
+    OMMethod *method;
+    void *stackPointer;
+    void *returnAddr;
+    jint locals[0];
+};
+} // namespace openminecraft::vm::pixeltower::v0
+
+#endif

include/openminecraft/vm/pixeltower/v0/om_pixeltower_klass.hpp

@@ -37,10 +37,12 @@ class OMKlass
 
     OMPixelTowerHeap *heap;
 
-    void *allocateInstance()
+    OMOOPDesc *allocateInstance()
     {
         assert(kind == OMKlassKind::Normal);
-        return heap->allocate(sizeof(OMOOPDesc) + length);
+        auto obj = (OMOOPDesc *)heap->allocate(sizeof(OMOOPDesc) + length);
+        obj->klass = this;
+        return obj;
     }
 };
 } // namespace openminecraft::vm::pixeltower::v0

include/openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp

@@ -16,7 +16,7 @@ struct OMMethod
     jint maxLocals;
     jint maxStack;
     jint codeSize;
-    uint8_t code[0];
+    jbyte code[0];
     // code space
 };
 } // namespace openminecraft::vm::pixeltower::v0

include/openminecraft/vm/pixeltower/v0/om_pixeltower_threads.hpp

@@ -0,0 +1,25 @@
+#ifndef OM_PIXELTOWER_THREADS_HPP
+#define OM_PIXELTOWER_THREADS_HPP
+
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_frame.hpp"
+#include <string>
+#include <thread>
+namespace openminecraft::vm::pixeltower::v0
+{
+class OMPixelTowerThread
+{
+  public:
+    OMPixelTowerThread() = default;
+    ~OMPixelTowerThread() = default;
+
+    std::thread::id id;
+    std::string name;
+    jbyte *pc;
+    OMFrame *currentFrame;
+    void *stack;
+};
+
+extern thread_local OMPixelTowerThread currentThread;
+} // namespace openminecraft::vm::pixeltower::v0
+
+#endif

src/boot/entrypoint.cpp

@@ -8,6 +8,7 @@
 #include <chrono>
 #include <csetjmp>
 #include <cstdlib>
+#include <cstring>
 #include <ctime>
 #include <filesystem>
 #include <fstream>
@@ -154,11 +155,22 @@ int boot(std::vector<std::string> args)
             case "pixeltower"_hash: {
                 if (commandBuffer.size() >= 3 && commandBuffer[1] == "init")
                 {
+                    tower->initCurrentThread(1ul * 1024 * 1024);
                     tower->init(commandBuffer[2]);
                     tower->load("../Test.class");
                     tower->loader->loadClass("openminecraft/Test");
                     auto cls = tower->loader->fetchClass("openminecraft/Test");
-                    logger->info("{}", (void *)cls);
+                    auto met = cls->methods;
+                    while (met != nullptr)
+                    {
+                        if (strcmp(met->name, "main") == 0 && strcmp(met->desc, "([Ljava/lang/String;)V") == 0)
+                        {
+                            tower->stackTest(met);
+                            break;
+                        }
+                        met = met->next;
+                    }
+                    tower->destroyCurrentThread();
                     commandBuffer.clear();
 
                     break;

src/vm/pixeltower/v0/om_pixeltower.cpp

@@ -1,9 +1,13 @@
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower.hpp"
 #include "openminecraft/log/om_log_common.hpp"
+#include "openminecraft/mem/om_mem_allocator.hpp"
 #include "openminecraft/util/om_util_result.hpp"
 #include "openminecraft/vm/classfile/om_class_file.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_base.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_frame.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
 #include "openminecraft/vm/pixeltower/v0/om_pixeltower_method.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_threads.hpp"
 #include <filesystem>
 #include <fstream>
 #include <memory>
@@ -23,41 +27,16 @@ OMPixelTower::~OMPixelTower()
     delete metaspace;
 }
 
-void OMPixelTower::testAppendMethod()
+void OMPixelTower::stackTest(OMMethod *method)
 {
-    auto alloc = (OMMethod *)metaspace->allocate(sizeof(OMMethod) + 128);
-    loader->loadClass("java/lang/Object");
-    alloc->klass = loader->fetchClass("java/lang/Object");
-    alloc->name = "equals";
-    alloc->desc = "(Ljava/lang/Object;)Z";
-    alloc->accessFlags = JVM_Acc_Public;
-    alloc->codeSize = 128;
-    alloc->lineNumberTable = nullptr;
+    auto frame = (OMFrame *)(currentThread.currentFrame == nullptr ? currentThread.stack
+                                                                   : currentThread.currentFrame->stackPointer);
+    frame->stackPointer = (jbyte *)currentThread.stack + sizeof(OMFrame);
+    frame->returnAddr = (void *)33550336;
+    frame->method = method;
 
-    for (auto i = 0; i < 128; i++)
-    {
-        alloc->code[i] = 0xcc;
-    }
-    logger.debug("function inserted at {}", (void *)alloc);
-
-    if (alloc == metaspace->heapBase())
-    {
-        return;
-    }
-
-    auto currentMet = (OMMethod *)metaspace->heapBase();
-    while (true)
-    {
-        if (currentMet->next == nullptr)
-        {
-            currentMet->next = alloc;
-            break;
-        }
-        else
-        {
-            currentMet = currentMet->next;
-        }
-    }
+    currentThread.currentFrame = frame;
+    currentThread.pc = method->code;
 }
 
 void OMPixelTower::init(std::string basePath)
@@ -97,4 +76,22 @@ void OMPixelTower::init(std::vector<std::shared_ptr<std::istream>> &streams)
         loader->stagClass(target.unwrap());
     }
 }
+
+void OMPixelTower::initCurrentThread(uint64_t tlsSize)
+{
+    if (currentThread.stack)
+    {
+        return;
+    }
+
+    currentThread.stack = mem::allocator::tracedCallocVMData(1, tlsSize);
+}
+
+void OMPixelTower::destroyCurrentThread()
+{
+    if (currentThread.stack)
+    {
+        mem::allocator::tracedFreeVMData(currentThread.stack);
+    }
+}
 } // namespace openminecraft::vm::pixeltower::v0

src/vm/pixeltower/v0/om_pixeltower_threads.cpp

@@ -0,0 +1,6 @@
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_threads.hpp"
+
+namespace openminecraft::vm::pixeltower::v0
+{
+thread_local OMPixelTowerThread currentThread;
+}