ForwardAllocator.cxx

Go to the documentation of this file.

 
#include "utils/ForwardAllocator.hxx"
 
#include "utils/Buffer.hxx"
 
// static
DynamicPool *ForwardAllocator::kbytePool_ =
    new DynamicPool(Bucket::init(sizeof(BufferType), 0));
 
static constexpr unsigned MALLOC_OVERHEAD = sizeof(void *);
 
#ifdef GTEST
// static
void ForwardAllocator::TEST_recreate_pool()
{
    delete kbytePool_;
    kbytePool_ = new DynamicPool(Bucket::init(sizeof(BufferType), 0));
}
#endif
 
ForwardAllocator::ForwardAllocator()
{
}
 
ForwardAllocator::~ForwardAllocator()
{
    OSMutexLock h(&lock_);
    while (!allocatedBlocks_.empty())
    {
        allocatedBlocks_.pop_front()->unref();
    }
}
 
void *ForwardAllocator::allocate(size_t size, size_t align)
{
    HASSERT(align <= alignof(primitive_t));
    if (size >= BLOCK_BYTE_SIZE)
    {
        // Large block. Allocate custom.
        size_t head = sizeof(Buffer<uint64_t>);
        head += size - sizeof(uint64_t);
        HASSERT(head < 65535); // a bit left for buffer header.
        auto *bufp =
            (Buffer<uint64_t> *)mainBufferPool->alloc_untyped(head, nullptr);
        HASSERT(bufp);
        // Links the new buffer into the queue.
        OSMutexLock h(&lock_);
        allocSize_ += head + MALLOC_OVERHEAD;
        if (allocatedBlocks_.empty())
        {
            allocatedBlocks_.SimpleQueue::push_front(bufp);
            offsetInLast_ = BLOCK_BYTE_SIZE + 1;
        }
        else
        {
            auto it = allocatedBlocks_.SimpleQueue::begin();
            ++it;
            allocatedBlocks_.insert(it, bufp);
        }
        return bufp->data();
    }
    OSMutexLock h(&lock_);
    size_t pad = offsetInLast_ % align;
    if (pad)
    {
        pad = (align - pad);
        allocWasted_ += pad;
    }
    offsetInLast_ += pad;
    if (offsetInLast_ + size > BLOCK_BYTE_SIZE)
    {
        allocWasted_ += BLOCK_BYTE_SIZE;
        allocWasted_ -= offsetInLast_;
        // Does not fit. Allocate new block.
        BufferType *new_block;
        kbytePool_->alloc(&new_block);
        allocSize_ += sizeof(BufferType) + MALLOC_OVERHEAD;
        HASSERT(new_block);
        allocatedBlocks_.push_front(new_block);
        offsetInLast_ = 0;
    }
    auto *ret = head_ptr() + offsetInLast_;
    offsetInLast_ += size;
    return ret;
}