无分支内存管理器？答案

【问题标题】：Branchless memory manager?无分支内存管理器？
【发布时间】：2011-01-30 06:52:24
【问题描述】：

有人想过如何编写一个完全无分支的内存管理器（在 C++ 中）吗？我已经编写了一个池、一个堆栈、一个队列和一个链表（从池中分配），但我想知道编写一个无分支的通用内存管理器有多合理。

这一切都是为了帮助创建一个真正可重用的框架，以进行可靠的并发、按顺序 CPU 和缓存友好的开发。

编辑：无分支是指不进行直接或间接函数调用，也不使用 ifs。我一直在想，我可能可以实现一些东西，首先将请求的大小更改为零以进行错误调用，但实际上并没有更多。我觉得这不是不可能的，但是这个练习的另一个方面是在所说的“不友好”处理器上对其进行分析，看看是否值得像这样努力避免分支。

【问题讨论】：

“分支”是什么意思？
@Neil，我想，这是拆分控制流的东西（例如if 运算符）。
如果分支表示if，那么答案是否定的。 @OP：您能否澄清一下这是否确实是您的意思？
这将是一个越界的答案，所以我仅将其添加为评论。您可能需要考虑使用尽可能少的分支实现并添加依赖于编译器/平台的代码来帮助分支预测器。
无分支 C++ 代码不一定会转换为无分支程序集。此外，分支 C++ 代码不一定转换为分支程序集。所以如果目标是对几乎不能处理分支的 CPU 非常友好，那么无分支 C++ 可能不是正确的工具。

标签： c++ concurrency containers data-oriented-design

【解决方案1】：

虽然我认为这不是一个好主意，但一种解决方案是预先分配各种日志₂ 大小的存储桶，愚蠢的伪代码：

class Allocator {

    void* malloc(size_t size) {
        int bucket = log2(size + sizeof(int));
        int* pointer = reinterpret_cast<int*>(m_buckets[bucket].back());
        m_buckets[bucket].pop_back();
        *pointer = bucket; //Store which bucket this was allocated from
        return pointer + 1; //Dont overwrite header
    }

    void free(void* pointer) {
        int* temp = reinterpret_cast<int*>(pointer) - 1;
        m_buckets[*temp].push_back(temp);
    }

    vector< vector<void*> > m_buckets;
};

（您当然也可以用简单的数组 + 计数器替换 std::vector）。

编辑：为了使其更健壮（即处理桶为空的情况），您必须添加某种形式的分支。

EDIT2：这是一个小的无分支log2 函数：

//returns the smallest x such that value <= (1 << x)
int
log2(int value) {
    union Foo {
        int x;
        float y;
    } foo;
    foo.y = value - 1;
    return ((foo.x & (0xFF << 23)) >> 23) - 126; //Extract exponent (base 2) of floating point number
}

这给出了分配

这里有一个link 说明浮点数在内存中的表示方式。

【讨论】：

Log2 可能需要依赖于平台的实现才能实现无分支。在 x86 上，您可能需要对参数执行 BSR 指令。
@Jasper：这里有一些代码声称是无分支 clz - 我假设没有测试它可以工作：stackoverflow.com/questions/2255177/…。从简短的浏览来看，对于输入 0，它似乎返回 0，因此您可能希望分支覆盖 0 情况或大于范围的一半情况。不过，正如您所说，实现可能会提供对更快 CPU 操作的访问。
我猜。在某些平台上，通过 float 可能是最好的 log2，但它只是伪可移植的，所以它不能是最普遍的后备。
“如果您需要更大的分配，您将不得不切换到双打”。假设您首先要从二次方存储桶中分配更大的块。希望“无分支”的意思是“不常见的情况除外”。
log2 方法让我大吃一惊，我不确定我是否能恢复那些脑细胞......

【解决方案2】：

我知道创建真正无分支分配器的唯一方法是提前保留它可能使用的所有内存。否则总会有一些隐藏的代码在某处查看我们是否超过了当前容量，无论它是在一个隐藏的push_back 向量中，检查大小是否超过了用于实现它的容量或类似的东西。

这是一个固定分配的粗略示例，它具有完全无分支的malloc 和free 方法。

class FixedAlloc
{
public:
    FixedAlloc(int element_size, int num_reserve)
    {
        element_size = max(element_size, sizeof(Chunk));
        mem = new char[num_reserve * element_size];

        char* ptr = mem;
        free_chunk = reinterpret_cast<Chunk*>(ptr);
        free_chunk->next = 0;

        Chunk* last_chunk = free_chunk;
        for (int j=1; j < num_reserve; ++j)
        {
            ptr += element_size;
            Chunk* chunk = reinterpret_cast<Chunk*>(ptr);
            chunk->next = 0;
            last_chunk->next = chunk;
            last_chunk = chunk;
        }
    }

    ~FixedAlloc()
    {
        delete[] mem;
    }

    void* malloc()
    {
        assert(free_chunk && free_chunk->next && "Reserve memory exhausted!");
        Chunk* chunk = free_chunk;
        free_chunk = free_chunk->next;
        return chunk->mem;
    }

    void free(void* mem)
    {
        Chunk* chunk = static_cast<Chunk*>(mem);
        chunk->next = free_chunk;
        free_chunk = chunk;
    }

private:
    union Chunk
    {
        Chunk* next;
        char mem[1];
    };
    char* mem;
    Chunk* free_chunk;
};

由于它是完全无分支的，如果您尝试分配比最初保留更多的内存，它只会出现段错误。它还具有未定义的尝试释放空指针的行为。为了一个更简单的例子，我也避免处理对齐。

【讨论】：