2

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

这个想法是这样的：

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;
}

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

4

1 回答 1

1

我认为对 s 进行数组分配效率更高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.

于 2012-07-07T04:06:19.533 回答