qzdoom/src/memarena.cpp

378 lines
10 KiB
C++
Raw Normal View History

2016-03-01 15:47:10 +00:00
/*
** memarena.cpp
** Implements memory arenas.
**
**---------------------------------------------------------------------------
** Copyright 2010 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
** A memory arena is used for efficient allocation of many small objects that
** will all be freed at once. Note that since individual destructors are not
** called, you must not use an arena to allocate any objects that use a
** destructor, either explicitly or implicitly (because they have members
** with destructors).
*/
#include "doomtype.h"
#include "m_alloc.h"
#include "memarena.h"
#include "c_dispatch.h"
#include "zstring.h"
#define BLOCK_SIZE (10*1024)
struct FMemArena::Block
{
Block *NextBlock;
void *Limit; // End of this block
void *Avail; // Start of free space in this block
void Reset();
void *Alloc(size_t size);
};
//==========================================================================
//
// RoundPointer
//
// Rounds a pointer up to a pointer-sized boundary.
//
//==========================================================================
static inline void *RoundPointer(void *ptr)
{
return (void *)(((size_t)ptr + sizeof(void*) - 1) & ~(sizeof(void*) - 1));
}
//==========================================================================
//
// FMemArena Constructor
//
//==========================================================================
FMemArena::FMemArena()
{
TopBlock = NULL;
FreeBlocks = NULL;
}
//==========================================================================
//
// FMemArena Destructor
//
//==========================================================================
FMemArena::~FMemArena()
{
FreeAllBlocks();
}
//==========================================================================
//
// FMemArena :: Alloc
//
//==========================================================================
void *FMemArena::Alloc(size_t size)
{
Block *block;
for (block = TopBlock; block != NULL; block = block->NextBlock)
{
void *res = block->Alloc(size);
if (res != NULL)
{
return res;
}
}
block = AddBlock(size);
return block->Alloc(size);
}
//==========================================================================
//
// FMemArena :: FreeAll
//
// Moves all blocks to the free list. No system-level deallocation occurs.
//
//==========================================================================
void FMemArena::FreeAll()
{
for (Block *next, *block = TopBlock; block != NULL; block = next)
{
next = block->NextBlock;
block->Reset();
block->NextBlock = FreeBlocks;
FreeBlocks = block;
}
TopBlock = NULL;
}
//==========================================================================
//
// FMemArena :: FreeAllBlocks
//
// Frees all blocks used by this arena.
//
//==========================================================================
void FMemArena::FreeAllBlocks()
{
FreeBlockChain(TopBlock);
FreeBlockChain(FreeBlocks);
}
//==========================================================================
//
// FMemArena :: FreeBlockChain
//
// Frees a chain of blocks.
//
//==========================================================================
void FMemArena::FreeBlockChain(Block *&top)
{
for (Block *next, *block = top; block != NULL; block = next)
{
next = block->NextBlock;
M_Free(block);
}
top = NULL;
}
//==========================================================================
//
// FMemArena :: AddBlock
//
// Allocates a block large enough to hold at least <size> bytes and adds it
// to the TopBlock chain.
//
//==========================================================================
FMemArena::Block *FMemArena::AddBlock(size_t size)
{
Block *mem, **last;
size += sizeof(Block); // Account for header size
// Search for a free block to use
for (last = &FreeBlocks, mem = FreeBlocks; mem != NULL; last = &mem->NextBlock, mem = mem->NextBlock)
{
if ((BYTE *)mem->Limit - (BYTE *)mem >= (ptrdiff_t)size)
{
*last = mem->NextBlock;
break;
}
}
if (mem == NULL)
{
// Allocate a new block
if (size < BLOCK_SIZE)
{
size = BLOCK_SIZE;
}
else
{ // Stick some free space at the end so we can use this block for
// other things.
size += BLOCK_SIZE/2;
}
mem = (Block *)M_Malloc(size);
mem->Limit = (BYTE *)mem + size;
}
mem->Reset();
mem->NextBlock = TopBlock;
TopBlock = mem;
return mem;
}
//==========================================================================
//
// FMemArena :: Block :: Reset
//
// Resets this block's Avail pointer.
//
//==========================================================================
void FMemArena::Block::Reset()
{
Avail = RoundPointer(this + sizeof(*this));
}
//==========================================================================
//
// FMemArena :: Block :: Alloc
//
// Allocates memory from the block if it has space. Returns NULL if not.
//
//==========================================================================
void *FMemArena::Block::Alloc(size_t size)
{
if ((char *)Avail + size > Limit)
{
return NULL;
}
void *res = Avail;
Avail = RoundPointer((char *)Avail + size);
return res;
}
//==========================================================================
//
// FSharedStringArena Constructor
//
//==========================================================================
FSharedStringArena::FSharedStringArena()
{
memset(Buckets, 0, sizeof(Buckets));
}
//==========================================================================
//
// FSharedStringArena Destructor
//
//==========================================================================
FSharedStringArena::~FSharedStringArena()
{
FreeAll();
// FMemArena destructor will free the blocks.
}
//==========================================================================
//
// FSharedStringArena :: Alloc
//
// Allocates a new string and initializes it with the passed string. This
// version takes an FString as a parameter, so it won't need to allocate any
// memory for the string text if it already exists in the arena.
//
//==========================================================================
FString *FSharedStringArena::Alloc(const FString &source)
{
unsigned int hash;
Node *strnode;
strnode = FindString(source, source.Len(), hash);
if (strnode == NULL)
{
strnode = (Node *)FMemArena::Alloc(sizeof(Node));
::new(&strnode->String) FString(source);
strnode->Hash = hash;
hash %= countof(Buckets);
strnode->Next = Buckets[hash];
Buckets[hash] = strnode;
}
return &strnode->String;
}
//==========================================================================
//
// FSharedStringArena :: Alloc
//
//==========================================================================
FString *FSharedStringArena::Alloc(const char *source)
{
return Alloc(source, strlen(source));
}
//==========================================================================
//
// FSharedStringArena :: Alloc
//
//==========================================================================
FString *FSharedStringArena::Alloc(const char *source, size_t strlen)
{
unsigned int hash;
Node *strnode;
strnode = FindString(source, strlen, hash);
if (strnode == NULL)
{
strnode = (Node *)FMemArena::Alloc(sizeof(Node));
::new(&strnode->String) FString(source, strlen);
strnode->Hash = hash;
hash %= countof(Buckets);
strnode->Next = Buckets[hash];
Buckets[hash] = strnode;
}
return &strnode->String;
}
//==========================================================================
//
// FSharedStringArena :: FindString
//
// Finds the string if it's already in the arena. Returns NULL if not.
//
//==========================================================================
FSharedStringArena::Node *FSharedStringArena::FindString(const char *str, size_t strlen, unsigned int &hash)
{
hash = SuperFastHash(str, strlen);
for (Node *node = Buckets[hash % countof(Buckets)]; node != NULL; node = node->Next)
{
if (node->Hash == hash && node->String.Len() == strlen && memcmp(&node->String[0], str, strlen) == 0)
{
return node;
}
}
return NULL;
}
//==========================================================================
//
// FSharedStringArena :: FreeAll
//
// In addition to moving all used blocks onto the free list, all FStrings
// they contain will have their destructors called.
//
//==========================================================================
void FSharedStringArena::FreeAll()
{
for (Block *next, *block = TopBlock; block != NULL; block = next)
{
next = block->NextBlock;
void *limit = block->Avail;
block->Reset();
for (Node *string = (Node *)block->Avail; string < limit; ++string)
{
string->~Node();
}
block->NextBlock = FreeBlocks;
FreeBlocks = block;
}
memset(Buckets, 0, sizeof(Buckets));
TopBlock = NULL;
}