KZoneAllocator Class Reference
#include <kallocator.h>
Detailed Description
Memory allocator for large groups of small objects.This should be used for large groups of objects that are created and destroyed together. When used carefully for this purpose it is faster and more memory efficient than malloc. Additionally to a usual obstack like allocator you can also free the objects individually. Because it does no compaction it still is faster then malloc()/free(). Depending on the exact usage pattern that might come at the expense of some memory though.
Definition at line 46 of file kallocator.h.
Public Member Functions | |
KZoneAllocator (unsigned long _blockSize=8 *1024) | |
~KZoneAllocator () | |
void * | allocate (size_t _size) |
void | deallocate (void *ptr) |
void | free_since (void *ptr) |
Protected Types | |
typedef QValueList< MemBlock * > | MemList |
Protected Member Functions | |
void | addBlock (MemBlock *b) |
void | delBlock (MemBlock *b) |
void | insertHash (MemBlock *b) |
void | initHash () |
Protected Attributes | |
MemBlock * | currentBlock |
unsigned long | blockSize |
unsigned long | blockOffset |
unsigned int | log2 |
unsigned int | num_blocks |
MemList ** | hashList |
unsigned int | hashSize |
bool | hashDirty |
Member Typedef Documentation
typedef QValueList<MemBlock *> KZoneAllocator::MemList [protected] |
Constructor & Destructor Documentation
KZoneAllocator::KZoneAllocator | ( | unsigned long | _blockSize = 8 *1024 |
) |
Creates a KZoneAllocator object.
- Parameters:
-
_blockSize Size in bytes of the blocks requested from malloc.
Definition at line 48 of file kallocator.cpp.
KZoneAllocator::~KZoneAllocator | ( | ) |
Destructs the ZoneAllocator and free all memory allocated by it.
Definition at line 59 of file kallocator.cpp.
Member Function Documentation
void * KZoneAllocator::allocate | ( | size_t | _size | ) |
Allocates a memory block.
- Parameters:
-
_size Size in bytes of the memory block. Memory is aligned to the size of a pointer.
Definition at line 184 of file kallocator.cpp.
void KZoneAllocator::deallocate | ( | void * | ptr | ) |
Gives back a block returned by allocate() to the zone allocator, and possibly deallocates the block holding it (when it's empty).
The first deallocate() after many allocate() calls (or the first at all) builds an internal data structure for speeding up deallocation. The consistency of that structure is maintained from then on (by allocate() and deallocate()) unless many more objects are allocated without any intervening deallocation, in which case it's thrown away and rebuilt at the next deallocate().
The effect of this is, that such initial deallocate() calls take more time then the normal calls, and that after this list is built, i.e. generally if deallocate() is used at all, also allocate() is a little bit slower. This means, that if you want to squeeze out the last bit performance you would want to use KZoneAllocator as an obstack, i.e. just use the functions allocate() and free_since(). All the remaining memory is returned to the system if the zone allocator is destroyed.
- Parameters:
-
ptr Pointer as returned by allocate().
Definition at line 207 of file kallocator.cpp.
void KZoneAllocator::free_since | ( | void * | ptr | ) |
Deallocate many objects at once.
free_since() deallocates all objects allocated after ptr
, including ptr
itself.
The intended use is something along the lines of:
KZoneAllocator alloc(8192); void *remember_me = alloc.allocate(0); for (int i = 0; i < 1000; i++) do_something_with (alloc.allocate(12)); alloc.free_since (remember_me);
- Parameters:
-
ptr Pointer as returned by allocate(). It acts like a kind of mark of a certain position in the stack of all objects, off which you can throw away everything above that mark.
Definition at line 240 of file kallocator.cpp.
void KZoneAllocator::addBlock | ( | MemBlock * | b | ) | [protected] |
Add a new memory block to the pool of blocks, and reorganize the hash lists if needed.
- Parameters:
-
b block to add
Definition at line 102 of file kallocator.cpp.
void KZoneAllocator::delBlock | ( | MemBlock * | b | ) | [protected] |
Delete a memory block.
This really returns the memory to the heap.
- Parameters:
-
b block to delete
Definition at line 148 of file kallocator.cpp.
void KZoneAllocator::initHash | ( | ) | [protected] |
Member Data Documentation
MemBlock* KZoneAllocator::currentBlock [protected] |
unsigned long KZoneAllocator::blockSize [protected] |
unsigned long KZoneAllocator::blockOffset [protected] |
unsigned int KZoneAllocator::log2 [protected] |
unsigned int KZoneAllocator::num_blocks [protected] |
MemList** KZoneAllocator::hashList [protected] |
unsigned int KZoneAllocator::hashSize [protected] |
bool KZoneAllocator::hashDirty [protected] |
The documentation for this class was generated from the following files: