xml_allocator Struct Reference

Inheritance diagram for xml_allocator:

Public Member Functions
	xml_allocator (xml_memory_page *root)
xml_memory_page *	allocate_page (size_t data_size)
void *	allocate_memory_oob (size_t size, xml_memory_page *&out_page)
void *	allocate_memory (size_t size, xml_memory_page *&out_page)
void *	allocate_object (size_t size, xml_memory_page *&out_page)
void	deallocate_memory (void *ptr, size_t size, xml_memory_page *page)
char_t *	allocate_string (size_t length)
void	deallocate_string (char_t *string)
bool	reserve ()

Static Public Member Functions
static void	deallocate_page (xml_memory_page *page)

Public Attributes
xml_memory_page *	_root
size_t	_busy_size

Detailed Description

Definition at line 510 of file pugixml.cc.

Constructor & Destructor Documentation

xml_allocator()

xml_allocator::xml_allocator ( xml_memory_page * root )

inline

Definition at line 512 of file pugixml.cc.

                                            : _root(root), _busy_size(root->busy_size)
        {
        #ifdef PUGIXML_COMPACT
            _hash = 0;
        #endif
        }

Referenced by xml_document_struct::xml_document_struct().

Member Function Documentation

allocate_memory()

void * xml_allocator::allocate_memory ( size_t size, xml_memory_page *& out_page )

inline

Definition at line 544 of file pugixml.cc.

        {
            if (PUGI__UNLIKELY(_busy_size + size > xml_memory_page_size))
                return allocate_memory_oob(size, out_page);
 
            void* buf = reinterpret_cast<char*>(_root) + sizeof(xml_memory_page) + _busy_size;
 
            _busy_size += size;
 
            out_page = _root;
 
            return buf;
        }

Referenced by allocate_object(), and allocate_string().

allocate_memory_oob()

PUGI__FN_NO_INLINE void * xml_allocator::allocate_memory_oob	(	size_t	size,
		xml_memory_page *&	out_page )

Definition at line 710 of file pugixml.cc.

    {
        const size_t large_allocation_threshold = xml_memory_page_size / 4;
 
        xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
        out_page = page;
 
        if (!page) return 0;
 
        if (size <= large_allocation_threshold)
        {
            _root->busy_size = _busy_size;
 
            // insert page at the end of linked list
            page->prev = _root;
            _root->next = page;
            _root = page;
 
            _busy_size = size;
        }
        else
        {
            // insert page before the end of linked list, so that it is deleted as soon as possible
            // the last page is not deleted even if it's empty (see deallocate_memory)
            assert(_root->prev);
 
            page->prev = _root->prev;
            page->next = _root;
 
            _root->prev->next = page;
            _root->prev = page;
 
            page->busy_size = size;
        }
 
        return reinterpret_cast<char*>(page) + sizeof(xml_memory_page);
    }

Referenced by allocate_memory().

allocate_object()

void * xml_allocator::allocate_object ( size_t size, xml_memory_page *& out_page )

inline

Definition at line 590 of file pugixml.cc.

        {
            return allocate_memory(size, out_page);
        }

Referenced by allocate_attribute(), and allocate_node().

allocate_page()

xml_memory_page * xml_allocator::allocate_page ( size_t data_size )

inline

Definition at line 519 of file pugixml.cc.

        {
            size_t size = sizeof(xml_memory_page) + data_size;
 
            // allocate block with some alignment, leaving memory for worst-case padding
            void* memory = xml_memory::allocate(size);
            if (!memory) return 0;
 
            // prepare page structure
            xml_memory_page* page = xml_memory_page::construct(memory);
            assert(page);
 
            assert(this == _root->allocator);
            page->allocator = this;
 
            return page;
        }

Referenced by allocate_memory_oob().

allocate_string()

char_t * xml_allocator::allocate_string ( size_t length )

inline

Definition at line 640 of file pugixml.cc.

        {
            static const size_t max_encoded_offset = (1 << 16) * xml_memory_block_alignment;
 
            PUGI__STATIC_ASSERT(xml_memory_page_size <= max_encoded_offset);
 
            // allocate memory for string and header block
            size_t size = sizeof(xml_memory_string_header) + length * sizeof(char_t);
 
            // round size up to block alignment boundary
            size_t full_size = (size + (xml_memory_block_alignment - 1)) & ~(xml_memory_block_alignment - 1);
 
            xml_memory_page* page;
            xml_memory_string_header* header = static_cast<xml_memory_string_header*>(allocate_memory(full_size, page));
 
            if (!header) return 0;
 
            // setup header
            ptrdiff_t page_offset = reinterpret_cast<char*>(header) - reinterpret_cast<char*>(page) - sizeof(xml_memory_page);
 
            assert(page_offset % xml_memory_block_alignment == 0);
            assert(page_offset >= 0 && static_cast<size_t>(page_offset) < max_encoded_offset);
            header->page_offset = static_cast<uint16_t>(static_cast<size_t>(page_offset) / xml_memory_block_alignment);
 
            // full_size == 0 for large strings that occupy the whole page
            assert(full_size % xml_memory_block_alignment == 0);
            assert(full_size < max_encoded_offset || (page->busy_size == full_size && page_offset == 0));
            header->full_size = static_cast<uint16_t>(full_size < max_encoded_offset ? full_size / xml_memory_block_alignment : 0);
 
            // round-trip through void* to avoid 'cast increases required alignment of target type' warning
            // header is guaranteed a pointer-sized alignment, which should be enough for char_t
            return static_cast<char_t*>(static_cast<void*>(header + 1));
        }

Referenced by strcpy_insitu().

deallocate_memory()

void xml_allocator::deallocate_memory ( void * ptr, size_t size, xml_memory_page * page )

inline

Definition at line 596 of file pugixml.cc.

        {
            if (page == _root) page->busy_size = _busy_size;
 
            assert(ptr >= reinterpret_cast<char*>(page) + sizeof(xml_memory_page) && ptr < reinterpret_cast<char*>(page) + sizeof(xml_memory_page) + page->busy_size);
            (void)!ptr;
 
            page->freed_size += size;
            assert(page->freed_size <= page->busy_size);
 
            if (page->freed_size == page->busy_size)
            {
                if (page->next == 0)
                {
                    assert(_root == page);
 
                    // top page freed, just reset sizes
                    page->busy_size = 0;
                    page->freed_size = 0;
 
                #ifdef PUGIXML_COMPACT
                    // reset compact state to maximize efficiency
                    page->compact_string_base = 0;
                    page->compact_shared_parent = 0;
                    page->compact_page_marker = 0;
                #endif
 
                    _busy_size = 0;
                }
                else
                {
                    assert(_root != page);
                    assert(page->prev);
 
                    // remove from the list
                    page->prev->next = page->next;
                    page->next->prev = page->prev;
 
                    // deallocate
                    deallocate_page(page);
                }
            }
        }

Referenced by deallocate_string(), destroy_attribute(), and destroy_node().

deallocate_page()

void xml_allocator::deallocate_page ( xml_memory_page * page )

inlinestatic

Definition at line 537 of file pugixml.cc.

        {
            xml_memory::deallocate(page);
        }

Referenced by deallocate_memory().

deallocate_string()

void xml_allocator::deallocate_string ( char_t * string )

inline

Definition at line 674 of file pugixml.cc.

        {
            // this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
            // we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
 
            // get header
            xml_memory_string_header* header = static_cast<xml_memory_string_header*>(static_cast<void*>(string)) - 1;
            assert(header);
 
            // deallocate
            size_t page_offset = sizeof(xml_memory_page) + header->page_offset * xml_memory_block_alignment;
            xml_memory_page* page = reinterpret_cast<xml_memory_page*>(static_cast<void*>(reinterpret_cast<char*>(header) - page_offset));
 
            // if full_size == 0 then this string occupies the whole page
            size_t full_size = header->full_size == 0 ? page->busy_size : header->full_size * xml_memory_block_alignment;
 
            deallocate_memory(header, full_size, page);
        }

Referenced by destroy_attribute(), destroy_node(), and strcpy_insitu().

reserve()

bool xml_allocator::reserve ( )

inline

Definition at line 693 of file pugixml.cc.

        {
        #ifdef PUGIXML_COMPACT
            return _hash->reserve();
        #else
            return true;
        #endif
        }

Referenced by append_new_attribute(), append_new_node(), and strcpy_insitu().

Member Data Documentation

_busy_size

size_t xml_allocator::_busy_size

Definition at line 703 of file pugixml.cc.

Referenced by allocate_memory(), allocate_memory_oob(), deallocate_memory(), and xml_allocator().

_root

xml_memory_page* xml_allocator::_root

Definition at line 702 of file pugixml.cc.

Referenced by allocate_memory(), allocate_memory_oob(), allocate_page(), deallocate_memory(), and xml_allocator().

---

The documentation for this struct was generated from the following file:

• pugixml.cc