X-Git-Url: http://mj.ucw.cz/gitweb/?a=blobdiff_plain;ds=sidebyside;f=ucw%2Fmempool.h;h=28ce680af772e9075d8537ec1dc27c8cf9e25069;hb=6912c77a66798de162fe31f79581cd7b5c97f12c;hp=7ac7f1667acef3a503a41c0661d2f73972402445;hpb=1cf8ac51f5495ccd5187dc220ffc69e95d6e0cfc;p=libucw.git diff --git a/ucw/mempool.h b/ucw/mempool.h index 7ac7f166..28ce680a 100644 --- a/ucw/mempool.h +++ b/ucw/mempool.h @@ -1,7 +1,7 @@ /* * UCW Library -- Memory Pools * - * (c) 1997--2005 Martin Mares + * (c) 1997--2014 Martin Mares * (c) 2007 Pavel Charvat * * This software may be freely distributed and used according to the terms @@ -11,6 +11,42 @@ #ifndef _UCW_POOLS_H #define _UCW_POOLS_H +#include +#include + +#ifdef CONFIG_UCW_CLEAN_ABI +#define mp_alloc ucw_mp_alloc +#define mp_alloc_internal ucw_mp_alloc_internal +#define mp_alloc_noalign ucw_mp_alloc_noalign +#define mp_alloc_zero ucw_mp_alloc_zero +#define mp_append_printf ucw_mp_append_printf +#define mp_append_vprintf ucw_mp_append_vprintf +#define mp_delete ucw_mp_delete +#define mp_flush ucw_mp_flush +#define mp_grow_internal ucw_mp_grow_internal +#define mp_init ucw_mp_init +#define mp_memdup ucw_mp_memdup +#define mp_multicat ucw_mp_multicat +#define mp_new ucw_mp_new +#define mp_open ucw_mp_open +#define mp_pop ucw_mp_pop +#define mp_printf ucw_mp_printf +#define mp_push ucw_mp_push +#define mp_realloc ucw_mp_realloc +#define mp_realloc_zero ucw_mp_realloc_zero +#define mp_restore ucw_mp_restore +#define mp_spread_internal ucw_mp_spread_internal +#define mp_start ucw_mp_start +#define mp_start_internal ucw_mp_start_internal +#define mp_start_noalign ucw_mp_start_noalign +#define mp_stats ucw_mp_stats +#define mp_str_from_mem ucw_mp_str_from_mem +#define mp_strdup ucw_mp_strdup +#define mp_strjoin ucw_mp_strjoin +#define mp_total_size ucw_mp_total_size +#define mp_vprintf ucw_mp_vprintf +#endif + /*** * [[defs]] * Definitions @@ -22,7 +58,7 @@ * You should use this one as an opaque handle only, the insides are internal. **/ struct mempool_state { - uns free[2]; + uint free[2]; void *last[2]; struct mempool_state *next; }; @@ -32,15 +68,18 @@ struct mempool_state { * You should use this one as an opaque handle only, the insides are internal. **/ struct mempool { + struct ucw_allocator allocator; struct mempool_state state; void *unused, *last_big; - uns chunk_size, threshold, idx; + uint chunk_size, threshold, idx; + u64 total_size; }; struct mempool_stats { /** Mempool statistics. See @mp_stats(). **/ u64 total_size; /* Real allocated size in bytes */ - uns chain_count[3]; /* Number of allocated chunks in small/big/unused chains */ - uns chain_size[3]; /* Size of allocated chunks in small/big/unused chains */ + u64 used_size; /* Estimated size allocated from mempool to application */ + uint chain_count[3]; /* Number of allocated chunks in small/big/unused chains */ + u64 chain_size[3]; /* Size of allocated chunks in small/big/unused chains */ }; /*** @@ -54,16 +93,20 @@ struct mempool_stats { /** Mempool statistics. See @mp_stats(). **/ * @chunk_size must be in the interval `[1, UINT_MAX / 2]`. * It will allocate memory by this large chunks and take * memory to satisfy requests from them. + * + * Memory pools can be treated as <>, see <>. **/ -void mp_init(struct mempool *pool, uns chunk_size); +void mp_init(struct mempool *pool, uint chunk_size); /** * Allocate and initialize a new memory pool. * See @mp_init() for @chunk_size limitations. * * The new mempool structure is allocated on the new mempool. + * + * Memory pools can be treated as <>, see <>. **/ -struct mempool *mp_new(uns chunk_size); +struct mempool *mp_new(uint chunk_size); /** * Cleanup mempool initialized by mp_init or mp_new. @@ -83,10 +126,22 @@ void mp_flush(struct mempool *pool); /** * Compute some statistics for debug purposes. * See the definition of the <>. + * This function scans the chunk list, so it can be slow. If you are interested + * in total memory consumption only, mp_total_size() is faster. **/ void mp_stats(struct mempool *pool, struct mempool_stats *stats); -u64 mp_total_size(struct mempool *pool); /** How many bytes were allocated by the pool. **/ +/** + * Return how many bytes were allocated by the pool, including unused parts + * of chunks. This function runs in constant time. + **/ +u64 mp_total_size(struct mempool *pool); + +/** + * Release unused chunks of memory reserved for further allocation + * requests, but stop if mp_total_size() would drop below @min_total_size. + **/ +void mp_shrink(struct mempool *pool, u64 min_total_size); /*** * [[alloc]] @@ -95,7 +150,7 @@ u64 mp_total_size(struct mempool *pool); /** How many bytes were allocated by th ***/ /* For internal use only, do not call directly */ -void *mp_alloc_internal(struct mempool *pool, uns size) LIKE_MALLOC; +void *mp_alloc_internal(struct mempool *pool, uint size) LIKE_MALLOC; /** * The function allocates new @size bytes on a given memory pool. @@ -107,24 +162,24 @@ void *mp_alloc_internal(struct mempool *pool, uns size) LIKE_MALLOC; * `CPU_STRUCT_ALIGN` bytes and this condition remains true also * after future reallocations. **/ -void *mp_alloc(struct mempool *pool, uns size); +void *mp_alloc(struct mempool *pool, uint size); /** * The same as @mp_alloc(), but the result may be unaligned. **/ -void *mp_alloc_noalign(struct mempool *pool, uns size); +void *mp_alloc_noalign(struct mempool *pool, uint size); /** * The same as @mp_alloc(), but fills the newly allocated memory with zeroes. **/ -void *mp_alloc_zero(struct mempool *pool, uns size); +void *mp_alloc_zero(struct mempool *pool, uint size); /** * Inlined version of @mp_alloc(). **/ -static inline void *mp_alloc_fast(struct mempool *pool, uns size) +static inline void *mp_alloc_fast(struct mempool *pool, uint size) { - uns avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1); + uint avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1); if (size <= avail) { pool->state.free[0] = avail - size; @@ -137,7 +192,7 @@ static inline void *mp_alloc_fast(struct mempool *pool, uns size) /** * Inlined version of @mp_alloc_noalign(). **/ -static inline void *mp_alloc_fast_noalign(struct mempool *pool, uns size) +static inline void *mp_alloc_fast_noalign(struct mempool *pool, uint size) { if (size <= pool->state.free[0]) { @@ -149,6 +204,14 @@ static inline void *mp_alloc_fast_noalign(struct mempool *pool, uns size) return mp_alloc_internal(pool, size); } +/** + * Return a generic allocator representing the given mempool. + **/ +static inline struct ucw_allocator *mp_get_allocator(struct mempool *mp) +{ + return &mp->allocator; +} + /*** * [[gbuf]] * Growing buffers @@ -162,12 +225,11 @@ static inline void *mp_alloc_fast_noalign(struct mempool *pool, uns size) ***/ /* For internal use only, do not call directly */ -void *mp_start_internal(struct mempool *pool, uns size) LIKE_MALLOC; -void *mp_grow_internal(struct mempool *pool, uns size); -void *mp_spread_internal(struct mempool *pool, void *p, uns size); +void *mp_start_internal(struct mempool *pool, uint size) LIKE_MALLOC; +void *mp_grow_internal(struct mempool *pool, uint size); +void *mp_spread_internal(struct mempool *pool, void *p, uint size); -static inline uns -mp_idx(struct mempool *pool, void *ptr) +static inline uint mp_idx(struct mempool *pool, void *ptr) { return ptr == pool->last_big; } @@ -185,15 +247,15 @@ mp_idx(struct mempool *pool, void *ptr) * Keep in mind that you can't make any other pool allocations * before you "close" the growing buffer with @mp_end(). */ -void *mp_start(struct mempool *pool, uns size); -void *mp_start_noalign(struct mempool *pool, uns size); +void *mp_start(struct mempool *pool, uint size); +void *mp_start_noalign(struct mempool *pool, uint size); /** * Inlined version of @mp_start(). **/ -static inline void *mp_start_fast(struct mempool *pool, uns size) +static inline void *mp_start_fast(struct mempool *pool, uint size) { - uns avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1); + uint avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1); if (size <= avail) { pool->idx = 0; @@ -207,7 +269,7 @@ static inline void *mp_start_fast(struct mempool *pool, uns size) /** * Inlined version of @mp_start_noalign(). **/ -static inline void *mp_start_fast_noalign(struct mempool *pool, uns size) +static inline void *mp_start_fast_noalign(struct mempool *pool, uint size) { if (size <= pool->state.free[0]) { @@ -230,7 +292,7 @@ static inline void *mp_ptr(struct mempool *pool) * Return the number of bytes available for extending the growing buffer. * (Before a reallocation will be needed). **/ -static inline uns mp_avail(struct mempool *pool) +static inline uint mp_avail(struct mempool *pool) { return pool->state.free[pool->idx]; } @@ -241,7 +303,7 @@ static inline uns mp_avail(struct mempool *pool) * change its starting position. The content will be unchanged to the minimum * of the old and new sizes; newly allocated memory will be uninitialized. * Multiple calls to mp_grow() have amortized linear cost wrt. the maximum value of @size. */ -static inline void *mp_grow(struct mempool *pool, uns size) +static inline void *mp_grow(struct mempool *pool, uint size) { return (size <= mp_avail(pool)) ? mp_ptr(pool) : mp_grow_internal(pool, size); } @@ -258,9 +320,43 @@ static inline void *mp_expand(struct mempool *pool) * Ensure that there is at least @size bytes free after @p, * if not, reallocate and adjust @p. **/ -static inline void *mp_spread(struct mempool *pool, void *p, uns size) +static inline void *mp_spread(struct mempool *pool, void *p, uint size) +{ + return (((uint)((byte *)pool->state.last[pool->idx] - (byte *)p) >= size) ? p : mp_spread_internal(pool, p, size)); +} + +/** + * Append a character to the growing buffer. Called with @p pointing after + * the last byte in the buffer, returns a pointer after the last byte + * of the new (possibly reallocated) buffer. + **/ +static inline char *mp_append_char(struct mempool *pool, char *p, uint c) +{ + p = mp_spread(pool, p, 1); + *p++ = c; + return p; +} + +/** + * Append a memory block to the growing buffer. Called with @p pointing after + * the last byte in the buffer, returns a pointer after the last byte + * of the new (possibly reallocated) buffer. + **/ +static inline void *mp_append_block(struct mempool *pool, void *p, const void *block, uint size) +{ + char *q = mp_spread(pool, p, size); + memcpy(q, block, size); + return q + size; +} + +/** + * Append a string to the growing buffer. Called with @p pointing after + * the last byte in the buffer, returns a pointer after the last byte + * of the new (possibly reallocated) buffer. + **/ +static inline void *mp_append_string(struct mempool *pool, void *p, const char *str) { - return (((uns)((byte *)pool->state.last[pool->idx] - (byte *)p) >= size) ? p : mp_spread_internal(pool, p, size)); + return mp_append_block(pool, p, str, strlen(str)); } /** @@ -275,12 +371,21 @@ static inline void *mp_end(struct mempool *pool, void *end) return p; } +/** + * Close the growing buffer as a string. That is, append a zero byte and call mp_end(). + **/ +static inline char *mp_end_string(struct mempool *pool, void *end) +{ + end = mp_append_char(pool, end, 0); + return mp_end(pool, end); +} + /** * Return size in bytes of the last allocated memory block (with @mp_alloc() or @mp_end()). **/ -static inline uns mp_size(struct mempool *pool, void *ptr) +static inline uint mp_size(struct mempool *pool, void *ptr) { - uns idx = mp_idx(pool, ptr); + uint idx = mp_idx(pool, ptr); return ((byte *)pool->state.last[idx] - (byte *)ptr) - pool->state.free[idx]; } @@ -289,15 +394,15 @@ static inline uns mp_size(struct mempool *pool, void *ptr) * for growing and return its size in bytes. The contents and the start pointer * remain unchanged. Do not forget to call @mp_end() to close it. **/ -uns mp_open(struct mempool *pool, void *ptr); +uint mp_open(struct mempool *pool, void *ptr); /** - * Inlined version of mp_open(). + * Inlined version of @mp_open(). **/ -static inline uns mp_open_fast(struct mempool *pool, void *ptr) +static inline uint mp_open_fast(struct mempool *pool, void *ptr) { pool->idx = mp_idx(pool, ptr); - uns size = ((byte *)pool->state.last[pool->idx] - (byte *)ptr) - pool->state.free[pool->idx]; + uint size = ((byte *)pool->state.last[pool->idx] - (byte *)ptr) - pool->state.free[pool->idx]; pool->state.free[pool->idx] += size; return size; } @@ -307,17 +412,17 @@ static inline uns mp_open_fast(struct mempool *pool, void *ptr) * to the new @size. Behavior is similar to @mp_grow(), but the resulting * block is closed. **/ -void *mp_realloc(struct mempool *pool, void *ptr, uns size); +void *mp_realloc(struct mempool *pool, void *ptr, uint size); /** * The same as @mp_realloc(), but fills the additional bytes (if any) with zeroes. **/ -void *mp_realloc_zero(struct mempool *pool, void *ptr, uns size); +void *mp_realloc_zero(struct mempool *pool, void *ptr, uint size); /** - * Inlined version of mp_realloc(). + * Inlined version of @mp_realloc(). **/ -static inline void *mp_realloc_fast(struct mempool *pool, void *ptr, uns size) +static inline void *mp_realloc_fast(struct mempool *pool, void *ptr, uint size) { mp_open_fast(pool, ptr); ptr = mp_grow(pool, size); @@ -336,7 +441,7 @@ static inline void *mp_realloc_fast(struct mempool *pool, void *ptr, uns size) /** * Save the current state of a memory pool. - * Do not call this function with an opened growing buffer. + * Do not call this function with an opened growing buffer. **/ static inline void mp_save(struct mempool *pool, struct mempool_state *state) { @@ -384,8 +489,8 @@ void mp_pop(struct mempool *pool); * ----------------- ***/ -char *mp_strdup(struct mempool *, const char *) LIKE_MALLOC; /** Makes a copy of a string on a mempool. **/ -void *mp_memdup(struct mempool *, const void *, uns) LIKE_MALLOC; /** Makes a copy of a memory block on a mempool. **/ +char *mp_strdup(struct mempool *, const char *) LIKE_MALLOC; /** Makes a copy of a string on a mempool. Returns NULL for NULL string. **/ +void *mp_memdup(struct mempool *, const void *, uint) LIKE_MALLOC; /** Makes a copy of a memory block on a mempool. **/ /** * Concatenates all passed strings. The last parameter must be NULL. * This will concatenate two strings: @@ -405,7 +510,12 @@ static inline char *LIKE_MALLOC mp_strcat(struct mempool *mp, const char *x, con * @p is the mempool to provide memory, @a is array of strings and @n * tells how many there is of them. **/ -char *mp_strjoin(struct mempool *p, char **a, uns n, uns sep) LIKE_MALLOC; +char *mp_strjoin(struct mempool *p, char **a, uint n, uint sep) LIKE_MALLOC; +/** + * Convert memory block to a string. Makes a copy of the given memory block + * in the mempool @p, adding an extra terminating zero byte at the end. + **/ +char *mp_str_from_mem(struct mempool *p, const void *mem, uint len) LIKE_MALLOC; /*** @@ -429,11 +539,19 @@ char *mp_vprintf(struct mempool *mp, const char *fmt, va_list args) LIKE_MALLOC; * * Returns pointer to the beginning of the string (the pointer may have * changed due to reallocation). + * + * Alternatively, this function may be called mp_printf_append() for compatibility with + * previous releases of LibUCW. **/ -char *mp_printf_append(struct mempool *mp, char *ptr, const char *fmt, ...) FORMAT_CHECK(printf,3,4); +char *mp_append_printf(struct mempool *mp, char *ptr, const char *fmt, ...) FORMAT_CHECK(printf,3,4); +#define mp_printf_append mp_append_printf /** - * Like @mp_printf_append(), but uses `va_list` for parameters. + * Like @mp_append_printf(), but uses `va_list` for parameters. + * + * Alternatively, this function may be called mp_vprintf_append() for compatibility with + * previous releases of LibUCW. **/ -char *mp_vprintf_append(struct mempool *mp, char *ptr, const char *fmt, va_list args); +char *mp_append_vprintf(struct mempool *mp, char *ptr, const char *fmt, va_list args); +#define mp_vprintf_append mp_append_vprintf #endif