Question

我想创建自己的游戏引擎，所以我买了几本书，其中一部是 Jason Gregory 的 Game Engine Architecture Second Edition ，他建议实施一些自定义分配器。本书谈到的一种分配器是基于堆栈的分配器，但是我在阅读它时感到困惑。您如何在其中存储数据？您使用什么数据类型？例如，您是否使用void*，void**，char[]的数组？该书说，您打算在开始时使用malloc分配一个大内存块，并在最后释放它，然后通过增加指针来“分配”内存。如果您可以帮助解释更多信息，那将是很好的选择，因为我似乎找不到没有使用std :: allocator的教程。我还认为这可能会对其他对自定义分配器感兴趣的人有所帮助，所以我在此处发布了问题。

这是他们在书中提供的头文件示例：

class StackAllocator
{
 public:
    // Represents the current top of the stack.
    // You can only roll back to the marker not to arbitrary locations within the stack
    typedef U32 Marker;

    explicit StackAllocator(U32 stackSize_bytes);

    void* alloc(U32 size_bytes); // Allocates a new block of the given size from stack top
    Marker getMarker(); // Returns a Marker to the current stack top
    void freeToMarker(Marker marker); // Rolls the stack back to a previous marker
    void clear(); // Clears the entire stack(rolls the stack back to zero)

private:
    // ...
}

编辑： 一段时间后，我开始工作了，但我不知道我做对了吗

头文件

typedef std::uint32_t U32;

struct Marker {
    size_t currentSize;
};

class StackAllocator
{
private:
    void* m_buffer; // Buffer of memory
    size_t m_currSize = 0;
    size_t m_maxSize;

public:
    void init(size_t stackSize_bytes); // allocates size of memory
    void shutDown();

    void* allocUnaligned(U32 size_bytes);

    Marker getMarker();
    void freeToMarker(Marker marker);

    void clear();
};

.cpp文件

void StackAllocator::init(size_t stackSize_bytes) {
    this->m_buffer = malloc(stackSize_bytes);
    this->m_maxSize = stackSize_bytes;
}

void StackAllocator::shutDown() {
    this->clear();

    free(m_buffer);
    m_buffer = nullptr;
}

void* StackAllocator::allocUnaligned(U32 size_bytes) {
    assert(m_maxSize - m_currSize >= size_bytes);

    m_buffer = static_cast<char*>(m_buffer) + size_bytes;
    m_currSize += size_bytes;
    return m_buffer;
}

Marker StackAllocator::getMarker() {
    Marker marker;
    marker.currentSize = m_currSize;
    return marker;
}

void StackAllocator::freeToMarker(Marker marker) {
    U32 difference = m_currSize - marker.currentSize;
    m_currSize -= difference;
    m_buffer = static_cast<char*>(m_buffer) - difference;
}

void StackAllocator::clear() {
    m_buffer = static_cast<char*>(m_buffer) - m_currSize;
}

Answer 1

为简单起见，可以说您正在跟踪引擎的MyFunClass集合。它可以是任何东西，并且您的线性分配器不一定必须跟踪同质类型的对象，但这通常是这样做的。通常，在使用自定义分配器时，您试图“调整”内存分配以将静态数据与动态的，不经常访问的与经常访问的对象分开，以期优化您的工作集并实现引用的局部性。

给出您提供的代码，首先，您将分配内存池。为简单起见，假设您需要足够的空间来存储1000个类型为MyFunClass的对象。

StackAllocator sa;
sa.Init( 1000 * sizeof(MyFunClass) );

然后，每次需要为FunClass“分配”新的内存块时，都可以这样进行：

void* mem = sa.allocUnaligned( sizeof(MyFunClass) );

当然，这实际上并没有分配任何东西。所有分配已在步骤1中进行。它只是将您已分配的部分内存标记为正在使用。

它也不构造MyFunClass。您的分配器不是强类型的，因此它返回的内存可以根据您的需要进行解释：作为C ++类对象的后备表示形式；等

现在，您将如何使用以这种方式分配的缓冲区？一种常见的方式是使用新的展示位置：

auto myObj = new (mem) MyFunClass();

因此，现在您正在通过调用allocUnaligned在保留的内存空间中构造C ++对象。

（请注意，allocUnaligned位使您了解了为什么我们通常不编写自己的自定义分配器：因为它们很难正确使用！我们甚至都没有提到对齐问题）

要获得额外的荣誉，请查看scope stacks，它将线性分配器方法提高到一个新水平。

自定义基于堆栈的分配器的缓冲区要使用哪种数据类型？

1 个答案: