From 7334fc5c5cfe4848b8855ad54b74a0eec8f6ac08 Mon Sep 17 00:00:00 2001 From: Pavel Charvat Date: Mon, 2 Jun 2014 14:32:19 +0200 Subject: [PATCH] Mempool: Converted to size_t. --- ucw/doc/mempool.txt | 2 +- ucw/mempool-fmt.c | 4 +-- ucw/mempool-str.c | 14 ++++----- ucw/mempool.c | 52 +++++++++++++++++----------------- ucw/mempool.h | 69 +++++++++++++++++++++++---------------------- 5 files changed, 71 insertions(+), 70 deletions(-) diff --git a/ucw/doc/mempool.txt b/ucw/doc/mempool.txt index 456cf1c8..5aa33ddd 100644 --- a/ucw/doc/mempool.txt +++ b/ucw/doc/mempool.txt @@ -112,7 +112,7 @@ This example uses libucw's own IO system, <>. void *stdin_data(struct mempool *pool) { struct fastbuf *fb = bopen_fd(0, NULL); // Read from stdin - uns amount; + size_t amount; char *ptr = mp_start(pool, 1024); while(amount = bread(fb, ptr, 1024)) { // Read a block ptr += amount; // Move after it diff --git a/ucw/mempool-fmt.c b/ucw/mempool-fmt.c index 90273af2..91b39cb6 100644 --- a/ucw/mempool-fmt.c +++ b/ucw/mempool-fmt.c @@ -16,7 +16,7 @@ #include static char * -mp_vprintf_at(struct mempool *mp, uns ofs, const char *fmt, va_list args) +mp_vprintf_at(struct mempool *mp, size_t ofs, const char *fmt, va_list args) { char *ret = mp_grow(mp, ofs + 1) + ofs; va_list args2; @@ -67,7 +67,7 @@ mp_printf(struct mempool *p, const char *fmt, ...) char * mp_append_vprintf(struct mempool *mp, char *ptr, const char *fmt, va_list args) { - uns ofs = mp_open(mp, ptr); + size_t ofs = mp_open(mp, ptr); ASSERT(ofs && !ptr[ofs - 1]); return mp_vprintf_at(mp, ofs - 1, fmt, args); } diff --git a/ucw/mempool-str.c b/ucw/mempool-str.c index 9391cbb6..657d756b 100644 --- a/ucw/mempool-str.c +++ b/ucw/mempool-str.c @@ -18,14 +18,14 @@ mp_strdup(struct mempool *p, const char *s) { if (!s) return NULL; - uns l = strlen(s) + 1; + size_t l = strlen(s) + 1; char *t = mp_alloc_fast_noalign(p, l); memcpy(t, s, l); return t; } void * -mp_memdup(struct mempool *p, const void *s, uns len) +mp_memdup(struct mempool *p, const void *s, size_t len) { void *t = mp_alloc_fast(p, len); memcpy(t, s, len); @@ -42,8 +42,8 @@ mp_multicat(struct mempool *p, ...) va_copy(a, args); while (x = va_arg(a, char *)) cnt++; - uns *sizes = alloca(cnt * sizeof(uns)); - uns len = 1; + size_t *sizes = alloca(cnt * sizeof(*sizes)); + size_t len = 1; cnt = 0; va_end(a); va_copy(a, args); @@ -66,8 +66,8 @@ mp_multicat(struct mempool *p, ...) char * mp_strjoin(struct mempool *p, char **a, uns n, uns sep) { - uns sizes[n]; - uns len = 1; + size_t sizes[n]; + size_t len = 1; for (uns i=0; i #define MP_CHUNK_TAIL ALIGN_TO(sizeof(struct mempool_chunk), CPU_STRUCT_ALIGN) -#define MP_SIZE_MAX (~0U - MP_CHUNK_TAIL - CPU_PAGE_SIZE) +#define MP_SIZE_MAX (SIZE_MAX - MP_CHUNK_TAIL - CPU_PAGE_SIZE) struct mempool_chunk { #ifdef CONFIG_DEBUG struct mempool *pool; // Can be useful when analysing coredump for memory leaks #endif struct mempool_chunk *next; - uns size; + size_t size; }; -static uns -mp_align_size(uns size) +static size_t +mp_align_size(size_t size) { #ifdef CONFIG_UCW_POOL_IS_MMAP return ALIGN_TO(size + MP_CHUNK_TAIL, CPU_PAGE_SIZE) - MP_CHUNK_TAIL; @@ -64,7 +64,7 @@ static void mp_allocator_free(struct ucw_allocator *a UNUSED, void *ptr UNUSED) } void -mp_init(struct mempool *pool, uns chunk_size) +mp_init(struct mempool *pool, size_t chunk_size) { chunk_size = mp_align_size(MAX(sizeof(struct mempool), chunk_size)); *pool = (struct mempool) { @@ -80,7 +80,7 @@ mp_init(struct mempool *pool, uns chunk_size) } static void * -mp_new_big_chunk(struct mempool *pool, uns size) +mp_new_big_chunk(struct mempool *pool, size_t size) { struct mempool_chunk *chunk; chunk = xmalloc(size + MP_CHUNK_TAIL) + size; @@ -98,7 +98,7 @@ mp_free_big_chunk(struct mempool *pool, struct mempool_chunk *chunk) } static void * -mp_new_chunk(struct mempool *pool, uns size) +mp_new_chunk(struct mempool *pool, size_t size) { #ifdef CONFIG_UCW_POOL_IS_MMAP struct mempool_chunk *chunk; @@ -124,7 +124,7 @@ mp_free_chunk(struct mempool *pool, struct mempool_chunk *chunk) } struct mempool * -mp_new(uns chunk_size) +mp_new(size_t chunk_size) { chunk_size = mp_align_size(MAX(sizeof(struct mempool), chunk_size)); struct mempool_chunk *chunk = mp_new_chunk(NULL, chunk_size); @@ -249,7 +249,7 @@ mp_shrink(struct mempool *pool, u64 min_total_size) } void * -mp_alloc_internal(struct mempool *pool, uns size) +mp_alloc_internal(struct mempool *pool, size_t size) { struct mempool_chunk *chunk; if (size <= pool->threshold) @@ -275,7 +275,7 @@ mp_alloc_internal(struct mempool *pool, uns size) else if (likely(size <= MP_SIZE_MAX)) { pool->idx = 1; - uns aligned = ALIGN_TO(size, CPU_STRUCT_ALIGN); + size_t aligned = ALIGN_TO(size, CPU_STRUCT_ALIGN); chunk = mp_new_big_chunk(pool, aligned); chunk->next = pool->state.last[1]; #ifdef CONFIG_DEBUG @@ -286,23 +286,23 @@ mp_alloc_internal(struct mempool *pool, uns size) return pool->last_big = (void *)chunk - aligned; } else - die("Cannot allocate %u bytes from a mempool", size); + die("Cannot allocate %zu bytes from a mempool", size); } void * -mp_alloc(struct mempool *pool, uns size) +mp_alloc(struct mempool *pool, size_t size) { return mp_alloc_fast(pool, size); } void * -mp_alloc_noalign(struct mempool *pool, uns size) +mp_alloc_noalign(struct mempool *pool, size_t size) { return mp_alloc_fast_noalign(pool, size); } void * -mp_alloc_zero(struct mempool *pool, uns size) +mp_alloc_zero(struct mempool *pool, size_t size) { void *ptr = mp_alloc_fast(pool, size); bzero(ptr, size); @@ -310,7 +310,7 @@ mp_alloc_zero(struct mempool *pool, uns size) } void * -mp_start_internal(struct mempool *pool, uns size) +mp_start_internal(struct mempool *pool, size_t size) { void *ptr = mp_alloc_internal(pool, size); pool->state.free[pool->idx] += size; @@ -318,27 +318,27 @@ mp_start_internal(struct mempool *pool, uns size) } void * -mp_start(struct mempool *pool, uns size) +mp_start(struct mempool *pool, size_t size) { return mp_start_fast(pool, size); } void * -mp_start_noalign(struct mempool *pool, uns size) +mp_start_noalign(struct mempool *pool, size_t size) { return mp_start_fast_noalign(pool, size); } void * -mp_grow_internal(struct mempool *pool, uns size) +mp_grow_internal(struct mempool *pool, size_t size) { if (unlikely(size > MP_SIZE_MAX)) - die("Cannot allocate %u bytes of memory", size); - uns avail = mp_avail(pool); + die("Cannot allocate %zu bytes of memory", size); + size_t avail = mp_avail(pool); void *ptr = mp_ptr(pool); if (pool->idx) { - uns amortized = likely(avail <= MP_SIZE_MAX / 2) ? avail * 2 : MP_SIZE_MAX; + size_t amortized = likely(avail <= MP_SIZE_MAX / 2) ? avail * 2 : MP_SIZE_MAX; amortized = MAX(amortized, size); amortized = ALIGN_TO(amortized, CPU_STRUCT_ALIGN); struct mempool_chunk *chunk = pool->state.last[1], *next = chunk->next; @@ -360,22 +360,22 @@ mp_grow_internal(struct mempool *pool, uns size) } } -uns +size_t mp_open(struct mempool *pool, void *ptr) { return mp_open_fast(pool, ptr); } void * -mp_realloc(struct mempool *pool, void *ptr, uns size) +mp_realloc(struct mempool *pool, void *ptr, size_t size) { return mp_realloc_fast(pool, ptr, size); } void * -mp_realloc_zero(struct mempool *pool, void *ptr, uns size) +mp_realloc_zero(struct mempool *pool, void *ptr, size_t size) { - uns old_size = mp_open_fast(pool, ptr); + size_t old_size = mp_open_fast(pool, ptr); ptr = mp_grow(pool, size); if (size > old_size) bzero(ptr + old_size, size - old_size); @@ -384,7 +384,7 @@ mp_realloc_zero(struct mempool *pool, void *ptr, uns size) } void * -mp_spread_internal(struct mempool *pool, void *p, uns size) +mp_spread_internal(struct mempool *pool, void *p, size_t size) { void *old = mp_ptr(pool); void *new = mp_grow_internal(pool, p-old+size); diff --git a/ucw/mempool.h b/ucw/mempool.h index b44b955a..8bf9bf91 100644 --- a/ucw/mempool.h +++ b/ucw/mempool.h @@ -58,7 +58,7 @@ * 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; }; @@ -71,7 +71,8 @@ struct mempool { struct ucw_allocator allocator; struct mempool_state state; void *unused, *last_big; - uns chunk_size, threshold, idx; + size_t chunk_size, threshold; + uns idx; u64 total_size; }; @@ -90,13 +91,13 @@ struct mempool_stats { /** Mempool statistics. See @mp_stats(). **/ /** * 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 <>, see <>. **/ -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. @@ -106,7 +107,7 @@ void mp_init(struct mempool *pool, uns chunk_size); * * Memory pools can be treated as <>, see <>. **/ -struct mempool *mp_new(uns chunk_size); +struct mempool *mp_new(size_t chunk_size); /** * Cleanup mempool initialized by mp_init or mp_new. @@ -150,7 +151,7 @@ void mp_shrink(struct mempool *pool, u64 min_total_size); ***/ /* 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. @@ -162,24 +163,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, 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; @@ -192,7 +193,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, size_t size) { if (size <= pool->state.free[0]) { @@ -225,9 +226,9 @@ static inline struct ucw_allocator *mp_get_allocator(struct mempool *mp) ***/ /* 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) { @@ -247,15 +248,15 @@ static inline uns 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, 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; @@ -269,7 +270,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, size_t size) { if (size <= pool->state.free[0]) { @@ -292,7 +293,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 size_t mp_avail(struct mempool *pool) { return pool->state.free[pool->idx]; } @@ -303,7 +304,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, size_t size) { return (size <= mp_avail(pool)) ? mp_ptr(pool) : mp_grow_internal(pool, size); } @@ -320,9 +321,9 @@ 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, 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)); } /** @@ -342,7 +343,7 @@ static inline char *mp_append_char(struct mempool *pool, char *p, uns 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); @@ -383,7 +384,7 @@ static inline char *mp_end_string(struct mempool *pool, void *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 size_t mp_size(struct mempool *pool, void *ptr) { uns idx = mp_idx(pool, ptr); return ((byte *)pool->state.last[idx] - (byte *)ptr) - pool->state.free[idx]; @@ -394,15 +395,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); +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; } @@ -412,17 +413,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, 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); @@ -490,7 +491,7 @@ void mp_pop(struct mempool *pool); ***/ 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: @@ -515,7 +516,7 @@ char *mp_strjoin(struct mempool *p, char **a, uns n, uns 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; /*** -- 2.39.2