VM (new pixeltower): 空闲块列表

Author: MetsukiMio

include/openminecraft/mem/om_mem_prealloc.hpp

@@ -15,7 +15,15 @@ class OMHeap
     void expand(void *target);
     void shrink(void *target);
 
+    uint64_t currentSizeAllocated();
+
+    bool vaild(void *p)
+    {
+        return p >= block && p < heapTop;
+    }
+
     void *block;
+    void *heapTop;
 
   private:
     log::OMLogger logger;
@@ -24,7 +32,6 @@ class OMHeap
 
     void activate(void *p, uint64_t length);
     void deactivate(void *p, uint64_t length);
-    void *heapTop;
 };
 } // namespace openminecraft::mem
 

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

@@ -0,0 +1,36 @@
+#ifndef OM_PIXELTOWER_HEAP_HPP
+#define OM_PIXELTOWER_HEAP_HPP
+
+#include "openminecraft/log/om_log_common.hpp"
+#include "openminecraft/mem/om_mem_prealloc.hpp"
+#include <cstdint>
+#include <mutex>
+#include <vector>
+namespace openminecraft::vm::pixeltower::v0
+{
+struct OMHeapEmptyBlock
+{
+    void *ptr;
+    uint64_t length;
+};
+
+class OMPixelTowerHeap
+{
+  public:
+    OMPixelTowerHeap(uint64_t minSize, uint64_t maxSize);
+    ~OMPixelTowerHeap();
+
+    void *allocate(uint64_t length);
+    void deallocate(void *ptr, uint64_t length);
+    void debug();
+    void merge();
+
+  private:
+    mem::OMHeap *heap;
+    std::mutex emptyBlockMutex;
+    std::vector<OMHeapEmptyBlock> emptyBlocks;
+    log::OMLogger logger;
+};
+} // namespace openminecraft::vm::pixeltower::v0
+
+#endif

src/boot/entrypoint.cpp

@@ -35,16 +35,13 @@
 #include "openminecraft/util/om_util_result.hpp"
 #include "openminecraft/util/om_util_version.hpp"
 #include "openminecraft/vfs/om_vfs_base.hpp"
-#include "openminecraft/vm/bytecode/om_bytecode_checker.hpp"
-#include "openminecraft/vm/bytecode/om_bytecode_descriptor.hpp"
-#include "openminecraft/vm/classfile/om_class_file.hpp"
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
 #include <SDL3/SDL.h>
 #include <boost/stacktrace.hpp>
 #include <fmt/format.h>
 
 using namespace openminecraft;
-using namespace openminecraft::vm::classfile;
-using namespace openminecraft::vm::bytecode;
+using namespace openminecraft::vm;
 using namespace openminecraft::binary::hash;
 using namespace std::chrono_literals;
 
@@ -118,8 +115,6 @@ int boot(std::vector<std::string> args)
     SDL_Quit();
 
     bool recovermode = false;
-    mem::OMHeap heap(0ul, 8ull * 1024 * 1024 * 1024);
-    heap.init();
 
     if (setjmp(recoverBuffer) == 0)
     {
@@ -151,11 +146,24 @@ int boot(std::vector<std::string> args)
                 mem::castorice::printres();
                 break;
             case "memtest"_hash: {
-                heap.expand(static_cast<uint8_t *>(heap.block) + 255);
-                auto i = static_cast<int *>(heap.block);
-                i[0] = 33550336;
-                logger->debug("heap write : {}", i[0]);
-                heap.shrink(heap.block);
+                pixeltower::v0::OMPixelTowerHeap heap(0, 1ul * 1024 * 1024 * 1024);
+                std::vector<void *> targets;
+                for (int i = 0; i < 2048; i++)
+                {
+                    targets.push_back(heap.allocate(1024));
+                }
+
+                srand(time(nullptr));
+                while (!targets.empty())
+                {
+                    auto idx = rand() % targets.size();
+                    heap.deallocate(targets[idx], 1024);
+                    targets.erase(targets.begin() + idx);
+                    if (targets.size() % 64 == 0)
+                    {
+                        heap.debug();
+                    }
+                }
 
                 commandBuffer.clear();
 

src/mem/om_mem_prealloc.cpp

@@ -1,4 +1,5 @@
 #include "openminecraft/mem/om_mem_prealloc.hpp"
+#include <new>
 
 namespace openminecraft::mem
 {
@@ -11,11 +12,16 @@ void OMHeap::init()
     }
     expand(static_cast<uint8_t *>(block) + minSize);
 }
+uint64_t OMHeap::currentSizeAllocated()
+{
+    return (size_t)heapTop - (size_t)block;
+}
 void OMHeap::expand(void *target)
 {
-    if (target < block || target <= heapTop)
+    if (target < block || target <= heapTop || ((size_t)target - (size_t)block) > maxSize)
     {
         logger.error("target is not valid!");
+        throw std::bad_alloc();
     }
 
     activate(heapTop, (size_t)target - (size_t)heapTop);
@@ -26,6 +32,7 @@ void OMHeap::shrink(void *target)
     if (target < block || target >= heapTop)
     {
         logger.error("target is not valid!");
+        throw std::bad_alloc();
     }
 
     deactivate(target, (size_t)heapTop - (size_t)target);

src/vm/pixeltower/v0/om_pixeltower_heap.cpp

@@ -0,0 +1,118 @@
+#include "openminecraft/vm/pixeltower/v0/om_pixeltower_heap.hpp"
+#include "openminecraft/mem/om_mem_prealloc.hpp"
+#include <algorithm>
+#include <mutex>
+
+namespace openminecraft::vm::pixeltower::v0
+{
+OMPixelTowerHeap::OMPixelTowerHeap(uint64_t minSize, uint64_t maxSize) : logger("OMPixelTowerHeap", this)
+{
+    heap = new mem::OMHeap(minSize, maxSize);
+    heap->init();
+    emptyBlocks.push_back({heap->block, heap->currentSizeAllocated()});
+}
+OMPixelTowerHeap::~OMPixelTowerHeap()
+{
+    delete heap;
+}
+
+void *OMPixelTowerHeap::allocate(uint64_t length)
+{
+    // force 8-byte alignment
+    if (length % 8 != 0)
+    {
+        length = length + 8 - (length % 8);
+    }
+
+alloc:
+    std::lock_guard<std::mutex> g(emptyBlockMutex);
+    for (auto it = emptyBlocks.begin(); it != emptyBlocks.end(); ++it)
+    {
+        if (it->length >= length) // available blocks found
+        {
+            void *target = it->ptr;
+            it->ptr = static_cast<uint8_t *>(it->ptr) + length;
+            it->length -= length;
+            if (it->length == 0 && emptyBlocks.size() > 1)
+            {
+                emptyBlocks.erase(it);
+            }
+            return target;
+        }
+    }
+
+    logger.debug("expands heap space from {} ...", heap->currentSizeAllocated());
+    heap->expand(static_cast<uint8_t *>(heap->heapTop) + 1ul * 1024 * 1024); // expand, 1MB larger heap
+    emptyBlocks.back().length += 1ul * 1024 * 1024;
+    logger.debug("to {}", heap->currentSizeAllocated());
+
+    goto alloc;
+}
+void OMPixelTowerHeap::debug()
+{
+    logger.info("{} bytes allocated", heap->currentSizeAllocated());
+    uint64_t t = 0;
+    for (auto p : emptyBlocks)
+    {
+        t += p.length;
+    }
+    logger.info("{} bytes free", t);
+}
+void OMPixelTowerHeap::deallocate(void *ptr, uint64_t length)
+{
+    if (!heap->vaild(ptr))
+    {
+        logger.error("{} not vaild!", ptr);
+        return;
+    }
+    for (auto it = emptyBlocks.begin(); it != emptyBlocks.end(); ++it)
+    {
+        if (it->ptr > ptr)
+        {
+            continue;
+        }
+
+        emptyBlockMutex.lock();
+        emptyBlocks.insert(it, {ptr, length});
+        emptyBlockMutex.unlock();
+        goto merge;
+    }
+
+    // first object
+    emptyBlockMutex.lock();
+    emptyBlocks.insert(emptyBlocks.begin(), {ptr, length});
+    emptyBlockMutex.unlock();
+
+merge:
+    merge();
+}
+
+void OMPixelTowerHeap::merge()
+{
+    std::lock_guard<std::mutex> g(emptyBlockMutex);
+    std::sort(emptyBlocks.begin(), emptyBlocks.end(),
+              [](const OMHeapEmptyBlock &b1, const OMHeapEmptyBlock &b2) { return b1.ptr < b2.ptr; });
+
+    auto it1 = emptyBlocks.begin();
+    auto it2 = emptyBlocks.begin();
+    ++it2;
+    while (true)
+    {
+        if (it2 == emptyBlocks.end())
+        {
+            break;
+        }
+
+        if (static_cast<uint8_t *>(it1->ptr) + it1->length == it2->ptr) // link!
+        {
+            it1->length += it2->length;
+            it2 = emptyBlocks.erase(it2);
+        }
+        else
+        {
+            ++it1;
+            ++it2;
+        }
+    }
+}
+} // namespace openminecraft::vm::pixeltower::v0