EMemChunk

typedef struct _EMemChunk EMemChunk;

e_memchunk_new ()

EMemChunk*          e_memchunk_new                      (int atomcount,
                                                         int atomsize);

Create a new memchunk header. Memchunks are an efficient way to allocate and deallocate identical sized blocks of memory quickly, and space efficiently.

e_memchunks are effectively the same as gmemchunks, only faster (much), and they use less memory overhead for housekeeping.

e_memchunk_alloc ()

void*               e_memchunk_alloc                    (EMemChunk *m);

e_memchunk_alloc0 ()

void*               e_memchunk_alloc0                   (EMemChunk *m);

e_memchunk_free ()

void                e_memchunk_free                     (EMemChunk *m,
                                                         void *mem);

Free a single atom back to the free pool of atoms in the given memchunk.

e_memchunk_empty ()

void                e_memchunk_empty                    (EMemChunk *m);

Clean out the memchunk buffers. Marks all allocated memory as free blocks, but does not give it back to the system. Can be used if the memchunk is to be used repeatedly.

e_memchunk_clean ()

void                e_memchunk_clean                    (EMemChunk *m);

Scan all empty blocks and check for blocks which can be free'd back to the system.

This routine may take a while to run if there are many allocated memory blocks (if the total number of allocations is many times greater than atomcount).

e_memchunk_destroy ()

void                e_memchunk_destroy                  (EMemChunk *m);

Free the memchunk header, and all associated memory.

EMemPool

typedef struct _EMemPool EMemPool;

enum EMemPoolFlags

typedef enum {
	E_MEMPOOL_ALIGN_STRUCT = 0,	/* allocate to native structure alignment */
	E_MEMPOOL_ALIGN_WORD = 1,	/* allocate to words - 16 bit alignment */
	E_MEMPOOL_ALIGN_BYTE = 2,	/* allocate to bytes - 8 bit alignment */
	E_MEMPOOL_ALIGN_MASK = 3, /* which bits determine the alignment information */
} EMemPoolFlags;

e_mempool_new ()

EMemPool*           e_mempool_new                       (int blocksize,
                                                         int threshold,
                                                         EMemPoolFlags flags);

Create a new mempool header. Mempools can be used to efficiently allocate data which can then be freed as a whole.

Mempools can also be used to efficiently allocate arbitrarily aligned data (such as strings) without incurring the space overhead of aligning each allocation (which is not required for strings).

However, each allocation cannot be freed individually, only all or nothing.

e_mempool_alloc ()

void*               e_mempool_alloc                     (EMemPool *pool,
                                                         int size);

Allocate a new data block in the mempool. Size will be rounded up to the mempool's alignment restrictions before being used.

e_mempool_strdup ()

char*               e_mempool_strdup                    (EMemPool *pool,
                                                         const char *str);

e_mempool_flush ()

void                e_mempool_flush                     (EMemPool *pool,
                                                         int freeall);

Flush used memory and mark allocated blocks as free.

If freeall is TRUE, then all allocated blocks are free'd as well. Otherwise only blocks above the threshold are actually freed, and the others are simply marked as empty.

e_mempool_destroy ()

void                e_mempool_destroy                   (EMemPool *pool);

Free all memory associated with a mempool.

EStrv

typedef struct _EStrv EStrv;

e_strv_new ()

EStrv*              e_strv_new                          (int size);

Create a new strv (string array) header. strv's can be used to create and work with arrays of strings that can then be compressed into a space-efficient static structure. This is useful where a number of strings are to be stored for lookup, and not generally edited afterwards.

The size limit is currently 254 elements. This will probably not change as arrays of this size suffer significant performance penalties when looking up strings with high indices.

e_strv_set_ref ()

EStrv*              e_strv_set_ref                      (EStrv *strv,
                                                         int index,
                                                         char *str);

Set a string array element by reference. The string is not copied until the array is packed.

If strv has been packed, then it is unpacked ready for more inserts, and should be packed again once finished with. The memory used by the original strv is not freed until the new strv is packed, or freed itself.

e_strv_set_ref_free ()

EStrv*              e_strv_set_ref_free                 (EStrv *strv,
                                                         int index,
                                                         char *str);

Set a string by reference, similar to set_ref, but also free the string when finished with it. The string is not copied until the strv is packed, and not at all if the index is overwritten.

e_strv_set ()

EStrv*              e_strv_set                          (EStrv *strv,
                                                         int index,
                                                         const char *str);

Set a string array reference. The string str is copied into the string array at location index.

If strv has been packed, then it is unpacked ready for more inserts, and should be packed again once finished with.

e_strv_pack ()

EStrv*              e_strv_pack                         (EStrv *strv);

Pack the strv into a space efficient structure for later lookup.

All strings are packed into a single allocated block, separated by single \0 characters, together with a count byte.

e_strv_get ()

char*               e_strv_get                          (EStrv *strv,
                                                         int index);

Retrieve a string by index. This function works identically on both packed and unpacked strv's, although may be much slower on a packed strv.

e_strv_destroy ()

void                e_strv_destroy                      (EStrv *strv);

Free a strv and all associated memory. Works on packed or unpacked strv's.

EPoolv

typedef struct _EPoolv EPoolv;

e_poolv_new ()

EPoolv*             e_poolv_new                         (unsigned int size);

create a new poolv (string vector which shares a global string pool). poolv's can be used to work with arrays of strings which save memory by eliminating duplicated allocations of the same string.

this is useful when you have a log of read-only strings that do not go away and are duplicated a lot (such as email headers).

we should probably in the future ref count the strings contained in the hash table, but for now let's not.

e_poolv_cpy ()

EPoolv*             e_poolv_cpy                         (EPoolv *dest,
                                                         const EPoolv *src);

Copy the contents of a pooled string vector

e_poolv_set ()

EPoolv*             e_poolv_set                         (EPoolv *poolv,
                                                         int index,
                                                         char *str,
                                                         int freeit);

Set a string vector reference. If the caller will no longer be referencing the string, freeit should be TRUE. Otherwise, this will duplicate the string if it is not found in the pool.

e_poolv_get ()

const char*         e_poolv_get                         (EPoolv *poolv,
                                                         int index);

Retrieve a string by index. This could possibly just be a macro.

Since the pool is never freed, this string does not need to be duplicated, but should not be modified.

e_poolv_destroy ()

void                e_poolv_destroy                     (EPoolv *poolv);

Free a pooled string vector. This doesn't free the strings from the vector, however.