feat(common): 为 Value、IxNodeHandle 和 RmRecord 类添加自定义内存分配器

- 在这些类中重载了 new 和 delete 操作符
- 使用 MemoryPool 实现内存池管理，以提高内存分配和释放的效率
- 注释掉了原有的 malloc 和 free 调用

Author: Lin-jingy

src/common/MemoryPool/MemoryPool.hpp

@@ -0,0 +1,235 @@
+/*-
+ * Copyright (c) 2013 Cosku Acay, http://www.coskuacay.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef MEMORY_POOL_HPP
+#define MEMORY_POOL_HPP
+
+#include <climits>
+#include <cstddef>
+
+template <typename T, size_t BlockSize = 4096>
+class MemoryPool {
+   public:
+    /* Member types */
+    typedef T value_type;
+    typedef T* pointer;
+    typedef T& reference;
+    typedef const T* const_pointer;
+    typedef const T& const_reference;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef std::false_type propagate_on_container_copy_assignment;
+    typedef std::true_type propagate_on_container_move_assignment;
+    typedef std::true_type propagate_on_container_swap;
+
+    template <typename U>
+    struct rebind {
+        typedef MemoryPool<U> other;
+    };
+
+    /* Member functions */
+    MemoryPool() noexcept;
+    MemoryPool(const MemoryPool& memoryPool) noexcept;
+    MemoryPool(MemoryPool&& memoryPool) noexcept;
+    template <class U>
+    MemoryPool(const MemoryPool<U>& memoryPool) noexcept;
+
+    ~MemoryPool() noexcept;
+
+    MemoryPool& operator=(const MemoryPool& memoryPool) = delete;
+    MemoryPool& operator=(MemoryPool&& memoryPool) noexcept;
+
+    pointer address(reference x) const noexcept;
+    const_pointer address(const_reference x) const noexcept;
+
+    // Can only allocate one object at a time. n and hint are ignored
+    pointer allocate(size_type n = 1, const_pointer hint = 0);
+    void deallocate(pointer p, size_type n = 1);
+
+    size_type max_size() const noexcept;
+
+    template <class U, class... Args>
+    void construct(U* p, Args&&... args);
+    template <class U>
+    void destroy(U* p);
+
+    template <class... Args>
+    pointer newElement(Args&&... args);
+    void deleteElement(pointer p);
+
+    static MemoryPool* getInstance() {
+        thread_local static MemoryPool instance;
+        return &instance;
+    }
+
+   private:
+    union Slot_ {
+        value_type element;
+        Slot_* next;
+    };
+
+    typedef char* data_pointer_;
+    typedef Slot_ slot_type_;
+    typedef Slot_* slot_pointer_;
+
+    slot_pointer_ currentBlock_;
+    slot_pointer_ currentSlot_;
+    slot_pointer_ lastSlot_;
+    slot_pointer_ freeSlots_;
+
+    size_type padPointer(data_pointer_ p, size_type align) const noexcept;
+    void allocateBlock();
+
+    static_assert(BlockSize >= 2 * sizeof(slot_type_), "BlockSize too small.");
+};
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::size_type MemoryPool<T, BlockSize>::padPointer(
+    data_pointer_ p, size_type align) const noexcept {
+    uintptr_t result = reinterpret_cast<uintptr_t>(p);
+    return ((align - result) % align);
+}
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::MemoryPool() noexcept {
+    currentBlock_ = nullptr;
+    currentSlot_ = nullptr;
+    lastSlot_ = nullptr;
+    freeSlots_ = nullptr;
+}
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool& memoryPool) noexcept : MemoryPool() {}
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::MemoryPool(MemoryPool&& memoryPool) noexcept {
+    currentBlock_ = memoryPool.currentBlock_;
+    memoryPool.currentBlock_ = nullptr;
+    currentSlot_ = memoryPool.currentSlot_;
+    lastSlot_ = memoryPool.lastSlot_;
+    freeSlots_ = memoryPool.freeSlots;
+}
+
+template <typename T, size_t BlockSize>
+template <class U>
+MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool<U>& memoryPool) noexcept : MemoryPool() {}
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>& MemoryPool<T, BlockSize>::operator=(MemoryPool&& memoryPool) noexcept {
+    if (this != &memoryPool) {
+        std::swap(currentBlock_, memoryPool.currentBlock_);
+        currentSlot_ = memoryPool.currentSlot_;
+        lastSlot_ = memoryPool.lastSlot_;
+        freeSlots_ = memoryPool.freeSlots;
+    }
+    return *this;
+}
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::~MemoryPool() noexcept {
+    slot_pointer_ curr = currentBlock_;
+    while (curr != nullptr) {
+        slot_pointer_ prev = curr->next;
+        operator delete(reinterpret_cast<void*>(curr));
+        curr = prev;
+    }
+}
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::pointer MemoryPool<T, BlockSize>::address(reference x) const noexcept {
+    return &x;
+}
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::const_pointer MemoryPool<T, BlockSize>::address(
+    const_reference x) const noexcept {
+    return &x;
+}
+
+template <typename T, size_t BlockSize>
+void MemoryPool<T, BlockSize>::allocateBlock() {
+    // Allocate space for the new block and store a pointer to the previous one
+    data_pointer_ newBlock = reinterpret_cast<data_pointer_>(operator new(BlockSize));
+    reinterpret_cast<slot_pointer_>(newBlock)->next = currentBlock_;
+    currentBlock_ = reinterpret_cast<slot_pointer_>(newBlock);
+    // Pad block body to staisfy the alignment requirements for elements
+    data_pointer_ body = newBlock + sizeof(slot_pointer_);
+    size_type bodyPadding = padPointer(body, alignof(slot_type_));
+    currentSlot_ = reinterpret_cast<slot_pointer_>(body + bodyPadding);
+    lastSlot_ = reinterpret_cast<slot_pointer_>(newBlock + BlockSize - sizeof(slot_type_) + 1);
+}
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::pointer MemoryPool<T, BlockSize>::allocate(size_type n, const_pointer hint) {
+    if (freeSlots_ != nullptr) {
+        pointer result = reinterpret_cast<pointer>(freeSlots_);
+        freeSlots_ = freeSlots_->next;
+        return result;
+    } else {
+        if (currentSlot_ >= lastSlot_) allocateBlock();
+        return reinterpret_cast<pointer>(currentSlot_++);
+    }
+}
+
+template <typename T, size_t BlockSize>
+inline void MemoryPool<T, BlockSize>::deallocate(pointer p, size_type n) {
+    if (p != nullptr) {
+        reinterpret_cast<slot_pointer_>(p)->next = freeSlots_;
+        freeSlots_ = reinterpret_cast<slot_pointer_>(p);
+    }
+}
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::size_type MemoryPool<T, BlockSize>::max_size() const noexcept {
+    size_type maxBlocks = -1 / BlockSize;
+    return (BlockSize - sizeof(data_pointer_)) / sizeof(slot_type_) * maxBlocks;
+}
+
+template <typename T, size_t BlockSize>
+template <class U, class... Args>
+inline void MemoryPool<T, BlockSize>::construct(U* p, Args&&... args) {
+    new (p) U(std::forward<Args>(args)...);
+}
+
+template <typename T, size_t BlockSize>
+template <class U>
+inline void MemoryPool<T, BlockSize>::destroy(U* p) {
+    p->~U();
+}
+
+template <typename T, size_t BlockSize>
+template <class... Args>
+inline typename MemoryPool<T, BlockSize>::pointer MemoryPool<T, BlockSize>::newElement(Args&&... args) {
+    pointer result = allocate();
+    construct<value_type>(result, std::forward<Args>(args)...);
+    return result;
+}
+
+template <typename T, size_t BlockSize>
+inline void MemoryPool<T, BlockSize>::deleteElement(pointer p) {
+    if (p != nullptr) {
+        p->~value_type();
+        deallocate(p);
+    }
+}
+
+#endif  // MEMORY_POOL_HPP

src/common/common.h

@@ -348,6 +348,16 @@ struct Value {
                 return false;
         }
     }
+
+    void* operator new (size_t size) {
+        return static_cast<void *>(MemoryPool<Value>::getInstance()->allocate(size));
+        // return ::std::malloc(size);
+    }
+
+    void operator delete (void *ptr) {
+        MemoryPool<Value>::getInstance()->deallocate(static_cast<Value *>(ptr));
+        // ::std::free(ptr);
+    }
 };
 
 // 前向声明 ArithExpr

src/index/ix_index_handle.h

@@ -293,6 +293,16 @@ class IxNodeHandle {
         }
         return key_value;
     }
+
+    void* operator new (size_t size) {
+        return static_cast<void *>(MemoryPool<IxNodeHandle>::getInstance()->allocate(size));
+        // return ::std::malloc(size);
+    }
+
+    void operator delete (void *ptr) {
+        MemoryPool<IxNodeHandle>::getInstance()->deallocate(static_cast<IxNodeHandle *>(ptr));
+        // ::std::free(ptr);
+    }
 };
 
 /**

src/record/rm_defs.h

@@ -29,6 +29,8 @@
 
 #include "defs.h"
 #include "storage/buffer_pool_manager.h"
+#include "common/MemoryPool/MemoryPool.hpp"
+#include "common/getFunctionTime.h"
 
 /** @brief 表示无效的页面号 */
 constexpr int RM_NO_PAGE = -1;
@@ -248,4 +250,14 @@ struct RmRecord {
         allocated_ = false;
         data = nullptr;
     }
+
+    void* operator new (size_t size) {
+        return static_cast<void *>(MemoryPool<RmRecord>::getInstance()->allocate(size));
+        // return ::std::malloc(size);
+    }
+
+    void operator delete (void *ptr) {
+        MemoryPool<RmRecord>::getInstance()->deallocate(static_cast<RmRecord *>(ptr));
+        // ::std::free(ptr);
+    }
 };