Asterisk
/
asterisk
mirror of https://github.com/asterisk/asterisk
1
0
Fork 0
Code Issues Releases Wiki Activity

Optimizations to the stringfields API

Browse Source 
This patch provides a number of optimizations to the stringfields API, focused around saving (not wasting) memory whenever possible. Thanks to Mark Michelson for inspiring this work and coming up with the first two optimizations that are represented here:

Changes:

- Cleanup of some code, fix incorrect doxygen comments

- When a field is emptied or replaced with a new allocation, decrease the amount of 'active' space in the pool it was held in; if that pool reaches zero active space, and is not the current pool, then free it as it is no longer in use

- When allocating a pool, try to allocate a size that will fit in a 'standard' malloc() allocation without wasting space

- When allocating space for a field, store the amount of space in the two bytes immediately preceding the field; this eliminates the need to call strlen() on the field when overwriting it, and more importantly it 'remembers' the amount of space the field has available, even if a shorter string has been stored in it since it was allocated

- Don't automatically double the size of each successive pool allocated; it's wasteful

http://reviewboard.digium.com/r/165/



git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@185581 65c4cc65-6c06-0410-ace0-fbb531ad65f3
certified/1.8.6
Kevin P. Fleming 17 years ago
parent d18a0cecdf
commit a009068110
2 changed files with 166 additions and 76 deletions
Show Stats Download Patch File Download Diff File

87
include/asterisk/stringfields.h
Unescape View File

@ -57,25 +57,23 @@
Fields will default to pointing to an empty string, and will revert to Fields will default to pointing to an empty string, and will revert to
that when ast_string_field_set() is called with a NULL argument. that when ast_string_field_set() is called with a NULL argument.
A string field will \b never contain NULL (this feature is not used A string field will \b never contain NULL.
in this code, but comes from external requirements).
ast_string_field_init(x, 0) will reset fields to the ast_string_field_init(x, 0) will reset fields to the
initial value while keeping the pool allocated. initial value while keeping the pool allocated.
Reading the fields is much like using 'const char * const' fields in the Reading the fields is much like using 'const char * const' fields in the
structure: you cannot write to the field or to the memory it points to structure: you cannot write to the field or to the memory it points to.
(XXX perhaps the latter is too much of a restriction since values
are not shared).
Writing to the fields must be done using the wrapper macros listed below; Writing to the fields must be done using the wrapper macros listed below;
and assignments are always by value (i.e. strings are copied): and assignments are always by value (i.e. strings are copied):
* ast_string_field_set() stores a simple value; * ast_string_field_set() stores a simple value;
* ast_string_field_build() builds the string using a printf-style; * ast_string_field_build() builds the string using a printf-style format;
* ast_string_field_build_va() is the varargs version of the above (for * ast_string_field_build_va() is the varargs version of the above (for
portability reasons it uses two vararg); portability reasons it uses two vararg arguments);
* variants of these function allow passing a pointer to the field * variants of these function allow passing a pointer to the field
as an argument. as an argument.
\code \code
ast_string_field_set(x, foo, "infinite loop"); ast_string_field_set(x, foo, "infinite loop");
ast_string_field_set(x, foo, NULL); // set to an empty string ast_string_field_set(x, foo, NULL); // set to an empty string
@ -110,6 +108,9 @@
Don't declare instances of this type directly; use the AST_STRING_FIELD() Don't declare instances of this type directly; use the AST_STRING_FIELD()
macro instead. macro instead.
In addition to the string itself, the amount of space allocated for the
field is stored in the two bytes immediately preceding it.
*/ */
typedef const char * ast_string_field; typedef const char * ast_string_field;
@ -117,7 +118,7 @@ typedef const char * ast_string_field;
\internal \internal
\brief A constant empty string used for fields that have no other value \brief A constant empty string used for fields that have no other value
*/ */
extern const char __ast_string_field_empty[]; extern const char *__ast_string_field_empty;
/*! /*!
\internal \internal
@ -125,18 +126,17 @@ extern const char __ast_string_field_empty[];
*/ */
struct ast_string_field_pool { struct ast_string_field_pool {
struct ast_string_field_pool *prev; /*!< pointer to the previous pool, if any */ struct ast_string_field_pool *prev; /*!< pointer to the previous pool, if any */
size_t size; /*!< the total size of the pool */
size_t used; /*!< the space used in the pool */
size_t active; /*!< the amount of space actively in use by fields */
char base[0]; /*!< storage space for the fields */ char base[0]; /*!< storage space for the fields */
}; };
/*! /*!
\internal \internal
\brief Structure used to manage the storage for a set of string fields. \brief Structure used to manage the storage for a set of string fields.
Because of the way pools are managed, we can only allocate from the topmost
pool, so the numbers here reflect just that.
*/ */
struct ast_string_field_mgr { struct ast_string_field_mgr {
size_t size; /*!< the total size of the current pool */
size_t used; /*!< the space used in the current pool */
ast_string_field last_alloc; /*!< the last field allocated */ ast_string_field last_alloc; /*!< the last field allocated */
}; };
@ -154,7 +154,8 @@ struct ast_string_field_mgr {
the pool has enough space available. If so, the additional space will be the pool has enough space available. If so, the additional space will be
allocated to this field and the field's address will not be changed. allocated to this field and the field's address will not be changed.
*/ */
int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr, size_t needed, int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr,
struct ast_string_field_pool **pool_head, size_t needed,
const ast_string_field *ptr); const ast_string_field *ptr);
/*! /*!
@ -176,7 +177,7 @@ ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr
\internal \internal
\brief Set a field to a complex (built) value \brief Set a field to a complex (built) value
\param mgr Pointer to the pool manager structure \param mgr Pointer to the pool manager structure
\param fields Pointer to the first entry of the field array \param pool_head Pointer to the current pool
\param ptr Pointer to a field within the structure \param ptr Pointer to a field within the structure
\param format printf-style format string \param format printf-style format string
\return nothing \return nothing
@ -189,7 +190,7 @@ void __ast_string_field_ptr_build(struct ast_string_field_mgr *mgr,
\internal \internal
\brief Set a field to a complex (built) value \brief Set a field to a complex (built) value
\param mgr Pointer to the pool manager structure \param mgr Pointer to the pool manager structure
\param fields Pointer to the first entry of the field array \param pool_head Pointer to the current pool
\param ptr Pointer to a field within the structure \param ptr Pointer to a field within the structure
\param format printf-style format string \param format printf-style format string
\param args va_list of the args for the format_string \param args va_list of the args for the format_string
@ -242,7 +243,32 @@ void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
/*! \internal \brief internal version of ast_string_field_init */ /*! \internal \brief internal version of ast_string_field_init */
int __ast_string_field_init(struct ast_string_field_mgr *mgr, int __ast_string_field_init(struct ast_string_field_mgr *mgr,
struct ast_string_field_pool **pool_head, int needed); struct ast_string_field_pool **pool_head, int needed);
/*!
\internal
\brief Release a field's allocation from a pool
\param pool_head Pointer to the current pool
\param ptr Field to be released
\return nothing
This function will search the pool list to find the pool that contains
the allocation for the specified field, then remove the field's allocation
from that pool's 'active' count. If the pool's active count reaches zero,
and it is not the current pool, then it will be freed.
*/
void __ast_string_field_release_active(struct ast_string_field_pool *pool_head,
const ast_string_field ptr);
/* the type of storage used to track how many bytes were allocated for a field */
typedef uint16_t ast_string_field_allocation;
/*!
\brief Macro to provide access to the allocation field that lives immediately in front of a string field
\param x Pointer to the string field
*/
#define AST_STRING_FIELD_ALLOCATION(x) *((ast_string_field_allocation *) (x - sizeof(ast_string_field_allocation)))
/*! /*!
\brief Set a field to a simple string value \brief Set a field to a simple string value
@ -251,20 +277,21 @@ int __ast_string_field_init(struct ast_string_field_mgr *mgr,
\param data String value to be copied into the field \param data String value to be copied into the field
\return nothing \return nothing
*/ */
#define ast_string_field_ptr_set(x, ptr, data) do { \ #define ast_string_field_ptr_set(x, ptr, data) do { \
const char *__d__ = (data); \ const char *__d__ = (data); \
size_t __dlen__ = (__d__) ? strlen(__d__) + 1 : 1; \ size_t __dlen__ = (__d__) ? strlen(__d__) + 1 : 1; \
const char **__p__ = (const char **) (ptr); \ ast_string_field *__p__ = (ast_string_field *) (ptr); \
char *__q__; \ if (__dlen__ == 1) { \
if (__dlen__ == 1) \ __ast_string_field_release_active((x)->__field_mgr_pool, *__p__); \
*__p__ = __ast_string_field_empty; \ *__p__ = __ast_string_field_empty; \
else if (!__ast_string_field_ptr_grow(&(x)->__field_mgr, __dlen__, ptr)) { \ } else if ((__dlen__ <= AST_STRING_FIELD_ALLOCATION(*__p__)) || \
__q__ = (char *) *__p__; \ (!__ast_string_field_ptr_grow(&(x)->__field_mgr, &(x)->__field_mgr_pool, __dlen__, __p__)) || \
memcpy(__q__, __d__, __dlen__); \ (*__p__ = __ast_string_field_alloc_space(&(x)->__field_mgr, &(x)->__field_mgr_pool, __dlen__))) { \
} else if ((*__p__ = __ast_string_field_alloc_space(&(x)->__field_mgr, &(x)->__field_mgr_pool, __dlen__))) { \ if (*__p__ != (*ptr)) { \
__q__ = (char *) *__p__; \ __ast_string_field_release_active((x)->__field_mgr_pool, (*ptr)); \
memcpy(__q__, __d__, __dlen__); \ } \
} \ memcpy((void *) *__p__, __d__, __dlen__); \
} \
} while (0) } while (0)
/*! /*!

151
main/utils.c
Unescape View File

@ -1469,7 +1469,32 @@ void ast_join(char *s, size_t len, char * const w[])
* stringfields support routines. * stringfields support routines.
*/ */
const char __ast_string_field_empty[] = ""; /*!< the empty string */ /* this is a little complex... string fields are stored with their
allocated size in the bytes preceding the string; even the
constant 'empty' string has to be this way, so the code that
checks to see if there is enough room for a new string doesn't
have to have any special case checks
*/
static const struct {
ast_string_field_allocation allocation;
char string[1];
} __ast_string_field_empty_buffer;
ast_string_field __ast_string_field_empty = __ast_string_field_empty_buffer.string;
#define ALLOCATOR_OVERHEAD 48
static size_t optimal_alloc_size(size_t size)
{
unsigned int count;
size += ALLOCATOR_OVERHEAD;
for (count = 1; size; size >>= 1, count++);
return (1 << count) - ALLOCATOR_OVERHEAD;
}
/*! \brief add a new block to the pool. /*! \brief add a new block to the pool.
* We can only allocate from the topmost pool, so the * We can only allocate from the topmost pool, so the
@ -1480,14 +1505,15 @@ static int add_string_pool(struct ast_string_field_mgr *mgr,
size_t size) size_t size)
{ {
struct ast_string_field_pool *pool; struct ast_string_field_pool *pool;
size_t alloc_size = optimal_alloc_size(sizeof(*pool) + size);
if (!(pool = ast_calloc(1, sizeof(*pool) + size))) if (!(pool = ast_calloc(1, alloc_size))) {
return -1; return -1;
}
pool->prev = *pool_head; pool->prev = *pool_head;
pool->size = alloc_size - sizeof(*pool);
*pool_head = pool; *pool_head = pool;
mgr->size = size;
mgr->used = 0;
mgr->last_alloc = NULL; mgr->last_alloc = NULL;
return 0; return 0;
@ -1511,13 +1537,16 @@ int __ast_string_field_init(struct ast_string_field_mgr *mgr,
struct ast_string_field_pool *cur = *pool_head; struct ast_string_field_pool *cur = *pool_head;
/* clear fields - this is always necessary */ /* clear fields - this is always necessary */
while ((struct ast_string_field_mgr *) p != mgr) while ((struct ast_string_field_mgr *) p != mgr) {
*p++ = __ast_string_field_empty; *p++ = __ast_string_field_empty;
}
mgr->last_alloc = NULL; mgr->last_alloc = NULL;
if (size > 0) { /* allocate the initial pool */ if (size > 0) { /* allocate the initial pool */
*pool_head = NULL; *pool_head = NULL;
return add_string_pool(mgr, pool_head, size); return add_string_pool(mgr, pool_head, size);
} }
if (size < 0) { /* reset all pools */ if (size < 0) { /* reset all pools */
*pool_head = NULL; *pool_head = NULL;
} else { /* preserve the first pool */ } else { /* preserve the first pool */
@ -1527,7 +1556,7 @@ int __ast_string_field_init(struct ast_string_field_mgr *mgr,
} }
cur = cur->prev; cur = cur->prev;
(*pool_head)->prev = NULL; (*pool_head)->prev = NULL;
mgr->used = 0; (*pool_head)->used = (*pool_head)->active = 0;
} }
while (cur) { while (cur) {
@ -1544,33 +1573,36 @@ ast_string_field __ast_string_field_alloc_space(struct ast_string_field_mgr *mgr
struct ast_string_field_pool **pool_head, size_t needed) struct ast_string_field_pool **pool_head, size_t needed)
{ {
char *result = NULL; char *result = NULL;
size_t space = mgr->size - mgr->used; size_t space = (*pool_head)->size - (*pool_head)->used;
size_t to_alloc = needed + sizeof(ast_string_field_allocation);
if (__builtin_expect(needed > space, 0)) { if (__builtin_expect(to_alloc > space, 0)) {
size_t new_size = mgr->size * 2; size_t new_size = (*pool_head)->size;
while (new_size < needed) while (new_size < to_alloc) {
new_size *= 2; new_size *= 2;
}
if (add_string_pool(mgr, pool_head, new_size)) if (add_string_pool(mgr, pool_head, new_size))
return NULL; return NULL;
} }
result = (*pool_head)->base + mgr->used; result = (*pool_head)->base + (*pool_head)->used;
mgr->used += needed; (*pool_head)->used += to_alloc;
(*pool_head)->active += needed;
result += sizeof(ast_string_field_allocation);
AST_STRING_FIELD_ALLOCATION(result) = needed;
mgr->last_alloc = result; mgr->last_alloc = result;
return result; return result;
} }
int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr, size_t needed, int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr,
struct ast_string_field_pool **pool_head, size_t needed,
const ast_string_field *ptr) const ast_string_field *ptr)
{ {
int grow = needed - (strlen(*ptr) + 1); ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
size_t space = mgr->size - mgr->used; size_t space = (*pool_head)->size - (*pool_head)->used;
if (grow <= 0) {
return 0;
}
if (*ptr != mgr->last_alloc) { if (*ptr != mgr->last_alloc) {
return 1; return 1;
@ -1580,30 +1612,57 @@ int __ast_string_field_ptr_grow(struct ast_string_field_mgr *mgr, size_t needed,
return 1; return 1;
} }
mgr->used += grow; (*pool_head)->used += grow;
(*pool_head)->active += grow;
AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
return 0; return 0;
} }
void __ast_string_field_release_active(struct ast_string_field_pool *pool_head,
const ast_string_field ptr)
{
struct ast_string_field_pool *pool, *prev;
if (ptr == __ast_string_field_empty) {
return;
}
for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
if ((pool->active == 0) && prev) {
prev->prev = pool->prev;
ast_free(pool);
}
break;
}
}
}
void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr, void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
struct ast_string_field_pool **pool_head, struct ast_string_field_pool **pool_head,
ast_string_field *ptr, const char *format, va_list ap1, va_list ap2) ast_string_field *ptr, const char *format, va_list ap1, va_list ap2)
{ {
size_t needed; size_t needed;
size_t available; size_t available;
size_t space = mgr->size - mgr->used; size_t space = (*pool_head)->size - (*pool_head)->used;
ssize_t grow;
char *target; char *target;
/* if the field already has space allocated, try to reuse it; /* if the field already has space allocated, try to reuse it;
otherwise, use the empty space at the end of the current otherwise, try to use the empty space at the end of the current
pool pool
*/ */
if ((*ptr)[0] != '\0') { if (*ptr != __ast_string_field_empty) {
target = (char *) *ptr; target = (char *) *ptr;
available = strlen(target) + 1; available = AST_STRING_FIELD_ALLOCATION(*ptr);
if (*ptr == mgr->last_alloc) {
available += space;
}
} else { } else {
target = (*pool_head)->base + mgr->used; target = (*pool_head)->base + (*pool_head)->used + sizeof(ast_string_field_allocation);
available = space; available = space - sizeof(ast_string_field_allocation);
} }
needed = vsnprintf(target, available, format, ap1) + 1; needed = vsnprintf(target, available, format, ap1) + 1;
@ -1611,28 +1670,32 @@ void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,
va_end(ap1); va_end(ap1);
if (needed > available) { if (needed > available) {
/* if the space needed can be satisfied by using the current /* the allocation could not be satisfied using the field's current allocation
pool (which could only occur if we tried to use the field's (if it has one), or the space available in the pool (if it does not). allocate
allocated space and failed), then use that space; otherwise space for it, adding a new string pool if necessary.
allocate a new pool
*/ */
if (needed > space) { if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) {
size_t new_size = mgr->size * 2; return;
while (new_size < needed)
new_size *= 2;
if (add_string_pool(mgr, pool_head, new_size))
return;
} }
target = (*pool_head)->base + mgr->used;
vsprintf(target, format, ap2); vsprintf(target, format, ap2);
} __ast_string_field_release_active(*pool_head, *ptr);
*ptr = target;
if (*ptr != target) { } else if (*ptr != target) {
/* the allocation was satisfied using available space in the pool, but not
using the space already allocated to the field
*/
__ast_string_field_release_active(*pool_head, *ptr);
mgr->last_alloc = *ptr = target; mgr->last_alloc = *ptr = target;
mgr->used += needed; AST_STRING_FIELD_ALLOCATION(target) = needed;
(*pool_head)->used += needed + sizeof(ast_string_field_allocation);
(*pool_head)->active += needed;
} else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
/* the allocation was satisfied by using available space in the pool *and*
the field was the last allocated field from the pool, so it grew
*/
(*pool_head)->used += grow;
(*pool_head)->active += grow;
AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
} }
} }

Write Preview
Loading…
Cancel
Save