LimitedPool.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_LIMITEDPOOL_HXX_
#define _UTILS_LIMITEDPOOL_HXX_
 
#include "utils/Buffer.hxx"
 
class LimitedPool : public Pool, private Atomic
{
public:
    LimitedPool(
        unsigned entry_size, unsigned entry_count, Pool *base_pool = nullptr)
        : itemSize_(entry_size)
        , freeCount_(entry_count)
        , basePool_(base_pool)
    {
    }
 
    size_t free_items() override
    {
        return freeCount_;
    }
 
    size_t free_items(size_t size) override
    {
        return size == itemSize_ ? freeCount_ : 0;
    }
 
protected:
    BufferBase *alloc_untyped(size_t size, Executable *flow) override
    {
        HASSERT(size == itemSize_);
        if (!flow)
        {
            DIE("LimitedPool only supports async allocation.");
        }
        BufferBase *b = nullptr;
        {
            AtomicHolder h(this);
            if (freeCount_ > 0)
            {
                --freeCount_;
                b = base_pool()->alloc_untyped(size, nullptr);
                HASSERT(b);
                b->pool_ = this;
            }
        }
        if (b)
        {
            flow->alloc_result(b);
            return b;
        }
        else
        {
            waitingQueue_.insert(flow);
            return nullptr;
        }
    }
 
    void free(BufferBase *item) override
    {
        HASSERT(item->size() == itemSize_);
        Executable *waiting = NULL;
        {
            AtomicHolder h(this);
            waiting = static_cast<Executable *>(waitingQueue_.next().item);
            if (!waiting)
            {
                ++freeCount_;
            }
        }
        if (waiting)
        {
            waiting->alloc_result(item);
        }
        else
        {
            base_pool()->free(item);
        }
    }
 
private:
    Pool *base_pool()
    {
        if (basePool_)
        {
            return basePool_;
        }
        return mainBufferPool;
    }
 
    uint16_t itemSize_;
    uint16_t freeCount_;
    Pool *basePool_;
    Q waitingQueue_;
};
 
#endif // _UTILS_LIMITEDPOOL_HXX_