JAISeq

include/JSystem/JAudio2/JASHeapCtrl.h

@@ -1,14 +1,125 @@
 #ifndef JASHEAPCTRL_H
 #define JASHEAPCTRL_H
 
-#include "dolphin/types.h"
+#include "JSystem/JSupport/JSUList.h"
+#include "dolphin/os/OSInterrupt.h"
+#include "dolphin/os/OSMutex.h"
+
+class JASDisposer;
+
+class JASHeap {
+    /* 80290140 */ JASHeap(JASDisposer*);
+    /* 802901AC */ void initRootHeap(void*, u32);
+    /* 8029021C */ void alloc(JASHeap*, u32);
+    /* 802903F4 */ void allocTail(JASHeap*, u32);
+    /* 802904E4 */ void free();
+    /* 80290608 */ void insertChild(JASHeap*, JASHeap*, void*, u32, bool);
+    /* 802906F0 */ void getTailHeap();
+    /* 8029077C */ void getTailOffset();
+    /* 802907E0 */ void getCurOffset();
+    /* 80290B54 */ ~JASHeap();
+
+    /* 0x00 */ JSUTree<JASHeap> mTree;
+    /* 0x1C */ OSMutex mMutex;
+    /* 0x34 */ JASDisposer* mDisposer;
+    /* 0x38 */ int field_0x38;
+    /* 0x3c */ int field_0x3c;
+    /* 0x40 */ void* field_0x40;
+};
 
 struct JASGenericMemPool {
     /* 80290848 */ JASGenericMemPool();
     /* 80290860 */ ~JASGenericMemPool();
     /* 802908C8 */ void newMemPool(u32, int);
-    /* 80290948 */ void alloc(u32);
+    /* 80290948 */ void* alloc(u32);
     /* 80290994 */ void free(void*, u32);
+
+    /* 0x00 */ void* field_0x0;
+    /* 0x04 */ int freeMemCount;
+    /* 0x08 */ int totalMemCount;
+    /* 0x0C */ int field_0xc;
+
+};
+
+namespace JASThreadingModel {
+    template <typename A0>
+    struct InterruptsDisable {
+        struct Lock {
+            Lock(const A0& param_0) { field_0x0 = OSDisableInterrupts(); }
+            ~Lock() { OSRestoreInterrupts(field_0x0); }
+
+            BOOL field_0x0;
+        };
+    };
+};
+
+template <typename T>
+class JASMemPool : public JASGenericMemPool {
+public:
+    void newMemPool(int param_0) { JASGenericMemPool::newMemPool(sizeof(T), param_0); }
+    void* alloc(u32 n) { return JASGenericMemPool::alloc(n); }
+    void free(void* ptr, u32 n) { JASGenericMemPool::free(ptr, n); }
+};
+
+template <typename T>
+class JASPoolAllocObject : public T {
+public:
+    static void* operator new(size_t n) {
+        JASMemPool<T>* memPool = getMemPool();
+        return memPool->alloc(n);
+    }
+    static void operator delete(void* ptr, size_t n) {
+        JASMemPool<T>* memPool_ = getMemPool();
+        memPool_->free(ptr, n);
+    }
+    static void newMemPool(int param_0) {
+        JASMemPool<T>* memPool_ = getMemPool();
+        memPool_->newMemPool(param_0);
+    }
+
+private:
+    static JASMemPool<T>* getMemPool() {
+        static JASMemPool<T> memPool_;
+        return &memPool_;
+    }
+};
+
+template <typename T>
+class JASMemPool_MultiThreaded : public JASGenericMemPool {
+public:
+    void newMemPool(int param_0) {
+        JASThreadingModel::InterruptsDisable<JASMemPool_MultiThreaded<T> >::Lock lock(*this);
+        JASGenericMemPool::newMemPool(sizeof(T), param_0);
+    }
+
+    void* alloc(size_t count) {
+        JASThreadingModel::InterruptsDisable<JASMemPool_MultiThreaded<T> >::Lock lock(*this);
+        return JASGenericMemPool::alloc(count);
+    }
+
+    void free(void* ptr, u32 param_1) {
+        JASThreadingModel::InterruptsDisable<JASMemPool_MultiThreaded<T> >::Lock lock(*this);
+        JASGenericMemPool::free(ptr, param_1);
+    }
+};
+
+template <typename T>
+class JASPoolAllocObject_MultiThreaded : public T {
+public:
+    static void* operator new(size_t n) {
+        JASMemPool_MultiThreaded<T>* memPool_ = getMemPool();
+        return memPool_->alloc(n);
+    }
+    static void operator delete(void* ptr, size_t n) {
+        JASMemPool_MultiThreaded<T>* memPool_ = getMemPool();
+        memPool_->free(ptr, n);
+    }
+
+private:
+    static JASMemPool_MultiThreaded<T>* getMemPool() {
+        static JASMemPool_MultiThreaded<T> memPool_;
+        return &memPool_;
+    }
 };
 
 #endif /* JASHEAPCTRL_H */