template <EAllocFreeType _alloc, bool __threads, int _Size>
class node_alloc;

CryMemoryAllocator.h

_Node_alloc_Mem_block_Huge * volatile __pCurrentHugeBlock;

LONG volatile _S_allocations;

this one is needed for proper simple_alloc wrapping

_Node_alloc_Mem_block_Huge * volatile _S_chunks;

static _Obj *_S_chunks;

_Obj * volatile _S_free_list[NFREELISTS];

_Mem_block* volatile _S_free_mem_blocks;

LONG volatile _S_freelist_counter[NFREELISTS];

LONG volatile _S_heap_size;

Amount of total allocated memory

_Node_Allocations_Tree<_Size> * volatile _S_Node_tree[NTREESCOUNT + 1];

LONG _S_wasted_in_allocation;

LONG _S_wasted_in_blocks;

static size_t _Find_binary_search(void * p, _Node_Allocations_Tree<_Size> * pBlock);

PS3

static size_t _Find_right_size(void * p);

static void * _M_allocate(size_t __n);

Chunk allocation state.

static void _M_deallocate(void * __p, size_t __n);

p may not be 0

static void _Register_Huge_Block(_Node_Allocations_Tree<_Size> * pBlock);

static char* _S_chunk_alloc(size_t __p_size, int& __nobjs);

Allocates a chunk for nobjs of size __p_size. nobjs may be reduced if it is inconvenient to allocate the requested number.

static size_t _S_fill_from_freelist(int num, _Obj* first, _Obj* last, void **);

static size_t _S_freelist_count(int num);

static size_t _S_freelist_count_inside(int num, _Obj* first, _Obj* last);

static void _S_freelist_delete_inside(int num, _Obj* first, _Obj* last);

static size_t _S_freelist_fill(int num, void ** _ptr);

static size_t _S_freememblocks_count_inside(int num, void* first, void* last);

static void _S_freememblocks_delete_inside(int num, void* first, void* last);

static size_t _S_get_free();

static _Obj* _S_refill(size_t __n);

Returns an object of size __n, and optionally adds to size __n free list.

static void _Unregister_Huge_Block(_Node_Allocations_Tree<_Size> * pBlock);

static void * alloc(size_t __n);

static void * allocate(size_t __n);

n must be > 0

static bool CanGuaranteeAlignment(size_t nSize, size_t nAlignment);

static void cleanup();

static size_t dealloc(void * __p);

static size_t dealloc(void * __p, size_t __n);

static size_t deallocate(void * __p);

p may not be 0

static size_t deallocate(void * __p, size_t __n);

static size_t get_heap_size();

__n must be > 0 static void * alloc(size_t __n) { return (__n > (size_t)__MAX_BYTES) ? Node_Allocator

static size_t get_wasted_in_allocation();

static size_t get_wasted_in_blocks();

static size_t getSize(void * __p);

static size_t getSizeEx(void * __p);

Helper method to retrieve the size of allocations only within the node allocator. If the memory block does not originate from within the node allocator, 0 is returned. important for PS3(talk to Chris Raine for details)

static bool IsInAddressRange(void* p);

static void Register_Small_Block(void * pObj, size_t count, size_t _n);

static void releaseMemory();

typedef _Node_alloc_Mem_block<_Size> _Mem_block;

typedef _Node_alloc_obj _Obj;

typedef char value_type;