mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
194 lines
4.9 KiB
C++
194 lines
4.9 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef MOZILLA_GFX_ITERABLEARENA_H_
|
|
#define MOZILLA_GFX_ITERABLEARENA_H_
|
|
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/gfx/Logging.h"
|
|
|
|
#include <string.h>
|
|
#include <vector>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
/// A simple pool allocator for plain data structures.
|
|
///
|
|
/// Beware that the pool will not attempt to run the destructors. It is the
|
|
/// responsibility of the user of this class to either use objects with no
|
|
/// destructor or to manually call the allocated objects destructors.
|
|
/// If the pool is growable, its allocated objects must be safely moveable in
|
|
/// in memory (through memcpy).
|
|
class IterableArena {
|
|
protected:
|
|
struct Header
|
|
{
|
|
size_t mBlocSize;
|
|
};
|
|
public:
|
|
enum ArenaType {
|
|
FIXED_SIZE,
|
|
GROWABLE
|
|
};
|
|
|
|
IterableArena(ArenaType aType, size_t aStorageSize)
|
|
: mSize(aStorageSize)
|
|
, mCursor(0)
|
|
, mIsGrowable(aType == GROWABLE)
|
|
{
|
|
if (mSize == 0) {
|
|
mSize = 128;
|
|
}
|
|
|
|
mStorage = (uint8_t*)malloc(mSize);
|
|
if (mStorage == nullptr) {
|
|
gfxCriticalError() << "Not enough Memory allocate a memory pool of size " << aStorageSize;
|
|
MOZ_CRASH();
|
|
}
|
|
}
|
|
|
|
~IterableArena()
|
|
{
|
|
free(mStorage);
|
|
}
|
|
|
|
/// Constructs a new item in the pool and returns a positive offset in case of
|
|
/// success.
|
|
///
|
|
/// The offset never changes even if the storage is reallocated, so users
|
|
/// of this class should prefer storing offsets rather than direct pointers
|
|
/// to the allocated objects.
|
|
/// Alloc can cause the storage to be reallocated if the pool was initialized
|
|
/// with IterableArena::GROWABLE.
|
|
/// If for any reason the pool fails to allocate enough space for the new item
|
|
/// Alloc returns a negative offset and the object's constructor is not called.
|
|
template<typename T, typename... Args>
|
|
ptrdiff_t
|
|
Alloc(Args&&... aArgs)
|
|
{
|
|
void* storage = nullptr;
|
|
auto offset = AllocRaw(sizeof(T), &storage);
|
|
if (offset < 0) {
|
|
return offset;
|
|
}
|
|
new (storage) T(Forward<Args>(aArgs)...);
|
|
return offset;
|
|
}
|
|
|
|
ptrdiff_t AllocRaw(size_t aSize, void** aOutPtr = nullptr)
|
|
{
|
|
const size_t blocSize = AlignedSize(sizeof(Header) + aSize);
|
|
|
|
if (AlignedSize(mCursor + blocSize) > mSize) {
|
|
if (!mIsGrowable) {
|
|
return -1;
|
|
}
|
|
|
|
size_t newSize = mSize * 2;
|
|
while (AlignedSize(mCursor + blocSize) > newSize) {
|
|
newSize *= 2;
|
|
}
|
|
|
|
uint8_t* newStorage = (uint8_t*)realloc(mStorage, newSize);
|
|
if (!newStorage) {
|
|
gfxCriticalError() << "Not enough Memory to grow the memory pool, size: " << newSize;
|
|
return -1;
|
|
}
|
|
|
|
mStorage = newStorage;
|
|
mSize = newSize;
|
|
}
|
|
ptrdiff_t offset = mCursor;
|
|
GetHeader(offset)->mBlocSize = blocSize;
|
|
mCursor += blocSize;
|
|
if (aOutPtr) {
|
|
*aOutPtr = GetStorage(offset);
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
/// Get access to an allocated item at a given offset (only use offsets returned
|
|
/// by Alloc or AllocRaw).
|
|
///
|
|
/// If the pool is growable, the returned pointer is only valid temporarily. The
|
|
/// underlying storage can be reallocated in Alloc or AllocRaw, so do not keep
|
|
/// these pointers around and store the offset instead.
|
|
void* GetStorage(ptrdiff_t offset = 0)
|
|
{
|
|
MOZ_ASSERT(offset >= 0);
|
|
MOZ_ASSERT(offset < mCursor);
|
|
return offset >= 0 ? mStorage + offset + sizeof(Header) : nullptr;
|
|
}
|
|
|
|
/// Clears the storage without running any destructor and without deallocating it.
|
|
void Clear()
|
|
{
|
|
mCursor = 0;
|
|
}
|
|
|
|
/// Iterate over the elements allocated in this pool.
|
|
///
|
|
/// Takes a lambda or function object accepting a void* as parameter.
|
|
template<typename Func>
|
|
void ForEach(Func cb)
|
|
{
|
|
Iterator it;
|
|
while (void* ptr = it.Next(this)) {
|
|
cb(ptr);
|
|
}
|
|
}
|
|
|
|
/// A simple iterator over an arena.
|
|
class Iterator {
|
|
public:
|
|
Iterator()
|
|
: mCursor(0)
|
|
{}
|
|
|
|
void* Next(IterableArena* aArena)
|
|
{
|
|
if (mCursor >= aArena->mCursor) {
|
|
return nullptr;
|
|
}
|
|
void* result = aArena->GetStorage(mCursor);
|
|
const size_t blocSize = aArena->GetHeader(mCursor)->mBlocSize;
|
|
MOZ_ASSERT(blocSize != 0);
|
|
mCursor += blocSize;
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
ptrdiff_t mCursor;
|
|
};
|
|
|
|
protected:
|
|
Header* GetHeader(ptrdiff_t offset)
|
|
{
|
|
return (Header*) (mStorage + offset);
|
|
}
|
|
|
|
size_t AlignedSize(size_t aSize) const
|
|
{
|
|
const size_t alignment = sizeof(uintptr_t);
|
|
return aSize + (alignment - (aSize % alignment)) % alignment;
|
|
}
|
|
|
|
uint8_t* mStorage;
|
|
uint32_t mSize;
|
|
ptrdiff_t mCursor;
|
|
bool mIsGrowable;
|
|
|
|
friend class Iterator;
|
|
};
|
|
|
|
} // namespace
|
|
} // namespace
|
|
|
|
#endif
|