#include <src/agg/agg_array.h>

Collaboration diagram for agg::block_allocator:

Classes
struct	block_type

Public Member Functions
void	remove_all ()

	~block_allocator ()

	block_allocator (unsigned block_size, unsigned block_ptr_inc=256-8)

int8u *	allocate (unsigned size, unsigned alignment=1)

Private Member Functions
void	allocate_block (unsigned size)

Private Attributes
unsigned	m_block_size

unsigned	m_block_ptr_inc

unsigned	m_num_blocks

unsigned	m_max_blocks

block_type *	m_blocks

int8u *	m_buf_ptr

unsigned	m_rest

Detailed Description

Class Documentation

◆ agg::block_allocator::block_type

struct agg::block_allocator::block_type

Class Members
int8u *	data
unsigned	size

Constructor & Destructor Documentation

◆ ~block_allocator()

agg::block_allocator::~block_allocator ( )

inline

        {
            remove_all();
        }

References remove_all().

Here is the call graph for this function:

◆ block_allocator()

agg::block_allocator::block_allocator	(	unsigned	block_size,
		unsigned	block_ptr_inc = `256-8`
	)

inline

                                                                           :
            m_block_size(block_size),
            m_block_ptr_inc(block_ptr_inc),
            m_num_blocks(0),
            m_max_blocks(0),
            m_blocks(0),
            m_buf_ptr(0),
            m_rest(0)
        {
        }

Member Function Documentation

◆ allocate()

int8u * agg::block_allocator::allocate	(	unsigned	size,
		unsigned	alignment = `1`
	)

inline

        {
            if(size == 0) return 0;
            if(size <= m_rest)
            {
                int8u* ptr = m_buf_ptr;
                if(alignment > 1)
                {
                    unsigned align = 
                        (alignment - unsigned((size_t)ptr) % alignment) % alignment;
 
                    size += align;
                    ptr += align;
                    if(size <= m_rest)
                    {
                        m_rest -= size;
                        m_buf_ptr += size;
                        return ptr;
                    }
                    allocate_block(size);
                    return allocate(size - align, alignment);
                }
                m_rest -= size;
                m_buf_ptr += size;
                return ptr;
            }
            allocate_block(size + alignment - 1);
            return allocate(size, alignment);
        }

References allocate(), allocate_block(), m_buf_ptr, and m_rest.

Referenced by allocate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allocate_block()

void agg::block_allocator::allocate_block ( unsigned size )

inlineprivate

        {
            if(size < m_block_size) size = m_block_size;
            if(m_num_blocks >= m_max_blocks) 
            {
                block_type* new_blocks = 
                    pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
 
                if(m_blocks)
                {
                    memcpy(new_blocks, 
                           m_blocks, 
                           m_num_blocks * sizeof(block_type));
                    pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
                }
                m_blocks = new_blocks;
                m_max_blocks += m_block_ptr_inc;
            }
 
            m_blocks[m_num_blocks].size = size;
            m_blocks[m_num_blocks].data = 
                m_buf_ptr =
                pod_allocator<int8u>::allocate(size);
 
            m_num_blocks++;
            m_rest = size;
        }

References agg::pod_allocator< T >::allocate(), agg::block_allocator::block_type::data, agg::pod_allocator< T >::deallocate(), m_block_ptr_inc, m_block_size, m_blocks, m_buf_ptr, m_max_blocks, m_num_blocks, m_rest, and agg::block_allocator::block_type::size.

Referenced by allocate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_all()

void agg::block_allocator::remove_all ( )

inline

        {
            if(m_num_blocks)
            {
                block_type* blk = m_blocks + m_num_blocks - 1;
                while(m_num_blocks--)
                {
                    pod_allocator<int8u>::deallocate(blk->data, blk->size);
                    --blk;
                }
                pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
            }
            m_num_blocks = 0;
            m_max_blocks = 0;
            m_blocks = 0;
            m_buf_ptr = 0;
            m_rest = 0;
        }