* You should use this one as an opaque handle only, the insides are internal.
**/
struct mempool_state {
- uns free[2];
+ size_t free[2];
void *last[2];
struct mempool_state *next;
};
struct ucw_allocator allocator;
struct mempool_state state;
void *unused, *last_big;
- uns chunk_size, threshold, idx;
+ size_t chunk_size, threshold;
+ uint 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 */
};
/***
/**
* Initialize a given mempool structure.
- * @chunk_size must be in the interval `[1, UINT_MAX / 2]`.
+ * @chunk_size must be in the interval `[1, SIZE_MAX / 2]`.
* It will allocate memory by this large chunks and take
* memory to satisfy requests from them.
*
* Memory pools can be treated as <<trans:respools,resources>>, see <<trans:res_mempool()>>.
**/
-void mp_init(struct mempool *pool, uns chunk_size);
+void mp_init(struct mempool *pool, size_t chunk_size);
/**
* Allocate and initialize a new memory pool.
*
* Memory pools can be treated as <<trans:respools,resources>>, see <<trans:res_mempool()>>.
**/
-struct mempool *mp_new(uns chunk_size);
+struct mempool *mp_new(size_t chunk_size);
/**
* Cleanup mempool initialized by mp_init or mp_new.
**/
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]]
***/
/* 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, size_t size) LIKE_MALLOC;
/**
* The function allocates new @size bytes on a given memory pool.
* `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, size_t 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, size_t 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, size_t 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, size_t size)
{
- uns avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1);
+ size_t avail = pool->state.free[0] & ~(size_t)(CPU_STRUCT_ALIGN - 1);
if (size <= avail)
{
pool->state.free[0] = avail - 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, size_t size)
{
if (size <= pool->state.free[0])
{
***/
/* 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, size_t size) LIKE_MALLOC;
+void *mp_grow_internal(struct mempool *pool, size_t size);
+void *mp_spread_internal(struct mempool *pool, void *p, size_t 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;
}
* 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, size_t size);
+void *mp_start_noalign(struct mempool *pool, size_t 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, size_t size)
{
- uns avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1);
+ size_t avail = pool->state.free[0] & ~(size_t)(CPU_STRUCT_ALIGN - 1);
if (size <= avail)
{
pool->idx = 0;
/**
* 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, size_t size)
{
if (size <= pool->state.free[0])
{
* 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 size_t mp_avail(struct mempool *pool)
{
return pool->state.free[pool->idx];
}
* 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, size_t size)
{
return (size <= mp_avail(pool)) ? mp_ptr(pool) : mp_grow_internal(pool, size);
}
* 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, size_t size)
{
- return (((uns)((byte *)pool->state.last[pool->idx] - (byte *)p) >= size) ? p : mp_spread_internal(pool, p, size));
+ return (((size_t)((byte *)pool->state.last[pool->idx] - (byte *)p) >= size) ? p : mp_spread_internal(pool, p, size));
}
/**
* 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, uns c)
+static inline char *mp_append_char(struct mempool *pool, char *p, uint c)
{
p = mp_spread(pool, p, 1);
*p++ = c;
* 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, uns size)
+static inline void *mp_append_block(struct mempool *pool, void *p, const void *block, size_t size)
{
char *q = mp_spread(pool, p, size);
memcpy(q, block, size);
/**
* 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 size_t 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];
}
* 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);
+size_t mp_open(struct mempool *pool, void *ptr);
/**
* Inlined version of @mp_open().
**/
-static inline uns mp_open_fast(struct mempool *pool, void *ptr)
+static inline size_t 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];
+ size_t size = ((byte *)pool->state.last[pool->idx] - (byte *)ptr) - pool->state.free[pool->idx];
pool->state.free[pool->idx] += size;
return size;
}
* 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, size_t 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, size_t size);
/**
* 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, size_t size)
{
mp_open_fast(pool, ptr);
ptr = mp_grow(pool, size);
***/
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 *, uns) LIKE_MALLOC; /** Makes a copy of a memory block on a mempool. **/
+void *mp_memdup(struct mempool *, const void *, size_t) 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:
* @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, uns len) LIKE_MALLOC;
+char *mp_str_from_mem(struct mempool *p, const void *mem, size_t len) LIKE_MALLOC;
/***