Question

我有几个不同的对象分配某些对象来相互通信，我决定给每个对象一个本地管理的内存池，只需在其中设置一个标志就可以将节点标记为空闲。

这个想法是这样的：

struct cat {/**couple data fields*/};

struct rat
{
    rat() : poolIndex_(0), poolSize_(INITIAL_SIZE), pool_(new cat *[poolSize_])
        {
            for (size_t i = 0; i < poolSize_; ++i)
                pool_[i] = new cat;
        }

    size_t poolIndex_;
    size_t poolSize_;
    cat** pool_;
};

我为rat及其朋友提供非成员函数，以便在用完节cat个节点时调整其池的大小（通过poolIndex_++ % poolSize_;发出节点）。非成员函数如下：

void quadruplePool(cat*** pool, size_t& poolIndex, size_t& poolSize)
{
    poolIndex = poolSize;
    cat** tmp = new cat *[poolSize*4];
    for (size_t i = 0; i < poolSize; ++i)
        tmp[i] = (*pool)[i];
    delete[] (*pool);
    (*pool) = tmp;
    poolSize = poolSize*4;
    for (size_t i = poolIndex; i < poolSize; ++i)
        (*pool)[i] = new cat;
}

代码中有什么东西可以让我从现在的速度加速吗？（速度对我来说至关重要）

Answer 1

我认为进行cat的数组分配效率要高得多，当它们被释放时，将它们放在一个空闲列表中。

struct CatPool {
    size_t poolSize_;
    size_t i_;
    cat *pool_;
    cat *free_;
    typedef std::unique_ptr<cat[]> PoolPtr;
    std::list<PoolPtr> cleanup_;

    CatPool (size_t pool_size) : poolSize_(pool_size), free_(0) { grow(); }

    void grow () {
        i_ = 0;
        pool_ = new cat[poolSize_];
        cleanup_.push_back(PoolPtr(pool_));
    }

    cat * get () {
        cat *c = free_;
        if (c) {
            free_ = free_->next_;
            return c;
        }
        for (;;) {
            if (i_ < poolSize_) return &pool_[i_++];
            grow();
        }
    }

    void put (cat *c) {
        c->next_ = free_;
        free_ = c;
    }
};

但是，您应该考虑使用现有的池分配器实现。例如，Boost的object_pool。

有没有更快的方法或优化我可以应用到我的临时内存池？

1 个答案: